thanh-kit 2.5.0

package/dist/index.js

@@ -0,0 +1,3829 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+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
+var paths_exports = {};
+__export(paths_exports, {
+  CLI_ROOT: () => CLI_ROOT,
+  TARGETS: () => TARGETS,
+  TEMPLATES_DIR: () => TEMPLATES_DIR,
+  getCkInternalSource: () => getCkInternalSource,
+  getEmbeddedTemplates: () => getEmbeddedTemplates,
+  getGlobalInstallPath: () => getGlobalInstallPath,
+  getTargetDir: () => getTargetDir,
+  isAkProject: () => isAkProject,
+  resolveSource: () => resolveSource
+});
+import { fileURLToPath } from "url";
+import { dirname, join, resolve } from "path";
+import { existsSync } from "fs";
+import { homedir } from "os";
+function getCkInternalSource() {
+  for (const basePath of CK_INTERNAL_PATHS) {
+    const claudeDir = join(basePath, ".claude");
+    if (existsSync(claudeDir) && existsSync(join(claudeDir, "skills"))) {
+      const agentsMd = join(basePath, "AGENTS.md");
+      return {
+        path: basePath,
+        type: "ck-internal",
+        claudeDir,
+        agentsMd: existsSync(agentsMd) ? agentsMd : null
+      };
+    }
+  }
+  return null;
+}
+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 geminiDir = join(dir, ".gemini");
+  const opencodeDir = join(dir, ".opencode");
+  const agentDir = join(dir, ".agent");
+  return existsSync(akConfig) || existsSync(claudeDir) || existsSync(geminiDir) || 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 ckInternal = getCkInternalSource();
+  if (ckInternal) {
+    return ckInternal;
+  }
+  const embedded = getEmbeddedTemplates();
+  if (embedded) {
+    return embedded;
+  }
+  return {
+    error: "No templates found. Reinstall: npm install -g thanh-kit"
+  };
+}
+var __filename, __dirname, CLI_ROOT, TEMPLATES_DIR, CK_INTERNAL_PATHS, 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");
+    CK_INTERNAL_PATHS = [
+      "/Users/nguyenthanh/AndroidStudioProjects/CK-Internal",
+      join(homedir(), "AndroidStudioProjects/CK-Internal"),
+      join(homedir(), "CK-Internal")
+    ];
+    TARGETS = {
+      claude: ".claude",
+      gemini: ".gemini",
+      discord: ".discord",
+      opencode: ".opencode",
+      generic: ".agent"
+    };
+  }
+});
+
+// src/targets/base-adapter.ts
+import fs from "fs-extra";
+import { join as join2, dirname as dirname2 } from "path";
+var BaseTargetAdapter;
+var init_base_adapter = __esm({
+  "src/targets/base-adapter.ts"() {
+    "use strict";
+    BaseTargetAdapter = class {
+      supports(feature) {
+        return this.config.features[feature];
+      }
+      getSupportedFeatures() {
+        return Object.entries(this.config.features).filter(([_, supported]) => supported).map(([feature]) => feature);
+      }
+      filterInstallItems(items) {
+        return {
+          agents: this.supports("agents") ? items.agents : [],
+          skills: this.supports("skills") ? items.skills : [],
+          commands: this.supports("commands") ? items.commands : [],
+          workflows: this.supports("workflows") ? items.workflows : [],
+          includeRouter: this.supports("router") && items.includeRouter,
+          includeHooks: this.supports("hooks") && items.includeHooks
+        };
+      }
+      /**
+       * Default: not supported - override in subclass if needed
+       */
+      async copyWorkflows(_items, _sourceDir, _targetDir, _mergeMode) {
+        return { copied: [], skipped: [], errors: [] };
+      }
+      async copyRouter(_sourceDir, _targetDir, _mergeMode) {
+        return { success: false, error: "Router not supported by this target" };
+      }
+      async copyHooks(_sourceDir, _targetDir, _mergeMode) {
+        return { success: false, error: "Hooks not supported by this target" };
+      }
+      async copyExtras(_sourceDir, _targetDir, _mergeMode) {
+        return [];
+      }
+      // Helper methods for common operations
+      async copyDirectory(dirName, sourceDir, destDir, mergeMode) {
+        const srcPath = join2(sourceDir, dirName);
+        if (!fs.existsSync(srcPath)) {
+          return { success: false, error: `${dirName} directory not found` };
+        }
+        try {
+          await fs.copy(srcPath, join2(destDir, dirName), { overwrite: !mergeMode });
+          return { success: true };
+        } catch (err) {
+          return { success: false, error: err.message };
+        }
+      }
+      async copyFile(srcPath, destPath, mergeMode) {
+        if (mergeMode && fs.existsSync(destPath)) {
+          return false;
+        }
+        if (fs.existsSync(srcPath)) {
+          await fs.ensureDir(dirname2(destPath));
+          await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
+          return true;
+        }
+        return false;
+      }
+      async listItems(typeDir, extension) {
+        if (!fs.existsSync(typeDir)) {
+          return [];
+        }
+        const entries = fs.readdirSync(typeDir);
+        return entries.filter((e) => {
+          if (extension) {
+            return e.endsWith(extension) && e !== "README.md";
+          }
+          return e !== "README.md";
+        }).map((e) => extension ? e.replace(extension, "") : e);
+      }
+      getItemList(items, typeDir, extension) {
+        if (items === "all") {
+          return this.listItemsSync(typeDir, extension);
+        }
+        return items;
+      }
+      listItemsSync(typeDir, extension) {
+        if (!fs.existsSync(typeDir)) {
+          return [];
+        }
+        const entries = fs.readdirSync(typeDir);
+        let result = entries.filter((e) => e !== "README.md");
+        if (extension) {
+          result = result.filter((e) => e.endsWith(extension)).map((e) => e.replace(extension, ""));
+        }
+        return [...new Set(result.map((e) => e.replace(/\.md$/, "")))];
+      }
+    };
+  }
+});
+
+// src/targets/claude-adapter.ts
+import fs2 from "fs-extra";
+import { join as join3 } from "path";
+var ClaudeAdapter;
+var init_claude_adapter = __esm({
+  "src/targets/claude-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    ClaudeAdapter = class extends BaseTargetAdapter {
+      config = {
+        name: "claude",
+        displayName: "Claude Code",
+        directory: ".claude",
+        features: {
+          agents: true,
+          skills: true,
+          commands: true,
+          workflows: true,
+          router: true,
+          hooks: true,
+          memory: true,
+          scripts: true,
+          "output-styles": true
+        }
+      };
+      async copyAgents(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join3(sourceDir, "agents");
+        const destTypeDir = join3(targetDir, "agents");
+        if (!fs2.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs2.ensureDir(destTypeDir);
+        if (items === "all") {
+          await fs2.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
+          const entries = fs2.readdirSync(typeDir).filter((e) => e.endsWith(".md") && e !== "README.md");
+          return { copied: entries.map((e) => e.replace(".md", "")), skipped: [], errors: [] };
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const agent of items) {
+          try {
+            const srcPath = join3(typeDir, agent + ".md");
+            if (!fs2.existsSync(srcPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const destPath = join3(destTypeDir, agent + ".md");
+            if (mergeMode && fs2.existsSync(destPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            await fs2.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(agent);
+          } catch (err) {
+            errors.push({ item: agent, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
+      }
+      async copySkills(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join3(sourceDir, "skills");
+        const destTypeDir = join3(targetDir, "skills");
+        if (!fs2.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs2.ensureDir(destTypeDir);
+        if (items === "all") {
+          await fs2.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
+          const entries = fs2.readdirSync(typeDir).filter((e) => {
+            const fullPath = join3(typeDir, e);
+            return fs2.statSync(fullPath).isDirectory() && fs2.existsSync(join3(fullPath, "SKILL.md"));
+          });
+          return { copied: entries, skipped: [], errors: [] };
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const skill of items) {
+          try {
+            const srcPath = join3(typeDir, skill);
+            if (!fs2.existsSync(srcPath) || !fs2.statSync(srcPath).isDirectory()) {
+              skipped.push(skill);
+              continue;
+            }
+            if (!fs2.existsSync(join3(srcPath, "SKILL.md"))) {
+              skipped.push(skill);
+              continue;
+            }
+            const destPath = join3(destTypeDir, skill);
+            if (mergeMode && fs2.existsSync(destPath)) {
+              skipped.push(skill);
+              continue;
+            }
+            await fs2.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(skill);
+          } catch (err) {
+            errors.push({ item: skill, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
+      }
+      async copyCommands(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join3(sourceDir, "commands");
+        const destTypeDir = join3(targetDir, "commands");
+        if (!fs2.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs2.ensureDir(destTypeDir);
+        if (items === "all") {
+          await fs2.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
+          const entries = fs2.readdirSync(typeDir);
+          return { copied: [...new Set(entries.map((e) => e.replace(".md", "")))], skipped: [], errors: [] };
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const item of items) {
+          try {
+            const itemPath = join3(typeDir, item);
+            const itemPathMd = itemPath + ".md";
+            let srcPath = null;
+            if (fs2.existsSync(itemPath)) {
+              srcPath = itemPath;
+            } else if (fs2.existsSync(itemPathMd)) {
+              srcPath = itemPathMd;
+            }
+            if (!srcPath) {
+              skipped.push(item);
+              continue;
+            }
+            const stat = fs2.statSync(srcPath);
+            const destPath = stat.isDirectory() ? join3(destTypeDir, item) : join3(destTypeDir, item + ".md");
+            if (mergeMode && fs2.existsSync(destPath)) {
+              skipped.push(item);
+              continue;
+            }
+            await fs2.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(item);
+          } catch (err) {
+            errors.push({ item, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
+      }
+      async copyWorkflows(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join3(sourceDir, "workflows");
+        const destTypeDir = join3(targetDir, "workflows");
+        if (!fs2.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs2.ensureDir(destTypeDir);
+        if (items === "all") {
+          await fs2.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
+          const entries = fs2.readdirSync(typeDir);
+          return { copied: entries.map((e) => e.replace(".md", "")), skipped: [], errors: [] };
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const item of items) {
+          try {
+            const srcPath = join3(typeDir, item + ".md");
+            if (!fs2.existsSync(srcPath)) {
+              skipped.push(item);
+              continue;
+            }
+            const destPath = join3(destTypeDir, item + ".md");
+            if (mergeMode && fs2.existsSync(destPath)) {
+              skipped.push(item);
+              continue;
+            }
+            await fs2.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(item);
+          } catch (err) {
+            errors.push({ item, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
+      }
+      async copyRouter(sourceDir, targetDir, mergeMode) {
+        return this.copyDirectory("router", sourceDir, targetDir, mergeMode);
+      }
+      async copyHooks(sourceDir, targetDir, mergeMode) {
+        return this.copyDirectory("hooks", sourceDir, targetDir, mergeMode);
+      }
+      async copyExtras(sourceDir, targetDir, mergeMode) {
+        const extras = ["memory", "output-styles", "scripts"];
+        const copied = [];
+        for (const extra of extras) {
+          const result = await this.copyDirectory(extra, sourceDir, targetDir, mergeMode);
+          if (result.success) {
+            copied.push(extra);
+          }
+        }
+        return copied;
+      }
+      async copyBaseFiles(targetDir, mergeMode) {
+        const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const sourceDir = join3(CLI_ROOT2, "templates");
+        const baseFiles = ["README.md", "settings.json", ".env.example", "statusline.cjs", "statusline.ps1", "statusline.sh"];
+        const copied = [];
+        for (const file of baseFiles) {
+          const srcPath = join3(sourceDir, file);
+          const destPath = join3(targetDir, file);
+          if (await this.copyFile(srcPath, destPath, mergeMode)) {
+            copied.push(file);
+          }
+        }
+        return copied;
+      }
+    };
+  }
+});
+
+// src/targets/gemini-adapter.ts
+import fs3 from "fs-extra";
+import { join as join4, dirname as dirname3 } from "path";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: "", body: content };
+  }
+  return { frontmatter: match[1], body: match[2] };
+}
+function escapeTomlString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+}
+function convertAgentToGemini(mdContent) {
+  const { frontmatter, body } = parseFrontmatter(mdContent);
+  if (!frontmatter) return mdContent;
+  let converted = frontmatter;
+  for (const [claudeModel, geminiModel] of Object.entries(MODEL_MAP)) {
+    const regex = new RegExp(`^model:\\s*${claudeModel}\\s*$`, "m");
+    if (geminiModel) {
+      converted = converted.replace(regex, `model: ${geminiModel}`);
+    } else {
+      converted = converted.replace(regex, "");
+    }
+  }
+  converted = converted.replace(/^tools:\s*.+$/m, "");
+  if (!converted.includes("kind:")) {
+    converted = converted.trim() + "\nkind: local";
+  }
+  return `---
+${converted.trim()}
+---
+${body}`;
+}
+function convertCommandToToml(mdContent) {
+  const { frontmatter, body } = parseFrontmatter(mdContent);
+  const descMatch = frontmatter.match(/description:\s*(.+)/);
+  const description = descMatch ? descMatch[1].trim() : "";
+  const prompt = body.trim().replace(/\$ARGUMENTS/g, "{{args}}");
+  const lines = [];
+  if (description) {
+    lines.push(`description = "${escapeTomlString(description)}"`);
+  }
+  lines.push(`prompt = '''
+${prompt}
+'''`);
+  return lines.join("\n");
+}
+var MODEL_MAP, GeminiAdapter;
+var init_gemini_adapter = __esm({
+  "src/targets/gemini-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    MODEL_MAP = {
+      "opus": "gemini-2.5-pro",
+      "sonnet": "gemini-2.5-flash",
+      "haiku": "gemini-2.0-flash-lite",
+      "inherit": ""
+      // Remove inherit, let Gemini use default
+    };
+    GeminiAdapter = class extends BaseTargetAdapter {
+      config = {
+        name: "gemini",
+        displayName: "Gemini CLI",
+        directory: ".gemini",
+        features: {
+          agents: true,
+          skills: true,
+          commands: true,
+          workflows: false,
+          router: false,
+          hooks: false,
+          memory: false,
+          scripts: false,
+          "output-styles": false
+        }
+      };
+      async copyAgents(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join4(sourceDir, "agents");
+        const destTypeDir = join4(targetDir, "agents");
+        if (!fs3.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs3.ensureDir(destTypeDir);
+        let agentList;
+        if (items === "all") {
+          const entries = fs3.readdirSync(typeDir);
+          agentList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(".md", ""));
+        } else {
+          agentList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const agent of agentList) {
+          try {
+            const srcPath = join4(typeDir, agent + ".md");
+            if (!fs3.existsSync(srcPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const destPath = join4(destTypeDir, agent + ".md");
+            if (mergeMode && fs3.existsSync(destPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const mdContent = fs3.readFileSync(srcPath, "utf-8");
+            const convertedContent = convertAgentToGemini(mdContent);
+            await fs3.writeFile(destPath, convertedContent, "utf-8");
+            copied.push(agent);
+          } catch (err) {
+            errors.push({ item: agent, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
+      }
+      async copySkills(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join4(sourceDir, "skills");
+        const destTypeDir = join4(targetDir, "skills");
+        if (!fs3.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs3.ensureDir(destTypeDir);
+        let skillList;
+        if (items === "all") {
+          const entries = fs3.readdirSync(typeDir);
+          skillList = entries.filter((e) => {
+            const fullPath = join4(typeDir, e);
+            return fs3.statSync(fullPath).isDirectory() && fs3.existsSync(join4(fullPath, "SKILL.md"));
+          });
+        } else {
+          skillList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const skill of skillList) {
+          try {
+            const srcPath = join4(typeDir, skill);
+            if (!fs3.existsSync(srcPath) || !fs3.statSync(srcPath).isDirectory()) {
+              skipped.push(skill);
+              continue;
+            }
+            if (!fs3.existsSync(join4(srcPath, "SKILL.md"))) {
+              skipped.push(skill);
+              continue;
+            }
+            const destPath = join4(destTypeDir, skill);
+            if (mergeMode && fs3.existsSync(destPath)) {
+              skipped.push(skill);
+              continue;
+            }
+            await fs3.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(skill);
+          } catch (err) {
+            errors.push({ item: skill, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
+      }
+      async copyCommands(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join4(sourceDir, "commands");
+        const destTypeDir = join4(targetDir, "commands");
+        if (!fs3.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs3.ensureDir(destTypeDir);
+        let itemList;
+        if (items === "all") {
+          const entries = fs3.readdirSync(typeDir);
+          itemList = [...new Set(entries.map((e) => e.replace(".md", "")))];
+        } else {
+          itemList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const item of itemList) {
+          try {
+            const srcPathMd = join4(typeDir, item + ".md");
+            const srcPathDir = join4(typeDir, item);
+            let copiedSomething = false;
+            if (fs3.existsSync(srcPathMd) && fs3.statSync(srcPathMd).isFile()) {
+              const destPath = join4(destTypeDir, item + ".toml");
+              if (!(mergeMode && fs3.existsSync(destPath))) {
+                await fs3.ensureDir(dirname3(destPath));
+                const mdContent = fs3.readFileSync(srcPathMd, "utf-8");
+                const tomlContent = convertCommandToToml(mdContent);
+                await fs3.writeFile(destPath, tomlContent, "utf-8");
+                copiedSomething = true;
+              }
+            }
+            if (fs3.existsSync(srcPathDir) && fs3.statSync(srcPathDir).isDirectory()) {
+              await this.convertDirectoryToToml(srcPathDir, join4(destTypeDir, item), mergeMode);
+              copiedSomething = true;
+            }
+            if (copiedSomething) {
+              copied.push(item);
+            } else {
+              skipped.push(item);
+            }
+          } catch (err) {
+            errors.push({ item, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
+      }
+      async convertDirectoryToToml(srcDir, destDir, mergeMode) {
+        await fs3.ensureDir(destDir);
+        const entries = fs3.readdirSync(srcDir);
+        for (const entry of entries) {
+          const srcPath = join4(srcDir, entry);
+          const stat = fs3.statSync(srcPath);
+          if (stat.isDirectory()) {
+            await this.convertDirectoryToToml(srcPath, join4(destDir, entry), mergeMode);
+          } else if (entry.endsWith(".md")) {
+            const destPath = join4(destDir, entry.replace(".md", ".toml"));
+            if (mergeMode && fs3.existsSync(destPath)) {
+              continue;
+            }
+            const mdContent = fs3.readFileSync(srcPath, "utf-8");
+            const tomlContent = convertCommandToToml(mdContent);
+            await fs3.writeFile(destPath, tomlContent, "utf-8");
+          } else {
+            const destPath = join4(destDir, entry);
+            if (mergeMode && fs3.existsSync(destPath)) {
+              continue;
+            }
+            await fs3.copy(srcPath, destPath, { overwrite: !mergeMode });
+          }
+        }
+      }
+      async copyBaseFiles(targetDir, mergeMode) {
+        const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const geminiTemplates = join4(CLI_ROOT2, "templates", "gemini");
+        const copied = [];
+        const settingsPath = join4(geminiTemplates, "settings.json");
+        const destSettingsPath = join4(targetDir, "settings.json");
+        if (fs3.existsSync(settingsPath)) {
+          if (!(mergeMode && fs3.existsSync(destSettingsPath))) {
+            await fs3.copy(settingsPath, destSettingsPath, { overwrite: !mergeMode });
+            copied.push("settings.json");
+          }
+        }
+        return copied;
+      }
+    };
+  }
+});
+
+// src/targets/discord-adapter.ts
+import fs4 from "fs-extra";
+import { join as join5, dirname as dirname4 } from "path";
+function parseFrontmatter2(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: "", body: content, description: "", argumentHint: "" };
+  }
+  const frontmatter = match[1];
+  const body = match[2].trim();
+  const descMatch = frontmatter.match(/description:\s*(.+)/);
+  const argMatch = frontmatter.match(/argument-hint:\s*(.+)/);
+  return {
+    frontmatter,
+    body,
+    description: descMatch ? descMatch[1].trim() : "",
+    argumentHint: argMatch ? argMatch[1].trim() : ""
+  };
+}
+function convertAgentToDiscord(mdContent) {
+  const { frontmatter, body } = parseFrontmatter2(mdContent);
+  if (!frontmatter) return mdContent;
+  let converted = frontmatter;
+  for (const [claudeModel, discordModel] of Object.entries(MODEL_MAP2)) {
+    const regex = new RegExp(`^model:\\s*${claudeModel}\\s*$`, "m");
+    if (discordModel) {
+      converted = converted.replace(regex, `model: ${discordModel}`);
+    } else {
+      converted = converted.replace(regex, "");
+    }
+  }
+  converted = converted.replace(/^tools:\s*.+$/m, "");
+  if (!converted.includes("kind:")) {
+    converted = converted.trim() + "\nkind: local";
+  }
+  return `---
+${converted.trim()}
+---
+${body}`;
+}
+function extractKeywords(content, commandName) {
+  const keywords = /* @__PURE__ */ new Set();
+  keywords.add(commandName);
+  keywords.add(commandName.replace(/-/g, " "));
+  const intentMap = {
+    "plan": ["plan", "design", "architect", "implement", "create plan"],
+    "brainstorm": ["brainstorm", "ideas", "options", "alternatives"],
+    "fix": ["fix", "debug", "error", "broken", "issue", "bug"],
+    "code": ["code", "implement", "build", "develop", "write code"],
+    "review": ["review", "check", "audit", "look at"],
+    "test": ["test", "testing", "spec", "unit test"],
+    "scout": ["scout", "search", "find", "explore codebase"],
+    "debug": ["debug", "trace", "diagnose", "investigate"]
+  };
+  const baseName = commandName.split("/")[0].split(":")[0];
+  if (intentMap[baseName]) {
+    intentMap[baseName].forEach((k) => keywords.add(k));
+  }
+  return Array.from(keywords).slice(0, 10);
+}
+function convertCommandToSkill(mdContent, commandName) {
+  const { description, argumentHint, body } = parseFrontmatter2(mdContent);
+  const prompt = body.replace(/\$ARGUMENTS/g, "{{args}}");
+  const keywords = extractKeywords(body, commandName);
+  return `---
+name: ${commandName.replace(/\//g, "-")}
+description: ${description || `Execute ${commandName} task`}
+user-invocable: true
+disable-model-invocation: false
+metadata: {"openclaw": {"always": true}}
+---
+
+# ${commandName.charAt(0).toUpperCase() + commandName.slice(1).replace(/-/g, " ")}
+
+## Trigger Conditions
+
+Activate when user mentions:
+${keywords.map((k) => `- "${k}"`).join("\n")}
+
+## Input
+${argumentHint ? `Expected input: ${argumentHint.replace("$ARGUMENTS", "{{args}}")}` : "User provides task description in natural language."}
+
+## Workflow
+
+${prompt}
+
+## Output Format
+
+Provide clear, actionable response based on the workflow above.
+`;
+}
+var MODEL_MAP2, DiscordAdapter;
+var init_discord_adapter = __esm({
+  "src/targets/discord-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    MODEL_MAP2 = {
+      "opus": "claude-3-opus",
+      "sonnet": "claude-3-sonnet",
+      "haiku": "claude-3-haiku",
+      "inherit": ""
+    };
+    DiscordAdapter = class extends BaseTargetAdapter {
+      config = {
+        name: "discord",
+        displayName: "Discord + OpenClaw",
+        directory: ".discord",
+        features: {
+          agents: true,
+          skills: true,
+          commands: true,
+          workflows: false,
+          router: false,
+          hooks: false,
+          memory: false,
+          scripts: false,
+          "output-styles": false
+        }
+      };
+      async copyAgents(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join5(sourceDir, "agents");
+        const destTypeDir = join5(targetDir, "agents");
+        if (!fs4.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs4.ensureDir(destTypeDir);
+        let agentList;
+        if (items === "all") {
+          const entries = fs4.readdirSync(typeDir);
+          agentList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(".md", ""));
+        } else {
+          agentList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const agent of agentList) {
+          try {
+            const srcPath = join5(typeDir, agent + ".md");
+            if (!fs4.existsSync(srcPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const destPath = join5(destTypeDir, agent + ".md");
+            if (mergeMode && fs4.existsSync(destPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const mdContent = fs4.readFileSync(srcPath, "utf-8");
+            const convertedContent = convertAgentToDiscord(mdContent);
+            await fs4.writeFile(destPath, convertedContent, "utf-8");
+            copied.push(agent);
+          } catch (err) {
+            errors.push({ item: agent, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
+      }
+      async copySkills(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join5(sourceDir, "skills");
+        const destTypeDir = join5(targetDir, "skills");
+        if (!fs4.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs4.ensureDir(destTypeDir);
+        let skillList;
+        if (items === "all") {
+          const entries = fs4.readdirSync(typeDir);
+          skillList = entries.filter((e) => {
+            const fullPath = join5(typeDir, e);
+            return fs4.statSync(fullPath).isDirectory() && fs4.existsSync(join5(fullPath, "SKILL.md"));
+          });
+        } else {
+          skillList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const skill of skillList) {
+          try {
+            const srcPath = join5(typeDir, skill);
+            if (!fs4.existsSync(srcPath) || !fs4.statSync(srcPath).isDirectory()) {
+              skipped.push(skill);
+              continue;
+            }
+            if (!fs4.existsSync(join5(srcPath, "SKILL.md"))) {
+              skipped.push(skill);
+              continue;
+            }
+            const destPath = join5(destTypeDir, skill);
+            if (mergeMode && fs4.existsSync(destPath)) {
+              skipped.push(skill);
+              continue;
+            }
+            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(skill);
+          } catch (err) {
+            errors.push({ item: skill, error: err.message });
+          }
+        }
+        const bundledCopied = await this.copyBundledSkills(targetDir, mergeMode);
+        copied.push(...bundledCopied);
+        return { copied, skipped, errors };
+      }
+      async copyCommands(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join5(sourceDir, "commands");
+        const destTypeDir = join5(targetDir, "commands");
+        const destSkillsDir = join5(targetDir, "skills");
+        if (!fs4.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs4.ensureDir(destTypeDir);
+        await fs4.ensureDir(destSkillsDir);
+        let itemList;
+        if (items === "all") {
+          const entries = fs4.readdirSync(typeDir);
+          itemList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(".md", ""));
+          const dirs = entries.filter((e) => {
+            const fullPath = join5(typeDir, e);
+            return fs4.statSync(fullPath).isDirectory();
+          });
+          itemList = [.../* @__PURE__ */ new Set([...itemList, ...dirs])];
+        } else {
+          itemList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        const commandsConfig = {};
+        for (const item of itemList) {
+          try {
+            const srcPathMd = join5(typeDir, item + ".md");
+            const srcPathDir = join5(typeDir, item);
+            if (fs4.existsSync(srcPathMd) && fs4.statSync(srcPathMd).isFile()) {
+              const destPath = join5(destTypeDir, item + ".md");
+              const skillDir = join5(destSkillsDir, item.replace(/\//g, "-"));
+              const skillPath = join5(skillDir, "SKILL.md");
+              if (!(mergeMode && fs4.existsSync(destPath))) {
+                await fs4.ensureDir(dirname4(destPath));
+                const mdContent = fs4.readFileSync(srcPathMd, "utf-8");
+                await fs4.copy(srcPathMd, destPath, { overwrite: !mergeMode });
+                if (!(mergeMode && fs4.existsSync(skillPath))) {
+                  await fs4.ensureDir(skillDir);
+                  const skillContent = convertCommandToSkill(mdContent, item);
+                  await fs4.writeFile(skillPath, skillContent, "utf-8");
+                }
+                const { description, body } = parseFrontmatter2(mdContent);
+                commandsConfig[item] = {
+                  description: description || `Execute ${item} command`,
+                  prompt: body.replace(/\$ARGUMENTS/g, "{{args}}")
+                };
+                copied.push(item);
+              } else {
+                skipped.push(item);
+              }
+            }
+            if (fs4.existsSync(srcPathDir) && fs4.statSync(srcPathDir).isDirectory()) {
+              await this.copyNestedCommands(srcPathDir, destTypeDir, destSkillsDir, item, mergeMode, commandsConfig);
+              copied.push(item + "/*");
+            }
+          } catch (err) {
+            errors.push({ item, error: err.message });
+          }
+        }
+        const configPath = join5(targetDir, "commands.json5");
+        if (Object.keys(commandsConfig).length > 0 && !(mergeMode && fs4.existsSync(configPath))) {
+          const json5Content = this.generateCommandsJson5(commandsConfig);
+          await fs4.writeFile(configPath, json5Content, "utf-8");
+        }
+        return { copied, skipped, errors };
+      }
+      async copyNestedCommands(srcDir, destDir, destSkillsDir, parentName, mergeMode, commandsConfig) {
+        const destTypeDir = join5(destDir, parentName);
+        await fs4.ensureDir(destTypeDir);
+        const entries = fs4.readdirSync(srcDir);
+        for (const entry of entries) {
+          const srcPath = join5(srcDir, entry);
+          const stat = fs4.statSync(srcPath);
+          if (stat.isDirectory()) {
+            await this.copyNestedCommands(
+              srcPath,
+              destTypeDir,
+              destSkillsDir,
+              entry,
+              mergeMode,
+              commandsConfig
+            );
+          } else if (entry.endsWith(".md") && entry !== "README.md") {
+            const destPath = join5(destTypeDir, entry);
+            const cmdName = `${parentName}/${entry.replace(".md", "")}`;
+            const skillName = cmdName.replace(/\//g, "-");
+            const skillDir = join5(destSkillsDir, skillName);
+            const skillPath = join5(skillDir, "SKILL.md");
+            if (mergeMode && fs4.existsSync(destPath)) {
+              continue;
+            }
+            const mdContent = fs4.readFileSync(srcPath, "utf-8");
+            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            if (!(mergeMode && fs4.existsSync(skillPath))) {
+              await fs4.ensureDir(skillDir);
+              const skillContent = convertCommandToSkill(mdContent, skillName);
+              await fs4.writeFile(skillPath, skillContent, "utf-8");
+            }
+            const { description, body } = parseFrontmatter2(mdContent);
+            commandsConfig[cmdName] = {
+              description: description || `Execute ${cmdName} command`,
+              prompt: body.replace(/\$ARGUMENTS/g, "{{args}}")
+            };
+          }
+        }
+      }
+      generateCommandsJson5(commands) {
+        const lines = [
+          "// Clawbot Commands Configuration",
+          "// Generated by Thanh Kit CLI",
+          "{",
+          '  "commands": {'
+        ];
+        const cmdEntries = Object.entries(commands);
+        cmdEntries.forEach(([name, cmd], index) => {
+          const safeName = name.replace(/\//g, ":");
+          const isLast = index === cmdEntries.length - 1;
+          lines.push(`    "${safeName}": {`);
+          lines.push(`      "description": ${JSON.stringify(cmd.description)},`);
+          lines.push(`      "prompt": ${JSON.stringify(cmd.prompt)}`);
+          lines.push(`    }${isLast ? "" : ","}`);
+        });
+        lines.push("  }");
+        lines.push("}");
+        return lines.join("\n");
+      }
+      async copyBundledSkills(targetDir, mergeMode) {
+        const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const bundledSkillsDir = join5(CLI_ROOT2, "templates", "discord", "skills");
+        const destSkillsDir = join5(targetDir, "skills");
+        const copied = [];
+        if (!fs4.existsSync(bundledSkillsDir)) {
+          return copied;
+        }
+        await fs4.ensureDir(destSkillsDir);
+        const skills = fs4.readdirSync(bundledSkillsDir);
+        for (const skill of skills) {
+          const srcPath = join5(bundledSkillsDir, skill);
+          const destPath = join5(destSkillsDir, skill);
+          if (fs4.statSync(srcPath).isDirectory()) {
+            if (mergeMode && fs4.existsSync(destPath)) {
+              continue;
+            }
+            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(`bundled:${skill}`);
+          }
+        }
+        return copied;
+      }
+      async copyBaseFiles(targetDir, mergeMode) {
+        const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const discordTemplates = join5(CLI_ROOT2, "templates", "discord");
+        const copied = [];
+        const filesToCopy = ["config.json5", "README.md"];
+        for (const file of filesToCopy) {
+          const srcPath = join5(discordTemplates, file);
+          const destPath = join5(targetDir, file);
+          if (fs4.existsSync(srcPath)) {
+            if (mergeMode && fs4.existsSync(destPath)) {
+              continue;
+            }
+            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(file);
+          }
+        }
+        return copied;
+      }
+      /**
+       * Update Discord config with bot token
+       */
+      async updateConfig(targetDir, token, guildId) {
+        const configPath = join5(targetDir, "config.json5");
+        if (!fs4.existsSync(configPath)) {
+          return;
+        }
+        let content = await fs4.readFile(configPath, "utf-8");
+        content = content.replace(
+          '"token": "${DISCORD_BOT_TOKEN}"',
+          `"token": "${token}"`
+        );
+        if (guildId) {
+          const guildConfig = `"${guildId}": {
+          "requireMention": true,
+          "users": [],
+          "roles": [],
+          "channels": {}
+        }`;
+          content = content.replace(
+            '"guilds": {\n        // Example guild configuration',
+            `"guilds": {
+        ${guildConfig},
+        // Example guild configuration`
+          );
+        }
+        await fs4.writeFile(configPath, content, "utf-8");
+      }
+      /**
+       * Setup OpenClaw CLI configuration
+       */
+      async setupOpenClaw(token) {
+        const { execSync: execSync3 } = await import("child_process");
+        try {
+          execSync3("which openclaw", { stdio: "ignore" });
+        } catch {
+          return { success: false, message: "OpenClaw CLI not installed. Run: npm install -g openclaw" };
+        }
+        try {
+          execSync3(`openclaw config set channels.discord.token '"${token}"' --json`, { stdio: "ignore" });
+          execSync3("openclaw config set channels.discord.enabled true --json", { stdio: "ignore" });
+          execSync3("openclaw config set gateway.mode local", { stdio: "ignore" });
+          return { success: true, message: "OpenClaw configured successfully!" };
+        } catch (error) {
+          return { success: false, message: `Failed to configure OpenClaw: ${error.message}` };
+        }
+      }
+    };
+  }
+});
+
+// src/targets/index.ts
+function getAdapter(target) {
+  const adapter = adapters[target];
+  if (!adapter) {
+    throw new Error(`Unknown target: ${target}. Available: ${Object.keys(adapters).join(", ")}`);
+  }
+  return adapter;
+}
+function isValidTarget(target) {
+  return target in adapters;
+}
+function getTargetDirectory(target) {
+  return adapters[target].config.directory;
+}
+function getTargetDisplayName(target) {
+  return adapters[target].config.displayName;
+}
+var adapters;
+var init_targets = __esm({
+  "src/targets/index.ts"() {
+    "use strict";
+    init_claude_adapter();
+    init_gemini_adapter();
+    init_discord_adapter();
+    init_claude_adapter();
+    init_gemini_adapter();
+    init_discord_adapter();
+    adapters = {
+      claude: new ClaudeAdapter(),
+      gemini: new GeminiAdapter(),
+      discord: new DiscordAdapter()
+    };
+  }
+});
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+import fs5 from "fs-extra";
+import { join as join6, relative } from "path";
+function hashFile(filePath) {
+  if (!fs5.existsSync(filePath)) {
+    return null;
+  }
+  const content = fs5.readFileSync(filePath);
+  return createHash("md5").update(content).digest("hex");
+}
+async function hashDirectory(dirPath, baseDir = dirPath) {
+  const hashes = {};
+  if (!fs5.existsSync(dirPath)) {
+    return hashes;
+  }
+  const items = await fs5.readdir(dirPath, { withFileTypes: true });
+  for (const item of items) {
+    const itemPath = join6(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 fs6 from "fs-extra";
+import { join as join7 } from "path";
+function getStatePath(projectDir) {
+  return join7(projectDir, STATE_DIR, STATE_FILE);
+}
+async function loadState(projectDir) {
+  const statePath = getStatePath(projectDir);
+  if (!fs6.existsSync(statePath)) {
+    return null;
+  }
+  try {
+    return await fs6.readJson(statePath);
+  } catch {
+    return null;
+  }
+}
+async function saveState(projectDir, state) {
+  const stateDir = join7(projectDir, STATE_DIR);
+  const statePath = join7(stateDir, STATE_FILE);
+  await fs6.ensureDir(stateDir);
+  await fs6.writeJson(statePath, state, { spaces: 2 });
+}
+async function createInitialState(projectDir, options) {
+  const { kit, source, target, targets, installed } = options;
+  const allHashes = {};
+  const targetList = targets || [target.replace(".", "")];
+  for (const t of targetList) {
+    const targetDirName = t.startsWith(".") ? t : `.${t}`;
+    const targetDir = join7(projectDir, targetDirName);
+    if (fs6.existsSync(targetDir)) {
+      const hashes = await hashDirectory(targetDir);
+      for (const [path, hash] of Object.entries(hashes)) {
+        allHashes[`${targetDirName}/${path}`] = hash;
+      }
+    }
+  }
+  const state = {
+    version: "1.0.0",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUpdate: (/* @__PURE__ */ new Date()).toISOString(),
+    kit,
+    source,
+    target,
+    targets,
+    installed,
+    originalHashes: allHashes
+  };
+  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 = join7(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 = join7(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/copy.ts
+import fs7 from "fs-extra";
+import { join as join8, dirname as dirname5 } from "path";
+async function copyItems(items, type, sourceDir, destDir, mergeMode = false) {
+  const typeDir = join8(sourceDir, type);
+  const destTypeDir = join8(destDir, type);
+  if (!fs7.existsSync(typeDir)) {
+    return { copied: [], skipped: items, errors: [] };
+  }
+  await fs7.ensureDir(destTypeDir);
+  const copied = [];
+  const skipped = [];
+  const errors = [];
+  for (const item of items) {
+    try {
+      const itemPath = join8(typeDir, item);
+      const itemPathMd = itemPath + ".md";
+      let srcPath;
+      if (fs7.existsSync(itemPath)) {
+        srcPath = itemPath;
+      } else if (fs7.existsSync(itemPathMd)) {
+        srcPath = itemPathMd;
+      } else {
+        skipped.push(item);
+        continue;
+      }
+      const stat = fs7.statSync(srcPath);
+      if (stat.isDirectory()) {
+        await fs7.copy(srcPath, join8(destTypeDir, item), { overwrite: !mergeMode });
+      } else {
+        const destPath = srcPath.endsWith(".md") ? join8(destTypeDir, item + ".md") : join8(destTypeDir, item);
+        await fs7.ensureDir(join8(destTypeDir, item.split("/").slice(0, -1).join("/")));
+        await fs7.copy(srcPath, destPath, { overwrite: !mergeMode });
+      }
+      copied.push(item);
+    } catch (err) {
+      errors.push({ item, error: err.message });
+    }
+  }
+  return { copied, skipped, errors };
+}
+async function copyAgentsMd(agentsMdPath, projectDir, mergeMode = false) {
+  if (!agentsMdPath || !fs7.existsSync(agentsMdPath)) {
+    return false;
+  }
+  const destPath = join8(projectDir, "AGENTS.md");
+  if (mergeMode && fs7.existsSync(destPath)) {
+    return false;
+  }
+  await fs7.copy(agentsMdPath, destPath, { overwrite: !mergeMode });
+  return true;
+}
+function listAvailable(type, sourceDir) {
+  const typeDir = join8(sourceDir, type);
+  if (!fs7.existsSync(typeDir)) {
+    return [];
+  }
+  const items = fs7.readdirSync(typeDir);
+  return items.map((item) => {
+    const itemPath = join8(typeDir, item);
+    const isDir = fs7.statSync(itemPath).isDirectory();
+    const name = item.replace(/\.md$/, "");
+    return { name, isDir, path: itemPath };
+  });
+}
+var init_copy = __esm({
+  "src/utils/copy.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// 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 promptCliTargets() {
+  const selection = await p.multiselect({
+    message: "Select AI CLI target(s):",
+    options: [
+      { value: "claude", label: "Claude Code", hint: ".claude/" },
+      { value: "gemini", label: "Gemini CLI", hint: ".gemini/" },
+      { value: "discord", label: "Discord + Clawbot", hint: ".discord/" }
+    ],
+    initialValues: ["claude"],
+    required: true
+  });
+  if (p.isCancel(selection)) process.exit(0);
+  return selection;
+}
+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);
+}
+function isOpenClawInstalled() {
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    execSync3("which openclaw", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGeminiCliInstalled() {
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    execSync3("which gemini", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGeminiCliLoggedIn() {
+  try {
+    const fs15 = __require("fs");
+    const path = __require("path");
+    const credsPath = path.join(process.env.HOME || "", ".gemini", "oauth_creds.json");
+    return fs15.existsSync(credsPath);
+  } catch {
+    return false;
+  }
+}
+async function setupGeminiCliAuth() {
+  const { execSync: execSync3, spawnSync } = __require("child_process");
+  try {
+    if (!isGeminiCliLoggedIn()) {
+      console.log(pc.cyan("Logging in to Gemini CLI..."));
+      spawnSync("gemini", ["auth", "login"], { stdio: "inherit" });
+    }
+    console.log(pc.cyan("Enabling Gemini CLI auth plugin..."));
+    execSync3("openclaw plugins enable google-gemini-cli-auth", { stdio: "ignore" });
+    console.log(pc.cyan("Setting Gemini CLI as default model provider..."));
+    execSync3("openclaw models auth login --provider google-gemini-cli --set-default", { stdio: "inherit" });
+    console.log(pc.green("\u2713 Gemini CLI OAuth configured successfully!"));
+    return true;
+  } catch (error) {
+    console.log(pc.red("\u2717 Failed to setup Gemini CLI auth"));
+    console.log(pc.gray("  Try manually:"));
+    console.log(pc.gray("    1. gemini auth login"));
+    console.log(pc.gray("    2. openclaw plugins enable google-gemini-cli-auth"));
+    console.log(pc.gray("    3. openclaw models auth login --provider google-gemini-cli --set-default"));
+    return false;
+  }
+}
+async function installGeminiCli() {
+  const { execSync: execSync3 } = __require("child_process");
+  try {
+    console.log(pc.cyan("Installing Gemini CLI..."));
+    execSync3("npm install -g @anthropic-ai/gemini-cli", { stdio: "inherit" });
+    console.log(pc.green("\u2713 Gemini CLI installed successfully!"));
+    console.log("");
+    return true;
+  } catch (error) {
+    console.log(pc.red("\u2717 Failed to install Gemini CLI"));
+    console.log(pc.gray("  Try manually: npm install -g @anthropic-ai/gemini-cli"));
+    console.log("");
+    return false;
+  }
+}
+function isDiscordConfigured() {
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    const result = execSync3("openclaw config get channels.discord.token 2>/dev/null", { encoding: "utf-8" });
+    return result && result.trim().length > 10;
+  } catch {
+    return false;
+  }
+}
+function restartGateway() {
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    execSync3("openclaw config set gateway.mode local", { stdio: "ignore" });
+    console.log(pc.cyan("Starting OpenClaw gateway..."));
+    execSync3("openclaw gateway", { stdio: "inherit" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installOpenClaw() {
+  const { execSync: execSync3 } = __require("child_process");
+  try {
+    console.log(pc.cyan("Installing OpenClaw CLI..."));
+    execSync3("npm install -g openclaw", { stdio: "inherit" });
+    console.log(pc.green("\u2713 OpenClaw CLI installed successfully!"));
+    console.log("");
+    return true;
+  } catch (error) {
+    console.log(pc.red("\u2717 Failed to install OpenClaw CLI"));
+    console.log(pc.gray("  Try manually: npm install -g openclaw"));
+    console.log("");
+    return false;
+  }
+}
+async function promptDiscordSetup() {
+  console.log("");
+  console.log(pc.cyan("\u2501\u2501\u2501 Discord Bot Setup \u2501\u2501\u2501"));
+  let openclawInstalled = isOpenClawInstalled();
+  if (!openclawInstalled) {
+    console.log(pc.yellow("\u26A0 OpenClaw CLI not found."));
+    console.log("");
+    const shouldInstall = await p.confirm({
+      message: "Install OpenClaw CLI now? (npm install -g openclaw)",
+      initialValue: true
+    });
+    if (p.isCancel(shouldInstall)) process.exit(0);
+    if (shouldInstall) {
+      openclawInstalled = await installOpenClaw();
+    }
+  }
+  if (openclawInstalled && isDiscordConfigured()) {
+    console.log(pc.green("\u2713 Discord bot token already configured."));
+    console.log("");
+    const action = await p.select({
+      message: "What do you want to do?",
+      options: [
+        { value: "restart", label: "Restart gateway", hint: "Use existing config" },
+        { value: "gemini-cli", label: "Setup Gemini CLI OAuth", hint: "Use Gemini CLI as AI provider" },
+        { value: "reconfigure", label: "Reconfigure", hint: "Enter new token" },
+        { value: "skip", label: "Skip setup", hint: "Continue without changes" }
+      ]
+    });
+    if (p.isCancel(action)) process.exit(0);
+    if (action === "restart") {
+      restartGateway();
+      return {
+        token: "",
+        autoSetup: false,
+        openclawInstalled: true,
+        restartOnly: true
+      };
+    }
+    if (action === "gemini-cli") {
+      let geminiInstalled = isGeminiCliInstalled();
+      if (!geminiInstalled) {
+        console.log(pc.yellow("\u26A0 Gemini CLI not found."));
+        const shouldInstall = await p.confirm({
+          message: "Install Gemini CLI now?",
+          initialValue: true
+        });
+        if (p.isCancel(shouldInstall)) process.exit(0);
+        if (shouldInstall) {
+          geminiInstalled = await installGeminiCli();
+        }
+      }
+      if (geminiInstalled) {
+        await setupGeminiCliAuth();
+      }
+      return {
+        token: "",
+        autoSetup: false,
+        openclawInstalled: true,
+        restartOnly: true,
+        useGeminiCli: true
+      };
+    }
+    if (action === "skip") {
+      return {
+        token: "",
+        autoSetup: false,
+        openclawInstalled: true,
+        restartOnly: true
+      };
+    }
+  }
+  console.log("");
+  console.log(pc.cyan("Choose AI Model Authentication:"));
+  const authMethod = await p.select({
+    message: "How do you want to authenticate with AI models?",
+    options: [
+      { value: "gemini-cli", label: "Gemini CLI OAuth", hint: "Recommended - uses Google OAuth via Gemini CLI" },
+      { value: "api-key", label: "API Key", hint: "Use your own API key" }
+    ]
+  });
+  if (p.isCancel(authMethod)) process.exit(0);
+  let useGeminiCli = false;
+  if (authMethod === "gemini-cli") {
+    let geminiInstalled = isGeminiCliInstalled();
+    if (!geminiInstalled) {
+      console.log(pc.yellow("\u26A0 Gemini CLI not found."));
+      const shouldInstall = await p.confirm({
+        message: "Install Gemini CLI now?",
+        initialValue: true
+      });
+      if (p.isCancel(shouldInstall)) process.exit(0);
+      if (shouldInstall) {
+        geminiInstalled = await installGeminiCli();
+      }
+    }
+    if (geminiInstalled && openclawInstalled) {
+      const setupSuccess = await setupGeminiCliAuth();
+      useGeminiCli = setupSuccess;
+    }
+  }
+  console.log("");
+  console.log(pc.gray("Get your Discord bot token from: https://discord.com/developers/applications"));
+  console.log("");
+  const token = await p.password({
+    message: "Discord Bot Token:",
+    mask: "*",
+    validate: (value) => {
+      if (!value || !value.trim()) return "Bot token is required";
+      if (value.length < 50) return "Invalid token format";
+    }
+  });
+  if (p.isCancel(token)) process.exit(0);
+  const hasGuild = await p.confirm({
+    message: "Do you have a Discord Server ID to configure?",
+    initialValue: false
+  });
+  if (p.isCancel(hasGuild)) process.exit(0);
+  let guildId;
+  if (hasGuild) {
+    const guild = await p.text({
+      message: "Discord Server ID:",
+      placeholder: "123456789012345678",
+      validate: (value) => {
+        if (!value || !value.trim()) return "Server ID is required";
+        if (!/^\d{17,20}$/.test(String(value))) return "Invalid Server ID format (should be 17-20 digits)";
+      }
+    });
+    if (p.isCancel(guild)) process.exit(0);
+    guildId = guild;
+  }
+  let autoSetup = false;
+  if (openclawInstalled && !useGeminiCli) {
+    const shouldAutoSetup = await p.confirm({
+      message: "Auto-setup OpenClaw config?",
+      initialValue: true
+    });
+    if (p.isCancel(shouldAutoSetup)) process.exit(0);
+    autoSetup = shouldAutoSetup;
+  } else if (useGeminiCli) {
+    autoSetup = true;
+  }
+  return {
+    token,
+    guildId,
+    autoSetup,
+    openclawInstalled,
+    useGeminiCli
+  };
+}
+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 fs8 from "fs-extra";
+import { join as join9, 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("");
+  if (options.password !== void 0) {
+    if (String(options.password) !== INIT_PASSWORD) {
+      console.log(pc2.red("Invalid access code. Access denied."));
+      return;
+    }
+  } else if (process.stdin.isTTY && !options.yes) {
+    const { password: password2 } = await import("@clack/prompts").then((p4) => ({
+      password: p4.password
+    }));
+    const inputPassword = await password2({
+      message: "Enter access code:",
+      mask: "*"
+    });
+    if (inputPassword !== INIT_PASSWORD) {
+      console.log(pc2.red("Invalid access code. Access denied."));
+      return;
+    }
+  } else {
+    console.log(pc2.red("Access code required. Use --password <code>"));
+    return;
+  }
+  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 cliTargets;
+  if (options.target) {
+    const targetsFromFlag = options.target.split(",").map((t) => t.trim());
+    cliTargets = targetsFromFlag.filter((t) => isValidTarget(t));
+    if (cliTargets.length === 0) {
+      console.log(pc2.yellow(`Unknown target "${options.target}", using "claude"`));
+      cliTargets = ["claude"];
+    }
+  } else if (!process.stdin.isTTY || options.yes) {
+    cliTargets = ["claude"];
+  } else {
+    cliTargets = await promptCliTargets();
+  }
+  let discordConfig = null;
+  let openclawSetupSuccess = false;
+  if (cliTargets.includes("discord") && process.stdin.isTTY && !options.yes) {
+    discordConfig = await promptDiscordSetup();
+  }
+  let existingAction = null;
+  const existingTargets = [];
+  for (const target of cliTargets) {
+    const targetDir = join9(projectDir, getTargetDirectory(target));
+    if (options.fresh && fs8.existsSync(targetDir)) {
+      await fs8.remove(targetDir);
+      existingTargets.push(getTargetDisplayName(target));
+    } else if (fs8.existsSync(targetDir) && !options.force) {
+      existingTargets.push(getTargetDisplayName(target));
+    }
+  }
+  if (options.fresh && existingTargets.length > 0) {
+    const akDir = join9(projectDir, ".ak");
+    if (fs8.existsSync(akDir)) {
+      await fs8.remove(akDir);
+    }
+    console.log(pc2.cyan(`Fresh install: removed existing files (${existingTargets.join(", ")})`));
+    existingAction = null;
+  } else if (existingTargets.length > 0 && !options.force) {
+    if (!process.stdin.isTTY || options.yes) {
+      if (options.yes) {
+        existingAction = "override";
+      } else {
+        console.log(pc2.yellow(`${existingTargets.join(", ")} already exists. Use --force to override.`));
+        return;
+      }
+    } else {
+      existingAction = await promptExistingTarget(existingTargets.join(", "));
+      if (existingAction === "skip") {
+        console.log(pc2.yellow("Skipped. No changes made."));
+        return;
+      }
+    }
+  }
+  if (!isCurrentDir && fs8.existsSync(projectDir) && !options.force) {
+    const files = fs8.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);
+    if (cliTargets.includes("claude")) {
+      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(`  Targets: ${cliTargets.map((t) => getTargetDisplayName(t)).join(", ")}`));
+  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 fs8.ensureDir(projectDir);
+    for (const target of cliTargets) {
+      const adapter = getAdapter(target);
+      const targetDir = join9(projectDir, adapter.config.directory);
+      await fs8.ensureDir(targetDir);
+      const targetLabel = adapter.config.displayName;
+      const filteredItems = adapter.filterInstallItems(toInstall);
+      spinner.text = mergeMode ? `Merging agents (${targetLabel})...` : `Copying agents (${targetLabel})...`;
+      await adapter.copyAgents(filteredItems.agents, source.claudeDir, targetDir, mergeMode);
+      spinner.text = mergeMode ? `Merging skills (${targetLabel})...` : `Copying skills (${targetLabel})...`;
+      await adapter.copySkills(filteredItems.skills, source.claudeDir, targetDir, mergeMode);
+      spinner.text = mergeMode ? `Merging commands (${targetLabel})...` : `Copying commands (${targetLabel})...`;
+      await adapter.copyCommands(filteredItems.commands, source.claudeDir, targetDir, mergeMode);
+      if (adapter.supports("workflows") && filteredItems.workflows.length > 0) {
+        spinner.text = mergeMode ? `Merging workflows (${targetLabel})...` : `Copying workflows (${targetLabel})...`;
+        await adapter.copyWorkflows(filteredItems.workflows, source.claudeDir, targetDir, mergeMode);
+      }
+      if (adapter.supports("router") && filteredItems.includeRouter) {
+        spinner.text = mergeMode ? `Merging router (${targetLabel})...` : `Copying router (${targetLabel})...`;
+        await adapter.copyRouter(source.claudeDir, targetDir, mergeMode);
+      }
+      if (adapter.supports("hooks") && filteredItems.includeHooks) {
+        spinner.text = mergeMode ? `Merging hooks (${targetLabel})...` : `Copying hooks (${targetLabel})...`;
+        await adapter.copyHooks(source.claudeDir, targetDir, mergeMode);
+      }
+      spinner.text = mergeMode ? `Merging extras (${targetLabel})...` : `Copying extras (${targetLabel})...`;
+      await adapter.copyExtras(source.claudeDir, targetDir, mergeMode);
+      spinner.text = mergeMode ? `Merging base files (${targetLabel})...` : `Copying base files (${targetLabel})...`;
+      await adapter.copyBaseFiles(targetDir, mergeMode);
+      if (target === "discord" && discordConfig && !discordConfig.restartOnly) {
+        const discordAdapter = adapter;
+        spinner.text = "Configuring Discord bot...";
+        await discordAdapter.updateConfig(targetDir, discordConfig.token, discordConfig.guildId);
+        if (discordConfig.autoSetup) {
+          spinner.text = "Setting up OpenClaw...";
+          const result = await discordAdapter.setupOpenClaw(discordConfig.token);
+          openclawSetupSuccess = result.success;
+          if (!result.success) {
+            console.log(pc2.yellow(`
+  Note: ${result.message}`));
+          }
+        }
+      } else if (target === "discord" && discordConfig?.restartOnly) {
+        openclawSetupSuccess = true;
+      }
+    }
+    if (source.agentsMd && cliTargets.includes("claude")) {
+      await copyAgentsMd(source.agentsMd, projectDir, mergeMode);
+    }
+    spinner.text = "Saving state...";
+    await createInitialState(projectDir, {
+      kit: kitName,
+      source: source.path,
+      targets: cliTargets,
+      target: getTargetDirectory(cliTargets[0]),
+      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}`));
+    }
+    const targetNames = cliTargets.map((t) => getTargetDisplayName(t)).join(" & ");
+    console.log(pc2.cyan(`Ready to code with ${targetNames}!`));
+    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"));
+    if (cliTargets.includes("discord")) {
+      console.log("");
+      console.log(pc2.cyan("Discord Bot Setup:"));
+      const openclawInstalled = discordConfig?.openclawInstalled ?? false;
+      if (!openclawInstalled) {
+        console.log(pc2.yellow("  0. npm install -g openclaw  - Install OpenClaw CLI first!"));
+        console.log(pc2.white("  1. openclaw gateway         - Start the bot"));
+        console.log(pc2.white("  2. Invite bot to server     - Use OAuth2 URL from Discord Portal"));
+        console.log(pc2.white("  3. DM the bot to pair       - Approve with: openclaw pairing approve discord <code>"));
+      } else {
+        if (openclawSetupSuccess) {
+          console.log(pc2.green("  \u2713 OpenClaw installed & configured"));
+        } else {
+          console.log(pc2.green("  \u2713 OpenClaw installed"));
+        }
+        console.log(pc2.white("  1. openclaw gateway         - Start the bot"));
+        console.log(pc2.white("  2. Invite bot to server     - Use OAuth2 URL from Discord Portal"));
+        console.log(pc2.white("  3. DM the bot to pair       - Approve with: openclaw pairing approve discord <code>"));
+      }
+      console.log(pc2.gray("  See .discord/README.md for full guide"));
+    }
+    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_PASSWORD;
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_kits();
+    init_paths();
+    init_targets();
+    init_state();
+    init_copy();
+    init_prompts();
+    INIT_PASSWORD = "6702";
+  }
+});
+
+// src/commands/add.ts
+var add_exports = {};
+__export(add_exports, {
+  addCommand: () => addCommand
+});
+import fs9 from "fs-extra";
+import { join as join10 } 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: tk add <type>:<name>"));
+    console.log(pc3.gray("Examples:"));
+    console.log(pc3.gray("  tk add skill:databases"));
+    console.log(pc3.gray("  tk add agent:debugger"));
+    console.log(pc3.gray("  tk 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 "tk 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 "tk list ${normalizedType}" to see available options.`));
+    return;
+  }
+  const targetFolder = state?.target || ".claude";
+  const targetDir = join10(projectDir, targetFolder);
+  const destPath = join10(targetDir, normalizedType, name);
+  const destPathMd = destPath + ".md";
+  if (fs9.existsSync(destPath) || fs9.existsSync(destPathMd)) {
+    console.log(pc3.yellow(`${type} "${name}" already exists in project.`));
+    console.log(pc3.gray('Use "tk 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 fs10 from "fs-extra";
+import { join as join11 } 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 "tk 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 tk. Run "tk 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 = join11(source.claudeDir, type);
+      if (fs10.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 = join11(targetDir, path);
+      const originalHash = state.originalHashes?.[path];
+      const currentHash = fs10.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 = join11(source.claudeDir, path);
+        const destPath = join11(targetDir, path);
+        await fs10.ensureDir(join11(targetDir, path.split("/").slice(0, -1).join("/")));
+        await fs10.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 fs11 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 "tk 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 && !fs11.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 fs12 from "fs-extra";
+import { join as join12 } 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 = join12(projectDir, folder);
+    if (fs12.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 fs12.ensureDir(join12(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 = join12(targetDir.dir, dir);
+            if (fs12.existsSync(fullPath)) {
+              const items = fs12.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: () => fs12.existsSync(join12(projectDir, "AGENTS.md"))
+    },
+    {
+      name: "source",
+      label: "Source directory accessible",
+      severity: "error",
+      check: () => {
+        if (!state || !state.source) return true;
+        return fs12.existsSync(state.source);
+      },
+      getMeta: () => state && state.source ? { source: state.source } : {}
+    },
+    {
+      name: "subdirs_agents",
+      label: "agents/ exists",
+      severity: "warning",
+      check: () => {
+        if (!targetDir) return false;
+        return fs12.existsSync(join12(targetDir.dir, "agents"));
+      },
+      fix: async () => {
+        if (targetDir) {
+          await fs12.ensureDir(join12(targetDir.dir, "agents"));
+        }
+      },
+      getMeta: () => {
+        if (!targetDir) return {};
+        const fullPath = join12(targetDir.dir, "agents");
+        if (fs12.existsSync(fullPath)) {
+          const items = fs12.readdirSync(fullPath).length;
+          return { items };
+        }
+        return {};
+      }
+    },
+    {
+      name: "subdirs_commands",
+      label: "commands/ exists",
+      severity: "warning",
+      check: () => {
+        if (!targetDir) return false;
+        return fs12.existsSync(join12(targetDir.dir, "commands"));
+      },
+      fix: async () => {
+        if (targetDir) {
+          await fs12.ensureDir(join12(targetDir.dir, "commands"));
+        }
+      },
+      getMeta: () => {
+        if (!targetDir) return {};
+        const fullPath = join12(targetDir.dir, "commands");
+        if (fs12.existsSync(fullPath)) {
+          const items = fs12.readdirSync(fullPath).length;
+          return { items };
+        }
+        return {};
+      }
+    },
+    {
+      name: "subdirs_skills",
+      label: "skills/ exists",
+      severity: "warning",
+      check: () => {
+        if (!targetDir) return false;
+        return fs12.existsSync(join12(targetDir.dir, "skills"));
+      },
+      fix: async () => {
+        if (targetDir) {
+          await fs12.ensureDir(join12(targetDir.dir, "skills"));
+        }
+      },
+      getMeta: () => {
+        if (!targetDir) return {};
+        const fullPath = join12(targetDir.dir, "skills");
+        if (fs12.existsSync(fullPath)) {
+          const items = fs12.readdirSync(fullPath).length;
+          return { items };
+        }
+        return {};
+      }
+    },
+    {
+      name: "subdirs_scripts",
+      label: "scripts/ exists",
+      severity: "warning",
+      check: () => {
+        if (!targetDir) return false;
+        return fs12.existsSync(join12(targetDir.dir, "scripts"));
+      }
+    },
+    {
+      name: "subdirs_hooks",
+      label: "hooks/ exists",
+      severity: "warning",
+      check: () => {
+        if (!targetDir) return false;
+        return fs12.existsSync(join12(targetDir.dir, "hooks"));
+      }
+    },
+    {
+      name: "statusline",
+      label: "statusline files exist",
+      severity: "warning",
+      check: () => {
+        if (!targetDir) return false;
+        return fs12.existsSync(join12(targetDir.dir, "statusline.cjs")) || fs12.existsSync(join12(targetDir.dir, "statusline.sh"));
+      }
+    }
+  ];
+  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 = `# Thanh 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 "tk init ." to initialize this directory
+`;
+      }
+      if (r.name === "state") {
+        markdown += `- State file is missing. Re-run "tk init" or create manually
+`;
+      }
+      if (r.name === "source" && r.meta?.source) {
+        markdown += `- Update source path: tk update --source <new-path>
+`;
+      }
+    }
+  }
+  const reportPath = join12(projectDir, ".ak", "doctor-report.md");
+  await fs12.ensureDir(join12(projectDir, ".ak"));
+  await fs12.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("\nThanh 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 "tk init ." to initialize this directory'));
+    }
+    if (!hasState && isProject) {
+      console.log(pc7.white('  \u2022 State file is missing. Re-run "tk init" or create manually'));
+    }
+    if (state && state.source && !fs12.existsSync(state.source)) {
+      console.log(pc7.white("  \u2022 Update source path: tk 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 fs13 from "fs-extra";
+import { join as join13 } 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 = join13(dir, folder);
+    if (fs13.existsSync(targetPath)) {
+      existingTargets.push({ name, path: targetPath });
+    }
+  }
+  const akDir = join13(dir, ".ak");
+  const hasAkState = fs13.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 = join13(target.path, subdir);
+      if (fs13.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 fs13.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 join14 } from "path";
+function getCurrentVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join14(CLI_ROOT, "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function getLatestVersion() {
+  const output = execSync2("npm view thanh-kit 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 && !options.force) {
+      console.log(pc11.green("\nAlready up to date!"));
+      console.log(pc11.gray("Use --force to reinstall anyway."));
+      return;
+    }
+    if (options.check) {
+      console.log(pc11.yellow('\nUpdate available! Run "tk update-cli" to install.'));
+      return;
+    }
+    const target = options.version || "latest";
+    const installSpinner = ora6(`Installing thanh-kit@${target}...`).start();
+    execSync2(`npm install -g thanh-kit@${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 thanh-kit"));
+  }
+}
+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 fs14 from "fs-extra";
+import { join as join15 } 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 = join15(source.claudeDir, "skills", skillName);
+  if (!fs14.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 = join15(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+      await fs14.ensureDir(join15(process.cwd(), AGENT_SKILL_PATHS[agent]));
+      await fs14.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 = join15(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+      await fs14.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 = join15(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+  return fs14.existsSync(skillPath);
+}
+function getInstalledSkills(agent) {
+  const skillsDir = join15(process.cwd(), AGENT_SKILL_PATHS[agent]);
+  if (!fs14.existsSync(skillsDir)) {
+    return [];
+  }
+  try {
+    const items = fs14.readdirSync(skillsDir);
+    return items.filter((item) => {
+      const itemPath = join15(skillsDir, item);
+      return fs14.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 dirname6, join as join17 } 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 CLI (claude, gemini, discord or combination)").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("-p, --password <code>", "Access code for initialization").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., tk 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").option("-f, --force", "Force reinstall even if already up to date").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 join16 } from "path";
+import { homedir as homedir2 } from "os";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+var CACHE_DIR = join16(homedir2(), ".thanh-kit");
+var CACHE_FILE = join16(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 = dirname6(__filename2);
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync3(join17(__dirname2, "..", "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+var cli = cac("tk");
+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 "tk update-cli" to update\n'));
+  }
+} catch {
+}
+//# sourceMappingURL=index.js.map