apero-kit-cli 1.7.0 → 2.0.0

package/dist/index.js

@@ -0,0 +1,2437 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/kits/index.ts
+var KITS, getKit, getKitList;
+var init_kits = __esm({
+  "src/kits/index.ts"() {
+    "use strict";
+    KITS = {
+      engineer: {
+        name: "engineer",
+        description: "Full-stack development kit for building applications",
+        emoji: "\u{1F6E0}\uFE0F",
+        color: "blue",
+        agents: [
+          "planner",
+          "debugger",
+          "fullstack-developer",
+          "tester",
+          "code-reviewer",
+          "git-manager",
+          "database-admin"
+        ],
+        commands: [
+          "plan",
+          "plan/parallel",
+          "plan/fast",
+          "plan/hard",
+          "code",
+          "code/auto",
+          "code/parallel",
+          "fix",
+          "fix/test",
+          "fix/types",
+          "fix/fast",
+          "fix/ci",
+          "test",
+          "test/ui",
+          "review",
+          "review/codebase",
+          "scout",
+          "build",
+          "lint"
+        ],
+        skills: [
+          "frontend-development",
+          "backend-development",
+          "databases",
+          "debugging",
+          "code-review",
+          "planning",
+          "problem-solving"
+        ],
+        workflows: ["feature-development", "bug-fixing"],
+        includeRouter: true,
+        includeHooks: true
+      },
+      researcher: {
+        name: "researcher",
+        description: "Research and analysis kit for exploring codebases",
+        emoji: "\u{1F52C}",
+        color: "green",
+        agents: [
+          "researcher",
+          "scout",
+          "scout-external",
+          "brainstormer",
+          "docs-manager",
+          "planner"
+        ],
+        commands: [
+          "scout",
+          "scout/ext",
+          "investigate",
+          "brainstorm",
+          "docs",
+          "docs/init",
+          "docs/update",
+          "docs/summarize",
+          "plan",
+          "ask",
+          "context"
+        ],
+        skills: [
+          "research",
+          "planning-with-files",
+          "documentation",
+          "project-index"
+        ],
+        workflows: [],
+        includeRouter: true,
+        includeHooks: false
+      },
+      designer: {
+        name: "designer",
+        description: "UI/UX design and frontend development kit",
+        emoji: "\u{1F3A8}",
+        color: "magenta",
+        agents: [
+          "ui-ux-designer",
+          "fullstack-developer",
+          "code-reviewer"
+        ],
+        commands: [
+          "code",
+          "fix",
+          "fix/ui",
+          "test/ui",
+          "review"
+        ],
+        skills: [
+          "ui-ux-pro-max",
+          "frontend-development",
+          "frontend-design"
+        ],
+        workflows: [],
+        includeRouter: false,
+        includeHooks: true
+      },
+      minimal: {
+        name: "minimal",
+        description: "Lightweight kit with essential agents only",
+        emoji: "\u{1F4E6}",
+        color: "yellow",
+        agents: ["planner", "debugger"],
+        commands: ["plan", "fix", "code"],
+        skills: ["planning", "debugging"],
+        workflows: [],
+        includeRouter: false,
+        includeHooks: false
+      },
+      full: {
+        name: "full",
+        description: "Complete kit with ALL agents, commands, and skills",
+        emoji: "\u{1F680}",
+        color: "cyan",
+        agents: "all",
+        commands: "all",
+        skills: "all",
+        workflows: "all",
+        includeRouter: true,
+        includeHooks: true
+      }
+    };
+    getKit = (name) => KITS[name] || null;
+    getKitList = () => Object.values(KITS);
+  }
+});
+
+// src/utils/paths.ts
+import { fileURLToPath } from "url";
+import { dirname, join, resolve } from "path";
+import { existsSync } from "fs";
+import { homedir } from "os";
+function getEmbeddedTemplates() {
+  if (existsSync(TEMPLATES_DIR)) {
+    const agentsMd = join(TEMPLATES_DIR, "AGENTS.md");
+    return {
+      path: TEMPLATES_DIR,
+      type: "embedded",
+      claudeDir: TEMPLATES_DIR,
+      agentsMd: existsSync(agentsMd) ? agentsMd : null
+    };
+  }
+  return null;
+}
+function getGlobalInstallPath() {
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "claude");
+  }
+  return join(homedir(), ".claude");
+}
+function isAkProject(dir = process.cwd()) {
+  const akConfig = join(dir, ".ak", "state.json");
+  const claudeDir = join(dir, ".claude");
+  const opencodeDir = join(dir, ".opencode");
+  const agentDir = join(dir, ".agent");
+  return existsSync(akConfig) || existsSync(claudeDir) || existsSync(opencodeDir) || existsSync(agentDir);
+}
+function getTargetDir(projectDir, target = "claude") {
+  const folder = TARGETS[target] || TARGETS.claude;
+  return join(projectDir, folder);
+}
+function resolveSource(sourceFlag) {
+  if (sourceFlag) {
+    const resolved = resolve(sourceFlag);
+    if (!existsSync(resolved)) {
+      return { error: `Source path not found: ${sourceFlag}` };
+    }
+    const claudeDir = join(resolved, ".claude");
+    const opencodeDir = join(resolved, ".opencode");
+    if (existsSync(claudeDir)) {
+      return {
+        path: resolved,
+        type: "custom",
+        claudeDir,
+        agentsMd: existsSync(join(resolved, "AGENTS.md")) ? join(resolved, "AGENTS.md") : null
+      };
+    }
+    if (existsSync(opencodeDir)) {
+      return {
+        path: resolved,
+        type: "custom",
+        claudeDir: opencodeDir,
+        agentsMd: existsSync(join(resolved, "AGENTS.md")) ? join(resolved, "AGENTS.md") : null
+      };
+    }
+    if (existsSync(join(resolved, "agents")) || existsSync(join(resolved, "commands"))) {
+      return {
+        path: resolved,
+        type: "custom",
+        claudeDir: resolved,
+        agentsMd: existsSync(join(resolved, "AGENTS.md")) ? join(resolved, "AGENTS.md") : null
+      };
+    }
+    return { error: `No templates found in: ${sourceFlag}` };
+  }
+  const embedded = getEmbeddedTemplates();
+  if (embedded) {
+    return embedded;
+  }
+  return {
+    error: "No templates found. Reinstall: npm install -g apero-kit-cli"
+  };
+}
+var __filename, __dirname, CLI_ROOT, TEMPLATES_DIR, TARGETS;
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    CLI_ROOT = __dirname.endsWith("dist") ? resolve(__dirname, "..") : resolve(__dirname, "../..");
+    TEMPLATES_DIR = join(CLI_ROOT, "templates");
+    TARGETS = {
+      claude: ".claude",
+      opencode: ".opencode",
+      generic: ".agent"
+    };
+  }
+});
+
+// src/utils/copy.ts
+import fs from "fs-extra";
+import { join as join2 } from "path";
+async function copyItems(items, type, sourceDir, destDir, mergeMode = false) {
+  const typeDir = join2(sourceDir, type);
+  const destTypeDir = join2(destDir, type);
+  if (!fs.existsSync(typeDir)) {
+    return { copied: [], skipped: items, errors: [] };
+  }
+  await fs.ensureDir(destTypeDir);
+  const copied = [];
+  const skipped = [];
+  const errors = [];
+  for (const item of items) {
+    try {
+      const itemPath = join2(typeDir, item);
+      const itemPathMd = itemPath + ".md";
+      let srcPath;
+      if (fs.existsSync(itemPath)) {
+        srcPath = itemPath;
+      } else if (fs.existsSync(itemPathMd)) {
+        srcPath = itemPathMd;
+      } else {
+        skipped.push(item);
+        continue;
+      }
+      const stat = fs.statSync(srcPath);
+      if (stat.isDirectory()) {
+        await fs.copy(srcPath, join2(destTypeDir, item), { overwrite: !mergeMode });
+      } else {
+        const destPath = srcPath.endsWith(".md") ? join2(destTypeDir, item + ".md") : join2(destTypeDir, item);
+        await fs.ensureDir(join2(destTypeDir, item.split("/").slice(0, -1).join("/")));
+        await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
+      }
+      copied.push(item);
+    } catch (err) {
+      errors.push({ item, error: err.message });
+    }
+  }
+  return { copied, skipped, errors };
+}
+async function copyAllOfType(type, sourceDir, destDir, mergeMode = false) {
+  const typeDir = join2(sourceDir, type);
+  const destTypeDir = join2(destDir, type);
+  if (!fs.existsSync(typeDir)) {
+    return { success: false, error: `${type} directory not found` };
+  }
+  try {
+    await fs.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+async function copyRouter(sourceDir, destDir, mergeMode = false) {
+  const routerDir = join2(sourceDir, "router");
+  if (!fs.existsSync(routerDir)) {
+    return { success: false, error: "Router directory not found" };
+  }
+  try {
+    await fs.copy(routerDir, join2(destDir, "router"), { overwrite: !mergeMode });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+async function copyHooks(sourceDir, destDir, mergeMode = false) {
+  const hooksDir = join2(sourceDir, "hooks");
+  if (!fs.existsSync(hooksDir)) {
+    return { success: false, error: "Hooks directory not found" };
+  }
+  try {
+    await fs.copy(hooksDir, join2(destDir, "hooks"), { overwrite: !mergeMode });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+async function copyBaseFiles(sourceDir, destDir, mergeMode = false) {
+  const baseFiles = ["README.md", "settings.json", ".env.example"];
+  const copied = [];
+  for (const file of baseFiles) {
+    const srcPath = join2(sourceDir, file);
+    const destPath = join2(destDir, file);
+    if (mergeMode && fs.existsSync(destPath)) {
+      continue;
+    }
+    if (fs.existsSync(srcPath)) {
+      await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
+      copied.push(file);
+    }
+  }
+  return copied;
+}
+async function copyAgentsMd(agentsMdPath, projectDir, mergeMode = false) {
+  if (!agentsMdPath || !fs.existsSync(agentsMdPath)) {
+    return false;
+  }
+  const destPath = join2(projectDir, "AGENTS.md");
+  if (mergeMode && fs.existsSync(destPath)) {
+    return false;
+  }
+  await fs.copy(agentsMdPath, destPath, { overwrite: !mergeMode });
+  return true;
+}
+function listAvailable(type, sourceDir) {
+  const typeDir = join2(sourceDir, type);
+  if (!fs.existsSync(typeDir)) {
+    return [];
+  }
+  const items = fs.readdirSync(typeDir);
+  return items.map((item) => {
+    const itemPath = join2(typeDir, item);
+    const isDir = fs.statSync(itemPath).isDirectory();
+    const name = item.replace(/\.md$/, "");
+    return { name, isDir, path: itemPath };
+  });
+}
+var init_copy = __esm({
+  "src/utils/copy.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+import fs2 from "fs-extra";
+import { join as join3, relative } from "path";
+function hashFile(filePath) {
+  if (!fs2.existsSync(filePath)) {
+    return null;
+  }
+  const content = fs2.readFileSync(filePath);
+  return createHash("md5").update(content).digest("hex");
+}
+async function hashDirectory(dirPath, baseDir = dirPath) {
+  const hashes = {};
+  if (!fs2.existsSync(dirPath)) {
+    return hashes;
+  }
+  const items = await fs2.readdir(dirPath, { withFileTypes: true });
+  for (const item of items) {
+    const itemPath = join3(dirPath, item.name);
+    const relativePath = relative(baseDir, itemPath);
+    if (item.isDirectory()) {
+      const subHashes = await hashDirectory(itemPath, baseDir);
+      Object.assign(hashes, subHashes);
+    } else if (item.isFile()) {
+      const hash = hashFile(itemPath);
+      if (hash) {
+        hashes[relativePath] = hash;
+      }
+    }
+  }
+  return hashes;
+}
+var init_hash = __esm({
+  "src/utils/hash.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/state.ts
+import fs3 from "fs-extra";
+import { join as join4 } from "path";
+function getStatePath(projectDir) {
+  return join4(projectDir, STATE_DIR, STATE_FILE);
+}
+async function loadState(projectDir) {
+  const statePath = getStatePath(projectDir);
+  if (!fs3.existsSync(statePath)) {
+    return null;
+  }
+  try {
+    return await fs3.readJson(statePath);
+  } catch {
+    return null;
+  }
+}
+async function saveState(projectDir, state) {
+  const stateDir = join4(projectDir, STATE_DIR);
+  const statePath = join4(stateDir, STATE_FILE);
+  await fs3.ensureDir(stateDir);
+  await fs3.writeJson(statePath, state, { spaces: 2 });
+}
+async function createInitialState(projectDir, options) {
+  const { kit, source, target, installed } = options;
+  const targetDir = join4(projectDir, target);
+  const hashes = await hashDirectory(targetDir);
+  const state = {
+    version: "1.0.0",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdate: (/* @__PURE__ */ new Date()).toISOString(),
+    kit,
+    source,
+    target,
+    installed,
+    originalHashes: hashes
+  };
+  await saveState(projectDir, state);
+  return state;
+}
+async function updateState(projectDir, updates) {
+  const state = await loadState(projectDir);
+  if (!state) {
+    throw new Error("No state found. Is this an ak project?");
+  }
+  const targetDir = join4(projectDir, state.target || ".claude");
+  const newHashes = await hashDirectory(targetDir);
+  const updatedState = {
+    ...state,
+    ...updates,
+    lastUpdate: (/* @__PURE__ */ new Date()).toISOString(),
+    originalHashes: newHashes
+  };
+  await saveState(projectDir, updatedState);
+  return updatedState;
+}
+async function getFileStatuses(projectDir) {
+  const state = await loadState(projectDir);
+  if (!state) {
+    return { error: "No state found" };
+  }
+  const targetDir = join4(projectDir, state.target || ".claude");
+  const currentHashes = await hashDirectory(targetDir);
+  const originalHashes = state.originalHashes || {};
+  const statuses = {
+    unchanged: [],
+    modified: [],
+    added: [],
+    deleted: []
+  };
+  for (const [path, hash] of Object.entries(originalHashes)) {
+    if (currentHashes[path] === void 0) {
+      statuses.deleted.push(path);
+    } else if (currentHashes[path] !== hash) {
+      statuses.modified.push(path);
+    } else {
+      statuses.unchanged.push(path);
+    }
+  }
+  for (const path of Object.keys(currentHashes)) {
+    if (originalHashes[path] === void 0) {
+      statuses.added.push(path);
+    }
+  }
+  return {
+    state,
+    statuses,
+    targetDir
+  };
+}
+var STATE_DIR, STATE_FILE;
+var init_state = __esm({
+  "src/utils/state.ts"() {
+    "use strict";
+    init_hash();
+    STATE_DIR = ".ak";
+    STATE_FILE = "state.json";
+  }
+});
+
+// src/utils/prompts.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+async function promptKit() {
+  const kits = getKitList();
+  const options = [
+    ...kits.map((kit2) => ({
+      value: kit2.name,
+      label: `${kit2.emoji}  ${kit2.name}`,
+      hint: kit2.description
+    })),
+    { value: "custom", label: "\u{1F527}  custom", hint: "Pick your own agents, skills, and commands" }
+  ];
+  const kit = await p.select({ message: "Select a kit:", options });
+  if (p.isCancel(kit)) process.exit(0);
+  return kit;
+}
+async function promptAgents(sourceDir) {
+  const available = listAvailable("agents", sourceDir);
+  if (available.length === 0) return [];
+  const selected = await p.multiselect({
+    message: "Select agents:",
+    options: available.map((item) => ({
+      value: item.name,
+      label: item.name,
+      hint: ["planner", "debugger"].includes(item.name) ? "(recommended)" : void 0
+    })),
+    initialValues: ["planner", "debugger"].filter((n) => available.some((a) => a.name === n))
+  });
+  if (p.isCancel(selected)) process.exit(0);
+  return selected;
+}
+async function promptSkills(sourceDir) {
+  const available = listAvailable("skills", sourceDir).filter((s) => s.isDir);
+  if (available.length === 0) return [];
+  const selected = await p.multiselect({
+    message: "Select skills:",
+    options: available.map((item) => ({
+      value: item.name,
+      label: item.name,
+      hint: ["planning", "debugging"].includes(item.name) ? "(recommended)" : void 0
+    })),
+    initialValues: ["planning", "debugging"].filter((n) => available.some((a) => a.name === n))
+  });
+  if (p.isCancel(selected)) process.exit(0);
+  return selected;
+}
+async function promptCommands(sourceDir) {
+  const available = listAvailable("commands", sourceDir);
+  if (available.length === 0) return [];
+  const selected = await p.multiselect({
+    message: "Select commands:",
+    options: available.map((item) => ({
+      value: item.name,
+      label: item.name,
+      hint: ["plan", "fix", "code"].includes(item.name) ? "(recommended)" : void 0
+    })),
+    initialValues: ["plan", "fix", "code"].filter((n) => available.some((a) => a.name === n))
+  });
+  if (p.isCancel(selected)) process.exit(0);
+  return selected;
+}
+async function promptIncludeRouter() {
+  const result = await p.confirm({ message: "Include router?", initialValue: true });
+  if (p.isCancel(result)) process.exit(0);
+  return result;
+}
+async function promptIncludeHooks() {
+  const result = await p.confirm({ message: "Include hooks?", initialValue: false });
+  if (p.isCancel(result)) process.exit(0);
+  return result;
+}
+async function promptConfirm(message, defaultValue = true) {
+  const result = await p.confirm({ message, initialValue: defaultValue });
+  if (p.isCancel(result)) process.exit(0);
+  return result;
+}
+async function promptExistingTarget(targetPath) {
+  const action = await p.select({
+    message: `${targetPath} already exists. What do you want to do?`,
+    options: [
+      { value: "override", label: "Override", hint: "Replace all files" },
+      { value: "merge", label: "Merge", hint: "Only add missing files" },
+      { value: "skip", label: "Skip", hint: "Do nothing" }
+    ]
+  });
+  if (p.isCancel(action)) process.exit(0);
+  return action;
+}
+async function promptUpdateConfirm(updates) {
+  console.log(pc.cyan("\nChanges to apply:"));
+  if (updates.toUpdate.length > 0) {
+    console.log(pc.green("  Will update:"));
+    updates.toUpdate.slice(0, 10).forEach((f) => console.log(pc.green(`    \u2713 ${f}`)));
+    if (updates.toUpdate.length > 10) console.log(pc.gray(`    ... and ${updates.toUpdate.length - 10} more`));
+  }
+  if (updates.skipped.length > 0) {
+    console.log(pc.yellow("  Will skip (modified locally):"));
+    updates.skipped.slice(0, 5).forEach((f) => console.log(pc.yellow(`    ~ ${f}`)));
+    if (updates.skipped.length > 5) console.log(pc.gray(`    ... and ${updates.skipped.length - 5} more`));
+  }
+  console.log("");
+  return promptConfirm("Apply these updates?", true);
+}
+var init_prompts = __esm({
+  "src/utils/prompts.ts"() {
+    "use strict";
+    init_kits();
+    init_copy();
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand
+});
+import fs4 from "fs-extra";
+import { join as join5, resolve as resolve2 } from "path";
+import pc2 from "picocolors";
+import ora from "ora";
+function filterComponents(list, exclude, only) {
+  if (!list || list === "all") return list;
+  let filtered = [...list];
+  if (only) {
+    const patterns = only.split(",").map((s) => s.trim());
+    filtered = filtered.filter((item) => patterns.some((p4) => item.includes(p4)));
+  }
+  if (exclude) {
+    const patterns = exclude.split(",").map((s) => s.trim());
+    filtered = filtered.filter((item) => !patterns.some((p4) => item.includes(p4)));
+  }
+  return filtered;
+}
+async function initCommand(projectName, options) {
+  console.log("");
+  let projectDir;
+  let isCurrentDir = false;
+  if (options.global) {
+    projectDir = getGlobalInstallPath();
+    isCurrentDir = true;
+    console.log(pc2.cyan(`Installing globally to ${projectDir}`));
+  } else if (!projectName || projectName === ".") {
+    projectDir = process.cwd();
+    projectName = ".";
+    isCurrentDir = true;
+    console.log(pc2.gray(`Initializing in current directory: ${projectDir}`));
+  } else {
+    projectDir = resolve2(process.cwd(), projectName);
+  }
+  let target = options.target || "claude";
+  if (!TARGETS[target]) {
+    console.log(pc2.yellow(`Unknown target "${target}", using "claude"`));
+    target = "claude";
+  }
+  const targetDir = getTargetDir(projectDir, target);
+  let existingAction = null;
+  if (options.fresh && fs4.existsSync(targetDir)) {
+    await fs4.remove(targetDir);
+    const akDir = join5(projectDir, ".ak");
+    if (fs4.existsSync(akDir)) {
+      await fs4.remove(akDir);
+    }
+    console.log(pc2.cyan("Fresh install: removed existing files"));
+    existingAction = null;
+  } else if (fs4.existsSync(targetDir) && !options.force) {
+    if (!process.stdin.isTTY || options.yes) {
+      if (options.yes) {
+        existingAction = "override";
+      } else {
+        console.log(pc2.yellow(`${TARGETS[target]} already exists. Use --force to override.`));
+        return;
+      }
+    } else {
+      existingAction = await promptExistingTarget(TARGETS[target]);
+      if (existingAction === "skip") {
+        console.log(pc2.yellow("Skipped. No changes made."));
+        return;
+      }
+    }
+  }
+  if (!isCurrentDir && fs4.existsSync(projectDir) && !options.force) {
+    const files = fs4.readdirSync(projectDir);
+    if (files.length > 0 && !existingAction) {
+      console.log(pc2.red(`Directory "${projectName}" already exists and is not empty.`));
+      console.log(pc2.gray("Use --force to overwrite."));
+      return;
+    }
+  }
+  const source = resolveSource(options.source);
+  if ("error" in source) {
+    console.log(pc2.red(`Error: ${source.error}`));
+    return;
+  }
+  console.log(pc2.gray(`Source: ${source.path}`));
+  let kitName = options.kit;
+  if (!kitName && !options.force && !options.yes) {
+    kitName = await promptKit();
+  } else if (!kitName) {
+    kitName = "engineer";
+  }
+  const mergeMode = existingAction === "merge";
+  let toInstall = {
+    agents: [],
+    commands: [],
+    skills: [],
+    workflows: [],
+    includeRouter: false,
+    includeHooks: false
+  };
+  if (kitName === "custom" && !options.yes) {
+    console.log(pc2.cyan("\nCustom kit configuration:"));
+    toInstall.agents = await promptAgents(source.claudeDir);
+    toInstall.skills = await promptSkills(source.claudeDir);
+    toInstall.commands = await promptCommands(source.claudeDir);
+    toInstall.includeRouter = await promptIncludeRouter();
+    toInstall.includeHooks = await promptIncludeHooks();
+  } else {
+    const kit = getKit(kitName);
+    if (!kit) {
+      console.log(pc2.red(`Unknown kit: ${kitName}`));
+      console.log(pc2.gray(`Available kits: ${Object.keys(KITS).join(", ")}`));
+      return;
+    }
+    toInstall = {
+      agents: kit.agents,
+      commands: kit.commands,
+      skills: kit.skills,
+      workflows: kit.workflows || [],
+      includeRouter: kit.includeRouter,
+      includeHooks: kit.includeHooks
+    };
+  }
+  if (options.exclude || options.only) {
+    toInstall.agents = filterComponents(toInstall.agents, options.exclude, options.only);
+    toInstall.skills = filterComponents(toInstall.skills, options.exclude, options.only);
+    toInstall.commands = filterComponents(toInstall.commands, options.exclude, options.only);
+    toInstall.workflows = filterComponents(toInstall.workflows, options.exclude, options.only);
+  }
+  console.log(pc2.cyan("\nWill create:"));
+  console.log(pc2.white(`  Project: ${projectName}/`));
+  console.log(pc2.white(`  Target:  ${TARGETS[target]}/`));
+  console.log(pc2.white(`  Kit:     ${kitName}`));
+  if (Array.isArray(toInstall.agents)) {
+    console.log(pc2.gray(`  Agents:  ${toInstall.agents.length}`));
+  }
+  if (Array.isArray(toInstall.skills)) {
+    console.log(pc2.gray(`  Skills:  ${toInstall.skills.length}`));
+  }
+  if (Array.isArray(toInstall.commands)) {
+    console.log(pc2.gray(`  Commands: ${toInstall.commands.length}`));
+  }
+  console.log("");
+  if (!options.force && !options.yes) {
+    if (!await promptConfirm("Proceed?")) {
+      console.log(pc2.yellow("Cancelled."));
+      return;
+    }
+  }
+  const spinner = ora("Creating project...").start();
+  try {
+    await fs4.ensureDir(projectDir);
+    const targetDir2 = getTargetDir(projectDir, target);
+    await fs4.ensureDir(targetDir2);
+    spinner.text = mergeMode ? "Merging agents..." : "Copying agents...";
+    if (toInstall.agents === "all") {
+      await copyAllOfType("agents", source.claudeDir, targetDir2, mergeMode);
+    } else if (toInstall.agents.length > 0) {
+      await copyItems(toInstall.agents, "agents", source.claudeDir, targetDir2, mergeMode);
+    }
+    spinner.text = mergeMode ? "Merging skills..." : "Copying skills...";
+    if (toInstall.skills === "all") {
+      await copyAllOfType("skills", source.claudeDir, targetDir2, mergeMode);
+    } else if (toInstall.skills.length > 0) {
+      await copyItems(toInstall.skills, "skills", source.claudeDir, targetDir2, mergeMode);
+    }
+    spinner.text = mergeMode ? "Merging commands..." : "Copying commands...";
+    if (toInstall.commands === "all") {
+      await copyAllOfType("commands", source.claudeDir, targetDir2, mergeMode);
+    } else if (toInstall.commands.length > 0) {
+      await copyItems(toInstall.commands, "commands", source.claudeDir, targetDir2, mergeMode);
+    }
+    spinner.text = mergeMode ? "Merging workflows..." : "Copying workflows...";
+    if (toInstall.workflows === "all") {
+      await copyAllOfType("workflows", source.claudeDir, targetDir2, mergeMode);
+    } else if (toInstall.workflows && toInstall.workflows.length > 0) {
+      await copyItems(toInstall.workflows, "workflows", source.claudeDir, targetDir2, mergeMode);
+    }
+    if (toInstall.includeRouter) {
+      spinner.text = mergeMode ? "Merging router..." : "Copying router...";
+      await copyRouter(source.claudeDir, targetDir2, mergeMode);
+    }
+    if (toInstall.includeHooks) {
+      spinner.text = mergeMode ? "Merging hooks..." : "Copying hooks...";
+      await copyHooks(source.claudeDir, targetDir2, mergeMode);
+    }
+    spinner.text = mergeMode ? "Merging base files..." : "Copying base files...";
+    await copyBaseFiles(source.claudeDir, targetDir2, mergeMode);
+    if (source.agentsMd) {
+      await copyAgentsMd(source.agentsMd, projectDir, mergeMode);
+    }
+    spinner.text = "Saving state...";
+    await createInitialState(projectDir, {
+      kit: kitName,
+      source: source.path,
+      target: TARGETS[target],
+      installed: {
+        agents: toInstall.agents === "all" ? ["all"] : toInstall.agents,
+        skills: toInstall.skills === "all" ? ["all"] : toInstall.skills,
+        commands: toInstall.commands === "all" ? ["all"] : toInstall.commands,
+        workflows: toInstall.workflows === "all" ? ["all"] : toInstall.workflows || [],
+        router: toInstall.includeRouter,
+        hooks: toInstall.includeHooks
+      }
+    });
+    const actionWord = mergeMode ? "merged" : existingAction === "override" ? "overridden" : "created";
+    spinner.succeed(pc2.green(`Project ${actionWord} successfully!`));
+    console.log("");
+    if (!isCurrentDir) {
+      console.log(pc2.cyan("Next steps:"));
+      console.log(pc2.white(`  cd ${projectName}`));
+      console.log(pc2.white("  # Start coding with Claude Code"));
+    } else {
+      console.log(pc2.cyan("Ready to code with Claude Code!"));
+    }
+    console.log("");
+    console.log(pc2.gray("Useful commands:"));
+    console.log(pc2.gray("  ak status     - Check file status"));
+    console.log(pc2.gray("  ak add <item> - Add more agents/skills"));
+    console.log(pc2.gray("  ak update     - Sync from source"));
+    console.log("");
+  } catch (error) {
+    spinner.fail(pc2.red("Failed to create project"));
+    console.error(pc2.red(error.message));
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+  }
+}
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_kits();
+    init_paths();
+    init_copy();
+    init_state();
+    init_prompts();
+  }
+});
+
+// src/commands/add.ts
+var add_exports = {};
+__export(add_exports, {
+  addCommand: () => addCommand
+});
+import fs5 from "fs-extra";
+import { join as join6 } from "path";
+import pc3 from "picocolors";
+import ora2 from "ora";
+async function addCommand(item, options = {}) {
+  const parts = item.split(":");
+  if (parts.length !== 2) {
+    console.log(pc3.red("Invalid format. Use: ak add <type>:<name>"));
+    console.log(pc3.gray("Examples:"));
+    console.log(pc3.gray("  ak add skill:databases"));
+    console.log(pc3.gray("  ak add agent:debugger"));
+    console.log(pc3.gray("  ak add command:fix/ci"));
+    return;
+  }
+  const [type, name] = parts;
+  const validTypes = ["agent", "agents", "skill", "skills", "command", "commands", "workflow", "workflows"];
+  if (!validTypes.includes(type)) {
+    console.log(pc3.red(`Invalid type: ${type}`));
+    console.log(pc3.gray(`Valid types: agent, skill, command, workflow`));
+    return;
+  }
+  const typeMap = {
+    agent: "agents",
+    agents: "agents",
+    skill: "skills",
+    skills: "skills",
+    command: "commands",
+    commands: "commands",
+    workflow: "workflows",
+    workflows: "workflows"
+  };
+  const normalizedType = typeMap[type];
+  const projectDir = options.path || process.cwd();
+  if (!isAkProject(projectDir)) {
+    console.log(pc3.red("Not in an ak project."));
+    console.log(pc3.gray('Run "ak init" first or use --path to specify project directory.'));
+    return;
+  }
+  const state = await loadState(projectDir);
+  if (!state) {
+    console.log(pc3.yellow("Warning: No state file found. Creating fresh state after add."));
+  }
+  const sourceFlag = options.source || (state ? state.source : null);
+  const source = resolveSource(sourceFlag);
+  if ("error" in source) {
+    console.log(pc3.red(`Error: ${source.error}`));
+    return;
+  }
+  const available = listAvailable(normalizedType, source.claudeDir);
+  const exists = available.some((a) => a.name === name);
+  if (!exists) {
+    console.log(pc3.red(`${type} "${name}" not found in source.`));
+    console.log(pc3.gray(`Use "ak list ${normalizedType}" to see available options.`));
+    return;
+  }
+  const targetFolder = state?.target || ".claude";
+  const targetDir = join6(projectDir, targetFolder);
+  const destPath = join6(targetDir, normalizedType, name);
+  const destPathMd = destPath + ".md";
+  if (fs5.existsSync(destPath) || fs5.existsSync(destPathMd)) {
+    console.log(pc3.yellow(`${type} "${name}" already exists in project.`));
+    console.log(pc3.gray('Use "ak update" to refresh from source.'));
+    return;
+  }
+  const spinner = ora2(`Adding ${type} "${name}"...`).start();
+  try {
+    const result = await copyItems([name], normalizedType, source.claudeDir, targetDir);
+    if (result.copied.length > 0) {
+      spinner.succeed(pc3.green(`Added ${type}: ${name}`));
+      if (state) {
+        const installed = state.installed || {};
+        const typeArray = installed[normalizedType];
+        if (!typeArray) {
+          installed[normalizedType] = [name];
+        } else if (Array.isArray(typeArray) && !typeArray.includes(name)) {
+          typeArray.push(name);
+        }
+        const newHashes = await hashDirectory(targetDir);
+        await updateState(projectDir, {
+          installed,
+          originalHashes: newHashes
+        });
+      }
+      console.log(pc3.gray(`Location: ${targetFolder}/${normalizedType}/${name}`));
+    } else if (result.skipped.length > 0) {
+      spinner.fail(pc3.red(`Could not find ${type}: ${name}`));
+    } else if (result.errors.length > 0) {
+      spinner.fail(pc3.red(`Error adding ${type}: ${result.errors[0].error}`));
+    }
+  } catch (error) {
+    spinner.fail(pc3.red(`Failed to add ${type}`));
+    console.error(pc3.red(error.message));
+  }
+}
+var init_add = __esm({
+  "src/commands/add.ts"() {
+    "use strict";
+    init_paths();
+    init_copy();
+    init_state();
+    init_hash();
+  }
+});
+
+// src/commands/list.ts
+var list_exports = {};
+__export(list_exports, {
+  listCommand: () => listCommand
+});
+import pc4 from "picocolors";
+async function listCommand(type, options = {}) {
+  const validTypes = ["kits", "agents", "skills", "commands", "workflows"];
+  if (!type) {
+    console.log(pc4.cyan("\nAvailable list commands:"));
+    console.log(pc4.white("  ak list kits      - List available kits"));
+    console.log(pc4.white("  ak list agents    - List available agents"));
+    console.log(pc4.white("  ak list skills    - List available skills"));
+    console.log(pc4.white("  ak list commands  - List available commands"));
+    console.log(pc4.white("  ak list workflows - List available workflows"));
+    console.log("");
+    return;
+  }
+  type = type.toLowerCase();
+  if (!validTypes.includes(type)) {
+    console.log(pc4.red(`Unknown type: ${type}`));
+    console.log(pc4.gray(`Valid types: ${validTypes.join(", ")}`));
+    return;
+  }
+  if (type === "kits") {
+    listKits();
+    return;
+  }
+  const source = resolveSource(options.source);
+  if ("error" in source) {
+    console.log(pc4.red(`Error: ${source.error}`));
+    return;
+  }
+  console.log(pc4.gray(`Source: ${source.path}
+`));
+  switch (type) {
+    case "agents":
+      listAgents(source.claudeDir);
+      break;
+    case "skills":
+      listSkills(source.claudeDir);
+      break;
+    case "commands":
+      listCommandsList(source.claudeDir);
+      break;
+    case "workflows":
+      listWorkflows(source.claudeDir);
+      break;
+  }
+}
+function listKits() {
+  const kits = getKitList();
+  console.log(pc4.bold(pc4.cyan("\nAvailable Kits:\n")));
+  for (const kit of kits) {
+    const colorFn = pc4[kit.color] || pc4.white;
+    console.log(`  ${kit.emoji}  ${colorFn(pc4.bold(kit.name.padEnd(12)))} - ${kit.description}`);
+    if (Array.isArray(kit.agents)) {
+      const agentCount = Array.isArray(kit.agents) ? kit.agents.length : "all";
+      const skillCount = Array.isArray(kit.skills) ? kit.skills.length : "all";
+      const cmdCount = Array.isArray(kit.commands) ? kit.commands.length : "all";
+      console.log(pc4.gray(`      Agents: ${agentCount} | Skills: ${skillCount} | Commands: ${cmdCount}`));
+    } else {
+      console.log(pc4.gray("      Includes: ALL agents, skills, commands"));
+    }
+  }
+  console.log(`
+  \u{1F527}  ${pc4.bold("custom".padEnd(12))} - Pick your own agents, skills, and commands`);
+  console.log("");
+}
+function listAgents(sourceDir) {
+  const agents = listAvailable("agents", sourceDir);
+  console.log(pc4.bold(pc4.cyan(`Available Agents (${agents.length}):
+`)));
+  if (agents.length === 0) {
+    console.log(pc4.gray("  No agents found"));
+    return;
+  }
+  const cols = 3;
+  const rows = Math.ceil(agents.length / cols);
+  for (let i = 0; i < rows; i++) {
+    let line = "  ";
+    for (let j = 0; j < cols; j++) {
+      const idx = i + j * rows;
+      if (idx < agents.length) {
+        line += pc4.white(agents[idx].name.padEnd(25));
+      }
+    }
+    console.log(line);
+  }
+  console.log("");
+}
+function listSkills(sourceDir) {
+  const skills = listAvailable("skills", sourceDir).filter((s) => s.isDir);
+  console.log(pc4.bold(pc4.cyan(`Available Skills (${skills.length}):
+`)));
+  if (skills.length === 0) {
+    console.log(pc4.gray("  No skills found"));
+    return;
+  }
+  const cols = 2;
+  const rows = Math.ceil(skills.length / cols);
+  for (let i = 0; i < rows; i++) {
+    let line = "  ";
+    for (let j = 0; j < cols; j++) {
+      const idx = i + j * rows;
+      if (idx < skills.length) {
+        line += pc4.white(skills[idx].name.padEnd(35));
+      }
+    }
+    console.log(line);
+  }
+  console.log("");
+}
+function listCommandsList(sourceDir) {
+  const commands = listAvailable("commands", sourceDir);
+  console.log(pc4.bold(pc4.cyan(`Available Commands (${commands.length}):
+`)));
+  if (commands.length === 0) {
+    console.log(pc4.gray("  No commands found"));
+    return;
+  }
+  const files = commands.filter((c) => !c.isDir);
+  const dirs = commands.filter((c) => c.isDir);
+  console.log(pc4.gray("  Main commands:"));
+  const cols = 4;
+  const rows = Math.ceil(files.length / cols);
+  for (let i = 0; i < rows; i++) {
+    let line = "    ";
+    for (let j = 0; j < cols; j++) {
+      const idx = i + j * rows;
+      if (idx < files.length) {
+        line += pc4.white(("/" + files[idx].name).padEnd(18));
+      }
+    }
+    console.log(line);
+  }
+  if (dirs.length > 0) {
+    console.log(pc4.gray("\n  Command groups:"));
+    for (const dir of dirs) {
+      console.log(pc4.yellow(`    /${dir.name}/`));
+    }
+  }
+  console.log("");
+}
+function listWorkflows(sourceDir) {
+  const workflows = listAvailable("workflows", sourceDir);
+  console.log(pc4.bold(pc4.cyan(`Available Workflows (${workflows.length}):
+`)));
+  if (workflows.length === 0) {
+    console.log(pc4.gray("  No workflows found"));
+    return;
+  }
+  for (const wf of workflows) {
+    console.log(pc4.white(`  \u2022 ${wf.name}`));
+  }
+  console.log("");
+}
+var init_list = __esm({
+  "src/commands/list.ts"() {
+    "use strict";
+    init_kits();
+    init_paths();
+    init_copy();
+  }
+});
+
+// src/commands/update.ts
+var update_exports = {};
+__export(update_exports, {
+  updateCommand: () => updateCommand
+});
+import fs6 from "fs-extra";
+import { join as join7 } from "path";
+import pc5 from "picocolors";
+import ora3 from "ora";
+async function updateCommand(options = {}) {
+  const projectDir = process.cwd();
+  if (!isAkProject(projectDir)) {
+    console.log(pc5.red("Not in an ak project."));
+    console.log(pc5.gray('Run "ak init" first.'));
+    return;
+  }
+  const state = await loadState(projectDir);
+  if (!state) {
+    console.log(pc5.red("No state file found."));
+    console.log(pc5.gray('This project may have been created without ak. Run "ak doctor" for more info.'));
+    return;
+  }
+  const sourceFlag = options.source || state.source;
+  const source = resolveSource(sourceFlag);
+  if ("error" in source) {
+    console.log(pc5.red(`Error: ${source.error}`));
+    return;
+  }
+  console.log(pc5.gray(`Source: ${source.path}`));
+  console.log(pc5.gray(`Target: ${state.target}`));
+  console.log("");
+  const spinner = ora3("Checking for updates...").start();
+  try {
+    const result = await getFileStatuses(projectDir);
+    if ("error" in result) {
+      spinner.fail(pc5.red(result.error));
+      return;
+    }
+    const { statuses, targetDir } = result;
+    let typesToUpdate = ["agents", "skills", "commands", "workflows"];
+    if (options.agents) typesToUpdate = ["agents"];
+    if (options.skills) typesToUpdate = ["skills"];
+    if (options.commands) typesToUpdate = ["commands"];
+    const sourceHashes = {};
+    for (const type of typesToUpdate) {
+      const typeDir = join7(source.claudeDir, type);
+      if (fs6.existsSync(typeDir)) {
+        const hashes = await hashDirectory(typeDir);
+        for (const [path, hash] of Object.entries(hashes)) {
+          sourceHashes[`${type}/${path}`] = hash;
+        }
+      }
+    }
+    const toUpdate = [];
+    const skipped = [];
+    const newFiles = [];
+    for (const [path, sourceHash] of Object.entries(sourceHashes)) {
+      const currentPath = join7(targetDir, path);
+      const originalHash = state.originalHashes?.[path];
+      const currentHash = fs6.existsSync(currentPath) ? hashFile(currentPath) : null;
+      if (!currentHash) {
+        newFiles.push(path);
+      } else if (currentHash === originalHash) {
+        if (sourceHash !== currentHash) {
+          toUpdate.push(path);
+        }
+      } else {
+        if (sourceHash !== originalHash) {
+          skipped.push(path);
+        }
+      }
+    }
+    spinner.stop();
+    if (toUpdate.length === 0 && newFiles.length === 0) {
+      console.log(pc5.green("\u2713 Already up to date!"));
+      if (skipped.length > 0) {
+        console.log(pc5.yellow(`  ${skipped.length} file(s) skipped (modified locally)`));
+      }
+      return;
+    }
+    console.log(pc5.cyan("Updates available:"));
+    console.log(pc5.green(`  ${toUpdate.length} file(s) to update`));
+    console.log(pc5.blue(`  ${newFiles.length} new file(s)`));
+    if (skipped.length > 0) {
+      console.log(pc5.yellow(`  ${skipped.length} file(s) skipped (modified locally)`));
+    }
+    console.log("");
+    if (options.dryRun) {
+      console.log(pc5.cyan("Dry run - no changes made"));
+      console.log(pc5.gray("\nFiles that would be updated:"));
+      [...toUpdate, ...newFiles].forEach((f) => console.log(pc5.gray(`  ${f}`)));
+      if (skipped.length > 0) {
+        console.log(pc5.gray("\nFiles that would be skipped:"));
+        skipped.forEach((f) => console.log(pc5.yellow(`  ~ ${f}`)));
+      }
+      return;
+    }
+    if (!options.force) {
+      const confirmed = await promptUpdateConfirm({
+        toUpdate: [...toUpdate, ...newFiles],
+        skipped
+      });
+      if (!confirmed) {
+        console.log(pc5.yellow("Cancelled."));
+        return;
+      }
+    }
+    const updateSpinner = ora3("Applying updates...").start();
+    let updated = 0;
+    let failed = 0;
+    for (const path of [...toUpdate, ...newFiles]) {
+      try {
+        const srcPath = join7(source.claudeDir, path);
+        const destPath = join7(targetDir, path);
+        await fs6.ensureDir(join7(targetDir, path.split("/").slice(0, -1).join("/")));
+        await fs6.copy(srcPath, destPath, { overwrite: true });
+        updated++;
+      } catch (err) {
+        failed++;
+        if (process.env.DEBUG) {
+          console.error(`Failed to update ${path}: ${err.message}`);
+        }
+      }
+    }
+    const newHashes = await hashDirectory(targetDir);
+    await updateState(projectDir, {
+      source: source.path,
+      originalHashes: newHashes
+    });
+    updateSpinner.succeed(pc5.green(`Updated ${updated} file(s)`));
+    if (failed > 0) {
+      console.log(pc5.yellow(`  ${failed} file(s) failed to update`));
+    }
+    if (skipped.length > 0) {
+      console.log(pc5.gray(`
+Skipped files (modified locally):`));
+      skipped.slice(0, 5).forEach((f) => console.log(pc5.yellow(`  ~ ${f}`)));
+      if (skipped.length > 5) {
+        console.log(pc5.gray(`  ... and ${skipped.length - 5} more`));
+      }
+    }
+  } catch (error) {
+    spinner.fail(pc5.red("Update failed"));
+    console.error(pc5.red(error.message));
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+  }
+}
+var init_update = __esm({
+  "src/commands/update.ts"() {
+    "use strict";
+    init_paths();
+    init_state();
+    init_hash();
+    init_prompts();
+  }
+});
+
+// src/commands/status.ts
+var status_exports = {};
+__export(status_exports, {
+  statusCommand: () => statusCommand
+});
+import pc6 from "picocolors";
+import fs7 from "fs-extra";
+async function statusCommand(options = {}) {
+  const projectDir = process.cwd();
+  if (!isAkProject(projectDir)) {
+    console.log(pc6.red("Not in an ak project."));
+    console.log(pc6.gray('Run "ak init" first.'));
+    return;
+  }
+  const state = await loadState(projectDir);
+  if (!state) {
+    console.log(pc6.yellow("No state file found."));
+    console.log(pc6.gray("This project may have been created without ak."));
+    return;
+  }
+  console.log(pc6.bold(pc6.cyan("\nProject Status\n")));
+  console.log(pc6.white(`  Kit:     ${state.kit}`));
+  console.log(pc6.white(`  Target:  ${state.target}`));
+  console.log(pc6.white(`  Source:  ${state.source}`));
+  console.log(pc6.gray(`  Created: ${new Date(state.createdAt).toLocaleDateString()}`));
+  console.log(pc6.gray(`  Updated: ${new Date(state.lastUpdate).toLocaleDateString()}`));
+  console.log("");
+  const result = await getFileStatuses(projectDir);
+  if ("error" in result) {
+    console.log(pc6.red(`Error: ${result.error}`));
+    return;
+  }
+  const { statuses } = result;
+  const total = statuses.unchanged.length + statuses.modified.length + statuses.added.length;
+  console.log(pc6.cyan("File Status:"));
+  console.log(pc6.green(`  \u2713 ${statuses.unchanged.length} unchanged`));
+  if (statuses.modified.length > 0) {
+    console.log(pc6.yellow(`  ~ ${statuses.modified.length} modified`));
+  }
+  if (statuses.added.length > 0) {
+    console.log(pc6.blue(`  + ${statuses.added.length} added locally`));
+  }
+  if (statuses.deleted.length > 0) {
+    console.log(pc6.red(`  - ${statuses.deleted.length} deleted`));
+  }
+  console.log(pc6.gray(`  Total: ${total} files tracked`));
+  console.log("");
+  if (statuses.modified.length > 0 && (options.verbose || statuses.modified.length <= 10)) {
+    console.log(pc6.yellow("Modified files:"));
+    for (const file of statuses.modified) {
+      console.log(pc6.yellow(`  ~ ${file}`));
+    }
+    console.log("");
+  } else if (statuses.modified.length > 10) {
+    console.log(pc6.yellow(`Modified files: (showing first 10, use --verbose for all)`));
+    for (const file of statuses.modified.slice(0, 10)) {
+      console.log(pc6.yellow(`  ~ ${file}`));
+    }
+    console.log(pc6.gray(`  ... and ${statuses.modified.length - 10} more`));
+    console.log("");
+  }
+  if (statuses.added.length > 0 && (options.verbose || statuses.added.length <= 5)) {
+    console.log(pc6.blue("Added locally:"));
+    for (const file of statuses.added) {
+      console.log(pc6.blue(`  + ${file}`));
+    }
+    console.log("");
+  }
+  if (state.installed) {
+    console.log(pc6.cyan("Installed Components:"));
+    const { agents, skills, commands, workflows, router, hooks } = state.installed;
+    if (agents && agents.length > 0) {
+      console.log(pc6.gray(`  Agents:    ${agents.includes("all") ? "ALL" : agents.length}`));
+    }
+    if (skills && skills.length > 0) {
+      console.log(pc6.gray(`  Skills:    ${skills.includes("all") ? "ALL" : skills.length}`));
+    }
+    if (commands && commands.length > 0) {
+      console.log(pc6.gray(`  Commands:  ${commands.includes("all") ? "ALL" : commands.length}`));
+    }
+    if (workflows && workflows.length > 0) {
+      console.log(pc6.gray(`  Workflows: ${workflows.includes("all") ? "ALL" : workflows.length}`));
+    }
+    if (router) console.log(pc6.gray("  Router:    \u2713"));
+    if (hooks) console.log(pc6.gray("  Hooks:     \u2713"));
+    console.log("");
+  }
+  if (state.source && !fs7.existsSync(state.source)) {
+    console.log(pc6.yellow("\u26A0 Source directory not found. Update may not work."));
+    console.log(pc6.gray(`  Expected: ${state.source}`));
+    console.log("");
+  }
+}
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_paths();
+    init_state();
+  }
+});
+
+// src/commands/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  doctorCommand: () => doctorCommand
+});
+import fs8 from "fs-extra";
+import { join as join8 } from "path";
+import pc7 from "picocolors";
+async function doctorCommand(options = {}) {
+  const projectDir = process.cwd();
+  let targetDir = null;
+  for (const [name, folder] of Object.entries(TARGETS)) {
+    const dir = join8(projectDir, folder);
+    if (fs8.existsSync(dir)) {
+      targetDir = { name, folder, dir };
+      break;
+    }
+  }
+  let state = await loadState(projectDir);
+  const checks = [
+    {
+      name: "project",
+      label: "ak project detected",
+      severity: "error",
+      check: () => isAkProject(projectDir),
+      fix: async () => {
+        await fs8.ensureDir(join8(projectDir, ".ak"));
+      }
+    },
+    {
+      name: "state",
+      label: "State file (.ak/state.json) exists",
+      severity: "warning",
+      check: () => state !== null,
+      fix: async () => {
+        const kit = "unknown";
+        const source = "";
+        const target = targetDir ? targetDir.folder : ".claude";
+        const installed = {};
+        if (targetDir) {
+          const dirs = ["agents", "skills", "commands", "workflows"];
+          for (const dir of dirs) {
+            const fullPath = join8(targetDir.dir, dir);
+            if (fs8.existsSync(fullPath)) {
+              const items = fs8.readdirSync(fullPath).filter((f) => !f.startsWith("."));
+              if (items.length > 0) {
+                installed[dir] = items;
+              }
+            }
+          }
+        }
+        await createInitialState(projectDir, { kit, source, target, installed });
+        state = await loadState(projectDir);
+      }
+    },
+    {
+      name: "target",
+      label: "Target directory exists",
+      severity: "error",
+      check: () => targetDir !== null,
+      getMeta: () => targetDir ? { folder: targetDir.folder } : {}
+    },
+    {
+      name: "agents_md",
+      label: "AGENTS.md exists",
+      severity: "warning",
+      check: () => fs8.existsSync(join8(projectDir, "AGENTS.md"))
+    },
+    {
+      name: "source",
+      label: "Source directory accessible",
+      severity: "error",
+      check: () => {
+        if (!state || !state.source) return true;
+        return fs8.existsSync(state.source);
+      },
+      getMeta: () => state && state.source ? { source: state.source } : {}
+    },
+    {
+      name: "subdirs_agents",
+      label: "agents/ exists",
+      severity: "warning",
+      check: () => {
+        if (!targetDir) return false;
+        return fs8.existsSync(join8(targetDir.dir, "agents"));
+      },
+      fix: async () => {
+        if (targetDir) {
+          await fs8.ensureDir(join8(targetDir.dir, "agents"));
+        }
+      },
+      getMeta: () => {
+        if (!targetDir) return {};
+        const fullPath = join8(targetDir.dir, "agents");
+        if (fs8.existsSync(fullPath)) {
+          const items = fs8.readdirSync(fullPath).length;
+          return { items };
+        }
+        return {};
+      }
+    },
+    {
+      name: "subdirs_commands",
+      label: "commands/ exists",
+      severity: "warning",
+      check: () => {
+        if (!targetDir) return false;
+        return fs8.existsSync(join8(targetDir.dir, "commands"));
+      },
+      fix: async () => {
+        if (targetDir) {
+          await fs8.ensureDir(join8(targetDir.dir, "commands"));
+        }
+      },
+      getMeta: () => {
+        if (!targetDir) return {};
+        const fullPath = join8(targetDir.dir, "commands");
+        if (fs8.existsSync(fullPath)) {
+          const items = fs8.readdirSync(fullPath).length;
+          return { items };
+        }
+        return {};
+      }
+    },
+    {
+      name: "subdirs_skills",
+      label: "skills/ exists",
+      severity: "warning",
+      check: () => {
+        if (!targetDir) return false;
+        return fs8.existsSync(join8(targetDir.dir, "skills"));
+      },
+      fix: async () => {
+        if (targetDir) {
+          await fs8.ensureDir(join8(targetDir.dir, "skills"));
+        }
+      },
+      getMeta: () => {
+        if (!targetDir) return {};
+        const fullPath = join8(targetDir.dir, "skills");
+        if (fs8.existsSync(fullPath)) {
+          const items = fs8.readdirSync(fullPath).length;
+          return { items };
+        }
+        return {};
+      }
+    }
+  ];
+  const results = await runChecks(checks, options);
+  if (options.json) {
+    await outputJson(projectDir, results);
+    return computeSummary(results);
+  }
+  if (options.report) {
+    await outputReport(projectDir, results, options);
+  }
+  if (options.checkOnly) {
+    const summary = computeSummary(results);
+    if (summary.issues > 0) {
+      process.exit(1);
+    } else {
+      process.exit(0);
+    }
+  }
+  await outputColored(projectDir, results, state, targetDir);
+  return computeSummary(results);
+}
+async function runChecks(checks, options) {
+  const results = [];
+  for (const c of checks) {
+    const passed = await c.check();
+    const meta = c.getMeta ? await c.getMeta() : void 0;
+    const result = {
+      name: c.name,
+      label: c.label,
+      passed,
+      severity: c.severity,
+      meta
+    };
+    if (!passed && options.fix && c.fix) {
+      try {
+        await c.fix();
+        result.fixed = true;
+        result.passed = true;
+      } catch (e) {
+        result.fixError = e.message;
+      }
+    }
+    results.push(result);
+  }
+  return results;
+}
+function computeSummary(results) {
+  let issues = 0;
+  let warnings = 0;
+  for (const r of results) {
+    if (!r.passed && r.severity === "error") {
+      issues++;
+    }
+    if (!r.passed && r.severity === "warning") {
+      warnings++;
+    }
+  }
+  return { issues, warnings };
+}
+async function outputJson(projectDir, results) {
+  const summary = computeSummary(results);
+  const fixed = results.filter((r) => r.fixed).length;
+  const output = {
+    project: projectDir,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    checks: results,
+    summary: {
+      total: results.length,
+      passed: results.filter((r) => r.passed).length,
+      failed: results.filter((r) => !r.passed).length,
+      warnings: summary.warnings,
+      fixed
+    }
+  };
+  console.log(JSON.stringify(output, null, 2));
+}
+async function outputReport(projectDir, results, options) {
+  const summary = computeSummary(results);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  let markdown = `# Apero Kit Doctor Report
+
+`;
+  markdown += `**Project:** ${projectDir}
+`;
+  markdown += `**Timestamp:** ${timestamp}
+
+`;
+  markdown += `## Summary
+
+`;
+  markdown += `- Total checks: ${results.length}
+`;
+  markdown += `- Passed: ${results.filter((r) => r.passed).length}
+`;
+  markdown += `- Failed: ${results.filter((r) => !r.passed).length}
+`;
+  markdown += `- Errors: ${summary.issues}
+`;
+  markdown += `- Warnings: ${summary.warnings}
+`;
+  if (options.fix) {
+    markdown += `- Fixed: ${results.filter((r) => r.fixed).length}
+`;
+  }
+  markdown += `
+`;
+  markdown += `## Check Results
+
+`;
+  for (const r of results) {
+    const icon = r.passed ? "\u2713" : r.severity === "error" ? "\u2717" : "\u26A0";
+    markdown += `### ${icon} ${r.label}
+
+`;
+    markdown += `- **Status:** ${r.passed ? "PASS" : "FAIL"}
+`;
+    markdown += `- **Severity:** ${r.severity}
+`;
+    if (r.fixed) {
+      markdown += `- **Fixed:** Yes
+`;
+    }
+    if (r.fixError) {
+      markdown += `- **Fix Error:** ${r.fixError}
+`;
+    }
+    if (r.meta && Object.keys(r.meta).length > 0) {
+      markdown += `- **Details:** ${JSON.stringify(r.meta)}
+`;
+    }
+    markdown += `
+`;
+  }
+  markdown += `## Suggestions
+
+`;
+  const failedChecks = results.filter((r) => !r.passed);
+  if (failedChecks.length === 0) {
+    markdown += `All checks passed! No suggestions.
+`;
+  } else {
+    for (const r of failedChecks) {
+      if (r.name === "project") {
+        markdown += `- Run "ak init ." to initialize this directory
+`;
+      }
+      if (r.name === "state") {
+        markdown += `- State file is missing. Re-run "ak init" or create manually
+`;
+      }
+      if (r.name === "source" && r.meta?.source) {
+        markdown += `- Update source path: ak update --source <new-path>
+`;
+      }
+    }
+  }
+  const reportPath = join8(projectDir, ".ak", "doctor-report.md");
+  await fs8.ensureDir(join8(projectDir, ".ak"));
+  await fs8.writeFile(reportPath, markdown, "utf-8");
+  if (!options.json) {
+    console.log(pc7.green(`
+\u2713 Report saved to ${reportPath}
+`));
+  }
+}
+async function outputColored(projectDir, results, state, targetDir) {
+  console.log(pc7.bold(pc7.cyan("\nApero Kit Doctor\n")));
+  console.log(pc7.gray("Checking project health...\n"));
+  for (const r of results) {
+    if (r.passed) {
+      let msg = `\u2713 ${r.label}`;
+      if (r.name === "target" && r.meta?.folder) {
+        msg += ` (${r.meta.folder})`;
+      }
+      if (r.name.startsWith("subdirs_") && r.meta?.items !== void 0) {
+        msg += ` (${r.meta.items} items)`;
+      }
+      console.log(pc7.green(msg));
+    } else {
+      const icon = r.severity === "error" ? "\u2717" : "\u26A0";
+      const color = r.severity === "error" ? pc7.red : pc7.yellow;
+      let msg = `${icon} ${r.label}`;
+      if (r.name === "target") {
+        msg = `${icon} No target directory (.claude/, .opencode/, .agent/)`;
+      }
+      if (r.name === "agents_md") {
+        msg = `${icon} AGENTS.md not found (optional but recommended)`;
+      }
+      if (r.name === "source" && r.meta?.source) {
+        msg = `${icon} Source directory not found: ${r.meta.source}`;
+      }
+      if (r.name.startsWith("subdirs_")) {
+        const dir = r.name.replace("subdirs_", "");
+        msg = `${icon} ${dir}/ not found`;
+      }
+      console.log(color(msg));
+    }
+  }
+  console.log("");
+  console.log(pc7.gray("Source detection:"));
+  const source = resolveSource();
+  if ("error" in source) {
+    console.log(pc7.yellow(`  \u26A0 ${source.error}`));
+  } else {
+    console.log(pc7.green(`  \u2713 Found source: ${source.path}`));
+    console.log(pc7.gray(`    Type: ${source.type || "unknown"}`));
+  }
+  const summary = computeSummary(results);
+  console.log("");
+  console.log(pc7.cyan("\u2500".repeat(40)));
+  if (summary.issues === 0 && summary.warnings === 0) {
+    console.log(pc7.bold(pc7.green("\n\u2713 All checks passed!\n")));
+  } else if (summary.issues === 0) {
+    console.log(pc7.yellow(`
+\u26A0 ${summary.warnings} warning(s), no critical issues
+`));
+  } else {
+    console.log(pc7.red(`
+\u2717 ${summary.issues} issue(s), ${summary.warnings} warning(s)
+`));
+  }
+  if (summary.issues > 0 || summary.warnings > 0) {
+    console.log(pc7.cyan("Suggestions:"));
+    const isProject = results.find((r) => r.name === "project")?.passed;
+    const hasState = results.find((r) => r.name === "state")?.passed;
+    if (!isProject) {
+      console.log(pc7.white('  \u2022 Run "ak init ." to initialize this directory'));
+    }
+    if (!hasState && isProject) {
+      console.log(pc7.white('  \u2022 State file is missing. Re-run "ak init" or create manually'));
+    }
+    if (state && state.source && !fs8.existsSync(state.source)) {
+      console.log(pc7.white("  \u2022 Update source path: ak update --source <new-path>"));
+    }
+    console.log("");
+  }
+}
+var init_doctor = __esm({
+  "src/commands/doctor.ts"() {
+    "use strict";
+    init_paths();
+    init_state();
+  }
+});
+
+// src/commands/help.ts
+var help_exports = {};
+__export(help_exports, {
+  helpCommand: () => helpCommand
+});
+import { exec } from "child_process";
+import pc8 from "picocolors";
+async function helpCommand(options) {
+  console.log(pc8.cyan("\n\u{1F4DA} Opening VividKit documentation...\n"));
+  console.log(pc8.green(`   ${HELP_URL}
+`));
+  const openCommand = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  exec(`${openCommand} ${HELP_URL}`);
+}
+var HELP_URL;
+var init_help = __esm({
+  "src/commands/help.ts"() {
+    "use strict";
+    HELP_URL = "https://www.vividkit.dev/vi/guides/what-is-claudekit";
+  }
+});
+
+// src/commands/uninstall.ts
+var uninstall_exports = {};
+__export(uninstall_exports, {
+  uninstallCommand: () => uninstallCommand
+});
+import fs9 from "fs-extra";
+import { join as join9 } from "path";
+import pc9 from "picocolors";
+import ora4 from "ora";
+import * as p2 from "@clack/prompts";
+async function uninstallCommand(options) {
+  p2.intro(pc9.bgCyan(pc9.black(" AK Uninstall ")));
+  const targets = [];
+  if (options.local || !options.global && !options.local) {
+    targets.push({ type: "local", dir: process.cwd() });
+  }
+  if (options.global) {
+    targets.push({ type: "global", dir: getGlobalInstallPath() });
+  }
+  let totalRemoved = 0;
+  for (const target of targets) {
+    const count = await uninstallFromDir(target.type, target.dir, options);
+    totalRemoved += count;
+  }
+  if (totalRemoved === 0) {
+    p2.outro(pc9.yellow("No installations found to remove."));
+  } else {
+    p2.outro(pc9.green(`Successfully removed ${totalRemoved} item(s).`));
+  }
+}
+async function uninstallFromDir(type, dir, options) {
+  const spinner = ora4(`Scanning ${type} installation at ${pc9.dim(dir)}`).start();
+  const state = await loadState(dir);
+  const existingTargets = [];
+  for (const [name, folder] of Object.entries(TARGETS)) {
+    const targetPath = join9(dir, folder);
+    if (fs9.existsSync(targetPath)) {
+      existingTargets.push({ name, path: targetPath });
+    }
+  }
+  const akDir = join9(dir, ".ak");
+  const hasAkState = fs9.existsSync(akDir);
+  if (existingTargets.length === 0 && !hasAkState) {
+    spinner.warn(pc9.yellow(`No AK installation found in ${type}`));
+    return 0;
+  }
+  spinner.succeed(pc9.green(`Found AK installation in ${type}`));
+  const removalList = [];
+  for (const target of existingTargets) {
+    for (const subdir of AK_SUBDIRS) {
+      const subdirPath = join9(target.path, subdir);
+      if (fs9.existsSync(subdirPath)) {
+        removalList.push(subdirPath);
+      }
+    }
+  }
+  if (hasAkState) {
+    removalList.push(akDir);
+  }
+  if (removalList.length === 0) {
+    console.log(pc9.yellow(`  No files to remove from ${type}`));
+    return 0;
+  }
+  console.log(pc9.cyan(`
+  Items to remove from ${type}:`));
+  for (const path of removalList) {
+    const relativePath = path.replace(dir + "/", "");
+    console.log(pc9.dim(`    \u2022 ${relativePath}`));
+  }
+  if (state) {
+    console.log(pc9.dim(`
+  Kit: ${state.kit}`));
+    console.log(pc9.dim(`  Target: ${state.target}`));
+  }
+  console.log(pc9.yellow(`
+  Preserved files: ${PRESERVED_FILES.join(", ")}`));
+  if (options.dryRun) {
+    console.log(pc9.yellow(`
+  [DRY RUN] Would remove ${removalList.length} item(s)`));
+    return 0;
+  }
+  if (!options.yes) {
+    const confirmed = await p2.confirm({
+      message: `Remove ${removalList.length} item(s) from ${type}?`,
+      initialValue: false
+    });
+    if (p2.isCancel(confirmed) || !confirmed) {
+      console.log(pc9.dim("  Cancelled."));
+      return 0;
+    }
+  }
+  const result = await removeItems(removalList, dir);
+  if (result.removed.length > 0) {
+    console.log(pc9.green(`
+  \u2713 Removed ${result.removed.length} item(s) from ${type}`));
+    for (const path of result.removed) {
+      const relativePath = path.replace(dir + "/", "");
+      console.log(pc9.dim(`    \u2022 ${relativePath}`));
+    }
+  }
+  if (result.errors.length > 0) {
+    console.log(pc9.red(`
+  \u2717 Failed to remove ${result.errors.length} item(s):`));
+    for (const error of result.errors) {
+      const relativePath = error.path.replace(dir + "/", "");
+      console.log(pc9.red(`    \u2022 ${relativePath}: ${error.error}`));
+    }
+  }
+  return result.removed.length;
+}
+async function removeItems(paths, baseDir) {
+  const result = {
+    removed: [],
+    errors: []
+  };
+  for (const path of paths) {
+    if (!path.startsWith(baseDir)) {
+      result.errors.push({
+        path,
+        error: "Path outside base directory (security check failed)"
+      });
+      continue;
+    }
+    const isExpectedPath = path.includes("/.ak") || AK_SUBDIRS.some((subdir) => path.includes(`/${subdir}`));
+    if (!isExpectedPath) {
+      result.errors.push({
+        path,
+        error: "Path is not an expected AK directory (security check failed)"
+      });
+      continue;
+    }
+    try {
+      await fs9.remove(path);
+      result.removed.push(path);
+    } catch (error) {
+      result.errors.push({
+        path,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return result;
+}
+var PRESERVED_FILES, AK_SUBDIRS;
+var init_uninstall = __esm({
+  "src/commands/uninstall.ts"() {
+    "use strict";
+    init_paths();
+    init_state();
+    PRESERVED_FILES = ["CLAUDE.md", "settings.json", "AGENTS.md"];
+    AK_SUBDIRS = ["agents", "skills", "commands", "workflows", "hooks", "router"];
+  }
+});
+
+// src/utils/git-tags.ts
+import { execSync } from "child_process";
+function fetchRemoteTags(repoUrl = REMOTE_REPO_URL) {
+  const output = execSync(`git ls-remote --tags "${repoUrl}"`, {
+    encoding: "utf-8",
+    timeout: 15e3,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return output.split("\n").filter((line) => line.includes("refs/tags/")).map((line) => {
+    const tag = line.split("refs/tags/")[1]?.replace("^{}", "");
+    return tag;
+  }).filter(Boolean).filter((v, i, a) => a.indexOf(v) === i);
+}
+function sortSemver(tags) {
+  return [...tags].sort((a, b) => {
+    const pa = a.replace(/^v/, "").split(/[.-]/);
+    const pb = b.replace(/^v/, "").split(/[.-]/);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+      const na = parseInt(pa[i]) || 0;
+      const nb = parseInt(pb[i]) || 0;
+      if (na !== nb) return nb - na;
+    }
+    return 0;
+  });
+}
+var REMOTE_REPO_URL;
+var init_git_tags = __esm({
+  "src/utils/git-tags.ts"() {
+    "use strict";
+    REMOTE_REPO_URL = "https://github.com/Thanhnguyen6702/CK-Internal.git";
+  }
+});
+
+// src/commands/versions.ts
+var versions_exports = {};
+__export(versions_exports, {
+  versionsCommand: () => versionsCommand
+});
+import pc10 from "picocolors";
+import ora5 from "ora";
+async function versionsCommand(options) {
+  const spinner = ora5("Fetching available versions...").start();
+  try {
+    const tags = fetchRemoteTags();
+    spinner.stop();
+    if (!tags || tags.length === 0) {
+      console.log(pc10.yellow("\nNo versions found."));
+      return;
+    }
+    let filtered = tags;
+    if (!options.all) {
+      filtered = tags.filter((tag) => !tag.includes("-"));
+    }
+    const sorted = sortSemver(filtered);
+    const limit = options.limit ? parseInt(options.limit, 10) : 10;
+    const limited = sorted.slice(0, limit);
+    console.log(pc10.bold("\nAvailable versions:\n"));
+    limited.forEach((tag, index) => {
+      const isLatest = index === 0;
+      const marker = isLatest ? pc10.green(" (latest)") : "";
+      console.log(`  ${pc10.cyan(tag)}${marker}`);
+    });
+    if (sorted.length > limited.length) {
+      console.log(pc10.gray(`
+  ... and ${sorted.length - limited.length} more (use --limit or --all)`));
+    }
+    console.log("");
+  } catch (err) {
+    spinner.stop();
+    console.log(pc10.red("\nFailed to fetch versions."));
+    console.log(pc10.gray(err.message));
+    if (err.message.includes("timeout")) {
+      console.log(pc10.gray("Network timeout. Check your connection."));
+    }
+  }
+}
+var init_versions = __esm({
+  "src/commands/versions.ts"() {
+    "use strict";
+    init_git_tags();
+  }
+});
+
+// src/commands/update-cli.ts
+var update_cli_exports = {};
+__export(update_cli_exports, {
+  updateCliCommand: () => updateCliCommand
+});
+import { execSync as execSync2 } from "child_process";
+import pc11 from "picocolors";
+import ora6 from "ora";
+import { readFileSync } from "fs";
+import { join as join10 } from "path";
+function getCurrentVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join10(CLI_ROOT, "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function getLatestVersion() {
+  const output = execSync2("npm view apero-kit-cli version", {
+    encoding: "utf-8",
+    timeout: 15e3,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return output.trim();
+}
+async function updateCliCommand(options) {
+  const current = getCurrentVersion();
+  const spinner = ora6("Checking for updates...").start();
+  try {
+    const latest = options.version || getLatestVersion();
+    spinner.stop();
+    console.log(`
+  Current: ${pc11.gray(current)}`);
+    console.log(`  Latest:  ${pc11.green(latest)}`);
+    if (current === latest && !options.version) {
+      console.log(pc11.green("\nAlready up to date!"));
+      return;
+    }
+    if (options.check) {
+      console.log(pc11.yellow('\nUpdate available! Run "ak update-cli" to install.'));
+      return;
+    }
+    const target = options.version || "latest";
+    const installSpinner = ora6(`Installing apero-kit-cli@${target}...`).start();
+    execSync2(`npm install -g apero-kit-cli@${target}`, {
+      encoding: "utf-8",
+      timeout: 6e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    installSpinner.succeed(pc11.green(`Updated to ${target}!`));
+  } catch (err) {
+    spinner.stop();
+    console.log(pc11.red("\nUpdate failed."));
+    console.log(pc11.gray(err.message));
+    console.log(pc11.gray("\nTry manually: npm install -g apero-kit-cli"));
+  }
+}
+var init_update_cli = __esm({
+  "src/commands/update-cli.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/commands/skills.ts
+var skills_exports = {};
+__export(skills_exports, {
+  skillsCommand: () => skillsCommand
+});
+import pc12 from "picocolors";
+import fs10 from "fs-extra";
+import { join as join11 } from "path";
+import * as p3 from "@clack/prompts";
+async function skillsCommand(options) {
+  const { name, agent, list, installed, uninstall, yes } = options;
+  if (list || !name && !installed) {
+    await listSkillsWithStatus();
+    return;
+  }
+  if (installed && !name) {
+    await showInstalledSkills();
+    return;
+  }
+  if (!name) {
+    console.log(pc12.red("Error: --name <skill> is required"));
+    console.log(pc12.gray("Usage: ak skills --name <skill> [--agent <agents>] [--uninstall]"));
+    process.exit(1);
+  }
+  const targetAgents = parseAgents(agent);
+  if (uninstall) {
+    await uninstallSkill(name, targetAgents, yes);
+    return;
+  }
+  await installSkill(name, targetAgents, yes);
+}
+async function listSkillsWithStatus() {
+  const source = resolveSource();
+  if ("error" in source) {
+    console.log(pc12.red(`Error: ${source.error}`));
+    process.exit(1);
+  }
+  const skills = listAvailable("skills", source.claudeDir).filter((s) => s.isDir);
+  if (skills.length === 0) {
+    console.log(pc12.yellow("No skills found in source"));
+    return;
+  }
+  console.log(pc12.bold(pc12.cyan(`
+Available Skills (${skills.length}):`)));
+  console.log(pc12.gray(`Source: ${source.path}
+`));
+  const header = "  Skill".padEnd(40) + "Claude  Cursor  Codex";
+  console.log(pc12.bold(header));
+  console.log(pc12.gray("  " + "\u2500".repeat(58)));
+  for (const skill of skills) {
+    const claudeInstalled = isSkillInstalled(skill.name, "claude");
+    const cursorInstalled = isSkillInstalled(skill.name, "cursor");
+    const codexInstalled = isSkillInstalled(skill.name, "codex");
+    const statusLine = "  " + skill.name.padEnd(38) + (claudeInstalled ? pc12.green("\u2713") : pc12.gray("-")).padEnd(8) + (cursorInstalled ? pc12.green("\u2713") : pc12.gray("-")).padEnd(8) + (codexInstalled ? pc12.green("\u2713") : pc12.gray("-"));
+    console.log(statusLine);
+  }
+  console.log("");
+  console.log(pc12.gray("Install: ak skills --name <skill> --agent <claude|cursor|codex>"));
+  console.log("");
+}
+async function showInstalledSkills() {
+  console.log(pc12.bold(pc12.cyan("\nInstalled Skills:\n")));
+  let hasAny = false;
+  for (const [agentType, skillPath] of Object.entries(AGENT_SKILL_PATHS)) {
+    const installed = getInstalledSkills(agentType);
+    if (installed.length > 0) {
+      hasAny = true;
+      console.log(pc12.bold(`  ${agentType}:`));
+      for (const skill of installed) {
+        console.log(pc12.white(`    \u2022 ${skill}`));
+      }
+      console.log("");
+    }
+  }
+  if (!hasAny) {
+    console.log(pc12.gray("  No skills installed"));
+    console.log("");
+  }
+}
+async function installSkill(skillName, agents, skipConfirm) {
+  const source = resolveSource();
+  if ("error" in source) {
+    console.log(pc12.red(`Error: ${source.error}`));
+    process.exit(1);
+  }
+  const skillPath = join11(source.claudeDir, "skills", skillName);
+  if (!fs10.existsSync(skillPath)) {
+    console.log(pc12.red(`Error: Skill "${skillName}" not found in source`));
+    console.log(pc12.gray(`Available skills: ak skills --list`));
+    process.exit(1);
+  }
+  if (!skipConfirm) {
+    const confirm4 = await p3.confirm({
+      message: `Install skill "${skillName}" to ${agents.join(", ")}?`
+    });
+    if (p3.isCancel(confirm4) || !confirm4) {
+      console.log(pc12.gray("Cancelled"));
+      process.exit(0);
+    }
+  }
+  const results = [];
+  for (const agent of agents) {
+    try {
+      const targetPath = join11(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+      await fs10.ensureDir(join11(process.cwd(), AGENT_SKILL_PATHS[agent]));
+      await fs10.copy(skillPath, targetPath, { overwrite: true });
+      results.push({ agent, success: true });
+    } catch (err) {
+      results.push({ agent, success: false, error: err.message });
+    }
+  }
+  console.log("");
+  const allSuccess = results.every((r) => r.success);
+  if (allSuccess) {
+    console.log(pc12.green(`\u2713 Installed "${skillName}" to ${agents.join(", ")}`));
+  } else {
+    for (const result of results) {
+      if (result.success) {
+        console.log(pc12.green(`\u2713 ${result.agent}: installed`));
+      } else {
+        console.log(pc12.red(`\u2717 ${result.agent}: ${result.error}`));
+      }
+    }
+  }
+  console.log("");
+}
+async function uninstallSkill(skillName, agents, skipConfirm) {
+  const installedIn = agents.filter((agent) => isSkillInstalled(skillName, agent));
+  if (installedIn.length === 0) {
+    console.log(pc12.yellow(`Skill "${skillName}" is not installed in ${agents.join(", ")}`));
+    process.exit(0);
+  }
+  if (!skipConfirm) {
+    const confirm4 = await p3.confirm({
+      message: `Uninstall skill "${skillName}" from ${installedIn.join(", ")}?`
+    });
+    if (p3.isCancel(confirm4) || !confirm4) {
+      console.log(pc12.gray("Cancelled"));
+      process.exit(0);
+    }
+  }
+  const results = [];
+  for (const agent of installedIn) {
+    try {
+      const targetPath = join11(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+      await fs10.remove(targetPath);
+      results.push({ agent, success: true });
+    } catch (err) {
+      results.push({ agent, success: false, error: err.message });
+    }
+  }
+  console.log("");
+  const allSuccess = results.every((r) => r.success);
+  if (allSuccess) {
+    console.log(pc12.green(`\u2713 Uninstalled "${skillName}" from ${installedIn.join(", ")}`));
+  } else {
+    for (const result of results) {
+      if (result.success) {
+        console.log(pc12.green(`\u2713 ${result.agent}: uninstalled`));
+      } else {
+        console.log(pc12.red(`\u2717 ${result.agent}: ${result.error}`));
+      }
+    }
+  }
+  console.log("");
+}
+function parseAgents(agentFlag) {
+  if (!agentFlag) {
+    return ["claude"];
+  }
+  const agents = agentFlag.split(",").map((a) => a.trim().toLowerCase());
+  const valid = agents.filter((a) => a in AGENT_SKILL_PATHS);
+  if (valid.length === 0) {
+    console.log(pc12.red("Error: No valid agents specified"));
+    console.log(pc12.gray("Valid agents: claude, cursor, codex"));
+    process.exit(1);
+  }
+  return valid;
+}
+function isSkillInstalled(skillName, agent) {
+  const skillPath = join11(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+  return fs10.existsSync(skillPath);
+}
+function getInstalledSkills(agent) {
+  const skillsDir = join11(process.cwd(), AGENT_SKILL_PATHS[agent]);
+  if (!fs10.existsSync(skillsDir)) {
+    return [];
+  }
+  try {
+    const items = fs10.readdirSync(skillsDir);
+    return items.filter((item) => {
+      const itemPath = join11(skillsDir, item);
+      return fs10.statSync(itemPath).isDirectory();
+    });
+  } catch {
+    return [];
+  }
+}
+var AGENT_SKILL_PATHS;
+var init_skills = __esm({
+  "src/commands/skills.ts"() {
+    "use strict";
+    init_paths();
+    init_copy();
+    AGENT_SKILL_PATHS = {
+      claude: ".claude/skills",
+      cursor: ".cursor/rules",
+      codex: ".codex/skills"
+    };
+  }
+});
+
+// src/index.ts
+import cac from "cac";
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join13 } from "path";
+import pc13 from "picocolors";
+
+// src/cli/command-registry.ts
+function registerCommands(cli2) {
+  cli2.command("init [project-name]", "Initialize a new project with an agent kit").option("-k, --kit <type>", "Kit type (engineer, researcher, designer, minimal, full, custom)").option("-t, --target <target>", "Target folder (claude, opencode, generic)").option("-s, --source <path>", "Custom source path for templates").option("-f, --force", "Overwrite existing directory").option("-g, --global", "Install to global ~/.claude/ directory").option("--fresh", "Remove existing installation before re-init").option("-y, --yes", "Skip prompts, use defaults").option("--exclude <patterns>", "Exclude components (comma-separated)").option("--only <patterns>", "Include only matching components (comma-separated)").action(async (projectName, options) => {
+    const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
+    await initCommand2(projectName, options);
+  });
+  cli2.command("add <item>", "Add agent, skill, or command (e.g., ak add skill:databases)").option("-s, --source <path>", "Custom source path").option("-p, --path <path>", "Target project path").action(async (item, options) => {
+    const { addCommand: addCommand2 } = await Promise.resolve().then(() => (init_add(), add_exports));
+    await addCommand2(item, options);
+  });
+  cli2.command("list [type]", "List available kits, agents, skills, or commands").option("-s, --source <path>", "Custom source path").action(async (type, options) => {
+    const { listCommand: listCommand2 } = await Promise.resolve().then(() => (init_list(), list_exports));
+    await listCommand2(type, options);
+  });
+  cli2.command("update", "Update/sync from source templates").option("-s, --source <path>", "Source path to sync from").option("--agents", "Update only agents").option("--skills", "Update only skills").option("--commands", "Update only commands").option("--all", "Update everything").option("-n, --dry-run", "Show what would be updated without making changes").option("-f, --force", "Force update without confirmation").action(async (options) => {
+    const { updateCommand: updateCommand2 } = await Promise.resolve().then(() => (init_update(), update_exports));
+    await updateCommand2(options);
+  });
+  cli2.command("status", "Show project status and file changes").option("-v, --verbose", "Show all files").action(async (options) => {
+    const { statusCommand: statusCommand2 } = await Promise.resolve().then(() => (init_status(), status_exports));
+    await statusCommand2(options);
+  });
+  cli2.command("doctor", "Check project health and diagnose issues").option("--fix", "Auto-fix common issues").option("--report", "Generate diagnostic report").option("--json", "Output JSON format").option("--check-only", "CI mode: exit 1 on failures").action(async (options) => {
+    const { doctorCommand: doctorCommand2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+    await doctorCommand2(options);
+  });
+  cli2.command("kits", "List all available kits").action(async () => {
+    const { listCommand: listCommand2 } = await Promise.resolve().then(() => (init_list(), list_exports));
+    await listCommand2("kits", {});
+  });
+  cli2.command("help", "Open interactive help documentation in browser").option("-s, --source <path>", "Custom source path").action(async (options) => {
+    const { helpCommand: helpCommand2 } = await Promise.resolve().then(() => (init_help(), help_exports));
+    await helpCommand2(options);
+  });
+  cli2.command("uninstall", "Remove ClaudeKit installations").option("-y, --yes", "Skip confirmation").option("-l, --local", "Uninstall only local installation").option("-g, --global", "Uninstall only global installation").option("--dry-run", "Preview what would be removed").action(async (options) => {
+    const { uninstallCommand: uninstallCommand2 } = await Promise.resolve().then(() => (init_uninstall(), uninstall_exports));
+    await uninstallCommand2(options);
+  });
+  cli2.command("versions", "List available versions").option("--kit <kit>", "Filter by kit").option("--limit <limit>", "Number of versions to show").option("--all", "Show all including prereleases").action(async (options) => {
+    const { versionsCommand: versionsCommand2 } = await Promise.resolve().then(() => (init_versions(), versions_exports));
+    await versionsCommand2(options);
+  });
+  cli2.command("update-cli", "Update the CLI itself to latest version").option("--check", "Check for updates without installing").option("--version <version>", "Update to specific version").action(async (options) => {
+    const { updateCliCommand: updateCliCommand2 } = await Promise.resolve().then(() => (init_update_cli(), update_cli_exports));
+    await updateCliCommand2(options);
+  });
+  cli2.command("skills", "Manage skills across coding agents").option("-n, --name <skill>", "Skill name").option("-a, --agent <agents>", "Target agents").option("-l, --list", "List available skills").option("--installed", "Show installed skills").option("-u, --uninstall", "Uninstall skill").option("-y, --yes", "Skip confirmation").action(async (options) => {
+    const { skillsCommand: skillsCommand2 } = await Promise.resolve().then(() => (init_skills(), skills_exports));
+    await skillsCommand2(options);
+  });
+}
+
+// src/utils/version-check.ts
+import { join as join12 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+var CACHE_DIR = join12(homedir2(), ".apero-kit");
+var CACHE_FILE = join12(CACHE_DIR, "version-check.json");
+var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
+function getCachedVersionNoFetch() {
+  try {
+    if (existsSync2(CACHE_FILE)) {
+      const cache = JSON.parse(readFileSync2(CACHE_FILE, "utf-8"));
+      return cache.version;
+    }
+  } catch {
+  }
+  return null;
+}
+function isNewerVersion(current, latest) {
+  const c = current.replace(/^v/, "").split(".").map(Number);
+  const l = latest.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((l[i] || 0) > (c[i] || 0)) return true;
+    if ((l[i] || 0) < (c[i] || 0)) return false;
+  }
+  return false;
+}
+
+// src/index.ts
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync3(join13(__dirname2, "..", "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var cli = cac("ak");
+registerCommands(cli);
+cli.help();
+cli.version(getVersion());
+cli.parse();
+try {
+  const version = getVersion();
+  const cachedLatest = getCachedVersionNoFetch();
+  if (cachedLatest && isNewerVersion(version, cachedLatest)) {
+    console.log(pc13.yellow(`
+  Update available: v${version} \u2192 v${cachedLatest}`));
+    console.log(pc13.gray('  Run "ak update-cli" to update\n'));
+  }
+} catch {
+}
+//# sourceMappingURL=index.js.map