@martinloop/mcp 0.8.6 → 0.8.8

package/dist/vendor/core/test-integrity.js

@@ -16,8 +16,10 @@
  * This module provides the analysis primitives. The verification pipeline
  * calls these during the post-run verification step.
  */
-import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { lstatSync, readFileSync, readdirSync, existsSync } from "node:fs";
 import { join, relative } from "node:path";
+import { extractTestSurface, hasTestSurface, testSurfaceWeakened } from "./test-surface.js";
 const TEST_FILE_PATTERNS = [
     /\.test\.[tj]sx?$/,
     /\.spec\.[tj]sx?$/,
@@ -195,3 +197,114 @@ export function validateTestIntegrity(rootDir, preRunTestSnapshot, preRunSourceF
         summary
     };
 }
+const TEST_PATH_PATTERNS = [
+    /\.(?:test|spec)\.[cm]?[jt]sx?$/u,
+    /(?:^|\/)(?:__tests__|tests?)\//u,
+    /(?:^|\/)test_[^/]+\.py$/u,
+    /_test\.(?:py|go)$/u
+];
+/**
+ * Repo-relative path check for test sources, covering JS/TS naming, test
+ * directories at any depth (including the repo root), Python, and Go.
+ */
+export function isTestPath(filePath) {
+    const normalized = filePath.replace(/\\/gu, "/").replace(/^\.\//u, "");
+    return TEST_PATH_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+/**
+ * Existing test files whose assertions the attempt removed or altered, whose cases it
+ * dropped or skipped, or which it deleted, compared with the boundary commit. New test
+ * files, appended cases, and edits to imports, setup or formatting are not reported.
+ * Files with no recognizable test surface (data, golden and snapshot files, unknown
+ * frameworks) fall back to the strict rule: any removed line counts. Changes committed
+ * by the attempt are included because the comparison is against `baseRef`, not HEAD.
+ */
+export function findWeakenedTestFiles(input) {
+    const candidates = [...new Set(input.changedFiles.map((file) => file.replace(/\\/gu, "/")))]
+        .filter(isTestPath)
+        .sort();
+    if (candidates.length === 0) {
+        return [];
+    }
+    const changedLines = listChangedTestFiles(input.repoRoot, input.baseRef, candidates);
+    for (const filePath of candidates) {
+        if (!changedLines.has(filePath) &&
+            readBaseContent(input.repoRoot, input.baseRef, filePath) === undefined &&
+            readWorkingContent(input.repoRoot, filePath) !== undefined) {
+            // Untracked files are absent from `git diff --numstat` but still belong
+            // to the caller's observed changed-file set.
+            changedLines.set(filePath, false);
+        }
+    }
+    return [...changedLines.entries()]
+        .filter(([filePath, removedLines]) => isWeakened(input, filePath, removedLines))
+        .map(([filePath]) => filePath)
+        .sort();
+}
+/** Modified files among `candidates`, with whether they lost a line (or are binary). */
+function listChangedTestFiles(repoRoot, baseRef, candidates) {
+    const result = spawnSync("git", ["diff", "--numstat", "--no-renames", "-z", baseRef, "--", ...candidates], { cwd: repoRoot, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+    if (result.status !== 0 || typeof result.stdout !== "string") {
+        const detail = typeof result.stderr === "string" ? result.stderr.trim() : "";
+        throw new Error(`Test-change inspection failed: ${detail || `git exited with ${String(result.status)}`}`);
+    }
+    const changed = new Map();
+    for (const record of result.stdout.split("\0")) {
+        const [additions, deletions, filePath] = record.split("\t");
+        if (filePath && additions !== undefined && deletions !== undefined) {
+            changed.set(filePath.trim(), deletions === "-" || Number(deletions) > 0);
+        }
+    }
+    return changed;
+}
+/** Cap on file size the surface analysis reads; larger files use the strict rule. */
+const MAX_SURFACE_BYTES = 2 * 1024 * 1024;
+const BASE_CONTENT_UNINSPECTABLE = Symbol("base-content-uninspectable");
+function isWeakened(input, filePath, removedLines) {
+    const before = readBaseContent(input.repoRoot, input.baseRef, filePath);
+    if (before === BASE_CONTENT_UNINSPECTABLE) {
+        return true;
+    }
+    if (before === undefined) {
+        const after = readWorkingContent(input.repoRoot, filePath);
+        // New tests are welcome, but focus/skip/expected-failure markers can still
+        // suppress the authoritative suite and therefore require approval.
+        return after === undefined || testSurfaceWeakened("", after, filePath);
+    }
+    const after = readWorkingContent(input.repoRoot, filePath);
+    if (after === undefined) {
+        // Deleted, replaced by a link, unreadable or oversized: cannot prove it still asserts.
+        return true;
+    }
+    if (!hasTestSurface(extractTestSurface(before, filePath))) {
+        return removedLines || testSurfaceWeakened(before, after, filePath);
+    }
+    return testSurfaceWeakened(before, after, filePath);
+}
+function readBaseContent(repoRoot, baseRef, filePath) {
+    const exists = spawnSync("git", ["cat-file", "-e", `${baseRef}:${filePath}`], { cwd: repoRoot });
+    if (exists.status !== 0) {
+        return undefined;
+    }
+    const result = spawnSync("git", ["show", `${baseRef}:${filePath}`], {
+        cwd: repoRoot,
+        encoding: "utf8",
+        maxBuffer: MAX_SURFACE_BYTES * 2
+    });
+    return result.status === 0 && typeof result.stdout === "string" && result.stdout.length <= MAX_SURFACE_BYTES
+        ? result.stdout
+        : BASE_CONTENT_UNINSPECTABLE;
+}
+function readWorkingContent(repoRoot, filePath) {
+    const absolutePath = join(repoRoot, filePath);
+    try {
+        const stats = lstatSync(absolutePath);
+        if (!stats.isFile() || stats.size > MAX_SURFACE_BYTES) {
+            return undefined;
+        }
+        return readFileSync(absolutePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/vendor/core/test-surface.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Test surface: what a test file asserts, how many cases it declares and how many it skips.
+ *
+ * Weakening is judged on this surface rather than on raw removed lines, so ordinary edits
+ * (growing an import list, reformatting, appending cases) are allowed while a removed or
+ * altered assertion, a dropped case or a newly skipped case is not.
+ *
+ * The extractor is language-agnostic and heuristic. It is comment- and string-aware so a
+ * commented-out assertion does not count as present. Files with no recognizable surface
+ * (data, golden and snapshot files, unknown frameworks) are reported as empty so callers
+ * can fall back to a stricter rule.
+ */
+export interface TestSurface {
+    /** Whitespace-normalized assertion expressions, in source order. */
+    assertions: string[];
+    /** Declared test cases. */
+    cases: number;
+    /** Skip, todo or disable markers. */
+    skips: number;
+}
+export declare function hasTestSurface(surface: TestSurface): boolean;
+export declare function extractTestSurface(content: string, path?: string): TestSurface;
+/**
+ * True when `after` removes or alters an assertion, declares fewer cases, or skips more
+ * cases than `before`. Added assertions and cases never count as weakening.
+ */
+export declare function testSurfaceWeakened(before: string, after: string, path?: string): boolean;

package/dist/vendor/core/test-surface.js

@@ -0,0 +1,231 @@
+/**
+ * Test surface: what a test file asserts, how many cases it declares and how many it skips.
+ *
+ * Weakening is judged on this surface rather than on raw removed lines, so ordinary edits
+ * (growing an import list, reformatting, appending cases) are allowed while a removed or
+ * altered assertion, a dropped case or a newly skipped case is not.
+ *
+ * The extractor is language-agnostic and heuristic. It is comment- and string-aware so a
+ * commented-out assertion does not count as present. Files with no recognizable surface
+ * (data, golden and snapshot files, unknown frameworks) are reported as empty so callers
+ * can fall back to a stricter rule.
+ */
+const HASH_COMMENT_EXTENSIONS = new Set(["py", "rb", "sh", "bash", "yaml", "yml", "toml", "pl", "r"]);
+const SLASH_ONLY_EXTENSIONS = new Set([
+    "js", "jsx", "ts", "tsx", "mjs", "cjs", "mts", "cts", "go", "rs", "java", "kt", "kts", "cs",
+    "swift", "scala", "c", "cc", "cpp", "h", "hpp", "dart", "php"
+]);
+const ASSERTION_START = /\b(?:assert\w*|expect|should\w*)\b[\w.!]*\s*\(|\bt\.(?:Error|Errorf|Fatal|Fatalf|Fail|FailNow)\s*\(|\brequire\.[A-Z]\w*\s*\(/giu;
+const PYTHON_BARE_ASSERT = /^[ \t]*assert[ \t]+(?!\()[^\n]*/gmu;
+const CHAIN_CONTINUATION = /\s*\.\s*[\w$]+(?:\s*\.\s*[\w$]+)*\s*\(/uy;
+const CASE_PATTERNS = [
+    /\b(?:test|it|specify)(?:\s*\.\s*(?:each|only|concurrent|serial|failing|sequential))*\s*\(/gu,
+    /\b(?:it|specify|scenario)[ \t]+['"]/gu,
+    /^[ \t]*(?:async[ \t]+)?def[ \t]+test\w*[ \t]*\(/gmu,
+    /^func[ \t]+Test\w*[ \t]*\(/gmu,
+    /#\[(?:tokio::)?test\b/gu,
+    /@Test\b|\[Test\]|\[Fact\]|\[Theory\]/gu
+];
+const SKIP_PATTERNS = [
+    /\b(?:test|it|describe|context|suite)\s*\.\s*(?:skip|todo)\b/gu,
+    /\b(?:test|it)\s*\.\s*failing\b/gu,
+    /\b(?:test|it|describe|context|suite|specify)\s*\.\s*only\b/gu,
+    /\bf(?:it|describe)\s*\(/gu,
+    /\bx(?:it|describe|test|context)\s*\(/gu,
+    /@pytest\.mark\.(?:skip\w*|xfail)|\bpytest\.(?:skip|xfail)\s*\(|@unittest\.(?:skip\w*|expectedFailure)|\bself\.skipTest\s*\(/gu,
+    /\bt\.Skip\w*\s*\(/gu,
+    /#\[ignore\b/gu,
+    /@Disabled\b|@Ignore\b/gu
+];
+export function hasTestSurface(surface) {
+    return surface.assertions.length > 0 || surface.cases > 0;
+}
+export function extractTestSurface(content, path) {
+    const code = stripComments(content, commentStyleFor(path));
+    return {
+        assertions: [...extractCallAssertions(code), ...extractBareAssertions(code)],
+        cases: CASE_PATTERNS.reduce((total, pattern) => total + countMatches(code, pattern), 0),
+        skips: SKIP_PATTERNS.reduce((total, pattern) => total + countMatches(code, pattern), 0)
+    };
+}
+/**
+ * True when `after` removes or alters an assertion, declares fewer cases, or skips more
+ * cases than `before`. Added assertions and cases never count as weakening.
+ */
+export function testSurfaceWeakened(before, after, path) {
+    const earlier = extractTestSurface(before, path);
+    const later = extractTestSurface(after, path);
+    if (later.cases < earlier.cases || later.skips > earlier.skips) {
+        return true;
+    }
+    const remaining = new Map();
+    for (const assertion of later.assertions) {
+        remaining.set(assertion, (remaining.get(assertion) ?? 0) + 1);
+    }
+    for (const assertion of earlier.assertions) {
+        const left = remaining.get(assertion) ?? 0;
+        if (left === 0) {
+            return true;
+        }
+        remaining.set(assertion, left - 1);
+    }
+    return false;
+}
+function commentStyleFor(path) {
+    const extension = path?.split(".").at(-1)?.toLowerCase() ?? "";
+    if (HASH_COMMENT_EXTENSIONS.has(extension)) {
+        return { slash: false, hash: true };
+    }
+    if (SLASH_ONLY_EXTENSIONS.has(extension)) {
+        return { slash: true, hash: extension === "php" };
+    }
+    return { slash: true, hash: true };
+}
+/** Replaces comments with spaces (newlines kept) while leaving string literals untouched. */
+function stripComments(content, style) {
+    let output = "";
+    let index = 0;
+    while (index < content.length) {
+        const char = content[index];
+        const next = content[index + 1];
+        if (isQuote(char)) {
+            const end = skipString(content, index);
+            output += content.slice(index, end);
+            index = end;
+        }
+        else if (style.slash && char === "/" && next === "/") {
+            const end = lineEnd(content, index);
+            output += " ".repeat(end - index);
+            index = end;
+        }
+        else if (style.slash && char === "/" && next === "*") {
+            const close = content.indexOf("*/", index + 2);
+            const end = close === -1 ? content.length : close + 2;
+            output += content.slice(index, end).replace(/[^\n]/gu, " ");
+            index = end;
+        }
+        else if (style.hash && char === "#" && next !== "[" && next !== "!") {
+            const end = lineEnd(content, index);
+            output += " ".repeat(end - index);
+            index = end;
+        }
+        else {
+            output += char;
+            index += 1;
+        }
+    }
+    return output;
+}
+function extractCallAssertions(code) {
+    const assertions = [];
+    const pattern = new RegExp(ASSERTION_START.source, ASSERTION_START.flags);
+    let cursor = 0;
+    let match;
+    while ((match = pattern.exec(code)) !== null) {
+        if (match.index < cursor) {
+            continue;
+        }
+        let end = balancedEnd(code, match.index + match[0].length - 1);
+        for (;;) {
+            const continuation = new RegExp(CHAIN_CONTINUATION.source, CHAIN_CONTINUATION.flags);
+            continuation.lastIndex = end;
+            const found = continuation.exec(code);
+            if (!found) {
+                break;
+            }
+            end = balancedEnd(code, end + found[0].length - 1);
+        }
+        assertions.push(normalize(code.slice(match.index, end)));
+        cursor = end;
+        pattern.lastIndex = end;
+    }
+    return assertions;
+}
+function extractBareAssertions(code) {
+    return (code.match(PYTHON_BARE_ASSERT) ?? []).map((line) => normalize(line));
+}
+/** Index just past the parenthesis that closes the one at `openIndex`; end of text if unbalanced. */
+function balancedEnd(code, openIndex) {
+    let depth = 0;
+    let index = openIndex;
+    while (index < code.length) {
+        const char = code[index];
+        if (isQuote(char)) {
+            index = skipString(code, index);
+            continue;
+        }
+        if (char === "(") {
+            depth += 1;
+        }
+        else if (char === ")") {
+            depth -= 1;
+            if (depth === 0) {
+                return index + 1;
+            }
+        }
+        index += 1;
+    }
+    return code.length;
+}
+/** Drops whitespace outside string literals, keeping one space between two word characters. */
+function normalize(text) {
+    let output = "";
+    let index = 0;
+    let pendingSpace = false;
+    while (index < text.length) {
+        const char = text[index];
+        if (isQuote(char)) {
+            const end = skipString(text, index);
+            output += text.slice(index, end);
+            index = end;
+            pendingSpace = false;
+            continue;
+        }
+        if (/\s/u.test(char)) {
+            pendingSpace = true;
+        }
+        else {
+            if (pendingSpace && /\w/u.test(output.at(-1) ?? "") && /\w/u.test(char)) {
+                output += " ";
+            }
+            output += char;
+            pendingSpace = false;
+        }
+        index += 1;
+    }
+    return output;
+}
+function isQuote(char) {
+    return char === '"' || char === "'" || char === "`";
+}
+/** Index just past the string literal that starts at `start`. */
+function skipString(text, start) {
+    const quote = text[start];
+    const triple = quote !== "`" && text.startsWith(quote.repeat(3), start);
+    const delimiter = triple ? quote.repeat(3) : quote;
+    const multiline = triple || quote === "`";
+    let index = start + delimiter.length;
+    while (index < text.length) {
+        const char = text[index];
+        if (char === "\\") {
+            index += 2;
+        }
+        else if (text.startsWith(delimiter, index)) {
+            return index + delimiter.length;
+        }
+        else if (!multiline && char === "\n") {
+            return index;
+        }
+        else {
+            index += 1;
+        }
+    }
+    return text.length;
+}
+function lineEnd(text, from) {
+    const newline = text.indexOf("\n", from);
+    return newline === -1 ? text.length : newline;
+}
+function countMatches(code, pattern) {
+    return (code.match(new RegExp(pattern.source, pattern.flags)) ?? []).length;
+}

package/dist/vendor/core/verified-handoff.d.ts

@@ -78,4 +78,5 @@ export interface BuildVerifiedHandoffInput {
     recovery?: Partial<VerifiedHandoffRecoveryV1>;
     nextAction: string;
 }
+export declare const NO_FILE_CHANGES_WARNING = "No file changes were observed for this run; the verifier result reflects the workspace as it already was.";
 export declare function buildVerifiedHandoff(input: BuildVerifiedHandoffInput): VerifiedHandoffV1;

package/dist/vendor/core/verified-handoff.js

@@ -207,6 +207,7 @@ function toCheck(step) {
 // ---------------------------------------------------------------------------
 // Main builder
 // ---------------------------------------------------------------------------
+export const NO_FILE_CHANGES_WARNING = "No file changes were observed for this run; the verifier result reflects the workspace as it already was.";
 export function buildVerifiedHandoff(input) {
     const generatedAt = input.generatedAt ?? new Date().toISOString();
     const changedFiles = input.changedFiles ?? [];
@@ -280,6 +281,11 @@ export function buildVerifiedHandoff(input) {
         ...(effectiveVerificationStatus !== input.verification.status
             ? ["A VERIFIED claim requires at least one launched, completed, exit-zero verifier step."]
             : []),
+        ...(fileEffects.observationStatus === "observed" &&
+            fileEffects.netChangedAtCompletion.length === 0 &&
+            input.loop.task.mutationMode !== "read_only"
+            ? [NO_FILE_CHANGES_WARNING]
+            : []),
     ];
     const outcome = resolveVerifiedHandoffOutcome({
         lifecycleState: input.loop.lifecycleState,

package/dist/vendor/core/verifier-input.d.ts

@@ -0,0 +1,4 @@
+/** Returns a reason when a verifier would be parsed differently from what the operator intended. */
+export declare function describeMalformedVerifier(command: string, options?: {
+    detectShellFold?: boolean;
+}): string | undefined;

package/dist/vendor/core/verifier-input.js

@@ -0,0 +1,107 @@
+const MARTIN_OWNED_OPTIONS = new Set([
+    "--allow-network-domain", "--allow-path", "--approve-config-changes",
+    "--approve-dependency-changes", "--approve-external-writes", "--approve-migrations",
+    "--approve-test-changes", "--baseline-usd", "--budget-usd", "--deny-path",
+    "--execution-profile", "--provider-execution-timeout-ms", "--runs-dir",
+    "--soft-limit-usd", "--unsafe-allow-unguarded-run", "--verify-only", "--verify-timeout-ms"
+]);
+const MARTIN_ENGINES = new Set(["auto", "claude", "codex", "gemini", "openai"]);
+const MARTIN_EXECUTABLES = new Set(["martin", "martin-loop", "martin.cmd", "martin-loop.cmd"]);
+const LAUNCHER_BOOLEAN_OPTIONS = new Set([
+    "-s", "--silent", "-y", "--yes", "--no-install", "--offline", "--prefer-offline", "--no-color"
+]);
+const LAUNCHER_VALUE_OPTIONS = new Set(["--cwd", "--dir", "--filter", "--package", "-p", "--workspace", "-w"]);
+function foldedMartinOptions(tokens) {
+    const folded = [];
+    tokens.forEach((token, index) => {
+        const [name, inlineValue] = token.split("=", 2);
+        if (name && MARTIN_OWNED_OPTIONS.has(name)) {
+            folded.push(name);
+            return;
+        }
+        if (name === "--engine") {
+            const value = (inlineValue ?? tokens[index + 1] ?? "").toLowerCase();
+            if (MARTIN_ENGINES.has(value))
+                folded.push(`--engine ${value}`);
+        }
+    });
+    return folded;
+}
+/** Returns a reason when a verifier would be parsed differently from what the operator intended. */
+export function describeMalformedVerifier(command, options = {}) {
+    const quote = findUnterminatedQuote(command);
+    if (quote !== undefined)
+        return `--verify value has an unterminated quote (${quote}): ${command}`;
+    if (options.detectShellFold === false)
+        return undefined;
+    const tokens = command.trim().split(/\s+/u);
+    const executableIndex = resolveLaunchedExecutableIndex(tokens);
+    const executable = normalizeExecutableToken(tokens[executableIndex] ?? "");
+    if (MARTIN_EXECUTABLES.has(executable))
+        return undefined;
+    const swallowed = foldedMartinOptions(tokens);
+    if (swallowed.length > 0) {
+        return `--verify value contains MartinLoop option(s) ${swallowed.join(", ")}: ${command}. `
+            + "The shell merged later flags into the verifier, usually because of a stray quote.";
+    }
+    return undefined;
+}
+function resolveLaunchedExecutableIndex(tokens) {
+    const launcher = normalizeExecutableToken(tokens[0] ?? "");
+    if (launcher === "node")
+        return 1;
+    if (launcher === "npx" || launcher === "pnpx") {
+        return skipLauncherOptions(tokens, 1);
+    }
+    if (launcher === "pnpm" || launcher === "npm" || launcher === "yarn") {
+        const actionIndex = skipLauncherOptions(tokens, 1);
+        const action = normalizeExecutableToken(tokens[actionIndex] ?? "");
+        if (action !== "exec" && action !== "dlx")
+            return 0;
+        return skipLauncherOptions(tokens, actionIndex + 1);
+    }
+    return 0;
+}
+function skipLauncherOptions(tokens, start) {
+    let index = start;
+    while (index < tokens.length) {
+        const token = tokens[index] ?? "";
+        if (token === "--" || LAUNCHER_BOOLEAN_OPTIONS.has(token) || token.startsWith("--color=")) {
+            index += 1;
+            continue;
+        }
+        if (LAUNCHER_VALUE_OPTIONS.has(token)) {
+            index += 2;
+            continue;
+        }
+        if ([...LAUNCHER_VALUE_OPTIONS].some((option) => token.startsWith(`${option}=`))) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function normalizeExecutableToken(token) {
+    const unquoted = token.replace(/^["']|["']$/gu, "");
+    const basename = unquoted.split(/[\\/]/u).at(-1)?.toLowerCase() ?? "";
+    return basename.endsWith(".js") ? basename.slice(0, -3) : basename;
+}
+function findUnterminatedQuote(command) {
+    let quote;
+    for (let index = 0; index < command.length; index += 1) {
+        const char = command[index];
+        const next = command[index + 1];
+        if (char === "\\" && quote !== "'" && (next === quote || next === "\\")) {
+            index += 1;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            if (quote === undefined)
+                quote = char;
+            else if (quote === char)
+                quote = undefined;
+        }
+    }
+    return quote;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/Keesan12/martin-loop",
     "source": "github"
   },
-  "version": "0.8.6",
+  "version": "0.8.8",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.8.6",
+      "version": "0.8.8",
       "transport": {
         "type": "stdio"
       }