ai-engineering-kit 0.1.0

package/dist/cli.js

@@ -0,0 +1,675 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { basename as basename2 } from "path";
+import { intro, outro, confirm, select, isCancel as isCancel2, cancel as cancel2, log } from "@clack/prompts";
+
+// src/catalog/load.ts
+import { readdirSync, readFileSync } from "fs";
+import { join, posix } from "path";
+
+// src/manifest/manifest.ts
+import { createHash } from "crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function serializeManifest(manifest) {
+  return JSON.stringify(manifest, null, 2) + "\n";
+}
+function parseManifest(json) {
+  return JSON.parse(json);
+}
+
+// src/catalog/definition.ts
+var CATEGORIES = [
+  { id: "core-workflow", label: "Core workflow", from: "skills/core-workflow", to: "ai/skills" }
+];
+var TREE_COMPONENTS = [
+  { id: "docs-foundations", label: "docs/foundations scaffold", from: "docs/foundations", to: "docs/foundations" },
+  { id: "ai-workspace", label: "ai/ workspace dirs", from: "ai-workspace", to: "ai" }
+];
+var COMPONENTS = [
+  { id: "skills", label: "Skills", unlocks: "categories" },
+  ...TREE_COMPONENTS.map((t) => ({ id: t.id, label: t.label })),
+  { id: "entry-files", label: "Agent entry files", unlocks: "agents" }
+];
+var AGENTS = [
+  {
+    id: "claude-code",
+    label: "Claude Code",
+    files: [{ from: "agents/claude-code.CLAUDE.md", to: "CLAUDE.md", substitute: true }]
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    files: [{ from: "agents/codex.AGENTS.md", to: "AGENTS.md", substitute: true }]
+  }
+];
+
+// src/catalog/load.ts
+function listFiles(root, base) {
+  let out = [];
+  for (const entry of readdirSync(join(root, base), { withFileTypes: true })) {
+    const rel = base ? posix.join(base, entry.name) : entry.name;
+    if (entry.isDirectory()) out = out.concat(listFiles(root, rel));
+    else out.push(rel);
+  }
+  return out;
+}
+function catalogFile(templateDir, templatePath, targetPath, extra) {
+  const content = readFileSync(join(templateDir, templatePath), "utf8");
+  return {
+    targetPath,
+    templatePath,
+    substitute: false,
+    contentHash: hashContent(content),
+    ...extra
+  };
+}
+function loadCatalog(templateDir, version) {
+  const files = [];
+  for (const category of CATEGORIES) {
+    for (const rel of listFiles(templateDir, category.from)) {
+      const sub = rel.slice(category.from.length + 1);
+      files.push(
+        catalogFile(templateDir, rel, posix.join(category.to, sub), {
+          component: "skills",
+          category: category.id
+        })
+      );
+    }
+  }
+  for (const tree of TREE_COMPONENTS) {
+    for (const rel of listFiles(templateDir, tree.from)) {
+      const sub = rel.slice(tree.from.length + 1);
+      files.push(
+        catalogFile(templateDir, rel, posix.join(tree.to, sub), { component: tree.id })
+      );
+    }
+  }
+  for (const agent of AGENTS) {
+    for (const file of agent.files) {
+      files.push(
+        catalogFile(templateDir, file.from, file.to, {
+          component: "entry-files",
+          agent: agent.id,
+          substitute: file.substitute
+        })
+      );
+    }
+  }
+  return { version, files };
+}
+
+// src/catalog/catalog.ts
+function resolveSelection(catalog, selection) {
+  return catalog.files.filter((f) => {
+    if (!selection.components.includes(f.component)) return false;
+    if (f.category !== void 0 && !selection.categories.includes(f.category)) return false;
+    if (f.agent !== void 0 && !selection.agents.includes(f.agent)) return false;
+    return true;
+  });
+}
+
+// src/planner/planner.ts
+function planInstall(input) {
+  const files = resolveSelection(input.catalog, input.selection);
+  const byPath = new Map(
+    (input.manifest?.files ?? []).map((f) => [f.path, f])
+  );
+  const actions = files.map((f) => {
+    const tracked = byPath.get(f.targetPath);
+    return tracked ? { type: planTracked(f, tracked, input.onDisk.get(f.targetPath)), path: f.targetPath } : { type: planUntracked(f, input.onDisk.has(f.targetPath)), path: f.targetPath };
+  });
+  return { actions };
+}
+function planTracked(file, tracked, onDiskHash) {
+  if (tracked.status === "ejected") return "skip";
+  const edited = onDiskHash !== tracked.hash;
+  const hasNewVersion = file.contentHash !== tracked.hash;
+  if (!edited) return hasNewVersion ? "refresh" : "skip";
+  return hasNewVersion ? "conflict" : "skip";
+}
+function planUntracked(_file, onDisk) {
+  return onDisk ? "conflict" : "add";
+}
+
+// src/io/project.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+var MANIFEST_FILE = ".ai-kit.json";
+function readManifest(projectDir) {
+  const path = join2(projectDir, MANIFEST_FILE);
+  if (!existsSync(path)) return null;
+  return parseManifest(readFileSync2(path, "utf8"));
+}
+function readOnDiskHashes(projectDir, files) {
+  const hashes = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const path = join2(projectDir, file.targetPath);
+    if (existsSync(path)) hashes.set(file.targetPath, hashContent(readFileSync2(path, "utf8")));
+  }
+  return hashes;
+}
+
+// src/applier/applier.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+
+// src/applier/write.ts
+import { mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { dirname, join as join3 } from "path";
+function writeTemplateFile(projectDir, templateDir, file, projectName, suffix = "") {
+  const raw = readFileSync3(join3(templateDir, file.templatePath), "utf8");
+  const content = file.substitute ? raw.replaceAll("{{PROJECT_NAME}}", projectName) : raw;
+  const targetPath = file.targetPath + suffix;
+  const dest = join3(projectDir, targetPath);
+  mkdirSync(dirname(dest), { recursive: true });
+  writeFileSync(dest, content);
+  return targetPath;
+}
+
+// src/applier/applier.ts
+var ApplyConflictError = class extends Error {
+  constructor(paths) {
+    super(`Refusing to overwrite existing files:
+  ${paths.join("\n  ")}`);
+    this.paths = paths;
+    this.name = "ApplyConflictError";
+  }
+  paths;
+};
+function applyPlan(input) {
+  const conflicts = input.plan.actions.filter((a) => a.type === "conflict").map((a) => a.path);
+  if (conflicts.length > 0) throw new ApplyConflictError(conflicts);
+  const byPath = new Map(input.files.map((f) => [f.targetPath, f]));
+  const written = [];
+  const entries = [];
+  for (const action of input.plan.actions) {
+    if (action.type !== "add" && action.type !== "refresh") continue;
+    const file = byPath.get(action.path);
+    if (!file) continue;
+    written.push(writeTemplateFile(input.projectDir, input.templateDir, file, input.projectName));
+    entries.push({
+      path: file.targetPath,
+      sourceVersion: input.version,
+      hash: file.contentHash,
+      status: "managed"
+    });
+  }
+  const manifest = {
+    version: input.version,
+    agents: input.selection.agents,
+    components: input.selection.components,
+    categories: input.selection.categories,
+    files: entries
+  };
+  writeFileSync2(join4(input.projectDir, MANIFEST_FILE), serializeManifest(manifest));
+  return { written, manifest };
+}
+
+// src/applier/links.ts
+import { existsSync as existsSync2, lstatSync, mkdirSync as mkdirSync2, readlinkSync, symlinkSync } from "fs";
+import { join as join5 } from "path";
+var CLAUDE_SKILLS_LINK = ".claude/skills";
+var LINK_TARGET = "../ai/skills";
+function currentTarget(projectDir) {
+  const path = join5(projectDir, CLAUDE_SKILLS_LINK);
+  if (!existsSync2(path) && !isSymlink(path)) return null;
+  return isSymlink(path) ? readlinkSync(path) : "<not-a-symlink>";
+}
+function isSymlink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function claudeSkillsLinkConflict(projectDir) {
+  const target = currentTarget(projectDir);
+  return target !== null && target !== LINK_TARGET;
+}
+function ensureClaudeSkillsLink(projectDir) {
+  if (currentTarget(projectDir) === LINK_TARGET) return "skipped";
+  mkdirSync2(join5(projectDir, ".claude"), { recursive: true });
+  try {
+    symlinkSync(LINK_TARGET, join5(projectDir, CLAUDE_SKILLS_LINK), "dir");
+    return "created";
+  } catch {
+    return "unsupported";
+  }
+}
+
+// src/paths.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
+import { fileURLToPath } from "url";
+var packageRoot = join6(dirname2(fileURLToPath(import.meta.url)), "..");
+var TEMPLATE_DIR = join6(packageRoot, "template");
+function kitVersion() {
+  const pkg = JSON.parse(readFileSync4(join6(packageRoot, "package.json"), "utf8"));
+  return pkg.version;
+}
+
+// src/init.ts
+function runInit(opts) {
+  const templateDir = opts.templateDir ?? TEMPLATE_DIR;
+  const version = opts.version ?? kitVersion();
+  const catalog = loadCatalog(templateDir, version);
+  const files = resolveSelection(catalog, opts.selection);
+  const plan = planInstall({
+    selection: opts.selection,
+    catalog,
+    onDisk: readOnDiskHashes(opts.projectDir, files),
+    manifest: readManifest(opts.projectDir)
+  });
+  const wantsSkillLink = opts.selection.agents.includes("claude-code") && files.some((f) => f.component === "skills");
+  if (wantsSkillLink && claudeSkillsLinkConflict(opts.projectDir)) {
+    throw new ApplyConflictError([CLAUDE_SKILLS_LINK]);
+  }
+  const result = applyPlan({
+    projectDir: opts.projectDir,
+    templateDir,
+    files,
+    plan,
+    selection: opts.selection,
+    version,
+    projectName: opts.projectName
+  });
+  if (wantsSkillLink && ensureClaudeSkillsLink(opts.projectDir) === "unsupported") {
+    console.warn(
+      `
+Could not create the ${CLAUDE_SKILLS_LINK} symlink (your OS blocked it).
+On Windows, enable Developer Mode (or run as admin) and re-run, or point Claude Code at ai/skills/ manually.`
+    );
+  }
+  return result;
+}
+
+// src/menu/prompt.ts
+import { basename } from "path";
+import { multiselect, text, isCancel, cancel } from "@clack/prompts";
+
+// src/menu/menu.ts
+function componentOptions() {
+  return COMPONENTS.map((c) => ({ value: c.id, label: c.label }));
+}
+function categoryOptions() {
+  return CATEGORIES.map((c) => ({ value: c.id, label: c.label }));
+}
+function agentOptions() {
+  return AGENTS.map((a) => ({ value: a.id, label: a.label }));
+}
+function buildSelection(answers) {
+  return {
+    components: answers.components,
+    categories: answers.components.includes("skills") ? answers.categories : [],
+    agents: answers.components.includes("entry-files") ? answers.agents : []
+  };
+}
+
+// src/menu/prompt.ts
+function required(value) {
+  if (isCancel(value)) {
+    cancel("Cancelled \u2014 nothing written.");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptForSelection(projectDir) {
+  const components = required(
+    await multiselect({
+      message: "Which parts do you want to install?",
+      options: componentOptions(),
+      required: true
+    })
+  );
+  let categories = [];
+  if (components.includes("skills")) {
+    categories = required(
+      await multiselect({
+        message: "Which skill categories?",
+        options: categoryOptions(),
+        required: true
+      })
+    );
+  }
+  let agents = [];
+  if (components.includes("entry-files")) {
+    agents = required(
+      await multiselect({
+        message: "Which coding agents?",
+        options: agentOptions(),
+        required: true
+      })
+    );
+  }
+  const projectName = required(
+    await text({
+      message: "Project name",
+      defaultValue: basename(projectDir),
+      placeholder: basename(projectDir)
+    })
+  );
+  return { selection: buildSelection({ components, categories, agents }), projectName };
+}
+
+// src/applier/update.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join7 } from "path";
+
+// src/applier/resolve.ts
+function conflictOps(choice) {
+  switch (choice) {
+    case "overwrite":
+      return { writeTarget: true, writeNew: false };
+    case "keep-mine":
+      return { writeTarget: false, writeNew: false };
+    case "keep-theirs":
+      return { writeTarget: false, writeNew: true };
+  }
+}
+
+// src/applier/update.ts
+function installedSelection(manifest) {
+  return { components: manifest.components, categories: manifest.categories, agents: manifest.agents };
+}
+var union = (a, b) => [.../* @__PURE__ */ new Set([...a, ...b])];
+function unionSelection(a, b) {
+  return {
+    components: union(a.components, b.components),
+    categories: union(a.categories, b.categories),
+    agents: union(a.agents, b.agents)
+  };
+}
+function applyTypesFor(mode) {
+  return mode === "add" ? /* @__PURE__ */ new Set(["add"]) : /* @__PURE__ */ new Set(["add", "refresh", "conflict"]);
+}
+function prepareReRun(input) {
+  const templateDir = input.templateDir ?? TEMPLATE_DIR;
+  const version = input.version ?? kitVersion();
+  const catalog = loadCatalog(templateDir, version);
+  const selection = unionSelection(installedSelection(input.manifest), input.addParts);
+  const files = resolveSelection(catalog, selection);
+  const plan = planInstall({
+    selection,
+    catalog,
+    onDisk: readOnDiskHashes(input.projectDir, files),
+    manifest: input.manifest
+  });
+  return { catalog, selection, files, plan, applyTypes: applyTypesFor(input.mode), version, templateDir };
+}
+var DEFAULT_APPLY = /* @__PURE__ */ new Set(["add", "refresh", "conflict"]);
+function applyUpdate(input) {
+  const byPath = new Map(input.files.map((f) => [f.targetPath, f]));
+  const written = [];
+  const applyTypes = input.applyTypes ?? DEFAULT_APPLY;
+  const write = (file, suffix = "") => written.push(writeTemplateFile(input.projectDir, input.templateDir, file, input.projectName, suffix));
+  for (const action of input.plan.actions) {
+    if (!applyTypes.has(action.type)) continue;
+    const file = byPath.get(action.path);
+    if (!file) continue;
+    if (action.type === "add" || action.type === "refresh") {
+      write(file);
+    } else if (action.type === "conflict") {
+      const ops = conflictOps(input.resolutions.get(action.path) ?? "keep-mine");
+      if (ops.writeTarget) write(file);
+      if (ops.writeNew) write(file, ".new");
+    }
+  }
+  const priorByPath = new Map(input.priorManifest.files.map((f) => [f.path, f]));
+  const actionByPath = new Map(input.plan.actions.map((a) => [a.path, a.type]));
+  const entries = [];
+  for (const file of input.files) {
+    const prior = priorByPath.get(file.targetPath);
+    if (prior?.status === "ejected") {
+      entries.push(prior);
+      continue;
+    }
+    const type = actionByPath.get(file.targetPath);
+    const reconciled = type === "skip" || type !== void 0 && applyTypes.has(type);
+    if (reconciled) {
+      entries.push({ path: file.targetPath, sourceVersion: input.version, hash: file.contentHash, status: "managed" });
+    } else if (prior) {
+      entries.push(prior);
+    }
+  }
+  const manifest = {
+    version: input.version,
+    agents: input.selection.agents,
+    components: input.selection.components,
+    categories: input.selection.categories,
+    files: entries
+  };
+  writeFileSync3(join7(input.projectDir, MANIFEST_FILE), serializeManifest(manifest));
+  return { written, manifest };
+}
+
+// src/cli.ts
+var EMPTY_SELECTION = { components: [], categories: [], agents: [] };
+function fullSelection() {
+  return {
+    components: ["skills", ...TREE_COMPONENTS.map((t) => t.id), "entry-files"],
+    categories: CATEGORIES.map((c) => c.id),
+    agents: AGENTS.map((a) => a.id)
+  };
+}
+function parseValue(args, flag) {
+  const i = args.indexOf(flag);
+  return i === -1 ? void 0 : args[i + 1];
+}
+function parseList(args, flag) {
+  const value = parseValue(args, flag);
+  return value === void 0 ? void 0 : value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function selectionFromArgs(args) {
+  if (args.includes("--all")) return fullSelection();
+  const all = fullSelection();
+  return {
+    components: parseList(args, "--components") ?? all.components,
+    categories: parseList(args, "--categories") ?? all.categories,
+    agents: parseList(args, "--agents") ?? all.agents
+  };
+}
+var ORDER = ["conflict", "add", "refresh", "skip"];
+var LABEL = {
+  add: "ADD",
+  refresh: "REFRESH",
+  conflict: "CONFLICT",
+  skip: "SKIP"
+};
+function formatPlan(plan) {
+  const lines = [];
+  for (const type of ORDER) {
+    const inGroup = plan.actions.filter((a) => a.type === type);
+    if (inGroup.length === 0) continue;
+    lines.push(`${LABEL[type]} (${inGroup.length})`);
+    for (const action of inGroup) lines.push(`  ${action.path}`);
+    lines.push("");
+  }
+  const counts = ORDER.map((t) => `${plan.actions.filter((a) => a.type === t).length} ${t}`).join("  ");
+  lines.push(`${plan.actions.length} files:  ${counts}`);
+  return lines.join("\n");
+}
+function printPlan(plan) {
+  console.log("\n" + formatPlan(plan));
+}
+function planFor(projectDir, selection) {
+  const catalog = loadCatalog(TEMPLATE_DIR, kitVersion());
+  const files = resolveSelection(catalog, selection);
+  const plan = planInstall({
+    selection,
+    catalog,
+    onDisk: readOnDiskHashes(projectDir, files),
+    manifest: readManifest(projectDir)
+  });
+  return { catalog, plan };
+}
+function reportConflict(error) {
+  if (!(error instanceof ApplyConflictError)) return false;
+  console.error("Refusing to overwrite existing files:");
+  for (const path of error.paths) console.error(`  ${path}`);
+  console.error("\nMove or remove them, or select different parts.");
+  process.exitCode = 1;
+  return true;
+}
+function dryRun(args) {
+  const projectDir = process.cwd();
+  const selection = selectionFromArgs(args);
+  const { catalog, plan } = planFor(projectDir, selection);
+  console.log(`ai-engineering-kit ${catalog.version} \u2014 dry run for ${projectDir}`);
+  printPlan(plan);
+}
+function init(args) {
+  const projectDir = process.cwd();
+  const selection = selectionFromArgs(args);
+  const projectName = parseValue(args, "--name") ?? basename2(projectDir);
+  try {
+    const result = runInit({ projectDir, selection, projectName });
+    console.log(`ai-engineering-kit ${kitVersion()} installed into ${projectDir}`);
+    console.log(`${result.written.length} files written.`);
+  } catch (error) {
+    if (!reportConflict(error)) throw error;
+  }
+}
+function bail(value) {
+  if (isCancel2(value)) {
+    cancel2("Cancelled \u2014 nothing written.");
+    process.exit(0);
+  }
+  return value;
+}
+async function runReRun(projectDir) {
+  const manifest = readManifest(projectDir);
+  intro(`ai-engineering-kit ${kitVersion()} \u2014 already installed`);
+  const mode = bail(
+    await select({
+      message: "What would you like to do?",
+      options: [
+        { value: "update", label: "Update installed parts to latest" },
+        { value: "add", label: "Add more parts" },
+        { value: "both", label: "Both" }
+      ]
+    })
+  );
+  let addParts = EMPTY_SELECTION;
+  let projectName = basename2(projectDir);
+  if (mode === "add" || mode === "both") {
+    const picked = await promptForSelection(projectDir);
+    addParts = picked.selection;
+    projectName = picked.projectName;
+  }
+  const prepared = prepareReRun({ projectDir, manifest, mode, addParts });
+  const applicable = {
+    actions: prepared.plan.actions.filter((a) => prepared.applyTypes.has(a.type))
+  };
+  log.message(formatPlan(applicable));
+  const resolutions = /* @__PURE__ */ new Map();
+  if (prepared.applyTypes.has("conflict")) {
+    for (const action of applicable.actions.filter((a) => a.type === "conflict")) {
+      const choice = bail(
+        await select({
+          message: `You edited ${action.path}. A newer version exists.`,
+          options: [
+            { value: "keep-mine", label: "Keep mine" },
+            { value: "overwrite", label: "Overwrite with the new version" },
+            { value: "keep-theirs", label: "Keep mine, save theirs as .new" }
+          ]
+        })
+      );
+      resolutions.set(action.path, choice);
+    }
+  }
+  const pending = applicable.actions.filter((a) => a.type !== "skip").length;
+  const proceed = await confirm({ message: `Apply ${pending} changes in ${projectDir}?` });
+  if (isCancel2(proceed) || !proceed) {
+    outro("Nothing written.");
+    return;
+  }
+  const result = applyUpdate({
+    projectDir,
+    templateDir: prepared.templateDir,
+    files: prepared.files,
+    plan: prepared.plan,
+    resolutions,
+    priorManifest: manifest,
+    selection: prepared.selection,
+    version: prepared.version,
+    projectName,
+    applyTypes: prepared.applyTypes
+  });
+  outro(`Done. ${result.written.length} files written.`);
+}
+async function runInteractive() {
+  const projectDir = process.cwd();
+  if (readManifest(projectDir)) return runReRun(projectDir);
+  intro(`ai-engineering-kit ${kitVersion()}`);
+  const { selection, projectName } = await promptForSelection(projectDir);
+  const { plan } = planFor(projectDir, selection);
+  log.message(formatPlan(plan));
+  const pending = plan.actions.filter((a) => a.type !== "skip").length;
+  const proceed = await confirm({ message: `Scaffold ${pending} files into ${projectDir}?` });
+  if (isCancel2(proceed) || !proceed) {
+    outro("Nothing written.");
+    return;
+  }
+  try {
+    const result = runInit({ projectDir, selection, projectName });
+    outro(`Installed ${result.written.length} files into ${projectDir}.`);
+  } catch (error) {
+    if (!reportConflict(error)) throw error;
+  }
+}
+function performReRun(projectDir, mode, addParts) {
+  const manifest = readManifest(projectDir);
+  if (!manifest) {
+    console.error("Not an ai-engineering-kit project (no .ai-kit.json). Run `ai-engineering-kit init` first.");
+    process.exitCode = 1;
+    return;
+  }
+  const prepared = prepareReRun({ projectDir, manifest, mode, addParts });
+  const result = applyUpdate({
+    projectDir,
+    templateDir: prepared.templateDir,
+    files: prepared.files,
+    plan: prepared.plan,
+    resolutions: /* @__PURE__ */ new Map(),
+    // non-interactive: conflicts default to keep-mine
+    priorManifest: manifest,
+    selection: prepared.selection,
+    version: prepared.version,
+    projectName: basename2(projectDir),
+    applyTypes: prepared.applyTypes
+  });
+  console.log(`${result.written.length} files written. Edited files were kept (use the interactive flow to resolve).`);
+}
+function update() {
+  performReRun(process.cwd(), "update", EMPTY_SELECTION);
+}
+function add(args) {
+  const addParts = {
+    components: parseList(args, "--components") ?? [],
+    categories: parseList(args, "--categories") ?? [],
+    agents: parseList(args, "--agents") ?? []
+  };
+  performReRun(process.cwd(), "add", addParts);
+}
+async function main(argv) {
+  const args = argv.slice(2);
+  if (args.includes("--dry-run")) return dryRun(args);
+  if (args[0] === "init") return init(args.slice(1));
+  if (args[0] === "update") return update();
+  if (args[0] === "add") return add(args.slice(1));
+  if (args.length === 0) return runInteractive();
+  console.log("ai-engineering-kit");
+  console.log("\nUsage:");
+  console.log("  ai-engineering-kit                 # interactive install or update");
+  console.log("  ai-engineering-kit init [--name <project>] [--all | --components a,b --categories x --agents y]");
+  console.log("  ai-engineering-kit update          # refresh installed parts to latest (keeps your edits)");
+  console.log("  ai-engineering-kit add --components a,b [--categories x] [--agents y]");
+  console.log("  ai-engineering-kit --dry-run [--all | --components a,b --categories x --agents y]");
+}
+main(process.argv).catch((error) => {
+  console.error(error);
+  process.exit(1);
+});