@event4u/agent-config 14.21.0 → 14.23.0

package/dist/cli-delegate/archive_completed_roadmaps.js

@@ -0,0 +1,542 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  blocker_is_resolved,
+  collect,
+  parse_blockers
+} from "./chunk-QAJS5YWY.js";
+import "./chunk-ULET4BYS.js";
+import {
+  isCliEntry
+} from "./chunk-5EK5WQN6.js";
+import "./chunk-YWVXLR44.js";
+import "./chunk-7XGD2OEU.js";
+import {
+  guardedBaselineProblems,
+  parseGuardedBaselines
+} from "./chunk-YDQSHTD7.js";
+import "./chunk-JO25G5H7.js";
+
+// src/agent-src/scripts/archive_completed_roadmaps.ts
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+var _HERE = fileURLToPath(import.meta.url);
+var ArgparseExit = class extends Error {
+  code;
+  constructor(code) {
+    super(`ArgparseExit(${code})`);
+    this.name = "ArgparseExit";
+    this.code = code;
+  }
+};
+function _run(cmd, cwd) {
+  const res = spawnSync(cmd[0], cmd.slice(1), { cwd, encoding: "utf-8" });
+  if (res.error) {
+    return { returncode: -1, stdout: res.stdout ?? "", stderr: String(res.error.message ?? "") };
+  }
+  return {
+    returncode: res.status === null ? -1 : res.status,
+    stdout: res.stdout ?? "",
+    stderr: res.stderr ?? ""
+  };
+}
+function _repo_root() {
+  const cp = _run(["git", "rev-parse", "--show-toplevel"], process.cwd());
+  return cp.returncode === 0 ? cp.stdout.trim() : process.cwd();
+}
+function _splitlines(s) {
+  if (s === "") return [];
+  const parts = s.split(/\r\n|\r|\n/);
+  if (parts.length && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+function _branch_touched_paths(root, base) {
+  const cp = _run(
+    ["git", "log", `${base}..HEAD`, "--name-only", "--pretty=format:"],
+    root
+  );
+  if (cp.returncode !== 0) {
+    return null;
+  }
+  const out = /* @__PURE__ */ new Set();
+  for (const line of _splitlines(cp.stdout)) {
+    const t = line.trim();
+    if (t) {
+      out.add(t);
+    }
+  }
+  return out;
+}
+var _FROZEN_RECORD_PREFIXES = ["agents/evidence/"];
+function _is_frozen_record(rel) {
+  const norm = rel.split(path.sep).join("/");
+  return _FROZEN_RECORD_PREFIXES.some((p) => norm.startsWith(p)) || norm.endsWith(".patch");
+}
+function _inbound_ref_rewrite(root, old_rel, new_rel, dry_run, tracked = true) {
+  const changed = [];
+  let candidates;
+  if (tracked) {
+    const grep = _run(["git", "grep", "-l", "--", old_rel], root);
+    if (grep.returncode === 1) {
+      return changed;
+    }
+    candidates = grep.returncode === 0 ? _splitlines(grep.stdout).map((l) => l.trim()) : _fs_grep_files(root, old_rel);
+  } else {
+    candidates = _fs_grep_files(root, old_rel);
+  }
+  for (const line of candidates) {
+    const rel = line.trim();
+    if (!rel || rel === old_rel) {
+      continue;
+    }
+    if (_is_frozen_record(rel)) {
+      continue;
+    }
+    const fp = path.join(root, rel);
+    let text;
+    try {
+      text = fs.readFileSync(fp, { encoding: "utf-8" });
+    } catch {
+      continue;
+    }
+    if (!text.includes(old_rel)) {
+      continue;
+    }
+    if (!dry_run) {
+      fs.writeFileSync(fp, _replaceAll(text, old_rel, new_rel), { encoding: "utf-8" });
+    }
+    changed.push(rel);
+  }
+  return changed;
+}
+function _replaceAll(text, oldStr, newStr) {
+  return text.split(oldStr).join(newStr);
+}
+function _git_mv(root, src_rel, dst_rel, dry_run) {
+  const dst = path.join(root, dst_rel);
+  if (dry_run) {
+    return { ok: true, tracked: true };
+  }
+  fs.mkdirSync(path.dirname(dst), { recursive: true });
+  const cp = _run(["git", "mv", src_rel, dst_rel], root);
+  if (cp.returncode === 0) {
+    return { ok: true, tracked: true };
+  }
+  try {
+    fs.renameSync(path.join(root, src_rel), dst);
+    return { ok: true, tracked: false };
+  } catch {
+    return { ok: false, tracked: false };
+  }
+}
+function _blockerStatuses(text) {
+  const out = /* @__PURE__ */ new Map();
+  for (const b of parse_blockers(text)) {
+    out.set(b.id, blocker_is_resolved(b) ? "resolved" : "open");
+  }
+  return out;
+}
+function _indexContent(root, rel) {
+  const cp = _run(["git", "show", `:${rel}`], root);
+  return cp.returncode === 0 ? cp.stdout : null;
+}
+function _blockerDivergence(root, rel, workTreeText) {
+  const staged = _indexContent(root, rel);
+  if (staged === null) {
+    return [];
+  }
+  const wt = _blockerStatuses(workTreeText);
+  const idx = _blockerStatuses(staged);
+  const ids = [.../* @__PURE__ */ new Set([...wt.keys(), ...idx.keys()])].sort();
+  const out = [];
+  for (const id of ids) {
+    const a = idx.get(id);
+    const b = wt.get(id);
+    if (a === b) {
+      continue;
+    }
+    out.push(
+      `blocker '${id}': staged=${a ?? "absent"} vs working tree=${b ?? "absent"}`
+    );
+  }
+  return out;
+}
+function _fs_grep_files(root, needle) {
+  const SKIP = /* @__PURE__ */ new Set([".git", "node_modules", ".augment", "dist"]);
+  const hits = [];
+  const walk = (dirAbs) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dirAbs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.name.startsWith(".git") || SKIP.has(e.name)) {
+        continue;
+      }
+      const abs = path.join(dirAbs, e.name);
+      if (e.isDirectory()) {
+        walk(abs);
+      } else if (e.isFile() && /\.(md|json|ya?ml|ts|js|txt)$/.test(e.name)) {
+        let text;
+        try {
+          text = fs.readFileSync(abs, { encoding: "utf-8" });
+        } catch {
+          continue;
+        }
+        if (text.includes(needle)) {
+          hits.push(path.relative(root, abs).split(path.sep).join("/"));
+        }
+      }
+    }
+  };
+  walk(root);
+  return hits;
+}
+var DEFERRED_RESOLUTION_RE = /<!--\s*deferred-resolution:\s*(carried-to|merged-into)\s*=\s*([A-Za-z0-9._-]+)\s*-->/;
+var DEFERRED_STEP_RE = /^[ \t]*[-*][ \t]+\[~\][ \t]*(.*)$/;
+var BLOCK_END_RE = /^[ \t]*[-*][ \t]+\[[ xX~-]\]|^#{1,6}[ \t]/;
+function _escapeRe(v) {
+  return v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function _relatesTo(text, slug) {
+  const lines = text.split("\n");
+  const start = lines.findIndex((l) => /^relates:/.test(l));
+  if (start === -1) return false;
+  const re = new RegExp(`^\\s*-\\s*(slug:\\s*)?${_escapeRe(slug)}\\s*$`);
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\S/.test(line)) break;
+    if (re.test(line)) return true;
+  }
+  return false;
+}
+function parseDeferredItems(text) {
+  const lines = text.split("\n");
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    const m = DEFERRED_STEP_RE.exec(lines[i]);
+    if (m === null) continue;
+    let block = lines[i];
+    for (let j = i + 1; j < lines.length; j++) {
+      if (BLOCK_END_RE.test(lines[j])) break;
+      block += "\n" + lines[j];
+    }
+    const a = DEFERRED_RESOLUTION_RE.exec(block);
+    out.push({
+      text: (m[1] ?? "").trim().slice(0, 120),
+      kind: a === null ? null : a[1],
+      destination: a === null ? null : a[2]
+    });
+  }
+  return out;
+}
+function deferralProblems(root, rel, text, alsoArchiving = /* @__PURE__ */ new Set()) {
+  const sourceSlug = rel.replace(/\.md$/, "");
+  const problems = [];
+  for (const item of parseDeferredItems(text)) {
+    const label = item.text === "" ? "(unnamed step)" : item.text;
+    if (item.kind === null || item.destination === null) {
+      problems.push(
+        `deferred step ${JSON.stringify(label)} carries no \`<!-- deferred-resolution: carried-to=<slug> -->\` annotation`
+      );
+      continue;
+    }
+    const candidates = [
+      path.join(root, "agents", "roadmaps", `${item.destination}.md`),
+      path.join(root, "agents", "roadmaps", "later", `${item.destination}.md`)
+    ];
+    if (item.destination === sourceSlug) {
+      problems.push(
+        `deferred step ${JSON.stringify(label)} names its OWN roadmap as the destination \u2014 a carry needs a different receiver, or the item is not carried at all`
+      );
+      continue;
+    }
+    if (alsoArchiving.has(item.destination)) {
+      problems.push(
+        `destination \`${item.destination}\` is being archived by this same sweep, so it would be dead the moment the carry lands \u2014 archive it first and re-run, or carry to a roadmap that stays active`
+      );
+      continue;
+    }
+    const found = candidates.find((c) => fs.existsSync(c));
+    if (found === void 0) {
+      const dead = ["archive", "skipped"].find(
+        (d) => fs.existsSync(path.join(root, "agents", "roadmaps", d, `${item.destination ?? ""}.md`))
+      );
+      problems.push(
+        dead === void 0 ? `deferred step ${JSON.stringify(label)} names destination \`${item.destination}\`, which does not exist` : `deferred step ${JSON.stringify(label)} names destination \`${item.destination}\`, which is in \`${dead}/\` \u2014 a dead roadmap cannot receive a carried item`
+      );
+      continue;
+    }
+    const destText = fs.readFileSync(found, "utf-8");
+    const backlink = new RegExp(`^parent_roadmap:[ 	]*${_escapeRe(sourceSlug)}[ 	]*$`, "m");
+    if (item.kind === "carried-to" && !backlink.test(destText)) {
+      problems.push(
+        `destination \`${item.destination}\` carries no \`parent_roadmap: ${sourceSlug}\` back-link \u2014 the link must be verifiable from both ends`
+      );
+      continue;
+    }
+    if (item.kind === "merged-into" && !backlink.test(destText) && !_relatesTo(destText, sourceSlug)) {
+      problems.push(
+        `destination \`${item.destination}\` carries no structured link back to \`${sourceSlug}\` \u2014 add a \`relates:\` row naming it (with a \`relation:\`) or a \`parent_roadmap:\` line. A mention in prose is not a link: it is satisfied by a filename or an example.`
+      );
+    }
+  }
+  return problems;
+}
+function archive_completed(root, opts) {
+  const { changed_only, base, dry_run } = opts;
+  const roadmap_root = path.join(root, "agents", "roadmaps");
+  if (!_isDir(roadmap_root)) {
+    return [];
+  }
+  const touched = changed_only ? _branch_touched_paths(root, base) : null;
+  if (changed_only && touched === null) {
+    process.stderr.write(
+      `  \u26A0\uFE0F  cannot resolve \`${base}\` \u2014 skipping the changed-only archival sweep (run with --all to force).
+`
+    );
+    return [];
+  }
+  const sweepSet = new Set(
+    collect(roadmap_root).filter((s2) => s2.open_ === 0).map((s2) => s2.rel.replace(/\.md$/, ""))
+  );
+  const archived = [];
+  for (const stats of collect(roadmap_root)) {
+    const roadmapText = fs.readFileSync(path.join(roadmap_root, stats.rel), "utf-8");
+    const guarded = parseGuardedBaselines(roadmapText);
+    if (guarded.length > 0) {
+      process.stderr.write(
+        `  \u26A0\uFE0F  ${stats.rel}: ${guarded.length} guarded-baseline step(s) \u2014 not archived. Verify against the real mechanism, then flip to \`[x]\`.
+`
+      );
+      for (const p of guardedBaselineProblems(guarded)) {
+        process.stderr.write(`        \xB7 ${p}
+`);
+      }
+      continue;
+    }
+    if (stats.open_ !== 0) {
+      continue;
+    }
+    if (stats.deferred !== 0) {
+      const abs = path.join(roadmap_root, stats.rel);
+      const others = new Set(sweepSet);
+      others.delete(stats.rel.replace(/\.md$/, ""));
+      const problems = deferralProblems(root, stats.rel, fs.readFileSync(abs, "utf-8"), others);
+      if (problems.length > 0) {
+        process.stderr.write(
+          `  \u26A0\uFE0F  ${stats.rel}: ${problems.length} unresolved deferral(s) \u2014 not archived.
+`
+        );
+        for (const p of problems) process.stderr.write(`        \xB7 ${p}
+`);
+        continue;
+      }
+    }
+    const open_blockers = stats.open_blockers;
+    if (open_blockers.length > 0) {
+      const ids = open_blockers.map((b) => b.id).join(", ");
+      process.stderr.write(
+        `  \u26A0\uFE0F  ${stats.rel}: all steps closed but ${open_blockers.length} blocker(s) still open (${ids}) \u2014 not archived. Resolve them, or record the decision, then re-run the sweep.
+`
+      );
+      continue;
+    }
+    const old_rel = `agents/roadmaps/${stats.rel}`;
+    if (changed_only && !touched.has(old_rel)) {
+      continue;
+    }
+    const divergence = _blockerDivergence(root, old_rel, roadmapText);
+    if (divergence.length > 0) {
+      process.stderr.write(
+        `  \u26A0\uFE0F  ${stats.rel}: staged and working-tree blockers disagree (${divergence.length}) \u2014 not archived. \`git mv\` would commit the staged content, which this sweep never validated. Stage or discard the change, then re-run.
+`
+      );
+      for (const d of divergence) {
+        process.stderr.write(`        \xB7 ${d}
+`);
+      }
+      continue;
+    }
+    const new_rel = `agents/roadmaps/archive/${stats.rel}`;
+    const mv = _git_mv(root, old_rel, new_rel, dry_run);
+    if (!mv.ok) {
+      process.stderr.write(`  \u26A0\uFE0F  could not archive ${old_rel} (mv failed)
+`);
+      continue;
+    }
+    if (!dry_run && mv.tracked) {
+      _run(["git", "add", "--", new_rel], root);
+    }
+    const refs = _inbound_ref_rewrite(root, old_rel, new_rel, dry_run, mv.tracked);
+    if (!dry_run && refs.length && mv.tracked) {
+      _run(["git", "add", "--", ...refs], root);
+    }
+    archived.push({ roadmap: old_rel, archived_to: new_rel, refs_migrated: refs });
+  }
+  return archived;
+}
+function _isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _regen_dashboard(root, dry_run) {
+  if (dry_run) {
+    return;
+  }
+  const bundledTwin = path.join(path.dirname(_HERE), "update_roadmap_progress.js");
+  if (_isFile(bundledTwin)) {
+    spawnSync(process.execPath, [bundledTwin], { cwd: root, encoding: "utf-8" });
+    return;
+  }
+  const script = path.join(path.dirname(_HERE), "update_roadmap_progress.ts");
+  _runTwin(root, script);
+}
+function _regen_archive_index(root, dry_run) {
+  if (dry_run) {
+    return;
+  }
+  const script = path.join(root, "src", "scripts", "build_archive_index.ts");
+  if (!_isFile(script)) {
+    return;
+  }
+  _runTwin(root, script);
+  for (const rel of ["agents/roadmaps/archive/INDEX.md", "agents/roadmaps/archive/index.json"]) {
+    if (_isFile(path.join(root, rel))) {
+      _run(["git", "add", "--", rel], root);
+    }
+  }
+}
+function _runTwin(root, script) {
+  const binName = process.platform === "win32" ? "tsx.cmd" : "tsx";
+  let dir = path.dirname(_HERE);
+  for (; ; ) {
+    const candidate = path.join(dir, "node_modules", ".bin", binName);
+    if (fs.existsSync(candidate)) {
+      spawnSync(candidate, [script], { cwd: root, encoding: "utf-8" });
+      return;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  spawnSync("npx", ["tsx", script], { cwd: root, encoding: "utf-8" });
+}
+var _PROG = "archive_completed_roadmaps.py";
+function _usage() {
+  return `usage: ${_PROG} [-h] [--all] [--base BASE] [--dry-run] [--repo-root REPO_ROOT]
+`;
+}
+function _parseArgs(argv) {
+  let all = false;
+  let base = "origin/main";
+  let dry_run = false;
+  let repo_root = null;
+  const emitError = (msg) => {
+    process.stderr.write(_usage());
+    process.stderr.write(`${_PROG}: error: ${msg}
+`);
+    throw new ArgparseExit(2);
+  };
+  let i = 0;
+  while (i < argv.length) {
+    const tok = argv[i];
+    if (tok === "-h" || tok === "--help") {
+      process.stdout.write(_usage());
+      throw new ArgparseExit(0);
+    } else if (tok === "--all") {
+      all = true;
+      i += 1;
+    } else if (tok === "--dry-run") {
+      dry_run = true;
+      i += 1;
+    } else if (tok === "--base") {
+      const val = argv[i + 1];
+      if (val === void 0) {
+        emitError("argument --base: expected one argument");
+      }
+      base = val;
+      i += 2;
+    } else if (tok.startsWith("--base=")) {
+      base = tok.slice("--base=".length);
+      i += 1;
+    } else if (tok === "--repo-root") {
+      const val = argv[i + 1];
+      if (val === void 0) {
+        emitError("argument --repo-root: expected one argument");
+      }
+      repo_root = val;
+      i += 2;
+    } else if (tok.startsWith("--repo-root=")) {
+      repo_root = tok.slice("--repo-root=".length);
+      i += 1;
+    } else {
+      emitError(`unrecognized arguments: ${tok}`);
+    }
+  }
+  return { all, base, dry_run, repo_root };
+}
+function main(argv) {
+  const ns = _parseArgs(argv ?? process.argv.slice(2));
+  const root = ns.repo_root ?? _repo_root();
+  const archived = archive_completed(root, {
+    changed_only: !ns.all,
+    base: ns.base,
+    dry_run: ns.dry_run
+  });
+  if (archived.length === 0) {
+    process.stdout.write("  \u2139\uFE0F  No completed roadmaps to archive.\n");
+    return 0;
+  }
+  _regen_dashboard(root, ns.dry_run);
+  _regen_archive_index(root, ns.dry_run);
+  const verb = ns.dry_run ? "Would archive" : "Archived";
+  for (const rec of archived) {
+    process.stdout.write(
+      `  \u2705  ${verb}: ${rec.roadmap} \u2192 ${rec.archived_to}` + (rec.refs_migrated.length ? `  (${rec.refs_migrated.length} ref(s) migrated)` : "") + "\n"
+    );
+  }
+  return 0;
+}
+if (isCliEntry(import.meta.url, "archive_completed_roadmaps")) {
+  try {
+    process.exitCode = main();
+  } catch (exc) {
+    if (exc instanceof ArgparseExit) {
+      process.exitCode = exc.code;
+    } else {
+      throw exc;
+    }
+  }
+}
+export {
+  _branch_touched_paths,
+  _git_mv,
+  _inbound_ref_rewrite,
+  _is_frozen_record,
+  _relatesTo,
+  _repo_root,
+  archive_completed,
+  deferralProblems,
+  main,
+  parseDeferredItems
+};