@martinloop/mcp 0.2.5 → 0.3.0

package/dist/vendor/adapters/claude-cli.js

@@ -31,7 +31,14 @@ const MODEL_PRICING = {
     // Keep legacy names working
     "claude-opus": { inputPer1K: 0.015, outputPer1K: 0.075 },
     "claude-sonnet": { inputPer1K: 0.003, outputPer1K: 0.015 },
-    "claude-haiku": { inputPer1K: 0.00025, outputPer1K: 0.00125 }
+    "claude-haiku": { inputPer1K: 0.00025, outputPer1K: 0.00125 },
+    // OpenAI coding models
+    "codex": { inputPer1K: 0.00125, cachedInputPer1K: 0.000125, outputPer1K: 0.01 },
+    "gpt-5-codex": { inputPer1K: 0.00125, cachedInputPer1K: 0.000125, outputPer1K: 0.01 },
+    "gpt-5.1-codex": { inputPer1K: 0.00125, cachedInputPer1K: 0.000125, outputPer1K: 0.01 },
+    "gpt-5.1-codex-max": { inputPer1K: 0.00125, cachedInputPer1K: 0.000125, outputPer1K: 0.01 },
+    "gpt-5.2-codex": { inputPer1K: 0.00175, cachedInputPer1K: 0.000175, outputPer1K: 0.014 },
+    "codex-mini-latest": { inputPer1K: 0.0015, cachedInputPer1K: 0.000375, outputPer1K: 0.006 }
 };
 function extractUsage(parsed, modelLabel) {
     if (!parsed?.usage) {
@@ -42,21 +49,189 @@ function extractUsage(parsed, modelLabel) {
             provenance: "unavailable"
         });
     }
-    const tokensIn = (parsed.usage.inputTokens ?? parsed.usage.input_tokens ?? 0) +
-        (parsed.usage.cacheReadInputTokens ?? parsed.usage.cache_read_input_tokens ?? 0) +
+    const promptTokens = (parsed.usage.inputTokens ?? parsed.usage.input_tokens ?? 0) +
         (parsed.usage.cacheCreationInputTokens ?? parsed.usage.cache_creation_input_tokens ?? 0);
+    const cachedInputTokens = parsed.usage.cacheReadInputTokens ?? parsed.usage.cache_read_input_tokens ?? 0;
+    const tokensIn = promptTokens + cachedInputTokens;
     const tokensOut = parsed.usage.outputTokens ?? parsed.usage.output_tokens ?? 0;
     const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
         { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
-    const actualUsd = (tokensIn / 1000) * pricing.inputPer1K +
+    const actualUsd = (promptTokens / 1000) * pricing.inputPer1K +
+        (cachedInputTokens / 1000) * (pricing.cachedInputPer1K ?? pricing.inputPer1K) +
         (tokensOut / 1000) * pricing.outputPer1K;
     return normalizeUsage({
         actualUsd: Number(actualUsd.toFixed(6)),
         tokensIn,
         tokensOut,
-        provenance: "actual"
+        cachedInputTokens,
+        provenance: "actual",
+        providerSettlement: {
+            providerId: "claude",
+            model: modelLabel ?? "claude",
+            transport: "cli",
+            source: "claude_json",
+            inputTokens: promptTokens,
+            cachedInputTokens,
+            outputTokens: tokensOut,
+            rawUsageAvailable: true,
+            settledAt: new Date().toISOString()
+        }
     });
 }
+function extractCodexJsonlResult(stdout, modelLabel) {
+    const events = stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+        try {
+            return JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter((event) => event !== undefined);
+    if (events.length === 0) {
+        return undefined;
+    }
+    const latestAgentMessage = [...events]
+        .reverse()
+        .find((event) => event.type === "item.completed" && event.item?.type === "agent_message");
+    const latestTurnCompleted = [...events]
+        .reverse()
+        .find((event) => event.type === "turn.completed" && event.usage !== undefined);
+    const summary = typeof latestAgentMessage?.item?.text === "string" && latestAgentMessage.item.text.trim().length > 0
+        ? latestAgentMessage.item.text.trim()
+        : stdout.trim();
+    if (!latestTurnCompleted?.usage) {
+        return {
+            summary,
+            usage: normalizeUsage({
+                actualUsd: 0,
+                tokensIn: 0,
+                tokensOut: 0,
+                provenance: "unavailable",
+                providerSettlement: {
+                    providerId: "codex",
+                    model: modelLabel ?? "codex",
+                    transport: "cli",
+                    source: "unavailable",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    rawUsageAvailable: false,
+                    settledAt: new Date().toISOString()
+                }
+            })
+        };
+    }
+    const promptTokens = latestTurnCompleted.usage.input_tokens ?? 0;
+    const cachedInputTokens = latestTurnCompleted.usage.cached_input_tokens ?? 0;
+    const outputTokens = latestTurnCompleted.usage.output_tokens ?? 0;
+    const reasoningOutputTokens = latestTurnCompleted.usage.reasoning_output_tokens ?? 0;
+    const tokensIn = promptTokens + cachedInputTokens;
+    const tokensOut = outputTokens + reasoningOutputTokens;
+    const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
+        MODEL_PRICING["codex"] ??
+        { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
+    const actualUsd = (promptTokens / 1000) * pricing.inputPer1K +
+        (cachedInputTokens / 1000) * (pricing.cachedInputPer1K ?? pricing.inputPer1K) +
+        (tokensOut / 1000) * pricing.outputPer1K;
+    return {
+        summary,
+        usage: normalizeUsage({
+            actualUsd: Number(actualUsd.toFixed(6)),
+            tokensIn,
+            tokensOut,
+            cachedInputTokens,
+            reasoningTokensOut: reasoningOutputTokens,
+            provenance: "actual",
+            providerSettlement: {
+                providerId: "codex",
+                model: modelLabel ?? "codex",
+                transport: "cli",
+                source: "codex_jsonl",
+                inputTokens: promptTokens,
+                cachedInputTokens,
+                outputTokens,
+                reasoningOutputTokens,
+                rawUsageAvailable: true,
+                settledAt: new Date().toISOString()
+            }
+        })
+    };
+}
+function extractGeminiJsonResult(stdout, modelLabel) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return undefined;
+    }
+    const summary = typeof parsed.response === "string" && parsed.response.trim().length > 0
+        ? parsed.response.trim()
+        : typeof parsed.error?.message === "string" && parsed.error.message.trim().length > 0
+            ? parsed.error.message.trim()
+            : stdout.trim();
+    const promptTokens = parsed.stats?.inputTokens ?? 0;
+    const cachedInputTokens = parsed.stats?.cachedReadTokens ?? 0;
+    const outputTokens = parsed.stats?.outputTokens ?? 0;
+    const reasoningOutputTokens = parsed.stats?.thoughtTokens ?? 0;
+    const hasUsage = parsed.stats !== undefined &&
+        (promptTokens > 0 || cachedInputTokens > 0 || outputTokens > 0 || reasoningOutputTokens > 0);
+    if (!hasUsage) {
+        return {
+            summary,
+            usage: normalizeUsage({
+                actualUsd: 0,
+                tokensIn: 0,
+                tokensOut: 0,
+                provenance: "unavailable",
+                providerSettlement: {
+                    providerId: "gemini",
+                    model: modelLabel ?? "flash",
+                    transport: "cli",
+                    source: "unavailable",
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    rawUsageAvailable: false,
+                    settledAt: new Date().toISOString()
+                }
+            })
+        };
+    }
+    const tokensIn = promptTokens + cachedInputTokens;
+    const tokensOut = outputTokens + reasoningOutputTokens;
+    const pricing = (modelLabel ? MODEL_PRICING[modelLabel] : undefined) ??
+        { inputPer1K: BLENDED_INPUT_COST_PER_1K, outputPer1K: BLENDED_OUTPUT_COST_PER_1K };
+    const actualUsd = (promptTokens / 1000) * pricing.inputPer1K +
+        (cachedInputTokens / 1000) * (pricing.cachedInputPer1K ?? pricing.inputPer1K) +
+        (tokensOut / 1000) * pricing.outputPer1K;
+    return {
+        summary,
+        usage: normalizeUsage({
+            actualUsd: Number(actualUsd.toFixed(6)),
+            tokensIn,
+            tokensOut,
+            cachedInputTokens,
+            reasoningTokensOut: reasoningOutputTokens,
+            provenance: "actual",
+            providerSettlement: {
+                providerId: "gemini",
+                model: modelLabel ?? "flash",
+                transport: "cli",
+                source: "gemini_json",
+                inputTokens: promptTokens,
+                cachedInputTokens,
+                outputTokens,
+                reasoningOutputTokens,
+                rawUsageAvailable: true,
+                settledAt: new Date().toISOString()
+            }
+        })
+    };
+}
 // ---------------------------------------------------------------------------
 // Structural failure hint detection
 //
@@ -90,6 +265,7 @@ export function createAgentCliAdapter(options) {
     const verifyTimeoutMs = options.verifyTimeoutMs ?? 60_000;
     const adapterId = `agent-cli:${options.adapterIdSuffix ?? options.command}`;
     const supportsJsonOutput = options.supportsJsonOutput === true;
+    const supportsUsageSettlement = supportsJsonOutput || options.command === "codex" || options.command === "gemini";
     const adapter = {
         adapterId,
         kind: "agent-cli",
@@ -100,10 +276,10 @@ export function createAgentCliAdapter(options) {
             transport: "cli",
             capabilities: createAdapterCapabilities({
                 preflight: true,
-                usageSettlement: supportsJsonOutput,
+                usageSettlement: supportsUsageSettlement,
                 diffArtifacts: true,
                 structuredErrors: true,
-                cachingSignals: supportsJsonOutput
+                cachingSignals: supportsUsageSettlement
             })
         },
         async execute(request) {
@@ -180,24 +356,58 @@ export function createAgentCliAdapter(options) {
                     // Fall through to plain-text handling
                 }
             }
-            const agentText = parsed?.result ?? agentResult.stdout.trim();
+            const codexJsonlResult = !supportsJsonOutput && options.command === "codex"
+                ? extractCodexJsonlResult(agentResult.stdout, options.model)
+                : undefined;
+            const geminiJsonResult = !supportsJsonOutput && options.command === "gemini"
+                ? extractGeminiJsonResult(agentResult.stdout, options.model)
+                : undefined;
+            const agentText = codexJsonlResult?.summary ??
+                geminiJsonResult?.summary ??
+                parsed?.result ??
+                agentResult.stdout.trim();
             const summary = truncate(agentText, 2000);
             const usage = parsed?.usage
                 ? extractUsage(parsed, options.model)
-                : normalizeUsage({
-                    actualUsd: estimatedUsage.actualUsd,
-                    estimatedUsd: estimatedUsage.actualUsd,
-                    tokensIn: estimatedUsage.tokensIn,
-                    tokensOut: Math.max(estimatedUsage.tokensOut, Math.ceil(agentText.length / 4)),
-                    provenance: "estimated"
-                });
+                : codexJsonlResult?.usage ??
+                    geminiJsonResult?.usage ??
+                    normalizeUsage({
+                        actualUsd: estimatedUsage.actualUsd,
+                        estimatedUsd: estimatedUsage.actualUsd,
+                        tokensIn: estimatedUsage.tokensIn,
+                        tokensOut: Math.max(estimatedUsage.tokensOut, Math.ceil(agentText.length / 4)),
+                        provenance: "estimated",
+                        providerSettlement: options.command === "codex"
+                            ? {
+                                providerId: "codex",
+                                model: options.model ?? "codex",
+                                transport: "cli",
+                                source: "estimated_fallback",
+                                inputTokens: estimatedUsage.tokensIn,
+                                outputTokens: Math.max(estimatedUsage.tokensOut, Math.ceil(agentText.length / 4)),
+                                rawUsageAvailable: false,
+                                settledAt: new Date().toISOString()
+                            }
+                            : options.command === "gemini"
+                                ? {
+                                    providerId: "gemini",
+                                    model: options.model ?? "flash",
+                                    transport: "cli",
+                                    source: "estimated_fallback",
+                                    inputTokens: estimatedUsage.tokensIn,
+                                    outputTokens: Math.max(estimatedUsage.tokensOut, Math.ceil(agentText.length / 4)),
+                                    rawUsageAvailable: false,
+                                    settledAt: new Date().toISOString()
+                                }
+                                : undefined
+                    });
             const verificationStack = request.context.verificationStack;
             const verification = await runVerification(request.context.verificationPlan, workingDirectory, verifyTimeoutMs, verificationStack, options.spawnImpl);
             // Check for zero-diff (agent ran but made no file changes)
             const repoRoot = request.context.repoRoot;
             let noDiff = false;
             if (repoRoot) {
-                noDiff = await checkNoDiff(repoRoot);
+                noDiff = await checkNoDiff(repoRoot, options.spawnImpl);
             }
             // Extract structured errors from stderr/stdout for better failure context
             const structuredErrors = normalizeStructuredErrors(extractStructuredErrors(agentResult.stderr, agentResult.stdout));
@@ -208,7 +418,11 @@ export function createAgentCliAdapter(options) {
             let scopeViolations = [];
             const scopeCtx = request.context;
             if (repoRoot && (scopeCtx.allowedPaths?.length || scopeCtx.deniedPaths?.length)) {
-                const diffResult = await runSubprocess("git", ["diff", "--name-only", "HEAD"], { cwd: repoRoot, timeoutMs: 5000 });
+                const diffResult = await runSubprocess("git", ["diff", "--name-only", "HEAD"], {
+                    cwd: repoRoot,
+                    timeoutMs: 5000,
+                    spawnImpl: options.spawnImpl
+                });
                 if (diffResult.exitCode === 0 && diffResult.stdout.trim()) {
                     const touchedFiles = diffResult.stdout.trim().split("\n").filter(Boolean);
                     const allowed = scopeCtx.allowedPaths ?? [];
@@ -392,6 +606,7 @@ export function createCodexCliAdapter(options = {}) {
             workingDirectory,
             "--sandbox",
             sandbox,
+            "--json",
             "--color",
             "never",
             ...modelArgs,
@@ -402,6 +617,47 @@ export function createCodexCliAdapter(options = {}) {
     });
 }
 // ---------------------------------------------------------------------------
+// Pre-configured: Gemini CLI
+// ---------------------------------------------------------------------------
+/**
+ * Spawns `gemini --model <model> --prompt "" --approval-mode <mode> --output-format json [...]`.
+ *
+ * The prompt is delivered via stdin while forcing headless mode with `--prompt ""`,
+ * which keeps large MartinLoop prompts off the command line on Windows.
+ *
+ * Requires the Gemini CLI to be installed and authenticated:
+ *   npm install -g @google/gemini-cli
+ */
+export function createGeminiCliAdapter(options = {}) {
+    const model = options.model ?? "flash";
+    const approvalMode = options.approvalMode ?? "yolo";
+    const extraArgs = options.extraArgs ?? [];
+    return createAgentCliAdapter({
+        command: "gemini",
+        adapterIdSuffix: "gemini",
+        model,
+        label: options.label ?? "Gemini CLI adapter",
+        workingDirectory: options.workingDirectory,
+        timeoutMs: options.timeoutMs,
+        verifyTimeoutMs: options.verifyTimeoutMs,
+        supportsJsonOutput: false,
+        spawnImpl: options.spawnImpl,
+        argsBuilder: () => [
+            "--model",
+            model,
+            "--prompt",
+            "",
+            "--approval-mode",
+            approvalMode,
+            ...(options.sandbox ? ["--sandbox"] : []),
+            "--output-format",
+            "json",
+            ...extraArgs
+        ],
+        stdinBuilder: (prompt) => prompt
+    });
+}
+// ---------------------------------------------------------------------------
 // Prompt builder
 //
 // Implements Qralph-style context isolation:
@@ -579,7 +835,11 @@ function extractStructuredErrors(stderr, stdout) {
     }
     return errors.slice(0, 10); // cap at 10 to avoid bloating prompts
 }
-async function checkNoDiff(repoRoot) {
-    const result = await runSubprocess("git", ["diff", "--name-only", "HEAD"], { cwd: repoRoot, timeoutMs: 5000 });
+async function checkNoDiff(repoRoot, spawnImpl) {
+    const result = await runSubprocess("git", ["diff", "--name-only", "HEAD"], {
+        cwd: repoRoot,
+        timeoutMs: 5000,
+        spawnImpl
+    });
     return result.exitCode === 0 && result.stdout.trim().length === 0;
 }

package/dist/vendor/adapters/cli-bridge.d.ts

@@ -26,4 +26,10 @@ export declare function readGitExecutionArtifacts(repoRoot: string, timeoutMs: n
     changedFiles?: string[];
     diffStats?: ReturnType<typeof diffStatsFromNumstat>;
 }>;
+export declare function readGitChangedFiles(repoRoot: string, timeoutMs: number, spawnImpl?: SpawnLike): Promise<string[]>;
+export interface SpawnPlan {
+    command: string;
+    args: string[];
+}
+export declare function createSpawnPlan(command: string, args: string[], cwd: string, preserveRawForInjectedSpawn: boolean): SpawnPlan;
 export declare function splitCommand(command: string): string[];

package/dist/vendor/adapters/cli-bridge.js

@@ -140,22 +140,44 @@ export async function readGitExecutionArtifacts(repoRoot, timeoutMs, spawnImpl)
         ...(diffStats ? { diffStats } : {})
     };
 }
-function createSpawnPlan(command, args, cwd, preserveRawForInjectedSpawn) {
-    if (preserveRawForInjectedSpawn || process.platform !== "win32" || isAbsolute(command)) {
-        return { command, args };
+export async function readGitChangedFiles(repoRoot, timeoutMs, spawnImpl) {
+    const statusResult = await runSubprocess("git", ["status", "-z", "--porcelain=v1", "--untracked-files=all", "--ignore-submodules=all"], { cwd: repoRoot, timeoutMs, spawnImpl });
+    if (statusResult.exitCode !== 0) {
+        return [];
     }
-    const resolved = resolveWindowsCommand(command, cwd);
-    if (!resolved) {
+    return parsePorcelainEntries(statusResult.stdout).filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+export function createSpawnPlan(command, args, cwd, preserveRawForInjectedSpawn) {
+    if (preserveRawForInjectedSpawn || process.platform !== "win32") {
         return { command, args };
     }
-    const extension = extname(resolved).toLowerCase();
+    // Try to resolve the command to an absolute path using the Windows PATH.
+    const resolvedOrUndefined = isAbsolute(command) ? command : resolveWindowsCommand(command, cwd);
+    // If resolution failed (command not found in PATH), fall back to cmd.exe shell execution so
+    // Windows can resolve the command itself — this covers cases like `pnpm` where the npm global
+    // bin directory is present in the shell PATH but not yet visible to this Node.js process.
+    if (resolvedOrUndefined === undefined) {
+        const cmdStr = [quoteWindowsCmdArg(command), ...args.map(quoteWindowsCmdArg)].join(" ");
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            args: ["/d", "/c", cmdStr]
+        };
+    }
+    const extension = extname(resolvedOrUndefined).toLowerCase();
     if (extension === ".cmd" || extension === ".bat") {
+        const cmdStr = [quoteWindowsCmdArg(resolvedOrUndefined), ...args.map(quoteWindowsCmdArg)].join(" ");
         return {
             command: process.env.ComSpec || "cmd.exe",
-            args: ["/d", "/s", "/c", [quoteWindowsCmdArg(resolved), ...args.map(quoteWindowsCmdArg)].join(" ")]
+            args: ["/d", "/s", "/c", cmdStr]
         };
     }
-    return { command: resolved, args };
+    if (extension === ".ps1") {
+        return {
+            command: "powershell.exe",
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", resolvedOrUndefined, ...args]
+        };
+    }
+    return { command: resolvedOrUndefined, args };
 }
 function resolveWindowsCommand(command, cwd) {
     const hasPathSegment = command.includes("\\") || command.includes("/");
@@ -178,11 +200,38 @@ function expandWindowsCommandCandidates(command) {
         return [command];
     }
     const pathExt = process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
-    return pathExt
+    const fromPathExt = pathExt
         .split(";")
         .map((extension) => extension.trim())
         .filter(Boolean)
         .map((extension) => `${command}${extension.toLowerCase()}`);
+    const candidates = [...fromPathExt, `${command}.ps1`];
+    return Array.from(new Set(candidates));
+}
+function parsePorcelainEntries(stdout) {
+    const entries = stdout.split("\u0000").filter((entry) => entry.length > 0);
+    const changedFiles = [];
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry === undefined || entry.length < 4) {
+            continue;
+        }
+        const status = entry.slice(0, 2);
+        const payload = entry.slice(3);
+        if (!payload) {
+            continue;
+        }
+        if (status.includes("R") || status.includes("C")) {
+            const renamedPath = entries[index + 1];
+            if (renamedPath && renamedPath.length > 0) {
+                changedFiles.push(renamedPath);
+                index += 1;
+                continue;
+            }
+        }
+        changedFiles.push(payload);
+    }
+    return changedFiles;
 }
 function windowsPathDirectories() {
     const rawPath = process.env.Path ?? process.env.PATH ?? "";

package/dist/vendor/adapters/codex-launcher.d.ts

@@ -0,0 +1,44 @@
+import { spawnSync } from "node:child_process";
+export interface CliCommandAvailability {
+    command: string;
+    available: boolean;
+    locator: string;
+    detail: string;
+    resolvedPath?: string;
+}
+export type CodexHostPlatform = "windows" | "linux" | "wsl" | "macos";
+export interface CodexHostDiagnosis {
+    hostPlatform: CodexHostPlatform;
+    nativeInstallValid: boolean;
+    warnings: string[];
+    remediation?: string;
+}
+export interface CodexLaunchProbeResult {
+    ok: boolean;
+    summary: string;
+    availability: CliCommandAvailability;
+    diagnosis: CodexHostDiagnosis;
+    command: string;
+    args: string[];
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+}
+type SpawnSyncLike = typeof spawnSync;
+export declare function resolveCliCommandAvailability(command: string, options?: {
+    platform?: NodeJS.Platform;
+    spawnSyncImpl?: SpawnSyncLike;
+}): CliCommandAvailability;
+export declare function detectCodexHostPlatform(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): CodexHostPlatform;
+export declare function diagnoseCodexHost(availability: CliCommandAvailability, options?: {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+}): CodexHostDiagnosis;
+export declare function probeCodexLaunch(input: {
+    workingDirectory: string;
+    availability?: CliCommandAvailability;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    spawnSyncImpl?: SpawnSyncLike;
+}): CodexLaunchProbeResult;
+export {};