agent-roast 0.16.0 → 0.18.0

package/README.md

@@ -78,9 +78,9 @@ Policy is read from the **base** branch, so a pull request cannot switch off the
 
 | Rule | Fires when | By default |
 | --- | --- | :-: |
-| `assertion-weakened` | an exact check is replaced by a weaker one: `toBe(42)` → `toBeDefined()`, `assert x == 1` → `assert x` | blocks |
+| `assertion-weakened` | an exact check is replaced by a weaker one: `toBe(42)` → `toBeDefined()`, `toBe(2)` → `toBeLessThanOrEqual(2)`, `toEqual(x)` → `toMatchObject(x)`, `assert x == 1` → `assert x` | blocks |
 | `guard-weakened` | a coverage threshold is lowered, `strict` is switched off, a lint rule is downgraded, a CI step may fail, a workflow stops running tests, a `conftest.py` hook sets a report to `passed` | blocks |
-| `test-skip` | a test is switched off or expected to fail: `it.skip`, `@pytest.mark.skip`, `@pytest.mark.xfail`, `it.fails`, `test.fixme`, `t.Skip`, `#[ignore]`, `@Disabled`, `[Ignore]`, `xit`, ... | blocks |
+| `test-skip` | a test that was already there is switched off or expected to fail: `it.skip`, `@pytest.mark.skip`, `@pytest.mark.xfail`, `it.fails`, `test.fixme`, `t.Skip`, `#[ignore]`, `@Disabled`, `[Ignore]`, `xit`, ... (a new test that is skipped is not reported) | blocks |
 | `test-focus`, `trivial-assert` | `.only` / `fit`; `expect(true).toBe(true)` and its relatives in ten languages; a test that asserts on a function it mocked itself | blocks |
 | `assertion-removed`, `test-removed`, `expectation-rewritten` | a test loses assertions, disappears, or its expected value is edited next to production code | warns |
 | `swallowed-error`, `type-escape`, `stub-abandonment` | `catch {}` / `except: pass`, `as any` / `# type: ignore` / `# pragma: no cover` / `istanbul ignore`, `throw new Error("Not implemented")` | warns |
@@ -109,17 +109,28 @@ old debt with a baseline: [docs/reference.md](docs/reference.md#configuration).
 ## Does it work?
 
 Measured, with the denominators and the caveats in [docs/benchmarks.md](docs/benchmarks.md). **Weakened checks are rare, mostly
-deliberate, and not specific to AI. agent-roast is a tripwire that stays silent until a check gets weaker.**
+deliberate, and not specific to AI. agent-roast is a tripwire that asks about them. On repositories it had not seen, about half of its
+blocks were questions with a harmless answer.**
 
-- **119 of 119** hand-labeled cheating edits are caught and **84 of 84** harmless look-alikes (reformats, moves, raised
+- **131 of 131** hand-labeled cheating edits are caught and **110 of 110** harmless look-alikes (reformats, moves, raised
   thresholds, environment-gated skips) stay silent. The cases were written with the detector, so they guard against regressions;
   they do not prove accuracy. One gap is documented and still open.
 - **12,645 commits** that touch tests or CI/config in 166 public repositories: blocking rules fired on 0.3% of AI-signed commits
   (Claude, Copilot, Cursor, Codex, Devin, aider) and on 0.3% of the others. Inside the same repositories the odds for an
   AI-signed commit were 0.81 times those of another commit (95% CI 0.40–1.67). There is no sign that AI-signed commits weaken
   checks more often.
-- **About one finding in five was a false alarm**, and most of the rest were deliberate, explained changes a reviewer should
-  see rather than mistakes. The labels come from one reader (an AI assistant), so treat them as a first estimate.
+- **On repositories it was not written from, about half of the blocked commits were false alarms.** Four samples of 39 or 40 public
+  repositories (158 in all, 44,878 commits) were replayed and every blocked commit was read. 0.17.0 blocked 74 of 11,604 commits in the
+  first sample and 65 of 10,726 in the fourth, and 69% of both were false alarms, mostly a skip on a test that the same commit adds.
+  This version, frozen before the fourth sample was drawn, blocked 41 of its 10,726 commits: 20 changed a check a reviewer should see
+  (an assertion that got weaker, a gate that was relaxed, a test switched off or left focused) and 21 were false alarms, nine of them in
+  one repository. Most of the rest, in the earlier measurements too, were deliberate and explained. One reader (an AI assistant) sorted
+  them, so treat the figures as a first estimate ([section 9](docs/benchmarks.md#9-repositories-nobody-had-tuned-on)).
+- **9,732 commits compared in full** from 164 public repositories that use coding agents (5,454 of them AI-signed) were reviewed again for the
+  last two releases, and every new finding was read. 0.15.0's rules reported 30 new findings there and 7 were false alarms (fixed in 0.16.0);
+  0.17.0's rule for an exact check turned into a bound reported 18 in 14 commits, all of them loosened checks, after two false alarms were
+  fixed. One reader, and a convenience sample ([section 7](docs/benchmarks.md#7-ai-signed-commits-and-a-test-that-checks-its-own-mock),
+  [section 8](docs/benchmarks.md#8-an-exact-check-turned-into-a-bound)).
 - `replay` ran on 179 public repositories that use coding agents: no commit would have been blocked in 149 of them.
 - The rules for **eight more languages** (Go, Rust, Java, Kotlin, C#, Ruby, PHP, Swift) ran on the newest 300 commits of 39
   repositories and every finding was read: 26 of 99 were skips that depend on the environment, now fixed; of the 73 left, 56 are

package/dist/{chunk-52FUQ4EP.js → chunk-2KWC2IAP.js}

@@ -788,9 +788,9 @@ var RULE_GUIDES = {
   },
   "assertion-weakened": {
     title: "Exact check replaced by a weaker one",
-    why: "Swapping an exact assertion for toBeDefined, a truthiness check or `is not None` keeps the test green while it verifies far less.",
+    why: "Swapping an exact assertion for toBeDefined, a truthiness check, `is not None`, a bound (`>= 2` in place of `== 2`) or toMatchObject in place of toEqual keeps the test green while it verifies far less.",
     suggestion: "Restore the exact check, or assert the specific value the code should produce.",
-    example: "expect(total).toBe(42) \u2192 expect(total).toBeDefined()  (restore the exact check)"
+    example: "expect(total).toBe(42) \u2192 expect(total).toBeDefined()  (restore the exact check); expect(cost).toBe(2) \u2192 expect(cost).toBeLessThanOrEqual(2)  (pin the value again)"
   },
   "assertion-removed": {
     title: "Test checks less than before",
@@ -1623,6 +1623,8 @@ function auditFileDiffs(files, commitHash = "HEAD", commitDate = (/* @__PURE__ *
         while (previous >= 0 && /\s/.test(source[previous])) previous--;
         if (source[previous] === ".") continue;
         if (match[2] && !isTestFile(file.path)) continue;
+        if (match[2] && callArguments(source, raw, match.index + match[0].length)?.length === 0) continue;
+        if (match[2] && previous >= 0 && (/[(,=:?[&|!+\-*%<]/.test(source[previous]) || /(?:await|return|yield|typeof|void)$/.test(source.slice(Math.max(0, previous - 6), previous + 1)))) continue;
         if (/\bfunction$/.test(source.slice(Math.max(0, previous - 8), previous + 1))) continue;
         if (source[match.index + match[0].length] === "
" && !/\.\s*each\s*$/.test(match[3])) continue;
         if ((match[1] === "skip" || match[1] === "fixme" || match[1] === "fail") && !match[3] && isConditionalSkip(source, raw, match.index + match[0].length)) continue;
@@ -3224,6 +3226,8 @@ function javascript(text) {
     const end = closing(code, open2);
     const args = end > 0 ? raw.slice(open2, end) : "";
     if (/requireActual|importActual|importOriginal/.test(args)) continue;
+    const loader = /^\(\s*(['"`])[^'"`\n]+\1\s*,\s*(?:async\s+)?(?:function\s*[\w$]*\s*)?\(\s*([A-Za-z_$][\w$]*)\s*[,)]/.exec(args)?.[2];
+    if (loader && new RegExp(`(?<![\\w$.])${loader.replace(/\$/g, "\\$")}\\s*(?:<[^\\n]*?>)?\\s*\\(`).test(args.slice(args.indexOf(loader) + loader.length))) continue;
     const factory = /^\(\s*(['"`])[^'"`\n]+\1\s*,/.test(args) && !/,\s*\{\s*spy\s*:\s*true\b/.test(args);
     if (!mocked.has(specifier)) mocked.set(specifier, { index: match.index, fake: factory });
   }
@@ -3339,6 +3343,15 @@ function python(text) {
     }
     return [line, end];
   };
+  const headerLine = (line) => {
+    for (let k = line; k >= 0 && k > line - 8; k--) {
+      if (!/^\s*with\b/.test(codeLines2[k] ?? "")) continue;
+      const head = codeLines2.slice(k, line).join("\n");
+      const open2 = (head.match(/[([{]/g) ?? []).length - (head.match(/[)\]}]/g) ?? []).length;
+      return k === line || open2 > 0 || codeLines2.slice(k, line).every((text2) => /\\\s*$/.test(text2)) ? k : null;
+    }
+    return null;
+  };
   const patched = /* @__PURE__ */ new Map();
   const patchCall = /(?<![\w.])(?:(?:mock|unittest\s*\.\s*mock)\s*\.\s*)?patch(\s*\.\s*object)?\s*\(|(?<![\w.])mocker\s*\.\s*patch(\s*\.\s*object)?\s*\(|(?<![\w.])monkeypatch\s*\.\s*setattr\s*\(/g;
   for (const match of code.matchAll(patchCall)) {
@@ -3352,7 +3365,11 @@ function python(text) {
     const key = target ? target[2] : parts ? `${expandObject(parts[1])}.${parts[3]}` : void 0;
     if (!key || !DOTTED.test(key)) continue;
     const line = lineIndex(match.index);
-    patched.set(key, [...patched.get(key) ?? [], { index: match.index, scope: blockOf(line) ?? scopeOf(line) }]);
+    const fixture = /^(?:mocker|monkeypatch)/.test(match[0]);
+    const header = headerLine(line);
+    const inForce = fixture || /^\s*@/.test(codeLines2[line] ?? "") || header !== null || /^\s*\.\s*start\s*\(/.test(code.slice(end + 1)) || /enter_context\s*\(\s*$/.test(code.slice(Math.max(0, match.index - 40), match.index));
+    if (!inForce) continue;
+    patched.set(key, [...patched.get(key) ?? [], { index: match.index, end, object: parts ? parts[1] : null, scope: (header !== null ? blockOf(header) : null) ?? blockOf(line) ?? scopeOf(line) }]);
   }
   if (!patched.size) return [];
   const found = /* @__PURE__ */ new Map();
@@ -3372,6 +3389,15 @@ function python(text) {
     const at = lineIndex(match.index);
     const patch = patched.get(key)?.find((item) => item.scope && within(item.scope, at) && (at >= lineIndex(item.index) || /^\s*@/.test(codeLines2[lineIndex(item.index)] ?? "")));
     if (!patch) continue;
+    if (patch.object) {
+      const handed = new RegExp(`(?<![\\w.])(?!(?:[\\w.]*\\.)?(?:patch|object|setattr)\\b)[A-Za-z_][\\w.]*\\(\\s*(?:[^()]*,\\s*)?${patch.object.replace(/[.$]/g, "\\$&")}\\s*[,)]`);
+      if (handed.test(code.slice(patch.end + 1, match.index))) continue;
+    }
+    if (patch.object) {
+      const attribute = key.slice(key.lastIndexOf(".") + 1);
+      const receiver = new RegExp(`(?<![\\w.])${patch.object.replace(/[.$]/g, "\\$&")}\\s*\\.\\s*(?!${attribute}\\b)\\w+\\s*\\(`);
+      if (receiver.test(code.slice(patch.end + 1, match.index))) continue;
+    }
     const line = lineOf2(patch.index);
     found.set(key, {
       key,
@@ -3593,20 +3619,113 @@ function testBodies(text, language) {
     };
   });
 }
+function maskRegexLiterals(text) {
+  let out = "", quote = "";
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (quote) {
+      out += char;
+      if (char === "\\" && i + 1 < text.length) out += text[++i];
+      else if (char === quote) quote = "";
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      out += char;
+      continue;
+    }
+    if (char === "/" && text[i + 1] !== "/" && text[i + 1] !== "*") {
+      let p = out.length - 1;
+      while (p >= 0 && /\s/.test(out[p])) p--;
+      if (p < 0 || /[(,=:[!&|?{};+\-*%~^]/.test(out[p]) || /(?:return|typeof|case)$/.test(out.slice(0, p + 1))) {
+        let j = i + 1, inClass = false, closed = false;
+        for (; j < text.length; j++) {
+          const c = text[j];
+          if (c === "\n") break;
+          if (c === "\\") {
+            j++;
+            continue;
+          }
+          if (c === "[") inClass = true;
+          else if (c === "]") inClass = false;
+          else if (c === "/" && !inClass) {
+            closed = true;
+            break;
+          }
+        }
+        if (closed) {
+          out += "/" + "_".repeat(j - i - 1) + "/";
+          i = j;
+          continue;
+        }
+      }
+    }
+    out += char;
+  }
+  return out;
+}
 function balance(line) {
-  const bare = line.replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, "");
+  const bare = maskRegexLiterals(line).replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, "").replace(/\\./g, "");
   let net = 0;
   for (const char of bare) net += "([{".includes(char) ? 1 : ")]}".includes(char) ? -1 : 0;
   return net;
 }
+function withoutMessageParens(statement) {
+  let depth = 0, quote = "";
+  for (let i = 0; i < statement.length; i++) {
+    const char = statement[i];
+    if (quote) {
+      if (char === "\\") i++;
+      else if (char === quote) quote = "";
+    } else if (char === '"' || char === "'") quote = char;
+    else if ("([{".includes(char)) depth++;
+    else if (")]}".includes(char)) depth--;
+    else if (char === "," && depth === 0) {
+      const message = statement.slice(i + 1).trim();
+      if (!message.startsWith("(") || !message.endsWith(")")) return statement;
+      let inner = 0, q = "";
+      for (let j = 0; j < message.length; j++) {
+        const c = message[j];
+        if (q) {
+          if (c === "\\") j++;
+          else if (c === q) q = "";
+        } else if (c === '"' || c === "'") q = c;
+        else if (c === "(") inner++;
+        else if (c === ")" && --inner === 0 && j < message.length - 1) return statement;
+      }
+      return `${statement.slice(0, i + 1)} ${message.slice(1, -1).trim()}`;
+    }
+  }
+  return statement;
+}
+function withoutOuterParens(statement) {
+  const start = /^\s*assert\s+/.exec(statement);
+  if (!start) return statement;
+  if (statement[start[0].length] !== "(") return withoutMessageParens(statement);
+  let depth = 0, quote = "";
+  for (let i = start[0].length; i < statement.length; i++) {
+    const char = statement[i];
+    if (quote) {
+      if (char === "\\") i++;
+      else if (char === quote) quote = "";
+    } else if (char === '"' || char === "'") quote = char;
+    else if (char === "(") depth++;
+    else if (char === ")" && --depth === 0) {
+      const rest = statement.slice(i + 1);
+      return /^\s*(?:,|$)/.test(rest) ? withoutMessageParens(`${statement.slice(0, start[0].length)}${statement.slice(start[0].length + 1, i)}${rest}`) : statement;
+    }
+  }
+  return statement;
+}
 function normalize(statement) {
   return statement.replace(/\s+/g, "").replace(/'/g, '"').replace(/,([)\]}])/g, "$1").replace(/;$/, "");
 }
 function splitStatements(text) {
   const pieces = [];
+  const scanned = maskRegexLiterals(text);
   let quote = "", start = 0;
-  for (let i = 0; i < text.length; i++) {
-    const char = text[i];
+  for (let i = 0; i < scanned.length; i++) {
+    const char = scanned[i];
     if (quote) {
       if (char === "\\") i++;
       else if (char === quote) quote = "";
@@ -3654,7 +3773,7 @@ function parseTests(text, language) {
         const clean = piece.replace(CALLBACK_HEADER, "");
         if (assertionPattern.test(clean)) {
           raw.push(clean);
-          assertions.push(normalize(clean));
+          assertions.push(normalize(language === "py" ? withoutOuterParens(clean) : clean));
         } else setupLines.push(clean);
       }
     }
@@ -3668,15 +3787,106 @@ function parseTests(text, language) {
 function skeleton(assertion) {
   return assertion.replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, "S").replace(/\b\d+(?:\.\d+)?\b/g, "N").replace(/\b(?:true|false|null|undefined|None|True|False|nil)\b/g, "V").replace(/\s+/g, "");
 }
-var WEAK_JS = /\.(?:toBeDefined|toBeTruthy|toBeFalsy|toBeUndefined)\s*\(|\.not\s*\.\s*(?:toBeNull|toBeUndefined|toThrow)\s*\(|\.toBeGreaterThanOrEqual\s*\(\s*0\s*\)|(?<!\.not)\.(?:toHaveBeenCalled|toBeCalled)\s*\(\s*\)|\.(?:toBe|toEqual|toStrictEqual)\s*\(\s*expect\s*\.\s*(?:anything\s*\(\s*\)|any\s*\(\s*\w+\s*\))\s*\)/;
+var WEAK_JS = /\.(?:toBeDefined|toBeTruthy|toBeFalsy)\s*\(|\.not\s*\.\s*(?:toBeNull|toBeUndefined|toThrow)\s*\(\s*\)|\.toBeGreaterThanOrEqual\s*\(\s*0\s*\)|(?<!\.not)\.(?:toHaveBeenCalled|toBeCalled)\s*\(\s*\)|\.(?:toBe|toEqual|toStrictEqual)\s*\(\s*expect\s*\.\s*(?:anything\s*\(\s*\)|any\s*\(\s*\w+\s*\))\s*\)/;
 var BOUND_JS = /\.toBeGreaterThan\s*\(\s*(?:0|-1)\s*\)|\.toBeGreaterThanOrEqual\s*\(\s*[01]\s*\)/;
 var ZERO_JS = /\.(?:toBe|toEqual|toStrictEqual|toHaveLength|toHaveBeenCalledTimes)\s*\(\s*(?:0|\[\s*\]|\{\s*\}|null|undefined|false|"")\s*\)/;
-var WEAK_PY = /^\s*assert\s+[\w.\[\]]+\s*(?:,.*)?$|^\s*assert\s+.+\bis\s+not\s+None\s*(?:,.*)?$|^\s*assert\s+True\b/;
+var WEAK_PY = /^\s*assert\s+[\w.]+(?:\[[^\]]*\])*\s*(?:,.*)?$|^\s*assert\s+.+\bis\s+not\s+None\s*(?:,.*)?$|^\s*assert\s+True\b/;
 var BOUND_PY = /^\s*assert\s+.+(?:>\s*0|>=\s*[01])\s*(?:,.*)?$/;
-var EMPTY_PY = /==\s*(?:0|\[\s*\]|\{\s*\}|""|''|None|False)\b|\bis\s+None\b|\bnot\b|!=\s*(?:0|None)\b/;
+var EMPTY_PY = /==\s*(?:0(?:\.0+)?(?![\w.])|\[\s*\]|\{\s*\}|""|''|\(\s*\)|(?:set|dict|list|tuple|frozenset)\(\s*\)|None\b|False\b)|\bis\s+None\b|\bnot\b|!=\s*(?:0|None)\b/;
 var PY_SPECIFIC = /==|!=|<=|>=|\bin\b|\bis\b|\bisinstance\s*\(|\.startswith\s*\(|\.endswith\s*\(|\bcallable\s*\(/;
 var JS_SPECIFIC = /\.(?:toBe|toEqual|toStrictEqual|toHaveLength|toContain|toContainEqual|toMatch|toMatchObject|toHaveProperty|toHaveBeenCalledWith|toHaveBeenLastCalledWith|toHaveBeenNthCalledWith|toBeCalledWith|toHaveBeenCalledTimes|toHaveBeenCalledOnce|toHaveTextContent|toHaveAttribute|toHaveValue|toThrow\w*|toBeGreaterThan\w*|toBeLessThan\w*)\s*\(/;
 var THROWING_QUERY = /\b(?:get|find)(?:All)?By\w*\s*\(/;
+function checkedExpression(assertion, language) {
+  const squash = (text) => text.replace(/\s+/g, "").replace(/^len\((.*)\)$/, "$1").replace(/\.length$/, "");
+  if (language === "py") {
+    const operand = /^\s*assert\s+(?:not\s+)?(.+?)\s*(?:==|!=|>=|<=|>|<|\bin\b|\bis\b)/.exec(assertion)?.[1] ?? /\bself\s*\.\s*assert\w*\s*\(\s*([^,]+?)\s*,/.exec(assertion)?.[1];
+    return operand ? squash(operand) : null;
+  }
+  const start = assertion.search(/(?<![\w$.])expect\s*\(/);
+  if (start >= 0) {
+    const open2 = assertion.indexOf("(", start);
+    let depth = 0;
+    for (let i = open2; i < assertion.length; i++) {
+      if (assertion[i] === "(") depth++;
+      else if (assertion[i] === ")" && --depth === 0) return squash(assertion.slice(open2 + 1, i));
+    }
+    return null;
+  }
+  const node = /assert\s*\.\s*(?:equal|strictEqual|deepEqual|deepStrictEqual|ok)\s*\(\s*([^,)]+?)\s*(?:,|\)|>=|<=|>|<)/.exec(assertion)?.[1];
+  return node ? squash(node) : null;
+}
+function matcherArgument(assertion, name) {
+  const open2 = new RegExp(`\\.\\s*${name}\\s*\\(`).exec(assertion);
+  if (!open2) return null;
+  let depth = 1;
+  for (let i = open2.index + open2[0].length; i < assertion.length; i++) {
+    if ("([{".includes(assertion[i])) depth++;
+    else if (")]}".includes(assertion[i]) && --depth === 0) return assertion.slice(open2.index + open2[0].length, i).replace(/\s+/g, "");
+  }
+  return null;
+}
+function isExact(assertion, language) {
+  if (language === "js") {
+    return !/\.\s*not\s*\./.test(assertion) && (/\.(?:toBe|toEqual|toStrictEqual|toHaveLength)\s*\(/.test(assertion) || /assert\s*\.\s*(?:equal|strictEqual|deepEqual|deepStrictEqual)\s*\(/.test(assertion));
+  }
+  if (language === "py") return /^\s*assert\s+.+?\s*==\s*\S/.test(assertion) || /\bself\s*\.\s*assertEqual\s*\(/.test(assertion);
+  return false;
+}
+function admits(value, operator, limit) {
+  switch (operator) {
+    case ">":
+      return value > limit;
+    case ">=":
+      return value >= limit;
+    case "<":
+      return value < limit;
+    case "<=":
+      return value <= limit;
+    default:
+      return true;
+  }
+}
+function relaxes(oldAssertion, newAssertion, language, siblings = []) {
+  const subject = checkedExpression(oldAssertion, language);
+  if (!subject || subject !== checkedExpression(newAssertion, language)) return false;
+  if (siblings.some((other) => isExact(other, language) && checkedExpression(other, language) === subject)) return false;
+  if (language === "js") {
+    if (/\.\s*not\s*\./.test(oldAssertion) || /\.\s*not\s*\./.test(newAssertion)) return false;
+    const exact = /\.(?:toBe|toEqual|toStrictEqual|toHaveLength)\s*\(\s*(-?\d+(?:\.\d+)?)\s*\)/.exec(oldAssertion)?.[1] ?? /assert\s*\.\s*(?:equal|strictEqual|deepEqual|deepStrictEqual)\s*\([^,]+,\s*(-?\d+(?:\.\d+)?)\s*[,)]/.exec(oldAssertion)?.[1];
+    const bound = /\.(?:toBeGreaterThan|toBeGreaterThanOrEqual|toBeLessThan|toBeLessThanOrEqual)\s*\(/.test(newAssertion) || /assert\s*\.\s*ok\s*\([^;]*(?:>=|<=|>|<)/.test(newAssertion);
+    if (exact !== void 0 && Number(exact) !== 0 && bound) {
+      const matcherLimit = /\.(toBeGreaterThan|toBeGreaterThanOrEqual|toBeLessThan|toBeLessThanOrEqual)\s*\(\s*(-?\d+(?:\.\d+)?)\s*\)/.exec(newAssertion);
+      const okLimit = /assert\s*\.\s*ok\s*\([^;]*?(>=|<=|>|<)\s*(-?\d+(?:\.\d+)?)\s*\)/.exec(newAssertion);
+      const operators = { toBeGreaterThan: ">", toBeGreaterThanOrEqual: ">=", toBeLessThan: "<", toBeLessThanOrEqual: "<=" };
+      if (matcherLimit && !admits(Number(exact), operators[matcherLimit[1]], Number(matcherLimit[2]))) return false;
+      if (okLimit && !admits(Number(exact), okLimit[1], Number(okLimit[2]))) return false;
+      return true;
+    }
+    const same = matcherArgument(oldAssertion, "toEqual") ?? matcherArgument(oldAssertion, "toStrictEqual");
+    return same !== null && same !== "" && same === matcherArgument(newAssertion, "toMatchObject");
+  }
+  if (language === "py") {
+    if (EMPTY_PY.test(oldAssertion)) return false;
+    const plain = (text) => !/\b(?:and|or)\b/.test(text.replace(/(['"`])(?:\\.|(?!\1)[^\\])*\1/g, ""));
+    const operator = (text) => /^\s*assert\s+(?:not\s+)?.+?\s*(==|!=|>=|<=|>|<|\bin\b|\bis\b)/.exec(text)?.[1] ?? "";
+    const exact = operator(oldAssertion) === "==" && plain(oldAssertion) || /\bself\s*\.\s*assertEqual\s*\(/.test(oldAssertion);
+    const bound = [">=", "<=", ">", "<"].includes(operator(newAssertion)) && plain(newAssertion) || /\bself\s*\.\s*assert(?:Greater|Less)(?:Equal)?\s*\(/.test(newAssertion);
+    if (!exact || !bound) return false;
+    const value = (text) => /==\s*(-?\d+(?:\.\d+)?|[\w.]+(?:\([^)]*\))?)\s*(?:,|$)/.exec(text)?.[1] ?? /\bassertEqual\s*\([^,]+,\s*(-?\d+(?:\.\d+)?|[\w.]+)\s*[,)]/.exec(text)?.[1];
+    const limit = (text) => {
+      const symbol = /^\s*assert\s+(?:not\s+)?.+?\s*(>=|<=|>|<)\s*(-?\d+(?:\.\d+)?|[\w.]+(?:\([^)]*\))?)\s*(?:,|$)/.exec(text);
+      if (symbol) return [symbol[1], symbol[2]];
+      const named = /\bassert(Greater|GreaterEqual|Less|LessEqual)\s*\([^,]+,\s*(-?\d+(?:\.\d+)?|[\w.]+)\s*[,)]/.exec(text);
+      return named ? [{ Greater: ">", GreaterEqual: ">=", Less: "<", LessEqual: "<=" }[named[1]], named[2]] : null;
+    };
+    const pinned = value(oldAssertion), bounded = limit(newAssertion);
+    if (pinned === void 0 || !bounded) return true;
+    const [operator2, edge] = bounded;
+    if (/^-?\d/.test(pinned) && /^-?\d/.test(edge)) return admits(Number(pinned), operator2, Number(edge));
+    return !(pinned === edge && (operator2 === ">" || operator2 === "<"));
+  }
+  return false;
+}
 function pinsLess(oldAssertion, newAssertion, language) {
   if (language === "js") {
     const was = /\.toThrow(?:Error)?\s*\(\s*([^)\s][^)]*)\)/.exec(oldAssertion);
@@ -3697,15 +3907,18 @@ function pinsLess(oldAssertion, newAssertion, language) {
   }
   return false;
 }
-function isWeaker(oldAssertion, newAssertion, language) {
-  if (pinsLess(oldAssertion, newAssertion, language)) return true;
+function isWeaker(rawOld, rawNew, language) {
+  const oldAssertion = language === "py" ? withoutOuterParens(rawOld) : rawOld, newAssertion = language === "py" ? withoutOuterParens(rawNew) : rawNew;
+  if (pinsLess(oldAssertion, newAssertion, language) || relaxes(oldAssertion, newAssertion, language)) return true;
   if (language === "js") {
     if (THROWING_QUERY.test(newAssertion) || !JS_SPECIFIC.test(oldAssertion) || WEAK_JS.test(oldAssertion) || BOUND_JS.test(oldAssertion)) return false;
-    return WEAK_JS.test(newAssertion) || BOUND_JS.test(newAssertion) && !ZERO_JS.test(oldAssertion);
+    const limit = /\.(?:toBeGreaterThan|toBeGreaterThanOrEqual|toBeLessThan|toBeLessThanOrEqual)\s*\(\s*([^)]*)\)/.exec(oldAssertion)?.[1];
+    return WEAK_JS.test(newAssertion) || BOUND_JS.test(newAssertion) && !ZERO_JS.test(oldAssertion) && (limit === void 0 || /^-?\d+(?:\.\d+)?$/.test(limit.trim()));
   }
   if (language === "py") {
     if (WEAK_PY.test(oldAssertion) || BOUND_PY.test(oldAssertion) || !PY_SPECIFIC.test(oldAssertion)) return false;
-    return WEAK_PY.test(newAssertion) || BOUND_PY.test(newAssertion) && !EMPTY_PY.test(oldAssertion) && /==|\bin\b|[<>]=?/.test(oldAssertion);
+    const limit = /(?:>=|<=|>|<)\s*([^\s,)]+)/.exec(oldAssertion)?.[1];
+    return WEAK_PY.test(newAssertion) || BOUND_PY.test(newAssertion) && !EMPTY_PY.test(oldAssertion) && /==|[<>]=?/.test(oldAssertion) && (limit === void 0 || /^-?\d+(?:\.\d+)?$/.test(limit));
   }
   return false;
 }
@@ -3724,6 +3937,34 @@ var HELPER_CALL = /(?<![\w$])((?:expect|assert|verify|check|require)[A-Z]\w*|_{0
 function finding(type, file, line, snippet, reason, commit) {
   return { type, file, lineNumber: Math.max(1, line), lineSnippet: snippet, commitHash: commit, commitDate: "", reason, suggestion: RULE_GUIDES[type].suggestion };
 }
+function alignAssertions(before, after) {
+  const table = Array.from({ length: before.length + 1 }, () => new Array(after.length + 1).fill(0));
+  for (let i = before.length - 1; i >= 0; i--) {
+    for (let j = after.length - 1; j >= 0; j--) table[i][j] = before[i] === after[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+  }
+  const pairs = /* @__PURE__ */ new Map();
+  for (let i = 0, j = 0; i < before.length && j < after.length; ) {
+    if (before[i] === after[j]) {
+      pairs.set(i, j);
+      i++;
+      j++;
+    } else if (table[i + 1][j] >= table[i][j + 1]) i++;
+    else j++;
+  }
+  return pairs;
+}
+function unmatchedIndexes(from, against) {
+  const budget = /* @__PURE__ */ new Map();
+  for (const assertion of against) budget.set(assertion, (budget.get(assertion) ?? 0) + 1);
+  return from.map((assertion, i) => ({ assertion, i })).filter(({ assertion }) => {
+    const available = budget.get(assertion) ?? 0;
+    if (available > 0) {
+      budget.set(assertion, available - 1);
+      return false;
+    }
+    return true;
+  }).map(({ i }) => i);
+}
 function analyzeTestFile(oldPath, newPath, oldText, newText, commit) {
   const language = languageOf(newText === null ? oldPath : newPath);
   if (!language || !(isTestFile(newPath) || isTestFile(oldPath))) return EMPTY;
@@ -3765,6 +4006,34 @@ function analyzeTestFile(oldPath, newPath, oldText, newText, commit) {
     if (current.parametrized && !old.parametrized) continue;
     const snapshot = (test) => test.raw.some((statement) => /\.toMatch(?:Inline)?Snapshot\b|\.matchSnapshot\b|\bsnapshot\s*\(/.test(statement));
     if (snapshot(current) && !snapshot(old)) continue;
+    if (old.assertions.length && current.assertions.length && current.assertions.length !== old.assertions.length && old.assertions.length * current.assertions.length <= 25e4) {
+      const aligned = alignAssertions(old.assertions, current.assertions);
+      const fresh = unmatchedIndexes(current.assertions, old.assertions);
+      const gone = unmatchedIndexes(old.assertions, current.assertions).filter((index) => (newTotals.get(old.assertions[index]) ?? 0) < (oldTotals.get(old.assertions[index]) ?? 0));
+      for (const index of gone) {
+        const was = checkedExpression(old.raw[index], language);
+        if (was === null) continue;
+        let low = -1, high = current.assertions.length;
+        for (const [from, to] of aligned) {
+          if (from < index) low = Math.max(low, to);
+          else if (from > index) high = Math.min(high, to);
+        }
+        const successors = fresh.filter((candidate) => candidate > low && candidate < high);
+        const siblings = successors.map((candidate) => current.raw[candidate]);
+        const partner = successors.find((candidate) => checkedExpression(current.raw[candidate], language) === was && relaxes(old.raw[index], current.raw[candidate], language, siblings));
+        if (partner !== void 0) {
+          result.immediate.push(finding(
+            "assertion-weakened",
+            newPath,
+            current.line,
+            `${old.name}: ${old.raw[index].slice(0, 80)} \u2192 ${current.raw[partner].slice(0, 80)}`,
+            "Assertion replaced by a weaker check",
+            commit
+          ));
+          break;
+        }
+      }
+    }
     if (current.assertions.length < old.assertions.length) {
       if ([...current.text.matchAll(HELPER_CALL)].some((call) => !(oldText ?? "").includes(call[1]))) continue;
       const budget = tally([current]);
@@ -3793,19 +4062,7 @@ ${addedText}`;
       continue;
     }
     if (current.assertions.length === old.assertions.length && old.assertions.length > 0) {
-      const left = (from, against) => {
-        const budget = /* @__PURE__ */ new Map();
-        for (const assertion of against) budget.set(assertion, (budget.get(assertion) ?? 0) + 1);
-        return from.map((assertion, i) => ({ assertion, i })).filter(({ assertion }) => {
-          const available = budget.get(assertion) ?? 0;
-          if (available > 0) {
-            budget.set(assertion, available - 1);
-            return false;
-          }
-          return true;
-        }).map(({ i }) => i);
-      };
-      const goneIndexes = left(old.assertions, current.assertions), freshIndexes = left(current.assertions, old.assertions);
+      const goneIndexes = unmatchedIndexes(old.assertions, current.assertions), freshIndexes = unmatchedIndexes(current.assertions, old.assertions);
       const changed = goneIndexes.map((index, k) => ({ before: old.assertions[index], after: current.assertions[freshIndexes[k]], rawBefore: old.raw[index], rawAfter: current.raw[freshIndexes[k]] })).filter((pair) => pair.after !== void 0);
       const weaker = changed.find((pair) => isWeaker(pair.rawBefore, pair.rawAfter, language));
       if (weaker) {
@@ -3839,8 +4096,8 @@ function resolveTampering(files, productionChanged) {
     ...productionChanged ? files.flatMap((file) => file.rewritten) : []
   ];
 }
-function isKnownFailureMarker(finding2) {
-  return finding2.type === "test-skip" && /\bxfail\b|\bexpectedFailure\b|\bfixme\b|expected to fail/i.test(finding2.reason);
+function isTestMarker(finding2) {
+  return finding2.type === "test-skip" && /\.(?:py|[cm]?[jt]sx?|rs|go)$/i.test(finding2.file ?? "");
 }
 function markedTest(finding2, lines) {
   const snippet = finding2.lineSnippet ?? "";
@@ -3848,10 +4105,10 @@ function markedTest(finding2, lines) {
   if (/\.py$/i.test(finding2.file ?? "")) {
     if (/^\s*pytestmark\b/.test(snippet)) return null;
     if (/imperative/.test(finding2.reason)) {
-      const indent = (lines[index] ?? "").search(/\S/);
+      const indent2 = (lines[index] ?? "").search(/\S/);
       for (let i = index - 1; i >= 0 && i > index - 200; i--) {
         const def = /^(\s*)(?:async\s+)?def\s+(\w+)\s*\(/.exec(lines[i]);
-        if (def && def[1].length < indent) return { key: `py:${def[2]}`, title: def[2] };
+        if (def && def[1].length < indent2) return { key: `py:${def[2]}`, title: def[2] };
       }
       return null;
     }
@@ -3861,31 +4118,55 @@ function markedTest(finding2, lines) {
     }
     return null;
   }
+  if (/\.rs$/i.test(finding2.file ?? "")) {
+    for (let i = index; i < lines.length && i < index + 12; i++) {
+      const fn = /^\s*(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?(?:unsafe\s+)?fn\s+(\w+)\s*[<(]/.exec(lines[i]);
+      if (fn) return { key: `rs:${fn[1]}`, title: fn[1] };
+    }
+    return null;
+  }
+  if (/\.go$/i.test(finding2.file ?? "")) {
+    for (let i = index; i >= 0 && i > index - 400; i--) {
+      const fn = /^func\s+(?:\([^)]*\)\s*)?((?:Test|Benchmark|Fuzz|Example)\w*)\s*\(/.exec(lines[i]);
+      if (fn) return { key: `go:${fn[1]}`, title: fn[1] };
+    }
+    return null;
+  }
   if (/\.each\b/.test(snippet)) return null;
-  const title = /(['"`])((?:\\.|(?!\1)[^\\\n])+)\1/.exec(snippet);
-  return title ? { key: `js:${title[0]}`, title: title[0] } : null;
+  const title = /\b(?:it|test|describe|suite|xit|xtest|xdescribe|fit|fdescribe)\b[\w$.\s]*\(\s*(['"`])((?:\\.|(?!\1)[^\\\n])+)\1\s*[,)]/.exec(snippet);
+  if (title) return { key: `js:${title[1]}${title[2]}${title[1]}`, title: `${title[1]}${title[2]}${title[1]}` };
+  const indent = (lines[index] ?? "").search(/\S/);
+  if (indent > 0 && /\b(?:test|it)\s*\.\s*(?:skip|fixme|fail)\s*\(/.test(snippet)) {
+    for (let i = index - 1; i >= 0 && i > index - 200; i--) {
+      if (!lines[i].trim() || lines[i].search(/\S/) >= indent) continue;
+      const owner = /^\s*(?:test|it)(?:\s*\.\s*\w+)*\s*\(\s*(['"`])((?:\\.|(?!\1)[^\\\n])+)\1/.exec(lines[i]);
+      return owner ? { key: `js:${owner[1]}${owner[2]}${owner[1]}`, title: `${owner[1]}${owner[2]}${owner[1]}` } : null;
+    }
+  }
+  return null;
 }
-function newKnownFailureMarkers(before, after, oldText, newText) {
-  const markers = after.filter(isKnownFailureMarker);
+function newTestMarkers(before, after, oldText, newText) {
+  const markers = after.filter(isTestMarker);
   if (!markers.length || oldText === null) return [];
   const oldLines = oldText.split(/\r?\n/), newLines = (newText ?? "").split(/\r?\n/);
-  const existed = (test) => test.key.startsWith("py:") ? new RegExp(`^\\s*(?:async\\s+)?def\\s+${test.title}\\s*\\(`, "m").test(oldText) : oldText.includes(test.title);
-  const markedBefore = /* @__PURE__ */ new Set();
+  const existed = (test) => test.key.startsWith("py:") ? new RegExp(`^\\s*(?:async\\s+)?def\\s+${test.title}\\s*\\(`, "m").test(oldText) : test.key.startsWith("rs:") ? new RegExp(`\\bfn\\s+${test.title}\\s*[<(]`).test(oldText) : test.key.startsWith("go:") ? new RegExp(`^func\\s+(?:\\([^)]*\\)\\s*)?${test.title}\\s*\\(`, "m").test(oldText) : oldText.includes(test.title);
+  const markedBefore = /* @__PURE__ */ new Map();
   let unnamedBefore = 0;
-  for (const finding2 of before.filter(isKnownFailureMarker)) {
+  for (const finding2 of before.filter(isTestMarker)) {
     const test = markedTest(finding2, oldLines);
-    if (test) markedBefore.add(test.key);
+    if (test) markedBefore.set(test.key, (markedBefore.get(test.key) ?? 0) + 1);
     else unnamedBefore++;
   }
-  const found = [], unnamed = [], seen = /* @__PURE__ */ new Set();
+  const found = [], unnamed = [], seen = /* @__PURE__ */ new Map();
   for (const finding2 of markers) {
     const test = markedTest(finding2, newLines);
     if (!test) {
       unnamed.push(finding2);
       continue;
     }
-    if (markedBefore.has(test.key) || seen.has(test.key) || !existed(test)) continue;
-    seen.add(test.key);
+    const nth = (seen.get(test.key) ?? 0) + 1, had = markedBefore.get(test.key) ?? 0;
+    seen.set(test.key, nth);
+    if (nth <= had || had === 0 && (nth > 1 && !test.key.startsWith("js:") || !existed(test))) continue;
     found.push(finding2);
   }
   return [...found, ...unnamed.slice(unnamedBefore)];
@@ -3919,7 +4200,8 @@ var THRESHOLD_PATTERNS = [
 var SWITCHES = ["strict", "noImplicitAny", "strictNullChecks", "noImplicitReturns", "useUnknownInCatchVariables"];
 var GATE_SCRIPT = /^(?:pre|post)?(?:test|lint|typecheck|type-check|check|ci|verify|validate)(?::[\w:.-]+)?$/;
 var CI_RUNNER = new RegExp(
-  String.raw`(?<![\w./-])(?:pytest|vitest|jest|mocha|tox|nox)(?![\w/-])` + String.raw`|(?<![\w./-])(?:npm|yarn|pnpm|bun|go|cargo|mvn|gradle|make|dotnet|flutter)\s+(?:run\s+)?(?:-\S+\s+)*test(?![\w/])` + String.raw`|\brun:.*(?<=\s)(?:tests?|unit|e2e)(?![\w/.-])`
+  String.raw`(?<![\w./-])(?:pytest|vitest|jest|mocha|tox|nox)(?![\w/-])` + String.raw`|(?<![\w./-])(?:npm|yarn|pnpm|bun|go|cargo|mvn|gradle|make|dotnet|flutter)\s+(?:run\s+)?(?:-\S+\s+)*test(?![\w/])` + // Monorepo runners: `nx affected --target=test`, `turbo run test`, `lerna run test`, `bazel test //...`.
+  String.raw`|(?<![\w./-])(?:nx|turbo|lerna|rush)\s+(?:run-many|affected|run|test)\b[^\n]*(?<![\w-])(?:test|tests)(?![\w-])` + String.raw`|(?<![\w./-])(?:bazel\s+test|ctest|phpunit|rspec|deno\s+test)(?![\w/-])` + String.raw`|\brun:.*(?<=\s)(?:tests?|unit|e2e)(?![\w/.-])`
 );
 var CI_FILE = /(?:\.github\/workflows\/|\.gitlab-ci)/;
 var CI_REUSABLE = /^\s*-?\s*uses:\s*\S*\.github\/workflows\/\S+/;
@@ -4221,7 +4503,7 @@ async function compareSnapshot(options, cwd, snapshot) {
         const fingerprint = findingFingerprint(finding2);
         existingCounts.set(fingerprint, (existingCounts.get(fingerprint) ?? 0) + 1);
       }
-      result.infractions.push(...compared.introduced.filter((finding2) => !isKnownFailureMarker(finding2)), ...newKnownFailureMarkers(before, after, oldText, newText));
+      result.infractions.push(...compared.introduced.filter((finding2) => !isTestMarker(finding2)), ...newTestMarkers(before, after, oldText, newText));
       result.removedFindings.push(...compared.removed);
       result.unchangedCount += compared.unchanged;
       result.beforeFindings += before.length;

package/dist/cli.js

@@ -38,7 +38,7 @@ import {
   terminalText,
   uninstallHooks,
   writeBaseline
-} from "./chunk-52FUQ4EP.js";
+} from "./chunk-2KWC2IAP.js";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.js

@@ -91,7 +91,7 @@ import {
   unquoteGitPath,
   validateExceptions,
   writeBaseline
-} from "./chunk-52FUQ4EP.js";
+} from "./chunk-2KWC2IAP.js";
 export {
   AGENT_LABELS,
   CONFIG_FILENAMES,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-roast",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Stops AI coding agents (and rushed humans) from turning a build green by weakening tests, coverage gates or CI. Hook for Claude Code, Codex and Cursor, pre-commit, GitHub Action. Offline.",
   "mcpName": "io.github.Nari-Ab/agent-roast",
   "type": "module",