sawbuck 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sawbuck",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Sign your agent to a contract so it does what you want: a deterministic, zero-LLM check that re-proves every win from the agent's source edits alone, so a green that came from editing the test is caught and reverted. A saddle for your coding harness.",
   "type": "module",
   "license": "MIT",

package/rank.mjs

@@ -14,7 +14,7 @@
 import { execFileSync } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
@@ -61,6 +61,55 @@ const codeish = (p) => /\.(m?[jt]sx?|cjs|py|go|rs|rb|java|kt|c|cc|cpp|h|hpp|php|
 // eslint-disable). The relevance lead: sharpen the signal, don't flatten it.
 const isTest = (p) => /(^|\/)(tests?|__tests__|specs?)\//i.test(p) || /[._-](test|spec)\.[a-z0-9]+$/i.test(p) || /(^|\/)test_[^/]+\.py$/i.test(p);
 
+// Per-language suppression normalization. The 100-repo study (STUDY-100.md) found a suppression's
+// raw count is an idiom artifact, not a risk level: a `# noqa` is background noise in Python (141
+// markers/repo) but a `t.Skip` is notable in Go. So a hit is discounted by how ubiquitous its
+// idiom is in the FILE's language. Discount-only [0.4, 1]: common idioms shrink, rare ones stay at
+// full base weight, and the ordering floor holds (revert 3 > test-skip 2.5 > suppression 2).
+// Reverts are idiom-independent and never normalized. --raw turns this off.
+const raw = process.argv.includes('--raw');
+const langOf = (p) => {
+  const e = (p.match(/\.([a-z0-9]+)$/i) || [, ''])[1].toLowerCase();
+  if (/^tsx?$/.test(e)) return 'ts';
+  if (/^(m?jsx?|cjs)$/.test(e)) return 'js';
+  if (['py', 'go', 'rs', 'php', 'phtml'].includes(e)) return e === 'phtml' ? 'php' : e;
+  if (['java', 'kt', 'kts', 'scala', 'groovy'].includes(e)) return 'java';
+  if (['cs', 'fs', 'vb'].includes(e)) return 'cs';
+  return 'other';
+};
+// baseline = markers/repo for that language+kind, from the study's per-language table.
+const BASELINE = {
+  py: { code: 141, skip: 4.6 }, ts: { code: 89, skip: 19.1 }, js: { code: 37, skip: 10.5 },
+  go: { code: 1.6, skip: 21.6 }, java: { code: 0.5, skip: 13.9 }, rs: { code: 0.3, skip: 4.1 },
+  cs: { code: 0.5, skip: 158 }, php: { code: 0.5, skip: 15 }, other: { code: 20, skip: 10 },
+};
+const REF = 15; // a hit at or below ~15 markers/repo for its language+kind keeps full weight
+const normMult = (p, kind) => {
+  if (raw) return 1;
+  const b = Math.max((BASELINE[langOf(p)] || BASELINE.other)[kind], 0.5);
+  return Math.max(0.4, Math.min(1, REF / b));
+};
+
+// Still-live filter (lead #4). A suppression on a path that is now CLEAN of suppressions is churn,
+// not current risk (the study: AutoMapper carries 4 live `[Ignore]` vs ~158/repo across C# history).
+// logbook's own SUPPRESS_PAT, git-grepped at HEAD but SCOPED to just the touched paths so the
+// per-turn hook stays cheap, tells us which still carry one. Imported so the pattern never drifts;
+// degrades to "treat all as live" if logbook cannot be imported. --raw turns it off.
+let liveSet = null;
+if (!raw && paths.length) {
+  try {
+    const { SUPPRESS_PAT } = await import(pathToFileURL(LB).href);
+    if (SUPPRESS_PAT && SUPPRESS_PAT.source) {
+      let grep = '';
+      try { grep = execFileSync('git', ['-C', repo, 'grep', '-lP', SUPPRESS_PAT.source, 'HEAD', '--', ...paths], { encoding: 'utf8' }); }
+      catch (e) { grep = (e.stdout || '').toString(); } // git grep exits 1 when nothing matches
+      liveSet = new Set(grep.split('\n').filter(Boolean).map((l) => l.replace(/^HEAD:/, '')));
+    }
+  } catch { liveSet = null; } // logbook unavailable -> skip the filter, do not crash the read face
+}
+// a suppression on a still-silenced path keeps its weight; on a now-clean path it is near-zero.
+const stillLive = (p) => (liveSet === null || liveSet.has(p) ? 1 : 0.25);
+
 const DAY = 86400000;
 const ranked = paths.map((p) => {
   let score = 0; const hits = []; const fixDates = [];
@@ -72,8 +121,11 @@ const ranked = paths.map((p) => {
     // "weakened" only on a NET assertion drop (logbook's own rule: del > add + 2), 
     // a rewrite that removes some asserts but adds more is not a weakening.
     else if (codeish(p) && ((e.suppressions && e.suppressions.length) || ((e.del_asserts || 0) > (e.add_asserts || 0) + 2) || e.downgrades > 0)) {
-      if (isTest(p)) { w = 2.5; kind = 'test disabled / weakened'; }
-      else { w = 2; kind = 'suppression in source'; }
+      const hasSupp = e.suppressions && e.suppressions.length;
+      const tst = isTest(p);
+      const m = hasSupp ? normMult(p, tst ? 'skip' : 'code') * stillLive(p) : 1; // normalize by language x still-live; leave a pure assertion-drop at full weight
+      if (tst) { w = 2.5 * m; kind = 'test disabled / weakened'; }
+      else { w = 2 * m; kind = 'suppression in source'; }
     }
     else if (e.fix) { w = 1.2; kind = 'bugfix here'; }
     else continue;