@event4u/agent-config 9.10.0 → 9.11.0

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

@@ -0,0 +1,715 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  resolve_project_root
+} from "./chunk-HJ6DAJHR.js";
+import {
+  resolvePackageRoot
+} from "./chunk-MCJYCQPF.js";
+
+// src/scripts/_cli/cmd_migrate.ts
+import { spawnSync } 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 PACKAGE_NAME_NPM = "@event4u/agent-config";
+var PACKAGE_NAME_COMPOSER = "event4u/agent-config";
+var LEGACY_DIRS = ["vendor", "node_modules"];
+var MANAGED_SYMLINKS = [
+  ".augment",
+  ".claude",
+  ".cursor",
+  ".clinerules",
+  ".windsurfrules"
+];
+var GITIGNORE_BLOCK_START = "# >>> event4u/agent-config (managed) >>>";
+var GITIGNORE_BLOCK_END = "# <<< event4u/agent-config (managed) <<<";
+var GITIGNORE_NEW_BODY = ".agent-settings.yml\nagents/sessions/\nagents/runtime/council/responses/\nagents/runtime/council/sessions/\n";
+var LEGACY_SETTINGS_FILES = [".agent-settings.yml", ".agent-user.yml"];
+var LEGACY_STATE_FILENAME = ".implement-ticket-state.json";
+var LEGACY_STATE_V1_FILENAME = ".work-state.json";
+var LEGACY_AGENT_CONFIG_SHELL = "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";
+    }
+    if (Number.isInteger(value)) return String(value);
+    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 _isFile(p) {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function _isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _isSymlink(p) {
+  try {
+    return fs.lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function _exists(p) {
+  try {
+    fs.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _readText(p) {
+  return fs.readFileSync(p, { encoding: "utf-8" });
+}
+function _writeText(p, text) {
+  fs.writeFileSync(p, text, { encoding: "utf-8" });
+}
+function _jsonLoadFile(p) {
+  return JSON.parse(_readText(p));
+}
+function _isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _detect_npm(pkg_json) {
+  if (!_isFile(pkg_json)) {
+    return false;
+  }
+  let data;
+  try {
+    data = _jsonLoadFile(pkg_json);
+  } catch {
+    return false;
+  }
+  if (!_isPlainObject(data)) {
+    return false;
+  }
+  for (const key of ["dependencies", "devDependencies"]) {
+    const section = data[key] ?? {};
+    if (_isPlainObject(section) && PACKAGE_NAME_NPM in section) {
+      return true;
+    }
+  }
+  return false;
+}
+function _detect_composer(composer_json) {
+  if (!_isFile(composer_json)) {
+    return false;
+  }
+  let data;
+  try {
+    data = _jsonLoadFile(composer_json);
+  } catch {
+    return false;
+  }
+  if (!_isPlainObject(data)) {
+    return false;
+  }
+  for (const key of ["require", "require-dev"]) {
+    const section = data[key] ?? {};
+    if (_isPlainObject(section) && PACKAGE_NAME_COMPOSER in section) {
+      return true;
+    }
+  }
+  return false;
+}
+function _classify_symlink(link) {
+  if (!_isSymlink(link)) {
+    return null;
+  }
+  let target;
+  try {
+    target = fs.readlinkSync(link);
+  } catch {
+    return null;
+  }
+  const target_str = target;
+  if (LEGACY_DIRS.some((seg) => target_str.split("/").includes(seg))) {
+    return "legacy";
+  }
+  return "user";
+}
+function _detect_legacy_state(project) {
+  return _isFile(path.join(project, LEGACY_STATE_FILENAME));
+}
+function _detect_legacy_settings(project) {
+  const found = [];
+  for (const name of LEGACY_SETTINGS_FILES) {
+    const flat = path.join(project, name);
+    if (_isFile(flat)) {
+      found.push(flat);
+    }
+    const typed = path.join(project, "settings", name);
+    if (_isFile(typed)) {
+      found.push(typed);
+    }
+  }
+  return found;
+}
+function _detect_empty_shell(project) {
+  const shell = path.join(project, LEGACY_AGENT_CONFIG_SHELL);
+  if (!_isDir(shell) || _isSymlink(shell)) {
+    return false;
+  }
+  try {
+    return fs.readdirSync(shell).length === 0;
+  } catch {
+    return false;
+  }
+}
+function _detect_already_migrated(project) {
+  if (_detect_npm(path.join(project, "package.json"))) {
+    return false;
+  }
+  if (_detect_composer(path.join(project, "composer.json"))) {
+    return false;
+  }
+  for (const name of MANAGED_SYMLINKS) {
+    if (_classify_symlink(path.join(project, name)) === "legacy") {
+      return false;
+    }
+  }
+  if (_detect_legacy_state(project)) {
+    return false;
+  }
+  if (_detect_legacy_settings(project).length) {
+    return false;
+  }
+  if (_detect_empty_shell(project)) {
+    return false;
+  }
+  return true;
+}
+function _strip_npm_entry(pkg_json) {
+  let data;
+  try {
+    data = _jsonLoadFile(pkg_json);
+  } catch {
+    return false;
+  }
+  if (!_isPlainObject(data)) {
+    return false;
+  }
+  let changed = false;
+  for (const key of ["dependencies", "devDependencies"]) {
+    const section = data[key];
+    if (_isPlainObject(section) && PACKAGE_NAME_NPM in section) {
+      delete section[PACKAGE_NAME_NPM];
+      changed = true;
+      if (Object.keys(section).length === 0) {
+        delete data[key];
+      }
+    }
+  }
+  if (changed) {
+    _writeText(pkg_json, _jsonDumpsIndentAscii(data, 2) + "\n");
+  }
+  return changed;
+}
+function _strip_composer_entry(composer_json) {
+  let data;
+  try {
+    data = _jsonLoadFile(composer_json);
+  } catch {
+    return false;
+  }
+  if (!_isPlainObject(data)) {
+    return false;
+  }
+  let changed = false;
+  for (const key of ["require", "require-dev"]) {
+    const section = data[key];
+    if (_isPlainObject(section) && PACKAGE_NAME_COMPOSER in section) {
+      delete section[PACKAGE_NAME_COMPOSER];
+      changed = true;
+      if (Object.keys(section).length === 0) {
+        delete data[key];
+      }
+    }
+  }
+  if (changed) {
+    _writeText(composer_json, _jsonDumpsIndentAscii(data, 2) + "\n");
+  }
+  return changed;
+}
+function _purge_legacy_symlinks(project) {
+  const removed = [];
+  const preserved = [];
+  for (const name of MANAGED_SYMLINKS) {
+    const link = path.join(project, name);
+    const kind = _classify_symlink(link);
+    if (kind === "legacy") {
+      try {
+        fs.unlinkSync(link);
+        removed.push(name);
+      } catch {
+        preserved.push(name);
+      }
+    } else if (kind === "user") {
+      preserved.push(name);
+    }
+  }
+  return [removed, preserved];
+}
+function _migrate_state_file(project) {
+  const source = path.join(project, LEGACY_STATE_FILENAME);
+  if (!_isFile(source)) {
+    return null;
+  }
+  const target = path.join(project, LEGACY_STATE_V1_FILENAME);
+  if (_exists(target)) {
+    try {
+      fs.unlinkSync(source);
+      return `removed stale ${LEGACY_STATE_FILENAME} (v1 already present)`;
+    } catch {
+      return null;
+    }
+  }
+  const migrator = _load_state_migrator();
+  if (migrator === null) {
+    return null;
+  }
+  migrator(source, { destination: target, backup: true });
+  return `migrated ${LEGACY_STATE_FILENAME} \u2192 ${LEGACY_STATE_V1_FILENAME}`;
+}
+function _load_state_migrator() {
+  const pkg_root = resolvePackageRoot(import.meta.url);
+  const rel = path.join(
+    "agent-src",
+    "templates",
+    "scripts",
+    "work_engine",
+    "migration",
+    "v0_to_v1.ts"
+  );
+  const driver = [path.join(pkg_root, "dist", rel), path.join(pkg_root, "src", rel)].find(
+    (p) => fs.existsSync(p)
+  ) ?? null;
+  if (driver === null) {
+    return null;
+  }
+  const binName = process.platform === "win32" ? "tsx.cmd" : "tsx";
+  let tsxBin = null;
+  for (let dir = pkg_root; ; ) {
+    const cand = path.join(dir, "node_modules", ".bin", binName);
+    if (fs.existsSync(cand)) {
+      tsxBin = cand;
+      break;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const command = tsxBin ?? "npx";
+  const prefix = tsxBin !== null ? [] : ["tsx"];
+  return (source, opts = {}) => {
+    const args = [...prefix, driver, source];
+    if (opts.destination !== void 0 && opts.destination !== null) {
+      args.push("--destination", opts.destination);
+    }
+    if (opts.backup === false) {
+      args.push("--no-backup");
+    }
+    const r = spawnSync(command, args, { encoding: "utf8" });
+    if (r.status !== 0) {
+      throw new Error(
+        `v0\u2192v1 state migration failed (exit ${r.status ?? "null"}): ${(r.stderr ?? "").trim()}`
+      );
+    }
+    return (r.stdout ?? "").trim();
+  };
+}
+function _delete_legacy_settings(project) {
+  const removed = [];
+  for (const p of _detect_legacy_settings(project)) {
+    try {
+      fs.unlinkSync(p);
+      removed.push(path.relative(project, p));
+    } catch {
+      continue;
+    }
+  }
+  const settings_dir = path.join(project, "settings");
+  if (_isDir(settings_dir) && !_isSymlink(settings_dir)) {
+    try {
+      if (fs.readdirSync(settings_dir).length === 0) {
+        fs.rmdirSync(settings_dir);
+        removed.push("settings/");
+      }
+    } catch {
+    }
+  }
+  return removed;
+}
+function _remove_empty_shell(project) {
+  const shell = path.join(project, LEGACY_AGENT_CONFIG_SHELL);
+  if (!_detect_empty_shell(project)) {
+    return false;
+  }
+  try {
+    fs.rmdirSync(shell);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function _reEscape(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function _update_gitignore(project) {
+  const gitignore = path.join(project, ".gitignore");
+  const block = `${GITIGNORE_BLOCK_START}
+${GITIGNORE_NEW_BODY}${GITIGNORE_BLOCK_END}
+`;
+  if (!_exists(gitignore)) {
+    _writeText(gitignore, block);
+    return true;
+  }
+  const text = _readText(gitignore);
+  const pattern = new RegExp(
+    _reEscape(GITIGNORE_BLOCK_START) + ".*?" + _reEscape(GITIGNORE_BLOCK_END) + "\\n?",
+    "s"
+  );
+  let new_text;
+  if (pattern.test(text)) {
+    new_text = text.replace(pattern, () => block);
+  } else {
+    new_text = text;
+    if (new_text && !new_text.endsWith("\n")) {
+      new_text += "\n";
+    }
+    new_text += block;
+  }
+  if (new_text === text) {
+    return false;
+  }
+  _writeText(gitignore, new_text);
+  return true;
+}
+function _build_plan(project) {
+  return {
+    npm: _detect_npm(path.join(project, "package.json")),
+    composer: _detect_composer(path.join(project, "composer.json")),
+    symlinks_legacy: MANAGED_SYMLINKS.filter(
+      (name) => _classify_symlink(path.join(project, name)) === "legacy"
+    ),
+    symlinks_user: MANAGED_SYMLINKS.filter(
+      (name) => _classify_symlink(path.join(project, name)) === "user"
+    ),
+    state_file: _isFile(path.join(project, LEGACY_STATE_FILENAME)),
+    settings_files: _detect_legacy_settings(project).map((p) => path.relative(project, p)),
+    empty_shell: _detect_empty_shell(project)
+  };
+}
+function _plan_lines(plan) {
+  const lines = [];
+  if (plan.npm) {
+    lines.push(`would remove ${PACKAGE_NAME_NPM} from package.json`);
+  }
+  if (plan.composer) {
+    lines.push(`would remove ${PACKAGE_NAME_COMPOSER} from composer.json`);
+  }
+  for (const name of plan.symlinks_legacy) {
+    lines.push(`would remove legacy symlink ${name}`);
+  }
+  for (const name of plan.symlinks_user) {
+    lines.push(`would preserve user-managed ${name} (review manually)`);
+  }
+  if (plan.state_file) {
+    lines.push(`would migrate ${LEGACY_STATE_FILENAME} \u2192 ${LEGACY_STATE_V1_FILENAME}`);
+  }
+  for (const rel of plan.settings_files) {
+    lines.push(`would delete legacy config ${rel}`);
+  }
+  if (plan.empty_shell) {
+    lines.push(`would remove empty ${LEGACY_AGENT_CONFIG_SHELL}/ shell`);
+  }
+  lines.push("would refresh .gitignore agent-config block");
+  return lines;
+}
+function _format_dry_run(plan, out) {
+  _print(out, "\u2139\uFE0F  legacy install detected \u2014 re-run without --dry-run to migrate:");
+  for (const line of _plan_lines(plan)) {
+    _print(out, `    - ${line}`);
+  }
+}
+function _pending_actions(plan) {
+  return Number(plan.npm) + Number(plan.composer) + plan.symlinks_legacy.length + plan.symlinks_user.length + Number(plan.state_file) + plan.settings_files.length + Number(plan.empty_shell);
+}
+function _format_check(plan, out) {
+  const n = _pending_actions(plan);
+  _print(
+    out,
+    `\u26A0\uFE0F  legacy install detected \u2014 ${n} pending action(s) (run \`agent-config migrate\` to apply, \`--dry-run\` to preview):`
+  );
+  for (const line of _plan_lines(plan)) {
+    _print(out, `    - ${line}`);
+  }
+}
+function _warn_on_major_mismatch(from_major, plan, out) {
+  if (from_major === "4" && !plan.composer) {
+    _print(
+      out,
+      "\u2139\uFE0F  --from 4 declared but no composer.json agent-config entry found; proceeding from the detected signals."
+    );
+  } else if (from_major === "5" && !plan.npm) {
+    _print(
+      out,
+      "\u2139\uFE0F  --from 5 declared but no package.json agent-config entry found; proceeding from the detected signals."
+    );
+  }
+}
+function _apply(project, out, err) {
+  const summary = [];
+  if (_strip_npm_entry(path.join(project, "package.json"))) {
+    summary.push(`removed ${PACKAGE_NAME_NPM} from package.json`);
+  }
+  if (_strip_composer_entry(path.join(project, "composer.json"))) {
+    summary.push(`removed ${PACKAGE_NAME_COMPOSER} from composer.json`);
+  }
+  const [removed_links, preserved_links] = _purge_legacy_symlinks(project);
+  for (const name of removed_links) {
+    summary.push(`removed legacy symlink ${name}`);
+  }
+  for (const name of preserved_links) {
+    summary.push(`preserved user-managed ${name} (review manually)`);
+  }
+  let state_summary;
+  try {
+    state_summary = _migrate_state_file(project);
+  } catch (exc) {
+    _print(err, `\u274C  state migration failed: ${exc.message}`);
+    return 1;
+  }
+  if (state_summary) {
+    summary.push(state_summary);
+  }
+  for (const rel of _delete_legacy_settings(project)) {
+    summary.push(`deleted legacy config ${rel}`);
+  }
+  if (_remove_empty_shell(project)) {
+    summary.push(`removed empty ${LEGACY_AGENT_CONFIG_SHELL}/ shell`);
+  }
+  if (_update_gitignore(project)) {
+    summary.push(".gitignore agent-config block refreshed");
+  }
+  _print(out, "\u2705  migration complete:");
+  for (const line of summary) {
+    _print(out, `    - ${line}`);
+  }
+  _print(out, "\n    Next: review the diff and commit.");
+  return 0;
+}
+function _parse(argv, out, err) {
+  const prog = "agent-config migrate";
+  const usage = `usage: ${prog} [-h] [--dry-run | --check] [--from {4,5}]
+`;
+  const emitError = (msg) => {
+    err.write(usage);
+    err.write(`${prog}: error: ${msg}
+`);
+    throw new ArgparseExit(2);
+  };
+  let dry_run = false;
+  let check = false;
+  let from_major = null;
+  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 === "--dry-run") {
+      dry_run = true;
+      i += 1;
+    } else if (tok === "--check") {
+      check = true;
+      i += 1;
+    } else if (tok === "--from") {
+      const val = argv[i + 1];
+      if (val === void 0) {
+        emitError("argument --from: expected one argument");
+        return { dry_run, check, from_major };
+      }
+      if (val !== "4" && val !== "5") {
+        emitError(
+          `argument --from: invalid choice: '${val}' (choose from '4', '5')`
+        );
+      }
+      from_major = val;
+      i += 2;
+    } else if (tok.startsWith("--from=")) {
+      const val = tok.slice("--from=".length);
+      if (val !== "4" && val !== "5") {
+        emitError(
+          `argument --from: invalid choice: '${val}' (choose from '4', '5')`
+        );
+      }
+      from_major = val;
+      i += 1;
+    } else {
+      emitError(`unrecognized arguments: ${tok}`);
+    }
+  }
+  if (dry_run && check) {
+    emitError("argument --check: not allowed with argument --dry-run");
+  }
+  return { dry_run, check, from_major };
+}
+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);
+  const [project] = resolve_project_root(null, { cwd: options.cwd ?? null });
+  if (args.from_major) {
+    _print(out, `\u2139\uFE0F  declared source major: ${args.from_major}.x`);
+  }
+  if (_detect_already_migrated(project)) {
+    if (args.check) {
+      _print(out, "\u2705  on the 6.0 layout \u2014 no migration needed.");
+    } else {
+      _print(out, "\u2705  already migrated \u2014 nothing to do.");
+    }
+    return 0;
+  }
+  const plan = _build_plan(project);
+  _warn_on_major_mismatch(args.from_major, plan, out);
+  if (args.check) {
+    _format_check(plan, out);
+    return 2;
+  }
+  if (args.dry_run) {
+    _format_dry_run(plan, out);
+    return 0;
+  }
+  return _apply(project, out, err);
+}
+var _bundled = true;
+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 (!_bundled && (_isCliEntry() || process.argv[1] === _HERE)) {
+  try {
+    process.exitCode = main(process.argv.slice(2));
+  } catch (exc) {
+    if (exc instanceof ArgparseExit) {
+      process.exitCode = exc.code;
+    } else {
+      throw exc;
+    }
+  }
+}
+
+export {
+  main
+};