@event4u/agent-config 9.10.0 → 9.12.0

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

@@ -0,0 +1,502 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  resolve_with_fallback,
+  write_target
+} from "./chunk-NDJLNC6Q.js";
+
+// src/scripts/_lib/agent_settings.ts
+import { createRequire } from "node:module";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var _require = createRequire(import.meta.url);
+var Logger = class {
+  name = "scripts._lib.agent_settings";
+  records = [];
+  info(message, ...args) {
+    this.records.push({ level: "INFO", message: _format(message, args) });
+  }
+  warning(message, ...args) {
+    this.records.push({ level: "WARNING", message: _format(message, args) });
+  }
+};
+function _format(template, args) {
+  let i = 0;
+  return template.replace(/%s/g, () => {
+    if (i < args.length) {
+      const value = args[i];
+      i += 1;
+      return _pystr(value);
+    }
+    return "%s";
+  });
+}
+function _pystr(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => _pyrepr(v)).join(", ")}]`;
+  }
+  return String(value);
+}
+function _pyrepr(value) {
+  if (typeof value === "string") {
+    return `'${value}'`;
+  }
+  return String(value);
+}
+var logger = new Logger();
+var DEFAULT_PROJECT_FILE = ".agent-settings.yml";
+var LOCAL_PROJECT_FILE = ".agent-settings.local.yml";
+var LOCAL_PROJECT_SUBDIR = ["agents", "settings"];
+function _local_settings_path(project_root) {
+  return path.join(project_root, ...LOCAL_PROJECT_SUBDIR, LOCAL_PROJECT_FILE);
+}
+function _canonical_settings_path(project_root) {
+  return path.join(project_root, ...LOCAL_PROJECT_SUBDIR, DEFAULT_PROJECT_FILE);
+}
+function project_settings_path(project_root) {
+  const canonical = _canonical_settings_path(project_root);
+  if (_exists(canonical)) {
+    return canonical;
+  }
+  const legacy = path.join(project_root, DEFAULT_PROJECT_FILE);
+  if (_exists(legacy)) {
+    return legacy;
+  }
+  return canonical;
+}
+var USER_GLOBAL_FILENAME = "agent-settings.yml";
+function DEFAULT_USER_GLOBAL_FILE() {
+  return write_target(USER_GLOBAL_FILENAME);
+}
+function _resolve_user_global_file() {
+  const found = resolve_with_fallback(USER_GLOBAL_FILENAME);
+  if (found !== null) {
+    return found;
+  }
+  return DEFAULT_USER_GLOBAL_FILE();
+}
+var MERGEABLE_KEYS = [
+  "name",
+  "ide",
+  "rule_loading_tier",
+  "memory.cadence",
+  "personal.bot_icon",
+  "personal.autonomy",
+  "telegraph.speak_scope",
+  // Knowledge-card global cross-project sharing is a USER-GLOBAL setting
+  // (ADR-100 / road-to-structure-grounding-v2). Whitelisted so the
+  // ~/.event4u/agent-config/agent-settings.yml values are honoured.
+  "knowledge.global_sharing.enabled",
+  "knowledge.global_sharing.allowed_tiers",
+  "knowledge.global_sharing.redaction.enabled",
+  "knowledge.global_sharing.redaction.halt_on_trigger",
+  "knowledge.global_sharing.auto_promote_threshold",
+  "knowledge.global_sharing.freshness.hypothesis_after_days",
+  "knowledge.global_sharing.freshness.stale_after_days"
+];
+var _DEFAULTS = {};
+var ANCHOR_AGENT_SETTINGS = "agent-settings";
+var ANCHOR_AGENTS_DIR = "agents-dir";
+var ANCHOR_GIT = "git";
+var _AGENTS_DIR_MARKERS = [
+  "roadmaps",
+  "settings/.ai-council.yml",
+  "roadmaps-progress.md",
+  // `overrides/` is the guaranteed minimal-consumer surface (ADR-020).
+  // Replaced the retired `.event4u-bridge.yml` marker (ADR-020 amendment
+  // 2026-07-13) so a bare consumer `agents/` dir stays anchorable.
+  "overrides"
+];
+var _LEGACY_ANCHOR_ENV = "AGENT_CONFIG_LEGACY_ANCHOR";
+function _exists(p) {
+  try {
+    fs.lstatSync(p);
+    fs.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _is_dir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _is_file(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _resolve(p) {
+  const absolute = path.resolve(p);
+  try {
+    return fs.realpathSync(absolute);
+  } catch {
+    return absolute;
+  }
+}
+function _ancestor_chain(start) {
+  const chain = [];
+  let cursor = start;
+  for (; ; ) {
+    chain.push(cursor);
+    const parent = path.dirname(cursor);
+    if (parent === cursor) {
+      break;
+    }
+    cursor = parent;
+  }
+  return chain;
+}
+function _boundary_anchor_at(dir) {
+  const agents_dir = path.join(dir, "agents");
+  if (_is_dir(agents_dir)) {
+    for (const marker of _AGENTS_DIR_MARKERS) {
+      if (_exists(path.join(agents_dir, marker))) {
+        return ANCHOR_AGENTS_DIR;
+      }
+    }
+  }
+  if (_exists(path.join(dir, ".git"))) {
+    return ANCHOR_GIT;
+  }
+  return null;
+}
+function find_project_root_with_anchor(start) {
+  const current = _exists(start) ? _resolve(start) : start;
+  const legacy = process.env[_LEGACY_ANCHOR_ENV] === "1";
+  const chain = _ancestor_chain(current);
+  if (legacy) {
+    for (const candidate of chain) {
+      if (_exists(path.join(candidate, ".git"))) {
+        return [candidate, ANCHOR_GIT];
+      }
+    }
+    return null;
+  }
+  for (const candidate of chain) {
+    const anchor = _boundary_anchor_at(candidate);
+    if (anchor !== null) {
+      return [candidate, anchor];
+    }
+  }
+  let outermost = null;
+  for (const candidate of chain) {
+    if (_exists(path.join(candidate, DEFAULT_PROJECT_FILE))) {
+      outermost = candidate;
+    }
+  }
+  if (outermost !== null) {
+    return [outermost, ANCHOR_AGENT_SETTINGS];
+  }
+  return null;
+}
+function find_project_root(start) {
+  const result = find_project_root_with_anchor(start);
+  return result !== null ? result[0] : null;
+}
+function find_project_root_with_trace(start) {
+  const trace = [];
+  const current = _exists(start) ? _resolve(start) : start;
+  const legacy = process.env[_LEGACY_ANCHOR_ENV] === "1";
+  const chain = _ancestor_chain(current);
+  if (legacy) {
+    for (const candidate of chain) {
+      const hit = _exists(path.join(candidate, ".git"));
+      trace.push({
+        ancestor: candidate,
+        pass: "boundary",
+        hit: hit ? ANCHOR_GIT : null,
+        reason: hit ? "legacy: .git found" : "legacy: no .git"
+      });
+      if (hit) {
+        return [candidate, ANCHOR_GIT, trace];
+      }
+    }
+    return [null, null, trace];
+  }
+  for (const candidate of chain) {
+    const agents_dir = path.join(candidate, "agents");
+    if (_is_dir(agents_dir)) {
+      for (const marker of _AGENTS_DIR_MARKERS) {
+        if (_exists(path.join(agents_dir, marker))) {
+          trace.push({
+            ancestor: candidate,
+            pass: "boundary",
+            hit: ANCHOR_AGENTS_DIR,
+            reason: `agents/ has ${marker}`
+          });
+          return [candidate, ANCHOR_AGENTS_DIR, trace];
+        }
+      }
+    }
+    if (_exists(path.join(candidate, ".git"))) {
+      trace.push({
+        ancestor: candidate,
+        pass: "boundary",
+        hit: ANCHOR_GIT,
+        reason: ".git present"
+      });
+      return [candidate, ANCHOR_GIT, trace];
+    }
+    trace.push({
+      ancestor: candidate,
+      pass: "boundary",
+      hit: null,
+      reason: "no agents/ marker, no .git"
+    });
+  }
+  let outermost = null;
+  for (const candidate of chain) {
+    const present = _exists(path.join(candidate, DEFAULT_PROJECT_FILE));
+    trace.push({
+      ancestor: candidate,
+      pass: "layer",
+      hit: present ? ANCHOR_AGENT_SETTINGS : null,
+      reason: present ? `${DEFAULT_PROJECT_FILE} present` : `no ${DEFAULT_PROJECT_FILE}`
+    });
+    if (present) {
+      outermost = candidate;
+    }
+  }
+  if (outermost !== null) {
+    return [outermost, ANCHOR_AGENT_SETTINGS, trace];
+  }
+  return [null, null, trace];
+}
+var ORIGIN_ROOT_FLAG = "root-flag";
+var ORIGIN_EXPLICIT = "explicit";
+var ORIGIN_ENV = "env";
+var ORIGIN_CWD_FALLBACK = "cwd-fallback";
+var PROJECT_ROOT_ENV = "AGENT_CONFIG_PROJECT_ROOT";
+var ROOT_OVERRIDE_ENV = "AGENT_CONFIG_ROOT_OVERRIDE";
+var ProjectRootError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProjectRootError";
+  }
+};
+function _validate_root_path(p, origin_label) {
+  const resolved = _expanduser(p);
+  if (!_exists(resolved)) {
+    throw new ProjectRootError(
+      `${origin_label} points to a path that does not exist: ${resolved}`
+    );
+  }
+  if (!_is_dir(resolved)) {
+    throw new ProjectRootError(
+      `${origin_label} points to a non-directory: ${resolved}`
+    );
+  }
+  return _resolve(resolved);
+}
+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 resolve_project_root(arg, options = {}) {
+  const cwd = options.cwd ?? null;
+  if (process.env[ROOT_OVERRIDE_ENV] === "1") {
+    const env_value2 = process.env[PROJECT_ROOT_ENV];
+    if (env_value2) {
+      return [_validate_root_path(env_value2, "--root"), ORIGIN_ROOT_FLAG];
+    }
+  }
+  if (arg !== null && String(arg) !== "") {
+    return [_validate_root_path(arg, "--project"), ORIGIN_EXPLICIT];
+  }
+  const env_value = process.env[PROJECT_ROOT_ENV];
+  if (env_value) {
+    return [_validate_root_path(env_value, PROJECT_ROOT_ENV), ORIGIN_ENV];
+  }
+  const start = _resolve(cwd ?? process.cwd());
+  const walked = find_project_root_with_anchor(start);
+  if (walked !== null) {
+    return walked;
+  }
+  return [start, ORIGIN_CWD_FALLBACK];
+}
+function _resolve_cascade_paths(cwd, project_path) {
+  if (cwd === null) {
+    const legacy = project_path ? project_path : DEFAULT_PROJECT_FILE;
+    const parent = path.dirname(legacy);
+    return [legacy, _canonical_settings_path(parent), _local_settings_path(parent)];
+  }
+  const root = find_project_root(cwd);
+  if (root === null) {
+    const legacy = project_path ? project_path : DEFAULT_PROJECT_FILE;
+    const parent = path.dirname(legacy);
+    return [legacy, _canonical_settings_path(parent), _local_settings_path(parent)];
+  }
+  const cwd_resolved = _resolve(cwd);
+  const chain = [];
+  let cursor = cwd_resolved;
+  for (; ; ) {
+    chain.push(cursor);
+    if (cursor === root) {
+      break;
+    }
+    const parent = path.dirname(cursor);
+    if (parent === cursor) {
+      break;
+    }
+    cursor = parent;
+  }
+  chain.reverse();
+  return [
+    ...chain.map((d) => path.join(d, DEFAULT_PROJECT_FILE)),
+    _canonical_settings_path(root),
+    _local_settings_path(root)
+  ];
+}
+function load_agent_settings(options = {}) {
+  const project_path = options.project_path ?? null;
+  const user_global_path = options.user_global_path ?? null;
+  const verbose = options.verbose ?? false;
+  const cwd = options.cwd ?? null;
+  const user_global_raw = _read_yaml(user_global_path ? user_global_path : _resolve_user_global_file()) ?? {};
+  const [user_global_filtered, ignored] = _filter_whitelist(user_global_raw, MERGEABLE_KEYS);
+  if (verbose && ignored.length > 0) {
+    logger.info(
+      "agent_settings: ignored non-whitelisted user-global keys: %s",
+      [...ignored].sort()
+    );
+  }
+  const cascade = _resolve_cascade_paths(cwd, project_path);
+  const merged = _deep_copy_defaults(_DEFAULTS);
+  _deep_merge(merged, user_global_filtered);
+  for (const p of cascade) {
+    const layer = _read_yaml(p) ?? {};
+    if (Object.keys(layer).length > 0) {
+      _deep_merge(merged, layer);
+    }
+  }
+  return merged;
+}
+function _read_yaml(p) {
+  if (!_is_file(p)) {
+    return null;
+  }
+  let YAML;
+  try {
+    YAML = _require("yaml");
+  } catch {
+    return null;
+  }
+  let data;
+  try {
+    const text = fs.readFileSync(p, "utf-8");
+    data = YAML.parse(text, { version: "1.1" });
+    if (data === null || data === void 0) {
+      data = {};
+    }
+  } catch (err) {
+    if (_is_yaml_error(err) || _is_os_error(err)) {
+      logger.warning("agent_settings: unreadable or malformed YAML at %s", p);
+      return null;
+    }
+    throw err;
+  }
+  return _is_plain_dict(data) ? data : null;
+}
+function _is_yaml_error(err) {
+  if (err instanceof Error) {
+    return err.name.startsWith("YAML") || err.name === "Error" || err.name === "TypeError";
+  }
+  return false;
+}
+function _is_os_error(err) {
+  return typeof err === "object" && err !== null && "code" in err && typeof err.code === "string";
+}
+function _filter_whitelist(raw, allowed) {
+  const filtered = {};
+  for (const dotted of allowed) {
+    const value = _get_dotted(raw, dotted);
+    if (value !== null && value !== void 0) {
+      _set_dotted(filtered, dotted, value);
+    }
+  }
+  const ignored = _leaf_paths(raw).filter((p) => !allowed.includes(p));
+  return [filtered, ignored];
+}
+function _get_dotted(data, dotted) {
+  let cursor = data;
+  for (const part of dotted.split(".")) {
+    if (!_is_plain_dict(cursor) || !(part in cursor)) {
+      return null;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function _set_dotted(target, dotted, value) {
+  const parts = dotted.split(".");
+  let cursor = target;
+  for (const part of parts.slice(0, -1)) {
+    let nxt = cursor[part];
+    if (nxt === void 0) {
+      nxt = {};
+      cursor[part] = nxt;
+    }
+    if (!_is_plain_dict(nxt)) {
+      nxt = {};
+      cursor[part] = nxt;
+    }
+    cursor = nxt;
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+function _leaf_paths(data, prefix = "") {
+  const paths = [];
+  for (const [key, value] of Object.entries(data)) {
+    const p = prefix ? `${prefix}.${key}` : key;
+    if (_is_plain_dict(value) && Object.keys(value).length > 0) {
+      paths.push(..._leaf_paths(value, p));
+    } else {
+      paths.push(p);
+    }
+  }
+  return paths;
+}
+function _deep_merge(dst, src) {
+  for (const [key, value] of Object.entries(src)) {
+    if (_is_plain_dict(value) && _is_plain_dict(dst[key])) {
+      _deep_merge(dst[key], value);
+    } else {
+      dst[key] = value;
+    }
+  }
+}
+function _deep_copy_defaults(src) {
+  const out = {};
+  _deep_merge(out, src);
+  return out;
+}
+function _is_plain_dict(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  logger,
+  DEFAULT_PROJECT_FILE,
+  LOCAL_PROJECT_FILE,
+  LOCAL_PROJECT_SUBDIR,
+  project_settings_path,
+  find_project_root_with_anchor,
+  find_project_root,
+  find_project_root_with_trace,
+  PROJECT_ROOT_ENV,
+  ROOT_OVERRIDE_ENV,
+  ProjectRootError,
+  resolve_project_root,
+  load_agent_settings
+};

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

@@ -0,0 +1,179 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  detectToolPresence
+} from "./chunk-OMIVVCG2.js";
+import {
+  buildInstallPlan,
+  sha256File
+} from "./chunk-523HCFYO.js";
+
+// src/install/preflight.ts
+import { accessSync, constants, existsSync as existsSync2, statSync } from "node:fs";
+import * as fs from "node:fs";
+import { dirname } from "node:path";
+
+// src/install/conflict.ts
+import { existsSync } from "node:fs";
+function isJsonTarget(entry) {
+  return entry.kind === "deployed" && entry.path.endsWith(".json");
+}
+function computeConflicts(plan) {
+  if (plan.policy.force) return [];
+  const out = [];
+  for (const entries of Object.values(plan.filesByTool)) {
+    for (const entry of entries) {
+      if (entry.kind === "bridge") continue;
+      if (entry.sha256 === null) continue;
+      if (!existsSync(entry.path)) continue;
+      if (plan.policy.knownPaths.has(entry.path)) continue;
+      const onDisk = sha256File(entry.path);
+      if (onDisk === entry.sha256) continue;
+      out.push({
+        path: entry.path,
+        kind: entry.kind,
+        plannedSha256: entry.sha256,
+        existingSha256: onDisk,
+        mergeable: isJsonTarget(entry)
+      });
+    }
+  }
+  return out;
+}
+
+// src/install/preflight.ts
+var DEFAULT_DISK_FLOOR_BYTES = 50 * 1024 * 1024;
+function nearestExistingAncestor(p) {
+  let cur = p;
+  while (!existsSync2(cur)) {
+    const parent = dirname(cur);
+    if (parent === cur) return cur;
+    cur = parent;
+  }
+  return cur;
+}
+function checkPermissions(inputs) {
+  const out = [];
+  const roots = /* @__PURE__ */ new Set([inputs.root, ...inputs.sources.map((s) => s.destDir)]);
+  for (const root of roots) {
+    const probe = nearestExistingAncestor(root);
+    try {
+      accessSync(probe, constants.W_OK);
+    } catch {
+      out.push({
+        id: "permissions",
+        severity: "blocking",
+        path: root,
+        message: `target root is not writable (nearest existing ancestor: ${probe})`,
+        remedy: `fix permissions on ${probe} or choose a different target`
+      });
+    }
+    if (existsSync2(root)) {
+      try {
+        if (!statSync(root).isDirectory()) {
+          out.push({
+            id: "permissions",
+            severity: "blocking",
+            path: root,
+            message: "target root exists but is not a directory",
+            remedy: `move or remove the file at ${root}`
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  return out;
+}
+function checkDiskSpace(inputs, opts = {}) {
+  const floor = opts.diskFloorBytes ?? DEFAULT_DISK_FLOOR_BYTES;
+  const probe = nearestExistingAncestor(inputs.root);
+  const statfsSync2 = fs.statfsSync;
+  if (typeof statfsSync2 !== "function") {
+    return [
+      {
+        id: "disk-space",
+        severity: "info",
+        path: probe,
+        message: "free-disk check unavailable on this Node runtime",
+        remedy: ""
+      }
+    ];
+  }
+  try {
+    const st = statfsSync2(probe);
+    const free = st.bavail * st.bsize;
+    if (free < floor) {
+      return [
+        {
+          id: "disk-space",
+          severity: "blocking",
+          path: probe,
+          message: `free disk ${free} B is below the ${floor} B floor`,
+          remedy: "free disk space on the target volume, then re-run"
+        }
+      ];
+    }
+  } catch {
+    return [
+      {
+        id: "disk-space",
+        severity: "info",
+        path: probe,
+        message: "free-disk probe failed (statfs error) \u2014 check skipped",
+        remedy: ""
+      }
+    ];
+  }
+  return [];
+}
+function checkConflicts(inputs) {
+  const plan = buildInstallPlan(inputs);
+  const conflicts = computeConflicts(plan);
+  return conflicts.map((c) => ({
+    id: "conflicts",
+    severity: "warning",
+    path: c.path,
+    message: `existing file conflicts with planned ${c.kind} content`,
+    remedy: "resolve interactively, or pass --force to overwrite"
+  }));
+}
+function checkHostDetection(inputs) {
+  const presence = detectToolPresence(inputs.root);
+  const detected = Object.entries(presence).filter(([, v]) => v === true).map(([k]) => k);
+  if (detected.length === 0) {
+    return [
+      {
+        id: "host-detection",
+        severity: "info",
+        path: inputs.root,
+        message: "no AI-tool directories detected at the target root",
+        remedy: "expected for a first global install; verify the target path is right"
+      }
+    ];
+  }
+  return [
+    {
+      id: "host-detection",
+      severity: "info",
+      path: inputs.root,
+      message: `detected AI-tool surfaces: ${detected.join(", ")}`,
+      remedy: ""
+    }
+  ];
+}
+function runPreflight(inputs, opts = {}) {
+  return [
+    ...checkPermissions(inputs),
+    ...checkDiskSpace(inputs, opts),
+    ...checkConflicts(inputs),
+    ...checkHostDetection(inputs)
+  ];
+}
+function hasBlockingFinding(findings) {
+  return findings.some((f) => f.severity === "blocking");
+}
+
+export {
+  runPreflight,
+  hasBlockingFinding
+};