@ambitresearch/genie 1.3.1

package/dist/sync/orchestrator.js

@@ -0,0 +1,288 @@
+/**
+ * M3-05 (DRO-261) — genie's 5-step atomic write-sequence orchestrator.
+ *
+ * `runAtomicSync` sequences one sync commit as five ordered, stop-on-first-
+ * failure steps. The atomic write sequence is load-bearing and unchanged in
+ * shape:
+ *
+ *   1. Write the `.genie/recompile` sentinel FIRST, to fence the manifest/copy
+ *      machinery — a consumer that sees the sentinel knows a sync is mid-flight
+ *      and the tree may be inconsistent until the anchor lands.
+ *   2. Apply every content write, chunked into batches of ≤ 256 per
+ *      `write_files` call (the M1-08 `MAX_FILES_PER_CALL` ceiling — a 257-file
+ *      call would be rejected as `TooManyFilesError`).
+ *   3. Apply every delete via one `delete_files` call. A path that is
+ *      authorized-but-absent is NOT a failure (M1-09 AC5 returns it in
+ *      `notFoundPaths`) — only a real error (out-of-plan path, unlink failure)
+ *      trips stop-on-first-failure.
+ *   4. RE-ARM the sentinel (write it again), so it still fences the tree after
+ *      the writes/deletes landed and right up until the anchor is committed.
+ *   5. Write `.genie/sync.json` LAST, via M3-06's {@link writeAnchor}. It is the
+ *      completion proof: its presence means every prior step succeeded.
+ *
+ * ── Why the anchor is last (AC7) ─────────────────────────────────────────────
+ * A mid-plan failure (steps 1–4) returns before step 5, so `.genie/sync.json`
+ * is never written for an incomplete sync. The NEXT sync sees "sentinel present,
+ * anchor absent" ({@link detectResumeStep} → 2) and knows the tree is a
+ * half-write to repair from step 2 — rather than trusting a stale anchor that
+ * would mask the incomplete state. This is the whole reason the write order is
+ * load-bearing.
+ *
+ * ── Native surface (CLAUDE.md hard rule 1) ───────────────────────────────────
+ * `.genie/recompile` and `.genie/sync.json` are genie-NATIVE artifacts. They are
+ * written fs-native to `projectRoot` (NOT through the plan-gated `write_files`
+ * verb — they would never match a user plan's `writes` globs, and they are
+ * genie's own bookkeeping, not user content). They must NOT be renamed to the
+ * Anthropic `_ds_recompile` / `_ds_sync.json` interop shapes; an interop bridge
+ * that maps them is a separate, opt-in concern.
+ *
+ * ── Composition (Kiln's plan, DRO-696) ───────────────────────────────────────
+ * Steps 2–3 call the in-process `writeFiles` / `deleteFiles` CORE functions
+ * directly (not over the MCP transport) — the same way `conjure_screen.ts`
+ * composes tool-layer logic — so the orchestrator reuses their full plan-gating,
+ * atomicity, and rollback contracts without re-implementing any of it.
+ */
+import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { performance } from "node:perf_hooks";
+import { deleteFiles } from "../tools/delete_files.js";
+import { MAX_FILES_PER_CALL, writeFiles } from "../tools/write_files.js";
+import { readAnchor, writeAnchor } from "./anchor.js";
+// ─── Native sentinel (AC2) ───────────────────────────────────────────────────
+/** Kit-root-relative path of genie's recompile fence sentinel (native surface). */
+export const RECOMPILE_SENTINEL_PATH = ".genie/recompile";
+/**
+ * The exact sentinel body (AC2). genie's native `{"by":"genie"}` marker — NOT
+ * the Anthropic `_ds_recompile` interop shape (CLAUDE.md hard rule 1). Kept as
+ * a compact single-line literal so a byte-for-byte assertion is trivial and the
+ * re-arm in step 4 reproduces it exactly.
+ */
+export const RECOMPILE_SENTINEL_BODY = '{"by":"genie"}';
+// ─── runAtomicSync (AC1–AC7, AC9) ────────────────────────────────────────────
+/**
+ * Run the 5-step atomic sync sequence. Stops on the first failing step (AC7),
+ * leaving `.genie/sync.json` unwritten so the next sync's diff repairs the
+ * half-write; a not-found delete inside step 3 is NOT a failure (AC4). Every
+ * attempted step emits a {@link StepEvent} (AC9).
+ */
+export async function runAtomicSync(deps, args) {
+    const { store, projectRoot } = deps;
+    const events = [];
+    try {
+        // Step 1 — fence the tree with the recompile sentinel FIRST (AC2).
+        await runStep(1, events, () => writeSentinel(projectRoot));
+        // Step 2 — content writes, chunked ≤ 256/call (AC3).
+        await runStep(2, events, () => runWrites(store, args.planId, args.writes));
+        // Step 3 — deletes (AC4); a not-found delete does not throw (M1-09 AC5).
+        await runStep(3, events, () => runDeletes(store, args.planId, args.deletes));
+        // Step 4 — re-arm the sentinel so it fences right up to the anchor (AC5).
+        await runStep(4, events, () => writeSentinel(projectRoot));
+        // Step 5 — write `.genie/sync.json` LAST as the completion proof (AC6).
+        await runStep(5, events, () => writeFinalAnchor(projectRoot, args));
+        return { ok: true, events };
+    }
+    catch (error) {
+        // The failing step pushed its own `ok: false` event before rethrowing, so
+        // the last event's step IS the failed step (AC7). `?? 1` is unreachable
+        // (a throw always follows at least one pushed event) but keeps the type
+        // total without a non-null assertion.
+        const failedStep = events[events.length - 1]?.step ?? 1;
+        return {
+            ok: false,
+            failedStep,
+            error: error instanceof Error ? error : new Error(String(error)),
+            events,
+        };
+    }
+}
+// ─── detectResumeStep (AC8) ──────────────────────────────────────────────────
+/**
+ * Inspect a kit root and report where the NEXT sync should resume from (AC8):
+ *
+ *   - `2`    — sentinel present, anchor ABSENT: a prior sync fenced the tree
+ *              (step 1) then crashed before the anchor landed (steps 2–4). The
+ *              tree is a half-write; resume from step 2 to re-apply
+ *              writes/deletes and re-arm before writing the anchor.
+ *   - `1`    — sentinel AND anchor both absent: a fresh, never-synced kit.
+ *              Start a normal sync from step 1.
+ *   - `null` — the anchor is present (a prior sync completed cleanly): there is
+ *              no partial-write to resume; the next sync is a NEW plan from step
+ *              1 with fresh inputs, not a resume.
+ *
+ * Never mutates the tree. Propagates {@link readAnchor}'s `AnchorParseError`
+ * for a corrupt-but-present anchor — a corrupt anchor is a real operability
+ * problem, not a "nothing to resume" signal (same reasoning `readAnchor` itself
+ * applies). Likewise propagates any non-"missing" error from the sentinel
+ * `stat` (e.g. `EACCES` on `.genie/`) rather than treating it as "sentinel
+ * absent" — see {@link pathExists}.
+ */
+export async function detectResumeStep(projectRoot) {
+    const sentinelPresent = await pathExists(join(projectRoot, RECOMPILE_SENTINEL_PATH));
+    const anchor = await readAnchor(projectRoot); // null when absent (AC8 of M3-06)
+    if (anchor !== null)
+        return null; // clean — last sync completed
+    return sentinelPresent ? 2 : 1; // half-write → step 2; fresh → step 1
+}
+// ─── Step bodies ─────────────────────────────────────────────────────────────
+/**
+ * Write (or re-arm) the native recompile sentinel fs-directly under
+ * `projectRoot`. Idempotent — steps 1 and 4 both call it and the second write
+ * simply reproduces the same bytes. Not plan-gated: `.genie/recompile` is
+ * genie's own bookkeeping, never user content.
+ */
+async function writeSentinel(projectRoot) {
+    await mkdir(join(projectRoot, ".genie"), { recursive: true });
+    await writeFile(join(projectRoot, RECOMPILE_SENTINEL_PATH), RECOMPILE_SENTINEL_BODY, "utf-8");
+}
+/**
+ * Step 2 — apply all content writes, chunked into ≤ `MAX_FILES_PER_CALL`
+ * batches, one plan-gated `writeFiles` call each (AC3). An empty `writes` array
+ * yields zero batches → zero calls → a clean no-op (the step still emits its
+ * event). A `WriteFailedError` / `PathOutsidePlanError` from any batch
+ * propagates and fails the step.
+ */
+async function runWrites(store, planId, writes) {
+    for (const batch of chunk(writes, MAX_FILES_PER_CALL)) {
+        await writeFiles(store, { planId, files: batch });
+    }
+}
+/**
+ * Step 3 — apply all deletes in one plan-gated `delete_files` call (AC4).
+ *
+ * Skipped entirely when there is nothing to delete: `delete_files`' args schema
+ * requires `paths` to be non-empty (`.min(1)`), so calling it with `[]` would
+ * be an `InvalidArguments` error rather than a no-op. A not-found path is
+ * handled INSIDE `deleteFiles` (returned in `notFoundPaths`, never thrown), so
+ * it does not fail this step (AC7's not-found exception). Only a real error
+ * (out-of-plan path, unlink failure) propagates.
+ */
+async function runDeletes(store, planId, deletes) {
+    if (deletes.length === 0)
+        return;
+    await deleteFiles(store, { planId, paths: deletes });
+}
+/**
+ * Step 5 — assemble M3-06's `PlanResult` from the sync inputs and write
+ * `.genie/sync.json` LAST via {@link writeAnchor} (AC6). `writeAnchor` hashes
+ * only source/render-extension paths and does its own temp-file + rename commit,
+ * so this step is the atomic completion proof.
+ */
+async function writeFinalAnchor(projectRoot, args) {
+    const planResult = {
+        writes: await resolveAnchorWrites(projectRoot, args.writes),
+        verified: args.verified ?? [],
+    };
+    await writeAnchor(projectRoot, planResult);
+}
+/**
+ * Resolve each {@link WriteInput} to the `{ path, content }` shape
+ * `writeAnchor` hashes.
+ *
+ * ── Committed bytes, not the plan's local source (Copilot review) ───────────
+ * Inline `data` resolves for free — utf-8 decodes to the string, base64 to a
+ * `Buffer` — the exact bytes already handed to `writeFiles` in step 2, no disk
+ * read at all.
+ *
+ * A `localPath` write is different: step 2 STREAMS it straight from the
+ * plan's `localDir` into the kit tree (`store/local.ts`'s `streamCopy`, via
+ * `createReadStream` — never buffered here, by design, so a large upload
+ * never fully loads into memory). This function used to re-read that SAME
+ * `localDir` source file a second time, during step 5, to compute its hash —
+ * a TOCTOU hazard, since the plan's `localDir` is a directory the CALLER
+ * controls and may keep writing to for the lifetime of a sync, so the bytes
+ * step 5 would hash could silently diverge from the bytes step 2 actually
+ * streamed into the kit. It also contradicted `sync/anchor.ts`'s own
+ * contract that hashes must come from "the exact bytes that landed, not
+ * re-read from disk after the fact."
+ *
+ * The fix: read the file back from `projectRoot` — the KIT destination step
+ * 2 just committed it to (`join(projectRoot, write.path)`) — never from the
+ * plan's `localDir` source. `projectRoot` is guaranteed (by `SyncDeps`'s own
+ * contract, see above) to be the exact directory `store.writeFiles` resolved
+ * the write to, so this hashes precisely the bytes the kit tree now holds —
+ * the same tree `writeAnchor` is meant to vouch for — rather than a second,
+ * independently-timed read of a directory outside genie's control.
+ *
+ * A write with neither `data` nor `localPath` is unreachable here (step 2's
+ * `write_files` would have rejected it, and step 5 only runs once step 2
+ * passed); it is defensively hashed as empty rather than throwing.
+ */
+async function resolveAnchorWrites(projectRoot, writes) {
+    const resolved = [];
+    for (const write of writes) {
+        let content;
+        if (write.data !== undefined) {
+            content = write.encoding === "base64" ? Buffer.from(write.data, "base64") : write.data;
+        }
+        else if (write.localPath !== undefined) {
+            content = await readFile(join(projectRoot, write.path));
+        }
+        else {
+            content = "";
+        }
+        resolved.push({ path: write.path, content });
+    }
+    return resolved;
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/**
+ * Time one step, push its {@link StepEvent}, and either return the step's value
+ * or re-throw after recording the failure (AC9). The re-throw is what
+ * `runAtomicSync`'s outer catch turns into the stop-on-first-failure result — so
+ * the failing step's event is always recorded before the sequence unwinds.
+ */
+async function runStep(step, events, fn) {
+    const start = performance.now();
+    try {
+        const value = await fn();
+        events.push({ step, ok: true, ms: performance.now() - start });
+        return value;
+    }
+    catch (error) {
+        events.push({ step, ok: false, ms: performance.now() - start });
+        throw error;
+    }
+}
+/** Split `items` into consecutive slices of at most `size` (AC3 chunking). */
+function chunk(items, size) {
+    const batches = [];
+    for (let index = 0; index < items.length; index += size) {
+        batches.push(items.slice(index, index + size));
+    }
+    return batches;
+}
+/**
+ * True if `path` exists (any node type); false if it (or a parent directory
+ * component) genuinely does not exist. Any OTHER `stat` failure — EACCES,
+ * EPERM, a transient I/O error — propagates rather than being misread as
+ * "absent" (Copilot review on this PR): silently mapping every error to
+ * `false` could make {@link detectResumeStep} report "fresh, start from step
+ * 1" for a sentinel that is actually present-but-unreadable, masking a real
+ * operability problem instead of surfacing it. Mirrors `./anchor.ts`'s
+ * `readAnchor` (and `store/local.ts`'s identical helper), which apply the
+ * same ENOENT/ENOTDIR-only rule for the same reason.
+ */
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        if (isMissingPathError(error))
+            return false;
+        throw error;
+    }
+}
+/**
+ * ENOENT (missing file) and ENOTDIR (a parent path component is a file, not a
+ * directory) both mean "not there". Duplicated locally rather than imported
+ * from `./anchor.ts` / `store/local.ts` — each of those already carries its
+ * own copy of this exact one-liner, matching this repo's established
+ * per-module-owns-its-guard convention for this helper.
+ */
+function isMissingPathError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR"));
+}
+//# sourceMappingURL=orchestrator.js.map

package/dist/sync/orchestrator.js.map

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

package/dist/tools/bind_kit.d.ts

@@ -0,0 +1,29 @@
+/**
+ * MCP tool: bind_kit (M1-20).
+ *
+ * Attaches a UI kit to a project and optionally marks it the default for
+ * screen generation (M1-21, `conjure_screen`, resolves against this).
+ *
+ * Input:  { projectId: string, kitId: string, default?: boolean }
+ * Output: ProjectSummary (same shape `list_projects`/`get_project` return)
+ */
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { BindKitArgs, ProjectSummary } from "./create_project.js";
+export declare const BIND_KIT_TOOL_NAME = "mcp__genie__bind_kit";
+/**
+ * Narrow port `bind_kit` depends on — anything that can bind a kit to a
+ * project and return its updated summary. `ProjectStore` (from
+ * `create_project.ts`) satisfies this structurally, matching the
+ * `ProjectGetStore`/`ProjectListStore` pattern already used by sibling tools.
+ */
+export interface ProjectBindKitStore {
+    bindKit(args: BindKitArgs): Promise<ProjectSummary>;
+}
+/**
+ * Validate args and bind the kit. Exported standalone (bypassing the MCP
+ * transport) so programmatic/direct callers get the same validation
+ * defense-in-depth as `get_project`'s `getProject()` and `get_kit`'s `getKit()`.
+ */
+export declare function bindKit(store: ProjectBindKitStore, args: unknown): Promise<ProjectSummary>;
+export declare function registerBindKitTool(server: McpServer, store: ProjectBindKitStore): void;
+//# sourceMappingURL=bind_kit.d.ts.map

package/dist/tools/bind_kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind_kit.d.ts","sourceRoot":"","sources":["../../src/tools/bind_kit.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGzE,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGvE,eAAO,MAAM,kBAAkB,yBAAyB,CAAC;AAwBzD;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACrD;AAED;;;;GAIG;AACH,wBAAsB,OAAO,CAAC,KAAK,EAAE,mBAAmB,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC,CAGhG;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI,CA8CvF"}

package/dist/tools/bind_kit.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { PROJECT_ID_PATTERN, ProjectStoreError, projectSummaryShape } from "./create_project.js";
+import { KIT_ID_PATTERN } from "./get_kit.js";
+export const BIND_KIT_TOOL_NAME = "mcp__genie__bind_kit";
+const projectIdSchema = z
+    .string()
+    .regex(PROJECT_ID_PATTERN, "projectId must be a 3-64 character slug containing only lowercase letters, numbers, and hyphens.");
+const kitIdSchema = z
+    .string()
+    .regex(KIT_ID_PATTERN, "kitId must be a 3-64 character slug containing only lowercase letters, numbers, and hyphens.");
+const bindKitArgsSchema = z
+    .object({
+    projectId: projectIdSchema,
+    kitId: kitIdSchema,
+    default: z.boolean().optional(),
+})
+    .strict();
+/**
+ * Validate args and bind the kit. Exported standalone (bypassing the MCP
+ * transport) so programmatic/direct callers get the same validation
+ * defense-in-depth as `get_project`'s `getProject()` and `get_kit`'s `getKit()`.
+ */
+export async function bindKit(store, args) {
+    const parsed = bindKitArgsSchema.parse(args);
+    return store.bindKit(parsed);
+}
+export function registerBindKitTool(server, store) {
+    server.registerTool(BIND_KIT_TOOL_NAME, {
+        title: "Bind kit",
+        description: "Attach a UI kit to a workspace or blueprint project, optionally marking it the " +
+            "default kit for screen generation. Binding the same kit twice updates the existing " +
+            "binding in place. Setting default: true clears default status from every other " +
+            "binding on the project. Typically precedes conjure_screen, which resolves its kit " +
+            "from these bindings when no explicit kitId is given.",
+        inputSchema: {
+            projectId: projectIdSchema,
+            kitId: kitIdSchema,
+            default: z.boolean().optional(),
+        },
+        outputSchema: projectSummaryShape,
+    }, async (args) => {
+        try {
+            const result = await bindKit(store, args);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+                structuredContent: result,
+            };
+        }
+        catch (error) {
+            if (error instanceof ProjectStoreError) {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                code: error.code,
+                                message: error.message,
+                                ...(error.projectId ? { projectId: error.projectId } : {}),
+                                ...(error.kitId ? { kitId: error.kitId } : {}),
+                            }),
+                        },
+                    ],
+                };
+            }
+            throw error;
+        }
+    });
+}
+//# sourceMappingURL=bind_kit.js.map

package/dist/tools/bind_kit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind_kit.js","sourceRoot":"","sources":["../../src/tools/bind_kit.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAEjG,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C,MAAM,CAAC,MAAM,kBAAkB,GAAG,sBAAsB,CAAC;AAEzD,MAAM,eAAe,GAAG,CAAC;KACtB,MAAM,EAAE;KACR,KAAK,CACJ,kBAAkB,EAClB,kGAAkG,CACnG,CAAC;AAEJ,MAAM,WAAW,GAAG,CAAC;KAClB,MAAM,EAAE;KACR,KAAK,CACJ,cAAc,EACd,8FAA8F,CAC/F,CAAC;AAEJ,MAAM,iBAAiB,GAAG,CAAC;KACxB,MAAM,CAAC;IACN,SAAS,EAAE,eAAe;IAC1B,KAAK,EAAE,WAAW;IAClB,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CAChC,CAAC;KACD,MAAM,EAAE,CAAC;AAYZ;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC,KAA0B,EAAE,IAAa;IACrE,MAAM,MAAM,GAAG,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC7C,OAAO,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;AAC/B,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,MAAiB,EAAE,KAA0B;IAC/E,MAAM,CAAC,YAAY,CACjB,kBAAkB,EAClB;QACE,KAAK,EAAE,UAAU;QACjB,WAAW,EACT,iFAAiF;YACjF,qFAAqF;YACrF,iFAAiF;YACjF,oFAAoF;YACpF,sDAAsD;QACxD,WAAW,EAAE;YACX,SAAS,EAAE,eAAe;YAC1B,KAAK,EAAE,WAAW;YAClB,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;SAChC;QACD,YAAY,EAAE,mBAAmB;KAClC,EACD,KAAK,EAAE,IAAI,EAAE,EAAE;QACb,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YAC1C,OAAO;gBACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;gBAClE,iBAAiB,EAAE,MAAM;aAC1B,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,iBAAiB,EAAE,CAAC;gBACvC,OAAO;oBACL,OAAO,EAAE,IAAI;oBACb,OAAO,EAAE;wBACP;4BACE,IAAI,EAAE,MAAe;4BACrB,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;gCACnB,IAAI,EAAE,KAAK,CAAC,IAAI;gCAChB,OAAO,EAAE,KAAK,CAAC,OAAO;gCACtB,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gCAC1D,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;6BAC/C,CAAC;yBACH;qBACF;iBACF,CAAC;YACJ,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/tools/conjure.d.ts

@@ -0,0 +1,141 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { type ValidatedComponent } from "../llm/schema.js";
+import { type LoadedPrompt } from "../llm/prompts.js";
+import { type ChatCompletionFn, type UsageInfo } from "../llm/component-response.js";
+import { type GeneratedFileWithEncoding } from "../llm/generated-files.js";
+import { type Framework } from "../framework/interface.js";
+export type { ChatCompletionFn, UsageInfo } from "../llm/component-response.js";
+export declare const CONJURE_TOOL_NAME = "mcp__genie__conjure";
+/** Target framework for the generated component (AC2/AC3). Re-exported from the
+ * M2-08 adapter module so the tool contract and the adapter registry share one
+ * source of truth (`framework/interface.ts#FRAMEWORKS`). */
+export declare const CONJURE_FRAMEWORKS: readonly ["react", "vue", "html"];
+export type ConjureFramework = Framework;
+/** Default framework + model routing alias (AC3). `design-default` is resolved
+ * to a concrete provider model by the configured endpoint/gateway (M2-05). */
+export declare const DEFAULT_FRAMEWORK: ConjureFramework;
+export declare const DEFAULT_MODEL = "design-default";
+/** `refUrl` bodies larger than this are warned about (AC7) and truncated before
+ * inlining, so a giant page can't blow the request's token budget. */
+export declare const REF_URL_WARN_BYTES: number;
+export type AddressLookup = (hostname: string) => Promise<readonly {
+    address: string;
+    family: number;
+}[]>;
+export declare function isSafeRefUrl(raw: string): boolean;
+/**
+ * Public boolean form of {@link resolveSafeAddress} kept for the existing
+ * test surface / any external reuse (M6-03 follow-up). A hostname is "safe"
+ * if at least one resolved address is not private/loopback/link-local.
+ */
+export declare function isSafeResolvedAddress(hostname: string, lookupAddresses?: AddressLookup): Promise<boolean>;
+/**
+ * Fetch a single URL whose hostname has already been resolved to a
+ * known-safe `address`/`family` (M6-03 follow-up, TOCTOU fix): rather than
+ * re-validating a hostname and then letting the HTTP client perform its own,
+ * second, independent DNS resolution at connect time — the exact gap an
+ * attacker-controlled DNS name (a "rebinding" host that answers safely to
+ * the guard and privately to the real connection) can exploit — this pins
+ * the *already-validated* address into the connection via undici's
+ * `Agent({ connect: { lookup } })` override, so validation and connection
+ * are guaranteed to use the identical address. Redirects are fetched with
+ * `redirect: "manual"` and returned to the caller un-followed; the caller
+ * (`safeFetchFollowingRedirects`) re-runs full validation (schema-level
+ * `isSafeRefUrl` + resolved-address check) on every redirect target before
+ * following it, so a public URL cannot use a redirect to smuggle a request to
+ * a private target past the guard.
+ */
+export declare function fetchWithPinnedAddress(url: string, address: string, family: 4 | 6, timeoutMs?: number): Promise<ReferenceFetchResponse & {
+    bodyTruncated: boolean;
+    observedBodyBytes: number;
+}>;
+declare const conjureArgsSchema: z.ZodObject<{
+    kitId: z.ZodString;
+    kit: z.ZodString;
+    prompt: z.ZodString;
+    group: z.ZodOptional<z.ZodString>;
+    refImageDataUrl: z.ZodOptional<z.ZodString>;
+    refUrl: z.ZodOptional<z.ZodString>;
+    framework: z.ZodDefault<z.ZodEnum<{
+        react: "react";
+        vue: "vue";
+        html: "html";
+    }>>;
+    model: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export type ConjureArgs = z.infer<typeof conjureArgsSchema>;
+/**
+ * What `conjure` returns (AC9): the validated component — its name, resolved
+ * group, file set, and manifest metadata — plus token `usage` for the caller's
+ * accounting. Deliberately does NOT include anything about having *written* the
+ * files: generation is pure (AC9).
+ */
+export interface ConjureResult extends Record<string, unknown> {
+    componentName: string;
+    group: string;
+    files: GeneratedFileWithEncoding[];
+    manifestEntry: ValidatedComponent["manifestEntry"];
+    usage: UsageInfo;
+}
+/** Injectable URL-fetch seam for tests (AC7). When omitted, production uses the
+ * DNS-validated, address-pinned Undici path rather than global `fetch`.
+ * `headers` is optional so existing test doubles that only stub `{ ok, status, text }`
+ * keep compiling; the redirect-following logic treats a missing `headers` on a
+ * 3xx response as "no Location to follow" and stops rather than throwing. */
+export interface ReferenceFetchResponse {
+    ok: boolean;
+    status: number;
+    headers?: {
+        get(name: string): string | null;
+    };
+    bodyTruncated?: boolean;
+    observedBodyBytes?: number;
+    text(): Promise<string>;
+}
+export type FetchFn = (url: string) => Promise<ReferenceFetchResponse>;
+export type PinnedFetchFn = typeof fetchWithPinnedAddress;
+export interface ConjureDeps {
+    chat?: ChatCompletionFn;
+    fetchImpl?: FetchFn;
+    /** Pinned socket seam for deterministic production-path tests. */
+    fetchPinnedAddress?: PinnedFetchFn;
+    /** DNS seam for deterministic SSRF tests. Production uses `dns.lookup`. */
+    lookupAddresses?: AddressLookup;
+    /** Overall DNS + redirect/fetch deadline seam. Production defaults to 30 seconds. */
+    refUrlTimeoutMs?: number;
+    /** Prompt loader override (tests). Defaults to the real versioned loader (AC5). */
+    loadSystemPrompt?: () => LoadedPrompt;
+}
+/** Typed failure surfaced to the tool boundary (mapped to an MCP error result).
+ * One code: an empty reply is just one way output can be invalid, so it folds
+ * into `ERR_LLM_OUTPUT_INVALID` rather than being its own code (Copilot review —
+ * keep the public error surface to codes this file actually throws). */
+export declare class ConjureError extends Error {
+    readonly code: "ERR_LLM_OUTPUT_INVALID";
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(code: "ERR_LLM_OUTPUT_INVALID", message: string, details?: Record<string, unknown> | undefined);
+}
+/**
+ * Truncate `text` so its UTF-8 encoding is at most `maxBytes` bytes, cutting on
+ * a codepoint boundary (Copilot review: `String.slice` cuts UTF-16 code units,
+ * so a non-ASCII page could still blow the byte cap). We encode, slice the byte
+ * buffer at the cap, then drop any trailing bytes that form a partial multi-byte
+ * sequence so the decoded result carries no U+FFFD replacement char and is
+ * guaranteed ≤ `maxBytes`.
+ */
+export declare function truncateUtf8(text: string, maxBytes: number): string;
+/**
+ * Generate one component. Pure (AC9): validates + returns, never writes.
+ *
+ * Flow: resolve args → optionally fetch `refUrl` (AC7) → run the shared
+ * request/validate/retry loop (build messages +vision AC6, call the endpoint
+ * with the json_schema response_format AC4, validate against COMPONENT_SCHEMA
+ * AC8, retry ONCE on failure) → return
+ * `{ componentName, group, files, manifestEntry, usage }` (AC9) and log a
+ * per-call line (AC10). The loop itself lives in `component-response.ts`, shared
+ * with `refine` (M2-04).
+ */
+export declare function conjure(deps: ConjureDeps, args: unknown): Promise<ConjureResult>;
+export declare function registerConjureTool(server: McpServer, deps?: ConjureDeps): void;
+//# sourceMappingURL=conjure.d.ts.map

package/dist/tools/conjure.d.ts.map

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