@event4u/agent-config 9.9.0 → 9.11.0

package/dist/cli-delegate/cmd_validate.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  PROJECT_BRIDGE_MARKERS,
+  USER_SCOPE_PATHS
+} from "./chunk-YMFO6FDN.js";
+import "./chunk-XX6TOPD7.js";
+import {
+  manifest_path,
+  read_manifest
+} from "./chunk-IR7P7JWA.js";
+import {
+  current_package_version
+} from "./chunk-GRRPEPRN.js";
+import "./chunk-7DSAMZFU.js";
+import {
+  resolve_project_root
+} from "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import "./chunk-MCJYCQPF.js";
+import "./chunk-OY53J6II.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_validate.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var _HERE = fileURLToPath(import.meta.url);
+var ArgparseExit = class extends Error {
+  constructor(code) {
+    super(`argparse-exit-${code}`);
+    this.code = code;
+  }
+  code;
+};
+function pyPathStr(p) {
+  if (p === "") return ".";
+  const isAbs = p.startsWith("/");
+  const parts = p.split("/").filter((seg) => seg !== "");
+  const joined = parts.join("/");
+  if (isAbs) {
+    return "/" + joined;
+  }
+  return joined === "" ? "." : joined;
+}
+function expanduser(p) {
+  let expanded;
+  if (p === "~") {
+    expanded = os.homedir();
+  } else if (p.startsWith("~/") || p.startsWith("~\\")) {
+    expanded = path.join(os.homedir(), p.slice(2));
+  } else {
+    expanded = p;
+  }
+  return pyPathStr(expanded);
+}
+function pathExists(p) {
+  try {
+    fs.statSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function print(line = "") {
+  process.stdout.write(line + "\n");
+}
+function pyRepr(value) {
+  if (value === null || value === void 0) return "None";
+  if (typeof value === "boolean") return value ? "True" : "False";
+  if (typeof value === "number") return String(value);
+  if (typeof value === "string") {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    return `'${escaped}'`;
+  }
+  return String(value);
+}
+function _resolve_marker(project_root, bridge_marker, scope) {
+  if (scope === "global") {
+    return expanduser(bridge_marker);
+  }
+  const candidate = bridge_marker;
+  if (path.isAbsolute(candidate)) {
+    return pyPathStr(candidate);
+  }
+  return pyPathStr(path.join(project_root, candidate));
+}
+function _counterpart_path(project_root, tool_id, scope) {
+  if (scope === "project") {
+    const anchor = USER_SCOPE_PATHS[tool_id];
+    return anchor ? expanduser(anchor) : null;
+  }
+  const rel = PROJECT_BRIDGE_MARKERS[tool_id];
+  return rel ? pyPathStr(path.join(project_root, rel)) : null;
+}
+function _check_entry(project_root, entry) {
+  const name = String(entry["name"] ?? "").trim();
+  const scope = String(entry["scope"] ?? "").trim();
+  const bridge_marker = String(entry["bridge_marker"] ?? "").trim();
+  const issues = [];
+  if (!name || scope !== "project" && scope !== "global" || !bridge_marker) {
+    issues.push({
+      kind: "manifest_corrupt",
+      name: name || "<unknown>",
+      detail: `entry missing required fields (scope=${pyRepr(scope)}, marker=${pyRepr(bridge_marker)})`
+    });
+    return issues;
+  }
+  const target = _resolve_marker(project_root, bridge_marker, scope);
+  if (!pathExists(target)) {
+    const counterpart = _counterpart_path(project_root, name, scope);
+    if (counterpart !== null && pathExists(counterpart)) {
+      const other_scope = scope === "project" ? "global" : "project";
+      issues.push({
+        kind: "scope_divergence",
+        name,
+        detail: `recorded scope=${scope} (${target}) is missing, but counterpart at scope=${other_scope} (${counterpart}) exists`
+      });
+    } else {
+      issues.push({
+        kind: "marker_missing",
+        name,
+        detail: `bridge_marker not found: ${target}`
+      });
+    }
+  }
+  return issues;
+}
+function _version_drift(manifest_version, current_version) {
+  if (!manifest_version || !current_version) {
+    return null;
+  }
+  if (manifest_version !== current_version) {
+    return {
+      kind: "version_drift",
+      name: "<manifest>",
+      detail: `manifest recorded agent_config_version=${manifest_version}; currently installed package is ${current_version}`
+    };
+  }
+  return null;
+}
+var PROG = "agent-config validate";
+var USAGE = `usage: ${PROG} [-h] [--project PROJECT] [--quiet]
+                             [--skip-version-check]
+`;
+function _argError(msg) {
+  process.stderr.write(USAGE);
+  process.stderr.write(`${PROG}: error: ${msg}
+`);
+  throw new ArgparseExit(2);
+}
+function _parse(argv) {
+  const opts = { project: null, quiet: false, skip_version_check: false };
+  const positionals = [];
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") {
+      process.stdout.write(USAGE);
+      throw new ArgparseExit(0);
+    }
+    const eq = a.startsWith("--") ? a.indexOf("=") : -1;
+    const flag = eq >= 0 ? a.slice(0, eq) : a;
+    const inlineVal = eq >= 0 ? a.slice(eq + 1) : null;
+    if (flag === "--quiet") {
+      if (inlineVal !== null) {
+        _argError(`argument --quiet: ignored explicit argument '${inlineVal}'`);
+      }
+      opts.quiet = true;
+      i += 1;
+      continue;
+    }
+    if (flag === "--skip-version-check") {
+      if (inlineVal !== null) {
+        _argError(`argument --skip-version-check: ignored explicit argument '${inlineVal}'`);
+      }
+      opts.skip_version_check = true;
+      i += 1;
+      continue;
+    }
+    if (flag === "--project") {
+      let value;
+      if (inlineVal !== null) {
+        value = inlineVal;
+      } else {
+        if (i + 1 >= argv.length) {
+          _argError("argument --project: expected one argument");
+        }
+        value = argv[i + 1];
+        i += 1;
+      }
+      opts.project = value;
+      i += 1;
+      continue;
+    }
+    if (a.startsWith("-") && a !== "-") {
+      _argError(`unrecognized arguments: ${a}`);
+    }
+    positionals.push(a);
+    i += 1;
+  }
+  if (positionals.length > 0) {
+    _argError(`unrecognized arguments: ${positionals.join(" ")}`);
+  }
+  return opts;
+}
+function _emit(quiet, msg) {
+  if (!quiet) {
+    print(msg);
+  }
+}
+function _format(issue) {
+  return `  \u274C  [${issue["kind"]}] ${issue["name"]}: ${issue["detail"]}`;
+}
+function main(argv) {
+  const opts = _parse(argv);
+  const arg = opts.project || process.env["PROJECT_ROOT"] || null;
+  const [project_root] = resolve_project_root(arg);
+  const manifest = manifest_path(project_root);
+  const data = read_manifest(manifest);
+  if (data === null) {
+    _emit(opts.quiet, `\u274C  No manifest found at ${manifest}`);
+    _emit(opts.quiet, "    Run `./agent-config init --tools=<id>` to create one.");
+    _emit(opts.quiet, "    Diagnose: `./agent-config doctor --check manifest-integrity`");
+    return 1;
+  }
+  const entries = data["tools"] || [];
+  const issues = [];
+  for (const entry of entries) {
+    for (const issue of _check_entry(project_root, entry)) {
+      issues.push(issue);
+    }
+  }
+  if (!opts.skip_version_check) {
+    const manifest_version = String(data["agent_config_version"] ?? "").trim();
+    const current_version = current_package_version();
+    const drift = _version_drift(manifest_version, current_version);
+    if (drift !== null) {
+      issues.push(drift);
+    }
+  }
+  _emit(opts.quiet, `Manifest:  ${manifest}`);
+  _emit(opts.quiet, `Tools:     ${entries.length} entries`);
+  if (issues.length === 0) {
+    _emit(opts.quiet, "\u2705  No drift detected.");
+    return 0;
+  }
+  _emit(opts.quiet, `Drift:     ${issues.length} issue(s)`);
+  for (const issue of issues) {
+    _emit(opts.quiet, _format(issue));
+  }
+  _emit(opts.quiet, "");
+  _emit(opts.quiet, "Run `./agent-config sync` to replay missing bridges, or");
+  _emit(opts.quiet, "`./agent-config init --tools=<id> --force` to refresh the manifest.");
+  const kinds = new Set(issues.map((issue) => issue["kind"]));
+  if (kinds.has("version_drift")) {
+    _emit(opts.quiet, "Diagnose:  `./agent-config doctor --check lockfile-freshness`");
+  }
+  if (kinds.has("marker_missing") || kinds.has("scope_divergence")) {
+    _emit(opts.quiet, "Diagnose:  `./agent-config doctor --check bridge-drift`");
+  }
+  if (kinds.has("manifest_corrupt")) {
+    _emit(opts.quiet, "Diagnose:  `./agent-config doctor --check manifest-integrity`");
+  }
+  return 1;
+}
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
+  try {
+    process.exitCode = main(process.argv.slice(2));
+  } catch (e) {
+    if (e instanceof ArgparseExit) {
+      process.exitCode = e.code;
+    } else {
+      throw e;
+    }
+  }
+}
+export {
+  ArgparseExit,
+  _check_entry,
+  _counterpart_path,
+  _format,
+  _parse,
+  _resolve_marker,
+  _version_drift,
+  main
+};

package/dist/cli-delegate/cmd_versions.js

@@ -0,0 +1,370 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  project_settings_path,
+  resolve_project_root
+} from "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_versions.ts
+import process from "node:process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var PACKAGE_NAME = "@event4u/agent-config";
+var _HERE_DIR = path.dirname(fileURLToPath(import.meta.url));
+var ArgparseExit = class extends Error {
+  code;
+  constructor(code) {
+    super(`ArgparseExit(${code})`);
+    this.name = "ArgparseExit";
+    this.code = code;
+  }
+};
+function _stdoutSink() {
+  return { write: (t) => process.stdout.write(t) };
+}
+function _stderrSink() {
+  return { write: (t) => process.stderr.write(t) };
+}
+function _print(out, line = "") {
+  out.write(line + "\n");
+}
+function _jsonStrAscii(s) {
+  let out = '"';
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    const ch = s[i];
+    switch (ch) {
+      case '"':
+        out += '\\"';
+        break;
+      case "\\":
+        out += "\\\\";
+        break;
+      case "\n":
+        out += "\\n";
+        break;
+      case "\r":
+        out += "\\r";
+        break;
+      case "	":
+        out += "\\t";
+        break;
+      case "\b":
+        out += "\\b";
+        break;
+      case "\f":
+        out += "\\f";
+        break;
+      default:
+        if (code < 32 || code > 126) {
+          out += "\\u" + code.toString(16).padStart(4, "0");
+        } else {
+          out += ch;
+        }
+    }
+  }
+  return out + '"';
+}
+function _jsonScalarAscii(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      if (Number.isNaN(value)) return "NaN";
+      return value > 0 ? "Infinity" : "-Infinity";
+    }
+    return String(value);
+  }
+  if (typeof value === "string") return _jsonStrAscii(value);
+  return null;
+}
+function _dumpIndentAscii(value, indent, depth) {
+  const scalar = _jsonScalarAscii(value);
+  if (scalar !== null) return scalar;
+  const pad = " ".repeat(indent * (depth + 1));
+  const closePad = " ".repeat(indent * depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const items = value.map((v) => pad + _dumpIndentAscii(v, indent, depth + 1));
+    return `[
+${items.join(",\n")}
+${closePad}]`;
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return "{}";
+    const items = keys.map(
+      (k) => `${pad}${_jsonStrAscii(k)}: ${_dumpIndentAscii(obj[k], indent, depth + 1)}`
+    );
+    return `{
+${items.join(",\n")}
+${closePad}}`;
+  }
+  return _jsonStrAscii(String(value));
+}
+function _jsonDumpsIndentAscii(value, indent) {
+  return _dumpIndentAscii(value, indent, 0);
+}
+function _project_root() {
+  const [root] = resolve_project_root(null);
+  return root;
+}
+function _local_package_version() {
+  const candidates = [
+    path.join(resolvePackageRoot(import.meta.url), "package.json"),
+    path.join(_project_root(), "package.json")
+  ];
+  for (const p of candidates) {
+    let exists;
+    try {
+      fs.statSync(p);
+      exists = true;
+    } catch {
+      exists = false;
+    }
+    if (exists) {
+      try {
+        const data = JSON.parse(fs.readFileSync(p, { encoding: "utf-8" }));
+        const v = data?.["version"];
+        return v === void 0 || v === null ? "" : String(v);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return "";
+}
+function _pinned_version() {
+  const settings = project_settings_path(_project_root());
+  let exists;
+  try {
+    fs.statSync(settings);
+    exists = true;
+  } catch {
+    exists = false;
+  }
+  if (!exists) {
+    return "";
+  }
+  try {
+    const text = fs.readFileSync(settings, { encoding: "utf-8" });
+    for (const rawLine of _splitlines(text)) {
+      const line = _pyStrip(rawLine);
+      if (line.startsWith("agent_config_version")) {
+        const idx = line.indexOf(":");
+        const rhs = idx === -1 ? "" : line.slice(idx + 1);
+        return _pyStripChars(_pyStripChars(_pyStrip(rhs), '"'), "'");
+      }
+    }
+  } catch {
+  }
+  return "";
+}
+function _query_npm() {
+  const proc = spawnSync("npm", ["view", PACKAGE_NAME, "versions", "--json"], {
+    encoding: "utf8",
+    timeout: 15e3
+  });
+  if (proc.error) {
+    return [];
+  }
+  if (proc.status !== 0) {
+    return [];
+  }
+  let data;
+  try {
+    data = JSON.parse(proc.stdout ?? "");
+  } catch {
+    return [];
+  }
+  if (typeof data === "string") {
+    return [data];
+  }
+  if (Array.isArray(data)) {
+    return data.map((v) => String(v));
+  }
+  return [];
+}
+function _format_table(versions, current, pinned, limit) {
+  const rows = [];
+  const head = limit > 0 ? versions.slice(Math.max(0, versions.length - limit)) : versions;
+  for (const v of head) {
+    const marks = [];
+    if (v === pinned) {
+      marks.push("\u2190 pinned");
+    }
+    if (v === current) {
+      marks.push("\u2190 latest");
+    }
+    const suffix = marks.length ? "  " + marks.join(" ") : "";
+    rows.push(`  ${v}${suffix}`);
+  }
+  return rows.join("\n");
+}
+function _isPyWs(code) {
+  return code === 9 || code === 10 || code === 11 || code === 12 || code === 13 || code === 28 || code === 29 || code === 30 || code === 31 || code === 32 || code === 133 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288;
+}
+function _pyStrip(s) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && _isPyWs(s.charCodeAt(start))) start += 1;
+  while (end > start && _isPyWs(s.charCodeAt(end - 1))) end -= 1;
+  return s.slice(start, end);
+}
+function _pyStripChars(s, ch) {
+  let start = 0;
+  let end = s.length;
+  while (start < end && s[start] === ch) start += 1;
+  while (end > start && s[end - 1] === ch) end -= 1;
+  return s.slice(start, end);
+}
+function _splitlines(text) {
+  if (text === "") return [];
+  const out = [];
+  let cur = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    const code = text.charCodeAt(i);
+    if (ch === "\r") {
+      if (text[i + 1] === "\n") i += 1;
+      out.push(cur);
+      cur = "";
+    } else if (ch === "\n" || code === 11 || code === 12 || code === 28 || code === 29 || code === 30 || code === 133 || code === 8232 || code === 8233) {
+      out.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur !== "") out.push(cur);
+  return out;
+}
+function _parse(argv, out, err) {
+  const prog = "agent-config versions";
+  const usage = `usage: ${prog} [-h] [--offline] [--limit LIMIT] [--json]
+`;
+  const emitError = (msg) => {
+    err.write(usage);
+    err.write(`${prog}: error: ${msg}
+`);
+    throw new ArgparseExit(2);
+  };
+  const opts = { offline: false, limit: 20, as_json: false };
+  const parseLimit = (raw) => {
+    const t = _pyStrip(raw);
+    if (!/^[+-]?\d(?:_?\d)*$/.test(t)) {
+      emitError(`argument --limit: invalid int value: '${raw}'`);
+    }
+    return parseInt(t.replace(/_/g, ""), 10);
+  };
+  let i = 0;
+  while (i < argv.length) {
+    const tok = argv[i];
+    if (tok === "-h" || tok === "--help") {
+      out.write(usage);
+      throw new ArgparseExit(0);
+    } else if (tok === "--offline") {
+      opts.offline = true;
+      i += 1;
+    } else if (tok === "--json") {
+      opts.as_json = true;
+      i += 1;
+    } else if (tok === "--limit") {
+      const val = argv[i + 1];
+      if (val === void 0) {
+        emitError("argument --limit: expected one argument");
+      }
+      opts.limit = parseLimit(val);
+      i += 2;
+    } else if (tok.startsWith("--limit=")) {
+      opts.limit = parseLimit(tok.slice("--limit=".length));
+      i += 1;
+    } else {
+      emitError(`unrecognized arguments: ${tok}`);
+    }
+  }
+  return opts;
+}
+function main(argv = null, options = {}) {
+  const out = options.out ?? _stdoutSink();
+  const err = options.err ?? _stderrSink();
+  const opts = _parse(argv ?? process.argv.slice(2), out, err);
+  const offline = opts.offline || process.env["AGENT_CONFIG_OFFLINE"] === "1";
+  const local = _local_package_version();
+  const pinned = _pinned_version();
+  let versions = [];
+  if (!offline) {
+    versions = _query_npm();
+  }
+  const latest = versions.length ? versions[versions.length - 1] : local;
+  if (opts.as_json) {
+    _print(
+      out,
+      _jsonDumpsIndentAscii(
+        {
+          pinned,
+          local,
+          latest,
+          versions,
+          source: versions.length ? "npm" : "local"
+        },
+        2
+      )
+    );
+    return 0;
+  }
+  _print(out, `package: ${PACKAGE_NAME}`);
+  _print(out, `pinned:  ${pinned || "\u2014 (no .agent-settings.yml)"}`);
+  _print(out, `local:   ${local || "\u2014"}`);
+  if (!versions.length) {
+    if (offline) {
+      _print(out, "offline mode \u2014 registry query skipped");
+    } else {
+      _print(out, "\u26A0\uFE0F   npm registry unreachable; showing local only");
+    }
+    return 0;
+  }
+  _print(out, `latest:  ${latest}`);
+  _print(out);
+  _print(out, `available versions (${opts.limit > 0 ? "last " + String(opts.limit) : "all"}):`);
+  _print(out, _format_table(versions, latest, pinned, opts.limit));
+  return 0;
+}
+var _HERE = fileURLToPath(import.meta.url);
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
+  try {
+    process.exitCode = main();
+  } catch (exc) {
+    if (exc instanceof ArgparseExit) {
+      process.exitCode = exc.code;
+    } else {
+      throw exc;
+    }
+  }
+}
+export {
+  main
+};

package/dist/discovery/deprecation-report.md

@@ -1,6 +1,6 @@
 # Discovery — Deprecation Report
 
-- Generated: `2026-07-29T02:24:41Z`
+- Generated: `2026-07-31T12:04:17Z`
 - Deprecated artefacts: **0**
 
 _None. Tree is clean._