@bridge_gpt/mcp-server 0.2.60 → 0.2.65

package/build/epic-coherence-input-cli.js

@@ -0,0 +1,137 @@
+/**
+ * BAPI-1320: thin CLI handler for the `epic-coherence-input` subcommand.
+ *
+ * The coherence procedure ships to consumer repositories, where
+ * `mcp_server/src/` does not exist, so authors who draft an epic as local
+ * markdown files reach the builder through this packaged subcommand. It holds
+ * no policy of its own: it parses argv, delegates to `epic-coherence-input.ts`,
+ * and prints exactly one JSON envelope on stdout. Diagnostics go only to the
+ * injected stderr logger. It never starts the MCP server.
+ */
+import { buildEpicCoherenceInput, checkEpicCoherenceInput, } from "./epic-coherence-input.js";
+const USAGE = [
+    "Usage: epic-coherence-input build --outline <path> --out <path>",
+    "       epic-coherence-input check <path>",
+    "",
+    "  build   Build epic-coherence-input.json from an outline and local markdown",
+    "          drafts, validate it, and print its three digests. Writes nothing",
+    "          when parsing or validation fails.",
+    "  check   Structurally validate an existing input document and print its",
+    "          three digests. Never judges coverage. Writes nothing.",
+    "",
+    "Every path is repository-relative to the current directory.",
+    "  -h, --help   Show this help.",
+].join("\n");
+/** Parse argv into the help / error / ok shape. Never throws. */
+export function parseEpicCoherenceInputArgs(argv) {
+    const mode = argv[0];
+    if (mode === undefined || mode === "-h" || mode === "--help")
+        return { kind: "help" };
+    if (argv.includes("-h") || argv.includes("--help"))
+        return { kind: "help" };
+    if (mode === "check") {
+        const rest = argv.slice(1);
+        if (rest.length !== 1 || rest[0].startsWith("-")) {
+            return { kind: "error", message: "check takes exactly one input path." };
+        }
+        return { kind: "ok", options: { mode: "check", input: rest[0] } };
+    }
+    if (mode === "build") {
+        let outline;
+        let out;
+        for (let i = 1; i < argv.length; i++) {
+            const arg = argv[i];
+            const value = argv[i + 1];
+            if (arg === "--outline" || arg === "--out") {
+                if (value === undefined || value.startsWith("-")) {
+                    return { kind: "error", message: `Flag "${arg}" requires a value.` };
+                }
+                if (arg === "--outline")
+                    outline = value;
+                else
+                    out = value;
+                i++;
+                continue;
+            }
+            return { kind: "error", message: `Unknown argument "${arg}".` };
+        }
+        if (!outline)
+            return { kind: "error", message: 'Flag "--outline" is required.' };
+        if (!out)
+            return { kind: "error", message: 'Flag "--out" is required.' };
+        return { kind: "ok", options: { mode: "build", outline, out } };
+    }
+    return { kind: "error", message: `Unknown mode "${mode}". Expected "build" or "check".` };
+}
+/**
+ * Run the `epic-coherence-input` subcommand. Returns 0 or 1 and never throws:
+ * every handled invocation prints exactly one JSON envelope on stdout.
+ */
+export async function runEpicCoherenceInputCli(argv, overrides = {}) {
+    const deps = {
+        env: process.env,
+        cwd: process.cwd(),
+        fs: createDefaultFs(),
+        log: (m) => process.stdout.write(`${m}\n`),
+        errorLog: (m) => process.stderr.write(`${m}\n`),
+        ...overrides,
+    };
+    const emitFailure = (error, errors) => {
+        deps.log(JSON.stringify({ ok: false, error, errors }));
+        deps.errorLog(`Error: ${error}`);
+        for (const detail of errors)
+            deps.errorLog(`  - ${detail}`);
+        return 1;
+    };
+    const parsed = parseEpicCoherenceInputArgs(argv);
+    if (parsed.kind === "help") {
+        deps.errorLog(USAGE);
+        deps.log(JSON.stringify({ ok: true, usage: USAGE }));
+        return 0;
+    }
+    if (parsed.kind === "error") {
+        deps.errorLog(USAGE);
+        return emitFailure(parsed.message, [parsed.message]);
+    }
+    const builderDeps = { cwd: deps.cwd, fs: deps.fs };
+    try {
+        if (parsed.options.mode === "build") {
+            const result = await buildEpicCoherenceInput({ outlinePath: parsed.options.outline, outPath: parsed.options.out }, builderDeps);
+            for (const warning of result.warnings)
+                deps.errorLog(`Warning: ${warning}`);
+            if (!result.ok) {
+                return emitFailure("build failed; nothing was written.", result.errors);
+            }
+            deps.log(JSON.stringify({
+                ok: true,
+                output_path: result.value.output_path,
+                digests: result.value.digests,
+                warnings: result.warnings,
+            }));
+            return 0;
+        }
+        const result = await checkEpicCoherenceInput(parsed.options.input, builderDeps);
+        if (!result.ok) {
+            return emitFailure("check failed: the input document is missing, unreadable, or not structurally valid.", result.errors);
+        }
+        deps.log(JSON.stringify({ ok: true, digests: result.value.digests, warnings: result.warnings }));
+        return 0;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return emitFailure(`unexpected failure: ${message}`, [message]);
+    }
+}
+/** Real filesystem seam, loaded lazily so importing this module stays cheap. */
+function createDefaultFs() {
+    return {
+        readFile: async (p) => (await import("node:fs/promises")).readFile(p, "utf-8"),
+        writeFile: async (p, data) => (await import("node:fs/promises")).writeFile(p, data, "utf-8"),
+        rename: async (from, to) => (await import("node:fs/promises")).rename(from, to),
+        unlink: async (p) => (await import("node:fs/promises")).unlink(p),
+        realpath: async (p) => (await import("node:fs/promises")).realpath(p),
+        mkdir: async (p) => {
+            await (await import("node:fs/promises")).mkdir(p, { recursive: true });
+        },
+    };
+}