@event4u/agent-config 9.10.0 → 9.11.0

package/dist/cli-delegate/cmd_export.js

@@ -0,0 +1,296 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  AIDER_MARKER,
+  CLAUDE_DESKTOP_MARKER,
+  CODEX_MARKER,
+  CONTINUE_MARKER,
+  JETBRAINS_MARKER,
+  KILOCODE_MARKER,
+  KIRO_MARKER,
+  ROOCODE_MARKER,
+  ZED_MARKER
+} from "./chunk-YMFO6FDN.js";
+import "./chunk-XX6TOPD7.js";
+import "./chunk-IR7P7JWA.js";
+import "./chunk-GRRPEPRN.js";
+import "./chunk-7DSAMZFU.js";
+import "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
+import "./chunk-OY53J6II.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_export.ts
+import process from "node:process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
+var TEMPLATES_DIR = path.join(PACKAGE_ROOT, "dist/agent-src", "templates");
+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 _ljust(s, width) {
+  const len = [...s].length;
+  if (len >= width) return s;
+  return s + " ".repeat(width - len);
+}
+var FileNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FileNotFoundError";
+  }
+};
+function _from_template(rel) {
+  return () => {
+    const p = path.join(TEMPLATES_DIR, rel);
+    let isFile;
+    try {
+      isFile = fs.statSync(p).isFile();
+    } catch {
+      isFile = false;
+    }
+    if (!isFile) {
+      throw new FileNotFoundError(
+        `template missing from package: ${p} (reinstall @event4u/agent-config or report a bug)`
+      );
+    }
+    return fs.readFileSync(p, { encoding: "utf-8" });
+  };
+}
+function _from_constant(value) {
+  return () => value;
+}
+var EXPORT_REGISTRY = {
+  roocode: [
+    "Roo Code marker (.roo/rules/agent-config.md body)",
+    _from_constant(ROOCODE_MARKER)
+  ],
+  "claude-desktop": [
+    "Claude Desktop marker (informational, global-scope tool)",
+    _from_constant(CLAUDE_DESKTOP_MARKER)
+  ],
+  aider: [
+    "Aider marker (manual `read:` wiring documented inline)",
+    _from_constant(AIDER_MARKER)
+  ],
+  codex: [
+    "Codex CLI marker (informational \u2014 AGENTS.md is canonical)",
+    _from_constant(CODEX_MARKER)
+  ],
+  continue: [
+    "Continue.dev marker (.continue/rules/agent-config.md body)",
+    _from_constant(CONTINUE_MARKER)
+  ],
+  kilocode: [
+    "Kilo Code marker (.kilocode/rules/agent-config.md body)",
+    _from_constant(KILOCODE_MARKER)
+  ],
+  zed: [
+    "Zed marker (informational \u2014 .rules at repo root is canonical)",
+    _from_constant(ZED_MARKER)
+  ],
+  jetbrains: [
+    "JetBrains AI Assistant marker (.jetbrains/agent-config.md body)",
+    _from_constant(JETBRAINS_MARKER)
+  ],
+  kiro: [
+    "Kiro marker (.kiro/steering/agent-config.md body)",
+    _from_constant(KIRO_MARKER)
+  ],
+  "agents-md": [
+    "AGENTS.md template (Thin-Root entry point \u2014 consumer scaffold)",
+    _from_template("AGENTS.md")
+  ],
+  "copilot-instructions": [
+    "GitHub Copilot Code Review instructions template",
+    _from_template("copilot-instructions.md")
+  ]
+};
+function _list_tools(out) {
+  _print(out, "Available tools for `agent-config export --tool <id>`:");
+  const keys = Object.keys(EXPORT_REGISTRY);
+  const width = Math.max(...keys.map((t) => [...t].length)) + 2;
+  const sortedKeys = [...keys].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  for (const tool_id of sortedKeys) {
+    const [desc] = EXPORT_REGISTRY[tool_id];
+    _print(out, `  ${_ljust(tool_id, width)}${desc}`);
+  }
+  return 0;
+}
+function _hash(content) {
+  return crypto.createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function _rel(p) {
+  const cwd = process.cwd();
+  const rel = path.relative(cwd, p);
+  if (rel === "" || rel !== ".." && !rel.startsWith(".." + path.sep) && !path.isAbsolute(rel)) {
+    return rel === "" ? p : rel;
+  }
+  return p;
+}
+function _write(output, content, opts) {
+  const { force, out, err } = opts;
+  let exists;
+  try {
+    fs.lstatSync(output);
+    exists = true;
+  } catch {
+    exists = false;
+  }
+  if (exists) {
+    const existing = fs.readFileSync(output, { encoding: "utf-8" });
+    if (_hash(existing) === _hash(content)) {
+      _print(out, `\u2139\uFE0F  ${_rel(output)} already exported (content matches).`);
+      return 0;
+    }
+    if (!force) {
+      _print(
+        err,
+        `\u274C  refusing to overwrite ${output} \u2014 content differs. Pass --force to replace.`
+      );
+      return 1;
+    }
+  }
+  fs.mkdirSync(path.dirname(output), { recursive: true });
+  fs.writeFileSync(output, content, { encoding: "utf-8" });
+  _print(out, `\u2705  exported to ${_rel(output)}`);
+  return 0;
+}
+function _parse(argv, out, err) {
+  const prog = "agent-config export";
+  const usage = `usage: ${prog} [-h] [--tool ID] [--output PATH] [--force] [--list]
+`;
+  const emitError = (msg) => {
+    err.write(usage);
+    err.write(`${prog}: error: ${msg}
+`);
+    throw new ArgparseExit(2);
+  };
+  const args = { tool: null, output: null, force: false, list: false };
+  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 === "--tool") {
+      const val = argv[i + 1];
+      if (val === void 0) emitError("argument --tool: expected one argument");
+      args.tool = val;
+      i += 2;
+    } else if (tok.startsWith("--tool=")) {
+      args.tool = tok.slice("--tool=".length);
+      i += 1;
+    } else if (tok === "--output") {
+      const val = argv[i + 1];
+      if (val === void 0) emitError("argument --output: expected one argument");
+      args.output = val;
+      i += 2;
+    } else if (tok.startsWith("--output=")) {
+      args.output = tok.slice("--output=".length);
+      i += 1;
+    } else if (tok === "--force") {
+      args.force = true;
+      i += 1;
+    } else if (tok === "--list") {
+      args.list = true;
+      i += 1;
+    } else {
+      emitError(`unrecognized arguments: ${tok}`);
+    }
+  }
+  return args;
+}
+function _expanduser(p) {
+  if (p === "~" || p.startsWith("~/")) {
+    return path.join(os.homedir(), p.slice(1));
+  }
+  if (p === "~" + path.sep || p.startsWith("~" + path.sep)) {
+    return path.join(os.homedir(), p.slice(1));
+  }
+  return p;
+}
+function main(argv = null, options = {}) {
+  const out = options.out ?? _stdoutSink();
+  const err = options.err ?? _stderrSink();
+  const args = _parse(argv ?? process.argv.slice(2), out, err);
+  if (args.list) {
+    return _list_tools(out);
+  }
+  if (!args.tool) {
+    _print(err, "\u274C  --tool is required (see --list for the catalog).");
+    return 2;
+  }
+  if (!args.output) {
+    _print(err, "\u274C  --output is required (no canonical-path defaults).");
+    return 2;
+  }
+  const entry = EXPORT_REGISTRY[args.tool];
+  if (entry === void 0) {
+    _print(err, `\u274C  unknown tool: ${args.tool} (see --list)`);
+    return 2;
+  }
+  const [, provider] = entry;
+  let content;
+  try {
+    content = provider();
+  } catch (exc) {
+    if (exc instanceof FileNotFoundError) {
+      _print(err, `\u274C  ${exc.message}`);
+      return 1;
+    }
+    throw exc;
+  }
+  const output = path.resolve(_expanduser(args.output));
+  return _write(output, content, { force: args.force, out, err });
+}
+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/cli-delegate/cmd_fleet.js

@@ -0,0 +1,332 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  hasBlockingFinding,
+  runPreflight
+} from "./chunk-RDGRHAAB.js";
+import "./chunk-OMIVVCG2.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
+import {
+  require_dist
+} from "./chunk-OY53J6II.js";
+import {
+  __toESM
+} from "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_fleet.ts
+var YAML = __toESM(require_dist(), 1);
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var _HERE = fileURLToPath(import.meta.url);
+var PACKAGE_ROOT = resolvePackageRoot(import.meta.url);
+var FleetConfigError = class extends Error {
+};
+function parseFleetSpec(text, baseDir) {
+  let raw;
+  try {
+    raw = YAML.parse(text);
+  } catch (exc) {
+    throw new FleetConfigError(`fleet config does not parse: ${exc.message}`);
+  }
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new FleetConfigError("fleet config must be a mapping with a `repos:` list");
+  }
+  const obj = raw;
+  const reposRaw = obj["repos"];
+  if (!Array.isArray(reposRaw) || reposRaw.length === 0) {
+    throw new FleetConfigError("`repos:` must be a non-empty list");
+  }
+  const repos = [];
+  for (const [i, entry] of reposRaw.entries()) {
+    if (typeof entry === "string") {
+      repos.push({ path: path.resolve(baseDir, entry) });
+      continue;
+    }
+    if (entry !== null && typeof entry === "object" && !Array.isArray(entry)) {
+      const e = entry;
+      const p = e["path"];
+      if (typeof p !== "string" || p.length === 0) {
+        throw new FleetConfigError(`repos[${i}] is missing a non-empty \`path\``);
+      }
+      const tools = e["tools"];
+      if (tools !== void 0 && typeof tools !== "string") {
+        throw new FleetConfigError(`repos[${i}].tools must be a comma-separated string`);
+      }
+      repos.push({
+        path: path.resolve(baseDir, p),
+        ...typeof tools === "string" ? { tools } : {}
+      });
+      continue;
+    }
+    throw new FleetConfigError(`repos[${i}] must be a path string or a {path, tools} mapping`);
+  }
+  const mcRaw = obj["max_concurrency"];
+  let maxConcurrency = 3;
+  if (mcRaw !== void 0) {
+    if (typeof mcRaw !== "number" || !Number.isInteger(mcRaw) || mcRaw < 1) {
+      throw new FleetConfigError("`max_concurrency` must be a positive integer");
+    }
+    maxConcurrency = mcRaw;
+  }
+  return { repos, maxConcurrency };
+}
+function validateFleetReport(obj) {
+  const problems = [];
+  if (obj === null || typeof obj !== "object") return ["report is not an object"];
+  const r = obj;
+  if (r["schema_version"] !== 1) problems.push("schema_version must be 1");
+  if (typeof r["ts"] !== "string" || Number.isNaN(Date.parse(String(r["ts"])))) {
+    problems.push("ts must be an ISO timestamp");
+  }
+  if (typeof r["max_concurrency"] !== "number") problems.push("max_concurrency must be a number");
+  if (r["status"] !== "ok" && r["status"] !== "fail") problems.push("status must be 'ok'|'fail'");
+  if (!Array.isArray(r["repos"])) {
+    problems.push("repos must be an array");
+    return problems;
+  }
+  const statuses = /* @__PURE__ */ new Set(["ok", "preflight-failed", "install-failed", "conformance-failed"]);
+  for (const [i, item] of r["repos"].entries()) {
+    const e = item;
+    if (typeof e["path"] !== "string") problems.push(`repos[${i}].path must be a string`);
+    if (!statuses.has(String(e["status"]))) problems.push(`repos[${i}].status invalid`);
+    if (!Array.isArray(e["findings"])) problems.push(`repos[${i}].findings must be an array`);
+    if (typeof e["durationMs"] !== "number") problems.push(`repos[${i}].durationMs must be a number`);
+    if (e["conformance"] !== null) {
+      const c = e["conformance"];
+      if (c === null || typeof c !== "object" || typeof c["exit"] !== "number") {
+        problems.push(`repos[${i}].conformance must be null or {exit, note}`);
+      }
+    }
+  }
+  return problems;
+}
+function defaultFleetCommands(packageRoot = PACKAGE_ROOT) {
+  const entry = path.join(packageRoot, "src", "scripts", "agent-config");
+  return {
+    installArgv: () => ["bash", entry, "refresh", "--project"],
+    conformanceArgv: () => ["bash", entry, "conformance"]
+  };
+}
+function spawnInRepo(argv, cwd, timeoutMs) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(argv[0], argv.slice(1), {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: timeoutMs
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString("utf8");
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString("utf8");
+    });
+    child.on("error", (err) => {
+      resolvePromise({ exit: 127, stdout, stderr: `${stderr}${err.message}` });
+    });
+    child.on("close", (code) => {
+      resolvePromise({ exit: code ?? 1, stdout, stderr });
+    });
+  });
+}
+var PREFLIGHT_POLICY = {
+  force: false,
+  interactive: false,
+  knownPaths: /* @__PURE__ */ new Set(),
+  knownPointers: /* @__PURE__ */ new Set(),
+  defaultStrategy: "skip"
+};
+async function runOneRepo(repo, commands, timeoutMs) {
+  const started = Date.now();
+  let findings;
+  if (!fs.existsSync(repo.path) || !fs.statSync(repo.path).isDirectory()) {
+    findings = [
+      {
+        id: "permissions",
+        severity: "blocking",
+        path: repo.path,
+        message: "repo path does not exist or is not a directory",
+        remedy: "fix the path in fleet.yaml (or clone the repo first)"
+      }
+    ];
+  } else {
+    findings = runPreflight({
+      target: "project",
+      root: repo.path,
+      sources: [],
+      policy: PREFLIGHT_POLICY
+    });
+  }
+  if (hasBlockingFinding(findings)) {
+    return {
+      path: repo.path,
+      status: "preflight-failed",
+      findings,
+      durationMs: Date.now() - started,
+      conformance: null
+    };
+  }
+  const install = await spawnInRepo(commands.installArgv(repo), repo.path, timeoutMs);
+  if (install.exit !== 0) {
+    return {
+      path: repo.path,
+      status: "install-failed",
+      findings,
+      durationMs: Date.now() - started,
+      conformance: null
+    };
+  }
+  const conf = await spawnInRepo(commands.conformanceArgv(repo), repo.path, timeoutMs);
+  const lastLine = conf.stdout.trim().split("\n").filter(Boolean).slice(-1)[0] ?? "";
+  return {
+    path: repo.path,
+    status: conf.exit === 0 ? "ok" : "conformance-failed",
+    findings,
+    durationMs: Date.now() - started,
+    conformance: { exit: conf.exit, note: lastLine.slice(0, 200) }
+  };
+}
+async function pool(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function worker() {
+    while (next < items.length) {
+      const i = next;
+      next += 1;
+      results[i] = await fn(items[i]);
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+}
+async function runFleet(spec, opts = {}) {
+  const commands = opts.commands ?? defaultFleetCommands();
+  const timeoutMs = opts.timeoutMs ?? 10 * 60 * 1e3;
+  const results = await pool(
+    spec.repos,
+    spec.maxConcurrency,
+    (repo) => runOneRepo(repo, commands, timeoutMs)
+  );
+  return {
+    schema_version: 1,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    max_concurrency: spec.maxConcurrency,
+    repos: results,
+    status: results.every((r) => r.status === "ok") ? "ok" : "fail"
+  };
+}
+function humanTable(report) {
+  const lines = [];
+  lines.push(`fleet: ${report.repos.length} repo(s) \xB7 max_concurrency ${report.max_concurrency}`);
+  for (const r of report.repos) {
+    const sym = r.status === "ok" ? "\u2705" : "\u274C";
+    const dur = `${Math.round(r.durationMs / 100) / 10}s`;
+    lines.push(`  ${sym} ${r.path} \u2014 ${r.status} (${dur})`);
+    for (const f of r.findings.filter((x) => x.severity === "blocking")) {
+      lines.push(`      ${f.id}: ${f.message}`);
+    }
+    if (r.conformance && r.status === "conformance-failed") {
+      lines.push(`      conformance exit ${r.conformance.exit}: ${r.conformance.note}`);
+    }
+  }
+  lines.push(report.status === "ok" ? "\u2705  fleet: all green" : "\u274C  fleet: at least one repo failed");
+  return lines.join("\n");
+}
+var USAGE = "usage: cmd_fleet [-h] --config fleet.yaml [--json]\n";
+async function main(argv = null) {
+  const args = argv !== null ? Array.from(argv) : process.argv.slice(2);
+  let configPath = null;
+  let json = false;
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (a === "-h" || a === "--help") {
+      process.stdout.write(USAGE);
+      return 0;
+    }
+    if (a === "--json") {
+      json = true;
+    } else if (a === "--config" || a.startsWith("--config=")) {
+      if (a.includes("=")) {
+        configPath = a.slice(a.indexOf("=") + 1);
+      } else {
+        configPath = String(args[i + 1] ?? "");
+        i += 1;
+      }
+    } else {
+      process.stderr.write(USAGE);
+      process.stderr.write(`cmd_fleet: error: unrecognized argument ${a}
+`);
+      return 2;
+    }
+    i += 1;
+  }
+  if (!configPath || !fs.existsSync(configPath)) {
+    process.stderr.write(USAGE);
+    process.stderr.write(`cmd_fleet: error: --config path missing or not found
+`);
+    return 2;
+  }
+  let spec;
+  try {
+    spec = parseFleetSpec(fs.readFileSync(configPath, "utf8"), path.dirname(path.resolve(configPath)));
+  } catch (exc) {
+    if (exc instanceof FleetConfigError) {
+      process.stderr.write(`cmd_fleet: error: ${exc.message}
+`);
+      return 2;
+    }
+    throw exc;
+  }
+  const report = await runFleet(spec);
+  if (json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+  } else {
+    process.stdout.write(`${humanTable(report)}
+`);
+  }
+  return report.status === "ok" ? 0 : 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) {
+  main(process.argv.slice(2)).then(
+    (code) => {
+      process.exitCode = code;
+    },
+    (err) => {
+      process.stderr.write(`cmd_fleet: fatal: ${err.message}
+`);
+      process.exitCode = 2;
+    }
+  );
+}
+export {
+  FleetConfigError,
+  defaultFleetCommands,
+  main,
+  parseFleetSpec,
+  runFleet,
+  validateFleetReport
+};