@mquan/mochi 0.1.0

package/dist/server/diagram/prompt-version.js

@@ -0,0 +1,47 @@
+// PROMPT_VERSION participates in the diagram cache key (server/diagram/cache.ts,
+// wired up in a later task). The cache treats different prompt_versions as
+// different keys — previously-cached specs become unreachable rather than
+// invalidated, so a bump is cheap to roll out but cannot be selectively undone.
+//
+// Bump policy when editing server/diagram/prompts/diagram-spec.md:
+//   patch (1.0.x) — typo or clarity edits that should not change the LLM's
+//                   output distribution. Whitespace-only edits do NOT bump.
+//   minor (1.x.0) — instruction tweaks (sharper lens criteria, new examples,
+//                   reworded narration rule). Output may shift; cached specs
+//                   remain compatible with the DiagramSpec schema.
+//   major (x.0.0) — prompt change incompatible with the current schema
+//                   (new required output fields, removed sections). Coordinate
+//                   with the schema bump in shared/diagram-spec.ts.
+// 1.1.0: m2.7 LLM-backend swap. Same prompt template, but the runtime now
+// passes a JSON Schema to the claude CLI via --json-schema, which enforces
+// the output shape. Cache invalidated to retire any specs generated against
+// the prior Anthropic-SDK tool-use path.
+//
+// 1.2.0: closed-set NodeKind/EdgeKind enums per lens (shared/design/kinds.ts)
+// + prompt template restructured into a static block (lens definitions,
+// kind enum tables, narration rules, schema) followed by a dynamic inputs
+// block (scope, intent, files). Output: smaller, more cacheable, more
+// evaluable. JSON Schema now constrains node.kind / edge.kind to the global
+// kind union; lens-correctness (kind must match the chosen lens) is enforced
+// at parse time by zod superRefine. Cache invalidated wholesale — any 1.1.x
+// spec might carry a now-illegal kind value.
+//
+// 1.3.0: added Step 3 sub-sections on node-label style ("concepts, not code"),
+// abstraction level per lens, and edge density (no orphan nodes). User
+// dogfood feedback showed Claude was labelling nodes with literal code
+// excerpts ("for-await line of readline(stdout)", "envelope.type === ...")
+// and emitting sparse / orphan-heavy graphs. The new sections explicitly
+// forbid code-fragment labels and require connected graphs. Schema
+// unchanged; cache invalidated so existing entries are regenerated under
+// the stricter guidance.
+//
+// 1.4.0: dropped the warnings channel entirely. The "Self-report uncertainty"
+// step (was Step 6) was producing code-review-style commentary that
+// confused readers ("TOCTOU window between resolveContainedPath and
+// readFile; the diagram is fine, the race is a code property"). The
+// stated purpose (diagram-fidelity caveats) kept getting lost in
+// code-observation noise. Schema drops `warnings`; UI drops the Warnings
+// component; prompt drops Step 6 and renumbers downstream steps. Cache
+// invalidated.
+export const PROMPT_VERSION = "1.4.0";
+//# sourceMappingURL=prompt-version.js.map

package/dist/server/diagram/prompt-version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-version.js","sourceRoot":"","sources":["../../../server/diagram/prompt-version.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,2EAA2E;AAC3E,0EAA0E;AAC1E,gFAAgF;AAChF,EAAE;AACF,mEAAmE;AACnE,2EAA2E;AAC3E,4EAA4E;AAC5E,6EAA6E;AAC7E,6EAA6E;AAC7E,mEAAmE;AACnE,uEAAuE;AACvE,+EAA+E;AAC/E,oEAAoE;AAEpE,0EAA0E;AAC1E,2EAA2E;AAC3E,4EAA4E;AAC5E,yCAAyC;AACzC,EAAE;AACF,8EAA8E;AAC9E,wEAAwE;AACxE,0EAA0E;AAC1E,sEAAsE;AACtE,4EAA4E;AAC5E,6EAA6E;AAC7E,4EAA4E;AAC5E,6CAA6C;AAC7C,EAAE;AACF,+EAA+E;AAC/E,uEAAuE;AACvE,uEAAuE;AACvE,2EAA2E;AAC3E,yEAAyE;AACzE,mEAAmE;AACnE,yEAAyE;AACzE,yBAAyB;AACzB,EAAE;AACF,8EAA8E;AAC9E,oEAAoE;AACpE,oEAAoE;AACpE,oEAAoE;AACpE,iEAAiE;AACjE,yEAAyE;AACzE,uEAAuE;AACvE,eAAe;AACf,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC"}

package/dist/server/diagram/prompts/diagram-spec.md

@@ -0,0 +1,315 @@
+<!-- GENERATED FILE — DO NOT EDIT. Source: server/diagram/prompts/diagram-spec.md.tmpl + shared/design/. Regenerate via `npm run build` (or `tsx scripts/gen-prompt.ts`). -->
+
+# DiagramSpec Generation
+
+You are an expert software analyst generating a behavioral diagram of unfamiliar code. Your reader is a developer trying to understand HOW the code works — its causal structure, the *why* behind decisions — not just what files exist.
+
+Your task: produce a single JSON value conforming to the `DiagramSpec` schema (defined at the end of this document). Output the JSON only, with no surrounding prose, no markdown fences, no commentary.
+
+---
+
+## Step 1 — Pick exactly one lens
+
+Choose the single lens (`flow | architecture | state | protocol`) that best illuminates this scope and intent. Use this guidance:
+
+- **`flow`** — Branching and looping logic within a single function or file. Use when the scope is one or two functions and the interesting question is "what path does execution take?"
+  - **Signals:** nested conditionals, loops, early returns, error branches.
+  - **Tiebreaker:** If the scope is a single function with branching, prefer flow over state.
+
+- **`architecture`** — Relationships between multiple modules, services, or layers. Use when the scope spans multiple files and the interesting question is "what depends on what, and how does data move?"
+  - **Signals:** imports across modules, service boundaries, layered code (controller → service → repository).
+  - **Tiebreaker:** If the scope is multiple files with one clear caller / callee chain, prefer architecture over flow.
+
+- **`state`** — Explicit state machines: a small set of named states with transitions triggered by events. Use when the code contains a state variable (an enum, a `status` field, a phase) that controls behavior.
+  - **Signals:** switch statements over a status, setState calls that name a phase, finite-state-machine libraries, async lifecycles like idle → loading → success / error.
+  - **Tiebreaker:** If two lenses fit equally well, pick the one the reader is more likely to need now and put the other in alternative_lenses.
+
+- **`protocol`** — Message exchanges between actors over time. Use when the scope describes a sequence of interactions: client and server, producer and consumer, two threads or processes coordinating.
+  - **Signals:** request/response pairs, pub/sub, async messaging, multi-step handshakes (auth flows, OAuth, websocket setup).
+  - **Tiebreaker:** Pick protocol when the temporal ordering of messages is the load-bearing thing — otherwise use architecture.
+
+**Tiebreakers:**
+
+- If the user's `intent` mentions framing words like "state", "flow", "architecture", "messages", "protocol", or "sequence", prefer the matching lens unless the code clearly disagrees.
+- If two lenses fit equally well, pick the one the reader is more likely to need now and put the other in `alternative_lenses`.
+
+**Intent disagrees with code shape.** If the user's intent suggests one lens but the code shape clearly calls for another, pick the code-shape lens and put the intent-suggested lens in `alternative_lenses` with a one-line reason. The reader can switch.
+
+**No lens fits cleanly.** Pick the closest lens and generate the spec normally. Refusing to emit a spec is worse than picking imperfectly.
+
+Single-lens rule: do not blend. Pick one. Other useful views belong in `alternative_lenses`.
+
+---
+
+## Step 2 — Use the closed-set kind vocabulary
+
+`node.kind` and `edge.kind` are constrained per lens. The tables below list every allowed value with a short definition. **You MUST pick one of the listed kinds for the lens you chose in Step 1.** Do not invent values outside the lens's enum. If a concept doesn't fit, pick the closest match and use `metadata` to capture nuance.
+
+### Allowed node kinds per lens
+
+
+### flow
+
+| kind | definition |
+|---|---|
+| `flow.entry` | the function or block where execution starts; usually one per flow diagram |
+| `flow.call` | a function or method invocation that synchronously transfers control |
+| `flow.branch` | a conditional fork (if / switch / ternary) that splits the path |
+| `flow.loop` | a loop construct (for / while / do) — show iteration as a back-edge |
+| `flow.await` | a suspension point on a Promise / async operation |
+| `flow.throw` | a thrown exception that unwinds the stack |
+| `flow.catch` | a catch handler that captures a thrown exception |
+| `flow.return` | an explicit return that exits the current frame |
+
+### architecture
+
+| kind | definition |
+|---|---|
+| `architecture.client` | the originating actor (browser, mobile app, external caller) |
+| `architecture.gateway` | a routing/edge layer (API gateway, reverse proxy, load balancer) |
+| `architecture.service` | a long-running runtime component with its own deployment |
+| `architecture.module` | an in-process code module — a library or subsystem |
+| `architecture.datastore` | a persistent store (database, file system, blob storage) |
+| `architecture.queue` | an async messaging primitive (queue, topic, stream) |
+| `architecture.external` | a third-party system outside the scope of this codebase |
+
+### state
+
+| kind | definition |
+|---|---|
+| `state.initial` | the entry state of the machine (usually exactly one) |
+| `state.intermediate` | any non-initial, non-terminal state |
+| `state.terminal` | a state from which no further transitions originate (one or more) |
+| `state.composite` | a state that contains substates (hierarchical state machines) |
+
+### protocol
+
+| kind | definition |
+|---|---|
+| `protocol.actor` | a participant whose timeline runs as a vertical lane |
+| `protocol.group` | a collection of actors treated as a unit for diagram clarity |
+
+
+### Allowed edge kinds per lens
+
+
+### flow
+
+| kind | definition |
+|---|---|
+| `flow.next` | sequential continuation — control moves to the next node unconditionally |
+| `flow.branch_true` | the truthy branch out of a flow.branch node |
+| `flow.branch_false` | the falsy branch out of a flow.branch node |
+| `flow.loop_back` | the back-edge that returns control to the loop header |
+| `flow.fallthrough` | a case-fallthrough or implicit continuation (e.g., switch without break) |
+
+### architecture
+
+| kind | definition |
+|---|---|
+| `architecture.call_sync` | a synchronous request/response call (HTTP, RPC, function call) |
+| `architecture.call_async` | a fire-and-forget call where the caller does not block on the response |
+| `architecture.event` | a published event the consumer may or may not handle |
+| `architecture.data_flow` | data movement (read/write) between a component and a datastore |
+| `architecture.depends_on` | a static dependency edge — A imports/uses B |
+
+### state
+
+| kind | definition |
+|---|---|
+| `state.transition` | a transition from one state to a different state |
+| `state.self_transition` | a transition whose source and target are the same state |
+
+### protocol
+
+| kind | definition |
+|---|---|
+| `protocol.request` | a request message sent from one actor to another |
+| `protocol.response` | the reply to a request |
+| `protocol.async_message` | a message sent without expecting a synchronous reply |
+| `protocol.return` | a return from a previously-invoked synchronous call |
+| `protocol.create` | an actor creates another actor (e.g., spawn, instantiate) |
+| `protocol.destroy` | an actor terminates another actor (e.g., close, dispose) |
+
+
+---
+
+## Step 3 — Build the diagram
+
+Populate `nodes`, `edges`, and `steps` per the schema. Keep ids short, lowercase, and stable across the document (e.g., `s_idle`, `e_idle_to_loading`, `step_1`).
+
+### Node labels are CONCEPTS, not code
+
+`node.label` must be a short noun-phrase or imperative describing what the node REPRESENTS — what a reader would write on a whiteboard sketch. It is NOT a code excerpt.
+
+**BAD** (literal code fragments — readers can read the source themselves):
+
+> "for-await line of readline(stdout)"
+> "envelope.type === 'stream_event'"
+> "await handle.exitCode"
+> "RETRY_BACKOFF_MS[attempt - 1]"
+> "if (cache.get(key) !== null)"
+
+**GOOD** (concept names — labels a reader can hold in their head):
+
+> "Stream CLI output line-by-line"
+> "Tool-use delta arrived"
+> "Wait for subprocess exit"
+> "Sleep before retry"
+> "Cache hit"
+
+Rules:
+
+- Length: 1–5 words for `state` / `architecture` nodes; 1–10 words for `flow` / `protocol` nodes.
+- No code-fragment characters: avoid `()`, `===`, `{}`, `$`, `→`, backticks, square-bracketed array indices, snake_case identifiers pulled straight from the source.
+- No file paths or line ranges in labels — those go in `code_anchor`.
+- Variable names appear in a label only when the variable IS the concept (e.g., "Cache" is fine for a node representing the cache; "cacheRef.current" is not).
+- Imperative or noun-phrase forms; not transcripts of source ("Validate JWT" not "jwt.verify(token, key)").
+
+### Abstraction level — match the lens
+
+The diagram's job is to compress code into a high-level mental model. If a reader has to open the source to understand your labels, the diagram failed.
+
+- **architecture**: nodes are deployable / runtime units. Services, modules, gateways, datastores, queues, external systems, clients. **NEVER** individual functions, control-flow constructs, or code expressions. A function call inside one service is NOT an architecture node — it's an implementation detail. Aim for 4–12 nodes covering the whole system shape.
+- **state**: nodes are named states the program/object can be in. `Loading`, `Authenticated`, `Disconnected`, `Idle`. Edges are transitions, labeled with the triggering event.
+- **flow**: nodes are steps in a procedure. Pick a granularity that yields 6–15 useful nodes — usually function-body-block level, not individual expressions or single statements. "Validate input" is a flow node; "if x > 0" generally isn't.
+- **protocol**: nodes are participating actors (one per participant). Messages between them are edges, not nodes.
+
+When in doubt, ask: would a senior engineer recognize this label as a meaningful concept in this codebase? If the label only makes sense after reading the exact line of code beneath it, raise the abstraction.
+
+### Edges — every diagram has them, every node connects
+
+A diagram with nodes but no edges is a list pretending to be a diagram. **Every spec MUST have edges.**
+
+- Every non-terminal node should have at least one edge in or out. Orphan nodes (zero edges) are almost always a sign of over-fragmentation or the wrong lens.
+- For `flow` and `state`: the edges form a connected graph — you should be able to walk from a start node to a terminal via edges.
+- For `architecture`: every depicted component connects to at least one other unless it's genuinely a leaf (e.g., an isolated external system drawn only to show its existence).
+- For `protocol`: every actor must participate in at least one message edge.
+
+If a meaningful relationship can't be expressed via the lens's edge-kind enum, that's a signal the lens is wrong — reconsider Step 1.
+
+---
+
+## Step 4 — Narrate causally (the WHY rule)
+
+This is the most important instruction in this document.
+
+Each `step.narration` must explain WHY this thing happens at this point in the sequence — what intent is served, what invariant is preserved, what failure mode is avoided. It must not merely label what happens.
+
+**BAD** (labels what happens — readers can see this from the diagram):
+
+> "Request enters the gateway."
+
+**GOOD** (explains why this ordering exists):
+
+> "The gateway authenticates at the edge so downstream services can trust the user id in the request context — and so a forged identity never reaches the database layer."
+
+**BAD:**
+
+> "State transitions from `loading` to `success`."
+
+**GOOD:**
+
+> "We move to `success` only after the response body has parsed cleanly, not just on a 200 status. A 200 with malformed JSON would otherwise advance the UI to a state that crashes on render."
+
+**BAD:**
+
+> "Client sends a POST to /auth/token."
+
+**GOOD:**
+
+> "The client exchanges the auth code on a fresh TLS connection — reusing the login form's connection would leak the code into the form-submission referrer, which is logged by upstream proxies."
+
+The narration is the value. Skim-test each step: if removing the diagram still leaves the narration informative, you've done it right. If the narration is just the node label rephrased, rewrite it.
+
+---
+
+## Step 5 — Anchor nodes and steps to code
+
+Use `code_anchor` (on nodes) and `code_focus` (on steps) only when you can point to a specific line range in the supplied files. Format: `{ "file": "<path as given in the inputs>", "range": [start, end] }` — 1-indexed, inclusive.
+
+When in doubt about exact lines: **omit the anchor**. A missing anchor is correct. A wrong anchor sends the reader to confusing code and erodes trust.
+
+Anchor ranges should be tight — the smallest range that contains the referenced behavior. A 100-line range is rarely useful; prefer 1 to 20 lines.
+
+---
+
+## Step 6 — Suggest alternative lenses
+
+Populate `alternative_lenses` with 0 to 2 entries describing other views that might help the same reader. Each `reason` is one short sentence stating what the alternative would reveal that the chosen lens does not.
+
+Example for a state-lens spec of an auth flow:
+
+- `{ "lens": "protocol", "reason": "Shows the client-server message exchange that drives each state transition." }`
+- `{ "lens": "flow", "reason": "Zooms into the branching inside the token-validation routine." }`
+
+If no other lens would help, return `[]`.
+
+---
+
+## Step 7 — Step count
+
+Generate **6 to 15 steps**, ordered to walk the reader through the diagram in causal order. Fewer than 6 is too sparse to be a guided tour. More than 15 overwhelms.
+
+If the scope naturally produces more steps, group them: pick the load-bearing 6 to 15. Detail that doesn't fit belongs in node `metadata` or in the narration of a grouped step, not as a separate channel.
+
+Each step:
+
+- `highlight.nodes` and `highlight.edges` — what should glow when this step is the cursor. Empty arrays are allowed if the step is purely narrative.
+- `code_focus` — optional. Use when one specific file and line range is the focus of this step.
+
+---
+
+## Step 8 — Output format
+
+Return a single JSON value matching the `DiagramSpec` schema below. No prose. No markdown fences. No leading or trailing whitespace beyond the JSON itself.
+
+The top-level fields you must set: `lens`, `scope`, `nodes`, `edges`, `steps`, `alternative_lenses`, `generated_at`, `prompt_version`, `model`.
+
+- `scope.files` mirrors the file paths in the input.
+- `scope.intent` mirrors the input intent, omitted if there was none.
+- `generated_at` — echo `{{generated_at}}` verbatim.
+- `model` — echo `{{model}}` verbatim.
+- `prompt_version` — set to `""` (empty string). The server overwrites this with the canonical version before caching.
+
+---
+
+## DiagramSpec schema (your JSON must conform to this)
+
+```ts
+{{schema}}
+```
+
+---
+
+## Final checklist before returning
+
+Run through this list mentally before emitting JSON:
+
+1. Single lens chosen — not blended.
+2. Every `node.kind` and `edge.kind` is one of the values from the table for the chosen lens.
+3. 6 to 15 steps — not fewer, not more.
+4. Every step's `narration` answers "why this, why now" — not just "what".
+5. Every `code_anchor` and `code_focus` is a tight, specific, verifiable range — or omitted.
+6. Every `edge.from` and `edge.to` matches a node id you defined.
+7. Every `step.highlight.nodes` and `step.highlight.edges` entry matches an id you defined.
+8. All node, edge, and step ids are unique within their arrays.
+9. `alternative_lenses`: 0 to 2 entries, each with a one-line reason.
+10. Output is a single JSON value with no surrounding prose.
+
+<!-- DYNAMIC INPUTS BELOW -->
+
+## Inputs
+
+- **Scope:** {{scope_summary}}
+- **Intent:** {{intent}}
+- **Generated at:** {{generated_at}}
+- **Model:** {{model}}
+
+### Source files
+
+{{files}}
+
+---
+
+Emit the JSON now.

package/dist/server/diagram/scope-resolver.d.ts

@@ -0,0 +1,44 @@
+import { EXT_TO_LANG } from "../api.js";
+import { type FileEntry } from "../analysis/index.js";
+import type { AnalysisContext } from "../../shared/analysis-schema.js";
+export { EXT_TO_LANG };
+export declare const MAX_SCOPE_TOKENS = 150000;
+export type Scope = {
+    kind: "file";
+    path: string;
+} | {
+    kind: "directory";
+    path: string;
+} | {
+    kind: "multi";
+    paths: string[];
+};
+export interface ResolvedScope {
+    files: FileEntry[];
+    analysis: AnalysisContext;
+    estimated_tokens: number;
+}
+export interface ResolveScopeOptions {
+    maxTokens?: number;
+}
+export declare function estimateTokens(content: string): number;
+export declare class ScopeOutsideRootError extends Error {
+    readonly path: string;
+    constructor(p: string);
+}
+export declare class FileResolutionError extends Error {
+    readonly path: string;
+    readonly reason: string;
+    constructor(p: string, reason: string);
+}
+export declare class EmptyScopeError extends Error {
+    constructor();
+}
+export declare class ScopeTooLargeError extends Error {
+    readonly estimated_tokens: number;
+    readonly max: number;
+    readonly suggestion: string;
+    constructor(estimated_tokens: number, max: number, fileCount: number);
+}
+export declare function resolveScope(scope: Scope, rootDir: string, opts?: ResolveScopeOptions): Promise<ResolvedScope>;
+//# sourceMappingURL=scope-resolver.d.ts.map

package/dist/server/diagram/scope-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-resolver.d.ts","sourceRoot":"","sources":["../../../server/diagram/scope-resolver.ts"],"names":[],"mappings":"AA0CA,OAAO,EAAE,WAAW,EAAe,MAAM,WAAW,CAAC;AAKrD,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,EAAE,WAAW,EAAE,CAAC;AAEvB,eAAO,MAAM,gBAAgB,SAAU,CAAC;AAExC,MAAM,MAAM,KAAK,GACb;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAEvC,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,QAAQ,EAAE,eAAe,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAKD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBACV,CAAC,EAAE,MAAM;CAKtB;AAED,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBACZ,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAMtC;AAED,qBAAa,eAAgB,SAAQ,KAAK;;CAKzC;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;gBAChB,gBAAgB,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;CAWrE;AA8GD,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,mBAAmB,GACzB,OAAO,CAAC,aAAa,CAAC,CA4BxB"}

package/dist/server/diagram/scope-resolver.js

@@ -0,0 +1,198 @@
+// Resolve a user-supplied Scope (single file, directory, or array of file
+// paths) into a normalized LLM payload: file contents + batched analysis
+// context + estimated token count. Sits between path selection (m1) and
+// diagram generation (m2 t6).
+//
+// Algorithm (high-level):
+//
+//   resolveScope(scope, rootDir)
+//     │
+//     ├─ realpath(rootDir)
+//     │
+//     ├─ scope.kind ─┬─ 'file'      → relPaths = [scope.path]
+//     │              ├─ 'multi'     → relPaths = scope.paths
+//     │              └─ 'directory' → selectFromPath(absDir), rebase
+//     │                               relpaths against realRoot
+//     │
+//     ├─ Promise.all(relPaths.map(loadFileEntry))
+//     │      • each path: containment check → stat → read → classify
+//     │      • per-path failures throw a typed error (fail-fast)
+//     │
+//     ├─ empty? → EmptyScopeError
+//     │
+//     ├─ Σ estimateTokens(content)
+//     │      • over budget? → ScopeTooLargeError with file count + suggestion
+//     │
+//     ├─ runAnalysis(files, realRoot)
+//     │      • tree-sitter + ts-morph + git-context (best-effort; t3)
+//     │
+//     └─ return { files, analysis, estimated_tokens }
+//
+// Error contract:
+//   - ScopeOutsideRootError   path escapes the project root (lex or via symlink)
+//   - FileResolutionError     stat/read/size failure for a specific path
+//   - EmptyScopeError         no files in the resolved set
+//   - ScopeTooLargeError      sum of estimated tokens > maxTokens budget
+//
+// All errors carry structured fields so the caller can build a useful
+// HTTP response without parsing error messages.
+import { readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { EXT_TO_LANG, languageFor } from "../api.js";
+import { MAX_FILE_BYTES, selectFromPath, } from "../input/path-selector.js";
+import { runAnalysis } from "../analysis/index.js";
+export { EXT_TO_LANG };
+export const MAX_SCOPE_TOKENS = 150_000;
+// Heuristic: ~4 chars per token for code-ish content. Deterministic, offline,
+// and good enough for a budget guardrail (the Anthropic SDK's exact counter
+// would require a network call per scope — see Decisions in the task file).
+export function estimateTokens(content) {
+    return Math.ceil(content.length / 4);
+}
+export class ScopeOutsideRootError extends Error {
+    path;
+    constructor(p) {
+        super(`scope path escapes the project root: ${p}`);
+        this.name = "ScopeOutsideRootError";
+        this.path = p;
+    }
+}
+export class FileResolutionError extends Error {
+    path;
+    reason;
+    constructor(p, reason) {
+        super(`failed to resolve file ${p}: ${reason}`);
+        this.name = "FileResolutionError";
+        this.path = p;
+        this.reason = reason;
+    }
+}
+export class EmptyScopeError extends Error {
+    constructor() {
+        super("scope resolved to zero files");
+        this.name = "EmptyScopeError";
+    }
+}
+export class ScopeTooLargeError extends Error {
+    estimated_tokens;
+    max;
+    suggestion;
+    constructor(estimated_tokens, max, fileCount) {
+        const suggestion = `Scope contains ${fileCount} file${fileCount === 1 ? "" : "s"} ` +
+            `estimating ${estimated_tokens.toLocaleString()} tokens (max ${max.toLocaleString()}). ` +
+            `Narrow to a smaller scope (single file, focused subdirectory, or 2–5 related files).`;
+        super(`scope too large: ${estimated_tokens} tokens > ${max} max`);
+        this.name = "ScopeTooLargeError";
+        this.estimated_tokens = estimated_tokens;
+        this.max = max;
+        this.suggestion = suggestion;
+    }
+}
+// Resolve `relPath` against `realRoot` to a contained absolute path, or
+// classify the failure. Returns:
+//   { kind: 'ok', abs }              — path is inside realRoot (post-symlink)
+//   { kind: 'lex-escape' }           — lexical traversal (e.g. '../x')
+//   { kind: 'not-found' }            — stat failed (ENOENT, EACCES on parent)
+//   { kind: 'symlink-escape' }       — exists but resolves outside realRoot
+//
+// Separating the four cases is what lets us throw the right typed error.
+// `resolveContainedPath` (in api.ts) collapses them all to `null`, which is
+// fine for the API layer's "show 404 vs 400" decision but loses the
+// resolution-vs-containment distinction we need here.
+async function classifyPath(realRoot, relPath) {
+    const requested = path.resolve(realRoot, relPath);
+    const lexContained = requested === realRoot || requested.startsWith(realRoot + path.sep);
+    if (!lexContained)
+        return { kind: "lex-escape" };
+    let abs;
+    try {
+        abs = await realpath(requested);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { kind: "not-found", reason: msg };
+    }
+    const realContained = abs === realRoot || abs.startsWith(realRoot + path.sep);
+    if (!realContained)
+        return { kind: "symlink-escape" };
+    return { kind: "ok", abs };
+}
+async function loadFileEntry(realRoot, relPath) {
+    const c = await classifyPath(realRoot, relPath);
+    if (c.kind === "lex-escape" || c.kind === "symlink-escape") {
+        throw new ScopeOutsideRootError(relPath);
+    }
+    if (c.kind === "not-found") {
+        throw new FileResolutionError(relPath, `not-found: ${c.reason}`);
+    }
+    const abs = c.abs;
+    const st = await stat(abs);
+    if (!st.isFile()) {
+        throw new FileResolutionError(relPath, "not-a-file");
+    }
+    if (st.size > MAX_FILE_BYTES) {
+        throw new FileResolutionError(relPath, `too-large: ${st.size} bytes (max ${MAX_FILE_BYTES})`);
+    }
+    let content;
+    try {
+        content = await readFile(abs, "utf8");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new FileResolutionError(relPath, `unreadable: ${msg}`);
+    }
+    const relFromRoot = path.relative(realRoot, abs) || path.basename(abs);
+    const language = languageFor(path.extname(abs));
+    return {
+        path: relFromRoot,
+        content,
+        language,
+        size: st.size,
+    };
+}
+async function relPathsFromScope(realRoot, scope) {
+    if (scope.kind === "file") {
+        return [scope.path];
+    }
+    if (scope.kind === "multi") {
+        return scope.paths;
+    }
+    // directory
+    const c = await classifyPath(realRoot, scope.path);
+    if (c.kind === "lex-escape" || c.kind === "symlink-escape") {
+        throw new ScopeOutsideRootError(scope.path);
+    }
+    if (c.kind === "not-found") {
+        throw new FileResolutionError(scope.path, `not-found: ${c.reason}`);
+    }
+    const abs = c.abs;
+    const st = await stat(abs);
+    if (!st.isDirectory()) {
+        throw new FileResolutionError(scope.path, "not-a-directory");
+    }
+    const sel = await selectFromPath(abs);
+    // selectFromPath returns paths relative to `abs`. Rebase against realRoot.
+    return sel.files.map((rel) => path.relative(realRoot, path.join(abs, rel)));
+}
+export async function resolveScope(scope, rootDir, opts) {
+    const maxTokens = opts?.maxTokens ?? MAX_SCOPE_TOKENS;
+    const realRoot = await realpath(rootDir);
+    const relPaths = await relPathsFromScope(realRoot, scope);
+    if (relPaths.length === 0) {
+        throw new EmptyScopeError();
+    }
+    const files = await Promise.all(relPaths.map((rel) => loadFileEntry(realRoot, rel)));
+    if (files.length === 0) {
+        throw new EmptyScopeError();
+    }
+    let estimated_tokens = 0;
+    for (const f of files) {
+        estimated_tokens += estimateTokens(f.content);
+    }
+    if (estimated_tokens > maxTokens) {
+        throw new ScopeTooLargeError(estimated_tokens, maxTokens, files.length);
+    }
+    const analysis = await runAnalysis(files, realRoot);
+    return { files, analysis, estimated_tokens };
+}
+//# sourceMappingURL=scope-resolver.js.map

package/dist/server/diagram/scope-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-resolver.js","sourceRoot":"","sources":["../../../server/diagram/scope-resolver.ts"],"names":[],"mappings":"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"}

package/dist/server/diagram/spawn.d.ts

@@ -0,0 +1,18 @@
+export interface SpawnRequest {
+    command: string;
+    args: readonly string[];
+    signal?: AbortSignal;
+    cwd?: string;
+}
+export interface SpawnHandle {
+    stdout: NodeJS.ReadableStream;
+    stderr: NodeJS.ReadableStream;
+    exitCode: Promise<number | null>;
+    kill: (signal?: NodeJS.Signals) => void;
+    pid: number | undefined;
+}
+export interface MinimalSubprocessSpawner {
+    spawn(req: SpawnRequest): SpawnHandle;
+}
+export declare const defaultSpawner: MinimalSubprocessSpawner;
+//# sourceMappingURL=spawn.d.ts.map

package/dist/server/diagram/spawn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../server/diagram/spawn.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAK9B,QAAQ,EAAE,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAGjC,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,OAAO,KAAK,IAAI,CAAC;IAExC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;CACzB;AAED,MAAM,WAAW,wBAAwB;IACvC,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,WAAW,CAAC;CACvC;AAED,eAAO,MAAM,cAAc,EAAE,wBA2F5B,CAAC"}