ast-mcp-server 0.7.2 → 0.8.1

package/dist/services/agent-targets.js

@@ -1,5 +1,5 @@
 export const MCP_SERVER_NAME = "ast";
-const EXPECTED_HERMES_TOOLS = [
+const EXPECTED_TOOLS = [
     "ast_list_files",
     "ast_get_outline",
     "ast_get_symbol_source",
@@ -12,111 +12,257 @@ const EXPECTED_HERMES_TOOLS = [
     "ast_get_operation_preview",
     "ast_apply_operation",
 ];
-function isMissingClaudeMcp(output) {
-    return (/\bno\s+mcp\s+server\b/i.test(output) &&
-        /(?:\bfound\b|\bnamed?\b)/i.test(output) &&
-        /\bast\b/i.test(output));
+function semver(value) {
+    const match = value.match(/(?:^|\s|v)(\d+)\.(\d+)\.(\d+)(?=\s|$|[-+()]|\.(?:\s|$))/);
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : undefined;
 }
-function inspectClaudeFields(stdout) {
-    const fields = new Map();
-    for (const line of stdout.split(/\r?\n/)) {
-        const match = line.match(/^\s*(Status|Type|Command|Args):\s*(.*)$/i);
-        if (match !== null)
-            fields.set(match[1].toLowerCase(), match[2].trim());
+function atLeast(value, minimum) {
+    return (value[0] > minimum[0] ||
+        (value[0] === minimum[0] &&
+            (value[1] > minimum[1] || (value[1] === minimum[1] && value[2] >= minimum[2]))));
+}
+export function classifyAgentVersion(id, output) {
+    const version = semver(output);
+    if (!version)
+        return {
+            status: "incompatible",
+            reason: "Version output does not match an admitted contract.",
+        };
+    if (id === "opencode" && !atLeast(version, [1, 18, 18])) {
+        return { status: "incompatible", reason: "OpenCode 1.18.18 or newer is required." };
+    }
+    return { status: "compatible", contract: `${id}-mcp-v1`, version: version.join(".") };
+}
+function expected(context, command, args) {
+    return (command === context.nodeExecutable &&
+        Array.isArray(args) &&
+        args.length === 1 &&
+        args[0] === context.serverEntryPath);
+}
+function parseJson(result) {
+    try {
+        return JSON.parse(result.stdout);
+    }
+    catch {
+        return undefined;
+    }
+}
+function structuredInspection(result, context) {
+    if (result.exitCode !== 0) {
+        return /(?:not found|no mcp server)/i.test(`${result.stdout}\n${result.stderr}`)
+            ? { status: "missing" }
+            : { status: "error", operation: "MCP inspection", result };
+    }
+    const value = parseJson(result);
+    if (!value || value.name !== MCP_SERVER_NAME)
+        return { status: "error", operation: "MCP inspection", result };
+    const transport = (value.transport ?? value);
+    return expected(context, transport.command, transport.args)
+        ? { status: "current" }
+        : {
+            status: "conflict",
+            detail: "The existing 'ast' registration does not match this package.",
+        };
+}
+function copilotStructuredInspection(result, context) {
+    if (result.exitCode !== 0) {
+        return /(?:not found|no mcp server)/i.test(`${result.stdout}\n${result.stderr}`)
+            ? { status: "missing" }
+            : { status: "error", operation: "MCP inspection", result };
+    }
+    const value = parseJson(result);
+    const server = value?.[MCP_SERVER_NAME];
+    if (server === null || typeof server !== "object" || Array.isArray(server)) {
+        return { status: "error", operation: "MCP inspection", result };
     }
-    return fields;
+    const configuration = server;
+    return configuration.type === "local" &&
+        configuration.source === "user" &&
+        configuration.enabled === true &&
+        Array.isArray(configuration.tools) &&
+        configuration.tools.length === 1 &&
+        configuration.tools[0] === "*" &&
+        expected(context, configuration.command, configuration.args)
+        ? { status: "current" }
+        : {
+            status: "conflict",
+            detail: "The existing user-scoped 'ast' registration does not match this package.",
+        };
 }
 const claudeMcp = {
     async inspect(runtime, context) {
         const result = await runtime.run(["mcp", "get", MCP_SERVER_NAME]);
         const output = `${result.stdout}\n${result.stderr}`;
-        if (result.exitCode !== 0) {
-            return isMissingClaudeMcp(output)
+        if (result.exitCode !== 0)
+            return /no\s+mcp\s+server.*ast/i.test(output)
                 ? { status: "missing" }
                 : { status: "error", operation: "MCP inspection", result };
+        const fields = new Map();
+        for (const line of result.stdout.split(/\r?\n/)) {
+            const match = line.match(/^\s*(Status|Type|Command|Args):\s*(.*)$/i);
+            if (match)
+                fields.set(match[1].toLowerCase(), match[2].trim());
         }
-        const fields = inspectClaudeFields(result.stdout);
-        const current = /connected/i.test(fields.get("status") ?? "") &&
+        return /connected/i.test(fields.get("status") ?? "") &&
             fields.get("type")?.toLowerCase() === "stdio" &&
-            fields.get("command") === context.nodeExecutable &&
-            fields.get("args") === context.serverEntryPath;
-        return current
+            expected(context, fields.get("command"), [fields.get("args")])
             ? { status: "current" }
             : {
                 status: "conflict",
                 detail: "The existing user-scoped 'ast' registration does not match this package.",
             };
     },
-    register(runtime, context) {
-        return runtime.run([
-            "mcp",
-            "add",
-            "--scope",
-            "user",
-            "--transport",
-            "stdio",
-            MCP_SERVER_NAME,
-            "--",
-            context.nodeExecutable,
-            context.serverEntryPath,
-        ]);
-    },
-    registrationAccepted(result) {
-        return result.exitCode === 0;
-    },
+    register: (runtime, context) => runtime.run([
+        "mcp",
+        "add",
+        "--scope",
+        "user",
+        "--transport",
+        "stdio",
+        MCP_SERVER_NAME,
+        "--",
+        context.nodeExecutable,
+        context.serverEntryPath,
+    ]),
+    registrationAccepted: (result) => result.exitCode === 0,
 };
 const hermesMcp = {
     async inspect(runtime) {
         const listed = await runtime.run(["mcp", "list"]);
-        if (listed.exitCode !== 0) {
+        if (listed.exitCode !== 0)
             return { status: "error", operation: "MCP list", result: listed };
-        }
         if (!/^\s*ast(?:\s|$)/im.test(listed.stdout))
             return { status: "missing" };
         const tested = await runtime.run(["mcp", "test", MCP_SERVER_NAME]);
-        const current = tested.exitCode === 0 && EXPECTED_HERMES_TOOLS.every((tool) => tested.stdout.includes(tool));
-        return current
+        return tested.exitCode === 0 && EXPECTED_TOOLS.every((tool) => tested.stdout.includes(tool))
             ? { status: "current" }
             : {
                 status: "conflict",
                 detail: "The existing 'ast' registration does not expose the expected structural tools.",
             };
     },
-    register(runtime, context) {
-        return runtime.run([
-            "mcp",
-            "add",
-            MCP_SERVER_NAME,
-            "--command",
-            context.nodeExecutable,
-            "--args",
-            context.serverEntryPath,
-        ], "\n");
+    register: (runtime, context) => runtime.run([
+        "mcp",
+        "add",
+        MCP_SERVER_NAME,
+        "--command",
+        context.nodeExecutable,
+        "--args",
+        context.serverEntryPath,
+    ], "\n"),
+    registrationAccepted: (result) => result.exitCode === 0 && /saved\s+'ast'/i.test(result.stdout),
+};
+const codexMcp = {
+    async inspect(runtime, context) {
+        return structuredInspection(await runtime.run(["mcp", "get", MCP_SERVER_NAME, "--json"]), context);
+    },
+    register: (runtime, context) => runtime.run([
+        "mcp",
+        "add",
+        MCP_SERVER_NAME,
+        "--",
+        context.nodeExecutable,
+        context.serverEntryPath,
+    ]),
+    registrationAccepted: (result) => result.exitCode === 0,
+};
+const copilotMcp = {
+    async inspect(runtime, context) {
+        return copilotStructuredInspection(await runtime.run(["mcp", "get", MCP_SERVER_NAME, "--json"]), context);
+    },
+    register: (runtime, context) => runtime.run([
+        "mcp",
+        "add",
+        MCP_SERVER_NAME,
+        "--",
+        context.nodeExecutable,
+        context.serverEntryPath,
+    ]),
+    registrationAccepted: (result) => result.exitCode === 0,
+};
+const geminiMcp = {
+    async inspect(runtime, context) {
+        const result = await runtime.run(["mcp", "list"]);
+        const output = `${result.stdout}\n${result.stderr}`;
+        if (/MCP servers are disabled in untrusted folders\. Trust this folder to continue\./i.test(output)) {
+            return {
+                status: "blocked_untrusted_folder",
+                detail: "Trust the working folder in Gemini CLI and retry.",
+            };
+        }
+        if (result.exitCode !== 0)
+            return { status: "error", operation: "MCP list", result };
+        if (/No MCP servers configured\./i.test(result.stdout))
+            return { status: "missing" };
+        const pattern = /ast[^\n]*Connected[^\n]*command:\s*([^,\n]+),\s*args:\s*\[([^\]]*)\]/i;
+        const match = result.stdout.match(pattern);
+        if (!match)
+            return { status: "error", operation: "MCP inspection", result };
+        return expected(context, match[1]?.trim(), match[2]?.split(",").map((item) => item.trim()))
+            ? { status: "current" }
+            : {
+                status: "conflict",
+                detail: "The existing Gemini 'ast' registration does not match this package.",
+            };
+    },
+    register: (runtime, context) => runtime.run([
+        "mcp",
+        "add",
+        MCP_SERVER_NAME,
+        context.nodeExecutable,
+        context.serverEntryPath,
+        "--scope",
+        "user",
+    ]),
+    registrationAccepted: (result) => result.exitCode === 0,
+};
+const opencodeMcp = {
+    async inspect() {
+        return {
+            status: "error",
+            operation: "OpenCode configuration inspection",
+            result: {
+                exitCode: 1,
+                stdout: "",
+                stderr: "OpenCode uses the routed configuration adapter.",
+            },
+        };
     },
-    registrationAccepted(result) {
-        return result.exitCode === 0 && /saved\s+'ast'/i.test(result.stdout);
+    async register() {
+        return { exitCode: 1, stdout: "", stderr: "OpenCode CLI registration is disabled." };
     },
+    registrationAccepted: () => false,
 };
 export const AGENT_TARGETS = [
+    { id: "claude", label: "Claude Code", command: "claude", skillTarget: "claude", mcp: claudeMcp },
+    { id: "hermes", label: "Hermes", command: "hermes", skillTarget: "hermes", mcp: hermesMcp },
     {
-        id: "claude",
-        label: "Claude Code",
-        command: "claude",
-        skillTarget: "claude",
-        mcp: claudeMcp,
+        id: "opencode",
+        label: "OpenCode",
+        command: "opencode",
+        skillTarget: "agents",
+        mcp: opencodeMcp,
     },
+    { id: "codex", label: "Codex CLI", command: "codex", skillTarget: "agents", mcp: codexMcp },
+    { id: "gemini", label: "Gemini CLI", command: "gemini", skillTarget: "agents", mcp: geminiMcp },
     {
-        id: "hermes",
-        label: "Hermes",
-        command: "hermes",
-        skillTarget: "hermes",
-        mcp: hermesMcp,
+        id: "copilot",
+        label: "GitHub Copilot CLI",
+        command: "copilot",
+        skillTarget: "agents",
+        mcp: copilotMcp,
     },
 ];
 export const AGENT_IDS = AGENT_TARGETS.map((target) => target.id);
 export function getAgentTarget(id) {
     const target = AGENT_TARGETS.find((candidate) => candidate.id === id);
-    if (target === undefined)
+    if (!target)
         throw new Error(`Unsupported agent target: ${id}`);
     return target;
 }
+export async function inspectAgentFixture(id, results, context) {
+    let index = 0;
+    return getAgentTarget(id).mcp.inspect({
+        run: async () => results[index++] ?? { exitCode: 1, stdout: "", stderr: "Missing fixture result." },
+    }, context);
+}

package/dist/services/checkbox-state.js

@@ -0,0 +1,31 @@
+export function createCheckboxState(choices) {
+    return {
+        choices: choices.map((choice) => ({ ...choice })),
+        focus: Math.max(0, choices.findIndex((choice) => choice.enabled)),
+    };
+}
+export function reduceCheckboxState(state, action) {
+    if (action === "cancel")
+        return { ...state, cancelled: true };
+    if (action === "up" || action === "down") {
+        const delta = action === "up" ? -1 : 1;
+        return {
+            ...state,
+            focus: Math.max(0, Math.min(state.choices.length - 1, state.focus + delta)),
+            validation: undefined,
+        };
+    }
+    if (action === "toggle") {
+        return {
+            ...state,
+            validation: undefined,
+            choices: state.choices.map((choice, index) => index === state.focus && choice.enabled ? { ...choice, checked: !choice.checked } : choice),
+        };
+    }
+    const selected = state.choices
+        .filter((choice) => choice.enabled && choice.checked)
+        .map((choice) => choice.id);
+    return selected.length === 0
+        ? { ...state, validation: "Select at least one agent." }
+        : { ...state, submitted: selected };
+}