voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/interactive/providers/mcp.js

@@ -0,0 +1,547 @@
+import { spawn } from "node:child_process";
+import { setTimeout as delay } from "node:timers/promises";
+import { loadRepoSettings } from "../../configs/settings/loader.js";
+import { BUNDLED_VORATIQ_TOOL_TARGET_NAME, } from "./shared.js";
+const FIRST_PARTY_MCP_VERIFY_DELAYS_MS = [
+    0, 250, 500, 1_000, 2_000, 4_000, 8_000,
+];
+const firstPartyMcpAdapters = {
+    codex: {
+        providerCommand: "codex",
+        installPromptMessage: "Would you like to install the Voratiq MCP?",
+        inspectHintCommand: (toolName) => `codex mcp get --json ${toolName}`,
+        inspectTools: inspectCodexMcpTools,
+        buildAddArgs: buildCodexMcpAddArgs,
+    },
+    claude: {
+        providerCommand: "claude",
+        installPromptMessage: "Would you like to install the Voratiq MCP?",
+        inspectHintCommand: (toolName) => `claude mcp get ${toolName}`,
+        inspectTools: inspectClaudeMcpTools,
+        buildAddArgs: buildClaudeMcpAddArgs,
+    },
+    gemini: {
+        providerCommand: "gemini",
+        installPromptMessage: "Would you like to install the Voratiq MCP?",
+        inspectHintCommand: () => "gemini mcp list",
+        inspectTools: inspectGeminiMcpTools,
+        buildAddArgs: buildGeminiMcpAddArgs,
+    },
+};
+export async function resolveFirstPartyMcpStatus(options) {
+    if (options.toolDeclarations.length === 0) {
+        return {
+            toolAttachmentStatus: "not-requested",
+            additionalArgs: [],
+        };
+    }
+    const settings = loadRepoSettings({ root: options.root });
+    if (settings.mcp[options.providerId] === "never") {
+        return {
+            toolAttachmentStatus: "failed",
+            additionalArgs: [],
+        };
+    }
+    const runCommand = options.mcpCommandRunner ?? runProviderMcpCommand;
+    const adapter = firstPartyMcpAdapters[options.providerId];
+    const initialInspection = summarizeFirstPartyMcpInspection({
+        toolDeclarations: options.toolDeclarations,
+        inspections: await adapter.inspectTools({
+            root: options.root,
+            toolDeclarations: options.toolDeclarations,
+            runCommand,
+        }),
+    });
+    if (initialInspection.conflict) {
+        throw new Error(buildFirstPartyMcpConflictMessage({
+            adapter,
+            tool: initialInspection.conflict.tool,
+            detail: initialInspection.conflict.detail,
+        }));
+    }
+    if (initialInspection.missingToolDeclarations.length === 0) {
+        return {
+            toolAttachmentStatus: "attached",
+            additionalArgs: [],
+        };
+    }
+    if (!options.promptForMcpInstall) {
+        return {
+            toolAttachmentStatus: "failed",
+            additionalArgs: [],
+        };
+    }
+    const shouldInstall = await options.promptForMcpInstall({
+        providerId: options.providerId,
+        message: adapter.installPromptMessage,
+        defaultValue: true,
+    });
+    if (!shouldInstall) {
+        return {
+            toolAttachmentStatus: "failed",
+            additionalArgs: [],
+        };
+    }
+    await installVoratiqMcpForProvider({
+        adapter,
+        root: options.root,
+        toolDeclarations: initialInspection.missingToolDeclarations,
+        runCommand,
+    });
+    const verifiedInspection = await verifyFirstPartyMcpStatus({
+        adapter,
+        root: options.root,
+        toolDeclarations: options.toolDeclarations,
+        runCommand,
+    });
+    if (verifiedInspection.conflict) {
+        throw new Error(buildFirstPartyMcpConflictMessage({
+            adapter,
+            tool: verifiedInspection.conflict.tool,
+            detail: verifiedInspection.conflict.detail,
+        }));
+    }
+    if (verifiedInspection.missingToolDeclarations.length > 0) {
+        throw new Error(buildFirstPartyMcpInstallVerificationMessage({
+            adapter,
+            missingToolDeclarations: verifiedInspection.missingToolDeclarations,
+        }));
+    }
+    return {
+        toolAttachmentStatus: "attached",
+        additionalArgs: [],
+    };
+}
+function summarizeFirstPartyMcpInspection(options) {
+    const missingToolDeclarations = [];
+    for (const tool of options.toolDeclarations) {
+        const inspection = options.inspections.get(tool.name);
+        if (!inspection || inspection.state === "missing") {
+            missingToolDeclarations.push(tool);
+            continue;
+        }
+        if (inspection.state === "conflicting") {
+            return {
+                missingToolDeclarations,
+                conflict: {
+                    tool,
+                    detail: inspection.detail,
+                },
+            };
+        }
+    }
+    return { missingToolDeclarations };
+}
+async function verifyFirstPartyMcpStatus(options) {
+    let lastSummary;
+    for (const waitMs of FIRST_PARTY_MCP_VERIFY_DELAYS_MS) {
+        if (waitMs > 0) {
+            await delay(waitMs);
+        }
+        lastSummary = summarizeFirstPartyMcpInspection({
+            toolDeclarations: options.toolDeclarations,
+            inspections: await options.adapter.inspectTools({
+                root: options.root,
+                toolDeclarations: options.toolDeclarations,
+                runCommand: options.runCommand,
+            }),
+        });
+        if (lastSummary.conflict ||
+            lastSummary.missingToolDeclarations.length === 0) {
+            return lastSummary;
+        }
+    }
+    return (lastSummary ?? { missingToolDeclarations: [...options.toolDeclarations] });
+}
+function buildFirstPartyMcpConflictMessage(options) {
+    const detailLine = options.detail ? ` ${options.detail}` : "";
+    return [
+        `A conflicting effective \`${options.tool.name}\` MCP entry is already configured for ${options.adapter.providerCommand}.${detailLine}`.trim(),
+        `Inspect it with \`${options.adapter.inspectHintCommand(options.tool.name)}\`, then update or remove the conflicting entry and retry.`,
+    ].join(" ");
+}
+function buildFirstPartyMcpInstallVerificationMessage(options) {
+    const [firstTool] = options.missingToolDeclarations;
+    const toolList = options.missingToolDeclarations
+        .map((tool) => `\`${tool.name}\``)
+        .join(", ");
+    return [
+        `Installed ${toolList}, but ${options.adapter.providerCommand} still does not resolve the expected Voratiq MCP configuration.`,
+        `Inspect the effective entry with \`${options.adapter.inspectHintCommand(firstTool?.name ?? BUNDLED_VORATIQ_TOOL_TARGET_NAME)}\` and retry.`,
+    ].join(" ");
+}
+async function inspectGeminiMcpTools(options) {
+    const inspections = new Map();
+    if (options.toolDeclarations.length === 0) {
+        return inspections;
+    }
+    const result = await options.runCommand({
+        command: "gemini",
+        args: ["mcp", "list"],
+        cwd: options.root,
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(buildProviderMcpInspectionError("gemini", result));
+    }
+    const entries = parseGeminiMcpListEntries([result.stdout, result.stderr].filter((part) => part.length > 0).join("\n"));
+    for (const tool of options.toolDeclarations) {
+        const entry = entries.get(tool.name);
+        if (!entry) {
+            inspections.set(tool.name, { state: "missing" });
+            continue;
+        }
+        inspections.set(tool.name, matchesDeclarationCommandAndArgs(tool, entry)
+            ? { state: "matched" }
+            : {
+                state: "conflicting",
+                detail: buildCommandMismatchDetail(tool, entry),
+            });
+    }
+    return inspections;
+}
+async function inspectCliMcpToolsViaGet(options) {
+    const inspections = new Map();
+    for (const tool of options.toolDeclarations) {
+        inspections.set(tool.name, await inspectCliMcpTool({
+            providerCommand: options.providerCommand,
+            root: options.root,
+            declaration: tool,
+            runCommand: options.runCommand,
+        }));
+    }
+    return inspections;
+}
+async function inspectCodexMcpTools(options) {
+    return await inspectCliMcpToolsViaGet({
+        providerCommand: "codex",
+        root: options.root,
+        toolDeclarations: options.toolDeclarations,
+        runCommand: options.runCommand,
+    });
+}
+async function inspectClaudeMcpTools(options) {
+    return await inspectCliMcpToolsViaGet({
+        providerCommand: "claude",
+        root: options.root,
+        toolDeclarations: options.toolDeclarations,
+        runCommand: options.runCommand,
+    });
+}
+async function inspectCliMcpTool(options) {
+    if (options.providerCommand === "codex") {
+        const result = await options.runCommand({
+            command: "codex",
+            args: ["mcp", "get", "--json", options.declaration.name],
+            cwd: options.root,
+        });
+        if (result.exitCode !== 0) {
+            if (isMissingMcpServerResult(result)) {
+                return { state: "missing" };
+            }
+            throw new Error(buildProviderMcpInspectionError("codex", result));
+        }
+        const parsed = tryParseJson(result.stdout);
+        if (parsed !== undefined) {
+            const candidate = findCommandArgsPair(parsed);
+            if (candidate) {
+                return matchesDeclarationCommandAndArgs(options.declaration, candidate)
+                    ? { state: "matched" }
+                    : {
+                        state: "conflicting",
+                        detail: buildCommandMismatchDetail(options.declaration, candidate),
+                    };
+            }
+        }
+        return textContainsCommandAndArgs(result.stdout, options.declaration)
+            ? { state: "matched" }
+            : {
+                state: "conflicting",
+                detail: "Configured entry does not match the expected Voratiq command.",
+            };
+    }
+    const result = await options.runCommand({
+        command: "claude",
+        args: ["mcp", "get", options.declaration.name],
+        cwd: options.root,
+    });
+    if (result.exitCode !== 0) {
+        if (isMissingMcpServerResult(result)) {
+            return { state: "missing" };
+        }
+        throw new Error(buildProviderMcpInspectionError("claude", result));
+    }
+    const candidate = parseSeparatedCommandAndArgs(result.stdout, {
+        commandLabel: "Command",
+        argsLabel: "Args",
+    }) ?? parseCommandLineValue(result.stdout, "Command");
+    if (candidate) {
+        return matchesDeclarationCommandAndArgs(options.declaration, candidate)
+            ? { state: "matched" }
+            : {
+                state: "conflicting",
+                detail: buildCommandMismatchDetail(options.declaration, candidate),
+            };
+    }
+    return textContainsCommandAndArgs(result.stdout, options.declaration)
+        ? { state: "matched" }
+        : {
+            state: "conflicting",
+            detail: "Configured entry does not match the expected Voratiq command.",
+        };
+}
+function buildProviderMcpInspectionError(providerCommand, result) {
+    const output = result.stderr.trim() || result.stdout.trim() || "Unknown error";
+    return `Failed to inspect ${providerCommand} MCP configuration: ${output}`;
+}
+function isMissingMcpServerResult(result) {
+    const output = `${result.stdout}\n${result.stderr}`.toLowerCase();
+    return (output.includes("no mcp server found") ||
+        output.includes("no mcp server named") ||
+        output.includes("not found") ||
+        output.includes("no server found"));
+}
+function tryParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function findCommandArgsPair(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            const nested = findCommandArgsPair(entry);
+            if (nested) {
+                return nested;
+            }
+        }
+        return undefined;
+    }
+    const candidate = value;
+    const command = typeof candidate.command === "string" ? candidate.command : undefined;
+    const args = normalizeStringArray(candidate.args);
+    if (command && args) {
+        return { command, args };
+    }
+    for (const nestedValue of Object.values(candidate)) {
+        const nested = findCommandArgsPair(nestedValue);
+        if (nested) {
+            return nested;
+        }
+    }
+    return undefined;
+}
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    if (!value.every((entry) => typeof entry === "string")) {
+        return undefined;
+    }
+    return [...value];
+}
+function matchesDeclarationCommandAndArgs(declaration, value) {
+    if (value.command !== declaration.command) {
+        return false;
+    }
+    const expectedArgs = declaration.args ? [...declaration.args] : [];
+    return areStringArraysEqual(value.args, expectedArgs);
+}
+function areStringArraysEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+        if (left[index] !== right[index]) {
+            return false;
+        }
+    }
+    return true;
+}
+function buildCommandMismatchDetail(declaration, actual) {
+    return [
+        `Expected \`${formatCommandAndArgs(declaration.command, declaration.args ?? [])}\`,`,
+        `found \`${formatCommandAndArgs(actual.command, actual.args)}\`.`,
+    ].join(" ");
+}
+function formatCommandAndArgs(command, args) {
+    return [command, ...args].join(" ");
+}
+function textContainsCommandAndArgs(text, declaration) {
+    const normalized = text.replaceAll(/\s+/gu, " ");
+    const commandIndex = normalized.indexOf(declaration.command);
+    if (commandIndex < 0) {
+        return false;
+    }
+    let cursor = commandIndex + declaration.command.length;
+    for (const arg of declaration.args ?? []) {
+        const index = normalized.indexOf(arg, cursor);
+        if (index < 0) {
+            return false;
+        }
+        cursor = index + arg.length;
+    }
+    return true;
+}
+function parseCommandLineValue(text, label) {
+    const pattern = new RegExp(`^${label}:\\s+(.+)$`, "mu");
+    const match = text.match(pattern);
+    if (!match?.[1]) {
+        return undefined;
+    }
+    return splitCommandLine(match[1]);
+}
+function parseSeparatedCommandAndArgs(text, labels) {
+    const commandLine = parseLabeledLine(text, labels.commandLabel);
+    if (!commandLine) {
+        return undefined;
+    }
+    const argsLine = parseLabeledLine(text, labels.argsLabel);
+    return {
+        command: commandLine,
+        args: argsLine
+            ? argsLine.split(/\s+/u).filter((part) => part.length > 0)
+            : [],
+    };
+}
+function parseLabeledLine(text, label) {
+    const pattern = new RegExp(`^${label}:\\s*(.+)$`, "mu");
+    const match = text.match(pattern);
+    return match?.[1]?.trim() || undefined;
+}
+function splitCommandLine(value) {
+    const trimmed = value.trim();
+    const withoutSuffix = trimmed.replace(/\s+\((?:stdio|sse|http)\)(?:\s+-\s+.+)?$/u, "");
+    const parts = withoutSuffix.split(/\s+/u).filter((part) => part.length > 0);
+    return {
+        command: parts[0] ?? "",
+        args: parts.slice(1),
+    };
+}
+async function installVoratiqMcpForProvider(options) {
+    for (const toolDeclaration of options.toolDeclarations) {
+        const result = await options.runCommand({
+            command: options.adapter.providerCommand,
+            args: options.adapter.buildAddArgs(toolDeclaration),
+            cwd: options.root,
+        });
+        if (result.exitCode !== 0) {
+            const stderr = result.stderr.trim();
+            const stdout = result.stdout.trim();
+            const output = stderr || stdout || `${options.adapter.providerCommand} mcp add failed`;
+            throw new Error(output);
+        }
+    }
+}
+function buildGeminiMcpAddArgs(tool) {
+    const args = ["mcp", "add", "--scope", "user", "--trust"];
+    if (tool.env) {
+        for (const [key, value] of Object.entries(tool.env)) {
+            args.push("-e", `${key}=${value}`);
+        }
+    }
+    args.push(tool.name, tool.command);
+    if (tool.args && tool.args.length > 0) {
+        args.push(...tool.args);
+    }
+    return args;
+}
+function buildCodexMcpAddArgs(tool) {
+    const args = ["mcp", "add"];
+    if (tool.env) {
+        for (const [key, value] of Object.entries(tool.env)) {
+            args.push("--env", `${key}=${value}`);
+        }
+    }
+    args.push(tool.name, "--", tool.command);
+    if (tool.args && tool.args.length > 0) {
+        args.push(...tool.args);
+    }
+    return args;
+}
+function buildClaudeMcpAddArgs(tool) {
+    const args = ["mcp", "add", "--scope", "user"];
+    if (tool.env) {
+        for (const [key, value] of Object.entries(tool.env)) {
+            args.push("-e", `${key}=${value}`);
+        }
+    }
+    args.push(tool.name, "--", tool.command);
+    if (tool.args && tool.args.length > 0) {
+        args.push(...tool.args);
+    }
+    return args;
+}
+function parseGeminiMcpListEntries(stdout) {
+    const entries = new Map();
+    for (const rawLine of stdout.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (!line || line.toLowerCase() === "no mcp servers configured.") {
+            continue;
+        }
+        const entry = parseGeminiMcpListEntry(line);
+        if (entry) {
+            entries.set(entry.name, entry.commandLine);
+        }
+    }
+    return entries;
+}
+function parseGeminiMcpListEntry(line) {
+    let normalized = line;
+    while (normalized.startsWith("✓") ||
+        normalized.startsWith("✗") ||
+        normalized.startsWith("-") ||
+        normalized.startsWith("*")) {
+        normalized = normalized.slice(1).trimStart();
+    }
+    const colonIndex = normalized.indexOf(":");
+    const candidate = (colonIndex >= 0 ? normalized.slice(0, colonIndex) : normalized).trim();
+    if (!candidate) {
+        return undefined;
+    }
+    if (!/^[A-Za-z0-9._-]+$/u.test(candidate)) {
+        return undefined;
+    }
+    if (colonIndex < 0) {
+        return undefined;
+    }
+    const commandText = normalized.slice(colonIndex + 1).trim();
+    if (!commandText) {
+        return undefined;
+    }
+    return {
+        name: candidate,
+        commandLine: splitCommandLine(commandText),
+    };
+}
+async function runProviderMcpCommand(input) {
+    const child = spawn(input.command, [...input.args], {
+        cwd: input.cwd,
+        env: input.env ?? process.env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+        stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk;
+    });
+    const exitCode = await new Promise((resolve) => {
+        child.on("close", (code) => {
+            resolve(typeof code === "number" ? code : null);
+        });
+    });
+    return {
+        exitCode,
+        stdout,
+        stderr,
+    };
+}

package/dist/interactive/providers/shared.d.ts

@@ -0,0 +1,2 @@
+export declare const BUNDLED_VORATIQ_TOOL_TARGET_NAME: "voratiq";
+export type FirstPartyProviderId = "codex" | "claude" | "gemini";

package/dist/interactive/providers/shared.js

@@ -0,0 +1 @@
+export const BUNDLED_VORATIQ_TOOL_TARGET_NAME = "voratiq";

package/dist/interactive/providers.d.ts

@@ -0,0 +1,3 @@
+export { createBundledVoratiqToolDeclaration, prepareProviderNativeLaunch, type ProviderLaunchPreparationInput, type ProviderLaunchPreparationResult, } from "./providers/launch.js";
+export { type FirstPartyMcpStatusAndArgs, resolveFirstPartyMcpStatus, } from "./providers/mcp.js";
+export { BUNDLED_VORATIQ_TOOL_TARGET_NAME } from "./providers/shared.js";

package/dist/interactive/providers.js

@@ -0,0 +1,3 @@
+export { createBundledVoratiqToolDeclaration, prepareProviderNativeLaunch, } from "./providers/launch.js";
+export { resolveFirstPartyMcpStatus, } from "./providers/mcp.js";
+export { BUNDLED_VORATIQ_TOOL_TARGET_NAME } from "./providers/shared.js";

package/dist/interactive/records.d.ts

@@ -0,0 +1,2 @@
+export type { InteractiveSessionPaths } from "../domain/interactive/persistence/adapter.js";
+export { appendInteractiveSessionRecord, disposeInteractiveSessionBuffer, ensureInteractiveSessionDirectories, flushAllInteractiveSessionBuffers, getInteractiveSessionRecordSnapshot, resolveInteractiveSessionPaths, rewriteInteractiveSessionRecord, toInteractiveSessionRelativePath, updateInteractiveSessionStatus, } from "../domain/interactive/persistence/adapter.js";

package/dist/interactive/records.js

@@ -0,0 +1 @@
+export { appendInteractiveSessionRecord, disposeInteractiveSessionBuffer, ensureInteractiveSessionDirectories, flushAllInteractiveSessionBuffers, getInteractiveSessionRecordSnapshot, resolveInteractiveSessionPaths, rewriteInteractiveSessionRecord, toInteractiveSessionRelativePath, updateInteractiveSessionStatus, } from "../domain/interactive/persistence/adapter.js";

package/dist/interactive/substrate.d.ts

@@ -0,0 +1,21 @@
+import { loadAgentById } from "../configs/agents/loader.js";
+import type { InteractiveLaunchFailure, PrepareAndSpawnNativeSessionResult, PreparedInteractiveSession, PrepareNativeSessionOptions, PrepareNativeSessionResult, SpawnPreparedSessionOptions, SpawnPreparedSessionResult } from "./types.js";
+interface ResolvedInteractiveAgentProvider {
+    agent: ReturnType<typeof loadAgentById>;
+    providerId: string;
+}
+export type ResolveInteractiveAgentProviderResult = {
+    ok: true;
+    value: ResolvedInteractiveAgentProvider;
+} | {
+    ok: false;
+    failure: InteractiveLaunchFailure;
+};
+export declare function resolveInteractiveAgentProvider(options: {
+    root: string;
+    agentId: string;
+}): ResolveInteractiveAgentProviderResult;
+export declare function prepareNativeInteractiveSession(options: PrepareNativeSessionOptions): Promise<PrepareNativeSessionResult>;
+export declare function spawnPreparedInteractiveSession(prepared: PreparedInteractiveSession, options?: SpawnPreparedSessionOptions): Promise<SpawnPreparedSessionResult>;
+export declare function prepareAndSpawnNativeInteractiveSession(options: PrepareNativeSessionOptions & SpawnPreparedSessionOptions): Promise<PrepareAndSpawnNativeSessionResult>;
+export {};