@event4u/agent-config 15.0.0 → 16.1.0

package/dist/cli-delegate/chunk-4E2W63DA.js

@@ -0,0 +1,335 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  write_atomic
+} from "./chunk-MWRD5YOH.js";
+
+// src/scripts/_lib/installed_tools.ts
+import * as fs 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(path) {
+  let text;
+  try {
+    text = require_read_text(path);
+  } catch {
+    return null;
+  }
+  const data = _parse_manual(text);
+  return _normalise_v2_shape(data);
+}
+function require_read_text(path) {
+  return fs.readFileSync(path, { 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(path, version, tools, options = {}) {
+  const rendered = _render(version, tools, { deploy_roots: options.deploy_roots ?? null });
+  return write_atomic(path, 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);
+}
+
+export {
+  SCHEMA_VERSIONS_SUPPORTED,
+  DEFAULT_DEPLOY_ROOTS,
+  manifest_path,
+  read_manifest,
+  write_manifest,
+  ScopeMismatchError,
+  upsert_tool
+};

package/dist/cli-delegate/chunk-5R7HOLAF.js

@@ -0,0 +1,99 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  atomicAppendLine
+} from "./chunk-6KM6ORRY.js";
+
+// src/install/txlog.ts
+import { createGzip } from "node:zlib";
+import { createReadStream, createWriteStream, existsSync, readFileSync, renameSync, statSync, unlinkSync } from "node:fs";
+import { pipeline } from "node:stream/promises";
+var ROTATION_MAX_BYTES = 10 * 1024 * 1024;
+var ROTATION_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var RECOVERY_DEPTH_CAP = 500;
+function appendTxLog(logPath, entry) {
+  if (shouldRotate(logPath)) {
+    rotateLogSync(logPath);
+  }
+  atomicAppendLine(logPath, JSON.stringify(entry));
+}
+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 shouldRotate(logPath, now = /* @__PURE__ */ new Date()) {
+  if (!existsSync(logPath)) {
+    return false;
+  }
+  let size = 0;
+  try {
+    size = statSync(logPath).size;
+  } catch {
+    return false;
+  }
+  if (size >= ROTATION_MAX_BYTES) {
+    return true;
+  }
+  const firstTs = readFirstTimestamp(logPath);
+  if (firstTs === null) {
+    return false;
+  }
+  return now.getTime() - firstTs >= ROTATION_MAX_AGE_MS;
+}
+function rotateLogSync(logPath) {
+  if (!existsSync(logPath)) {
+    return;
+  }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const rotated = logPath.replace(/\.jsonl$/, `.${stamp}.jsonl`);
+  renameSync(logPath, rotated);
+  void gzipInPlace(rotated).catch(() => {
+  });
+}
+async function gzipInPlace(source) {
+  const target = `${source}.gz`;
+  await pipeline(createReadStream(source), createGzip(), createWriteStream(target));
+  try {
+    unlinkSync(source);
+  } catch {
+  }
+}
+function readFirstTimestamp(logPath) {
+  try {
+    const raw = readFileSync(logPath, "utf8");
+    const firstLine = raw.split("\n", 1)[0] ?? "";
+    const parsed = tryParseEntry(firstLine);
+    if (parsed === null) return null;
+    const t = Date.parse(parsed.ts);
+    return Number.isFinite(t) ? t : null;
+  } catch {
+    return null;
+  }
+}
+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;
+  }
+}
+
+export {
+  appendTxLog,
+  readRecentEntries
+};

package/dist/cli-delegate/{chunk-IVBPRCQO.js → chunk-6KFEC3G7.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-MCJYCQPF.js";
 import {
   resolve_project_root
-} from "./chunk-2XY7ILBT.js";
+} from "./chunk-FC75PGJE.js";
 
 // src/scripts/_cli/cmd_migrate.ts
 import { spawnSync } from "node:child_process";