martin-loop 0.1.2 → 0.1.3

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

@@ -0,0 +1,127 @@
+import { spawn } from "node:child_process";
+import { isAbsolute } from "node:path";
+import { diffStatsFromNumstat } from "./runtime-support.js";
+export async function runSubprocess(command, args, options) {
+    return new Promise((resolve) => {
+        let timedOut = false;
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        const stdinMode = options.stdinData !== undefined ? "pipe" : "ignore";
+        let proc;
+        try {
+            proc = (options.spawnImpl ?? spawn)(command, args, {
+                cwd: options.cwd,
+                stdio: [stdinMode, "pipe", "pipe"],
+                env: process.env,
+                // shell: true is required on Windows to resolve PATH shims (e.g. claude.cmd).
+                // Avoid it for absolute .exe paths because cmd.exe can split paths with spaces.
+                // Prompt content is never passed as a shell argument, it goes via stdin, so
+                // injection risk from the DEP0190 warning does not apply here.
+                shell: shouldUseWindowsShell(command)
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            resolve({
+                exitCode: 1,
+                stdout: "",
+                stderr: message,
+                timedOut: false
+            });
+            return;
+        }
+        if (options.stdinData !== undefined && proc.stdin) {
+            proc.stdin.write(options.stdinData, "utf8");
+            proc.stdin.end();
+        }
+        proc.stdout?.on("data", (chunk) => {
+            stdoutChunks.push(chunk);
+        });
+        proc.stderr?.on("data", (chunk) => {
+            stderrChunks.push(chunk);
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            proc.kill("SIGTERM");
+        }, options.timeoutMs);
+        proc.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({
+                exitCode: code ?? 1,
+                stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf8"),
+                timedOut
+            });
+        });
+        proc.on("error", (error) => {
+            clearTimeout(timer);
+            resolve({
+                exitCode: 1,
+                stdout: "",
+                stderr: error.message,
+                timedOut: false
+            });
+        });
+    });
+}
+export async function runVerification(commands, cwd, timeoutMs, verificationStack, spawnImpl) {
+    const steps = verificationStack && verificationStack.length > 0
+        ? verificationStack.map((step) => ({
+            command: step.command,
+            fastFail: step.fastFail !== false
+        }))
+        : commands.map((command) => ({ command, fastFail: true }));
+    if (steps.length === 0) {
+        return { passed: true, summary: "No verification commands specified." };
+    }
+    const failedSteps = [];
+    for (const step of steps) {
+        const parts = step.command.trim().split(/\s+/u);
+        const bin = parts[0];
+        const args = parts.slice(1);
+        if (!bin) {
+            continue;
+        }
+        const result = await runSubprocess(bin, args, { cwd, timeoutMs, spawnImpl });
+        if (result.timedOut) {
+            return { passed: false, summary: `Verification timed out: ${step.command}` };
+        }
+        if (result.exitCode !== 0) {
+            const detail = truncate(result.stderr.trim() || result.stdout.trim(), 500);
+            const summary = `Verification failed: ${step.command}\n${detail}`;
+            if (step.fastFail) {
+                return { passed: false, summary };
+            }
+            failedSteps.push(step.command);
+        }
+    }
+    if (failedSteps.length > 0) {
+        return { passed: false, summary: `Failed steps: ${failedSteps.join(", ")}` };
+    }
+    return { passed: true, summary: `All ${String(steps.length)} verification step(s) passed.` };
+}
+export async function readGitExecutionArtifacts(repoRoot, timeoutMs, spawnImpl) {
+    const changedFilesResult = await runSubprocess("git", ["diff", "--name-only", "HEAD"], { cwd: repoRoot, timeoutMs, spawnImpl });
+    const numstatResult = await runSubprocess("git", ["diff", "--numstat", "HEAD"], { cwd: repoRoot, timeoutMs, spawnImpl });
+    const changedFiles = changedFilesResult.exitCode === 0
+        ? changedFilesResult.stdout
+            .split(/\r?\n/u)
+            .map((entry) => entry.trim())
+            .filter(Boolean)
+        : [];
+    const diffStats = numstatResult.exitCode === 0 ? diffStatsFromNumstat(numstatResult.stdout) : undefined;
+    return {
+        ...(changedFiles.length > 0 ? { changedFiles } : {}),
+        ...(diffStats ? { diffStats } : {})
+    };
+}
+function shouldUseWindowsShell(command) {
+    return process.platform === "win32" && !isAbsolute(command);
+}
+function truncate(text, maxLength) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `...${text.slice(-(maxLength - 3))}`;
+}
+//# sourceMappingURL=cli-bridge.js.map

package/dist/vendor/adapters/direct-provider.d.ts

@@ -0,0 +1,10 @@
+import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../core/index.js";
+export interface DirectProviderAdapterOptions {
+    providerId: string;
+    model: string;
+    label?: string;
+    transport?: "http" | "routed_http";
+    capabilities?: Partial<NonNullable<MartinAdapter["metadata"]["capabilities"]>>;
+    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export declare function createDirectProviderAdapter(options: DirectProviderAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/direct-provider.js

@@ -0,0 +1,41 @@
+import { createAdapterCapabilities } from "./runtime-support.js";
+export function createDirectProviderAdapter(options) {
+    return {
+        adapterId: `direct:${options.providerId}:${options.model}`,
+        kind: "direct-provider",
+        label: options.label ?? `Direct provider (${options.providerId}/${options.model})`,
+        metadata: {
+            providerId: options.providerId,
+            model: options.model,
+            transport: options.transport ?? "http",
+            capabilities: createAdapterCapabilities({
+                usageSettlement: true,
+                structuredErrors: true,
+                ...options.capabilities
+            })
+        },
+        async execute(request) {
+            if (options.responder) {
+                return await options.responder(request);
+            }
+            return {
+                status: "failed",
+                summary: `Direct provider ${options.providerId}/${options.model} is not configured for live inference.`,
+                usage: {
+                    actualUsd: 0,
+                    tokensIn: 0,
+                    tokensOut: 0,
+                    provenance: "unavailable"
+                },
+                verification: {
+                    passed: false,
+                    summary: "No live provider request was attempted."
+                },
+                failure: {
+                    message: `Direct provider ${options.providerId}/${options.model} is not configured for live inference. environment_mismatch`
+                }
+            };
+        }
+    };
+}
+//# sourceMappingURL=direct-provider.js.map

package/dist/vendor/adapters/index.d.ts

@@ -0,0 +1,5 @@
+export { createDirectProviderAdapter, type DirectProviderAdapterOptions } from "./direct-provider.js";
+export { createStubDirectProviderAdapter, type StubDirectProviderAdapterOptions } from "./stub-direct-provider.js";
+export { createStubAgentCliAdapter, type StubAgentCliAdapterOptions } from "./stub-agent-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter, type AgentCliAdapterOptions, type ClaudeCliAdapterOptions, type CodexCliAdapterOptions, type CliArgsBuilder } from "./claude-cli.js";
+export type { SpawnLike, SubprocessResult, VerificationOutcome } from "./cli-bridge.js";

package/dist/vendor/adapters/index.js

@@ -0,0 +1,5 @@
+export { createDirectProviderAdapter } from "./direct-provider.js";
+export { createStubDirectProviderAdapter } from "./stub-direct-provider.js";
+export { createStubAgentCliAdapter } from "./stub-agent-cli.js";
+export { createAgentCliAdapter, createClaudeCliAdapter, createCodexCliAdapter } from "./claude-cli.js";
+//# sourceMappingURL=index.js.map

package/dist/vendor/adapters/runtime-support.d.ts

@@ -0,0 +1,14 @@
+import type { MartinAdapter, MartinAdapterResult } from "../core/index.js";
+type StructuredError = NonNullable<NonNullable<MartinAdapterResult["execution"]>["structuredErrors"]>[number];
+type DiffStats = NonNullable<NonNullable<MartinAdapterResult["execution"]>["diffStats"]>;
+export declare function createAdapterCapabilities(overrides?: Partial<NonNullable<MartinAdapter["metadata"]["capabilities"]>>): NonNullable<MartinAdapter["metadata"]["capabilities"]>;
+export declare function normalizeUsage(input: {
+    actualUsd?: number;
+    estimatedUsd?: number;
+    tokensIn?: number;
+    tokensOut?: number;
+    provenance?: MartinAdapterResult["usage"]["provenance"];
+}): MartinAdapterResult["usage"];
+export declare function diffStatsFromNumstat(stdout: string): DiffStats | undefined;
+export declare function normalizeStructuredErrors(errors: StructuredError[] | undefined): StructuredError[];
+export {};

package/dist/vendor/adapters/runtime-support.js

@@ -0,0 +1,52 @@
+export function createAdapterCapabilities(overrides = {}) {
+    return {
+        preflight: true,
+        usageSettlement: false,
+        diffArtifacts: false,
+        structuredErrors: false,
+        cachingSignals: false,
+        ...overrides
+    };
+}
+export function normalizeUsage(input) {
+    const provenance = input.provenance ??
+        (input.estimatedUsd !== undefined ? "estimated" : "actual");
+    const actualUsd = provenance === "estimated"
+        ? input.estimatedUsd ?? input.actualUsd ?? 0
+        : input.actualUsd ?? 0;
+    return {
+        actualUsd: roundUsd(actualUsd),
+        ...(input.estimatedUsd !== undefined
+            ? { estimatedUsd: roundUsd(input.estimatedUsd) }
+            : {}),
+        tokensIn: input.tokensIn ?? 0,
+        tokensOut: input.tokensOut ?? 0,
+        provenance
+    };
+}
+export function diffStatsFromNumstat(stdout) {
+    const lines = stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length === 0) {
+        return undefined;
+    }
+    let filesChanged = 0;
+    let addedLines = 0;
+    let deletedLines = 0;
+    for (const line of lines) {
+        const [added, deleted] = line.split(/\s+/u);
+        filesChanged += 1;
+        addedLines += Number(added) || 0;
+        deletedLines += Number(deleted) || 0;
+    }
+    return { filesChanged, addedLines, deletedLines };
+}
+export function normalizeStructuredErrors(errors) {
+    return errors?.slice(0, 10) ?? [];
+}
+function roundUsd(value) {
+    return Math.round(value * 1_000_000) / 1_000_000;
+}
+//# sourceMappingURL=runtime-support.js.map

package/dist/vendor/adapters/stub-agent-cli.d.ts

@@ -0,0 +1,8 @@
+import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../core/index.js";
+export interface StubAgentCliAdapterOptions {
+    command: string[];
+    profile?: string;
+    label?: string;
+    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export declare function createStubAgentCliAdapter(options: StubAgentCliAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/stub-agent-cli.js

@@ -0,0 +1,41 @@
+import { createAdapterCapabilities } from "./runtime-support.js";
+export function createStubAgentCliAdapter(options) {
+    const metadata = {
+        command: options.command.join(" "),
+        providerId: "agent-cli",
+        model: options.profile ?? options.command[0] ?? "default",
+        transport: "cli",
+        capabilities: createAdapterCapabilities(),
+        ...(options.profile ? { profile: options.profile } : {})
+    };
+    return {
+        adapterId: `agent-cli:${options.command.join(":")}`,
+        kind: "agent-cli",
+        label: options.label ?? `Stub agent CLI (${options.command.join(" ")})`,
+        metadata,
+        async execute(request) {
+            if (options.responder) {
+                return await options.responder(request);
+            }
+            return {
+                status: "failed",
+                summary: `Stub agent CLI ${options.command.join(" ")} did not execute a live session.`,
+                usage: {
+                    actualUsd: 0,
+                    tokensIn: 0,
+                    tokensOut: 0,
+                    provenance: "unavailable"
+                },
+                verification: {
+                    passed: false,
+                    summary: "No CLI execution was attempted."
+                },
+                failure: {
+                    message: `Agent CLI ${options.command.join(" ")} is not configured for live execution.`,
+                    classHint: "environment_mismatch"
+                }
+            };
+        }
+    };
+}
+//# sourceMappingURL=stub-agent-cli.js.map

package/dist/vendor/adapters/stub-direct-provider.d.ts

@@ -0,0 +1,8 @@
+import type { MartinAdapter, MartinAdapterRequest, MartinAdapterResult } from "../core/index.js";
+export interface StubDirectProviderAdapterOptions {
+    providerId: string;
+    model: string;
+    label?: string;
+    responder?: (request: MartinAdapterRequest) => Promise<MartinAdapterResult> | MartinAdapterResult;
+}
+export declare function createStubDirectProviderAdapter(options: StubDirectProviderAdapterOptions): MartinAdapter;

package/dist/vendor/adapters/stub-direct-provider.js

@@ -0,0 +1,10 @@
+import { createDirectProviderAdapter } from "./direct-provider.js";
+export function createStubDirectProviderAdapter(options) {
+    return createDirectProviderAdapter({
+        providerId: options.providerId,
+        model: options.model,
+        label: options.label ?? `Stub direct provider (${options.providerId}/${options.model})`,
+        responder: options.responder
+    });
+}
+//# sourceMappingURL=stub-direct-provider.js.map

package/dist/vendor/cli/bin/martin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/vendor/cli/bin/martin.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { executeCli } from "../index.js";
+const args = process.argv.slice(2);
+executeCli(args)
+    .then((result) => {
+    if (result.stdout) {
+        process.stdout.write(`${result.stdout}\n`);
+    }
+    if (result.stderr) {
+        process.stderr.write(`${result.stderr}\n`);
+    }
+    process.exitCode = result.exitCode;
+})
+    .catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=martin.js.map

package/dist/vendor/cli/index.d.ts

@@ -0,0 +1,39 @@
+import { type LoopBudget } from "../contracts/index.js";
+export type RunCommandRequest = {
+    workspaceId: string;
+    projectId: string;
+    title: string;
+    objective: string;
+    verificationPlan: string[];
+    metadata: Record<string, string>;
+    budget: LoopBudget;
+    configPath?: string;
+    cwd?: string;
+    model?: string;
+    engine?: string;
+    allowedPaths?: string[];
+    deniedPaths?: string[];
+    acceptanceCriteria?: string[];
+};
+export type ParsedCliArguments = {
+    command: "help";
+} | {
+    command: "run";
+    request: RunCommandRequest;
+} | {
+    command: "bench";
+    suiteId: string;
+} | {
+    command: "inspect";
+    file: string;
+} | {
+    command: "resume";
+    loopId: string;
+};
+export declare function executeCli(args: string[]): Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function parseCliArguments(args: string[]): ParsedCliArguments;
+export declare function renderCliHelp(): string;