@martinloop/mcp 0.8.6 → 0.8.7

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

@@ -0,0 +1,228 @@
+/**
+ * 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,
+    /\bx(?:it|describe|test|context)\s*\(/gu,
+    /@pytest\.mark\.skip\w*|\bpytest\.skip\s*\(|@unittest\.skip\w*|\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,2 @@
+/** Returns a reason when a verifier would be parsed differently from what the operator intended. */
+export declare function describeMalformedVerifier(command: string): string | undefined;

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

@@ -0,0 +1,59 @@
+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"]);
+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) {
+    const quote = findUnterminatedQuote(command);
+    if (quote !== undefined)
+        return `--verify value has an unterminated quote (${quote}): ${command}`;
+    const tokens = command.trim().split(/\s+/u);
+    const executable = tokens[0]?.replace(/^["']|["']$/gu, "").toLowerCase() ?? "";
+    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 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.7",
   "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.7",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.8.6",
+      "version": "0.8.7",
       "transport": {
         "type": "stdio"
       }