@event4u/agent-config 9.9.0 → 9.11.0

package/dist/cli-delegate/chunk-7DSAMZFU.js

@@ -0,0 +1,356 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  __toESM
+} from "./chunk-J55WI3RR.js";
+
+// src/install/atomic.ts
+import {
+  closeSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+function atomicWriteFile(target, data, options = {}) {
+  const mode = options.mode ?? 420;
+  const parent = dirname(target);
+  mkdirSync(parent, { recursive: true });
+  const tmp = join(parent, `.tmp.${process.pid}.${randSuffix()}`);
+  let fd = null;
+  try {
+    fd = openSync(tmp, "w", mode);
+    const buf = typeof data === "string" ? Buffer.from(data, "utf8") : data;
+    writeSync(fd, buf, 0, buf.length, 0);
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = null;
+    renameSync(tmp, target);
+  } catch (err) {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function atomicAppendLine(target, line) {
+  let existing = "";
+  try {
+    existing = readFileSync(target, "utf8");
+  } catch {
+    existing = "";
+  }
+  const sep = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  atomicWriteFile(target, `${existing}${sep}${line}
+`);
+}
+function randSuffix() {
+  return Math.floor(Math.random() * 281474976710655).toString(16).padStart(12, "0");
+}
+
+// src/scripts/_lib/claude_settings_hooks.ts
+var YAML = __toESM(require_dist(), 1);
+import * as fs from "node:fs";
+import * as path from "node:path";
+function _yaml_parse(text) {
+  return YAML.parse(text);
+}
+var MANAGED_SIGNATURE = "dispatch:hook --platform claude";
+var CorruptSettingsError = class extends Error {
+  constructor(file, cause) {
+    super(
+      `${file} exists but is not valid JSON (${cause}). Refusing to overwrite a user-owned settings file \u2014 fix or remove it, then re-run.`
+    );
+    this.name = "CorruptSettingsError";
+  }
+};
+var SettingsLockError = class extends Error {
+  constructor(lockPath) {
+    super(
+      `settings lock ${lockPath} is held by another process. Re-run when the concurrent install finishes (stale lock: delete the file).`
+    );
+    this.name = "SettingsLockError";
+  }
+};
+function build_claude_hook_matrix(manifest_path) {
+  const raw = fs.readFileSync(manifest_path, "utf8");
+  const manifest = _yaml_parse(raw) ?? {};
+  const hook_spec = manifest["schema_version"] ?? 1;
+  const platforms = manifest["platforms"] ?? {};
+  const claude_events = (platforms["claude"] ?? {}) || {};
+  const aliasesAll = manifest["native_event_aliases"] ?? {};
+  const aliases = (aliasesAll["claude"] ?? {}) || {};
+  const ac_to_native = {};
+  for (const [native, ac] of Object.entries(aliases)) {
+    ac_to_native[String(ac)] = native;
+  }
+  const matrix = {};
+  for (const [ac_event, concerns] of Object.entries(claude_events)) {
+    if (!concerns || Array.isArray(concerns) && concerns.length === 0) continue;
+    const native = ac_to_native[ac_event];
+    if (native === void 0) continue;
+    matrix[native] = `BIN="$CLAUDE_PROJECT_DIR/agent-config"; [ -x "$BIN" ] || BIN=agent-config; command -v "$BIN" >/dev/null 2>&1 || exit 0; "$BIN" dispatch:hook --platform claude --event ${ac_event} --native-event ${native} --project-dir "$CLAUDE_PROJECT_DIR" --min-version ${String(hook_spec)}`;
+  }
+  return matrix;
+}
+function _is_managed_group(group) {
+  if (typeof group !== "object" || group === null || Array.isArray(group)) return false;
+  const hooks = group.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some(
+    (h) => typeof h === "object" && h !== null && typeof h.command === "string" && h.command.includes(MANAGED_SIGNATURE)
+  );
+}
+function _read_settings(settings_path) {
+  if (!fs.existsSync(settings_path)) return {};
+  const raw = fs.readFileSync(settings_path, "utf8");
+  if (raw.trim() === "") return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new CorruptSettingsError(settings_path, e.message);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new CorruptSettingsError(settings_path, "top level is not an object");
+  }
+  return parsed;
+}
+function _with_lock(settings_path, fn) {
+  const lockPath = settings_path + ".agent-config.lock";
+  fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+  let fd;
+  try {
+    fd = fs.openSync(lockPath, "wx");
+  } catch {
+    throw new SettingsLockError(lockPath);
+  }
+  try {
+    return fn();
+  } finally {
+    fs.closeSync(fd);
+    fs.rmSync(lockPath, { force: true });
+  }
+}
+function ensure_managed_hooks(settings_path, matrix) {
+  return _with_lock(settings_path, () => {
+    const settings = _read_settings(settings_path);
+    const before = JSON.stringify(settings);
+    const hooks = (settings["hooks"] ?? {}) || {};
+    const touched = [];
+    for (const [native, command] of Object.entries(matrix)) {
+      const existing = Array.isArray(hooks[native]) ? hooks[native] : [];
+      const user_groups = existing.filter((g) => !_is_managed_group(g));
+      const managed_group = {
+        hooks: [{ type: "command", command }]
+      };
+      const next = [...user_groups, managed_group];
+      if (JSON.stringify(next) !== JSON.stringify(existing)) touched.push(native);
+      hooks[native] = next;
+    }
+    settings["hooks"] = hooks;
+    const after = JSON.stringify(settings);
+    if (after === before) {
+      return { changed: false, events: [] };
+    }
+    atomicWriteFile(settings_path, JSON.stringify(settings, null, 2) + "\n");
+    return { changed: true, events: touched };
+  });
+}
+function remove_managed_hooks(settings_path) {
+  if (!fs.existsSync(settings_path)) return { changed: false, events: [] };
+  return _with_lock(settings_path, () => {
+    const settings = _read_settings(settings_path);
+    const hooks = settings["hooks"];
+    if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks)) {
+      return { changed: false, events: [] };
+    }
+    const hooksRec = hooks;
+    const touched = [];
+    for (const [native, groups] of Object.entries(hooksRec)) {
+      if (!Array.isArray(groups)) continue;
+      const kept = groups.filter((g) => !_is_managed_group(g));
+      if (kept.length !== groups.length) {
+        touched.push(native);
+        if (kept.length === 0) {
+          delete hooksRec[native];
+        } else {
+          hooksRec[native] = kept;
+        }
+      }
+    }
+    if (touched.length === 0) return { changed: false, events: [] };
+    if (Object.keys(hooksRec).length === 0) {
+      delete settings["hooks"];
+    }
+    atomicWriteFile(settings_path, JSON.stringify(settings, null, 2) + "\n");
+    return { changed: true, events: touched };
+  });
+}
+
+// src/scripts/_lib/claude_builtin_names.ts
+var _CURRENT = [
+  "add-dir",
+  "advisor",
+  "agents",
+  "autofix-pr",
+  "background",
+  "batch",
+  "branch",
+  "btw",
+  "cd",
+  "chrome",
+  "claude-api",
+  "clear",
+  "code-review",
+  "color",
+  "compact",
+  "config",
+  "context",
+  "copy",
+  "cost",
+  "dataviz",
+  "debug",
+  "deep-research",
+  "design-login",
+  "design-sync",
+  "desktop",
+  "diff",
+  "doctor",
+  "effort",
+  "exit",
+  "export",
+  "fast",
+  "feedback",
+  "fewer-permission-prompts",
+  "focus",
+  "fork",
+  "goal",
+  "heapdump",
+  "help",
+  "hooks",
+  "ide",
+  "init",
+  "insights",
+  "install-github-app",
+  "install-slack-app",
+  "keybindings",
+  "login",
+  "logout",
+  "loop",
+  "mcp",
+  "memory",
+  "mobile",
+  "model",
+  "passes",
+  "permissions",
+  "plan",
+  "plugin",
+  "powerup",
+  "pr-comments",
+  "privacy-settings",
+  "radio",
+  "recap",
+  "release-notes",
+  "reload-plugins",
+  "reload-skills",
+  "remote-control",
+  "remote-env",
+  "rename",
+  "resume",
+  "review",
+  "rewind",
+  "run",
+  "run-skill-generator",
+  "sandbox",
+  "schedule",
+  "scroll-speed",
+  "security-review",
+  "setup-bedrock",
+  "setup-vertex",
+  "simplify",
+  "skills",
+  "stats",
+  "status",
+  "statusline",
+  "stickers",
+  "teleport",
+  "thinking",
+  "trust",
+  "upgrade",
+  "usage",
+  "verify",
+  "vim",
+  "web",
+  "whats-new",
+  "workflow",
+  "workflows",
+  "worktree"
+];
+var _LEGACY = [
+  "bashes",
+  "bug",
+  "migrate-installer",
+  "output-style",
+  "terminal-setup",
+  "theme",
+  "todos"
+];
+var CLAUDE_CODE_BUILTIN_NAMES = /* @__PURE__ */ new Set([
+  ..._CURRENT,
+  ..._LEGACY
+]);
+function is_claude_builtin_name(slug) {
+  return CLAUDE_CODE_BUILTIN_NAMES.has(slug.toLowerCase());
+}
+
+// src/scripts/_lib/model_tier.ts
+import fs2 from "node:fs";
+var TIER_TO_CLAUDE_MODEL = {
+  high: "opus",
+  medium: "sonnet",
+  lite: "haiku"
+};
+var MODEL_TIER_RE = /^model_tier:\s*"?([a-z]+)"?\s*$/m;
+function read_model_tier(skill_md) {
+  if (!fs2.existsSync(skill_md)) return null;
+  const text = fs2.readFileSync(skill_md).toString("utf-8");
+  if (!text.startsWith("---\n")) return null;
+  const end = text.indexOf("\n---\n", 4);
+  if (end === -1) return null;
+  const m = MODEL_TIER_RE.exec(text.slice(4, end));
+  return m ? m[1] : null;
+}
+function render_native_model_md(text, tier) {
+  const model = TIER_TO_CLAUDE_MODEL[tier];
+  if (model === void 0) {
+    throw new Error(`'${tier}'`);
+  }
+  return text.replace(MODEL_TIER_RE, `model: ${model}`);
+}
+
+export {
+  atomicAppendLine,
+  MANAGED_SIGNATURE,
+  build_claude_hook_matrix,
+  ensure_managed_hooks,
+  remove_managed_hooks,
+  is_claude_builtin_name,
+  TIER_TO_CLAUDE_MODEL,
+  MODEL_TIER_RE,
+  read_model_tier,
+  render_native_model_md
+};

package/dist/cli-delegate/chunk-7HQ52DHU.js

@@ -0,0 +1,74 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  write_target
+} from "./chunk-NDJLNC6Q.js";
+
+// src/scripts/_lib/update_check.ts
+var PACKAGE_NAME = "@event4u/agent-config";
+var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var FETCH_TIMEOUT_S = 1;
+var CHECK_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var STATE_FILENAME = "update-check.json";
+var DEFAULT_STATE_PATH = write_target(STATE_FILENAME);
+async function fetch_latest_from_npm(options = {}) {
+  const timeout = options.timeout ?? FETCH_TIMEOUT_S;
+  const url = options.url ?? NPM_REGISTRY_URL;
+  const fetch_impl = options.fetch_impl ?? fetch;
+  try {
+    const resp = await fetch_impl(url, {
+      headers: {
+        Accept: "application/json",
+        "User-Agent": "agent-config-update-check"
+      },
+      signal: AbortSignal.timeout(timeout * 1e3)
+    });
+    const payload = await resp.json();
+    if (payload !== null && typeof payload === "object" && !Array.isArray(payload)) {
+      const version = payload.version;
+      if (typeof version === "string" && version.trim()) {
+        return version.trim();
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function _int_or_zero(part) {
+  const trimmed = part.trim();
+  if (/^[+-]?\d+$/.test(trimmed)) {
+    return parseInt(trimmed, 10);
+  }
+  return 0;
+}
+function _is_newer(latest, installed) {
+  const parse = (v) => {
+    const core = v.replace(/^v+/, "").split("-")[0] ?? "";
+    const parts = core.split(".");
+    const out = [];
+    for (const p of parts.slice(0, 3)) {
+      out.push(_int_or_zero(p));
+    }
+    while (out.length < 3) {
+      out.push(0);
+    }
+    return [out[0], out[1], out[2]];
+  };
+  const a = parse(latest);
+  const b = parse(installed);
+  for (let i = 0; i < 3; i += 1) {
+    if (a[i] > b[i]) {
+      return true;
+    }
+    if (a[i] < b[i]) {
+      return false;
+    }
+  }
+  return false;
+}
+
+export {
+  DEFAULT_STATE_PATH,
+  fetch_latest_from_npm,
+  _is_newer
+};

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

@@ -0,0 +1,266 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/agent_src.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var _HERE = path.dirname(fileURLToPath(import.meta.url));
+var _DEFAULT_ROOT = path.resolve(_HERE, "..", "..", "..");
+function _deriveRoots(root) {
+  const packages = path.join(root, "packages");
+  const src = path.join(root, "src");
+  return {
+    ROOT: root,
+    LEGACY_SRC: path.join(root, ".agent-src.uncondensed"),
+    PACKAGES: packages,
+    PACKAGE_CORE: path.join(packages, "core"),
+    SRC: src,
+    SRC_SKILLS: path.join(src, "skills"),
+    SRC_RULES: path.join(src, "rules"),
+    SRC_AGENT: path.join(src, "agent-src"),
+    SRC_DOMAINS: path.join(src, "domains")
+  };
+}
+var _roots = _deriveRoots(_DEFAULT_ROOT);
+var _SRC_DOMAINS_PREFIX = "src/domains/";
+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 _exists(p) {
+  try {
+    fs.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _iterdirSorted(p) {
+  let names;
+  try {
+    names = fs.readdirSync(p);
+  } catch {
+    return [];
+  }
+  names.sort();
+  return names.map((name) => path.join(p, name));
+}
+function _rglobSorted(root, pattern) {
+  const out = [];
+  const suffix = pattern === "*" ? null : pattern.slice(1);
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const ent of entries) {
+      const full = path.join(dir, ent.name);
+      const matches = suffix === null ? true : ent.name.endsWith(suffix);
+      if (matches) {
+        out.push(full);
+      }
+      if (ent.isDirectory() || ent.isSymbolicLink() && _isDir(full)) {
+        walk(full);
+      }
+    }
+  };
+  walk(root);
+  out.sort();
+  return out;
+}
+function _relativeToPosix(child, root) {
+  const rel = path.relative(root, child);
+  return rel.split(path.sep).join("/");
+}
+function _isUnder(child, root) {
+  const rel = path.relative(root, child);
+  return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function _domains_command_logical(p) {
+  const dom = _roots.SRC_DOMAINS;
+  if (p !== dom && !_isUnder(p, dom)) {
+    return null;
+  }
+  const rel = _relativeToPosix(p, dom);
+  const parts = rel.split("/");
+  if (parts.length < 3 || parts[parts.length - 1] !== "command.md") {
+    return null;
+  }
+  const subpath = parts.slice(1, -1).join("/");
+  return `commands/${subpath}.md`;
+}
+function* _iter_domains_commands() {
+  const dom = _roots.SRC_DOMAINS;
+  if (!_isDir(dom)) {
+    return;
+  }
+  for (const p of _rglobSorted(dom, "command.md")) {
+    if (!_isFile(p)) {
+      continue;
+    }
+    const logical = _domains_command_logical(p);
+    if (logical !== null) {
+      yield [p, logical];
+    }
+  }
+}
+var _LEGACY_PREFIX = ".agent-src.uncondensed/";
+var _PACKAGE_SUFFIX = "/.agent-src.uncondensed/";
+var _SRC_SKILLS_PREFIX = "src/skills/";
+var _SRC_RULES_PREFIX = "src/rules/";
+function _root_specs() {
+  const specs = [];
+  if (_exists(_roots.LEGACY_SRC)) {
+    specs.push([_roots.LEGACY_SRC, ""]);
+  }
+  if (_exists(_roots.PACKAGES)) {
+    for (const pkg of _iterdirSorted(_roots.PACKAGES)) {
+      const sub = path.join(pkg, ".agent-src.uncondensed");
+      if (_isDir(sub)) {
+        specs.push([sub, ""]);
+      }
+    }
+  }
+  if (_isDir(_roots.SRC_AGENT)) {
+    specs.push([_roots.SRC_AGENT, ""]);
+  }
+  if (_isDir(_roots.SRC_SKILLS)) {
+    specs.push([_roots.SRC_SKILLS, "skills/"]);
+  }
+  if (_isDir(_roots.SRC_RULES)) {
+    specs.push([_roots.SRC_RULES, "rules/"]);
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const [physical, prefix] of specs) {
+    if (!prefix) {
+      continue;
+    }
+    const claimedBy = seen.get(prefix);
+    if (claimedBy !== void 0) {
+      throw new Error(
+        `source-root logical-prefix collision: ${JSON.stringify(prefix)} claimed by both ${claimedBy} and ${physical}`
+      );
+    }
+    seen.set(prefix, physical);
+  }
+  return specs;
+}
+function artefact_roots() {
+  const roots = [];
+  if (_exists(_roots.LEGACY_SRC)) {
+    roots.push(_roots.LEGACY_SRC);
+  }
+  if (_exists(_roots.PACKAGES)) {
+    for (const pkg of _iterdirSorted(_roots.PACKAGES)) {
+      const sub = path.join(pkg, ".agent-src.uncondensed");
+      if (_isDir(sub)) {
+        roots.push(sub);
+      }
+    }
+  }
+  if (_isDir(_roots.SRC_AGENT)) {
+    roots.push(_roots.SRC_AGENT);
+  }
+  if (_isDir(_roots.SRC_SKILLS) || _isDir(_roots.SRC_RULES)) {
+    roots.push(_roots.SRC);
+  }
+  return roots;
+}
+function* iter_all_sources() {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [root, prefix] of _root_specs()) {
+    for (const p of _rglobSorted(root, "*")) {
+      if (!_isFile(p)) {
+        continue;
+      }
+      if (p !== root && !_isUnder(p, root)) {
+        continue;
+      }
+      const rel = prefix + _relativeToPosix(p, root);
+      if (seen.has(rel)) {
+        continue;
+      }
+      seen.add(rel);
+      yield [p, rel];
+    }
+  }
+  for (const [p, rel] of _iter_domains_commands()) {
+    if (seen.has(rel)) {
+      continue;
+    }
+    seen.add(rel);
+    yield [p, rel];
+  }
+}
+function resolve_logical(logical_rel) {
+  const rel = logical_rel.replaceAll("\\", "/").replace(/^\/+/, "");
+  for (const [root, prefix] of _root_specs()) {
+    let p;
+    if (prefix) {
+      if (!rel.startsWith(prefix)) {
+        continue;
+      }
+      p = path.join(root, rel.slice(prefix.length));
+    } else {
+      p = path.join(root, rel);
+    }
+    if (_exists(p)) {
+      return p;
+    }
+  }
+  if (rel.startsWith("commands/") && rel.endsWith(".md") && _isDir(_roots.SRC_DOMAINS)) {
+    const subpath = rel.slice("commands/".length, rel.length - ".md".length);
+    for (const packDir of _iterdirSorted(_roots.SRC_DOMAINS)) {
+      const cand = path.join(packDir, subpath, "command.md");
+      if (_isFile(cand)) {
+        return cand;
+      }
+    }
+  }
+  return null;
+}
+function strip_source_prefix(rel) {
+  const posix = rel.replaceAll("\\", "/");
+  if (posix.startsWith(_LEGACY_PREFIX)) {
+    return posix.slice(_LEGACY_PREFIX.length);
+  }
+  if (posix.startsWith("packages/")) {
+    const idx = posix.indexOf(_PACKAGE_SUFFIX);
+    if (idx !== -1) {
+      return posix.slice(idx + _PACKAGE_SUFFIX.length);
+    }
+  }
+  if (posix.startsWith(_SRC_SKILLS_PREFIX)) {
+    return `skills/${posix.slice(_SRC_SKILLS_PREFIX.length)}`;
+  }
+  if (posix.startsWith(_SRC_RULES_PREFIX)) {
+    return `rules/${posix.slice(_SRC_RULES_PREFIX.length)}`;
+  }
+  if (posix.startsWith(_SRC_DOMAINS_PREFIX) && posix.endsWith("/command.md")) {
+    const rest = posix.slice(_SRC_DOMAINS_PREFIX.length);
+    const parts = rest.split("/");
+    if (parts.length >= 3) {
+      return `commands/${parts.slice(1, -1).join("/")}.md`;
+    }
+  }
+  return null;
+}
+
+export {
+  artefact_roots,
+  iter_all_sources,
+  resolve_logical,
+  strip_source_prefix
+};