@ambitresearch/genie 1.3.1

package/dist/manifest/compiler.js

@@ -0,0 +1,306 @@
+/**
+ * M3-03 (DRO-259) — the `.genie/manifest.json` writer (client-side compiler).
+ *
+ * This is genie's substitute for Anthropic's server-side manifest
+ * compilation (research report §6): a small, dependency-light walker that
+ * recompiles `<projectRoot>/.genie/manifest.json` from the `@genie` markers
+ * on disk whenever the M3-02 watcher fires (or on any direct call — this
+ * module has no opinion on WHEN it runs, only on producing a correct
+ * manifest for a given `projectRoot` snapshot).
+ *
+ * ── Schema reconciliation (recorded on DRO-259 before this file was written) ──
+ * This issue's own AC4 (and the RFC §6.8/§7.1 sketch, and the M4-03 viewer's
+ * `fetch` code) describe a root key `cards` with `viewport: {width,height}`
+ * as an object. But `../store/manifest.ts` — already merged, backing the
+ * shipped/tested M1-15 `list_components` tool, read by BOTH `LocalFsKitStore`
+ * and `GitHostKitStore` — has a zod schema that requires the root key
+ * `components`, with `viewport` as the raw marker STRING (e.g. `"400x200"`
+ * or `"desktop"`), plus `{name, group, path, hash, lastModified}`.
+ *
+ * Emitting `cards` would silently break `list_components` (a live, shipped
+ * P0 tool): its zod parse requires `components` and would throw
+ * `ManifestParseError` on a `cards`-shaped file. So this compiler emits
+ * `components` with a STRING `viewport`, matching the already-shipped reader
+ * contract. `../store/manifest.ts`'s schemas are `.passthrough()`, so the
+ * RFC's additional fields are layered on top without conflict: top-level
+ * `version: 1`, `generatedAt`, `name` (the kit/project's directory basename),
+ * `groups: string[]`; per-card `subtitle`/`tags` when a sibling `meta.json`
+ * supplies them. This is additive/forward-compatible per RFC §16.2 ("add a
+ * new output field — allowed in minor/patch").
+ *
+ * Pure-ish orchestration: the only side effects are reading the component
+ * tree + sibling `meta.json`/`_groups.json` files and the final atomic write.
+ * Marker PRESENCE validation and card sort order are delegated to
+ * already-shipped, independently-tested modules (M3-01's `validateMarker`,
+ * `store/manifest.ts`'s `compareComponents`); group/viewport extraction is
+ * a narrow regex read of the same already-validated marker line (see
+ * `extractGroup`/`extractViewportToken` below for why M3-01's own
+ * `extractViewport` isn't reused verbatim here).
+ */
+import { mkdir, mkdtemp, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative } from "node:path";
+import { validateMarker } from "../validate/marker.js";
+import { sriSha256 } from "../store/kit-files.js";
+import { compareComponents, MANIFEST_PATH } from "../store/manifest.js";
+/** Loose runtime guard — a `meta.json` is optional and non-renderable, so a
+ * malformed one degrades to "no extra metadata" rather than failing the
+ * whole compile (this module owns availability of the manifest; a single
+ * bad `meta.json` must not take that down). */
+function parseComponentMeta(raw) {
+    try {
+        const json = JSON.parse(raw);
+        if (typeof json !== "object" || json === null)
+            return {};
+        const obj = json;
+        const subtitle = typeof obj["subtitle"] === "string" ? obj["subtitle"] : undefined;
+        const tags = Array.isArray(obj["tags"]) && obj["tags"].every((t) => typeof t === "string")
+            ? obj["tags"]
+            : undefined;
+        return { subtitle, tags };
+    }
+    catch {
+        return {};
+    }
+}
+/** Loose parse of an optional `_groups.json` sibling: an explicit group order
+ * (Impl Notes: "Group order: alphabetical unless a `_groups.json` sibling
+ * pins it"). Any shape other than a flat string array is treated as absent —
+ * this is a purely cosmetic ordering hint, never a hard requirement. */
+function parseGroupsOrder(raw) {
+    try {
+        const json = JSON.parse(raw);
+        if (Array.isArray(json) && json.every((g) => typeof g === "string")) {
+            return json;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** ENOENT/ENOTDIR both mean "not there" — the same convention `store/local.ts`
+ * and `sync/anchor.ts` use throughout this codebase. */
+function isMissingPathError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code !== undefined &&
+        (error.code === "ENOENT" ||
+            error.code === "ENOTDIR"));
+}
+/**
+ * Recursively walk `${projectRoot}/components` for `*.html` files (AC2).
+ * Returns `[]` when the `components/` directory doesn't exist yet (a brand
+ * new kit/project) rather than throwing — an empty manifest is a valid,
+ * expected state (mirrors `store/manifest.ts`'s `selectComponents` treating
+ * an absent manifest as `[]`, not an error).
+ */
+async function walkPreviewFiles(componentsRoot, projectRoot) {
+    let entries;
+    try {
+        entries = await readdir(componentsRoot, { withFileTypes: true });
+    }
+    catch (error) {
+        if (isMissingPathError(error))
+            return [];
+        throw error;
+    }
+    const out = [];
+    for (const entry of entries) {
+        const absPath = join(componentsRoot, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...(await walkPreviewFiles(absPath, projectRoot)));
+            continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".html"))
+            continue;
+        out.push({ absPath, relPath: relative(projectRoot, absPath).replaceAll("\\", "/") });
+    }
+    return out;
+}
+/** Read a sibling file next to `htmlAbsPath` (same directory, given basename).
+ * Returns `undefined` on any read failure (missing, EISDIR, etc.) — every
+ * sibling here is optional metadata, never load-bearing for the card itself. */
+async function readSibling(htmlAbsPath, siblingName) {
+    return readOptionalFile(join(dirname(htmlAbsPath), siblingName));
+}
+/** Read a file at an exact absolute path, tolerating absence (or any other
+ * read failure) as `undefined` rather than throwing — used for every
+ * optional, best-effort sidecar this compiler reads (`meta.json`,
+ * `_groups.json`), none of which are load-bearing for the manifest itself. */
+async function readOptionalFile(absPath) {
+    try {
+        return await readFile(absPath, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Extract a card's `group` from the validated `@genie` marker line itself
+ * (AC2: "extracts group + viewport via the M3-01 helper") rather than from
+ * the directory path — the marker is genie's "registration contract" (M3-01's
+ * own module doc), so it is the authoritative source, and reading it directly
+ * also cards a preview file correctly even if a kit doesn't follow the
+ * `components/<group>/<Name>/<Name>.html` two-level convention `../store/
+ * manifest.ts`'s consumers otherwise assume. Safe to assume a match here:
+ * every card reaching this function already passed `validateMarker` against
+ * `MARKER_REGEX`, whose own pattern requires a `group="[^"]*"` capture.
+ */
+function extractGroup(firstLine) {
+    return /^<!--\s*@genie\s+group="([^"]*)"/.exec(firstLine)?.[1] ?? "";
+}
+/**
+ * Extract a card's `viewport` token verbatim from the marker line (AC2/AC5).
+ * `../validate/marker.ts`'s `extractViewport` is deliberately NOT used here:
+ * it decomposes a strict `WxH` token into `{width,height}` integers for
+ * consumers doing arithmetic on the value, and returns `undefined` for
+ * anything else (including a named token like `"desktop"`) — exactly the
+ * case `extractViewport`'s own doc comment calls out as "kept as an opaque
+ * string" by "list_components/the manifest compiler". Re-serializing the
+ * parsed integers back through `${width}x${height}` would also risk silently
+ * normalizing a literal marker string (e.g. dropping a leading zero), which
+ * this compiler must not do — its job is to mirror the marker byte-for-byte,
+ * not reformat it. Returns `""` when the marker has no `viewport` attribute
+ * at all (`../store/manifest.ts`'s `viewport` is a plain `z.string()`, so an
+ * absent viewport still needs SOME string, and `""` is the same "no value"
+ * signal `store/manifest.ts`'s consumers already treat any falsy string as).
+ */
+function extractViewportToken(firstLine) {
+    return /(?:^|\s)viewport="([^"]*)"/.exec(firstLine)?.[1] ?? "";
+}
+/**
+ * Derive a card's `name` from its filename (`<Name>.html` → `<Name>`) — the
+ * on-disk convention every M3-03-adjacent module (RFC §7.1, `conjure.ts`'s
+ * system prompt) assumes.
+ */
+function deriveName(relPath) {
+    const file = basename(relPath);
+    return file.endsWith(".html") ? file.slice(0, -".html".length) : file;
+}
+// ─── compileManifest (AC1–AC7) ───────────────────────────────────────────────
+/**
+ * Recompile the manifest for `projectRoot` (AC1) purely from what's on disk
+ * right now — no incremental state, no cache. Safe to call as often as the
+ * watcher likes; a debounce (M3-02's own 100 ms window) is the caller's
+ * concern, not this function's.
+ *
+ * Steps (AC2/AC3):
+ *  1. Walk `${projectRoot}/components/**\/*.html`.
+ *  2. For each, validate the `@genie` first line (M3-01). A file that fails
+ *     is SKIPPED (not carded) and reported in `skipped` — mirrors the RFC
+ *     §6.8 failure mode ("the watcher silently skips it; validate surfaces
+ *     the omission").
+ *  3. Extract `viewport` from the marker line; join a sibling `meta.json`
+ *     for `subtitle`/`tags` when present (AC3).
+ *  4. Hash the HTML file's bytes as `sha256-<base64>` SRI (AC5, same format
+ *     `list_files`/`.genie/sync.json` use — `store/kit-files.ts`'s
+ *     `sriSha256`).
+ *  5. Sort groups alphabetically unless a root `_groups.json` sibling pins an
+ *     explicit order (Impl Notes); sort cards alphabetically by `name`
+ *     within a group, ties broken by `path` (the shared `compareComponents`
+ *     from `store/manifest.ts` — AC6-equivalent ordering used everywhere
+ *     else a component list is sorted in this codebase).
+ *  6. Atomically write `.genie/manifest.json` (AC6): stage under
+ *     `${projectRoot}/.genie-tmp/`, then rename over the destination — same
+ *     same-filesystem-rename pattern `sync/anchor.ts` and `store/local.ts`
+ *     already use, so a crash mid-write leaves the PRIOR manifest (or none)
+ *     intact, never a half-written one.
+ */
+export async function compileManifest(projectRoot) {
+    const componentsRoot = join(projectRoot, "components");
+    const previews = await walkPreviewFiles(componentsRoot, projectRoot);
+    const skipped = [];
+    const cards = [];
+    for (const { absPath, relPath } of previews) {
+        // Read the file's raw bytes ONCE: sriSha256 hashes these exact bytes
+        // (matching store/local.ts's own convention of hashing what was actually
+        // read, not a re-encoded string), and the same buffer is decoded to utf-8
+        // for marker/content parsing — avoiding a second disk read per file and
+        // any lossy-decode edge case a re-read could introduce.
+        const bytes = await readFile(absPath);
+        const content = bytes.toString("utf-8");
+        const validation = validateMarker(relPath, content);
+        if (!validation.ok) {
+            skipped.push({ path: relPath, reason: validation.code });
+            continue;
+        }
+        const firstLine = content.split("\n", 1)[0] ?? "";
+        const group = extractGroup(firstLine);
+        const viewportToken = extractViewportToken(firstLine);
+        const [stats, metaRaw] = await Promise.all([stat(absPath), readSibling(absPath, "meta.json")]);
+        const meta = metaRaw ? parseComponentMeta(metaRaw) : {};
+        cards.push({
+            name: deriveName(relPath),
+            group,
+            path: relPath,
+            viewport: viewportToken,
+            hash: sriSha256(bytes),
+            lastModified: stats.mtime.toISOString(),
+            ...(meta.subtitle !== undefined ? { subtitle: meta.subtitle } : {}),
+            ...(meta.tags !== undefined ? { tags: meta.tags } : {}),
+        });
+    }
+    cards.sort(compareComponents);
+    const pinnedRaw = await readOptionalFile(join(projectRoot, "_groups.json"));
+    const pinnedOrder = pinnedRaw ? parseGroupsOrder(pinnedRaw) : undefined;
+    const discoveredGroups = [...new Set(cards.map((c) => c.group))];
+    const groups = orderGroups(discoveredGroups, pinnedOrder);
+    const manifest = {
+        version: 1,
+        name: basename(projectRoot),
+        generatedAt: new Date().toISOString(),
+        groups,
+        components: cards,
+    };
+    await writeManifestAtomic(projectRoot, manifest);
+    return { manifest, skipped };
+}
+/**
+ * Alphabetical by default; when `pinnedOrder` is supplied (a parsed
+ * `_groups.json`), pinned groups come first in their given order, followed by
+ * any remaining discovered group NOT in the pin list, alphabetically — so an
+ * incomplete pin list never silently drops a group from the manifest.
+ */
+function orderGroups(discovered, pinnedOrder) {
+    if (!pinnedOrder || pinnedOrder.length === 0) {
+        return [...discovered].sort(byCodeUnit);
+    }
+    const discoveredSet = new Set(discovered);
+    const pinned = pinnedOrder.filter((g) => discoveredSet.has(g));
+    const pinnedSet = new Set(pinned);
+    const remainder = discovered.filter((g) => !pinnedSet.has(g)).sort(byCodeUnit);
+    return [...pinned, ...remainder];
+}
+function byCodeUnit(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+/**
+ * Atomic write (AC6): stage the serialized manifest under
+ * `${projectRoot}/.genie-tmp/` (same filesystem as the `.genie/` destination
+ * — `rename()` is only atomic within one filesystem, the same load-bearing
+ * reasoning `sync/anchor.ts`'s `writeAnchor` and `store/local.ts`'s
+ * `stageAndCommit` already rely on), then rename over
+ * `${projectRoot}/.genie/manifest.json`. `.genie-tmp` is already excluded
+ * from every kit listing (`store/kit-files.ts`'s `DEFAULT_IGNORED_SEGMENTS`),
+ * so a `list_files` call mid-compile never surfaces this staging directory.
+ */
+async function writeManifestAtomic(projectRoot, manifest) {
+    const destPath = join(projectRoot, MANIFEST_PATH);
+    await mkdir(join(projectRoot, ".genie"), { recursive: true });
+    const genieTmpRoot = join(projectRoot, ".genie-tmp");
+    await mkdir(genieTmpRoot, { recursive: true });
+    const stagingRoot = await mkdtemp(join(genieTmpRoot, "manifest-"));
+    try {
+        const stagedPath = join(stagingRoot, "manifest.json");
+        await writeFile(stagedPath, JSON.stringify(manifest, null, 2), "utf-8");
+        await rename(stagedPath, destPath);
+    }
+    finally {
+        await rm(stagingRoot, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=compiler.js.map

package/dist/manifest/compiler.js.map

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

package/dist/manifest/ensure.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `ensureManifest` — the single entry point for "compile the kit's manifest and
+ * make sure `.genie/manifest.json` reflects it" (design: 2026-07-05 chat-
+ * invocation, piece A).
+ *
+ * ## Why this exists
+ *
+ * Manifest compilation ({@link compileManifest}) already writes
+ * `.genie/manifest.json` atomically as its final step. But historically the
+ * ONLY caller that triggered a compile at request time was the `ui://genie/grid`
+ * resource handler ({@link file://../ui/grid-resource.ts}). The `preview` tool
+ * booted the viewer WITHOUT compiling, so a caller that opened the Vite /
+ * `file://` vehicle — or an MCP Inspector that cannot read `ui://` resources at
+ * all — saw an EMPTY grid, and `list_components` (which reads the compiled
+ * manifest) returned `[]` until some unrelated `ui://` read happened to compile
+ * it. That order-dependence was the root of the "preview shows nothing" bug.
+ *
+ * Routing BOTH the `preview` tool and the grid resource through this one helper
+ * removes the divergence: there is exactly one way a manifest gets produced +
+ * persisted at request time, so the two surfaces can never drift on how (or
+ * whether) they compile.
+ *
+ * ## Contract
+ *
+ * Given a kit directory, compile it from what's on disk right now and return the
+ * resulting {@link Manifest}. Persistence of `.genie/manifest.json` is inherited
+ * from {@link compileManifest} (its atomic stage-then-rename write) — this
+ * wrapper adds no write of its own; it exists to (a) give callers the
+ * manifest-only shape they want without each re-destructuring `{ manifest }`,
+ * and (b) be the named seam both the tool and the resource depend on.
+ *
+ * The `skipped` diagnostics from a compile are intentionally dropped here — the
+ * two callers (`preview`, grid resource) only need the manifest to render;
+ * surfacing skipped/invalid components is `validate`'s job, not the view path's.
+ */
+import { type Manifest } from "./compiler.js";
+/**
+ * Compile `kitDir`'s manifest from disk and persist `.genie/manifest.json`
+ * (persistence via {@link compileManifest}). Returns the compiled manifest.
+ *
+ * Throws whatever {@link compileManifest} throws (e.g. an unreadable kit dir);
+ * callers that must degrade to an empty grid rather than error — like the grid
+ * resource — catch it themselves, preserving their existing failure semantics.
+ */
+export declare function ensureManifest(kitDir: string): Promise<Manifest>;
+//# sourceMappingURL=ensure.d.ts.map

package/dist/manifest/ensure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure.d.ts","sourceRoot":"","sources":["../../src/manifest/ensure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE/D;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAGtE"}

package/dist/manifest/ensure.js

@@ -0,0 +1,49 @@
+/**
+ * `ensureManifest` — the single entry point for "compile the kit's manifest and
+ * make sure `.genie/manifest.json` reflects it" (design: 2026-07-05 chat-
+ * invocation, piece A).
+ *
+ * ## Why this exists
+ *
+ * Manifest compilation ({@link compileManifest}) already writes
+ * `.genie/manifest.json` atomically as its final step. But historically the
+ * ONLY caller that triggered a compile at request time was the `ui://genie/grid`
+ * resource handler ({@link file://../ui/grid-resource.ts}). The `preview` tool
+ * booted the viewer WITHOUT compiling, so a caller that opened the Vite /
+ * `file://` vehicle — or an MCP Inspector that cannot read `ui://` resources at
+ * all — saw an EMPTY grid, and `list_components` (which reads the compiled
+ * manifest) returned `[]` until some unrelated `ui://` read happened to compile
+ * it. That order-dependence was the root of the "preview shows nothing" bug.
+ *
+ * Routing BOTH the `preview` tool and the grid resource through this one helper
+ * removes the divergence: there is exactly one way a manifest gets produced +
+ * persisted at request time, so the two surfaces can never drift on how (or
+ * whether) they compile.
+ *
+ * ## Contract
+ *
+ * Given a kit directory, compile it from what's on disk right now and return the
+ * resulting {@link Manifest}. Persistence of `.genie/manifest.json` is inherited
+ * from {@link compileManifest} (its atomic stage-then-rename write) — this
+ * wrapper adds no write of its own; it exists to (a) give callers the
+ * manifest-only shape they want without each re-destructuring `{ manifest }`,
+ * and (b) be the named seam both the tool and the resource depend on.
+ *
+ * The `skipped` diagnostics from a compile are intentionally dropped here — the
+ * two callers (`preview`, grid resource) only need the manifest to render;
+ * surfacing skipped/invalid components is `validate`'s job, not the view path's.
+ */
+import { compileManifest } from "./compiler.js";
+/**
+ * Compile `kitDir`'s manifest from disk and persist `.genie/manifest.json`
+ * (persistence via {@link compileManifest}). Returns the compiled manifest.
+ *
+ * Throws whatever {@link compileManifest} throws (e.g. an unreadable kit dir);
+ * callers that must degrade to an empty grid rather than error — like the grid
+ * resource — catch it themselves, preserving their existing failure semantics.
+ */
+export async function ensureManifest(kitDir) {
+    const { manifest } = await compileManifest(kitDir);
+    return manifest;
+}
+//# sourceMappingURL=ensure.js.map

package/dist/manifest/ensure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure.js","sourceRoot":"","sources":["../../src/manifest/ensure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAAE,eAAe,EAAiB,MAAM,eAAe,CAAC;AAE/D;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,MAAc;IACjD,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,eAAe,CAAC,MAAM,CAAC,CAAC;IACnD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/manifest/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Public re-export barrel for the M3-03 manifest compiler (DRO-259).
+ *
+ * Mirrors the existing `store/index.ts` / `plans/index.ts` / `validate/
+ * index.ts` / `watch/index.ts` barrel pattern: downstream consumers (the
+ * M3-02 watcher's `onChange` wiring, `validate`'s M3-04 full-scan facet, the
+ * M4 viewer's build tooling) import from `../manifest/index.js` rather than
+ * reaching into `./compiler.js` directly, so this module's internal file
+ * layout can change without breaking callers.
+ */
+export { compileManifest, type CompileResult, type Manifest, type ManifestCard, type ManifestSkip, } from "./compiler.js";
+export { ensureManifest } from "./ensure.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/manifest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/manifest/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,eAAe,EACf,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,YAAY,GAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/manifest/index.js

@@ -0,0 +1,13 @@
+/**
+ * Public re-export barrel for the M3-03 manifest compiler (DRO-259).
+ *
+ * Mirrors the existing `store/index.ts` / `plans/index.ts` / `validate/
+ * index.ts` / `watch/index.ts` barrel pattern: downstream consumers (the
+ * M3-02 watcher's `onChange` wiring, `validate`'s M3-04 full-scan facet, the
+ * M4 viewer's build tooling) import from `../manifest/index.js` rather than
+ * reaching into `./compiler.js` directly, so this module's internal file
+ * layout can change without breaking callers.
+ */
+export { compileManifest, } from "./compiler.js";
+export { ensureManifest } from "./ensure.js";
+//# sourceMappingURL=index.js.map

package/dist/manifest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/manifest/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,eAAe,GAKhB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/middleware/plan-guard.d.ts

@@ -0,0 +1,167 @@
+/**
+ * `withPlanGuard` — centralised plan-vs-write guard middleware (M1-13,
+ * DRO-239).
+ *
+ * BEFORE this file, every plan-gated verb (`write_files`, `delete_files`) had
+ * to reimplement the same four checks — planId presence, planId existence,
+ * planId expiry, and per-path glob membership. When they drifted (as they
+ * already had: `write_files` split path-outside-plan into `"glob"` vs
+ * `"escapesLocalDir"` sub-reasons while `delete_files` used a single message,
+ * and only `plan.ts` emitted a structured audit log), a request that would be
+ * rejected by one verb could slip through another with the same shape.
+ *
+ * This middleware makes the guard one seam: every plan-gated tool wraps its
+ * handler in `withPlanGuard(...)`, and the four checks (AC2 (a)–(d)) live
+ * here, produce one canonical JSON-RPC `-32602 InvalidParams`-shaped payload
+ * (AC3), and emit one canonical `plan.guard.reject` audit line (AC6). The
+ * refactored write/delete tools stop re-implementing these checks entirely.
+ *
+ * Tool-side error taxonomies (e.g. `write_files`' `PayloadTooLargeError`,
+ * `delete_files`' `DeleteFailed`) stay in the tools — this middleware only
+ * owns the plan-boundary check, matching the issue's scope ("one middleware
+ * so every write/delete/register/unregister call funnels through identical
+ * validation"), and stops at that boundary so tools remain responsible for
+ * their own downstream error shapes.
+ */
+import { type PlanState } from "../plans/index.js";
+/**
+ * Reasons the guard can reject a call, in the enum shape mandated by AC3
+ * (`data.reason` is a client-consumable string). Kept intentionally coarse:
+ * a client should be able to branch on this without knowing the guard's
+ * internals. The order here matches the order the guard performs its checks
+ * (see `withPlanGuard`), which is also the order they short-circuit in.
+ */
+export type PlanGuardRejectReason = 
+/** AC2(a) — `planId` was missing, empty, or not a string. */
+"planIdMissing"
+/**
+ * AC2(b)+(c) — `planId` was well-formed but the plan doesn't exist, or
+ * has expired. Both surface identically because the underlying plan
+ * registry (`plans/index.ts`) already collapses them into a single
+ * `PlanNotFoundError` — there is no separate `PlanExpiredError` for the
+ * middleware to distinguish, and shipping two reasons here for what the
+ * registry treats as one state would just push clients to guess which one
+ * they got.
+ */
+ | "planNotFound"
+/**
+ * AC2(d) — a path in the request doesn't match any glob in the plan's
+ * `writes` (mode `"writes"`) or `deletes` (mode `"deletes"`) list.
+ */
+ | "pathOutsidePlan";
+/**
+ * The guard operates in one of two modes: it checks paths against either the
+ * plan's `writes` or its `deletes` glob list. This is a discriminator on the
+ * middleware options — not a runtime toggle on a single "check either" mode,
+ * because a `write_files` call must NOT be authorised by a `deletes` glob
+ * (and vice versa; a plan's two glob lists are strictly separate). Encoding
+ * this as an option, rather than inferring it from the tool name, keeps the
+ * middleware tool-agnostic and locks the strict separation as a per-call
+ * choice.
+ */
+export type PlanGuardMode = "writes" | "deletes";
+/**
+ * Options controlling how the guard extracts paths from a given tool call.
+ *
+ * The two shipping consumers name their path list differently:
+ *   - `write_files` uses `{ files: [{ path, … }] }` (default when `mode: "writes"`)
+ *   - `delete_files` uses `{ paths: [] }`             (default when `mode: "deletes"`, or via `pathsKey: "paths"`)
+ *
+ * Future consumers (`register_assets`, per AC4's forward-compat hook) have
+ * their own shapes — the `extractPaths` escape hatch lets any tool plug in
+ * without adding another built-in shape variant here.
+ */
+export interface PlanGuardOptions {
+    mode: PlanGuardMode;
+    /**
+     * For array-of-strings shapes: the top-level key whose value is a
+     * `string[]` of paths. Defaults to `"paths"` when `mode: "deletes"` (the
+     * shape delete_files uses).
+     */
+    pathsKey?: string;
+    /**
+     * For non-standard shapes: a custom function that returns the flat list
+     * of paths to check. Overrides `pathsKey` and the built-in
+     * `files[].path` extraction when set. Used e.g. by `register_assets`
+     * (whose paths live under `assets[].path`).
+     */
+    extractPaths?: (args: any) => string[];
+}
+/**
+ * The MCP tool-result shape returned by the SDK's `registerTool` handler
+ * signature — kept structural (rather than pulling in the SDK's own
+ * `CallToolResult` type) so this middleware doesn't force a `@modelcontextprotocol/sdk`
+ * import on files that don't otherwise need one. The `content` items are
+ * declared with a discriminated-literal `type` so the returned value slots
+ * directly into the SDK's own `CallToolResult` typing (which uses a union
+ * over `type: "text" | "image" | ...` and would reject a `string`).
+ */
+export interface ToolResultContentText {
+    type: "text";
+    text: string;
+    [key: string]: unknown;
+}
+export interface ToolResult {
+    isError?: boolean;
+    content: Array<ToolResultContentText>;
+    structuredContent?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Context passed as the second argument to the wrapped handler on success —
+ * the resolved plan. The handler would otherwise have to call `getPlan` a
+ * second time to reach `plan.localDir` / `plan.kitId`, doubling the
+ * plan-registry hit for every request; passing it through means every
+ * downstream write/delete op sees the exact PlanState that authorised the
+ * call (not one refreshed a few ms later on a separate `getPlan`).
+ */
+export interface PlanGuardContext {
+    plan: PlanState;
+}
+/**
+ * A tool handler as `withPlanGuard` sees it: takes the raw args and an
+ * optional guard context (the resolved plan), returns an MCP tool result.
+ *
+ * The `Args` and `Result` type parameters flow through the HOF so a
+ * caller-side type assertion isn't needed at the handler's signature.
+ */
+export type GuardedHandler<Args, Result extends ToolResult> = (args: Args, ctx: PlanGuardContext) => Promise<Result>;
+/**
+ * Wrap a plan-gated tool handler so every call funnels through one plan-vs-
+ * write validation seam.
+ *
+ * Order of checks — matches AC2 (a)→(d), and is intentionally the same order
+ * the tool would fail-fast on today:
+ *
+ *   1. **planId present** (AC2(a)) — string, non-empty. Missing values are
+ *      rejected before touching the plan registry: a `getPlan("")` would
+ *      throw as "not found", which would lose the distinction the reason
+ *      enum draws between "you forgot to send a planId" and "the planId you
+ *      sent doesn't match any plan we have." Clients act on those
+ *      differently (the first is a client bug; the second may be an expired
+ *      capability grant that needs re-issuing).
+ *
+ *   2. **planId exists + not expired** (AC2(b)+(c)) — `getPlan` throws
+ *      `PlanNotFoundError` for both, so they surface as one `planNotFound`
+ *      reason (see the enum comment above for why).
+ *
+ *   3. **path matches plan globs** (AC2(d)) — every extracted path is
+ *      checked against `plan.writes` or `plan.deletes` per `options.mode`.
+ *      Fails on the FIRST offending path: the exact offending path is
+ *      surfaced (both in the returned payload and the audit log), so an
+ *      operator investigating a rejection knows which specific path
+ *      tripped the guard without having to diff the whole request against
+ *      the plan's glob list.
+ *
+ * Only if all three pass does the wrapped handler run — with the resolved
+ * plan handed through in `ctx.plan`, so it doesn't re-fetch (see
+ * `PlanGuardContext`).
+ *
+ * Non-guard errors (a `getPlan` throw that isn't `PlanNotFoundError`, or
+ * a handler throw) are NOT swallowed — they propagate as-is, so a
+ * disk-corrupt plan snapshot or an internal handler bug is still visible to
+ * the transport layer (as an MCP internal error), rather than being masked
+ * as a plan-boundary rejection.
+ */
+export declare function withPlanGuard<Args, Result extends ToolResult>(options: PlanGuardOptions, handler: GuardedHandler<Args, Result>): (args: Args) => Promise<Result | ToolResult>;
+//# sourceMappingURL=plan-guard.d.ts.map

package/dist/middleware/plan-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-guard.d.ts","sourceRoot":"","sources":["../../src/middleware/plan-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAgD,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEjG;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB;AAC/B,6DAA6D;AAC3D,eAAe;AACjB;;;;;;;;GAQG;GACD,cAAc;AAChB;;;GAGG;GACD,iBAAiB,CAAC;AAEtB;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEjD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,aAAa,CAAC;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IAEH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,MAAM,EAAE,CAAC;CACxC;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AACD,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,KAAK,CAAC,qBAAqB,CAAC,CAAC;IACtC,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,SAAS,CAAC;CACjB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,CAAC,IAAI,EAAE,MAAM,SAAS,UAAU,IAAI,CAC5D,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,gBAAgB,KAClB,OAAO,CAAC,MAAM,CAAC,CAAC;AAmGrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,SAAS,UAAU,EAC3D,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,GACpC,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,MAAM,GAAG,UAAU,CAAC,CAuD9C"}