@event4u/agent-config 9.9.0 → 9.11.0

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

@@ -0,0 +1,47 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};

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

@@ -0,0 +1,35 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/package_root.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+var PACKAGE_NAME = "@event4u/agent-config";
+var MAX_ASCENT = 16;
+function resolvePackageRoot(fromUrlOrPath, legacyHops = 3) {
+  const start = fromUrlOrPath.startsWith("file:") ? fileURLToPath(fromUrlOrPath) : fromUrlOrPath;
+  const startDir = path.dirname(start);
+  let dir = startDir;
+  for (let i = 0; i < MAX_ASCENT; i++) {
+    const manifest = path.join(dir, "package.json");
+    if (fs.existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(manifest, "utf8"));
+        if (parsed.name === PACKAGE_NAME) {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return path.resolve(startDir, ...Array.from({ length: legacyHops }, () => ".."));
+}
+
+export {
+  resolvePackageRoot
+};

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

@@ -0,0 +1,169 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/user_global_paths.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var _PARTIAL_SUFFIX = ".event4u-partial-";
+var EVENT4U_HOME_ENV = "EVENT4U_CONFIG_HOME";
+var DEFAULT_EVENT4U_ROOT_RELATIVE = path.join(".event4u", "agent-config");
+var LEGACY_XDG_ROOT_RELATIVE = path.join(".config", "agent-config");
+function expanduser(p) {
+  if (p === "~") {
+    return os.homedir();
+  }
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}
+function is_absolute_like_python(p) {
+  if (process.platform === "win32") {
+    return /^[a-zA-Z]:[\\/]/.test(p) || /^([\\/]{2})[^\\/]+[\\/][^\\/]+/.test(p);
+  }
+  return p.startsWith("/");
+}
+function event4u_root(env) {
+  const env_map = env ?? process.env;
+  const override = env_map[EVENT4U_HOME_ENV];
+  if (override) {
+    return expanduser(override);
+  }
+  return path.join(os.homedir(), DEFAULT_EVENT4U_ROOT_RELATIVE);
+}
+function legacy_xdg_root() {
+  return path.join(os.homedir(), LEGACY_XDG_ROOT_RELATIVE);
+}
+function resolve_with_fallback(relative_name, options = {}) {
+  if (is_absolute_like_python(relative_name)) {
+    throw new Error(
+      `resolve_with_fallback expects a relative path, got '${relative_name}'`
+    );
+  }
+  const new_path = path.join(event4u_root(options.env ?? null), relative_name);
+  if (fs.existsSync(new_path)) {
+    return new_path;
+  }
+  const legacy_path = path.join(legacy_xdg_root(), relative_name);
+  if (fs.existsSync(legacy_path)) {
+    return legacy_path;
+  }
+  return null;
+}
+function write_target(relative_name, options = {}) {
+  if (is_absolute_like_python(relative_name)) {
+    throw new Error(`write_target expects a relative path, got '${relative_name}'`);
+  }
+  return path.join(event4u_root(options.env ?? null), relative_name);
+}
+var MIGRATION_BREADCRUMB_NAME = "MIGRATED.md";
+var _BREADCRUMB_TEMPLATE = `# Migrated to \`~/.event4u/agent-config/\`
+
+This directory (\`~/.config/agent-config/\`) is the **legacy** location
+for \`event4u/agent-config\` user-global state. As of v2.4 the canonical
+location is \`~/.event4u/agent-config/\`.
+
+The migration shim has already copied your settings, keys, lockfiles,
+and overrides into the new namespace. File modes (0600 on keys) were
+preserved. Loaders prefer the new path but still read from this tree
+as a fallback, so removing it is safe **once you've confirmed** the
+new location is working.
+
+## To clean up
+
+\`\`\`bash
+rm -rf ~/.config/agent-config
+\`\`\`
+
+## Why the move
+
+\`~/.config/\` is a generic XDG-shaped directory shared by many tools.
+\`~/.event4u/agent-config/\` is vendor-namespaced and avoids collisions
+with unrelated CLIs. See
+\`agents/roadmaps/road-to-event4u-namespace-and-claude-desktop.md\` for
+the full rationale.
+`;
+function migrate_legacy_namespace(options = {}) {
+  const legacy_root = options.legacy_root_override ?? legacy_xdg_root();
+  const new_root = event4u_root(options.env ?? null);
+  let legacy_stat;
+  try {
+    legacy_stat = fs.statSync(legacy_root);
+  } catch {
+    return false;
+  }
+  if (!legacy_stat.isDirectory()) {
+    return false;
+  }
+  const legacy_entries = fs.readdirSync(legacy_root).filter((name) => name !== MIGRATION_BREADCRUMB_NAME);
+  if (legacy_entries.length === 0) {
+    return false;
+  }
+  const new_has_content = fs.existsSync(new_root) && fs.readdirSync(new_root).some((name) => !_is_partial_name(name));
+  if (new_has_content) {
+    _ensure_breadcrumb(legacy_root);
+    return false;
+  }
+  fs.mkdirSync(new_root, { recursive: true });
+  _purge_partial_entries(new_root);
+  for (const name of legacy_entries) {
+    const entry = path.join(legacy_root, name);
+    const target = path.join(new_root, name);
+    if (fs.existsSync(target)) {
+      continue;
+    }
+    const staging = path.join(new_root, `${name}${_PARTIAL_SUFFIX}${process.pid}`);
+    if (fs.existsSync(staging)) {
+      _remove_path(staging);
+    }
+    if (fs.statSync(entry).isDirectory()) {
+      fs.cpSync(entry, staging, { recursive: true, preserveTimestamps: true });
+    } else {
+      fs.copyFileSync(entry, staging);
+      const src_stat = fs.statSync(entry);
+      fs.chmodSync(staging, src_stat.mode & 4095);
+      fs.utimesSync(staging, src_stat.atime, src_stat.mtime);
+    }
+    fs.renameSync(staging, target);
+  }
+  _ensure_breadcrumb(legacy_root);
+  return true;
+}
+function _is_partial_name(name) {
+  return name.includes(_PARTIAL_SUFFIX);
+}
+function _purge_partial_entries(new_root) {
+  for (const name of fs.readdirSync(new_root)) {
+    if (_is_partial_name(name)) {
+      _remove_path(path.join(new_root, name));
+    }
+  }
+}
+function _remove_path(p) {
+  let st = null;
+  try {
+    st = fs.lstatSync(p);
+  } catch {
+    return;
+  }
+  if (st.isDirectory() && !st.isSymbolicLink()) {
+    fs.rmSync(p, { recursive: true });
+  } else {
+    fs.rmSync(p, { force: true });
+  }
+}
+function _ensure_breadcrumb(legacy_root) {
+  const breadcrumb = path.join(legacy_root, MIGRATION_BREADCRUMB_NAME);
+  if (fs.existsSync(breadcrumb)) {
+    return;
+  }
+  fs.writeFileSync(breadcrumb, _BREADCRUMB_TEMPLATE, "utf-8");
+}
+
+export {
+  event4u_root,
+  legacy_xdg_root,
+  resolve_with_fallback,
+  write_target,
+  migrate_legacy_namespace
+};

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

@@ -0,0 +1,26 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/install/detect.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+function detectToolPresence(root) {
+  return {
+    augment: isDir(join(root, ".augment")),
+    claude: isDir(join(root, ".claude")),
+    cursor: isDir(join(root, ".cursor")),
+    cline: isDir(join(root, ".clinerules")),
+    windsurf: isDir(join(root, ".windsurf")) || existsSync(join(root, ".windsurfrules")),
+    agentsMd: existsSync(join(root, "AGENTS.md"))
+  };
+}
+function isDir(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export {
+  detectToolPresence
+};