auditor-lambda 0.3.30 → 0.3.33

package/dist/mcp/server.js

@@ -69,7 +69,7 @@ function failure(id, code, message, data) {
         },
     };
 }
-function parseContentLength(headerBlock) {
+export function parseContentLength(headerBlock) {
     const headers = headerBlock.split("\r\n");
     const contentLengthHeader = headers.find((header) => header.toLowerCase().startsWith("content-length:"));
     if (!contentLengthHeader) {
@@ -186,95 +186,127 @@ function toolResult(value) {
         structuredContent: value && typeof value === "object" ? value : { value },
     };
 }
-async function readResource(uri, context) {
-    switch (uri) {
-        case "audit-code://artifacts/current": {
+export const resourceRegistry = [
+    {
+        uri: "audit-code://artifacts/current",
+        name: "current_artifacts",
+        description: "Current artifact bundle as JSON.",
+        mimeType: "application/json",
+        async read(context) {
             const bundle = await loadArtifactBundle(context.artifactsDir);
-            return {
-                mimeType: "application/json",
-                text: JSON.stringify(bundle),
-            };
-        }
-        case "audit-code://handoff/current": {
+            return { mimeType: this.mimeType, text: JSON.stringify(bundle) };
+        },
+    },
+    {
+        uri: "audit-code://handoff/current",
+        name: "operator_handoff",
+        description: "Current operator handoff payload as JSON.",
+        mimeType: "application/json",
+        async read(context) {
             const status = (await getStatusPayload(context)).handoff;
-            return {
-                mimeType: "application/json",
-                text: JSON.stringify(status),
-            };
-        }
-        case "audit-code://install/guide": {
+            return { mimeType: this.mimeType, text: JSON.stringify(status) };
+        },
+    },
+    {
+        uri: "audit-code://install/guide",
+        name: "install_guide",
+        description: "Repo-local install guide for supported IDE hosts.",
+        mimeType: "text/markdown",
+        async read(context) {
             const path = join(context.root, ".audit-code", "install", "GETTING-STARTED.md");
             const guide = (await readOptionalTextFile(path)) ??
                 "Run `audit-code install` from the repository root to generate the repo-local setup guide.";
-            return {
-                mimeType: "text/markdown",
-                text: guide,
-            };
-        }
-        case "audit-code://report/current": {
+            return { mimeType: this.mimeType, text: guide };
+        },
+    },
+    {
+        uri: "audit-code://report/current",
+        name: "audit_report",
+        description: "Current deterministic audit report if available.",
+        mimeType: "text/markdown",
+        async read(context) {
             const report = (await readOptionalTextFile(join(context.artifactsDir, "audit-report.md"))) ??
                 (await readOptionalTextFile(join(context.root, "audit-report.md"))) ??
                 "The audit report has not been rendered yet.";
-            return {
-                mimeType: "text/markdown",
-                text: report,
-            };
-        }
-        default:
-            throw new Error(`Unknown resource URI: ${uri}`);
+            return { mimeType: this.mimeType, text: report };
+        },
+    },
+];
+async function readResource(uri, context) {
+    const entry = resourceRegistry.find((r) => r.uri === uri);
+    if (!entry) {
+        throw new Error(`Unknown resource URI: ${uri}`);
     }
+    return entry.read(context);
 }
-function promptDefinitions() {
-    return [
-        {
-            name: "audit-code",
-            description: "Start or continue the autonomous audit loop through the auditor MCP tools.",
-            arguments: [],
-        },
-        {
-            name: "review-task",
-            description: "Inspect one audit task with explain_task and the current artifacts before reviewing code.",
-            arguments: [
-                {
-                    name: "task_id",
-                    required: true,
-                    description: "Audit task id to inspect.",
-                },
-            ],
-        },
-        {
-            name: "synthesize-report",
-            description: "Read the current audit report resource and summarize the highest-signal findings.",
-            arguments: [],
-        },
-    ];
+function resourceListPayload() {
+    return resourceRegistry.map((entry) => ({
+        uri: entry.uri,
+        name: entry.name,
+        description: entry.description,
+        mimeType: entry.mimeType,
+    }));
 }
-function renderPrompt(name, args) {
-    switch (name) {
-        case "audit-code":
+export const promptRegistry = [
+    {
+        name: "audit-code",
+        description: "Start or continue the autonomous audit loop through the next-step machine.",
+        arguments: [],
+        render() {
             return [
-                "Use the auditor MCP tools as the primary interface to the backend wrapper.",
-                "1. Call `start_audit`.",
-                "2. If the audit is blocked, inspect `audit-code://handoff/current`.",
+                "Use `audit-code next-step` as the canonical interface to the backend wrapper.",
+                "1. Prefer running `audit-code next-step` directly from the repository root.",
+                "2. If this MCP adapter is your only available integration, call `start_audit` or `continue_audit`; both return the same one-step contract.",
+                "3. If the audit is blocked, inspect `audit-code://handoff/current`.",
                 "   Do not read `audit-code://artifacts/current` unless explicitly needed for a specific task; it is massive and consumes your context window.",
-                "3. When the user provides additional evidence, call `import_results` or `import_runtime_updates`.",
-                "4. Call `continue_audit` until the status is complete or explicitly blocked for operator input.",
+                "4. When the user provides additional evidence, call `import_results` or `import_runtime_updates`.",
             ].join("\n");
-        case "review-task":
+        },
+    },
+    {
+        name: "review-task",
+        description: "Inspect one audit task with explain_task and the current artifacts before reviewing code.",
+        arguments: [
+            {
+                name: "task_id",
+                required: true,
+                description: "Audit task id to inspect.",
+            },
+        ],
+        render(args) {
             return [
                 `Use \`explain_task\` for task \`${String(args?.task_id ?? "")}\` before you inspect code manually.`,
                 "Do not read the full `audit-code://artifacts/current` bundle unless specifically needed, as it is massive.",
             ].join("\n");
-        case "synthesize-report":
+        },
+    },
+    {
+        name: "synthesize-report",
+        description: "Read the current audit report resource and summarize the highest-signal findings.",
+        arguments: [],
+        render() {
             return [
                 "Read `audit-code://report/current`.",
                 "Summarize the final audit report as work blocks first, then highlight the most important risks and remediation priorities.",
             ].join("\n");
-        default:
-            throw new Error(`Unknown prompt: ${name}`);
+        },
+    },
+];
+function promptDefinitions() {
+    return promptRegistry.map((entry) => ({
+        name: entry.name,
+        description: entry.description,
+        arguments: entry.arguments,
+    }));
+}
+function renderPrompt(name, args) {
+    const entry = promptRegistry.find((p) => p.name === name);
+    if (!entry) {
+        throw new Error(`Unknown prompt: ${name}`);
     }
+    return entry.render(args);
 }
-async function runContinueAudit(context, extraArgs = []) {
+async function runContinueAudit(context, extraArgs = ["next-step"]) {
     const step = await parseCliJson(extraArgs, context);
     if (!step || typeof step !== "object" || Array.isArray(step))
         return step;
@@ -378,7 +410,7 @@ function toolDefinitions() {
     return [
         {
             name: "start_audit",
-            description: "Start the audit wrapper and advance until completion or blocked operator handoff.",
+            description: "Compatibility adapter over audit-code next-step; returns one step contract.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -406,7 +438,7 @@ function toolDefinitions() {
         },
         {
             name: "continue_audit",
-            description: "Continue the audit wrapper from the current artifacts directory.",
+            description: "Compatibility adapter over audit-code next-step from the current artifacts directory.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -510,7 +542,7 @@ function toolDefinitions() {
         },
         {
             name: "report_capability",
-            description: "Report host subagent dispatch capability and advance to the next step. Call this instead of running audit-code next-step from the shell during a capability_check step.",
+            description: "Compatibility adapter that calls audit-code next-step with host subagent capability flags.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -542,6 +574,153 @@ function toolDefinitions() {
         },
     ];
 }
+/**
+ * Extract zero or more complete Content-Length framed messages from a buffer.
+ * Returns an array of parsed body strings and the remaining unconsumed buffer.
+ * On framing errors, emits a framing error response via `emit` and resets the buffer.
+ */
+export function extractFrames(buffer, emit) {
+    const bodies = [];
+    let current = buffer;
+    while (true) {
+        const separator = current.indexOf("\r\n\r\n");
+        if (separator < 0) {
+            break;
+        }
+        let contentLength;
+        try {
+            const headerBlock = current.slice(0, separator).toString("utf8");
+            contentLength = parseContentLength(headerBlock);
+        }
+        catch (error) {
+            current = Buffer.alloc(0);
+            emit(failure(null, -32700, `Invalid MCP framing: ${error instanceof Error ? error.message : String(error)}.`));
+            break;
+        }
+        const frameLength = separator + 4 + contentLength;
+        if (current.length < frameLength) {
+            break;
+        }
+        bodies.push(current.slice(separator + 4, frameLength).toString("utf8"));
+        current = current.slice(frameLength);
+    }
+    return { bodies, remaining: current };
+}
+/**
+ * Dispatch a single JSON-RPC request and return the response(s) to send,
+ * plus updated shutdown state.
+ */
+export async function dispatchRequest(request, ctx) {
+    const responses = [];
+    let { shutdownRequested } = ctx;
+    if (!request.method) {
+        responses.push(failure(request.id ?? null, -32600, "Missing method."));
+        return { responses, shutdownRequested };
+    }
+    try {
+        switch (request.method) {
+            case "initialize": {
+                const requestedVersion = typeof request.params?.protocolVersion === "string"
+                    ? request.params.protocolVersion
+                    : PROTOCOL_VERSION;
+                const negotiatedVersion = requestedVersion <= PROTOCOL_VERSION
+                    ? requestedVersion
+                    : PROTOCOL_VERSION;
+                responses.push(success(request.id ?? null, {
+                    protocolVersion: negotiatedVersion,
+                    serverInfo: {
+                        name: "audit-code",
+                        version: ctx.version,
+                    },
+                    instructions: "Use audit-code next-step as the primary backend loop. These MCP tools are compatibility adapters that return the same one-step contract.",
+                    capabilities: {
+                        tools: { listChanged: false },
+                        resources: { subscribe: false, listChanged: false },
+                        prompts: { listChanged: false },
+                    },
+                }));
+                break;
+            }
+            case "notifications/initialized":
+                break;
+            case "ping":
+                if (request.id !== undefined) {
+                    responses.push(success(request.id, {}));
+                }
+                break;
+            case "tools/list":
+                responses.push(success(request.id ?? null, { tools: toolDefinitions() }));
+                break;
+            case "tools/call": {
+                const params = parseObject(request.params);
+                const toolName = params.name;
+                if (!hasValue(toolName)) {
+                    throw new Error("tools/call requires a tool name.");
+                }
+                responses.push(success(request.id ?? null, await handleToolCall(toolName, parseObject(params.arguments), ctx.defaults)));
+                break;
+            }
+            case "resources/list":
+                responses.push(success(request.id ?? null, {
+                    resources: resourceListPayload(),
+                }));
+                break;
+            case "resources/read": {
+                const params = parseObject(request.params);
+                if (!hasValue(params.uri)) {
+                    throw new Error("resources/read requires uri.");
+                }
+                const resource = await readResource(params.uri, ctx.defaults);
+                responses.push(success(request.id ?? null, {
+                    contents: [
+                        {
+                            uri: params.uri,
+                            mimeType: resource.mimeType,
+                            text: resource.text,
+                        },
+                    ],
+                }));
+                break;
+            }
+            case "prompts/list":
+                responses.push(success(request.id ?? null, {
+                    prompts: promptDefinitions(),
+                }));
+                break;
+            case "prompts/get": {
+                const params = parseObject(request.params);
+                if (!hasValue(params.name)) {
+                    throw new Error("prompts/get requires name.");
+                }
+                responses.push(success(request.id ?? null, {
+                    description: promptDefinitions().find((prompt) => prompt.name === params.name)?.description,
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: renderPrompt(params.name, parseObject(params.arguments)),
+                            },
+                        },
+                    ],
+                }));
+                break;
+            }
+            case "shutdown":
+                shutdownRequested = true;
+                responses.push(success(request.id ?? null, {}));
+                break;
+            case "exit":
+                return { responses, shutdownRequested, exit: shutdownRequested ? 0 : 1 };
+            default:
+                responses.push(failure(request.id ?? null, -32601, `Unknown method: ${request.method}`));
+        }
+    }
+    catch (error) {
+        responses.push(failure(request.id ?? null, -32000, error instanceof Error ? error.message : String(error)));
+    }
+    return { responses, shutdownRequested };
+}
 export async function runAuditCodeMcpServer(argv) {
     const defaults = parseServerOptions(argv);
     const version = await packageVersion();
@@ -549,29 +728,9 @@ export async function runAuditCodeMcpServer(argv) {
     let buffer = Buffer.alloc(0);
     process.stdin.on("data", async (chunk) => {
         buffer = Buffer.concat([buffer, chunk]);
-        while (true) {
-            const separator = buffer.indexOf("\r\n\r\n");
-            if (separator < 0) {
-                return;
-            }
-            let contentLength;
-            try {
-                const headerBlock = buffer.slice(0, separator).toString("utf8");
-                contentLength = parseContentLength(headerBlock);
-            }
-            catch (error) {
-                buffer = Buffer.alloc(0);
-                writeMessage(failure(null, -32700, `Invalid MCP framing: ${error instanceof Error ? error.message : String(error)}.`));
-                return;
-            }
-            const frameLength = separator + 4 + contentLength;
-            if (buffer.length < frameLength) {
-                return;
-            }
-            const body = buffer
-                .slice(separator + 4, frameLength)
-                .toString("utf8");
-            buffer = buffer.slice(frameLength);
+        const { bodies, remaining } = extractFrames(buffer, writeMessage);
+        buffer = remaining;
+        for (const body of bodies) {
             let request;
             try {
                 request = JSON.parse(body);
@@ -580,137 +739,17 @@ export async function runAuditCodeMcpServer(argv) {
                 writeMessage(failure(null, -32700, "Invalid JSON-RPC payload.", error instanceof Error ? error.message : String(error)));
                 continue;
             }
-            if (!request.method) {
-                writeMessage(failure(request.id ?? null, -32600, "Missing method."));
-                continue;
-            }
-            try {
-                switch (request.method) {
-                    case "initialize": {
-                        const requestedVersion = typeof request.params?.protocolVersion === "string"
-                            ? request.params.protocolVersion
-                            : PROTOCOL_VERSION;
-                        const negotiatedVersion = requestedVersion <= PROTOCOL_VERSION
-                            ? requestedVersion
-                            : PROTOCOL_VERSION;
-                        writeMessage(success(request.id ?? null, {
-                            protocolVersion: negotiatedVersion,
-                            serverInfo: {
-                                name: "audit-code",
-                                version,
-                            },
-                            instructions: "Use the audit-code MCP tools as the primary interface to the backend wrapper. Prefer start_audit, get_status, continue_audit, and the audit-code resources over ad hoc shell commands.",
-                            capabilities: {
-                                tools: { listChanged: false },
-                                resources: { subscribe: false, listChanged: false },
-                                prompts: { listChanged: false },
-                            },
-                        }));
-                        break;
-                    }
-                    case "notifications/initialized":
-                        break;
-                    case "ping":
-                        if (request.id !== undefined) {
-                            writeMessage(success(request.id, {}));
-                        }
-                        break;
-                    case "tools/list":
-                        writeMessage(success(request.id ?? null, { tools: toolDefinitions() }));
-                        break;
-                    case "tools/call": {
-                        const params = parseObject(request.params);
-                        const toolName = params.name;
-                        if (!hasValue(toolName)) {
-                            throw new Error("tools/call requires a tool name.");
-                        }
-                        writeMessage(success(request.id ?? null, await handleToolCall(toolName, parseObject(params.arguments), defaults)));
-                        break;
-                    }
-                    case "resources/list":
-                        writeMessage(success(request.id ?? null, {
-                            resources: [
-                                {
-                                    uri: "audit-code://artifacts/current",
-                                    name: "current_artifacts",
-                                    description: "Current artifact bundle as JSON.",
-                                    mimeType: "application/json",
-                                },
-                                {
-                                    uri: "audit-code://handoff/current",
-                                    name: "operator_handoff",
-                                    description: "Current operator handoff payload as JSON.",
-                                    mimeType: "application/json",
-                                },
-                                {
-                                    uri: "audit-code://install/guide",
-                                    name: "install_guide",
-                                    description: "Repo-local install guide for supported IDE hosts.",
-                                    mimeType: "text/markdown",
-                                },
-                                {
-                                    uri: "audit-code://report/current",
-                                    name: "audit_report",
-                                    description: "Current deterministic audit report if available.",
-                                    mimeType: "text/markdown",
-                                },
-                            ],
-                        }));
-                        break;
-                    case "resources/read": {
-                        const params = parseObject(request.params);
-                        if (!hasValue(params.uri)) {
-                            throw new Error("resources/read requires uri.");
-                        }
-                        const resource = await readResource(params.uri, defaults);
-                        writeMessage(success(request.id ?? null, {
-                            contents: [
-                                {
-                                    uri: params.uri,
-                                    mimeType: resource.mimeType,
-                                    text: resource.text,
-                                },
-                            ],
-                        }));
-                        break;
-                    }
-                    case "prompts/list":
-                        writeMessage(success(request.id ?? null, {
-                            prompts: promptDefinitions(),
-                        }));
-                        break;
-                    case "prompts/get": {
-                        const params = parseObject(request.params);
-                        if (!hasValue(params.name)) {
-                            throw new Error("prompts/get requires name.");
-                        }
-                        writeMessage(success(request.id ?? null, {
-                            description: promptDefinitions().find((prompt) => prompt.name === params.name)?.description,
-                            messages: [
-                                {
-                                    role: "user",
-                                    content: {
-                                        type: "text",
-                                        text: renderPrompt(params.name, parseObject(params.arguments)),
-                                    },
-                                },
-                            ],
-                        }));
-                        break;
-                    }
-                    case "shutdown":
-                        shutdownRequested = true;
-                        writeMessage(success(request.id ?? null, {}));
-                        break;
-                    case "exit":
-                        process.exit(shutdownRequested ? 0 : 1);
-                        break;
-                    default:
-                        writeMessage(failure(request.id ?? null, -32601, `Unknown method: ${request.method}`));
-                }
+            const result = await dispatchRequest(request, {
+                version,
+                defaults,
+                shutdownRequested,
+            });
+            shutdownRequested = result.shutdownRequested;
+            for (const response of result.responses) {
+                writeMessage(response);
             }
-            catch (error) {
-                writeMessage(failure(request.id ?? null, -32000, error instanceof Error ? error.message : String(error)));
+            if (result.exit !== undefined) {
+                process.exit(result.exit);
             }
         }
     });

package/dist/orchestrator/artifactFreshness.d.ts

@@ -0,0 +1,4 @@
+export declare function stableStringify(value: unknown): string;
+export declare function normalizeForMetadataHash(artifactName: string, value: unknown): unknown;
+export declare function hashArtifactValue(artifactName: string, value: unknown): string;
+export declare function buildReverseDependencyMap(): Record<string, string[]>;

package/dist/orchestrator/artifactFreshness.js

@@ -0,0 +1,45 @@
+import { createHash } from "node:crypto";
+import { ARTIFACT_DEPENDENCY_MAP } from "./dependencyMap.js";
+export function stableStringify(value) {
+    if (value === undefined) {
+        return "null";
+    }
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item ?? null)).join(",")}]`;
+    }
+    const entries = Object.entries(value)
+        .filter(([, item]) => item !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+}
+export function normalizeForMetadataHash(artifactName, value) {
+    if ((artifactName === "repo_manifest.json" ||
+        artifactName === "tooling_manifest.json") &&
+        value &&
+        typeof value === "object" &&
+        !Array.isArray(value)) {
+        const record = value;
+        const { generated_at: _generatedAt, ...rest } = record;
+        return rest;
+    }
+    return value;
+}
+export function hashArtifactValue(artifactName, value) {
+    return createHash("sha256")
+        .update(stableStringify(normalizeForMetadataHash(artifactName, value)))
+        .digest("hex");
+}
+export function buildReverseDependencyMap() {
+    const reverse = {};
+    for (const [upstream, downstreamList] of Object.entries(ARTIFACT_DEPENDENCY_MAP)) {
+        reverse[upstream] ??= [];
+        for (const downstream of downstreamList) {
+            reverse[downstream] ??= [];
+            reverse[downstream].push(upstream);
+        }
+    }
+    return reverse;
+}

package/dist/orchestrator/artifactMetadata.js

@@ -1,54 +1,5 @@
-import { createHash } from "node:crypto";
-import { ARTIFACT_DEPENDENCY_MAP } from "./dependencyMap.js";
 import { getArtifactValue } from "../io/artifacts.js";
-function stableStringify(value) {
-    if (value === undefined) {
-        return "null";
-    }
-    if (value === null || typeof value !== "object") {
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map((item) => stableStringify(item ?? null)).join(",")}]`;
-    }
-    const entries = Object.entries(value)
-        .filter(([, item]) => item !== undefined)
-        .sort(([a], [b]) => a.localeCompare(b));
-    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
-}
-function hashValue(value) {
-    return createHash("sha256").update(stableStringify(value)).digest("hex");
-}
-function normalizeForMetadataHash(artifactName, value) {
-    if (artifactName === "repo_manifest.json" &&
-        value &&
-        typeof value === "object" &&
-        !Array.isArray(value)) {
-        const record = value;
-        const { generated_at: _generatedAt, ...rest } = record;
-        return rest;
-    }
-    if (artifactName === "tooling_manifest.json" &&
-        value &&
-        typeof value === "object" &&
-        !Array.isArray(value)) {
-        const record = value;
-        const { generated_at: _generatedAt, ...rest } = record;
-        return rest;
-    }
-    return value;
-}
-function buildReverseDependencyMap() {
-    const reverse = {};
-    for (const [upstream, downstreamList] of Object.entries(ARTIFACT_DEPENDENCY_MAP)) {
-        reverse[upstream] ??= [];
-        for (const downstream of downstreamList) {
-            reverse[downstream] ??= [];
-            reverse[downstream].push(upstream);
-        }
-    }
-    return reverse;
-}
+import { buildReverseDependencyMap, hashArtifactValue, stableStringify, } from "./artifactFreshness.js";
 const REVERSE_DEPENDENCY_MAP = buildReverseDependencyMap();
 function computeDependencyFirstOrder(artifactNames) {
     const target = new Set(artifactNames);
@@ -97,7 +48,7 @@ export function computeArtifactMetadata(bundle, previous, updatedArtifacts = [])
             artifacts[artifactName] = previousEntry;
             continue;
         }
-        const contentHash = hashValue(normalizeForMetadataHash(artifactName, value));
+        const contentHash = hashArtifactValue(artifactName, value);
         const dependencyRevisions = Object.fromEntries((REVERSE_DEPENDENCY_MAP[artifactName] ?? [])
             .filter((dependencyName) => dependencyName !== "artifact_metadata.json")
             .sort()