@event4u/agent-config 9.9.0 → 9.11.0

package/dist/cli-delegate/cmd_prune.js

@@ -0,0 +1,444 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  PROJECT_BRIDGE_MARKERS
+} from "./chunk-YMFO6FDN.js";
+import "./chunk-XX6TOPD7.js";
+import {
+  manifest_path,
+  read_manifest
+} from "./chunk-IR7P7JWA.js";
+import "./chunk-GRRPEPRN.js";
+import "./chunk-7DSAMZFU.js";
+import {
+  resolve_project_root
+} from "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import "./chunk-MCJYCQPF.js";
+import "./chunk-OY53J6II.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_prune.ts
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var ArgparseExit = class extends Error {
+  code;
+  constructor(code) {
+    super(`ArgparseExit(${code})`);
+    this.name = "ArgparseExit";
+    this.code = code;
+  }
+};
+var _stdout = { write: (t) => process.stdout.write(t) };
+var _stderr = { write: (t) => process.stderr.write(t) };
+function _print(out, line = "") {
+  out.write(line + "\n");
+}
+function expanduser(p) {
+  if (p === "~" || p.startsWith("~/")) {
+    const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
+    return home + p.slice(1);
+  }
+  return p;
+}
+function _exists(p) {
+  try {
+    fs.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _listOf(value) {
+  return Array.isArray(value) ? value : [];
+}
+function _jsonStrAscii(s) {
+  let out = '"';
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    const ch = s[i];
+    switch (ch) {
+      case '"':
+        out += '\\"';
+        break;
+      case "\\":
+        out += "\\\\";
+        break;
+      case "\n":
+        out += "\\n";
+        break;
+      case "\r":
+        out += "\\r";
+        break;
+      case "	":
+        out += "\\t";
+        break;
+      case "\b":
+        out += "\\b";
+        break;
+      case "\f":
+        out += "\\f";
+        break;
+      default:
+        if (code < 32 || code > 126) {
+          out += "\\u" + code.toString(16).padStart(4, "0");
+        } else {
+          out += ch;
+        }
+    }
+  }
+  return out + '"';
+}
+function _jsonScalarAscii(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      if (Number.isNaN(value)) return "NaN";
+      return value > 0 ? "Infinity" : "-Infinity";
+    }
+    return String(value);
+  }
+  if (typeof value === "string") return _jsonStrAscii(value);
+  return null;
+}
+function _dumpIndentAscii(value, indent, depth) {
+  const scalar = _jsonScalarAscii(value);
+  if (scalar !== null) return scalar;
+  const pad = " ".repeat(indent * (depth + 1));
+  const closePad = " ".repeat(indent * depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const items = value.map((v) => pad + _dumpIndentAscii(v, indent, depth + 1));
+    return `[
+${items.join(",\n")}
+${closePad}]`;
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return "{}";
+    const items = keys.map(
+      (k) => `${pad}${_jsonStrAscii(k)}: ${_dumpIndentAscii(obj[k], indent, depth + 1)}`
+    );
+    return `{
+${items.join(",\n")}
+${closePad}}`;
+  }
+  return _jsonStrAscii(String(value));
+}
+function _jsonDumpsIndentAscii(value, indent) {
+  return _dumpIndentAscii(value, indent, 0);
+}
+function _resolve_project_root(arg) {
+  const [root] = resolve_project_root(arg);
+  return root;
+}
+function _load_manifest(project_root, opts) {
+  const manifest_path2 = manifest_path(project_root);
+  const manifest = read_manifest(manifest_path2);
+  if (manifest === null) {
+    if (opts.force_empty) {
+      return [null, /* @__PURE__ */ new Set()];
+    }
+    return [null, null];
+  }
+  const tools = _listOf(manifest["tools"]) ?? [];
+  const declared = /* @__PURE__ */ new Set();
+  for (const e of tools) {
+    const name = e["name"];
+    if (name && e["scope"] === "project" && (e["status"] ?? "installed") === "installed") {
+      declared.add(String(name));
+    }
+  }
+  return [manifest, declared];
+}
+function _resolve_path(project_root, raw) {
+  const p = expanduser(raw);
+  if (!path.isAbsolute(p)) {
+    return path.join(project_root, p);
+  }
+  return p;
+}
+function _sha256(p) {
+  try {
+    return crypto.createHash("sha256").update(fs.readFileSync(p)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function _orphaned(project_root, manifest, declared, opts = {}) {
+  const resume_uninstall = opts.resume_uninstall ?? false;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  if (!resume_uninstall) {
+    for (const tool_id of Object.keys(PROJECT_BRIDGE_MARKERS)) {
+      const rel = PROJECT_BRIDGE_MARKERS[tool_id];
+      if (declared.has(tool_id)) {
+        continue;
+      }
+      const target = path.join(project_root, rel);
+      if (!_exists(target)) {
+        continue;
+      }
+      out.push([tool_id, target, null, null]);
+      seen.add(_realpath(target));
+    }
+  }
+  if (manifest === null) {
+    return out;
+  }
+  for (const tool of _listOf(manifest["tools"])) {
+    if (tool["scope"] !== "project") {
+      continue;
+    }
+    const files = _listOf(tool["files"]);
+    if (!files.length) {
+      continue;
+    }
+    const tool_id = String(tool["name"] ?? "");
+    const status = tool["status"] ?? "installed";
+    if (resume_uninstall) {
+      if (status !== "uninstalling") {
+        continue;
+      }
+    } else if (status === "installed" && declared.has(tool_id)) {
+      continue;
+    }
+    for (const entry of files) {
+      const kind = entry["kind"];
+      if (kind !== "bridge" && kind !== "marker" && kind !== "deployed") {
+        continue;
+      }
+      const raw = entry["path"] ?? "";
+      if (!raw) {
+        continue;
+      }
+      const target = _resolve_path(project_root, raw);
+      const resolved = _realpath(target);
+      if (seen.has(resolved) || !_exists(target)) {
+        continue;
+      }
+      out.push([tool_id, target, kind, entry["sha256"] ?? null]);
+      seen.add(resolved);
+    }
+  }
+  return out;
+}
+function _realpath(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+}
+function _classify(target, expected_sha) {
+  if (expected_sha === null) {
+    return ["orphan", null];
+  }
+  const actual = _sha256(target);
+  if (actual === null || actual !== expected_sha) {
+    return ["modified", actual];
+  }
+  return ["orphan", actual];
+}
+function _remove(target, opts) {
+  if (opts.dry_run) {
+    return [true, "would remove"];
+  }
+  try {
+    fs.unlinkSync(target);
+    return [true, "removed"];
+  } catch (exc) {
+    const e = exc;
+    if (e && e.code === "EISDIR") {
+      return [false, "\u274C is a directory (refusing \u2014 use uninstall --purge)"];
+    }
+    return [false, `\u274C failed (${_pyOSErrorStr(e, target)})`];
+  }
+}
+function _pyOSErrorStr(e, filename) {
+  const errno = typeof e.errno === "number" ? Math.abs(e.errno) : null;
+  const STRERROR = {
+    EPERM: "Operation not permitted",
+    EISDIR: "Is a directory",
+    EACCES: "Permission denied",
+    ENOENT: "No such file or directory",
+    EBUSY: "Device or resource busy",
+    ENOTEMPTY: "Directory not empty"
+  };
+  const strerror = e.code && STRERROR[e.code] || (e.message ?? String(e));
+  if (errno !== null) {
+    return `[Errno ${errno}] ${strerror}: '${filename}'`;
+  }
+  return strerror;
+}
+function _parse(argv) {
+  const prog = "agent-config prune";
+  const usage = "usage: agent-config prune [-h] [--project PROJECT] [--dry-run] [--json]\n                          [--all-missing-lock] [--resume-uninstall]\n";
+  const emitError = (msg) => {
+    _stderr.write(usage);
+    _stderr.write(`${prog}: error: ${msg}
+`);
+    throw new ArgparseExit(2);
+  };
+  const opts = {
+    project: null,
+    dry_run: false,
+    json: false,
+    all_missing_lock: false,
+    resume_uninstall: false
+  };
+  let i = 0;
+  while (i < argv.length) {
+    const tok = argv[i];
+    const flag = tok.includes("=") ? tok.slice(0, tok.indexOf("=")) : tok;
+    if (flag === "-h" || flag === "--help") {
+      _stdout.write(usage);
+      throw new ArgparseExit(0);
+    } else if (flag === "--project") {
+      const eq = tok.indexOf("=");
+      if (eq >= 0) {
+        opts.project = tok.slice(eq + 1);
+        i += 1;
+      } else {
+        const val = argv[i + 1];
+        if (val === void 0) {
+          emitError("argument --project: expected one argument");
+        }
+        opts.project = val;
+        i += 2;
+      }
+    } else if (flag === "--dry-run") {
+      opts.dry_run = true;
+      i += 1;
+    } else if (flag === "--json") {
+      opts.json = true;
+      i += 1;
+    } else if (flag === "--all-missing-lock") {
+      opts.all_missing_lock = true;
+      i += 1;
+    } else if (flag === "--resume-uninstall") {
+      opts.resume_uninstall = true;
+      i += 1;
+    } else {
+      emitError(`unrecognized arguments: ${tok}`);
+    }
+  }
+  return opts;
+}
+function _relativeToOr(target, base) {
+  if (!path.isAbsolute(target)) {
+    return target;
+  }
+  const rel = path.relative(base, target);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    return target;
+  }
+  return rel;
+}
+function _emit_text(project_root, candidates, results, opts, out) {
+  const prefix = opts.dry_run ? "[dry-run] " : "";
+  if (!candidates.length) {
+    _print(out, `\u2705  ${prefix}no orphaned bridges in ${project_root}`);
+    return;
+  }
+  const modified = results.filter((r) => r[2] === "modified");
+  const orphans = results.filter((r) => r[2] === "orphan");
+  _print(
+    out,
+    `${prefix}${orphans.length} orphaned, ${modified.length} modified bridge(s) under ${project_root}:`
+  );
+  for (const [tool_id, target, state, ok, msg] of results) {
+    const rel = _relativeToOr(target, project_root);
+    if (state === "modified") {
+      _print(out, `  \u26A0  ${tool_id}: modified \u2014 skipped ${rel}`);
+      continue;
+    }
+    const mark = ok ? "\xB7" : "!";
+    _print(out, `  ${mark} ${tool_id}: ${msg} ${rel}`);
+  }
+}
+function _emit_json(project_root, results, opts, out) {
+  const payload = {
+    project_root,
+    dry_run: opts.dry_run,
+    orphans: results.map(([tool_id, target, state, ok, msg]) => ({
+      tool: tool_id,
+      path: _relativeToOr(target, project_root),
+      state,
+      ok,
+      status: msg
+    }))
+  };
+  _print(out, _jsonDumpsIndentAscii(payload, 2));
+}
+function main(argv = null) {
+  const opts = _parse(argv !== null ? [...argv] : process.argv.slice(2));
+  const project_root = _resolve_project_root(opts.project);
+  const [manifest, declared] = _load_manifest(project_root, {
+    force_empty: opts.all_missing_lock
+  });
+  if (declared === null) {
+    const manifest_path2 = manifest_path(project_root);
+    _print(_stderr, `\u274C  no project lockfile at ${manifest_path2}`);
+    _print(
+      _stderr,
+      "    pass --all-missing-lock to prune every known marker (destructive)"
+    );
+    return 1;
+  }
+  const candidates = _orphaned(project_root, manifest, declared, {
+    resume_uninstall: opts.resume_uninstall
+  });
+  const results = [];
+  for (const [tool_id, target, _kind, expected_sha] of candidates) {
+    const [state] = _classify(target, expected_sha);
+    if (state === "modified") {
+      results.push([tool_id, target, state, true, "skipped (modified)"]);
+      continue;
+    }
+    const [ok, msg] = _remove(target, { dry_run: opts.dry_run });
+    results.push([tool_id, target, state, ok, msg]);
+  }
+  if (opts.json) {
+    _emit_json(project_root, results, { dry_run: opts.dry_run }, _stdout);
+  } else {
+    _emit_text(project_root, candidates, results, { dry_run: opts.dry_run }, _stdout);
+  }
+  const failed = results.filter((r) => !r[2]);
+  return failed.length ? 1 : 0;
+}
+var _HERE = fileURLToPath(import.meta.url);
+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 (exc) {
+    if (exc instanceof ArgparseExit) {
+      process.exitCode = exc.code;
+    } else {
+      throw exc;
+    }
+  }
+}
+export {
+  main
+};

package/dist/cli-delegate/cmd_refresh.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  ArgparseExit,
+  _default_runner,
+  _is_source_repo,
+  _parse,
+  _refresh_global,
+  _refresh_project,
+  _remove_legacy_consumer_bridge_marker,
+  _sync_gitattributes,
+  _sync_gitignore,
+  main
+} from "./chunk-736JCWLM.js";
+import "./chunk-MCJYCQPF.js";
+import "./chunk-J55WI3RR.js";
+export {
+  ArgparseExit,
+  _default_runner,
+  _is_source_repo,
+  _parse,
+  _refresh_global,
+  _refresh_project,
+  _remove_legacy_consumer_bridge_marker,
+  _sync_gitattributes,
+  _sync_gitignore,
+  main
+};