@astrosheep/keiyaku 0.1.0

package/build/index.js

@@ -0,0 +1,423 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { handleKeiyaku, handleAsk, handleDrive, invokeJudgment, resolveJudgmentOath, } from "./logic.js";
+import * as git from "./git.js";
+import { isSubagentExecError } from "./subagent-exec/index.js";
+import { appendDebugLog } from "./debug-log.js";
+import { asMessage, isFlowError, pickHintFromError } from "./errors.js";
+import { buildKeiyakuSuccessResponse, buildAskResponse, buildDriveResponse, buildToolErrorResponse, buildJudgmentDoneResponse, buildJudgmentDropResponse, } from "./response-builders.js";
+import { askToolSchema, issueKeiyakuToolSchema, driveKeiyakuToolSchema, judgmentToolSchema, cliHelpToolSchema, } from "./tool-schemas.js";
+import { listTermPresets, resolveTermPreset } from "./term-presets.js";
+function classifyToolError(error) {
+    if (isFlowError(error)) {
+        return { errorType: "keiyaku_error", errorCode: error.code };
+    }
+    if (isSubagentExecError(error)) {
+        return { errorType: "subagent_exec_error", errorCode: error.code };
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+        return { errorType: "abort_error", errorCode: "ABORTED" };
+    }
+    return { errorType: "runtime_error", errorCode: "INTERNAL_ERROR" };
+}
+function formatCriteria(criteria) {
+    return criteria.map((item) => `- ${item}`).join("\n");
+}
+function registerTools(server) {
+    const preset = resolveTermPreset();
+    const summonPreset = preset.tools.summon;
+    const drivePreset = preset.tools.drive;
+    const askPreset = preset.tools.ask;
+    const judgmentPreset = preset.tools.judgment;
+    const helpPreset = preset.tools.help;
+    const presetIdentities = listTermPresets()
+        .map((item) => `${item.id}=${item.identity}`)
+        .join(", ");
+    const currentOath = resolveJudgmentOath();
+    const dynamicJudgmentSchema = judgmentToolSchema.extend({
+        oath: judgmentToolSchema.shape.oath.describe(judgmentToolSchema.shape.oath.description.replace("${OATH_TEXT}", `'${currentOath}'`)),
+    });
+    const dynamicIssueSchema = issueKeiyakuToolSchema.extend({
+        subagentName: issueKeiyakuToolSchema.shape.subagentName.describe(issueKeiyakuToolSchema.shape.subagentName.description
+            .replace("${IDENTITY}", preset.identity)
+            .replace("${PRESET_IDENTITIES}", presetIdentities)),
+    });
+    const dynamicDriveSchema = driveKeiyakuToolSchema.extend({
+        subagentName: driveKeiyakuToolSchema.shape.subagentName.describe(driveKeiyakuToolSchema.shape.subagentName.description
+            .replace("${IDENTITY}", preset.identity)
+            .replace("${PRESET_IDENTITIES}", presetIdentities)),
+    });
+    const dynamicAskSchema = askToolSchema.extend({
+        subagentName: askToolSchema.shape.subagentName.describe(askToolSchema.shape.subagentName.description
+            .replace("${IDENTITY}", preset.identity)
+            .replace("${PRESET_IDENTITIES}", presetIdentities)),
+    });
+    server.registerTool(summonPreset.name, {
+        title: summonPreset.title,
+        description: summonPreset.description,
+        inputSchema: dynamicIssueSchema,
+    }, async ({ title, goal, directive, context, constraints, criteria, subagentName, cwd }, extra) => {
+        const workingDir = cwd || process.cwd();
+        try {
+            appendDebugLog(`tool summon start cwd=${workingDir}`, { cwd: workingDir, section: "script" });
+            const finalContext = context?.trim() || "No additional context provided.";
+            const result = await handleKeiyaku({
+                cwd: workingDir,
+                title,
+                goal,
+                directive,
+                context: finalContext,
+                criteria: formatCriteria(criteria),
+                constraints,
+                subagentName,
+                signal: extra.signal,
+            });
+            appendDebugLog(`tool summon success branch=${result.branch} base=${result.baseBranch} round=${result.round}`, {
+                cwd: workingDir,
+                section: "script",
+            });
+            const { identity } = resolveTermPreset();
+            return buildKeiyakuSuccessResponse(result, {
+                title,
+                goal,
+                directive,
+                context,
+                constraints,
+                criteria,
+                subagentName,
+                cwd: workingDir,
+            });
+        }
+        catch (err) {
+            const message = asMessage(err);
+            appendDebugLog(`tool summon error: ${message}`, { cwd: workingDir, section: "script" });
+            const hint = pickHintFromError(err, message);
+            const { errorType, errorCode } = classifyToolError(err);
+            const { identity } = resolveTermPreset();
+            return buildToolErrorResponse({
+                tool: "summon",
+                title: "Keiyaku",
+                message,
+                hint,
+                errorType,
+                errorCode,
+                inputEcho: [
+                    "Inputs:",
+                    `Title: ${title}`,
+                    `Goal: ${goal}`,
+                    ...(directive ? [`Directive: ${directive}`] : []),
+                    `Criteria (${criteria.length}): ${criteria.join("; ")}`,
+                    ...(context ? [`Context: ${context}`] : []),
+                    ...(constraints ? [`Constraints: ${constraints}`] : []),
+                    ...(subagentName ? [`${identity}: ${subagentName}`] : []),
+                    `CWD: ${workingDir}`,
+                ],
+            });
+        }
+    });
+    server.registerTool(drivePreset.name, {
+        title: drivePreset.title,
+        description: drivePreset.description,
+        inputSchema: dynamicDriveSchema,
+    }, async ({ directive, context, subagentName, cwd }, extra) => {
+        const workingDir = cwd || process.cwd();
+        try {
+            appendDebugLog(`tool drive start cwd=${workingDir}`, {
+                cwd: workingDir,
+                section: "script",
+            });
+            const outcome = await handleDrive({
+                cwd: workingDir,
+                directive,
+                context,
+                subagentName,
+                signal: extra.signal,
+            });
+            appendDebugLog(`tool drive success round=${outcome.round}`, {
+                cwd: workingDir,
+                section: "script",
+            });
+            return buildDriveResponse(outcome, { directive, context, subagentName, cwd: workingDir });
+        }
+        catch (err) {
+            const message = asMessage(err);
+            appendDebugLog(`tool drive error: ${message}`, { cwd: workingDir, section: "script" });
+            const hint = pickHintFromError(err, message);
+            const { errorType, errorCode } = classifyToolError(err);
+            const { identity } = resolveTermPreset();
+            return buildToolErrorResponse({
+                tool: "drive",
+                title: "Drive",
+                message,
+                hint,
+                errorType,
+                errorCode,
+                inputEcho: [
+                    "Inputs:",
+                    `Directive: ${directive}`,
+                    ...(context ? [`Context: ${context}`] : []),
+                    ...(subagentName ? [`${identity}: ${subagentName}`] : []),
+                    `CWD: ${workingDir}`,
+                ],
+            });
+        }
+    });
+    server.registerTool(askPreset.name, {
+        title: askPreset.title,
+        description: askPreset.description,
+        inputSchema: dynamicAskSchema,
+    }, async ({ request, context, subagentName, cwd }, extra) => {
+        const workingDir = cwd || process.cwd();
+        try {
+            appendDebugLog(`tool ask start cwd=${workingDir}`, { cwd: workingDir, section: "script" });
+            const result = await handleAsk({
+                cwd: workingDir,
+                request,
+                context,
+                subagentName,
+                signal: extra.signal,
+            });
+            appendDebugLog(`tool ask success`, { cwd: workingDir, section: "script" });
+            return buildAskResponse(result, { request, context, subagentName, cwd: workingDir });
+        }
+        catch (err) {
+            const message = asMessage(err);
+            appendDebugLog(`tool ask error: ${message}`, { cwd: workingDir, section: "script" });
+            const hint = pickHintFromError(err, message);
+            const { errorType, errorCode } = classifyToolError(err);
+            const { identity } = resolveTermPreset();
+            return buildToolErrorResponse({
+                tool: "ask",
+                title: "Ask",
+                message,
+                hint,
+                errorType,
+                errorCode,
+                inputEcho: [
+                    "Inputs:",
+                    `Request: ${request}`,
+                    `Context: ${context}`,
+                    ...(subagentName ? [`${identity}: ${subagentName}`] : []),
+                    `CWD: ${workingDir}`,
+                ],
+            });
+        }
+    });
+    server.registerTool(judgmentPreset.name, {
+        title: judgmentPreset.title,
+        description: judgmentPreset.description,
+        inputSchema: dynamicJudgmentSchema,
+    }, async ({ intent, criteriaChecks, metPrecise, metMinimal, metIsolated, metIdiomatic, metCohesive, oath, cwd }, extra) => {
+        const workingDir = cwd || process.cwd();
+        const criteriaCheckParts = criteriaChecks;
+        try {
+            appendDebugLog(`tool judgment start intent=${intent} cwd=${workingDir} criteriaChecks=${criteriaCheckParts.length}`, {
+                cwd: workingDir,
+                section: "script",
+            });
+            const outcome = await invokeJudgment({
+                cwd: workingDir,
+                intent,
+                criteriaChecks: criteriaCheckParts,
+                metPrecise,
+                metMinimal,
+                metIsolated,
+                metIdiomatic,
+                metCohesive,
+                oath,
+                signal: extra.signal,
+            });
+            if (intent === "INVOKE") {
+                if (!("status" in outcome) || outcome.status !== "done") {
+                    throw new Error("Unexpected INVOKE outcome shape");
+                }
+                const finalOutcome = outcome;
+                appendDebugLog(`tool judgment INVOKE success branch=${finalOutcome.branch} base=${finalOutcome.baseBranch}`, {
+                    cwd: workingDir,
+                    section: "script",
+                });
+                return buildJudgmentDoneResponse(finalOutcome, {
+                    criteriaChecks: criteriaCheckParts,
+                    metPrecise,
+                    metMinimal,
+                    metIsolated,
+                    metIdiomatic,
+                    metCohesive,
+                    oath,
+                    cwd: workingDir,
+                });
+            }
+            if (!("status" in outcome) || outcome.status !== "dropped") {
+                throw new Error("Unexpected DROP outcome shape");
+            }
+            const finalOutcome = outcome;
+            appendDebugLog(`tool judgment DROP success branch=${finalOutcome.branch} base=${finalOutcome.baseBranch}`, {
+                cwd: workingDir,
+                section: "script",
+            });
+            return buildJudgmentDropResponse(finalOutcome, {
+                criteriaChecks: criteriaCheckParts,
+                metPrecise,
+                metMinimal,
+                metIsolated,
+                metIdiomatic,
+                metCohesive,
+                oath,
+                cwd: workingDir,
+            });
+        }
+        catch (err) {
+            const message = asMessage(err);
+            appendDebugLog(`tool judgment error: ${message}`, { cwd: workingDir, section: "script" });
+            const hint = pickHintFromError(err, message);
+            const { errorType, errorCode } = classifyToolError(err);
+            return buildToolErrorResponse({
+                tool: "invoke_judgment",
+                title: "Invoke Judgment",
+                message,
+                hint,
+                errorType,
+                errorCode,
+                inputEcho: [
+                    "Inputs:",
+                    `Intent: ${intent}`,
+                    `Criteria checks (${criteriaCheckParts.length}): ${criteriaCheckParts.join("; ")}`,
+                    `Quality flags: metPrecise=${metPrecise} metMinimal=${metMinimal} metIsolated=${metIsolated} metIdiomatic=${metIdiomatic} metCohesive=${metCohesive}`,
+                    ...(oath ? [`Oath: ${oath}`] : []),
+                    `CWD: ${workingDir}`,
+                ],
+            });
+        }
+    });
+    server.registerTool(helpPreset.name, {
+        title: helpPreset.title,
+        description: helpPreset.description,
+        inputSchema: cliHelpToolSchema,
+    }, async ({ question }) => {
+        const workingDir = process.cwd();
+        let branchState = "Unknown";
+        try {
+            const currentBranch = await git.getCurrentBranch(workingDir);
+            const activeKeiyaku = await git.getActiveKeiyakuBranch(workingDir);
+            if (activeKeiyaku) {
+                const base = await git.getKeiyakuBase(workingDir, activeKeiyaku);
+                branchState = `Active Keiyaku: ${activeKeiyaku}\n  Base Branch: ${base || "unknown"}`;
+            }
+            else {
+                branchState = `No active keiyaku. Current branch: ${currentBranch}`;
+            }
+        }
+        catch {
+            branchState = "Not a git repository or git error.";
+        }
+        const helpContent = [
+            "# Keiyaku System Help",
+            "",
+            "## Current State",
+            branchState,
+            "",
+            "## Core Files (.keiyaku/)",
+            "These files define the 'Law' of the project. **CRITICAL**: Use Markdown lists (`- item`).",
+            "",
+            "- **base-criteria.md**: Universal standards for task completion. Automatically inherited.",
+            "- **base-constraints.md**: Mandatory architectural boundaries and coding standards.",
+            "",
+            "## Workflow",
+            "1. `summon`: Start a new keiyaku (creates branch, begins round 1).",
+            "2. `drive`: Provide feedback or new instructions for the next round.",
+            "3. `invoke_judgment`: Express intent (INVOKE/DROP) to merge or discard changes.",
+            "",
+            "## Protocol Files (Pact Roots)",
+            "- **KEIYAKU.md**: The immutable mission definition for the current task.",
+            "- **KEIYAKU_TRACE.md**: The audit log of all rounds and reviews.",
+            "",
+            `Regarding: "${question}"`,
+        ].join("\n");
+        return {
+            content: [{ type: "text", text: helpContent }],
+            structuredContent: { ok: true, tool: "cli_help", status: "completed" },
+        };
+    });
+}
+function createServer() {
+    const server = new McpServer({
+        name: "keiyaku",
+        version: "1.0.0",
+    });
+    registerTools(server);
+    return server;
+}
+function sendJsonRpcError(res, code, message) {
+    const body = JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code, message },
+        id: null,
+    });
+    res.writeHead(code === -32603 ? 500 : 405, { "content-type": "application/json" });
+    res.end(body);
+}
+async function startStdio() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Keiyaku MCP Server running on stdio");
+}
+async function startStreamableHttp() {
+    const host = process.env.KEIYAKU_MCP_HTTP_HOST || "127.0.0.1";
+    const portRaw = process.env.KEIYAKU_MCP_HTTP_PORT || "3000";
+    const port = Number(portRaw);
+    if (!Number.isFinite(port) || port <= 0) {
+        throw new Error(`invalid KEIYAKU_MCP_HTTP_PORT: ${portRaw}`);
+    }
+    const app = createMcpExpressApp({ host });
+    app.post("/mcp", async (req, res) => {
+        const server = createServer();
+        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+        try {
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            console.error("Error handling MCP Streamable HTTP request:", error);
+            if (!res.headersSent) {
+                sendJsonRpcError(res, -32603, "Internal server error");
+            }
+        }
+        finally {
+            await transport.close().catch(() => undefined);
+            await server.close().catch(() => undefined);
+        }
+    });
+    app.get("/mcp", (_req, res) => {
+        sendJsonRpcError(res, -32000, "Method not allowed.");
+    });
+    app.delete("/mcp", (_req, res) => {
+        sendJsonRpcError(res, -32000, "Method not allowed.");
+    });
+    await new Promise((resolve, reject) => {
+        const listener = app.listen(port, host, () => {
+            console.error(`Keiyaku MCP Server running on streamable-http http://${host}:${port}/mcp`);
+            resolve();
+        });
+        listener.on("error", reject);
+    });
+}
+async function main() {
+    const transport = (process.env.KEIYAKU_MCP_TRANSPORT || "stdio").toLowerCase();
+    if (transport === "streamable-http") {
+        await startStreamableHttp();
+        return;
+    }
+    if (transport === "stdio") {
+        await startStdio();
+        return;
+    }
+    throw new Error(`Unsupported KEIYAKU_MCP_TRANSPORT '${transport}'. Expected 'stdio' or 'streamable-http'.`);
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});