agentic-flow-kit 1.8.7 → 2.0.0

package/templates/_agents/scripts/rewrite-file.mjs

@@ -1,133 +0,0 @@
-#!/usr/bin/env node
-// rewrite-file.mjs — 按行字面替换 + 响亮失败（2026-10-12 silent-noop-loud-failure）
-// 背景（papercut 2026-10-06 行，留痕在包源仓 git 历史与 CHANGELOG；两次假落账实证）：
-//   `node -e "fs.writeFileSync(p, s.replace(A, B))"` 对 **CRLF 检出文件**用 `\n` 锚串定位时
-//   **静默无操作**，脚本照样打印「落账 OK」——假成功比响亮失败危险得多（台账/文档被以为改了）。
-// 本工具把该形态的三个失效点逐一堵死：
-//   ① 按行处理并保留原行尾（`/\r?\n/` 切分 + 检出 EOL 回写）——不再有「\n 锚串匹配不上 CRLF」这一类
-//   ② 替换数必须与 --expect 相符（默认 1）——0 命中即非零退出，**文件不写**，绝不存在「以为改了」
-//   ③ 写后回读校验（新锚已在、旧锚已零、行数不变、EOL 未变）——全过才打印成功；任一不过即非零退出
-// 另防两类自伤：find === replace（无操作却报成功）与目标文件不存在（fail-loud，不静默建文件）。
-// 原子写：同目录临时文件 + rename——中途崩溃不留半写文件（沿 git-merge-jsonl.mjs / compact-ledgers.mjs 惯例）。
-// 用法：node .agents/scripts/rewrite-file.mjs <文件> --find <字面串> --replace <字面串>
-//         [--expect N] [--allow-multi] [--dry-run] [--root <仓库根>]
-//   --expect N    期望命中数（默认 1）；实际 ≠ N → 非零退出且不写盘
-//   --allow-multi 显式声明允许多命中（等价 --expect 的宽松形态：N ≥ 1 即过，用于批量同串替换）
-//   --dry-run     只打印将发生的替换与校验预览，不写盘
-// 测试：node .agents/scripts/rewrite-file.test.mjs
-// 沿革：2026-10-12 立档（优先级 3：把「静默无操作」改成响亮失败）
-import fs from 'node:fs';
-import path from 'node:path';
-
-const argv = process.argv.slice(2);
-const argOf = (k) => {
-  const i = argv.indexOf(k);
-  return i >= 0 && i + 1 < argv.length ? argv[i + 1] : '';
-};
-const DRY = argv.includes('--dry-run');
-const MULTI = argv.includes('--allow-multi');
-let file = '';
-let find = null;
-let replace = null;
-for (let i = 0; i < argv.length; i++) {
-  const a = argv[i];
-  if (a === '--find') find = argv[++i] ?? null;
-  else if (a === '--replace') replace = argv[++i] ?? null;
-  else if (a === '--expect') { /* 下面统一解析 */ }
-  else if (a === '--root') { /* 仅为与其它脚本口令一致，路径按 cwd 解析 */ i++; }
-  else if (a === '--dry-run' || a === '--allow-multi') { /* 旗标已处理 */ }
-  else if (!a.startsWith('--') && !file) file = a;
-}
-const expectRaw = argOf('--expect');
-
-const USAGE = `用法：node .agents/scripts/rewrite-file.mjs <文件> --find <字面串> --replace <字面串> [--expect N] [--allow-multi] [--dry-run]`;
-const die = (msg) => { console.error(`❌ rewrite-file: ${msg}\n${USAGE}`); process.exit(1); };
-if (argv.includes('--help') || argv.includes('-h')) { console.log(USAGE); process.exit(0); }
-if (!file) die('缺目标文件');
-if (find === null || replace === null) die('--find 与 --replace 必须成对给出');
-if (find === '') die('--find 不能为空串（空串会命中每一行，属误用）');
-if (find === replace) die(`--find 与 --replace 相同（「${find.slice(0, 40)}」）——无操作却会报成功，正是本工具要堵的形态`);
-let expect = 1;
-if (expectRaw !== '') {
-  if (!/^\d+$/.test(expectRaw)) die(`--expect 须为非负整数（现 ${expectRaw}）`);
-  expect = Number(expectRaw);
-}
-if (MULTI && expectRaw !== '') die('--allow-multi 与 --expect 互斥（一个宽松一个严格，同给无法裁决）');
-
-const abs = path.resolve(process.cwd(), file);
-if (!fs.existsSync(abs)) die(`目标文件不存在：${file}（不静默创建新文件——路径写错时应响亮失败）`);
-let raw;
-try { raw = fs.readFileSync(abs, 'utf8'); } catch (err) { die(`读取失败：${file}（${err.message}）`); }
-
-// ---- 按行处理 + EOL 保全 ----
-const crlf = raw.includes('\r\n');
-const eol = crlf ? '\r\n' : '\n';
-const hadTrailingNewline = /\r?\n$/.test(raw);
-const lines = raw.split(/\r?\n/);
-// 末行是「 trailing newline 产生的空串」时不计入可替换行集合（避免把 EOF 空串当一行改）
-const bodyLines = hadTrailingNewline ? lines.slice(0, -1) : lines;
-
-let hits = 0;
-const changedIdx = [];
-const newBody = bodyLines.map((l, i) => {
-  if (!l.includes(find)) return l;
-  const n = l.split(find).length - 1;
-  hits += n;
-  changedIdx.push(i + 1);
-  return l.split(find).join(replace);
-});
-
-if (hits === 0) {
-  console.error(`❌ rewrite-file: 0 命中——未写盘（文件保持原样）`);
-  console.error(`   文件：${file}`);
-  console.error(`   行尾：${crlf ? 'CRLF（仓库 autocrlf 检出态）' : 'LF'}｜总行数：${bodyLines.length}`);
-  console.error(`   锚串（前 80 字符）：${JSON.stringify(find.slice(0, 80))}`);
-  console.error(`   常见成因：① 锚串与文件实际内容不一致（空格/全角/标点）；② 用 \\n 跨行锚串去匹配 CRLF 文件——本工具按行匹配，跨行锚请拆成单行锚或改用 Edit 工具；③ 文件已被前一次改动写过。`);
-  process.exit(1);
-}
-if (MULTI) {
-  if (hits < 1) die('内部不变式违反：hits < 1');
-} else if (hits !== expect) {
-  console.error(`❌ rewrite-file: 命中数 ${hits} ≠ 期望 ${expect}——未写盘（文件保持原样）`);
-  console.error(`   文件：${file}｜命中行号：${changedIdx.join(', ')}`);
-  console.error(`   含义：锚串不是唯一命中——要么目标不唯一（应加 --expect ${hits} 或 --allow-multi 明示），要么文件已被改过。`);
-  process.exit(1);
-}
-
-const out = newBody.join(eol) + (hadTrailingNewline ? eol : '');
-if (newBody.length !== bodyLines.length) die('内部不变式违反：行数发生变化');
-
-if (DRY) {
-  console.log(`[dry-run] ${file}：将替换 ${hits} 处（行 ${changedIdx.join(', ')}），行尾 ${crlf ? 'CRLF' : 'LF'}，未写盘`);
-  process.exit(0);
-}
-
-// ---- 原子写 ----
-const tmp = `${abs}.rewrite-tmp`;
-try {
-  fs.writeFileSync(tmp, out, 'utf8');
-  fs.renameSync(tmp, abs);
-} catch (err) {
-  try { fs.unlinkSync(tmp); } catch { /* tmp 可能尚未创建 */ }
-  die(`写入失败：${file}（${err.message}）——原文件应保持原样，请核对后重试`);
-}
-
-// ---- 写后回读校验（③）：任一不过即非零退出，绝不打印成功 ----
-const problems = [];
-let back;
-try { back = fs.readFileSync(abs, 'utf8'); } catch (err) { die(`回读失败：${file}（${err.message}）——写入结果不可验证，请人工核对`); }
-if (back !== out) problems.push('回读内容与拟写内容不一致（写入被截断或并发改动）');
-if (back.includes(find)) problems.push('旧锚串仍存在于回读内容中（替换不完整）');
-if (replace !== '' && !back.includes(replace)) problems.push('新锚串不在回读内容中');
-const backLines = back.split(/\r?\n/);
-const backBody = hadTrailingNewline ? backLines.slice(0, -1) : backLines;
-if (backBody.length !== bodyLines.length) problems.push(`行数变化：${bodyLines.length} → ${backBody.length}`);
-if (back.includes('\r\n') !== crlf) problems.push(`行尾形态变化：${crlf ? 'CRLF' : 'LF'} → ${back.includes('\r\n') ? 'CRLF' : 'LF'}`);
-if (problems.length) {
-  console.error(`❌ rewrite-file: 写后回读校验未过——${file}`);
-  problems.forEach((p) => console.error(`   - ${p}`));
-  console.error('   现场已保留（不要手改），请核对后用 git 恢复或重新替换');
-  process.exit(1);
-}
-
-console.log(`✅ rewrite-file: ${file} 替换 ${hits} 处（行 ${changedIdx.join(', ')}）｜行尾 ${crlf ? 'CRLF' : 'LF'} 保全｜行数 ${bodyLines.length} 不变｜回读校验通过`);

package/templates/_agents/scripts/rewrite-file.test.mjs

@@ -1,148 +0,0 @@
-#!/usr/bin/env node
-// rewrite-file.test.mjs — 按行字面替换 + 响亮失败 fixture 套件（2026-10-12 silent-noop-loud-failure）
-// 覆盖：CRLF 保全（papercut 2026-10-06 的静默无操作场景）/ 0 命中不写盘 / 命中数不符期望 /
-//       --allow-multi / --dry-run / 缺文件 fail-loud / find===replace 自伤防护 / 跨行锚串必失败 /
-//       无尾换行保全 / 写后回读校验成功形态
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-const SCRIPT = path.join(SCRIPT_DIR, 'rewrite-file.mjs');
-
-let pass = 0;
-let fail = 0;
-const check = (desc, cond, detail = '') => {
-  if (cond) { pass++; console.log(`PASS  ${desc}`); }
-  else { fail++; console.log(`FAIL  ${desc}${detail ? '\n      ' + detail : ''}`); }
-};
-
-const run = (file, args) => {
-  const r = spawnSync(process.execPath, [SCRIPT, file, ...args], { encoding: 'utf8' });
-  return { code: r.status, out: `${r.stdout || ''}${r.stderr || ''}` };
-};
-const mk = (name, content) => {
-  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'rewrite-file-'));
-  const p = path.join(d, name);
-  fs.writeFileSync(p, content, 'utf8');
-  return p;
-};
-
-// T1：基本 LF 替换 → exit 0 + 内容正确 + 成功语含回读校验
-{
-  const p = mk('lf.md', 'a\nANCHOR\nc\n');
-  const r = run(p, ['--find', 'ANCHOR', '--replace', 'NEW']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T1 基本 LF 替换 → exit 0 且内容正确', r.code === 0 && after === 'a\nNEW\nc\n', r.out);
-  check('T1b 成功语含「回读校验通过」', /回读校验通过/.test(r.out), r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T2：CRLF 保全——papercut 2026-10-06 的静默无操作场景，本工具必须真改且不坏行尾
-{
-  const p = mk('crlf.md', 'line1\r\nANCHOR here\r\nline3\r\n');
-  const r = run(p, ['--find', 'ANCHOR', '--replace', 'NEW']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T2 CRLF 文件替换成功且行尾保全', r.code === 0 && after === 'line1\r\nNEW here\r\nline3\r\n', r.out);
-  check('T2b 未混入裸 LF（无 CRLF→LF 漂移）', !/[^\r]\n/.test(after), JSON.stringify(after));
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T3：0 命中 → exit 1 且文件逐字节不变（核心：绝不存在「以为改了」）
-{
-  const before = 'x\r\nZZZ not here\r\n';
-  const p = mk('nohit.md', before);
-  const r = run(p, ['--find', 'QQQ', '--replace', 'Q']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T3 0 命中 → exit 1 且文件逐字节不变', r.code === 1 && after === before, r.out);
-  check('T3b 报错点名行尾与常见成因（CRLF 检出态）', /0 命中/.test(r.out) && /CRLF/.test(r.out) && /跨行锚/.test(r.out), r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T4：命中数与期望不符 → exit 1 且不写盘（锚串非唯一时必须响亮，不可顺手全改）
-{
-  const before = 'k\nk\n';
-  const p = mk('multi.md', before);
-  const r = run(p, ['--find', 'k', '--replace', 'K']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T4 命中 2 ≠ 期望 1 → exit 1 且未写盘', r.code === 1 && after === before && /命中数 2 ≠ 期望 1/.test(r.out), r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T5：显式 --expect 2 → 过（同一行两处命中也按处计）
-{
-  const p = mk('expect2.md', 'k k\n');
-  const r = run(p, ['--find', 'k', '--replace', 'K', '--expect', '2']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T5 --expect 2 且命中 2 → exit 0 且两处都改', r.code === 0 && after === 'K K\n', r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T6：--allow-multi 多命中 → 过（宽松形态，明示批量）
-{
-  const p = mk('allowmulti.md', 'k\nk\nk\n');
-  const r = run(p, ['--find', 'k', '--replace', 'K', '--allow-multi']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T6 --allow-multi 三命中 → exit 0 且全改', r.code === 0 && after === 'K\nK\nK\n', r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T7：--allow-multi 与 --expect 互斥 → exit 1（一宽一严无法裁决）
-{
-  const p = mk('conflict.md', 'k\n');
-  const r = run(p, ['--find', 'k', '--replace', 'K', '--allow-multi', '--expect', '1']);
-  check('T7 --allow-multi 与 --expect 互斥 → exit 1', r.code === 1 && /互斥/.test(r.out), r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T8：--dry-run → 不写盘
-{
-  const p = mk('dry.md', 'a\nANCHOR\n');
-  const r = run(p, ['--find', 'ANCHOR', '--replace', 'NEW', '--dry-run']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T8 --dry-run → exit 0 且未写盘', r.code === 0 && after === 'a\nANCHOR\n' && /dry-run/.test(r.out), r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T9：目标文件不存在 → exit 1 fail-loud（不静默创建新文件）
-{
-  const d = fs.mkdtempSync(path.join(os.tmpdir(), 'rewrite-file-'));
-  const r = run(path.join(d, 'nope.md'), ['--find', 'a', '--replace', 'b']);
-  check('T9 文件不存在 → exit 1 且不创建文件', r.code === 1 && /不存在/.test(r.out) && !fs.existsSync(path.join(d, 'nope.md')), r.out);
-  fs.rmSync(d, { recursive: true, force: true });
-}
-// T10：find === replace → exit 1（无操作却报成功，正是要堵的形态）
-{
-  const p = mk('same.md', 'a\nSAME\n');
-  const r = run(p, ['--find', 'SAME', '--replace', 'SAME']);
-  check('T10 find === replace → exit 1', r.code === 1 && /相同/.test(r.out), r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T11：跨行锚串（含 \n）→ 0 命中 exit 1——把「\n 锚串匹配 CRLF 文件静默无操作」变成响亮失败
-{
-  const p = mk('crossline.md', 'aaa\r\nbbb\r\n');
-  const r = run(p, ['--find', 'aaa\nbbb', '--replace', 'xxx']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T11 跨行锚串 → exit 1 且文件不变（提示拆单行锚）', r.code === 1 && after === 'aaa\r\nbbb\r\n' && /跨行锚/.test(r.out), r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T12：无尾换行保全
-{
-  const p = mk('notrailing.md', 'a\nANCHOR');
-  const r = run(p, ['--find', 'ANCHOR', '--replace', 'NEW']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T12 原文件无尾换行 → 替换后仍无尾换行', r.code === 0 && after === 'a\nNEW', JSON.stringify(after));
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T13：空 --find → exit 1（空串会命中每一行，属误用）
-{
-  const p = mk('emptyfind.md', 'a\n');
-  const r = run(p, ['--find', '', '--replace', 'b']);
-  check('T13 空 --find → exit 1', r.code === 1 && /不能为空串/.test(r.out), r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-// T14：同行的两处命中按处计数，且 --expect 3 精确匹配（处计数语义显式化）
-{
-  const p = mk('twiceinline.md', 'k-k-k\n');
-  const r = run(p, ['--find', 'k', '--replace', 'K', '--expect', '3']);
-  const after = fs.readFileSync(p, 'utf8');
-  check('T14 同行多处按处计数（3 处）→ exit 0', r.code === 0 && after === 'K-K-K\n', r.out);
-  fs.rmSync(path.dirname(p), { recursive: true, force: true });
-}
-
-console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
-process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/rule-budget.mjs

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-// 常驻面体积预算检查（单源：本脚本 + .agents/rule-budgets.txt；触发点：check-hygiene 检查 13（--all，WARN）、
-// .githooks/pre-commit（--staged，硬拦））
-// 自 sh 版移植 node（2026-10-08 ci 去 sh 化；2026-10-13 自 Shipyard.Material 参考实现回灌）——CI agent（Windows）
-// 免 git-bash 依赖，check-loop 检查 13 从「无 sh 静默跳过」变恒可跑。语义逐条对齐 sh 版：
-//   --all    查「提交后树」全量；--staged 仅查本次暂存触及的条目 + 触及目录的合计
-//   退出码 0 通过 / 1 超限（违例打到 stdout，调用方决定警告还是阻断）；缺预算表 exit 0（fixture 沙箱不拦——既有语义）
-// 「提交后树」= 索引（index）内容：staged 版优先于 HEAD；无 git（fixture）回退工作区文件。
-// 字节口径 = 索引 / HEAD 内容（git cat-file，LF 归一）。禁用工作区 wc -c 口径（CRLF 膨胀系统性偏大，
-// 2026-09-21 实测差 ~500B 一度误判超限）——本脚本所有字节数都走 cat-file，仅无 git 时才落工作区。
-// 条目数预算（2026-10-15 减重手段② 自源仓回灌）：上限字段形如 `<N>#count` 时按「匹配文件条数」执法
-//   而非字节——规则面一进一出（新增一条须先退役一条，退役判定 agg-judgments --retire-candidates）。
-//   旧格式行（纯数字）不受影响；`#count` 行对旧读者（未升级的脚本副本）因上限非纯数字被跳过——
-//   fail-open，不误拦。
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const mode = process.argv[2] === '--staged' ? '--staged' : '--all';
-
-const git = (args) => {
-  const r = spawnSync('git', args, { encoding: 'utf8' });
-  return { ok: !r.error && r.status === 0, out: (r.stdout || '').trim() };
-};
-const root = git(['rev-parse', '--show-toplevel']);
-if (root.ok) process.chdir(root.out); // 非 git 环境（fixture 沙箱）留在原地
-
-const BUDGETS = '.agents/rule-budgets.txt';
-if (!fs.existsSync(BUDGETS)) process.exit(0);
-
-// 「提交后」字节数：索引 → HEAD → 工作区
-const fsize = (f) => {
-  if (git(['cat-file', '-e', `:${f}`]).ok) return Number(git(['cat-file', '-s', `:${f}`]).out);
-  if (git(['cat-file', '-e', `HEAD:${f}`]).ok) return Number(git(['cat-file', '-s', `HEAD:${f}`]).out);
-  try { return fs.readFileSync(f).length; } catch { return 0; }
-};
-
-const staged = mode === '--staged'
-  ? git(['-c', 'core.quotepath=off', 'diff', '--cached', '--name-only']).out.split('\n').filter(Boolean)
-  : [];
-
-// intentional-simple: glob 仅支持预算表在用的两形态——「固定目录 + * 后缀」（.agents/commands/*.md）
-// 与目录本身（/ 结尾，展开一层直接子文件）；表出现更复杂 glob 时再升级
-const expand = (pat) => {
-  if (pat.endsWith('/')) {
-    const dir = pat.replace(/\/$/, '');
-    if (!fs.existsSync(dir)) return [];
-    return fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile())
-      .map((e) => path.join(dir, e.name));
-  }
-  if (pat.includes('*')) {
-    const i = pat.lastIndexOf('/');
-    const dir = i < 0 ? '.' : pat.slice(0, i);
-    const name = pat.slice(i + 1);
-    const star = name.indexOf('*');
-    const pre = name.slice(0, star), suf = name.slice(star + 1);
-    if (!fs.existsSync(dir)) return [];
-    return fs.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile()
-      && e.name.startsWith(pre) && e.name.endsWith(suf))
-      .map((e) => path.join(dir, e.name));
-  }
-  return fs.existsSync(pat) ? [pat] : [];
-};
-
-let viol = 0;
-const over = (what, bytes, lim) => { console.log(`常驻面超限：${what} ${bytes}B > 上限 ${lim}B`); viol = 1; };
-const overCount = (pat, n, lim) => { console.log(`常驻面超限（条目数）：${pat} ${n} 项 > 上限 ${lim} 项——一进一出：新增须先退役一条（退役判定 agg-judgments --retire-candidates）`); viol = 1; };
-
-for (const line of fs.readFileSync(BUDGETS, 'utf8').split(/\r?\n/)) {
-  const sp = line.lastIndexOf(' ');
-  if (sp < 0) continue;
-  const pat = line.slice(0, sp), lim = line.slice(sp + 1);
-  if (pat === '' || pat.startsWith('#')) continue;
-  // 条目数预算（2026-10-15 减重手段②）：`<N>#count` = 匹配文件数上限（一进一出的执法面）
-  const cnt = /^(\d+)#count$/.exec(lim);
-  if (!cnt && !/^\d+$/.test(lim)) continue;
-  if (cnt) {
-    if (mode === '--staged' && !staged.some((sf) => sf.startsWith(pat))) continue;
-    const n = expand(pat).length;
-    if (n > Number(cnt[1])) overCount(pat, n, cnt[1]);
-    continue;
-  }
-  if (pat.endsWith('/')) {
-    // 目录合计：--staged 下仅当暂存触及该目录内文件才查（字面前缀匹配，同 sh 版 2026-09-24 口径）
-    if (mode === '--staged' && !staged.some((sf) => sf.startsWith(pat))) continue;
-    const total = expand(pat).reduce((s, f) => s + fsize(f), 0);
-    if (total > Number(lim)) over(`${pat} 合计`, total, lim);
-  } else {
-    for (const f of expand(pat)) {
-      if (mode === '--staged' && !staged.includes(f.replace(/\\/g, '/'))) continue;
-      const b = fsize(f);
-      if (b > Number(lim)) over(f, b, lim);
-    }
-  }
-}
-process.exit(viol ? 1 : 0);

package/templates/_agents/scripts/rule-budget.test.mjs

@@ -1,118 +0,0 @@
-#!/usr/bin/env node
-// rule-budget.test.mjs — 常驻面预算黑盒套件（2026-10-15 减重手段② 自源仓回灌随附：#count 条目数指令）
-// 夹具：os.tmpdir 下临时目录（非 git 环境——脚本 git rev-parse 失败留在 fixture 目录，
-// 字节口径回退工作区文件；与真实仓「索引/HEAD」口径的差异不影响指令语义判定）。
-// 覆盖：字节超限/未超、#count 超限/压线、旧格式行不受 #count 影响、缺预算表 exit 0、
-//       --staged 无 git（staged 空）时 #count 门跳过。
-// 运行：node templates/_agents/scripts/rule-budget.test.mjs
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-
-const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'rule-budget.mjs');
-
-let pass = 0;
-let fail = 0;
-const check = (desc, cond, detail = '') => {
-  if (cond) { pass++; console.log(`PASS  ${desc}`); }
-  else { fail++; console.log(`FAIL  ${desc}${detail ? '\n      ' + detail : ''}`); }
-};
-
-function makeFixture({ budgets, dirs = {}, files = {} }) {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'rule-budget-'));
-  if (budgets !== null) {
-    fs.mkdirSync(path.join(root, '.agents'), { recursive: true });
-    fs.writeFileSync(path.join(root, '.agents', 'rule-budgets.txt'), budgets, 'utf8');
-  }
-  for (const [dir, names] of Object.entries(dirs)) {
-    fs.mkdirSync(path.join(root, dir), { recursive: true });
-    for (const n of names) fs.writeFileSync(path.join(root, dir, n), 'x\n', 'utf8');
-  }
-  for (const [f, content] of Object.entries(files)) {
-    fs.mkdirSync(path.dirname(path.join(root, f)), { recursive: true });
-    fs.writeFileSync(path.join(root, f), content, 'utf8');
-  }
-  return root;
-}
-
-const run = (cwd, mode = '--all') => {
-  const r = spawnSync(process.execPath, [SCRIPT, mode], { cwd, encoding: 'utf8' });
-  return { code: r.status, out: String(r.stdout || '') };
-};
-
-let root;
-
-// ---- T1 字节超限（旧格式语义不回归）----
-root = makeFixture({
-  budgets: 'AGENTS.md 10\n',
-  files: { 'AGENTS.md': 'x'.repeat(50) },
-});
-{
-  const r = run(root);
-  check('T1 字节超限 exit 1 + 违例行', r.code === 1 && r.out.includes('常驻面超限：AGENTS.md') && r.out.includes('> 上限 10B'), JSON.stringify(r));
-}
-
-// ---- T2 字节未超 → 0 ----
-root = makeFixture({
-  budgets: 'AGENTS.md 100\n',
-  files: { 'AGENTS.md': 'x'.repeat(50) },
-});
-check('T2 字节未超 exit 0', run(root).code === 0);
-
-// ---- T3 #count 超限 ----
-root = makeFixture({
-  budgets: '.agents/rules/ 2#count\n',
-  dirs: { '.agents/rules': ['r01-a.md', 'r02-b.md', 'r03-c.md'] },
-});
-{
-  const r = run(root);
-  check('T3 #count 超限 exit 1 + 条目数违例行 + 一进一出提示', r.code === 1 && r.out.includes('条目数') && r.out.includes('3 项 > 上限 2 项') && r.out.includes('一进一出'), JSON.stringify(r));
-}
-
-// ---- T4 #count 压线（= 上限）→ 0 ----
-root = makeFixture({
-  budgets: '.agents/rules/ 3#count\n',
-  dirs: { '.agents/rules': ['r01-a.md', 'r02-b.md', 'r03-c.md'] },
-});
-check('T4 #count 压线 exit 0', run(root).code === 0);
-
-// ---- T5 混合表：#count 行存在但未触其它字节条目 → 0（互不干扰）----
-root = makeFixture({
-  budgets: 'AGENTS.md 100\n.agents/rules/ 3#count\n',
-  files: { 'AGENTS.md': 'x'.repeat(50) },
-  dirs: { '.agents/rules': ['r01-a.md', 'r02-b.md', 'r03-c.md'] },
-});
-check('T5 混合表双通过 exit 0', run(root).code === 0);
-
-// ---- T6 缺预算表 → exit 0（fixture 沙箱不拦，既有语义）----
-root = makeFixture({ budgets: null });
-check('T6 缺预算表 exit 0', run(root).code === 0);
-
-// ---- T7 --staged 无 git（staged 空）：#count 门跳过不拦 ----
-root = makeFixture({
-  budgets: '.agents/rules/ 2#count\n',
-  dirs: { '.agents/rules': ['r01-a.md', 'r02-b.md', 'r03-c.md'] },
-});
-{
-  const r = run(root, '--staged');
-  check('T7 --staged 无 git 环境跳过 #count 门 exit 0', r.code === 0, JSON.stringify(r));
-}
-
-// ---- T8 glob 形态 #count（* 后缀）也按条数执法 ----
-root = makeFixture({
-  budgets: '.agents/commands/*.md 2#count\n',
-  dirs: { '.agents/commands': ['a.md', 'b.md', 'c.md', 'd.txt'] },
-});
-{
-  const r = run(root);
-  check('T8 glob #count 只数 *.md（3 项 > 2）exit 1', r.code === 1 && r.out.includes('3 项'), JSON.stringify(r));
-}
-
-for (const d of fs.readdirSync(os.tmpdir()).filter((f) => f.startsWith('rule-budget-'))) {
-  try { fs.rmSync(path.join(os.tmpdir(), d), { recursive: true, force: true }); } catch { /* Windows 文件锁容忍 */ }
-}
-
-console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
-process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/run-tests.mjs

@@ -1,99 +0,0 @@
-#!/usr/bin/env node
-// run-tests — 引擎脚本测试统一入口（2026-10-08 agents-hygiene 批2；2026-10-09 并行化）
-// 用途：一条命令跑 .agents/scripts/ 下全部 *.test.mjs 套件——逐个 node 直跑（与 test.md 逐条口径一致，
-//       不引 node --test：既有套件是自研 check/「合计: PASS n / FAIL n」计数风格，非 node:test 风格）。
-// 语义：套件并发执行（默认 6，--concurrency <N> 可调，1 = 等价旧串行；非正整数 fail-loud）——每套件
-//       stdout/stderr 缓冲、完成即回放（「[run-tests] ▶ 套件名」分隔头，避免并行交错不可读）；
-//       stderr 仅红套件回放尾部 5 行防刷屏；聚合各套件「合计: PASS n / FAIL n」末次计数（无该行按 0 计）；
-//       任一套件 exit 非零 / spawn 失败 / 计数 FAIL>0 → 该套件记红；有红套件即 exit 1。
-//       套件发现 = 目录内 *.test.mjs 字典序（非递归）；回放按完成序（并行的自然结果，不影响裁决）。
-// 红线：只做调度层并行，不改任何套件内部；并发默认 6（2026-10-09 实测：串行 2m47s → 并发4 2m05s →
-// 并发6 1m48s，套件各异步 tmp fixture 无共享态）——Windows spawn 密集会放大瞬时抖动（同日实证一次
-// git EBUSY 偶发红），故不取更高默认；套件内 git 调用已有 gitRetry 防护。
-// 2026-10-10 复测定案（perf 系列）：6→12 仅 -3~5%（114.4s → 111.8/108.4s，本机 12 核，两次 c12 全绿
-// 无偶发红；噪声带 ±3s）——膝点在 4-6 间，并发档位已非杠杆：工作池地板 = check-loop.test 独跑
-// 73.8s（占总时长 65%，234 次套件内顺序 spawn node）。再快须并行化套件内场景（动套件内部结构，
-// 撞本红线），收益/风险另议；默认维持 6。
-// 用法：node .agents/scripts/run-tests.mjs [--dir <目录>] [--only <文件名子串>] [--concurrency <N>]
-//       --dir 默认本脚本所在目录（测试注入钩子）；--only 过滤文件名（调试单套件用，如 --only check-loop）。
-// 测试：node .agents/scripts/run-tests.test.mjs（临时目录夹具：并行全绿聚合 / 红套件 / 崩溃套件 / --only / 空目录 / 并发数校验 / 并发1=串行）
-// 沿革：2026-10-08 立档（串行）；2026-10-09 并行化（sess_52d1d1be 路线图「串行→并行」真缺口）。
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-
-const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
-const args = process.argv.slice(2);
-const val = (flag) => (args.includes(flag) ? args[args.indexOf(flag) + 1] : null);
-const dir = val('--dir') || SCRIPT_DIR;
-const only = val('--only');
-const concRaw = val('--concurrency');
-const CONC = concRaw === null ? 6 : Number(concRaw);
-if (!Number.isInteger(CONC) || CONC < 1) {
-  console.error(`run-tests: --concurrency 须为正整数（现 ${concRaw}）`);
-  process.exit(1);
-}
-
-let suites;
-try {
-  suites = fs.readdirSync(dir).filter((f) => f.endsWith('.test.mjs') && (!only || f.includes(only))).sort();
-} catch (e) {
-  console.error(`run-tests: 无法读取目录 ${dir}（${e.code || e.message}）`);
-  process.exit(1);
-}
-if (!suites.length) {
-  console.error(`run-tests: ${dir} 下无 *.test.mjs${only ? `（--only ${only}）` : ''}`);
-  process.exit(1);
-}
-
-// 工作池调度（完成一个补一个——分块会让最慢套件阻塞同块槽位，2026-10-09 实测 check-loop.test 独占 ~1/3 时长）
-let totalPass = 0, totalFail = 0, red = 0;
-const runSuite = (s) => new Promise((resolve) => {
-  const child = spawn(process.execPath, [path.join(dir, s)]);
-  let out = '', err = '';
-  child.stdout.on('data', (d) => { out += d; });
-  child.stderr.on('data', (d) => { err += d; });
-  child.on('close', (code) => resolve({ stdout: out, stderr: err, status: code, error: null }));
-  child.on('error', (e) => resolve({ stdout: out, stderr: err, status: null, error: e }));
-});
-const replay = (s, r) => {
-  const m = [...String(r.stdout || '').matchAll(/合计: PASS (\d+) \/ FAIL (\d+)/g)].pop();
-  const p = m ? Number(m[1]) : 0;
-  const f = m ? Number(m[2]) : 0;
-  totalPass += p;
-  totalFail += f;
-  const ok = r.status === 0 && f === 0;
-  process.stdout.write(`\n[run-tests] ▶ ${s}\n`);
-  if (r.stdout) process.stdout.write(r.stdout);
-  if (ok) {
-    console.log(`[run-tests] OK ${s}（PASS ${p} / FAIL ${f}）`);
-  } else {
-    red++;
-    console.log(`[run-tests] RED ${s}${r.status != null ? `（exit ${r.status}）` : r.error ? `（spawn ${r.error.code || r.error.message}）` : ''}${m ? `（PASS ${p} / FAIL ${f}）` : ''}`);
-    if (r.stderr) process.stderr.write(String(r.stderr).split('\n').slice(-5).join('\n') + '\n');
-  }
-};
-{
-  const queue = [...suites];
-  const inflight = new Map(); // suite -> promise（回放按提交序记录、完成即按序回放：用「下一个待回放」指针）
-  const pending = [];         // {s, promise}
-  let cursor = 0;
-  const launch = () => {
-    while (inflight.size < CONC && queue.length) {
-      const s = queue.shift();
-      const pr = runSuite(s).then((r) => ({ s, r }));
-      inflight.set(s, pr);
-      pending.push(pr);
-    }
-  };
-  launch();
-  while (cursor < pending.length) {
-    const { s, r } = await pending[cursor++];
-    inflight.delete(s);
-    replay(s, r);
-    launch();
-  }
-}
-console.log(`\n[run-tests] 套件 ${suites.length}（红 ${red}，并发 ${CONC}）｜断言合计 PASS ${totalPass} / FAIL ${totalFail}${red ? '——红套件见上，修复后原路重跑' : '——全绿'}`);
-process.exit(red ? 1 : 0);