@event4u/agent-config 9.10.0 → 9.12.0

package/dist/cli-delegate/cmd_conformance.js

@@ -0,0 +1,643 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  ArgparseExit,
+  STATUS_SYMBOLS,
+  _classify,
+  _collect_manifest_entries,
+  _foreign_records,
+  _is_global_only_consumer,
+  _jsonDumpsIndentAscii,
+  _resolve_project_root,
+  _run_checks,
+  _run_checks_no_manifest,
+  _scan_foreign
+} from "./chunk-TEGJU2JX.js";
+import "./chunk-FTAISGDQ.js";
+import "./chunk-736JCWLM.js";
+import {
+  atomicAppendLine,
+  manifest_path,
+  read_manifest
+} from "./chunk-A3HJ6NTI.js";
+import "./chunk-GRRPEPRN.js";
+import "./chunk-TJIAM5FW.js";
+import "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import {
+  detectToolPresence
+} from "./chunk-OMIVVCG2.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
+import {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  __toESM
+} from "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_conformance.ts
+var YAML = __toESM(require_dist(), 1);
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// src/install/txlog.ts
+import { createReadStream, createWriteStream, existsSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
+var ROTATION_MAX_BYTES = 10 * 1024 * 1024;
+var ROTATION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var RECOVERY_DEPTH_CAP = 500;
+function readRecentEntries(logPath) {
+  if (!existsSync(logPath)) {
+    return [];
+  }
+  const raw = readFileSync(logPath, "utf8");
+  const lines = raw.split("\n").filter((l) => l.length > 0);
+  const tail = lines.slice(-RECOVERY_DEPTH_CAP);
+  const out = [];
+  for (const line of tail) {
+    const parsed = tryParseEntry(line);
+    if (parsed !== null) {
+      out.push(parsed);
+    }
+  }
+  return out;
+}
+function tryParseEntry(line) {
+  try {
+    const obj = JSON.parse(line);
+    if (typeof obj.ts !== "string" || typeof obj.kind !== "string" || typeof obj.path !== "string") {
+      return null;
+    }
+    return obj;
+  } catch {
+    return null;
+  }
+}
+
+// src/scripts/_cli/cmd_conformance.ts
+var _HERE = fileURLToPath(import.meta.url);
+var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
+var CONFORMANCE_CHECK_IDS = [
+  "txlog-clean",
+  "router-pointers",
+  "hook-dispatcher",
+  "lean-projection",
+  "host-manifest"
+];
+var THIN_STUB_MARKER = "Routed rule \u2014 load the body on trigger-match";
+function print(s = "") {
+  process.stdout.write(`${s}
+`);
+}
+function eprint(s = "") {
+  process.stderr.write(`${s}
+`);
+}
+function conformanceLogPath() {
+  const override = process.env["AGENT_CONFIG_CONFORMANCE_LOG"];
+  if (override && override.trim().length > 0) {
+    return override;
+  }
+  return path.join(os.homedir(), ".event4u", "agent-config", "conformance-log.jsonl");
+}
+function installLogPath() {
+  const override = process.env["AGENT_CONFIG_INSTALL_LOG"];
+  if (override && override.trim().length > 0) {
+    return override;
+  }
+  return path.join(os.homedir(), ".event4u", "agent-config", "install-log.jsonl");
+}
+function _check_txlog_clean(logPath = installLogPath()) {
+  if (!fs.existsSync(logPath)) {
+    return {
+      id: "txlog-clean",
+      status: "ok",
+      message: "no install transaction log \u2014 nothing to recover",
+      remedy: ""
+    };
+  }
+  const entries = readRecentEntries(logPath);
+  if (entries.length === 0) {
+    return {
+      id: "txlog-clean",
+      status: "ok",
+      message: "install transaction log is empty",
+      remedy: ""
+    };
+  }
+  const last = entries[entries.length - 1];
+  if (last.kind === "abort") {
+    return {
+      id: "txlog-clean",
+      status: "fail",
+      message: `install log tail is an abandoned run (abort at ${last.ts}${last.note ? `: ${last.note}` : ""})`,
+      remedy: "re-run `agent-config init` (recovery reverse-applies the aborted tail)"
+    };
+  }
+  return {
+    id: "txlog-clean",
+    status: "ok",
+    message: `install log tail clean (${entries.length} recent entries, last: ${last.kind})`,
+    remedy: ""
+  };
+}
+function routeTargetPaths(target) {
+  const sep = target.indexOf(":");
+  if (sep <= 0) return [];
+  const kind = target.slice(0, sep);
+  const id = target.slice(sep + 1);
+  if (!id) return [];
+  switch (kind) {
+    case "skill":
+      return [path.join("dist", "agent-src", "skills", id, "SKILL.md")];
+    case "command":
+      return [path.join("dist", "agent-src", "commands", `${id}.md`)];
+    case "guideline":
+      return [path.join("docs", "guidelines", `${id}.md`)];
+    case "contract":
+      return [
+        path.join("docs", "contracts", `${id}.md`),
+        path.join("dist", "agent-src", "contexts", "contracts", `${id}.md`)
+      ];
+    default:
+      return [];
+  }
+}
+function _check_router_pointers(packageRoot = PACKAGE_ROOT) {
+  const routerPath = path.join(packageRoot, "dist", "router.json");
+  if (!fs.existsSync(routerPath)) {
+    return {
+      id: "router-pointers",
+      status: "fail",
+      message: `router index missing: ${routerPath}`,
+      remedy: "reinstall the package (dist/router.json ships with every release)"
+    };
+  }
+  let router;
+  try {
+    router = JSON.parse(fs.readFileSync(routerPath, "utf8"));
+  } catch (exc) {
+    return {
+      id: "router-pointers",
+      status: "fail",
+      message: `router index does not parse: ${exc.message}`,
+      remedy: "reinstall the package \u2014 dist/router.json is corrupt"
+    };
+  }
+  const rulesDir = path.join(packageRoot, "dist", "agent-src", "rules");
+  const broken = [];
+  let ids = 0;
+  let targets = 0;
+  for (const kernelId of router["kernel"] ?? []) {
+    ids += 1;
+    if (!fs.existsSync(path.join(rulesDir, `${kernelId}.md`))) {
+      broken.push(`kernel:${kernelId} \u2192 rules/${kernelId}.md missing`);
+    }
+  }
+  for (const tier of ["tier_1", "tier_2"]) {
+    for (const entry of router[tier] ?? []) {
+      const ruleId = String(entry["id"] ?? "");
+      ids += 1;
+      if (!fs.existsSync(path.join(rulesDir, `${ruleId}.md`))) {
+        broken.push(`${tier}:${ruleId} \u2192 rules/${ruleId}.md missing`);
+      }
+      for (const target of entry["routes_to"] ?? []) {
+        targets += 1;
+        const candidates = routeTargetPaths(String(target));
+        if (candidates.length === 0) {
+          broken.push(`${ruleId} \u2192 unparseable routes_to ${JSON.stringify(target)}`);
+          continue;
+        }
+        if (!candidates.some((rel) => fs.existsSync(path.join(packageRoot, rel)))) {
+          broken.push(`${ruleId} \u2192 ${target} (${candidates[0]} missing)`);
+        }
+      }
+    }
+  }
+  if (broken.length > 0) {
+    const sample = broken.slice(0, 5).join("; ");
+    return {
+      id: "router-pointers",
+      status: "fail",
+      message: `${broken.length} unresolved router pointer(s): ${sample}`,
+      remedy: "reinstall the package; if this is a dev tree, run the compile/condense pipeline"
+    };
+  }
+  return {
+    id: "router-pointers",
+    status: "ok",
+    message: `router index parses; ${ids} rule ids + ${targets} routes_to targets resolve`,
+    remedy: ""
+  };
+}
+function detectSmokePlatform(projectRoot) {
+  const presence = detectToolPresence(projectRoot);
+  if (presence.claude) return "claude";
+  if (presence.cursor) return "cursor";
+  if (presence.augment) return "augment";
+  if (presence.windsurf) return "windsurf";
+  if (presence.cline) return "cline";
+  return "claude";
+}
+function dispatcherRunner(packageRoot) {
+  const localTsx = path.join(packageRoot, "node_modules", ".bin", "tsx");
+  const script = path.join(packageRoot, "src", "scripts", "hooks", "dispatch_hook.ts");
+  if (fs.existsSync(localTsx)) {
+    return [localTsx, script];
+  }
+  return ["npx", "tsx", script];
+}
+function _check_hook_dispatcher(projectRoot, packageRoot = PACKAGE_ROOT, opts = {}) {
+  const platform = opts.platform ?? detectSmokePlatform(projectRoot);
+  const runner = opts.runner ?? dispatcherRunner(packageRoot);
+  const results = [];
+  for (const event of ["session_start", "stop"]) {
+    const payload = JSON.stringify({
+      session_id: "conformance-smoke",
+      cwd: projectRoot,
+      platform_hint: platform,
+      ...event === "stop" ? { stop_reason: "conformance-smoke" } : { source: "startup" }
+    });
+    const argv = [...runner, "--platform", platform, "--event", event];
+    const proc = spawnSync(argv[0], argv.slice(1), {
+      input: payload,
+      cwd: projectRoot,
+      encoding: "utf8",
+      timeout: opts.timeoutMs ?? 3e4
+    });
+    if (proc.error) {
+      return {
+        id: "hook-dispatcher",
+        status: "fail",
+        message: `dispatcher spawn failed for ${event}: ${proc.error.message}`,
+        remedy: "verify the package install (node_modules present) and re-run"
+      };
+    }
+    if (proc.status !== 0 && proc.status !== 2) {
+      const tail = (proc.stderr ?? "").trim().split("\n").slice(-2).join(" | ");
+      return {
+        id: "hook-dispatcher",
+        status: "fail",
+        message: `dispatcher returned exit ${proc.status} for synthetic ${event} (${tail || "no stderr"})`,
+        remedy: "run `agent-config doctor --check offline-readiness` and check hook_manifest.yaml"
+      };
+    }
+    results.push(`${event}=${proc.status}`);
+  }
+  return {
+    id: "hook-dispatcher",
+    status: "ok",
+    message: `dispatcher (platform: ${platform}) answered ${results.join(", ")}`,
+    remedy: ""
+  };
+}
+function readSettingsMode(projectRoot) {
+  const settingsPath = path.join(projectRoot, ".agent-settings.yml");
+  if (!fs.existsSync(settingsPath)) {
+    return "eager-all";
+  }
+  try {
+    const parsed = YAML.parse(fs.readFileSync(settingsPath, "utf8"));
+    const lean = parsed?.["lean_projection"] ?? null;
+    const mode = lean?.["mode"];
+    return typeof mode === "string" && mode.length > 0 ? mode : "eager-all";
+  } catch {
+    return "eager-all";
+  }
+}
+function kernelIdsFromRouter(packageRoot) {
+  try {
+    const router = JSON.parse(
+      fs.readFileSync(path.join(packageRoot, "dist", "router.json"), "utf8")
+    );
+    return new Set((router["kernel"] ?? []).map(String));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function _check_lean_projection(projectRoot, packageRoot = PACKAGE_ROOT, projectedRulesDir) {
+  const mode = readSettingsMode(projectRoot);
+  if (mode !== "eager-all" && mode !== "thin") {
+    return {
+      id: "lean-projection",
+      status: "fail",
+      message: `lean_projection.mode has unknown value ${JSON.stringify(mode)}`,
+      remedy: "set lean_projection.mode to 'eager-all' or 'thin' in .agent-settings.yml"
+    };
+  }
+  const rulesDir = projectedRulesDir ?? path.join(projectRoot, ".augment", "rules");
+  if (!fs.existsSync(rulesDir)) {
+    return {
+      id: "lean-projection",
+      status: "skipped",
+      message: `no projected rules dir at ${rulesDir} \u2014 projection consistency not applicable`,
+      remedy: ""
+    };
+  }
+  const kernel = kernelIdsFromRouter(packageRoot);
+  const files = fs.readdirSync(rulesDir).filter((f) => f.endsWith(".md") && f !== "INDEX.md").sort();
+  const nonKernel = files.filter((f) => !kernel.has(f.replace(/\.md$/, "")));
+  if (nonKernel.length === 0) {
+    return {
+      id: "lean-projection",
+      status: "skipped",
+      message: "no non-kernel projected rules found \u2014 nothing to compare",
+      remedy: ""
+    };
+  }
+  const inconsistent = [];
+  for (const f of nonKernel) {
+    let text = "";
+    try {
+      text = fs.readFileSync(path.join(rulesDir, f), "utf8");
+    } catch {
+      continue;
+    }
+    const isStub = text.includes(THIN_STUB_MARKER);
+    if (mode === "thin" && !isStub) {
+      inconsistent.push(`${f} (full body under thin mode)`);
+    }
+    if (mode === "eager-all" && isStub) {
+      inconsistent.push(`${f} (thin stub under eager-all mode)`);
+    }
+  }
+  if (inconsistent.length > 0) {
+    const sample = inconsistent.slice(0, 3).join("; ");
+    return {
+      id: "lean-projection",
+      status: "fail",
+      message: `${inconsistent.length}/${nonKernel.length} projected rules contradict lean_projection.mode=${mode}: ${sample}`,
+      remedy: "re-run the install/sync so the projection matches the configured mode"
+    };
+  }
+  return {
+    id: "lean-projection",
+    status: "ok",
+    message: `mode=${mode} consistent across ${nonKernel.length} non-kernel projected rules`,
+    remedy: ""
+  };
+}
+var HOST_MANIFEST_KEYS = /* @__PURE__ */ new Set([
+  "schema_version",
+  "subagent_spawn",
+  "parallel_spawn",
+  "status_polling",
+  "separate_quota_pool"
+]);
+function _check_host_manifest(projectRoot) {
+  const detected = Object.entries(detectToolPresence(projectRoot)).filter(([, v]) => v === true).map(([k]) => k);
+  const detectedNote = detected.length > 0 ? `detected surfaces: ${detected.join(", ")}` : "no surfaces detected";
+  const settingsPath = path.join(projectRoot, ".agent-settings.yml");
+  if (!fs.existsSync(settingsPath)) {
+    return {
+      id: "host-manifest",
+      status: "ok",
+      message: `no .agent-settings.yml \u2014 safe-default manifest applies (${detectedNote})`,
+      remedy: ""
+    };
+  }
+  let parsed = null;
+  try {
+    parsed = YAML.parse(fs.readFileSync(settingsPath, "utf8"));
+  } catch (exc) {
+    return {
+      id: "host-manifest",
+      status: "fail",
+      message: `.agent-settings.yml does not parse: ${exc.message}`,
+      remedy: "fix the YAML syntax, or run `agent-config settings:check`"
+    };
+  }
+  const subagents = parsed?.["subagents"] ?? null;
+  const manifest = subagents?.["host_capabilities"];
+  if (manifest === void 0 || manifest === null) {
+    return {
+      id: "host-manifest",
+      status: "ok",
+      message: `no host_capabilities override \u2014 safe-default manifest applies (${detectedNote})`,
+      remedy: ""
+    };
+  }
+  if (typeof manifest !== "object" || Array.isArray(manifest)) {
+    return {
+      id: "host-manifest",
+      status: "fail",
+      message: "subagents.host_capabilities is not a mapping",
+      remedy: "use the four boolean fields from the host-capability manifest contract"
+    };
+  }
+  const problems = [];
+  for (const [key, value] of Object.entries(manifest)) {
+    if (!HOST_MANIFEST_KEYS.has(key)) {
+      problems.push(`unknown key '${key}'`);
+      continue;
+    }
+    if (key === "schema_version") {
+      if (value !== 1) problems.push(`schema_version must be 1 (got ${JSON.stringify(value)})`);
+      continue;
+    }
+    if (typeof value !== "boolean") {
+      problems.push(`'${key}' must be boolean (got ${JSON.stringify(value)})`);
+    }
+  }
+  if (problems.length > 0) {
+    return {
+      id: "host-manifest",
+      status: "fail",
+      message: `host_capabilities malformed: ${problems.slice(0, 4).join("; ")}`,
+      remedy: "only schema_version:1 + four boolean capability fields are valid"
+    };
+  }
+  return {
+    id: "host-manifest",
+    status: "ok",
+    message: `host_capabilities override parses strictly (${detectedNote})`,
+    remedy: ""
+  };
+}
+function runConformanceChecks(opts = {}) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const packageRoot = opts.packageRoot ?? PACKAGE_ROOT;
+  const checks = [];
+  checks.push(_check_txlog_clean());
+  checks.push(_check_router_pointers(packageRoot));
+  if (opts.skipDispatcher === true) {
+    checks.push({
+      id: "hook-dispatcher",
+      status: "skipped",
+      message: "dispatcher smoke skipped by flag",
+      remedy: ""
+    });
+  } else {
+    checks.push(_check_hook_dispatcher(projectRoot, packageRoot));
+  }
+  checks.push(_check_lean_projection(projectRoot, packageRoot));
+  checks.push(_check_host_manifest(projectRoot));
+  return checks;
+}
+function appendConformanceReport(checks, projectRoot, logPath = conformanceLogPath()) {
+  const fails = checks.filter((c) => c["status"] === "fail").map((c) => String(c["id"]));
+  const ok = checks.filter((c) => c["status"] === "ok").length;
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: "conformance",
+    path: projectRoot,
+    sha256: null,
+    note: `${ok}/${checks.length} ok; fails: ${fails.length > 0 ? fails.join(",") : "none"}`
+  };
+  try {
+    atomicAppendLine(logPath, JSON.stringify(entry));
+  } catch {
+  }
+}
+var USAGE = "usage: agent-config conformance [-h] [--project PROJECT] [--json]\n                                [--skip-dispatcher]\n";
+function _parse(argv) {
+  const opts = { project: null, json: false, skip_dispatcher: false };
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") {
+      process.stdout.write(USAGE);
+      throw new ArgparseExit(0);
+    }
+    if (a === "--json") {
+      opts.json = true;
+    } else if (a === "--skip-dispatcher") {
+      opts.skip_dispatcher = true;
+    } else if (a === "--project" || a.startsWith("--project=")) {
+      if (a.includes("=")) {
+        opts.project = a.slice(a.indexOf("=") + 1);
+      } else {
+        if (i + 1 >= argv.length) {
+          process.stderr.write(USAGE);
+          process.stderr.write("agent-config conformance: error: --project expects a value\n");
+          throw new ArgparseExit(2);
+        }
+        opts.project = argv[i + 1];
+        i += 1;
+      }
+    } else {
+      process.stderr.write(USAGE);
+      process.stderr.write(`agent-config conformance: error: unrecognized argument ${a}
+`);
+      throw new ArgparseExit(2);
+    }
+    i += 1;
+  }
+  return opts;
+}
+function main(argv = null) {
+  const opts = _parse(argv !== null ? Array.from(argv) : process.argv.slice(2));
+  let project_root;
+  try {
+    [project_root] = _resolve_project_root(opts.project);
+  } catch (exc) {
+    eprint(`\u274C  conformance: ${exc.message}`);
+    return 2;
+  }
+  const manifest_pth = manifest_path(project_root);
+  const manifest = read_manifest(manifest_pth);
+  let doctorChecks;
+  let drift = { missing: [], modified: [], foreign: [], tag_drift: [] };
+  if (manifest === null) {
+    const bridge_present = _is_global_only_consumer(project_root);
+    doctorChecks = _run_checks_no_manifest(project_root, bridge_present, null);
+  } else {
+    const [records, known] = _collect_manifest_entries(project_root, manifest);
+    const [missing, modified, tag_drift] = _classify(records);
+    const foreign = _foreign_records(
+      project_root,
+      _scan_foreign(project_root, manifest, known)
+    );
+    drift = { missing, modified, foreign, tag_drift };
+    doctorChecks = _run_checks(project_root, manifest, drift, null);
+  }
+  const conformanceChecks = runConformanceChecks({
+    projectRoot: project_root,
+    skipDispatcher: opts.skip_dispatcher
+  });
+  const allChecks = [...doctorChecks, ...conformanceChecks];
+  const driftCount = drift["missing"].length + drift["modified"].length + drift["foreign"].length + drift["tag_drift"].length;
+  const failed = allChecks.some((c) => c["status"] === "fail") || driftCount > 0;
+  appendConformanceReport(conformanceChecks, project_root);
+  if (opts.json) {
+    print(
+      _jsonDumpsIndentAscii(
+        {
+          project_root,
+          drift,
+          doctor_checks: doctorChecks,
+          conformance_checks: conformanceChecks,
+          status: failed ? "fail" : "ok"
+        },
+        2
+      )
+    );
+  } else {
+    print(`  \u{1F4CD}  project_root: ${project_root}`);
+    print("conformance:");
+    for (const c of allChecks) {
+      const sym = STATUS_SYMBOLS[c["status"]] ?? "?";
+      print(`  ${sym} ${c["id"]}: ${c["message"]}`);
+      if (c["status"] !== "ok" && c["remedy"]) {
+        print(`      fix: ${c["remedy"]}`);
+      }
+    }
+    if (driftCount > 0) {
+      print(`  \u274C drift: ${driftCount} drifted file(s) \u2014 run \`agent-config doctor\` for detail`);
+    }
+    print("");
+    print(
+      failed ? "\u274C  conformance: red \u2014 the OS is not fully installed/firing here" : "\u2705  conformance: green \u2014 installed and firing"
+    );
+  }
+  return failed ? 1 : 0;
+}
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
+  try {
+    process.exitCode = main(process.argv.slice(2));
+  } catch (e) {
+    if (e instanceof ArgparseExit) {
+      process.exitCode = e.code;
+    } else {
+      throw e;
+    }
+  }
+}
+export {
+  CONFORMANCE_CHECK_IDS,
+  PACKAGE_ROOT,
+  THIN_STUB_MARKER,
+  _check_hook_dispatcher,
+  _check_host_manifest,
+  _check_lean_projection,
+  _check_router_pointers,
+  _check_txlog_clean,
+  _parse,
+  appendConformanceReport,
+  conformanceLogPath,
+  detectSmokePlatform,
+  installLogPath,
+  main,
+  routeTargetPaths,
+  runConformanceChecks
+};