martin-loop 0.1.5 → 1.3.0

package/demo/seeded-workspace/README.md

@@ -1,35 +1,35 @@
-# MartinLoop Demo Sandbox
-
-This workspace is the safe public demo copied by `martin-loop demo`.
-
-It is intentionally small:
-
-- `npm test` is green out of the box
-- `martin.config.yaml` keeps the budget tiny
-- the first suggested MartinLoop run can stay in stub mode with `MARTIN_LIVE=false`
-
-## Files
-
-- `src/invoice-summary.js`: tiny module used by the demo task
-- `test/invoice-summary.test.js`: Node test suite
-- `TASKS.md`: suggested objectives for a stub-safe run or a live adapter run
-- `martin.config.yaml`: low-risk governance defaults
-
-## Suggested flow
-
-```sh
-npm install
-npm test
-```
-
-Safe first run:
-
-```sh
-MARTIN_LIVE=false npx martin-loop run "Summarize the demo workspace and confirm the verifier is green" --verify "npm test"
-```
-
-Optional live run:
-
-```sh
-npx martin-loop run "Add support for a discount percentage to summarizeInvoice and update the tests" --verify "npm test" --engine codex
-```
+# MartinLoop Demo Sandbox
+
+This workspace is the safe public demo copied by `martin-loop demo`.
+
+It is intentionally small:
+
+- `npm test` is green out of the box
+- `martin.config.yaml` keeps the budget tiny
+- the first suggested MartinLoop run can stay in stub mode with `MARTIN_LIVE=false`
+
+## Files
+
+- `src/invoice-summary.js`: tiny module used by the demo task
+- `test/invoice-summary.test.js`: Node test suite
+- `TASKS.md`: suggested objectives for a stub-safe run or a live adapter run
+- `martin.config.yaml`: low-risk governance defaults
+
+## Suggested flow
+
+```sh
+npm install
+npm test
+```
+
+Safe first run:
+
+```sh
+MARTIN_LIVE=false npx martin-loop run "Summarize the demo workspace and confirm the verifier is green" --verify "npm test"
+```
+
+Optional live run:
+
+```sh
+npx martin-loop run "Add support for a discount percentage to summarizeInvoice and update the tests" --verify "npm test" --engine codex
+```

package/demo/seeded-workspace/TASKS.md

@@ -1,29 +1,29 @@
-# Suggested Demo Tasks
-
-## Stub-safe first run
-
-Use this when you want to see MartinLoop create a governed run record without spending provider budget:
-
-```text
-Summarize the demo workspace, confirm the verifier command is green, and explain the safest next change to make.
-```
-
-Verifier:
-
-```sh
-npm test
-```
-
-## Optional live run
-
-Use this when you want a real coding task in the sandbox:
-
-```text
-Add support for a discount percentage to summarizeInvoice and update the tests while keeping the existing tax behavior intact.
-```
-
-Verifier:
-
-```sh
-npm test
-```
+# Suggested Demo Tasks
+
+## Stub-safe first run
+
+Use this when you want to see MartinLoop create a governed run record without spending provider budget:
+
+```text
+Summarize the demo workspace, confirm the verifier command is green, and explain the safest next change to make.
+```
+
+Verifier:
+
+```sh
+npm test
+```
+
+## Optional live run
+
+Use this when you want a real coding task in the sandbox:
+
+```text
+Add support for a discount percentage to summarizeInvoice and update the tests while keeping the existing tax behavior intact.
+```
+
+Verifier:
+
+```sh
+npm test
+```

package/demo/seeded-workspace/martin.config.yaml

@@ -1,11 +1,11 @@
-policyProfile: strict_local
-budget:
-  maxUsd: 2
-  softLimitUsd: 1
-  maxIterations: 2
-  maxTokens: 12000
-governance:
-  destructiveActionPolicy: approval
-  telemetryDestination: local-only
-  verifierRules:
-    - npm test
+policyProfile: strict_local
+budget:
+  maxUsd: 2
+  softLimitUsd: 1
+  maxIterations: 2
+  maxTokens: 12000
+governance:
+  destructiveActionPolicy: approval
+  telemetryDestination: local-only
+  verifierRules:
+    - npm test

package/demo/seeded-workspace/package.json

@@ -1,8 +1,8 @@
-{
-  "name": "martin-loop-demo-sandbox",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "test": "node --test"
-  }
-}
+{
+  "name": "martin-loop-demo-sandbox",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/demo/seeded-workspace/src/invoice-summary.js

@@ -1,11 +1,11 @@
-export function summarizeInvoice(items, taxRate = 0) {
-  const subtotal = items.reduce((sum, item) => sum + item.quantity * item.unitPrice, 0);
-  const tax = Number((subtotal * taxRate).toFixed(2));
-  const total = Number((subtotal + tax).toFixed(2));
-
-  return {
-    subtotal: Number(subtotal.toFixed(2)),
-    tax,
-    total
-  };
-}
+export function summarizeInvoice(items, taxRate = 0) {
+  const subtotal = items.reduce((sum, item) => sum + item.quantity * item.unitPrice, 0);
+  const tax = Number((subtotal * taxRate).toFixed(2));
+  const total = Number((subtotal + tax).toFixed(2));
+
+  return {
+    subtotal: Number(subtotal.toFixed(2)),
+    tax,
+    total
+  };
+}

package/demo/seeded-workspace/test/invoice-summary.test.js

@@ -1,20 +1,20 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { summarizeInvoice } from "../src/invoice-summary.js";
-
-test("summarizeInvoice returns subtotal, tax, and total", () => {
-  const result = summarizeInvoice(
-    [
-      { quantity: 2, unitPrice: 19.99 },
-      { quantity: 1, unitPrice: 5.5 }
-    ],
-    0.13
-  );
-
-  assert.deepEqual(result, {
-    subtotal: 45.48,
-    tax: 5.91,
-    total: 51.39
-  });
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { summarizeInvoice } from "../src/invoice-summary.js";
+
+test("summarizeInvoice returns subtotal, tax, and total", () => {
+  const result = summarizeInvoice(
+    [
+      { quantity: 2, unitPrice: 19.99 },
+      { quantity: 1, unitPrice: 5.5 }
+    ],
+    0.13
+  );
+
+  assert.deepEqual(result, {
+    subtotal: 45.48,
+    tax: 5.91,
+    total: 51.39
+  });
+});

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

@@ -0,0 +1 @@
+export declare function calculateIndex(): number;

package/dist/vendor/adapters/counter.js

@@ -0,0 +1,4 @@
+export function calculateIndex() {
+    return 10;
+}
+//# sourceMappingURL=counter.js.map

package/dist/vendor/adapters/git-baseline.d.ts

@@ -0,0 +1,50 @@
+import type { MartinAdapterResult } from "../core/index.js";
+import { type SpawnLike } from "./cli-bridge.js";
+type DiffStats = NonNullable<NonNullable<MartinAdapterResult["execution"]>["diffStats"]>;
+export interface GitBaselineArtifact {
+    startHeadSha: string;
+    startTrackedStatus: string;
+    startTrackedSet: string[];
+    startTrackedDiffSha256: Record<string, string>;
+    startUntrackedSet: string[];
+    startTimestamp: string;
+    worktreeClean: boolean;
+    pilotRepoClass: string | null;
+}
+export interface GitNormalizationArtifact {
+    startHeadSha: string;
+    endHeadShaBeforeNormalization: string;
+    normalizationApplied: boolean;
+    normalizationMode: "reset_mixed_to_start_head" | "none";
+    normalizationSucceeded: boolean;
+    headAfterNormalization: string;
+}
+export interface ScopeSurfaceArtifact {
+    trackedChangedPaths: string[];
+    deletedPaths: string[];
+    newUntrackedPaths: string[];
+    allChangedPaths: string[];
+    changedBaselinePaths: string[];
+    baselineWasClean: boolean;
+    noCodeChange: boolean;
+    diffStats?: DiffStats;
+}
+export declare function captureBaseline(options: {
+    repoRoot: string;
+    timeoutMs: number;
+    spawnImpl?: SpawnLike;
+    pilotRepoClass?: string | null;
+}): Promise<GitBaselineArtifact>;
+export declare function normalizeAdapterGitState(options: {
+    repoRoot: string;
+    baseline: GitBaselineArtifact;
+    timeoutMs: number;
+    spawnImpl?: SpawnLike;
+}): Promise<GitNormalizationArtifact>;
+export declare function collectScopeSurface(options: {
+    repoRoot: string;
+    baseline: GitBaselineArtifact;
+    timeoutMs: number;
+    spawnImpl?: SpawnLike;
+}): Promise<ScopeSurfaceArtifact>;
+export {};

package/dist/vendor/adapters/git-baseline.js

@@ -0,0 +1,233 @@
+import { createHash } from "node:crypto";
+import { runSubprocess } from "./cli-bridge.js";
+import { diffStatsFromNumstat } from "./runtime-support.js";
+export async function captureBaseline(options) {
+    const [startHeadSha, startTrackedStatus, startUntrackedSet] = await Promise.all([
+        readRequiredScalar(options.repoRoot, ["rev-parse", "HEAD"], options.timeoutMs, options.spawnImpl),
+        readOptionalStdout(options.repoRoot, ["status", "--porcelain=v1", "--untracked-files=no"], options.timeoutMs, options.spawnImpl),
+        readLines(options.repoRoot, ["ls-files", "--others", "--exclude-standard"], options.timeoutMs, options.spawnImpl)
+    ]);
+    const startTrackedSet = parsePorcelainTrackedPaths(startTrackedStatus);
+    const startTrackedDiffSha256 = await collectPathDiffHashes({
+        repoRoot: options.repoRoot,
+        baseRef: startHeadSha,
+        paths: startTrackedSet,
+        timeoutMs: options.timeoutMs,
+        spawnImpl: options.spawnImpl
+    });
+    return {
+        startHeadSha,
+        startTrackedStatus,
+        startTrackedSet,
+        startTrackedDiffSha256,
+        startUntrackedSet,
+        startTimestamp: new Date().toISOString(),
+        worktreeClean: startTrackedStatus.trim().length === 0 && startUntrackedSet.length === 0,
+        pilotRepoClass: options.pilotRepoClass ?? null
+    };
+}
+export async function normalizeAdapterGitState(options) {
+    const endHeadShaBeforeNormalization = await readRequiredScalar(options.repoRoot, ["rev-parse", "HEAD"], options.timeoutMs, options.spawnImpl);
+    const normalizationApplied = endHeadShaBeforeNormalization !== options.baseline.startHeadSha;
+    if (!normalizationApplied) {
+        return {
+            startHeadSha: options.baseline.startHeadSha,
+            endHeadShaBeforeNormalization,
+            normalizationApplied: false,
+            normalizationMode: "none",
+            normalizationSucceeded: true,
+            headAfterNormalization: endHeadShaBeforeNormalization
+        };
+    }
+    const resetResult = await runSubprocess("git", ["reset", "--mixed", options.baseline.startHeadSha], {
+        cwd: options.repoRoot,
+        timeoutMs: options.timeoutMs,
+        spawnImpl: options.spawnImpl
+    });
+    const headAfterNormalization = resetResult.exitCode === 0
+        ? await readRequiredScalar(options.repoRoot, ["rev-parse", "HEAD"], options.timeoutMs, options.spawnImpl)
+        : endHeadShaBeforeNormalization;
+    return {
+        startHeadSha: options.baseline.startHeadSha,
+        endHeadShaBeforeNormalization,
+        normalizationApplied: true,
+        normalizationMode: "reset_mixed_to_start_head",
+        normalizationSucceeded: resetResult.exitCode === 0 && headAfterNormalization === options.baseline.startHeadSha,
+        headAfterNormalization
+    };
+}
+export async function collectScopeSurface(options) {
+    const [nameStatusResult, numstatResult, endUntrackedSet] = await Promise.all([
+        runSubprocess("git", ["diff", "--name-status", "--no-renames", options.baseline.startHeadSha], {
+            cwd: options.repoRoot,
+            timeoutMs: options.timeoutMs,
+            spawnImpl: options.spawnImpl
+        }),
+        runSubprocess("git", ["diff", "--numstat", "--no-renames", options.baseline.startHeadSha], {
+            cwd: options.repoRoot,
+            timeoutMs: options.timeoutMs,
+            spawnImpl: options.spawnImpl
+        }),
+        readLines(options.repoRoot, ["ls-files", "--others", "--exclude-standard"], options.timeoutMs, options.spawnImpl)
+    ]);
+    const trackedChangedPaths = [];
+    const deletedPaths = [];
+    const changedBaselinePaths = [];
+    const seenTracked = new Set();
+    const seenDeleted = new Set();
+    const baselineTracked = new Set(options.baseline.startTrackedSet.map(normalizeGitPath));
+    const candidateTrackedPaths = [];
+    if (nameStatusResult.exitCode === 0) {
+        for (const rawLine of splitLines(nameStatusResult.stdout)) {
+            const parts = rawLine.split(/\t+/u).map((entry) => normalizeGitPath(entry));
+            const status = parts[0]?.trim() ?? "";
+            const candidatePath = parts.at(-1);
+            if (!status || !candidatePath) {
+                continue;
+            }
+            if (status.startsWith("D")) {
+                candidateTrackedPaths.push({ path: candidatePath, deleted: true });
+                continue;
+            }
+            candidateTrackedPaths.push({ path: candidatePath, deleted: false });
+        }
+    }
+    const endTrackedDiffSha256 = await collectPathDiffHashes({
+        repoRoot: options.repoRoot,
+        baseRef: options.baseline.startHeadSha,
+        paths: candidateTrackedPaths.map((candidate) => candidate.path),
+        timeoutMs: options.timeoutMs,
+        spawnImpl: options.spawnImpl
+    });
+    for (const candidate of candidateTrackedPaths) {
+        const baselineHash = options.baseline.startTrackedDiffSha256[candidate.path];
+        const endHash = endTrackedDiffSha256[candidate.path];
+        const changedSinceBaseline = !baselineTracked.has(candidate.path) ||
+            baselineHash === undefined ||
+            endHash === undefined ||
+            baselineHash !== endHash;
+        if (!changedSinceBaseline) {
+            continue;
+        }
+        if (baselineTracked.has(candidate.path)) {
+            changedBaselinePaths.push(candidate.path);
+        }
+        if (candidate.deleted) {
+            if (!seenDeleted.has(candidate.path)) {
+                seenDeleted.add(candidate.path);
+                deletedPaths.push(candidate.path);
+            }
+            continue;
+        }
+        if (!seenTracked.has(candidate.path)) {
+            seenTracked.add(candidate.path);
+            trackedChangedPaths.push(candidate.path);
+        }
+    }
+    const startingUntracked = new Set(options.baseline.startUntrackedSet.map(normalizeGitPath));
+    const newUntrackedPaths = endUntrackedSet
+        .map(normalizeGitPath)
+        .filter((entry) => !startingUntracked.has(entry));
+    const allChangedPaths = uniquePaths([
+        ...trackedChangedPaths,
+        ...deletedPaths,
+        ...newUntrackedPaths
+    ]);
+    const diffStats = allChangedPaths.length > 0
+        ? await collectDiffStats({
+            repoRoot: options.repoRoot,
+            baseRef: options.baseline.startHeadSha,
+            paths: allChangedPaths,
+            fallbackStdout: numstatResult.stdout,
+            fallbackExitCode: numstatResult.exitCode,
+            timeoutMs: options.timeoutMs,
+            spawnImpl: options.spawnImpl
+        })
+        : undefined;
+    return {
+        trackedChangedPaths,
+        deletedPaths,
+        newUntrackedPaths,
+        allChangedPaths,
+        changedBaselinePaths: uniquePaths(changedBaselinePaths),
+        baselineWasClean: options.baseline.worktreeClean,
+        noCodeChange: allChangedPaths.length === 0,
+        ...(diffStats ? { diffStats } : {})
+    };
+}
+function uniquePaths(paths) {
+    return [...new Set(paths.map(normalizeGitPath).filter(Boolean))];
+}
+function splitLines(stdout) {
+    return stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function parsePorcelainTrackedPaths(status) {
+    const paths = [];
+    for (const line of status.split(/\r?\n/u).filter(Boolean)) {
+        const code = line.slice(0, 2);
+        if (code === "??" || code === "!!") {
+            continue;
+        }
+        const rawPath = line.slice(3).trim();
+        if (!rawPath) {
+            continue;
+        }
+        for (const path of rawPath.split(" -> ")) {
+            paths.push(path);
+        }
+    }
+    return uniquePaths(paths);
+}
+async function collectPathDiffHashes(options) {
+    const hashes = {};
+    for (const path of uniquePaths(options.paths)) {
+        const result = await runSubprocess("git", ["diff", "--binary", options.baseRef, "--", path], {
+            cwd: options.repoRoot,
+            timeoutMs: options.timeoutMs,
+            spawnImpl: options.spawnImpl
+        });
+        hashes[path] = sha256Text(JSON.stringify({
+            stdout: result.stdout,
+            stderr: result.exitCode === 0 ? "" : result.stderr,
+            exitCode: result.exitCode
+        }));
+    }
+    return hashes;
+}
+async function collectDiffStats(options) {
+    const result = await runSubprocess("git", ["diff", "--numstat", "--no-renames", options.baseRef, "--", ...uniquePaths(options.paths)], {
+        cwd: options.repoRoot,
+        timeoutMs: options.timeoutMs,
+        spawnImpl: options.spawnImpl
+    });
+    if (result.exitCode === 0) {
+        return diffStatsFromNumstat(result.stdout);
+    }
+    return options.fallbackExitCode === 0 ? diffStatsFromNumstat(options.fallbackStdout) : undefined;
+}
+function normalizeGitPath(path) {
+    return path.replace(/\\/gu, "/").trim();
+}
+function sha256Text(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+async function readRequiredScalar(repoRoot, args, timeoutMs, spawnImpl) {
+    const result = await runSubprocess("git", args, { cwd: repoRoot, timeoutMs, spawnImpl });
+    if (result.exitCode !== 0) {
+        const detail = result.stderr.trim() || result.stdout.trim() || args.join(" ");
+        throw new Error(`Git baseline command failed: ${detail}`);
+    }
+    return result.stdout.trim();
+}
+async function readOptionalStdout(repoRoot, args, timeoutMs, spawnImpl) {
+    const result = await runSubprocess("git", args, { cwd: repoRoot, timeoutMs, spawnImpl });
+    return result.exitCode === 0 ? result.stdout : "";
+}
+async function readLines(repoRoot, args, timeoutMs, spawnImpl) {
+    const result = await runSubprocess("git", args, { cwd: repoRoot, timeoutMs, spawnImpl });
+    return result.exitCode === 0 ? splitLines(result.stdout) : [];
+}
+//# sourceMappingURL=git-baseline.js.map

package/dist/vendor/adapters/openrouter-adapter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * OpenRouter Adapter — real LLM-backed coding agent via OpenRouter API.
+ *
+ * Uses function-calling (tool use) to give the LLM read_file, write_file,
+ * and run_command tools. Loops until verification passes or max turns reached.
+ *
+ * Compatible with any OpenRouter model that supports function calling:
+ * openai/gpt-4o, openai/gpt-4o-mini, anthropic/claude-3.5-sonnet, etc.
+ */
+import type { MartinAdapter } from "../core/index.js";
+export declare function createOpenRouterAdapter(options: {
+    apiKey: string;
+    model?: string;
+    maxTurns?: number;
+}): MartinAdapter;