@event4u/agent-config 14.18.0 → 14.20.0

package/dist/cli-delegate/{chunk-CYH5SP6M.js → chunk-I6RHFQEG.js}

@@ -25,6 +25,7 @@ import { spawnSync } from "node:child_process";
 import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 
 // src/scripts/_lib/security_lint.ts
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -41,7 +42,7 @@ var DEFAULT_SCAN_ROOTS = [
   "dist/agent-src"
 ];
 var _EXAMPLE_PATH = /(^|\/)(docs|evals|tests?|fixtures?)(\/|$)|example|template|sample|\/_template/i;
-var _PRAGMA = /<!--\s*security-lint:\s*allow\s+([A-Za-z0-9_-]+)\s+"([^"]+)"\s*-->/g;
+var _PRAGMA = /<!--\s*security-lint:\s*allow\s+([A-Za-z0-9_-]+)\s+"([^"]+)"((?:\s+sha256:[0-9a-f]{64})*)\s*-->/g;
 var _FENCE = /^(\s*)(`{3,}|~{3,})\s*([A-Za-z0-9_-]*)\s*$/;
 var SEVERITY_RANK = { LOW: 1, MED: 2, HIGH: 3 };
 var Finding = class {
@@ -87,6 +88,10 @@ function is_example_path(rel_path) {
 function path_weight(rel_path) {
   return is_example_path(rel_path) ? 0.25 : 1;
 }
+var PROJECTION_PREFIX = "dist/agent-src/";
+function source_identity(rel) {
+  return rel.startsWith(PROJECTION_PREFIX) ? `src/${rel.slice(PROJECTION_PREFIX.length)}` : rel;
+}
 var ScannedFile = class {
   path;
   // absolute or as-given path
@@ -97,8 +102,10 @@ var ScannedFile = class {
   in_any_fence;
   pragmas;
   // check id → reason
+  /** check id → the sha256 fingerprints that pragma accepts. Empty = unbound. */
+  pragma_hashes;
   weight;
-  constructor(pathArg, rel, lines, in_example_fence, in_any_fence, pragmas, weight) {
+  constructor(pathArg, rel, lines, in_example_fence, in_any_fence, pragmas, weight, pragma_hashes = {}) {
     this.path = pathArg;
     this.rel = rel;
     this.lines = lines;
@@ -106,10 +113,74 @@ var ScannedFile = class {
     this.in_any_fence = in_any_fence;
     this.pragmas = pragmas;
     this.weight = weight;
+    this.pragma_hashes = pragma_hashes;
   }
   pragma_allows(check) {
     return Object.prototype.hasOwnProperty.call(this.pragmas, check);
   }
+  /**
+   * Which form of pragma this file carries for `check`.
+   *
+   * `absent`  — no pragma; scan normally.
+   * `legacy`  — a pragma with no fingerprint. Suppresses the whole file, as it
+   *             always did, and says so: a key lookup accepts whatever the
+   *             line is later changed to say, which is the defect being paid
+   *             down, not a mode anybody should choose.
+   * `bound`   — a pragma listing fingerprints. Suppresses exactly the matches
+   *             whose evidence hashes to one of them; anything else survives.
+   */
+  pragma_form(check) {
+    if (!this.pragma_allows(check)) return "absent";
+    return (this.pragma_hashes[check] ?? []).length > 0 ? "bound" : "legacy";
+  }
+  /**
+   * The fingerprint one finding's evidence hashes to.
+   *
+   * WHAT IS HASHED, and each part earns its place:
+   *   check id      — the same line may legitimately be accepted for one check
+   *                   and not another.
+   *   rel path      — the location IDENTITY. Not the line NUMBER: an unrelated
+   *                   insert above would otherwise break every pragma in the
+   *                   file, and a suppression that breaks on unrelated edits
+   *                   gets deleted rather than re-derived. A `dist/agent-src/`
+   *                   path folds to its `src/` original first, because the
+   *                   projection is byte-exact by contract (ADR-201) and
+   *                   carries the pragma verbatim — without the fold, every
+   *                   migrated pragma would suppress the source and leave its
+   *                   own copy flagged, which is a gate that reds on a file
+   *                   nobody may edit.
+   *   matched line, — the evidence. ASCII whitespace runs collapse so a reflow
+   *   normalized      does not invalidate the binding, `sha256:<hex>` tokens are
+   *                   removed, and NOTHING else is stripped: the zero-width
+   *                   characters this suite hunts are exactly what a wider
+   *                   normalizer would erase.
+   *
+   * WHY THE HASH TOKENS COME OUT. A pragma's own reason string can be the
+   * matched evidence — two in this tree are, because they quote the very
+   * phrases their check detects in order to explain themselves. Without this
+   * the fingerprint would have to be computed over a line that already
+   * contains it, which has no fixed point: writing the hash changes the line,
+   * which changes the hash. Stripping the tokens makes the fingerprint stable
+   * under the act of recording it, and costs nothing elsewhere — a `sha256:`
+   * token in ordinary prose is not evidence of anything a linter here checks.
+   *
+   * Deliberately NOT the whole file: incidental content elsewhere would make
+   * every unrelated edit re-fire the pragma, which is the noise that produces
+   * blanket suppressions.
+   */
+  evidence_fingerprint(finding) {
+    const text = finding.line > 0 ? this.lines[finding.line - 1] ?? "" : "";
+    const normalized = text.replace(/\s*sha256:[0-9a-f]{64}/g, "").replace(/[ \t]+/g, " ").trim();
+    return createHash("sha256").update(`${finding.check}
+${source_identity(this.rel)}
+${normalized}`, "utf-8").digest("hex");
+  }
+  /** Drop the findings this file's BOUND pragma for `check` accepts. */
+  filter_bound_pragma(check, findings) {
+    const accepted = new Set(this.pragma_hashes[check] ?? []);
+    if (accepted.size === 0) return [...findings];
+    return findings.filter((f) => !accepted.has(this.evidence_fingerprint(f)));
+  }
   /** Yield [lineno, text] honouring the fence masks (mirrors iter_lines). */
   *iter_lines(opts = {}) {
     const skip_example_fence = opts.skip_example_fence ?? true;
@@ -200,11 +271,18 @@ function scan_file(filePath) {
     }
   }
   const pragmas = {};
+  const pragmaHashes = {};
   for (const text of lines) {
     _PRAGMA.lastIndex = 0;
     let m;
     while ((m = _PRAGMA.exec(text)) !== null) {
-      pragmas[m[1]] = m[2];
+      const check = m[1];
+      pragmas[check] = m[2];
+      const hashes = (m[3] ?? "").match(/sha256:([0-9a-f]{64})/g) ?? [];
+      pragmaHashes[check] = [
+        ...pragmaHashes[check] ?? [],
+        ...hashes.map((h) => h.slice("sha256:".length))
+      ];
       if (m.index === _PRAGMA.lastIndex) {
         _PRAGMA.lastIndex += 1;
       }
@@ -217,7 +295,29 @@ function scan_file(filePath) {
     in_example,
     in_any,
     pragmas,
-    path_weight(rel)
+    path_weight(rel),
+    pragmaHashes
+  );
+}
+function scan_path(filePath, base) {
+  const sf = scan_file(filePath);
+  let rel;
+  const baseResolved = path.resolve(base);
+  const fileResolved = path.resolve(filePath);
+  if (fileResolved === baseResolved || fileResolved.startsWith(baseResolved + path.sep)) {
+    rel = path.relative(baseResolved, fileResolved).split(path.sep).join("/");
+  } else {
+    rel = path.basename(filePath);
+  }
+  return new ScannedFile(
+    sf.path,
+    rel,
+    sf.lines,
+    sf.in_example_fence,
+    sf.in_any_fence,
+    sf.pragmas,
+    path_weight(rel),
+    sf.pragma_hashes
   );
 }
 function _rglobSorted(base) {
@@ -253,9 +353,9 @@ function _pathCmp(a, b) {
   if (pa.length > pb.length) return 1;
   return 0;
 }
-function* iter_corpus(roots = DEFAULT_SCAN_ROOTS, exts = [".md"]) {
+function* iter_corpus(roots = DEFAULT_SCAN_ROOTS, exts = [".md"], scanBase = ROOT) {
   for (const root of roots) {
-    const base = path.join(ROOT, root);
+    const base = path.join(scanBase, root);
     if (!fs.existsSync(base)) {
       continue;
     }
@@ -267,11 +367,27 @@ function* iter_corpus(roots = DEFAULT_SCAN_ROOTS, exts = [".md"]) {
         continue;
       }
       if (st.isFile() && exts.includes(path.extname(p))) {
-        yield scan_file(p);
+        yield scan_path(p, scanBase);
       }
     }
   }
 }
+var LEGACY_PRAGMA_CHECK = "legacy-pragma";
+function legacy_pragma_finding(sf, check) {
+  return new Finding(
+    sf.rel,
+    0,
+    LEGACY_PRAGMA_CHECK,
+    "LOW",
+    `unbound \`security-lint: allow ${check}\` pragma suppresses this whole file \u2014 it accepts whatever the matched text is later changed to say. Bind it with \`sha256:<hex>\` per accepted match.`,
+    sf.weight
+  );
+}
+var CHILD_SCANNED_PREFIX = "scanned: ";
+function report_child_scanned(count) {
+  process.stderr.write(`${CHILD_SCANNED_PREFIX}${String(count)}
+`);
+}
 function report(findings, opts) {
   const check_label = opts.check_label;
   if (findings.length === 0) {
@@ -647,9 +763,11 @@ function _cpName(cp) {
   return n !== void 0 ? n : "<unnamed>";
 }
 function _scan(sf) {
-  if (sf.pragma_allows(CHECK)) {
-    return [];
+  const pragmaForm = sf.pragma_form(CHECK);
+  if (pragmaForm === "legacy") {
+    return [legacy_pragma_finding(sf, CHECK)];
   }
+  const finish = (hits) => pragmaForm === "bound" ? sf.filter_bound_pragma(CHECK, hits) : hits;
   const out = [];
   for (const [lineno, text] of sf.iter_lines({ skip_example_fence: true })) {
     let vs_run = 0;
@@ -687,7 +805,7 @@ function _scan(sf) {
       );
     }
   }
-  return out;
+  return finish(out);
 }
 var _BINARY_EXT = /* @__PURE__ */ new Set([
   "png",
@@ -848,7 +966,7 @@ function _sanitize(filePath) {
   return out;
 }
 function _argError(msg) {
-  process.stderr.write("usage: lint_hidden_unicode [-h] [--json] [--fix]\n");
+  process.stderr.write("usage: lint_hidden_unicode [-h] [--json] [--fix] [--root DIR]\n");
   process.stderr.write(`lint_hidden_unicode: error: ${msg}
 `);
   process.exit(2);
@@ -856,14 +974,27 @@ function _argError(msg) {
 function parse_args(argv) {
   const out = { json: false, fix: false };
   const extra = [];
+  let rootPending = false;
   for (const a of argv) {
+    if (rootPending) {
+      out.root = a;
+      rootPending = false;
+      continue;
+    }
     if (a === "-h" || a === "--help") {
-      process.stdout.write("usage: lint_hidden_unicode [-h] [--json] [--fix]\n");
+      process.stdout.write("usage: lint_hidden_unicode [-h] [--json] [--fix] [--root DIR]\n");
       process.exit(0);
     } else if (a === "--json") {
       out.json = true;
     } else if (a === "--fix") {
       out.fix = true;
+    } else if (a === "--root" || a.startsWith("--root=")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) {
+        out.root = a.slice(eq + 1);
+      } else {
+        rootPending = true;
+      }
     } else {
       extra.push(a);
     }
@@ -875,10 +1006,11 @@ function parse_args(argv) {
 }
 function main(argv = null) {
   const args = parse_args(argv ?? process.argv.slice(2));
+  const scanBase = args.root === void 0 ? ROOT : path2.resolve(args.root);
   const findings = [];
   const flagged = /* @__PURE__ */ new Set();
   let corpusFiles = 0;
-  for (const sf of iter_corpus()) {
+  for (const sf of iter_corpus(DEFAULT_SCAN_ROOTS, [".md"], scanBase)) {
     corpusFiles += 1;
     const hits = _scan(sf);
     for (const h of hits) {
@@ -903,7 +1035,7 @@ function main(argv = null) {
     }
     throw exc;
   }
-  const sourceFiles = _eligibleSourceFiles();
+  const sourceFiles = args.root === void 0 ? _eligibleSourceFiles() : [];
   for (const h of _scanSourceControlBytes(sourceFiles)) {
     findings.push(h);
   }
@@ -922,6 +1054,9 @@ function main(argv = null) {
 `);
     }
   }
+  if (args.json) {
+    report_child_scanned(corpusFiles + (sourceFiles === null ? 0 : sourceFiles.length));
+  }
   if (args.json) {
     const payload = py_json_dumps_indent2(findings.map((f) => f.toDict()));
     process.stdout.write(payload + "\n");
@@ -2298,7 +2433,7 @@ function queryIndex(indexPath, keys, types) {
 }
 
 // src/scripts/learning_sidecar.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import * as fs6 from "node:fs";
 import * as path6 from "node:path";
 import process4 from "node:process";
@@ -2314,7 +2449,7 @@ function _parseTsMs(ts) {
   return Number.isNaN(t) ? null : t;
 }
 function _bodyHash(body) {
-  return createHash("sha256").update(body.trim().toLowerCase()).digest("hex").slice(0, 12);
+  return createHash2("sha256").update(body.trim().toLowerCase()).digest("hex").slice(0, 12);
 }
 function _globSignalFiles(dir) {
   let names;