@event4u/agent-config 9.9.0 → 9.11.0

package/dist/cli-delegate/chunk-IR7P7JWA.js

@@ -0,0 +1,872 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  write_target
+} from "./chunk-NDJLNC6Q.js";
+import {
+  __export
+} from "./chunk-J55WI3RR.js";
+
+// src/scripts/_lib/fs_atomic.ts
+import fs from "node:fs";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+function _normalize_encoding(encoding) {
+  const compact = encoding.toLowerCase().replace(/[-_\s]/g, "");
+  const candidates = [encoding, compact];
+  if (compact === "latin1" || compact === "iso88591") candidates.push("latin1");
+  if (compact === "utf8") candidates.push("utf8");
+  if (compact === "utf16le" || compact === "utf16") candidates.push("utf16le");
+  if (compact === "usascii") candidates.push("ascii");
+  for (const c of candidates) {
+    if (Buffer.isEncoding(c)) return c;
+  }
+  throw new Error(`unknown encoding: ${encoding}`);
+}
+function write_atomic(p, data, options = {}) {
+  const encoding = options.encoding ?? "utf-8";
+  const target = path.normalize(p);
+  const parent = path.dirname(target);
+  fs.mkdirSync(parent, { recursive: true });
+  let payload;
+  if (typeof data === "string") {
+    payload = Buffer.from(data, _normalize_encoding(encoding));
+  } else if (data instanceof Uint8Array) {
+    payload = Buffer.from(data);
+  } else {
+    throw new TypeError(
+      `write_atomic: data must be str or bytes, got ${typeof data}`
+    );
+  }
+  let fd = null;
+  let tmp_path = "";
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    tmp_path = path.join(
+      parent,
+      `.${path.basename(target)}.tmp.${randomBytes(6).toString("hex")}`
+    );
+    try {
+      fd = fs.openSync(tmp_path, "wx", 384);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") continue;
+      throw err;
+    }
+  }
+  if (fd === null) {
+    throw new Error("write_atomic: could not create a unique temp file");
+  }
+  let closed = false;
+  try {
+    let offset = 0;
+    while (offset < payload.length) {
+      offset += fs.writeSync(fd, payload, offset, payload.length - offset);
+    }
+    try {
+      fs.fsyncSync(fd);
+    } catch {
+    }
+    fs.closeSync(fd);
+    closed = true;
+    fs.renameSync(tmp_path, target);
+  } catch (err) {
+    if (!closed) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      fs.unlinkSync(tmp_path);
+    } catch {
+    }
+    throw err;
+  }
+  _fsync_dir(parent);
+  return target;
+}
+function _fsync_dir(directory) {
+  let dir_fd;
+  try {
+    dir_fd = fs.openSync(directory, fs.constants.O_RDONLY);
+  } catch {
+    return;
+  }
+  try {
+    try {
+      fs.fsyncSync(dir_fd);
+    } catch {
+    }
+  } finally {
+    fs.closeSync(dir_fd);
+  }
+}
+
+// src/scripts/_lib/installed_tools.ts
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as fsPath from "node:path";
+var MANIFEST_ENV = "AGENT_CONFIG_INSTALLED_TOOLS";
+var DEFAULT_MANIFEST_RELATIVE = fsPath.join("agents", "installed-tools.lock");
+var SCHEMA_VERSION = 2;
+var SCHEMA_VERSIONS_SUPPORTED = [1, 2];
+var _VALID_SCOPES = ["global", "project"];
+var DEFAULT_DEPLOY_ROOTS = [
+  ".augment/rules",
+  ".augment/skills",
+  ".augment/commands",
+  ".cursor/rules",
+  ".claude/skills",
+  ".claude/commands",
+  ".clinerules",
+  ".windsurf/rules"
+];
+function expanduser(p) {
+  if (p === "~") {
+    return os.homedir();
+  }
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return fsPath.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}
+function manifest_path(project_root, env) {
+  const env_map = env ?? process.env;
+  const override = env_map[MANIFEST_ENV];
+  if (override) {
+    return expanduser(override);
+  }
+  return fsPath.join(project_root, DEFAULT_MANIFEST_RELATIVE);
+}
+var _TOP_KEY_RE = /^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
+var _LIST_DASH_RE = /^\s*-\s*(.+?)\s*$/;
+var _INDENT_KEY_RE = /^\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*"?([^"\n]*?)"?\s*$/;
+function read_manifest(path3) {
+  let text;
+  try {
+    text = require_read_text(path3);
+  } catch {
+    return null;
+  }
+  const data = _parse_manual(text);
+  return _normalise_v2_shape(data);
+}
+function require_read_text(path3) {
+  return fs2.readFileSync(path3, { encoding: "utf-8" });
+}
+function _normalise_v2_shape(data) {
+  if (data["tools"] === void 0 || data["tools"] === null) {
+    data["tools"] = [];
+  }
+  if (data["deploy_roots"] === void 0 || data["deploy_roots"] === null) {
+    data["deploy_roots"] = [];
+  }
+  const tools = data["tools"];
+  for (const tool of tools) {
+    if (typeof tool !== "object" || tool === null) {
+      continue;
+    }
+    const t = tool;
+    if (t["files"] === void 0 || t["files"] === null) {
+      t["files"] = [];
+    }
+    if (t["merged_keys"] === void 0 || t["merged_keys"] === null) {
+      t["merged_keys"] = [];
+    }
+  }
+  return data;
+}
+function _parse_manual(text) {
+  const data = { tools: [] };
+  const tools = data["tools"];
+  let in_tools = false;
+  let current = null;
+  let skip_until_outdent = false;
+  for (const raw of splitlines(text)) {
+    const stripped = raw.trim();
+    if (!stripped || stripped.startsWith("#")) {
+      continue;
+    }
+    if (stripped === "tools:") {
+      in_tools = true;
+      current = null;
+      skip_until_outdent = false;
+      continue;
+    }
+    if (in_tools) {
+      const indent = raw.length - lstrip_spaces(raw).length;
+      if (skip_until_outdent && indent > 4) {
+        continue;
+      }
+      skip_until_outdent = false;
+      const m = _LIST_DASH_RE.exec(raw);
+      if (m && indent === 2) {
+        const first = m[1];
+        current = {};
+        tools.push(current);
+        const inline = _TOP_KEY_RE.exec(first);
+        if (inline) {
+          current[inline[1]] = inline[2];
+        }
+        continue;
+      }
+      const mk = _INDENT_KEY_RE.exec(raw);
+      if (mk && current !== null && indent === 4) {
+        const key = mk[1];
+        const val = mk[2];
+        if ((key === "files" || key === "merged_keys") && !val) {
+          skip_until_outdent = true;
+          continue;
+        }
+        current[key] = val;
+        continue;
+      }
+    }
+    const m_top = _TOP_KEY_RE.exec(raw);
+    if (m_top) {
+      const key = m_top[1];
+      const value = m_top[2];
+      if (key === "deploy_roots" && !value) {
+        in_tools = false;
+        current = null;
+        skip_until_outdent = true;
+        continue;
+      }
+      if (key === "schema_version") {
+        const parsed = parse_int_strict(value);
+        data[key] = parsed === null ? value : parsed;
+      } else {
+        data[key] = value;
+      }
+      in_tools = false;
+      current = null;
+      skip_until_outdent = false;
+    }
+  }
+  return data;
+}
+function splitlines(text) {
+  const parts = text.split("\n");
+  if (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+function lstrip_spaces(s) {
+  let i = 0;
+  while (i < s.length && s[i] === " ") {
+    i += 1;
+  }
+  return s.slice(i);
+}
+function parse_int_strict(value) {
+  if (!/^[+-]?\d+$/.test(value.trim())) {
+    return null;
+  }
+  return Number.parseInt(value, 10);
+}
+function _render(version, tools, options = {}) {
+  const deploy_roots = options.deploy_roots ?? null;
+  const lines = [
+    `schema_version: ${SCHEMA_VERSION}`,
+    `agent_config_version: "${version}"`
+  ];
+  if (deploy_roots && deploy_roots.length > 0) {
+    lines.push("deploy_roots:");
+    for (const root of deploy_roots) {
+      lines.push(`  - ${root}`);
+    }
+  }
+  lines.push("tools:");
+  for (const tool of tools) {
+    lines.push(`  - name: ${String(tool["name"])}`);
+    lines.push(`    scope: ${String(tool["scope"])}`);
+    lines.push(`    bridge_marker: ${String(tool["bridge_marker"])}`);
+    lines.push(`    installed_at: "${String(tool["installed_at"])}"`);
+    const status = tool["status"];
+    if (status) {
+      lines.push(`    status: ${String(status)}`);
+    }
+    let files = tool["files"] ?? [];
+    if (files.length > 0) {
+      files = stable_sort(files, (f) => [String(f["path"])]);
+      lines.push("    files:");
+      for (const entry of files) {
+        lines.push(`      - path: ${String(entry["path"])}`);
+        lines.push(`        kind: ${String(entry["kind"])}`);
+        const sha = entry["sha256"];
+        if (sha === null || sha === void 0) {
+          lines.push("        sha256: null");
+        } else {
+          lines.push(`        sha256: "${String(sha)}"`);
+        }
+      }
+    }
+    let merged = tool["merged_keys"] ?? [];
+    if (merged.length > 0) {
+      merged = stable_sort(merged, (e) => [
+        String(e["file"]),
+        String(e["json_pointer"])
+      ]);
+      lines.push("    merged_keys:");
+      for (const entry of merged) {
+        lines.push(`      - file: ${String(entry["file"])}`);
+        lines.push(`        json_pointer: "${String(entry["json_pointer"])}"`);
+        const vh = entry["value_hash"];
+        if (vh !== null && vh !== void 0) {
+          lines.push(`        value_hash: "${String(vh)}"`);
+        }
+      }
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function stable_sort(items, key) {
+  return items.map((item, index) => ({ item, index, k: key(item) })).sort((a, b) => {
+    const len = Math.max(a.k.length, b.k.length);
+    for (let i = 0; i < len; i += 1) {
+      const av = a.k[i] ?? "";
+      const bv = b.k[i] ?? "";
+      if (av < bv) return -1;
+      if (av > bv) return 1;
+    }
+    return a.index - b.index;
+  }).map((entry) => entry.item);
+}
+function write_manifest(path3, version, tools, options = {}) {
+  const rendered = _render(version, tools, { deploy_roots: options.deploy_roots ?? null });
+  return write_atomic(path3, rendered);
+}
+var ScopeMismatchError = class extends Error {
+  name_;
+  recorded_scope;
+  new_scope;
+  constructor(name, recorded_scope, new_scope) {
+    super(
+      `tool '${name}' is committed as scope=${recorded_scope}; refusing to change it to scope=${new_scope} without --force`
+    );
+    this.name = "ScopeMismatchError";
+    this.name_ = name;
+    this.recorded_scope = recorded_scope;
+    this.new_scope = new_scope;
+  }
+};
+function upsert_tool(existing, options) {
+  const {
+    name,
+    scope,
+    bridge_marker,
+    installed_at = null,
+    force = false,
+    files = null,
+    merged_keys = null
+  } = options;
+  if (!_VALID_SCOPES.includes(scope)) {
+    throw new ValueError(`scope must be one of ${_VALID_SCOPES.join(",")}: '${scope}'`);
+  }
+  const stamp = installed_at || _today();
+  const _build = (prior = null) => {
+    const entry = {
+      name,
+      scope,
+      bridge_marker,
+      installed_at: stamp
+    };
+    if (files !== null) {
+      entry["files"] = [...files];
+    } else if (prior !== null && Array.isArray(prior["files"]) && prior["files"].length > 0) {
+      entry["files"] = [...prior["files"]];
+    }
+    if (merged_keys !== null) {
+      entry["merged_keys"] = [...merged_keys];
+    } else if (prior !== null && Array.isArray(prior["merged_keys"]) && prior["merged_keys"].length > 0) {
+      entry["merged_keys"] = [...prior["merged_keys"]];
+    }
+    return entry;
+  };
+  const result = [];
+  let found = false;
+  for (const entry of existing) {
+    if (entry["name"] === name) {
+      found = true;
+      const recorded = String(entry["scope"] ?? "");
+      if (recorded === scope) {
+        if (files === null && merged_keys === null) {
+          result.push(entry);
+        } else {
+          const refreshed = _build(entry);
+          refreshed["installed_at"] = entry["installed_at"] ?? stamp;
+          result.push(refreshed);
+        }
+        continue;
+      }
+      if (!force) {
+        throw new ScopeMismatchError(name, recorded, scope);
+      }
+      result.push(_build(entry));
+      continue;
+    }
+    result.push(entry);
+  }
+  if (!found) {
+    result.push(_build());
+  }
+  return result;
+}
+var ValueError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValueError";
+  }
+};
+function _today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+
+// src/scripts/_lib/global_deploy_inventory.ts
+var global_deploy_inventory_exports = {};
+__export(global_deploy_inventory_exports, {
+  INVENTORY_BASENAME: () => INVENTORY_BASENAME,
+  INVENTORY_ENV: () => INVENTORY_ENV,
+  SCHEMA_VERSION: () => SCHEMA_VERSION2,
+  expected_deploy_files: () => expected_deploy_files,
+  inventory_path: () => inventory_path,
+  load_inventory: () => load_inventory,
+  reap_stale: () => reap_stale,
+  reap_tagged_orphans: () => reap_tagged_orphans,
+  record_deploy: () => record_deploy,
+  save_inventory: () => save_inventory
+});
+import { randomBytes as randomBytes2 } from "node:crypto";
+import * as fs3 from "node:fs";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+var SCHEMA_VERSION2 = 1;
+var INVENTORY_BASENAME = "deployed-files.json";
+var INVENTORY_ENV = "AGENT_CONFIG_DEPLOY_INVENTORY";
+function expanduser2(p) {
+  if (p === "~") {
+    return os2.homedir();
+  }
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return path2.join(os2.homedir(), p.slice(2));
+  }
+  return p;
+}
+function resolve_path(p) {
+  try {
+    return fs3.realpathSync(p);
+  } catch {
+    const abs = path2.resolve(p);
+    const parts = abs.split(path2.sep);
+    for (let i = parts.length; i > 0; i -= 1) {
+      const prefix = parts.slice(0, i).join(path2.sep) || path2.sep;
+      try {
+        const real = fs3.realpathSync(prefix);
+        const rest = parts.slice(i);
+        return rest.length > 0 ? path2.join(real, ...rest) : real;
+      } catch {
+        continue;
+      }
+    }
+    return abs;
+  }
+}
+function path_exists(p) {
+  try {
+    fs3.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function inventory_path(env) {
+  const env_map = env ?? process.env;
+  const override = env_map[INVENTORY_ENV];
+  if (override) {
+    return expanduser2(override);
+  }
+  return write_target(INVENTORY_BASENAME, { env: env ?? null });
+}
+function load_inventory(p) {
+  const target = p ?? inventory_path();
+  let data;
+  try {
+    data = JSON.parse(fs3.readFileSync(target, { encoding: "utf-8" }));
+  } catch {
+    return { schema_version: SCHEMA_VERSION2, tools: {} };
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data) || typeof data["tools"] !== "object" || data["tools"] === null || Array.isArray(data["tools"])) {
+    return { schema_version: SCHEMA_VERSION2, tools: {} };
+  }
+  return data;
+}
+function save_inventory(data, p) {
+  const target = p ?? inventory_path();
+  fs3.mkdirSync(path2.dirname(target), { recursive: true });
+  const payload = json_dumps_sorted(data, 2) + "\n";
+  const parent = path2.dirname(target);
+  let fd = null;
+  let tmp_name = "";
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    tmp_name = path2.join(parent, `${path2.basename(target)}.${randomBytes2(6).toString("hex")}`);
+    try {
+      fd = fs3.openSync(tmp_name, "wx", 384);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        continue;
+      }
+      throw err;
+    }
+  }
+  if (fd === null) {
+    throw new Error("save_inventory: could not create a unique temp file");
+  }
+  try {
+    fs3.writeFileSync(fd, payload, { encoding: "utf-8" });
+    fs3.closeSync(fd);
+    fs3.renameSync(tmp_name, target);
+  } catch (err) {
+    try {
+      fs3.closeSync(fd);
+    } catch {
+    }
+    try {
+      fs3.unlinkSync(tmp_name);
+    } catch {
+    }
+    throw err;
+  }
+  return target;
+}
+function json_dumps_sorted(value, indent) {
+  return render_json(value, indent, 0);
+}
+function render_json(value, indent, depth) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") {
+    return json_string_ascii(value);
+  }
+  const pad = " ".repeat(indent * (depth + 1));
+  const close_pad = " ".repeat(indent * depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const items = value.map((v) => pad + render_json(v, indent, depth + 1));
+    return "[\n" + items.join(",\n") + "\n" + close_pad + "]";
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    const items = keys.map(
+      (k) => pad + json_string_ascii(k) + ": " + render_json(obj[k], indent, depth + 1)
+    );
+    return "{\n" + items.join(",\n") + "\n" + close_pad + "}";
+  }
+  return "null";
+}
+function json_string_ascii(s) {
+  const base = JSON.stringify(s);
+  let out = "";
+  for (let i = 0; i < base.length; i += 1) {
+    const code = base.charCodeAt(i);
+    if (code > 126) {
+      out += "\\u" + code.toString(16).padStart(4, "0");
+    } else {
+      out += base[i];
+    }
+  }
+  return out;
+}
+function expected_deploy_files(src, dest_rel) {
+  const out = /* @__PURE__ */ new Set();
+  let src_stat;
+  try {
+    src_stat = fs3.statSync(src);
+  } catch {
+    return out;
+  }
+  if (!src_stat.isDirectory()) {
+    out.add(as_posix(dest_rel));
+    return out;
+  }
+  const _walk = (node, prefix) => {
+    const entries = fs3.readdirSync(node).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    for (const name of entries) {
+      const entry = path2.join(node, name);
+      const rel = join_rel(prefix, name);
+      const lst = fs3.lstatSync(entry);
+      if (lst.isDirectory() && !lst.isSymbolicLink()) {
+        _walk(entry, rel);
+        continue;
+      }
+      let resolved_is_dir = false;
+      try {
+        resolved_is_dir = fs3.statSync(entry).isDirectory();
+      } catch {
+        resolved_is_dir = false;
+      }
+      if (resolved_is_dir) {
+        _walk(fs3.realpathSync(entry), rel);
+        continue;
+      }
+      out.add(as_posix(rel));
+    }
+  };
+  _walk(src, dest_rel);
+  return out;
+}
+function join_rel(prefix, name) {
+  return prefix ? path2.join(prefix, name) : name;
+}
+function as_posix(p) {
+  if (p === "") {
+    return ".";
+  }
+  return p.split(path2.sep).join("/");
+}
+function reap_stale(tool_id, anchor, current_files, inventory, dry_run = false) {
+  const tools = inventory["tools"] ?? {};
+  const entry = tools[tool_id];
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    return [];
+  }
+  const e = entry;
+  const recorded_anchor = e["anchor"];
+  const prev_files = e["files"];
+  if (typeof recorded_anchor !== "string" || !Array.isArray(prev_files)) {
+    return [];
+  }
+  const anchor_resolved = resolve_path(expanduser2(anchor));
+  if (resolve_path(expanduser2(recorded_anchor)) !== anchor_resolved) {
+    return [];
+  }
+  const deleted = [];
+  const prune_candidates = /* @__PURE__ */ new Set();
+  const orphans = difference(prev_files, current_files);
+  for (const rel of sorted_strings(orphans)) {
+    if (typeof rel !== "string" || !rel || rel.startsWith("/") || rel.startsWith("..")) {
+      continue;
+    }
+    const target = path2.join(anchor_resolved, rel);
+    try {
+      relative_to(resolve_path(path2.dirname(target)), anchor_resolved);
+    } catch {
+      continue;
+    }
+    let lst = null;
+    try {
+      lst = fs3.lstatSync(target);
+    } catch {
+      lst = null;
+    }
+    if (lst && lst.isDirectory() && !lst.isSymbolicLink()) {
+      continue;
+    }
+    if (dry_run) {
+      if (path_exists(target) || lst !== null && lst.isSymbolicLink()) {
+        deleted.push(target);
+      }
+      continue;
+    }
+    try {
+      fs3.unlinkSync(target);
+    } catch {
+      continue;
+    }
+    deleted.push(target);
+    prune_candidates.add(path2.dirname(target));
+  }
+  prune_empty_dirs(prune_candidates, anchor_resolved);
+  return deleted;
+}
+function reap_tagged_orphans(anchor, dest_subs, current_files, package_tag, dry_run = false) {
+  const anchor_resolved = resolve_path(expanduser2(anchor));
+  const deleted = [];
+  const prune_candidates = /* @__PURE__ */ new Set();
+  const needle = `package: ${package_tag}`;
+  for (const dest_sub of dest_subs) {
+    const root = dest_sub ? path2.join(anchor_resolved, dest_sub) : anchor_resolved;
+    let root_stat;
+    try {
+      root_stat = fs3.statSync(root);
+    } catch {
+      continue;
+    }
+    if (!root_stat.isDirectory()) {
+      continue;
+    }
+    for (const md of rglob_md(root)) {
+      let md_lst;
+      try {
+        md_lst = fs3.lstatSync(md);
+      } catch {
+        continue;
+      }
+      if (md_lst.isDirectory()) {
+        continue;
+      }
+      const rel = relative_to_posix(md, anchor_resolved);
+      if (current_files.has(rel)) {
+        continue;
+      }
+      try {
+        relative_to(resolve_path(path2.dirname(md)), anchor_resolved);
+      } catch {
+        continue;
+      }
+      let head;
+      try {
+        head = fs3.readFileSync(md, { encoding: "utf-8" });
+      } catch {
+        continue;
+      }
+      if (!head.startsWith("---")) {
+        continue;
+      }
+      const end = head.indexOf("\n---", 3);
+      const block = head.slice(0, end !== -1 ? end : head.length);
+      const hit = splitlines2(block).some((line) => line.trim() === needle);
+      if (!hit) {
+        continue;
+      }
+      if (dry_run) {
+        deleted.push(md);
+        continue;
+      }
+      try {
+        fs3.unlinkSync(md);
+      } catch {
+        continue;
+      }
+      deleted.push(md);
+      prune_candidates.add(path2.dirname(md));
+    }
+  }
+  prune_empty_dirs(prune_candidates, anchor_resolved);
+  return deleted;
+}
+function record_deploy(tool_id, anchor, current_files, inventory) {
+  if (typeof inventory["tools"] !== "object" || inventory["tools"] === null || Array.isArray(inventory["tools"])) {
+    inventory["tools"] = {};
+  }
+  const tools = inventory["tools"];
+  tools[tool_id] = {
+    anchor: String(anchor),
+    files: sorted_strings([...current_files])
+  };
+  inventory["schema_version"] = SCHEMA_VERSION2;
+  return inventory;
+}
+function prune_empty_dirs(prune_candidates, anchor_resolved) {
+  const ordered = [...prune_candidates].sort(
+    (a, b) => b.split(path2.sep).length - a.split(path2.sep).length
+  );
+  for (const start of ordered) {
+    let node = start;
+    while (node !== anchor_resolved && is_ancestor(anchor_resolved, node)) {
+      try {
+        fs3.rmdirSync(node);
+      } catch {
+        break;
+      }
+      node = path2.dirname(node);
+    }
+  }
+}
+function is_ancestor(anchor, node) {
+  const rel = path2.relative(anchor, node);
+  return rel !== "" && !rel.startsWith("..") && !path2.isAbsolute(rel);
+}
+function relative_to(child, parent) {
+  if (child === parent) {
+    return "";
+  }
+  const rel = path2.relative(parent, child);
+  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+    throw new Error(`'${child}' is not in the subpath of '${parent}'`);
+  }
+  return rel;
+}
+function relative_to_posix(child, parent) {
+  return path2.relative(parent, child).split(path2.sep).join("/");
+}
+function rglob_md(root) {
+  const out = [];
+  const walk = (dir) => {
+    let names;
+    try {
+      names = fs3.readdirSync(dir).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    } catch {
+      return;
+    }
+    for (const name of names) {
+      const full = path2.join(dir, name);
+      let lst;
+      try {
+        lst = fs3.lstatSync(full);
+      } catch {
+        continue;
+      }
+      if (lst.isDirectory() && !lst.isSymbolicLink()) {
+        walk(full);
+      } else if (name.endsWith(".md")) {
+        out.push(full);
+      }
+    }
+  };
+  walk(root);
+  return out;
+}
+function difference(prev, current) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of prev) {
+    if (typeof item === "string" && current.has(item)) {
+      continue;
+    }
+    if (seen.has(item)) {
+      continue;
+    }
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+function sorted_strings(items) {
+  return items.filter((i) => typeof i === "string").sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function splitlines2(text) {
+  const parts = text.split("\n");
+  if (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+
+export {
+  write_atomic,
+  SCHEMA_VERSIONS_SUPPORTED,
+  DEFAULT_DEPLOY_ROOTS,
+  manifest_path,
+  read_manifest,
+  write_manifest,
+  ScopeMismatchError,
+  upsert_tool,
+  load_inventory,
+  save_inventory,
+  expected_deploy_files,
+  reap_stale,
+  reap_tagged_orphans,
+  record_deploy,
+  global_deploy_inventory_exports
+};