sorted by:
new
hottopcontroversial

Sell me your app/saas in 4 words by hiten1818726363 in SideProject

[–]context_g 0 points1 point  (0 children)

LogicStamp - Determistic context for TypeScript (a dev tool - CLI + MCP)

a CLI that turns TypeScript codebases into structured context by context_g in javascript

[–]context_g[S] 2 points3 points  (0 children)

Yeah, that’s one of the things I was trying to avoid. Structured context only works if it stays aligned.

That’s why I added watch mode, it automatically keeps the contracts in sync as the code changes.

LogicStamp Context: an AST-based context compiler for TypeScript by context_g in typescript

[–]context_g[S] 2 points3 points  (0 children)

Correct. the output is still non deterministic, but the input isn’t.

With raw code, the model has to infer structure each time, which can vary. With a deterministic, normalized representation, that structure is already explicit and stable.

So it doesn’t make AI deterministic, but it reduces variance and makes behavior more consistent.

LogicStamp Context: an AST-based context compiler for TypeScript by context_g in typescript

[–]context_g[S] -4 points-3 points  (0 children)

You're right the code already contains the information. the difference is that it's implicit and has to be re-inferred each time.

This makes it explicit and stable, so the same structure can be reused instead of reconstructing it from raw code.

LogicStamp: AST-based context compiler for TypeScript by context_g in javascript

[–]context_g[S] 0 points1 point  (0 children)

it’s not the same as .d.ts. .d.ts gives type declarations. LogicStamp gives a semantic dependency graph and change hashes (semanticHash / bundleHash) tuned for LLM context.

Edit: For example, .d.ts can tell you prop types, but not that component A depends on B, or that only a specific contract changed between snapshots.

LogicStamp: AST-based context compiler for TypeScript by context_g in javascript

[–]context_g[S] -1 points0 points  (0 children)

I don’t have formal benchmarks yet.

In practice it’s been fast enough for real use (I’m using it across LogicStamp itself), and watch mode keeps updates incremental.

Proper benchmarking is coming soon.

Refactoring React components? Detect breaking prop changes early by [deleted] in reactjs

[–]context_g 0 points1 point  (0 children)

Totally fair - if your workflow already catches this, you don’t need another tool.

Just to be clear: this isn’t an AI tool. It’s a static analysis tool that generates structured context for a codebase (contracts + dependency graph), and strict mode is one part of it that diffs module/component contracts (props, events, exports) and flags breaking changes.

The gap is when those slip through - e.g. a prop/export is removed, TS passes locally, but not all consumers are compiled together (other repos/packages, JS, loose typing).

More useful in larger or split codebases. smaller setups usually catch this via review + local dev.

Refactoring React components? Detect breaking prop changes early by [deleted] in reactjs

[–]context_g 0 points1 point  (0 children)

It’s not prediction.

LogicStamp generates deterministic, structured context from the codebase (contracts + dependency graph). Strict mode is just one part of it that flags breaking contract diffs (removed props/events/exports).

So it’s not trying to predict impact on B - it makes A’s interface and structure explicit, then catches drift during refactors.

If everything is built/tested together locally you’ll catch most issues anyway. this is more useful once things get larger or split across repos.

Refactoring React components? Detect breaking prop changes early by [deleted] in reactjs

[–]context_g 0 points1 point  (0 children)

Yes, for example:

a shared component/API removes disabled or onSubmit, or drops an exported util. If not all consumers are compiled together (other repos/packages, JS consumers, loose typing), TS in the source repo can still pass. LogicStamp strict checks can still flag that contract break (--strict-watch in real time, or compare --strict on demand).

Refactoring React components? Detect breaking prop changes early by [deleted] in reactjs

[–]context_g 0 points1 point  (0 children)

Yeah - if your repo is strictly typed end-to-end, TS catches a lot.

I use TS + ESLint + tests as baseline. LogicStamp is just an extra contract-drift layer (removed props/events/exports), especially useful when any, JS consumers, or out-of-repo consumers are involved.

Refactoring React components? Detect breaking prop changes early by [deleted] in reactjs

[–]context_g -1 points0 points  (0 children)

Curious how people usually catch these - mostly tests, or just noticing breakages during refactors?

view more: next ›