@event4u/agent-config 9.9.0 → 9.11.0

package/dist/cli-delegate/cmd_converge.js

@@ -0,0 +1,326 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  write_target
+} from "./chunk-NDJLNC6Q.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
+import {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  __toESM
+} from "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_converge.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";
+var _stdout = { write: (t) => process.stdout.write(t) };
+var _stderr = { write: (t) => process.stderr.write(t) };
+function _print(out, line = "") {
+  out.write(`${line}
+`);
+}
+function _default_runner(cmd) {
+  const r = spawnSync(cmd[0], cmd.slice(1), { stdio: "inherit" });
+  if (r.error) {
+    _stderr.write(`agent-config converge: cannot run ${cmd[0]}: ${String(r.error)}
+`);
+    return 1;
+  }
+  return r.status ?? 1;
+}
+var _HERE = fileURLToPath(import.meta.url);
+function _package_root() {
+  return resolvePackageRoot(import.meta.url);
+}
+var SETTINGS_FILENAME = "agent-settings.yml";
+var CONSENT_KEY_PATH = ["install", "auto_converge"];
+var ArgparseExit = class extends Error {
+  code;
+  constructor(code) {
+    super(`exit ${code}`);
+    this.code = code;
+  }
+};
+var PROG = "agent-config converge";
+var USAGE = `usage: ${PROG} [-h] [--dry-run] [--yes]
+`;
+function _argError(msg) {
+  _stderr.write(USAGE);
+  _stderr.write(`${PROG}: error: ${msg}
+`);
+  throw new ArgparseExit(2);
+}
+function _parse(argv) {
+  const args = { dry_run: false, yes: false };
+  for (const a of argv) {
+    if (a === "-h" || a === "--help") {
+      _stdout.write(USAGE);
+      throw new ArgparseExit(0);
+    }
+    if (a === "--dry-run") {
+      args.dry_run = true;
+      continue;
+    }
+    if (a === "--yes" || a === "-y") {
+      args.yes = true;
+      continue;
+    }
+    _argError(`unrecognized arguments: ${a}`);
+  }
+  return args;
+}
+function _load_matrix(matrix_path) {
+  const raw = YAML.parse(fs.readFileSync(matrix_path, "utf-8"), { version: "1.1" });
+  const tools = raw["tools"];
+  if (!tools || typeof tools !== "object" || Array.isArray(tools)) {
+    throw new Error("surface-matrix.yml: `tools` must be a mapping");
+  }
+  return tools;
+}
+function _expand(p, home, pkg_root) {
+  return p.startsWith("~/") ? path.join(home, p.slice(2)) : path.join(pkg_root, p);
+}
+function _exists(p) {
+  try {
+    fs.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detect_duplicates(tools, home, pkg_root) {
+  const findings = [];
+  for (const [tool_id, entry] of Object.entries(tools)) {
+    const all_of = entry.duplicate?.detect?.all_of;
+    if (!Array.isArray(all_of) || all_of.length === 0) {
+      continue;
+    }
+    const present = all_of.every(
+      (p) => typeof p === "string" && _exists(_expand(p, home, pkg_root))
+    );
+    if (!present) {
+      continue;
+    }
+    const reaps_raw = entry.converge?.reaps;
+    const reaps = Array.isArray(reaps_raw) ? reaps_raw.filter((r) => typeof r === "string" && r.startsWith("~/")) : [];
+    findings.push({
+      tool: tool_id,
+      description: entry.duplicate?.description ?? "duplicate install surface",
+      command: entry.converge?.command ?? "",
+      reaps
+    });
+  }
+  return findings;
+}
+function read_consent(settings_path) {
+  try {
+    const raw = YAML.parse(fs.readFileSync(settings_path, "utf-8"), { version: "1.1" });
+    const install = raw?.[CONSENT_KEY_PATH[0]];
+    if (install && typeof install === "object" && !Array.isArray(install)) {
+      return install[CONSENT_KEY_PATH[1]] === true;
+    }
+  } catch {
+  }
+  return false;
+}
+function persist_consent(settings_path, out) {
+  let doc = {};
+  try {
+    const parsed = YAML.parse(fs.readFileSync(settings_path, "utf-8"), { version: "1.1" });
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      doc = parsed;
+    }
+  } catch {
+  }
+  const install = doc["install"] && typeof doc["install"] === "object" && !Array.isArray(doc["install"]) ? doc["install"] : {};
+  if (install[CONSENT_KEY_PATH[1]] === true) {
+    return;
+  }
+  install[CONSENT_KEY_PATH[1]] = true;
+  doc["install"] = install;
+  fs.mkdirSync(path.dirname(settings_path), { recursive: true });
+  fs.writeFileSync(settings_path, YAML.stringify(doc), "utf-8");
+  _print(out, `\u2705  standing consent persisted: install.auto_converge: true (${settings_path})`);
+}
+function _tty_confirm(question) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return false;
+  }
+  process.stdout.write(`${question} [y/N] `);
+  const buf = Buffer.alloc(64);
+  let answer = "";
+  try {
+    const fd = fs.openSync("/dev/tty", "rs");
+    const n = fs.readSync(fd, buf, 0, 64, null);
+    fs.closeSync(fd);
+    answer = buf.toString("utf-8", 0, n).trim().toLowerCase();
+  } catch {
+    return false;
+  }
+  return answer === "y" || answer === "yes";
+}
+function live_session_notice(executed_reaps) {
+  const hit = executed_reaps.some((r) => r.startsWith("~/.claude/plugins/"));
+  if (!hit) {
+    return null;
+  }
+  return `\u26A0\uFE0F  Live-session note: Claude Code sessions that were ALREADY RUNNING still
+    hold the removed plugin's hook registrations. Until you restart them,
+    every event logs a non-blocking
+      "Failed to run: Plugin directory does not exist: \u2026/plugins/cache/\u2026"
+    error. This is cosmetic for new sessions but means the affected LIVE
+    session's plugin-sourced hooks no longer run \u2014 restart Claude Code
+    sessions to clear it. Do NOT follow the error's "/plugin to reinstall"
+    hint: reinstalling recreates the duplicate surface converge just removed
+    (the ~/.claude/ file projection already carries content AND hooks).`;
+}
+function main(argv = null, opts = {}) {
+  let args;
+  try {
+    args = _parse(argv ?? process.argv.slice(2));
+  } catch (e) {
+    if (e instanceof ArgparseExit) {
+      return e.code;
+    }
+    throw e;
+  }
+  const out = opts.out ?? _stdout;
+  const err = opts.err ?? _stderr;
+  const runner = opts.runner ?? _default_runner;
+  const home = opts.home ?? os.homedir();
+  const pkg_root = opts.package_root ?? _package_root();
+  const settings_path = opts.settings_path ?? write_target(SETTINGS_FILENAME);
+  const confirm = opts.confirm ?? _tty_confirm;
+  const matrix_path = path.join(pkg_root, "src", "config", "surface-matrix.yml");
+  if (!fs.existsSync(matrix_path)) {
+    _print(err, `\u274C  ${matrix_path} not found \u2014 reinstall the package (agent-config upgrade)`);
+    return 1;
+  }
+  let tools;
+  try {
+    tools = _load_matrix(matrix_path);
+  } catch (e) {
+    _print(err, `\u274C  surface-matrix.yml unreadable: ${e instanceof Error ? e.message : String(e)}`);
+    return 1;
+  }
+  const findings = detect_duplicates(tools, home, pkg_root);
+  if (findings.length === 0) {
+    _print(out, "\u2705  no duplicate install surfaces detected \u2014 nothing to converge.");
+    return 0;
+  }
+  _print(out, `Duplicate install surface(s) detected on ${findings.length} tool(s):`);
+  for (const f of findings) {
+    _print(out, `  \xB7 ${f.tool}: ${f.description}`);
+  }
+  _print(out);
+  if (args.dry_run) {
+    _print(out, "Dry run \u2014 the following actions WOULD run (nothing was touched):");
+    for (const f of findings) {
+      if (f.command) {
+        _print(out, `  \u2192 ${f.command}`);
+      }
+      for (const reap of f.reaps) {
+        _print(out, `  \u2192 rm -rf ${reap}  (package-tagged orphan, matrix-declared)`);
+      }
+    }
+    return 0;
+  }
+  let consented = args.yes || read_consent(settings_path);
+  if (!consented) {
+    consented = confirm(
+      `Converge now? This runs the per-tool uninstall command(s) above and reaps the matrix-declared caches. Persists install.auto_converge: true.`
+    );
+    if (!consented) {
+      _print(
+        err,
+        `\u274C  converge refused \u2014 no consent. Re-run interactively, pass --yes, or set
+    install.auto_converge: true in ${settings_path}`
+      );
+      return 1;
+    }
+  }
+  persist_consent(settings_path, out);
+  let failures = 0;
+  const report = [];
+  const executed_reaps = [];
+  for (const f of findings) {
+    if (f.command) {
+      _print(out, `\u2192 ${f.command}`);
+      const rc = runner(f.command.split(" "));
+      if (rc !== 0) {
+        failures += 1;
+        _print(err, `\u26A0\uFE0F  ${f.tool}: uninstall command exited ${rc} \u2014 continuing with reaps.`);
+      } else {
+        report.push(`${f.tool}: ran \`${f.command}\``);
+      }
+    }
+    for (const reap of f.reaps) {
+      const abs = _expand(reap, home, pkg_root);
+      if (!_exists(abs)) {
+        continue;
+      }
+      try {
+        fs.rmSync(abs, { recursive: true, force: true });
+        report.push(`${f.tool}: reaped package-tagged orphan \`${reap}\``);
+        executed_reaps.push(reap);
+        _print(out, `\u2192 reaped ${reap}`);
+      } catch (e) {
+        failures += 1;
+        _print(err, `\u26A0\uFE0F  ${f.tool}: could not reap ${reap}: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  }
+  _print(out);
+  _print(out, "Convergence report:");
+  for (const line of report) {
+    _print(out, `  \u2705 ${line}`);
+  }
+  if (report.length === 0) {
+    _print(out, "  (no actions completed)");
+  }
+  const notice = live_session_notice(executed_reaps);
+  if (notice !== null) {
+    _print(out);
+    _print(out, notice);
+  }
+  _print(
+    out,
+    "Rollback hint: a removed Claude Code plugin can be reinstalled with\n  claude plugin marketplace add event4u-app/agent-config && claude plugin install agent-config@event4u-agent-config\n(the file projection is untouched \u2014 content and hooks keep working)."
+  );
+  return failures > 0 ? 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.exit(main());
+}
+export {
+  _load_matrix,
+  detect_duplicates,
+  live_session_notice,
+  main,
+  persist_consent,
+  read_consent
+};

package/dist/cli-delegate/cmd_doctor.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  ArgparseExit,
+  CHECK_IDS,
+  GLOBAL_CHECK_IDS,
+  INSTALL_MODE_MARKER_RELATIVE,
+  MANIFEST_REQUIRED_CHECK_IDS,
+  MCP_BETA_GATES,
+  MIN_PYTHON,
+  NO_FRONTMATTER,
+  PACKAGE_TAG_ID,
+  REPAIR_IDS,
+  STATUS_SYMBOLS,
+  _check_bridge_drift,
+  _check_bridge_drift_no_manifest,
+  _check_claude_command_wrappers,
+  _check_claude_plugin,
+  _check_council_cli,
+  _check_detection,
+  _check_duplicate_scope_rules,
+  _check_git_identity,
+  _check_global_binary,
+  _check_humanizer_runtime,
+  _check_lockfile_freshness,
+  _check_manifest_integrity,
+  _check_mcp_beta_readiness,
+  _check_mcp_mode,
+  _check_offline_readiness,
+  _check_python_runtime,
+  _check_rule_scope_drift,
+  _check_scope,
+  _check_settings_review_pending,
+  _check_stale_orphans,
+  _check_team,
+  _check_tier_usage_readiness,
+  _check_unsupported_combos,
+  _check_wizard_state,
+  _classify,
+  _collect_manifest_entries,
+  _detect_install_mode,
+  _detect_wrapper,
+  _detection_report,
+  _emit_checks_text,
+  _emit_json,
+  _emit_text,
+  _fix_hint,
+  _foreign_records,
+  _git_config_path,
+  _is_global_only_consumer,
+  _jsonDumpsIndentAscii,
+  _parse,
+  _read_council_facts,
+  _read_inline_package_tag,
+  _reset_detection_memo,
+  _resolve_project_root,
+  _run_checks,
+  _run_checks_no_manifest,
+  _run_context,
+  _run_repair,
+  _run_trace_root,
+  _scan_foreign,
+  _settings_layer_chain,
+  _skipped_manifest_check,
+  _wizard_state_path,
+  main
+} from "./chunk-4SV3XGFA.js";
+import "./chunk-FTAISGDQ.js";
+import "./chunk-TFG57JJM.js";
+import "./chunk-736JCWLM.js";
+import "./chunk-BJGXZNPM.js";
+import "./chunk-IR7P7JWA.js";
+import "./chunk-GRRPEPRN.js";
+import "./chunk-7DSAMZFU.js";
+import "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import "./chunk-MCJYCQPF.js";
+import "./chunk-OY53J6II.js";
+import "./chunk-J55WI3RR.js";
+export {
+  ArgparseExit,
+  CHECK_IDS,
+  GLOBAL_CHECK_IDS,
+  INSTALL_MODE_MARKER_RELATIVE,
+  MANIFEST_REQUIRED_CHECK_IDS,
+  MCP_BETA_GATES,
+  MIN_PYTHON,
+  NO_FRONTMATTER,
+  PACKAGE_TAG_ID,
+  REPAIR_IDS,
+  STATUS_SYMBOLS,
+  _check_bridge_drift,
+  _check_bridge_drift_no_manifest,
+  _check_claude_command_wrappers,
+  _check_claude_plugin,
+  _check_council_cli,
+  _check_detection,
+  _check_duplicate_scope_rules,
+  _check_git_identity,
+  _check_global_binary,
+  _check_humanizer_runtime,
+  _check_lockfile_freshness,
+  _check_manifest_integrity,
+  _check_mcp_beta_readiness,
+  _check_mcp_mode,
+  _check_offline_readiness,
+  _check_python_runtime,
+  _check_rule_scope_drift,
+  _check_scope,
+  _check_settings_review_pending,
+  _check_stale_orphans,
+  _check_team,
+  _check_tier_usage_readiness,
+  _check_unsupported_combos,
+  _check_wizard_state,
+  _classify,
+  _collect_manifest_entries,
+  _detect_install_mode,
+  _detect_wrapper,
+  _detection_report,
+  _emit_checks_text,
+  _emit_json,
+  _emit_text,
+  _fix_hint,
+  _foreign_records,
+  _git_config_path,
+  _is_global_only_consumer,
+  _jsonDumpsIndentAscii,
+  _parse,
+  _read_council_facts,
+  _read_inline_package_tag,
+  _reset_detection_memo,
+  _resolve_project_root,
+  _run_checks,
+  _run_checks_no_manifest,
+  _run_context,
+  _run_repair,
+  _run_trace_root,
+  _scan_foreign,
+  _settings_layer_chain,
+  _skipped_manifest_check,
+  _wizard_state_path,
+  main
+};