probatio 0.1.2 → 0.2.0

package/dist/swarm/check-kill.js

@@ -4,8 +4,8 @@ import { SCHEMA_VERSION } from "../contract.js";
 import { directImporters } from "../mutate/affected.js";
 import { filesInDiff } from "../mutate/patch.js";
 import { killLabel } from "../mutate/kill-label.js";
-import { runMutants } from "../mutate/run.js";
-import { campaignSummary } from "../mutate/suite-decision.js";
+import { normalizeResult, runMutants } from "../mutate/run.js";
+import { campaignSummary, UNVIABLE_NEXT } from "../mutate/suite-decision.js";
 /** The gap is done only when this mutant is killed and the baseline suite is green. */
 export async function checkKill(id, options) {
     const importers = importersOf(id, options);
@@ -48,18 +48,24 @@ export async function checkKill(id, options) {
     let outcome = null;
     let killedBy = [];
     if (existsSync(resultFile)) {
-        const result = JSON.parse(readFileSync(resultFile, "utf8"));
+        const result = normalizeResult(JSON.parse(readFileSync(resultFile, "utf8")));
         outcome = result.outcome ?? null;
         killedBy = Array.isArray(result.killedBy) ? result.killedBy : [];
     }
-    const done = suiteGreen && outcome === "killed";
-    const label = done ? killLabel(killedBy) : null;
+    // A mutant that does not build needs no test. The task is closed, and it is not called a kill.
+    const unviableMutant = suiteGreen && outcome === "unviable";
+    const done = (suiteGreen && outcome === "killed") || unviableMutant;
+    const label = unviableMutant ? { cause: "build", next: UNVIABLE_NEXT } : done ? killLabel(killedBy) : null;
     const head = checkHead(report);
     return {
         schemaVersion: SCHEMA_VERSION,
         ok: done,
         command: "check-kill",
-        summary: done ? `${head} ${id} is dead and the suite is green.` : `${head} ${id} is not done.`,
+        summary: unviableMutant
+            ? `${head} ${id} does not build. No test is needed.`
+            : done
+                ? `${head} ${id} is dead and the suite is green.`
+                : `${head} ${id} is not done.`,
         next: label?.next ?? (done ? "The gap-fixing task is done." : "The task is not done."),
         nextCall: null,
         done,
@@ -78,11 +84,12 @@ function importersOf(id, options) {
     return directImporters(options.packageDir, rels, options.testsDir);
 }
 function checkHead(report) {
-    const finished = report.killed + report.survived + report.flaky + report.timeouts + report.errors + report.noCoverage;
+    const finished = report.killed + report.unviable + report.survived + report.flaky + report.timeouts + report.errors + report.noCoverage;
     return campaignSummary({
         noCoverage: report.noCoverage,
         survived: report.survived,
         killed: report.killed,
+        unviable: report.unviable,
         flaky: report.flaky,
         timeouts: report.timeouts,
         errors: report.errors,

package/dist/swarm/queue.js

@@ -1,13 +1,19 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { loadSealed } from "../memory/state.js";
+/** One path segment. Rejects slashes and `..` so a claim cannot leave the queue directory. */
+export function safeFilePart(value) {
+    if (!/^[A-Za-z0-9._-]+$/.test(value) || value === "." || value === "..")
+        return null;
+    return value;
+}
 export function seedQueue(root, ids) {
     const sealed = new Set(loadSealed(root));
     const queue = path.join(root, "queue");
     mkdirSync(queue, { recursive: true });
     const written = [];
     for (const id of [...ids].sort()) {
-        if (sealed.has(id))
+        if (sealed.has(id) || !safeFilePart(id))
             continue;
         const dest = path.join(queue, `${id}.json`);
         if (existsSync(dest))
@@ -19,23 +25,23 @@ export function seedQueue(root, ids) {
 }
 /** Claim by atomic rename. A second claim fails because the queue file is already gone. */
 export function claimItem(root, id, agent, now, leaseMs) {
+    if (!safeFilePart(id) || !safeFilePart(agent))
+        return { ok: false, summary: "agent and id must be a single file name.", file: null };
     const source = path.join(root, "queue", `${id}.json`);
     const claimed = path.join(root, "claimed");
     const dest = path.join(claimed, `${agent}-${id}.json`);
     if (!existsSync(source))
         return { ok: false, summary: `${id} is not in the queue.`, file: null };
     mkdirSync(claimed, { recursive: true });
-    const body = JSON.parse(readFileSync(source, "utf8"));
-    body.id = id;
-    body.agent = agent;
-    body.leasedUntil = now + leaseMs;
-    writeFileSync(source, `${JSON.stringify(body)}\n`);
+    // Rename first. Writing the body before the rename lets the other claim overwrite the winner.
     try {
         renameSync(source, dest);
     }
     catch {
         return { ok: false, summary: `${id} was claimed by someone else.`, file: null };
     }
+    const body = { id, agent, leasedUntil: now + leaseMs };
+    writeFileSync(dest, `${JSON.stringify(body)}\n`);
     return { ok: true, summary: `${agent} claimed ${id} until ${body.leasedUntil}.`, file: dest };
 }
 /** Move claims whose lease has expired back to the queue. */
@@ -53,7 +59,7 @@ export function reapClaims(root, now) {
         const body = JSON.parse(readFileSync(file, "utf8"));
         if (typeof body.leasedUntil !== "number" || body.leasedUntil > now)
             continue;
-        if (!body.id)
+        if (!body.id || !safeFilePart(body.id))
             continue;
         renameSync(file, path.join(queue, `${body.id}.json`));
         returned.push(body.id);

package/dist/verify/change.js

@@ -23,6 +23,11 @@ export async function verifyChange(options) {
     const ranges = parseUnified(diff.stdout);
     const names = git(repo, ["diff", "--name-only", "--no-renames", options.base, options.commit, ...scope]);
     const changed = names.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const status = git(repo, ["status", "--porcelain", ...scope]);
+    const dirty = status.stdout.trim().length > 0;
+    if (dirty && (options.base === options.commit || changed.length === 0)) {
+        return fail(options.outDir, "The working tree has uncommitted changes. verify-change did not score them. Commit the edit, or pass --base and --commit that name different commits with a diff.");
+    }
     const goldenContract = goldenDiffs(repo, options.base, options.commit, changed);
     const packageFiles = [];
     const chosen = [];

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "probatio",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Mutation runner for AI agents. Scores a test suite by the bugs it catches.",
   "type": "module",
   "bin": {
-    "probatio": "dist/cli.js"
+    "probatio": "dist/cli.js",
+    "probatio-mcp": "dist/mcp.js"
   },
   "files": [
     "dist"
@@ -19,12 +20,13 @@
     "url": "https://github.com/IronAdamant/Probatio/issues"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json && mkdir -p dist/mutate && cp src/mutate/fail-reporter.mjs src/mutate/node-coverage.mjs src/mutate/precise-lines.mjs src/mutate/child-lines.mjs src/mutate/mocha-coverage.cjs src/mutate/node-batch.mjs src/mutate/node-batch-loader.mjs src/mutate/py-reporter.py src/mutate/py-pytest-reporter.py src/mutate/probatio-jacoco-run.java dist/mutate/",
+    "build": "tsc -p tsconfig.json && mkdir -p dist/mutate && cp src/mutate/fail-reporter.mjs src/mutate/node-coverage.mjs src/mutate/precise-lines.mjs src/mutate/child-lines.mjs src/mutate/mocha-coverage.cjs src/mutate/node-batch.mjs src/mutate/node-batch-loader.mjs src/mutate/load-failure.mjs src/mutate/py-reporter.py src/mutate/py-pytest-reporter.py src/mutate/probatio-jacoco-run.java dist/mutate/",
+    "prepack": "npm run build",
     "test": "tsx --test tests/*.test.ts",
     "probatio": "tsx src/cli.ts"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=22.6"
   },
   "dependencies": {
     "typescript": "^5.7.2"