@cannbot-ai/install-helper 0.0.1-beta.0

package/dist/index.js

@@ -0,0 +1,2900 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { select as select3, Separator as Separator3 } from "@inquirer/prompts";
+import chalk5 from "chalk";
+
+// src/ui/wizard.ts
+import { select, checkbox, Separator } from "@inquirer/prompts";
+import chalk2 from "chalk";
+
+// src/core/registry.ts
+var PLUGIN_REGISTRY = [
+  {
+    id: "ops-direct-invoke",
+    dir: "plugins-official/ops-direct-invoke",
+    displayName: "AscendC Kernel \u76F4\u8C03",
+    script: "init.sh",
+    aliases: ["ops-direct", "ascendc-direct", "direct", "kernel"],
+    skills: 16,
+    agents: 3,
+    description: "Ascend C Kernel <<<>>> \u76F4\u8C03\u7B97\u5B50\u5F00\u53D1\u5168\u6D41\u7A0B"
+  },
+  {
+    id: "ops-direct-invoke-flash",
+    dir: "plugins-official/ops-direct-invoke-flash",
+    displayName: "AscendC Kernel \u4ECE\u96F6\u6784\u5EFA",
+    script: "init.sh",
+    aliases: ["flash", "kernel-flash"],
+    skills: 1,
+    agents: 1,
+    description: "Ascend C / Ascend950 Reg API \u6838\u51FD\u6570\u4ECE\u96F6\u6784\u5EFA"
+  },
+  {
+    id: "ops-registry-invoke",
+    dir: "plugins-official/ops-registry-invoke",
+    displayName: "AscendC \u7B97\u5B50\u6CE8\u518C\u8C03\u7528",
+    script: "init.sh",
+    aliases: ["ops-registry", "ascendc-registry", "registry"],
+    skills: 12,
+    agents: 4,
+    description: "Ascend C \u7B97\u5B50\u6CE8\u518C\u8C03\u7528\u5F00\u53D1\u6D41\u7A0B"
+  },
+  {
+    id: "pypto-op-orchestrator",
+    dir: "plugins-official/pypto-op-orchestrator",
+    displayName: "PyPTO \u7B97\u5B50",
+    script: "init.sh",
+    aliases: ["pypto", "pytorch"],
+    skills: 8,
+    agents: 3,
+    description: "PyPTO \u7B97\u5B50\u7AEF\u5230\u7AEF\u5F00\u53D1\u7F16\u6392"
+  },
+  {
+    id: "triton-op-generator",
+    dir: "plugins-official/triton-op-generator",
+    displayName: "Triton \u7B97\u5B50\u751F\u6210",
+    script: "install.sh",
+    aliases: ["triton"],
+    skills: 6,
+    agents: 0,
+    description: "Triton-Ascend \u7B97\u5B50\u4EE3\u7801\u751F\u6210\u4E0E\u4F18\u5316"
+  },
+  {
+    id: "tilelang-op-orchestrator",
+    dir: "plugins-official/tilelang-op-orchestrator",
+    displayName: "TileLang \u7B97\u5B50",
+    script: "init.sh",
+    aliases: ["tilelang"],
+    skills: 9,
+    agents: 3,
+    description: "TileLang \u7B97\u5B50\u5F00\u53D1\u6D41\u7A0B"
+  },
+  {
+    id: "model-infer-optimize",
+    dir: "plugins-official/model-infer-optimize",
+    displayName: "NPU \u63A8\u7406\u4F18\u5316",
+    script: "init.sh",
+    aliases: ["model-infer", "infer", "inference"],
+    skills: 11,
+    agents: 3,
+    description: "NPU \u6A21\u578B\u63A8\u7406\u7AEF\u5230\u7AEF\u4F18\u5316"
+  },
+  {
+    id: "catlass-op-generator",
+    dir: "plugins-official/catlass-op-generator",
+    displayName: "Catlass \u7B97\u5B50\u76F4\u8C03",
+    script: "init.sh",
+    aliases: ["catlass"],
+    skills: 10,
+    agents: 3,
+    description: "Catlass \u7B97\u5B50\u76F4\u8C03\u5F00\u53D1"
+  },
+  {
+    id: "ops-code-reviewer",
+    dir: "plugins-official/ops-code-reviewer",
+    displayName: "\u4EE3\u7801\u68C0\u89C6",
+    script: "init.sh",
+    aliases: ["code-review", "reviewer", "review"],
+    skills: 5,
+    agents: 1,
+    description: "\u4EE3\u7801\u68C0\u89C6\u4E0E\u89C4\u8303\u68C0\u67E5"
+  },
+  {
+    id: "torch-compile",
+    dir: "plugins-official/torch-compile",
+    displayName: "torch.compile \u56FE\u6A21\u5F0F",
+    script: "init.sh",
+    aliases: ["torch", "compile", "graph"],
+    skills: 6,
+    agents: 1,
+    description: "PyTorch torch.compile \u56FE\u6A21\u5F0F\u9002\u914D"
+  }
+];
+function findPlugin(query) {
+  const normalized = query.toLowerCase().trim();
+  const exactMatch = PLUGIN_REGISTRY.find(
+    (p) => p.id === normalized || p.id === query.trim()
+  );
+  if (exactMatch) return exactMatch;
+  const aliasMatch = PLUGIN_REGISTRY.find(
+    (p) => p.aliases.some((a) => a === normalized)
+  );
+  if (aliasMatch) return aliasMatch;
+  const prefixMatch = PLUGIN_REGISTRY.find((p) => p.id.startsWith(normalized));
+  if (prefixMatch) return prefixMatch;
+  return void 0;
+}
+function getAllPlugins() {
+  return PLUGIN_REGISTRY;
+}
+function getPluginById(id) {
+  return PLUGIN_REGISTRY.find((p) => p.id === id);
+}
+
+// src/core/detector.ts
+import { execa } from "execa";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// src/utils/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync } from "fs";
+function detectTraeVariant() {
+  const home = homedir();
+  if (existsSync(join(home, ".trae-cn"))) return "ide";
+  if (existsSync(join(home, ".marscode"))) return "plugin";
+  if (existsSync(join(home, ".traecli"))) return "cli";
+  return "unknown";
+}
+function getConfigRoot(tool, level, base) {
+  const home = homedir();
+  if (level === "global") {
+    switch (tool) {
+      case "opencode":
+        return join(home, ".config", "opencode");
+      case "claude":
+        return join(home, ".claude");
+      case "trae": {
+        const variant = detectTraeVariant();
+        switch (variant) {
+          case "plugin":
+            return join(home, ".marscode");
+          case "cli":
+            return join(home, ".traecli");
+          default:
+            return join(home, ".trae-cn");
+        }
+      }
+      case "cursor":
+        return join(home, ".cursor");
+      case "copilot":
+        return join(home, ".copilot");
+    }
+  }
+  const baseDir = base || process.cwd();
+  switch (tool) {
+    case "opencode":
+      return join(baseDir, ".opencode");
+    case "claude":
+      return join(baseDir, ".claude");
+    case "trae": {
+      const variant = detectTraeVariant();
+      switch (variant) {
+        case "plugin":
+          return join(baseDir, ".marscode");
+        case "cli":
+          return join(baseDir, ".traecli");
+        default:
+          return join(baseDir, ".trae");
+      }
+    }
+    case "cursor":
+      return join(baseDir, ".cursor");
+    case "copilot":
+      return join(baseDir, ".github");
+  }
+}
+function getConfigFileName(tool) {
+  return tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
+}
+function getSkillsDir(configRoot) {
+  return join(configRoot, "skills");
+}
+function getAgentsDir(configRoot) {
+  return join(configRoot, "agents");
+}
+function getManifestPath(configRoot) {
+  return join(configRoot, "cannbot-manifest.json");
+}
+function getCannbotConfigDir() {
+  return join(homedir(), ".cannbot");
+}
+function getCannbotRepoPath() {
+  return join(getCannbotConfigDir(), "repo");
+}
+
+// src/core/detector.ts
+async function getCommandVersion(cmd, args = ["--version"]) {
+  try {
+    const result = await execa(cmd, args, { timeout: 5e3 });
+    const output = result.stdout.trim();
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : output.split("\n")[0];
+  } catch {
+    return void 0;
+  }
+}
+async function getCommandPath(cmd) {
+  try {
+    const result = await execa("which", [cmd], { timeout: 5e3 });
+    return result.stdout.trim();
+  } catch {
+    return void 0;
+  }
+}
+async function detectOpenCode() {
+  const path = await getCommandPath("opencode");
+  if (!path) return void 0;
+  const version = await getCommandVersion("opencode");
+  return { name: "opencode", version, path };
+}
+async function detectClaude() {
+  const path = await getCommandPath("claude");
+  if (!path) return void 0;
+  const version = await getCommandVersion("claude");
+  return { name: "claude", version, path };
+}
+async function detectTrae() {
+  const home = homedir2();
+  const variant = detectTraeVariant();
+  let path;
+  if (variant === "ide" && existsSync2(join2(home, ".trae-cn"))) {
+    path = join2(home, ".trae-cn");
+  } else if (variant === "plugin" && existsSync2(join2(home, ".marscode"))) {
+    path = join2(home, ".marscode");
+  } else if (variant === "cli" && existsSync2(join2(home, ".traecli"))) {
+    path = join2(home, ".traecli");
+  } else if (variant === "unknown") {
+    const cmdPath = await getCommandPath("trae");
+    if (cmdPath) path = cmdPath;
+  }
+  if (!path) return void 0;
+  return { name: "trae", version: variant, path };
+}
+async function detectCursor() {
+  const path = await getCommandPath("cursor");
+  if (path) {
+    const version = await getCommandVersion("cursor");
+    return { name: "cursor", version, path };
+  }
+  if (process.platform === "darwin") {
+    const appPath = "/Applications/Cursor.app";
+    if (existsSync2(appPath)) {
+      return { name: "cursor", path: appPath };
+    }
+  }
+  return void 0;
+}
+async function detectCopilot() {
+  const path = await getCommandPath("gh");
+  if (!path) return void 0;
+  try {
+    await execa("gh", ["extension", "list"], { timeout: 5e3 });
+    return { name: "copilot", path };
+  } catch {
+    return void 0;
+  }
+}
+async function detectTools() {
+  const detectors = [
+    detectOpenCode,
+    detectClaude,
+    detectTrae,
+    detectCursor,
+    detectCopilot
+  ];
+  const results = await Promise.allSettled(detectors.map((d) => d()));
+  const tools = [];
+  for (const result of results) {
+    if (result.status === "fulfilled" && result.value) {
+      tools.push(result.value);
+    }
+  }
+  return tools;
+}
+function getToolDisplayName(tool) {
+  const names = {
+    opencode: "OpenCode",
+    claude: "Claude Code",
+    trae: "Trae",
+    cursor: "Cursor",
+    copilot: "GitHub Copilot"
+  };
+  return names[tool];
+}
+function getAllTools() {
+  return ["opencode", "claude", "trae", "cursor", "copilot"];
+}
+
+// src/core/manifest.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { join as join3 } from "path";
+function readManifest(configRoot) {
+  const manifestPath = getManifestPath(configRoot);
+  if (existsSync3(manifestPath)) {
+    try {
+      const content = readFileSync(manifestPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+    }
+  }
+  return null;
+}
+function readAllManifests(configRoot) {
+  const manifests = [];
+  const plugins = getAllPlugins();
+  const standardPath = getManifestPath(configRoot);
+  if (existsSync3(standardPath)) {
+    try {
+      const content = readFileSync(standardPath, "utf-8");
+      manifests.push(JSON.parse(content));
+    } catch {
+    }
+  }
+  for (const plugin of plugins) {
+    const pluginManifestPath = join3(configRoot, `${plugin.id}-manifest.json`);
+    if (existsSync3(pluginManifestPath)) {
+      try {
+        const content = readFileSync(pluginManifestPath, "utf-8");
+        manifests.push(JSON.parse(content));
+      } catch {
+      }
+    }
+  }
+  return manifests;
+}
+function scanInstalled() {
+  const plugins = getAllPlugins();
+  const installed = [];
+  const tools = ["opencode", "claude", "trae", "cursor", "copilot"];
+  const levels = ["project", "global"];
+  for (const tool of tools) {
+    for (const level of levels) {
+      const configRoot = getConfigRoot(tool, level);
+      const manifests = readAllManifests(configRoot);
+      for (const manifest of manifests) {
+        const plugin = plugins.find((p) => p.id === manifest.team);
+        if (!plugin) continue;
+        const alreadyAdded = installed.some(
+          (p) => p.id === plugin.id && p.tool === tool && p.level === level
+        );
+        if (alreadyAdded) continue;
+        installed.push({
+          id: plugin.id,
+          displayName: plugin.displayName,
+          tool,
+          level,
+          skillsCount: manifest.installed_skills?.length || 0,
+          agentsCount: manifest.installed_agents?.length || 0,
+          installTime: manifest.install_time,
+          configRoot
+        });
+      }
+    }
+  }
+  return installed;
+}
+
+// src/utils/i18n.ts
+var zh_CN = {
+  wizard_title: "CANNBot \u4EA4\u4E92\u5F0F\u5B89\u88C5\u52A9\u624B",
+  wizard_detect: "\u6B63\u5728\u68C0\u6D4B\u5DF2\u5B89\u88C5\u7684 AI \u7F16\u7A0B\u5DE5\u5177...",
+  wizard_select_tool: "\u9009\u62E9 AI \u7F16\u7A0B\u5DE5\u5177",
+  wizard_select_level: "\u9009\u62E9\u5B89\u88C5\u4F4D\u7F6E",
+  wizard_select_plugins: "\u9009\u62E9\u8981\u5B89\u88C5\u7684\u63D2\u4EF6",
+  wizard_confirm: "\u786E\u8BA4\u5B89\u88C5",
+  wizard_detected_tool: "\u68C0\u6D4B\u5230",
+  wizard_confirm_tool: "\u4F7F\u7528",
+  wizard_last_used: "\u4E0A\u6B21\u4F7F\u7528",
+  wizard_already_installed: "\u5DF2\u5B89\u88C5",
+  install_cloning: "\u6B63\u5728\u514B\u9686 cannbot-skills \u4ED3\u5E93...",
+  install_repo_ready: "\u4ED3\u5E93\u5C31\u7EEA",
+  install_progress: "\u6B63\u5728\u5B89\u88C5",
+  install_done: "\u5B89\u88C5\u5B8C\u6210",
+  install_success: "\u6210\u529F",
+  install_failed: "\u5931\u8D25",
+  install_already_installed: "\u5DF2\u5B89\u88C5",
+  install_reinstall_confirm: "\u662F\u5426\u91CD\u65B0\u5B89\u88C5\uFF08\u8986\u76D6\uFF09",
+  install_skip: "\u8DF3\u8FC7",
+  install_enhanced_next_steps: "\u4E0B\u4E00\u6B65",
+  install_enhanced_launch: "\u542F\u52A8",
+  install_enhanced_try: "\u8BD5\u8BD5",
+  install_enhanced_more: "\u66F4\u591A",
+  install_enhanced_check: "\u68C0\u67E5",
+  install_enhanced_docs: "\u6587\u6863",
+  update_title: "\u66F4\u65B0\u5DF2\u5B89\u88C5\u7684 Skills",
+  update_updating: "\u6B63\u5728\u66F4\u65B0",
+  update_done: "\u66F4\u65B0\u5B8C\u6210",
+  update_no_plugins: "\u6682\u65E0\u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6",
+  doctor_title: "CANNBot Doctor",
+  doctor_tools: "AI \u5DE5\u5177",
+  doctor_plugins: "\u5DF2\u5B89\u88C5\u63D2\u4EF6",
+  doctor_links: "\u94FE\u63A5\u5B8C\u6574\u6027",
+  doctor_config: "\u914D\u7F6E\u6587\u4EF6",
+  doctor_result: "\u7ED3\u679C",
+  doctor_fix_title: "\u81EA\u52A8\u4FEE\u590D",
+  doctor_fix_cleaning: "\u6E05\u7406\u5931\u6548\u94FE\u63A5",
+  doctor_fix_rebuilding: "\u91CD\u5EFA\u76EE\u5F55",
+  doctor_fix_done: "\u4FEE\u590D\u5B8C\u6210",
+  info_title: "\u63D2\u4EF6\u8BE6\u60C5",
+  info_description: "\u63CF\u8FF0",
+  info_skills: "Skills",
+  info_agents: "Agents",
+  info_status: "\u72B6\u6001",
+  info_quickstart: "\u5FEB\u901F\u5F00\u59CB",
+  info_not_found: "\u672A\u627E\u5230\u63D2\u4EF6",
+  lang_title: "\u8BED\u8A00\u8BBE\u7F6E",
+  lang_current: "\u5F53\u524D\u8BED\u8A00",
+  lang_set: "\u8BED\u8A00\u5DF2\u8BBE\u7F6E\u4E3A",
+  lang_invalid: "\u65E0\u6548\u7684\u8BED\u8A00\uFF0C\u652F\u6301: zh_CN, en_US",
+  list_title: "\u53EF\u7528\u573A\u666F",
+  list_id: "\u5E8F\u53F7",
+  list_name: "\u573A\u666F\u540D",
+  list_status: "\u72B6\u6001",
+  list_skills: "Skills",
+  list_agents: "Agents",
+  status_installed: "\u5DF2\u88C5",
+  status_not_installed: "\u672A\u88C5",
+  error_tool_not_found: "\u672A\u68C0\u6D4B\u5230\u4EFB\u4F55 AI \u7F16\u7A0B\u5DE5\u5177",
+  error_plugin_not_found: "\u672A\u627E\u5230\u63D2\u4EF6",
+  error_repo_not_found: "\u4ED3\u5E93\u672A\u627E\u5230",
+  quick_start: "\u542F\u52A8\u547D\u4EE4",
+  quick_start_hint: "\u8BD5\u8BD5\u8F93\u5165: \u5E2E\u6211\u5F00\u53D1\u4E00\u4E2A Abs \u7B97\u5B50",
+  skill_select_category: "\u9009\u62E9 Skill \u7C7B\u522B",
+  skill_select_items: "\u9009\u62E9\u8981\u5B89\u88C5\u7684 Skills",
+  skill_already_installed: "\u5DF2\u5B89\u88C5",
+  skill_install_progress: "\u6B63\u5728\u5B89\u88C5",
+  skill_install_done: "Skill \u5B89\u88C5\u5B8C\u6210",
+  skill_uninstall_done: "Skill \u5378\u8F7D\u5B8C\u6210",
+  skill_list_title: "\u53EF\u7528 Skills",
+  wizard_select_mode: "\u9009\u62E9\u5B89\u88C5\u7C7B\u578B",
+  wizard_mode_plugin: "\u5B89\u88C5 Plugin",
+  wizard_mode_plugin_desc: "\u5B8C\u6574\u5F00\u53D1\u5DE5\u4F5C\u6D41\uFF08Skills + Agents + \u914D\u7F6E\u6587\u4EF6\uFF09",
+  wizard_mode_skill: "\u5B89\u88C5 Skill",
+  wizard_mode_skill_desc: "\u4EC5\u5B89\u88C5\u9886\u57DF\u77E5\u8BC6\u6280\u80FD\uFF0C\u8BA9 AI \u638C\u63E1\u7279\u5B9A\u80FD\u529B",
+  wizard_back: "\u8FD4\u56DE",
+  wizard_cancel: "\u9000\u51FA",
+  wizard_no_selection: "\u672A\u9009\u62E9\u4EFB\u4F55\u9879\uFF0C\u8BF7\u9009\u62E9\u64CD\u4F5C",
+  wizard_back_to_reselect: "\u8FD4\u56DE"
+};
+var en_US = {
+  wizard_title: "CANNBot Skills Setup Wizard",
+  wizard_detect: "Detecting installed AI coding tools...",
+  wizard_select_tool: "Select AI coding tool",
+  wizard_select_level: "Select install level",
+  wizard_select_plugins: "Select scenarios to install",
+  wizard_confirm: "Confirm installation",
+  wizard_detected_tool: "Detected",
+  wizard_confirm_tool: "Confirm using",
+  wizard_last_used: "last used",
+  wizard_already_installed: "installed",
+  install_cloning: "Cloning cannbot-skills repository...",
+  install_repo_ready: "Repository ready",
+  install_progress: "Installing",
+  install_done: "Installation complete",
+  install_success: "success",
+  install_failed: "failed",
+  install_already_installed: "already installed",
+  install_reinstall_confirm: "Reinstall (overwrite)",
+  install_skip: "skipped",
+  install_enhanced_next_steps: "Next steps",
+  install_enhanced_launch: "Launch",
+  install_enhanced_try: "Try",
+  install_enhanced_more: "More",
+  install_enhanced_check: "Check",
+  install_enhanced_docs: "Docs",
+  update_title: "Update installed Skills",
+  update_updating: "Updating",
+  update_done: "Update complete",
+  update_no_plugins: "No installed plugins",
+  doctor_title: "CANNBot Doctor",
+  doctor_tools: "AI Tools",
+  doctor_plugins: "Installed Plugins",
+  doctor_links: "Link Integrity",
+  doctor_config: "Configuration",
+  doctor_result: "Result",
+  doctor_fix_title: "Auto-fix",
+  doctor_fix_cleaning: "Cleaning broken links",
+  doctor_fix_rebuilding: "Rebuilding directories",
+  doctor_fix_done: "Fix complete",
+  info_title: "Plugin Details",
+  info_description: "Description",
+  info_skills: "Skills",
+  info_agents: "Agents",
+  info_status: "Status",
+  info_quickstart: "Quick Start",
+  info_not_found: "Plugin not found",
+  lang_title: "Language Settings",
+  lang_current: "Current language",
+  lang_set: "Language set to",
+  lang_invalid: "Invalid language, supported: zh_CN, en_US",
+  list_title: "Available Scenarios",
+  list_id: "#",
+  list_name: "Name",
+  list_status: "Status",
+  list_skills: "Skills",
+  list_agents: "Agents",
+  status_installed: "installed",
+  status_not_installed: "not installed",
+  error_tool_not_found: "No AI coding tool detected",
+  error_plugin_not_found: "Plugin not found",
+  error_repo_not_found: "Repository not found",
+  quick_start: "Launch command",
+  quick_start_hint: "Try: help me develop an Abs operator",
+  skill_select_category: "Select Skill category",
+  skill_select_items: "Select Skills to install (space to toggle, enter to confirm)",
+  skill_already_installed: "installed",
+  skill_install_progress: "Installing",
+  skill_install_done: "Skill installation complete",
+  skill_uninstall_done: "Skill uninstallation complete",
+  skill_list_title: "Available Skills",
+  wizard_select_mode: "Select installation mode",
+  wizard_mode_plugin: "Install Plugin",
+  wizard_mode_plugin_desc: "Full development workflow (Skills + Agents + config)",
+  wizard_mode_skill: "Install Skill",
+  wizard_mode_skill_desc: "Domain knowledge only, give AI specific capabilities",
+  wizard_back: "Go back",
+  wizard_cancel: "Cancel installation",
+  wizard_no_selection: "No items selected, please choose an action",
+  wizard_back_to_reselect: "Go back"
+};
+var currentLang = "zh_CN";
+function setLanguage(lang) {
+  currentLang = lang;
+}
+function t(key) {
+  return currentLang === "zh_CN" ? zh_CN[key] : en_US[key];
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var logger = {
+  success: (msg) => console.log(chalk.green("\u2713") + " " + msg),
+  error: (msg) => console.log(chalk.red("\u2717") + " " + msg),
+  warn: (msg) => console.log(chalk.yellow("\u26A0") + " " + msg),
+  info: (msg) => console.log(chalk.cyan("\u2192") + " " + msg),
+  step: (msg) => console.log(chalk.dim(msg)),
+  blank: () => console.log()
+};
+function createSpinner(text) {
+  return ora({ text, color: "cyan" });
+}
+function printBanner(subtitle) {
+  console.log(chalk.cyan(`
+   ____    _    _   _ _   _ ____        _
+  / ___|  / \\  | \\ | | \\ | | __ )  ___ | |_
+ | |     / _ \\ |  \\| |  \\| |  _ \\ / _ \\| __|
+ | |___ / ___ \\| |\\  | |\\  | |_) | (_) | |_
+  \\____/_/   \\_\\_| \\_|_| \\_|____/ \\___/ \\__|
+`));
+  if (subtitle) {
+    console.log(chalk.bold(`  ${subtitle}`));
+    console.log();
+  }
+}
+function getDisplayWidth(str) {
+  let width = 0;
+  for (const ch of str) {
+    const code = ch.codePointAt(0);
+    if (code >= 11904 && code <= 40959 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65103 || code >= 65280 && code <= 65519) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function printBoxTitle(title, width = 65) {
+  const border = "\u2550".repeat(width);
+  const displayWidth = getDisplayWidth(title);
+  const totalPadding = width - displayWidth;
+  const leftPadding = Math.floor(totalPadding / 2);
+  const rightPadding = totalPadding - leftPadding;
+  const paddedTitle = " ".repeat(Math.max(0, leftPadding)) + title + " ".repeat(Math.max(0, rightPadding));
+  console.log();
+  console.log(chalk.cyan.bold(`  \u2554${border}\u2557`));
+  console.log(chalk.cyan.bold(`  \u2551`) + chalk.cyan.bold(paddedTitle) + chalk.cyan.bold(`\u2551`));
+  console.log(chalk.cyan.bold(`  \u255A${border}\u255D`));
+  console.log();
+}
+function showOperationHints(isCheckbox = false) {
+  if (isCheckbox) {
+    console.log(`  \u{1F4A1} \x1B[36m\u2191\u2193\x1B[0m \u79FB\u52A8 | \x1B[36m\u7A7A\u683C\x1B[0m \u9009\u62E9 | \x1B[36m\u23CE\x1B[0m \u786E\u8BA4
+`);
+  } else {
+    console.log(`  \u{1F4A1} \x1B[36m\u2191\u2193\x1B[0m \u79FB\u52A8 | \x1B[36m\u23CE\x1B[0m \u786E\u8BA4
+`);
+  }
+}
+
+// src/utils/config.ts
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { parse, stringify } from "yaml";
+function getConfigDir() {
+  return join4(homedir3(), ".cannbot");
+}
+function getConfigPath() {
+  return join4(getConfigDir(), "config.yaml");
+}
+function readConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync4(configPath)) {
+    return {
+      language: "zh_CN",
+      installedPlugins: []
+    };
+  }
+  try {
+    const content = readFileSync2(configPath, "utf-8");
+    const parsed = parse(content);
+    return {
+      language: parsed.language || "zh_CN",
+      lastTool: parsed.lastTool,
+      lastLevel: parsed.lastLevel,
+      repoPath: parsed.repoPath,
+      installedPlugins: parsed.installedPlugins || []
+    };
+  } catch {
+    return {
+      language: "zh_CN",
+      installedPlugins: []
+    };
+  }
+}
+function writeConfig(config) {
+  const configDir = getConfigDir();
+  if (!existsSync4(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  const configPath = getConfigPath();
+  const content = stringify(config);
+  writeFileSync(configPath, content, "utf-8");
+}
+function updateConfig(updates) {
+  const config = readConfig();
+  const updated = { ...config, ...updates };
+  writeConfig(updated);
+  return updated;
+}
+function addInstalledPlugin(pluginId) {
+  const config = readConfig();
+  if (!config.installedPlugins.includes(pluginId)) {
+    config.installedPlugins.push(pluginId);
+    writeConfig(config);
+  }
+}
+function removeInstalledPlugin(pluginId) {
+  const config = readConfig();
+  config.installedPlugins = config.installedPlugins.filter(
+    (id) => id !== pluginId
+  );
+  writeConfig(config);
+}
+
+// src/ui/theme.ts
+var selectTheme = {
+  helpMode: "never"
+};
+var checkboxTheme = {
+  icon: {
+    checked: "\x1B[32m\u2611\x1B[22m",
+    unchecked: "\u2610",
+    cursor: "\u276F"
+  },
+  helpMode: "never"
+};
+
+// src/ui/wizard.ts
+var BACK = "__back__";
+var CANCEL = "__cancel__";
+async function selectToolWithDetection() {
+  const config = readConfig();
+  logger.blank();
+  const spinner = createSpinner(t("wizard_detect"));
+  spinner.start();
+  const detectedTools = await detectTools();
+  spinner.stop();
+  const result = await stepTool(detectedTools, config.lastTool);
+  if (result === BACK) return "back";
+  if (result === CANCEL) return "cancel";
+  return result;
+}
+async function runWizard() {
+  const config = readConfig();
+  logger.blank();
+  const spinner = createSpinner(t("wizard_detect"));
+  spinner.start();
+  const detectedTools = await detectTools();
+  spinner.stop();
+  let selectedTool;
+  let level = "project";
+  let plugins = [];
+  let step = 0;
+  while (true) {
+    switch (step) {
+      case 0: {
+        const result = await stepTool(detectedTools, config.lastTool);
+        if (result === BACK) {
+          return { language: config.language || "zh_CN", tool: "opencode", level: "project", plugins: [], confirmed: false, back: true };
+        }
+        if (result === CANCEL) {
+          return { language: config.language || "zh_CN", tool: "opencode", level: "project", plugins: [], confirmed: false };
+        }
+        selectedTool = result;
+        step = 1;
+        break;
+      }
+      case 1: {
+        const result = await stepLevel(config.lastLevel);
+        if (result === BACK) {
+          step = 0;
+          break;
+        }
+        if (result === CANCEL) {
+          return { language: config.language || "zh_CN", tool: selectedTool, level: "project", plugins: [], confirmed: false };
+        }
+        level = result;
+        step = 2;
+        break;
+      }
+      case 2: {
+        const result = await stepPlugins(selectedTool, level);
+        if (result === BACK) {
+          step = 1;
+          break;
+        }
+        if (result === CANCEL) {
+          return { language: config.language || "zh_CN", tool: selectedTool, level, plugins: [], confirmed: false };
+        }
+        plugins = result;
+        step = 3;
+        break;
+      }
+      case 3: {
+        const result = await stepConfirm(selectedTool, level, plugins);
+        if (result === BACK) {
+          step = 2;
+          break;
+        }
+        if (result === CANCEL || result === false) {
+          return { language: config.language || "zh_CN", tool: selectedTool, level, plugins: [], confirmed: false };
+        }
+        updateConfig({ lastTool: selectedTool, lastLevel: level });
+        return { language: config.language || "zh_CN", tool: selectedTool, level, plugins, confirmed: true };
+      }
+    }
+  }
+}
+async function stepTool(detectedTools, lastTool) {
+  printBoxTitle("\u9009\u62E9 AI \u7F16\u7A0B\u5DE5\u5177");
+  if (detectedTools.length === 0) {
+    logger.error(t("error_tool_not_found"));
+    const choices2 = [
+      ...["opencode", "claude", "trae", "cursor", "copilot"].map((tool) => ({
+        name: `> ${getToolDisplayName(tool)}`,
+        value: tool
+      })),
+      new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+      { name: "<- " + t("wizard_back"), value: BACK },
+      { name: "x  " + t("wizard_cancel"), value: CANCEL }
+    ];
+    showOperationHints();
+    const result2 = await select({ message: t("wizard_select_tool"), choices: choices2, default: lastTool, loop: false, theme: selectTheme });
+    if (result2 === BACK) return BACK;
+    if (result2 === CANCEL) return CANCEL;
+    return result2;
+  }
+  if (detectedTools.length === 1) {
+    const tool = detectedTools[0];
+    const isLastUsed = lastTool === tool.name;
+    const suffix = isLastUsed ? ` [${t("wizard_last_used")}]` : "";
+    logger.success(
+      `${t("wizard_detected_tool")}: ${getToolDisplayName(tool.name)}${tool.version ? ` (v${tool.version})` : ""}${suffix}`
+    );
+    const choices2 = [
+      { name: `> ${t("wizard_confirm_tool")} ${getToolDisplayName(tool.name)}`, value: tool.name },
+      { name: `> ${t("wizard_select_tool")}`, value: "manual" },
+      new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+      { name: "<- " + t("wizard_back"), value: BACK },
+      { name: "x  " + t("wizard_cancel"), value: CANCEL }
+    ];
+    showOperationHints();
+    const result2 = await select({ message: t("wizard_select_tool"), choices: choices2, loop: false, theme: selectTheme });
+    if (result2 === BACK) return BACK;
+    if (result2 === CANCEL) return CANCEL;
+    if (result2 === "manual") {
+      return stepToolManual(lastTool);
+    }
+    return tool.name;
+  }
+  const choices = detectedTools.map((tool) => {
+    const isLastUsed = lastTool === tool.name;
+    const suffix = isLastUsed ? ` [${t("wizard_last_used")}]` : "";
+    return {
+      name: `> ${getToolDisplayName(tool.name)}${tool.version ? ` (v${tool.version})` : ""}${suffix}`,
+      value: tool.name
+    };
+  });
+  choices.push(new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  choices.push({ name: "<- " + t("wizard_back"), value: BACK });
+  choices.push({ name: "x  " + t("wizard_cancel"), value: CANCEL });
+  showOperationHints();
+  const result = await select({ message: t("wizard_select_tool"), choices, default: lastTool, loop: false, theme: selectTheme });
+  if (result === BACK) return BACK;
+  if (result === CANCEL) return CANCEL;
+  return result;
+}
+async function stepToolManual(lastTool) {
+  const choices = [
+    ...["opencode", "claude", "trae", "cursor", "copilot"].map((tool) => ({
+      name: `> ${getToolDisplayName(tool)}`,
+      value: tool
+    })),
+    new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+    { name: "<- " + t("wizard_back"), value: BACK },
+    { name: "x  " + t("wizard_cancel"), value: CANCEL }
+  ];
+  showOperationHints();
+  const result = await select({ message: t("wizard_select_tool"), choices, default: lastTool, loop: false, theme: selectTheme });
+  if (result === BACK) return BACK;
+  if (result === CANCEL) return CANCEL;
+  return result;
+}
+async function stepLevel(lastLevel) {
+  printBoxTitle("\u9009\u62E9\u5B89\u88C5\u4F4D\u7F6E");
+  const choices = [
+    { name: "> project \u2014 \u5B89\u88C5\u5230\u5F53\u524D\u76EE\u5F55\uFF08\u63A8\u8350\uFF0C\u4EC5\u5F53\u524D\u9879\u76EE\u53EF\u7528\uFF09", value: "project" },
+    { name: "> global \u2014 \u5B89\u88C5\u5230\u5168\u5C40\uFF08\u6240\u6709\u9879\u76EE\u5171\u4EAB\uFF09", value: "global" },
+    new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+    { name: "<- " + t("wizard_back"), value: BACK },
+    { name: "x  " + t("wizard_cancel"), value: CANCEL }
+  ];
+  showOperationHints();
+  const result = await select({
+    message: t("wizard_select_level"),
+    choices,
+    default: lastLevel || "project",
+    loop: false,
+    theme: selectTheme
+  });
+  if (result === BACK) return BACK;
+  if (result === CANCEL) return CANCEL;
+  return result;
+}
+async function stepPlugins(tool, level) {
+  printBoxTitle("\u9009\u62E9\u8981\u5B89\u88C5\u7684\u63D2\u4EF6");
+  const plugins = getAllPlugins();
+  const configRoot = getConfigRoot(tool, level);
+  const manifests = readAllManifests(configRoot);
+  const installedSet = new Set(manifests.map((m) => m.team));
+  const choices = plugins.map((p) => {
+    const isInstalled = installedSet.has(p.id);
+    const suffix = isInstalled ? ` [${t("wizard_already_installed")}]` : "";
+    return {
+      name: `${p.displayName}${suffix} (${p.skills} skills, ${p.agents} agents)`,
+      value: p.id,
+      checked: false
+    };
+  });
+  choices.push(new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  choices.push({ name: "<- " + t("wizard_back"), value: BACK, checked: false });
+  choices.push({ name: "x  " + t("wizard_cancel"), value: CANCEL, checked: false });
+  showOperationHints(true);
+  const selected = await checkbox({
+    message: t("wizard_select_plugins"),
+    choices,
+    loop: false,
+    instructions: false,
+    theme: checkboxTheme
+  });
+  if (selected.includes(BACK)) return BACK;
+  if (selected.includes(CANCEL)) return CANCEL;
+  const pluginIds = selected.filter((v) => v !== BACK && v !== CANCEL);
+  if (pluginIds.length === 0) {
+    const action = await select({
+      message: t("wizard_no_selection"),
+      choices: [
+        new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+        { name: "<- " + t("wizard_back_to_reselect"), value: "back" },
+        { name: "x  " + t("wizard_cancel"), value: "cancel" }
+      ],
+      loop: false,
+      theme: selectTheme
+    });
+    if (action === "back") return BACK;
+    return CANCEL;
+  }
+  return pluginIds;
+}
+async function stepConfirm(tool, level, plugins) {
+  printBoxTitle("\u786E\u8BA4\u5B89\u88C5");
+  const allPlugins = getAllPlugins();
+  const selectedPlugins = plugins.map((id) => allPlugins.find((p) => p.id === id));
+  logger.info(`\u5373\u5C06\u5B89\u88C5 ${chalk2.bold(plugins.length)} \u4E2A\u573A\u666F\u5230 ${chalk2.cyan("." + tool + "/")}\uFF1A`);
+  for (const plugin of selectedPlugins) {
+    if (plugin) {
+      logger.step(`  \u2022 ${chalk2.bold(plugin.displayName)} ${chalk2.dim(`(${plugin.skills} skills, ${plugin.agents} agents)`)}`);
+    }
+  }
+  logger.blank();
+  const choices = [
+    { name: "> " + t("wizard_confirm"), value: "confirm" },
+    new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+    { name: "<- " + t("wizard_back"), value: BACK },
+    { name: "x  " + t("wizard_cancel"), value: CANCEL }
+  ];
+  showOperationHints();
+  const result = await select({ message: t("wizard_confirm"), choices, loop: false, theme: selectTheme });
+  if (result === BACK) return BACK;
+  if (result === CANCEL) return CANCEL;
+  return true;
+}
+
+// src/core/repository.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { join as join6 } from "path";
+import { execa as execa2 } from "execa";
+
+// src/core/scanner.ts
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, dirname } from "path";
+import { parse as parseYaml } from "yaml";
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "asc-devkit",
+  "cann-samples",
+  "tilelang-ascend",
+  ".agents",
+  ".opencode",
+  ".claude",
+  "dist",
+  "build"
+]);
+var SKILL_SCAN_DIRS = [
+  "ops",
+  "model",
+  "graph",
+  "infra",
+  "ops-lab"
+];
+var PLUGIN_SCAN_DIRS = [
+  "plugins-official",
+  "plugins-community"
+];
+function scanSkills(repoPath) {
+  const skills = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of SKILL_SCAN_DIRS) {
+    const fullPath = join5(repoPath, dir);
+    if (!existsSync5(fullPath)) continue;
+    scanDirectory(fullPath, repoPath, dir, skills, seen);
+  }
+  for (const pluginDir of PLUGIN_SCAN_DIRS) {
+    const pluginParent = join5(repoPath, pluginDir);
+    if (!existsSync5(pluginParent)) continue;
+    for (const plugin of safeReaddir(pluginParent)) {
+      const pluginPath = join5(pluginParent, plugin);
+      if (!isDirectory(pluginPath)) continue;
+      const skillsDir = join5(pluginPath, "skills");
+      if (existsSync5(skillsDir)) {
+        scanDirectory(skillsDir, repoPath, `${pluginDir}/${plugin}/skills`, skills, seen);
+      }
+      const skillDir = join5(pluginPath, "skill");
+      if (existsSync5(skillDir)) {
+        scanDirectory(skillDir, repoPath, `${pluginDir}/${plugin}/skill`, skills, seen);
+      }
+    }
+  }
+  return skills;
+}
+function parseFrontmatter(filePath) {
+  try {
+    const content = readFileSync3(filePath, "utf-8");
+    const lines = content.split("\n");
+    if (lines.length < 3) return null;
+    if (lines[0].trim() !== "---") return null;
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].trim() === "---") {
+        endIndex = i;
+        break;
+      }
+    }
+    if (endIndex === -1) return null;
+    const yamlBlock = lines.slice(1, endIndex).join("\n").replace(/\r$/, "");
+    const parsed = parseYaml(yamlBlock);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (!parsed.name || typeof parsed.name !== "string") return null;
+    return {
+      name: parsed.name.trim(),
+      description: (parsed.description || "").trim()
+    };
+  } catch {
+    return null;
+  }
+}
+function getCurrentCommit(repoPath) {
+  try {
+    const headFile = join5(repoPath, ".git", "HEAD");
+    if (!existsSync5(headFile)) return "unknown";
+    const headContent = readFileSync3(headFile, "utf-8").trim();
+    if (headContent.startsWith("ref: ")) {
+      const refPath = join5(repoPath, ".git", headContent.slice(5));
+      if (existsSync5(refPath)) {
+        return readFileSync3(refPath, "utf-8").trim();
+      }
+    }
+    return headContent;
+  } catch {
+    return "unknown";
+  }
+}
+function readScanCache() {
+  try {
+    const cachePath = getCachePath();
+    if (!existsSync5(cachePath)) return null;
+    const content = readFileSync3(cachePath, "utf-8");
+    const cache = JSON.parse(content);
+    if (!cache.skills || !cache.timestamp) return null;
+    const age = Date.now() - cache.timestamp;
+    if (age > 24 * 60 * 60 * 1e3) return null;
+    return cache;
+  } catch {
+    return null;
+  }
+}
+function writeScanCache(cache) {
+  try {
+    const cachePath = getCachePath();
+    const cacheDir = dirname(cachePath);
+    if (!existsSync5(cacheDir)) {
+      mkdirSync2(cacheDir, { recursive: true });
+    }
+    writeFileSync2(cachePath, JSON.stringify(cache, null, 2));
+  } catch {
+  }
+}
+function getCachePath() {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join5(homeDir, ".cannbot", "scan-cache.json");
+}
+function scanDirectory(dirPath, repoPath, sourcePrefix, skills, seen) {
+  for (const entry of safeReaddir(dirPath)) {
+    const fullPath = join5(dirPath, entry);
+    if (EXCLUDE_DIRS.has(entry)) continue;
+    if (!isDirectory(fullPath)) continue;
+    const skillMd = join5(fullPath, "SKILL.md");
+    if (existsSync5(skillMd)) {
+      const frontmatter = parseFrontmatter(skillMd);
+      if (frontmatter && !seen.has(frontmatter.name)) {
+        seen.add(frontmatter.name);
+        skills.push({
+          id: frontmatter.name,
+          description: frontmatter.description,
+          source: sourcePrefix,
+          filePath: skillMd
+        });
+      }
+    }
+    scanDirectory(fullPath, repoPath, sourcePrefix, skills, seen);
+  }
+}
+function safeReaddir(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/core/skill-registry.ts
+var CATEGORY_DEFS = [
+  { id: "knowledge", name: "\u77E5\u8BC6\u4E0E\u53C2\u8003" },
+  { id: "env-tools", name: "\u73AF\u5883\u4E0E\u5DE5\u5177" },
+  { id: "debug", name: "\u8C03\u8BD5\u4E0E\u8BCA\u65AD" },
+  { id: "testing", name: "\u6D4B\u8BD5\u4E0E\u8D28\u91CF" },
+  { id: "ascendc", name: "AscendC \u5F00\u53D1" },
+  { id: "pypto", name: "PyPTO \u5F00\u53D1" },
+  { id: "tilelang", name: "TileLang \u5F00\u53D1" },
+  { id: "triton", name: "Triton \u5F00\u53D1" },
+  { id: "model", name: "\u6A21\u578B\u63A8\u7406\u4F18\u5316" },
+  { id: "graph", name: "\u56FE\u6A21\u5F0F" },
+  { id: "platform", name: "\u5E73\u53F0\u5DE5\u5177" },
+  { id: "other", name: "\u5176\u4ED6 Skills" }
+];
+var dynamicSkills = [];
+var initialized = false;
+function initFromScan(scanned) {
+  dynamicSkills = scanned.map((s) => ({
+    id: s.id,
+    description: s.description,
+    source: s.source
+  }));
+  initialized = true;
+}
+var STATIC_SKILL_CATEGORIES = [
+  {
+    id: "knowledge",
+    name: "\u77E5\u8BC6\u4E0E\u53C2\u8003",
+    skills: [
+      { id: "npu-arch", description: "NPU \u67B6\u6784\u77E5\u8BC6\u3001\u82AF\u7247\u578B\u53F7\u6620\u5C04", source: "ops" },
+      { id: "ascendc-api-best-practices", description: "API \u4F7F\u7528\u6700\u4F73\u5B9E\u8DF5", source: "ops" },
+      { id: "ascendc-tiling-design", description: "Tiling \u548C Kernel \u8BBE\u8BA1\u65B9\u6CD5\u8BBA", source: "ops" },
+      { id: "ascendc-docs-search", description: "API \u6587\u6863\u7D22\u5F15 + \u5728\u7EBF\u641C\u7D22", source: "ops" },
+      { id: "ascendc-docs-gen", description: "\u7B97\u5B50\u6587\u6863\u5199\u4F5C\u53C2\u8003", source: "ops" },
+      { id: "ascendc-performance-best-practices", description: "\u6027\u80FD\u4F18\u5316\u7ECF\u9A8C\u603B\u7ED3", source: "ops" },
+      { id: "ascendc-regbase-best-practice", description: "RegBase \u7B97\u5B50 API \u7EA6\u675F", source: "ops" },
+      { id: "ops-precision-standard", description: "\u7B97\u5B50\u7CBE\u5EA6\u6807\u51C6\uFF08atol/rtol\uFF09", source: "ops" },
+      { id: "ops-spec-gen", description: "\u7B97\u5B50 spec.yaml \u751F\u6210\u4E0E\u6821\u9A8C", source: "ops" }
+    ]
+  },
+  {
+    id: "env-tools",
+    name: "\u73AF\u5883\u4E0E\u5DE5\u5177",
+    skills: [
+      { id: "ascendc-env-check", description: "NPU \u8BBE\u5907\u67E5\u8BE2\u3001CANN \u73AF\u5883\u9A8C\u8BC1", source: "ops" },
+      { id: "cann-env-setup", description: "CANN \u5B89\u88C5\u4E0E\u73AF\u5883\u914D\u7F6E\u6307\u5BFC", source: "ops" },
+      { id: "ops-profiling", description: "NPU \u6027\u80FD\u91C7\u96C6\u4E0E\u5206\u6790", source: "ops" },
+      { id: "ops-simulator", description: "CANN Simulator \u7CBE\u5EA6/\u6027\u80FD\u4EFF\u771F", source: "ops" },
+      { id: "torch-ops-profiler", description: "torch_npu.profiler \u6027\u80FD\u62A5\u544A", source: "ops" },
+      { id: "aiss-tiling-solver", description: "AISS-TilingSolver \u81EA\u52A8\u6C42\u89E3 Tiling \u53C2\u6570", source: "ops" }
+    ]
+  },
+  {
+    id: "debug",
+    name: "\u8C03\u8BD5\u4E0E\u8BCA\u65AD",
+    skills: [
+      { id: "ascendc-precision-debug", description: "\u7CBE\u5EA6\u8C03\u8BD5\u3001\u75C7\u72B6-\u539F\u56E0\u901F\u67E5", source: "ops" },
+      { id: "ascendc-runtime-debug", description: "\u8FD0\u884C\u65F6\u9519\u8BEF\u7801\u89E3\u6790", source: "ops" },
+      { id: "ascendc-crash-debug", description: "\u5361\u6B7B/\u5D29\u6E83\u8C03\u8BD5\u3001Coredump \u5206\u6790", source: "ops" },
+      { id: "ascendc-perf-optimize", description: "\u6027\u80FD\u4F18\u5316\u7B56\u7565\u5236\u5B9A", source: "ops" },
+      { id: "model-infer-precision-debug", description: "NPU \u63A8\u7406\u7CBE\u5EA6\u8BCA\u65AD", source: "model" },
+      { id: "model-infer-runtime-debug", description: "NPU \u63A8\u7406\u8FD0\u884C\u65F6\u9519\u8BEF\u8BCA\u65AD", source: "model" },
+      { id: "torch-npugraph-ex-dfx-triage", description: "npugraph_ex DFX \u95EE\u9898\u5206\u8BCA", source: "graph" },
+      { id: "torch-npugraph-ex-compile-error-diagnosis", description: "npugraph_ex \u7F16\u8BD1\u671F\u62A5\u9519\u8BCA\u65AD", source: "graph" }
+    ]
+  },
+  {
+    id: "testing",
+    name: "\u6D4B\u8BD5\u4E0E\u8D28\u91CF",
+    skills: [
+      { id: "ascendc-code-review", description: "\u4EE3\u7801\u68C0\u89C6\u65B9\u6CD5\u8BBA", source: "ops" },
+      { id: "ascendc-ut-develop", description: "UT \u5F00\u53D1\u4E0E\u8986\u76D6\u7387\u589E\u5F3A", source: "ops" },
+      { id: "ascendc-st-design", description: "ST \u6D4B\u8BD5\u7528\u4F8B\u8BBE\u8BA1", source: "ops" },
+      { id: "ascendc-whitebox-design", description: "\u767D\u76D2\u6D4B\u8BD5\u7528\u4F8B\u751F\u6210", source: "ops" },
+      { id: "ascendc-task-focus", description: "\u957F\u4EFB\u52A1\u805A\u7126\u9632\u8FF7\u5931", source: "ops" },
+      { id: "tilelang-op-test-design", description: "TileLang \u6D4B\u8BD5\u8BBE\u8BA1", source: "ops" },
+      { id: "tilelang-review", description: "TileLang \u4EE3\u7801\u683C\u5F0F\u68C0\u67E5", source: "ops" },
+      { id: "triton-op-verifier", description: "Triton \u7B97\u5B50\u9A8C\u8BC1", source: "ops" },
+      { id: "cannbot-skill-reviewer", description: "Skill \u5165\u5E93\u8D28\u91CF\u5BA1\u67E5", source: "infra" }
+    ]
+  },
+  {
+    id: "ascendc",
+    name: "AscendC \u5F00\u53D1",
+    skills: [
+      { id: "ascendc-direct-invoke-template", description: "Kernel \u76F4\u8C03\u5DE5\u7A0B\u6A21\u677F", source: "ops" },
+      { id: "ascendc-registry-invoke-template", description: "\u81EA\u5B9A\u4E49\u7B97\u5B50\u5DE5\u7A0B\u6A21\u677F", source: "ops" },
+      { id: "ascendc-direct-invoke-to-registry-invoke", description: "\u76F4\u8C03\u8F6C\u6CE8\u518C\u8C03\u7528", source: "ops" },
+      { id: "ascendc-registry-invoke-to-direct-invoke", description: "\u6CE8\u518C\u8C03\u7528\u8F6C\u76F4\u8C03", source: "ops" },
+      { id: "ascendc-blaze-best-practice", description: "Matmul/GEMM Blaze \u76F4\u8C03\u751F\u6210", source: "ops" },
+      { id: "ascendc-simt-best-practices", description: "SIMT \u6700\u4F73\u5B9E\u8DF5\u4E0E API \u5BFC\u822A", source: "ops" },
+      { id: "ascendc-simt-tiling-design", description: "SIMT \u7B97\u5B50\u5207\u5206\u8BBE\u8BA1", source: "ops" },
+      { id: "torch-ascendc-op-extension", description: "Ascend C \u5BF9\u63A5 PyTorch", source: "ops" },
+      { id: "catlass-op-design", description: "Catlass \u7B97\u5B50\u8BBE\u8BA1", source: "ops" },
+      { id: "catlass-op-develop", description: "Catlass \u7B97\u5B50\u5F00\u53D1", source: "ops" },
+      { id: "catlass-op-perf-tune", description: "Catlass \u6027\u80FD\u8C03\u4F18", source: "ops" },
+      { id: "cuda2ascend-simt", description: "CUDA \u8FC1\u79FB\u5230 Ascend C SIMT", source: "ops-lab" },
+      { id: "ops-direct-invoke-flash", description: "\u4ECE\u96F6\u6784\u5EFA Ascend C \u6838\u51FD\u6570", source: "plugins-official/ops-direct-invoke-flash/skills" },
+      { id: "ops-registry-invoke-workflow", description: "\u6CE8\u518C\u8C03\u7528\u5DE5\u4F5C\u6D41", source: "plugins-official/ops-registry-invoke" },
+      { id: "ops-easyasc-dsl", description: "EasyASC DSL \u7B97\u5B50\u5F00\u53D1", source: "plugins-community/ops-easyasc-dsl" }
+    ]
+  },
+  {
+    id: "pypto",
+    name: "PyPTO \u5F00\u53D1",
+    skills: [
+      { id: "pypto-intent-understand", description: "\u9700\u6C42\u610F\u56FE\u7406\u89E3\u4E0E\u89C4\u683C\u751F\u6210", source: "ops" },
+      { id: "pypto-api-explore", description: "API \u53EF\u884C\u6027\u63A2\u7D22\u4E0E\u5206\u6790", source: "ops" },
+      { id: "pypto-op-design", description: "\u7B97\u5B50\u65B9\u6848\u8BBE\u8BA1\u751F\u6210", source: "ops" },
+      { id: "pypto-golden-generate", description: "Golden \u53C2\u8003\u5B9E\u73B0\u751F\u6210", source: "ops" },
+      { id: "pypto-op-develop", description: "\u7B97\u5B50\u4EE3\u7801\u5B9E\u73B0\u4E0E\u6D4B\u8BD5", source: "ops" },
+      { id: "pypto-precision-debug", description: "\u7CBE\u5EA6\u95EE\u9898\u6392\u67E5", source: "ops" },
+      { id: "pypto-precision-compare", description: "\u7CBE\u5EA6\u5BF9\u6BD4\u5206\u6790", source: "ops" },
+      { id: "pypto-op-perf-tune", description: "\u6027\u80FD\u5206\u6790\u4E0E\u8C03\u4F18", source: "ops" }
+    ]
+  },
+  {
+    id: "tilelang",
+    name: "TileLang \u5F00\u53D1",
+    skills: [
+      { id: "tilelang-env-check", description: "\u73AF\u5883\u68C0\u67E5\u4E0E\u914D\u7F6E\u9A8C\u8BC1", source: "ops" },
+      { id: "tilelang-submodule-pull", description: "\u4E09\u65B9\u5E93\u4E0E\u5B50\u6A21\u5757\u62C9\u53D6", source: "ops" },
+      { id: "tilelang-api-best-practices", description: "TileLang API \u6700\u4F73\u5B9E\u8DF5", source: "ops" },
+      { id: "tilelang-programming-model-guide", description: "Developer/Expert \u6A21\u5F0F\u9009\u62E9", source: "ops" },
+      { id: "tilelang-op-design", description: "\u7B97\u5B50\u8BBE\u8BA1\u6587\u6863\u751F\u6210", source: "ops" },
+      { id: "tilelang-op-develop", description: "\u7B97\u5B50\u4EE3\u7801\u5B9E\u73B0\u4E0E\u6D4B\u8BD5", source: "ops" },
+      { id: "tilelang-op-test-design", description: "\u6D4B\u8BD5\u8BBE\u8BA1\u4E0E\u8986\u76D6\u7387\u5206\u6790", source: "ops" },
+      { id: "tilelang-perf-optimization", description: "\u6027\u80FD\u8C03\u4F18\u4E0E\u52A3\u5316\u68C0\u67E5", source: "ops" },
+      { id: "tilelang-review", description: "\u4EE3\u7801\u683C\u5F0F\u68C0\u67E5\u4E0E\u4FEE\u590D", source: "ops" }
+    ]
+  },
+  {
+    id: "triton",
+    name: "Triton \u5F00\u53D1",
+    skills: [
+      { id: "triton-task-extractor", description: "\u7B97\u5B50\u4EFB\u52A1\u63D0\u53D6\u4E0E\u6784\u5EFA", source: "ops" },
+      { id: "triton-op-designer", description: "\u7B97\u6CD5\u8349\u56FE\u8BBE\u8BA1", source: "ops" },
+      { id: "triton-op-coding", description: "Triton \u5185\u6838\u4EE3\u7801\u751F\u6210", source: "ops" },
+      { id: "triton-op-verifier", description: "\u7B97\u5B50\u7CBE\u5EA6\u548C\u6027\u80FD\u9A8C\u8BC1", source: "ops" },
+      { id: "triton-latency-optimizer", description: "Triton \u4EE3\u7801\u6027\u80FD\u4F18\u5316", source: "ops" }
+    ]
+  },
+  {
+    id: "model",
+    name: "\u6A21\u578B\u63A8\u7406\u4F18\u5316",
+    skills: [
+      { id: "model-infer-migrator", description: "\u6846\u67B6\u9002\u914D\u4E0E\u90E8\u7F72\u57FA\u7EBF", source: "model" },
+      { id: "model-infer-parallel-analysis", description: "\u5E76\u884C\u7B56\u7565\u5206\u6790\uFF08TP/EP/DP\uFF09", source: "model" },
+      { id: "model-infer-parallel-impl", description: "\u5E76\u884C\u5207\u5206\u5B9E\u65BD", source: "model" },
+      { id: "model-infer-kvcache", description: "KVCache \u4F18\u5316 + FA \u66FF\u6362", source: "model" },
+      { id: "model-infer-fusion", description: "torch_npu \u878D\u5408\u7B97\u5B50\u66FF\u6362", source: "model" },
+      { id: "model-infer-graph-mode", description: "torch.compile \u56FE\u6A21\u5F0F\u9002\u914D", source: "model" },
+      { id: "model-infer-multi-stream", description: "\u591A\u6D41\u5E76\u884C\u4F18\u5316", source: "model" },
+      { id: "model-infer-prefetch", description: "\u6743\u91CD\u9884\u53D6\u9002\u914D", source: "model" },
+      { id: "model-infer-superkernel", description: "SuperKernel \u9002\u914D", source: "model" },
+      { id: "model-infer-precision-debug", description: "NPU \u63A8\u7406\u7CBE\u5EA6\u8BCA\u65AD", source: "model" },
+      { id: "model-infer-runtime-debug", description: "NPU \u63A8\u7406\u8FD0\u884C\u65F6\u9519\u8BEF\u8BCA\u65AD", source: "model" }
+    ]
+  },
+  {
+    id: "graph",
+    name: "\u56FE\u6A21\u5F0F",
+    skills: [
+      { id: "torch-npugraph-ex-knowledge", description: "npugraph_ex \u4F7F\u7528\u6307\u5357", source: "graph" },
+      { id: "torch-npugraph-ex-template", description: "npugraph_ex MRE \u4EE3\u7801\u6A21\u677F", source: "graph" },
+      { id: "torch-npugraph-ex-dfx-triage", description: "DFX \u95EE\u9898\u5206\u8BCA", source: "graph" },
+      { id: "torch-npugraph-ex-compile-error-diagnosis", description: "\u7F16\u8BD1\u671F\u62A5\u9519\u8BCA\u65AD", source: "graph" },
+      { id: "torch-npugraph-ex-runtime-error-diagnosis", description: "\u8FD0\u884C\u65F6\u62A5\u9519\u8BCA\u65AD", source: "graph" },
+      { id: "torch-npugraph-ex-performance-diagnosis", description: "\u6027\u80FD\u8BCA\u65AD", source: "graph" },
+      { id: "torch-custom-ops-guide", description: "\u81EA\u5B9A\u4E49\u7B97\u5B50\u5165\u56FE\u6307\u5357", source: "graph" }
+    ]
+  },
+  {
+    id: "platform",
+    name: "\u5E73\u53F0\u5DE5\u5177",
+    skills: [
+      { id: "gitcode-pr-handler", description: "GitCode PR \u6807\u9898/\u63CF\u8FF0\u751F\u6210", source: "infra" },
+      { id: "gitcode-issue-gen", description: "GitCode Issue \u751F\u6210\u4E0E\u5173\u8054", source: "infra" },
+      { id: "gitcode-issue-handler", description: "GitCode Issue \u7AEF\u5230\u7AEF\u5904\u7F6E", source: "infra" },
+      { id: "gitcode-toolkit", description: "GitCode \u534F\u4F5C\u901A\u7528\u53C2\u8003", source: "infra" },
+      { id: "cannbot-skill-reviewer", description: "Skill \u5165\u5E93\u8D28\u91CF\u5BA1\u67E5", source: "infra" }
+    ]
+  }
+];
+var CATEGORY_MAP = {};
+for (const cat of STATIC_SKILL_CATEGORIES) {
+  for (const skill of cat.skills) {
+    CATEGORY_MAP[skill.id] = cat.id;
+  }
+}
+function getActiveSkills() {
+  if (initialized) return deduplicate(dynamicSkills);
+  return deduplicate(STATIC_SKILL_CATEGORIES.flatMap((c) => c.skills));
+}
+function deduplicate(skills) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const skill of skills) {
+    if (!seen.has(skill.id)) {
+      result.push(skill);
+      seen.add(skill.id);
+    }
+  }
+  return result;
+}
+function findSkill(query) {
+  const normalized = query.toLowerCase().trim();
+  const pool = getActiveSkills();
+  return pool.find((s) => s.id === normalized);
+}
+function getAllSkills() {
+  return getActiveSkills();
+}
+function getAllCategories() {
+  const skills = getActiveSkills();
+  return CATEGORY_DEFS.map((def) => ({
+    id: def.id,
+    name: def.name,
+    skills: skills.filter((s) => {
+      const catId = CATEGORY_MAP[s.id];
+      if (catId) return catId === def.id;
+      return def.id === "other";
+    })
+  })).filter((cat) => cat.skills.length > 0);
+}
+
+// src/core/repository.ts
+var REPO_URL = "https://gitcode.com/cann/cannbot-skills.git";
+var RepositoryManager = class {
+  repoPath;
+  constructor(customPath) {
+    this.repoPath = customPath;
+  }
+  async ensureRepo() {
+    if (this.repoPath && this.isValidRepo(this.repoPath)) {
+      return this.repoPath;
+    }
+    const cwd = process.cwd();
+    if (this.isValidRepo(cwd)) {
+      this.repoPath = cwd;
+      return cwd;
+    }
+    const envPath = process.env.CANNBOT_REPO_PATH;
+    if (envPath && this.isValidRepo(envPath)) {
+      this.repoPath = envPath;
+      return envPath;
+    }
+    const cachedPath = getCannbotRepoPath();
+    if (this.isValidRepo(cachedPath)) {
+      this.repoPath = cachedPath;
+      return cachedPath;
+    }
+    return await this.cloneRepo();
+  }
+  async ensureRepoAndScan() {
+    const repoPath = await this.ensureRepo();
+    const cache = readScanCache();
+    if (cache && cache.repoCommit === getCurrentCommit(repoPath)) {
+      initFromScan(cache.skills);
+      return repoPath;
+    }
+    const skills = scanSkills(repoPath);
+    initFromScan(skills);
+    writeScanCache({
+      skills,
+      repoCommit: getCurrentCommit(repoPath),
+      timestamp: Date.now()
+    });
+    return repoPath;
+  }
+  async updateRepo() {
+    const repoPath = await this.ensureRepo();
+    try {
+      await execa2("git", ["pull", "--quiet"], { cwd: repoPath, timeout: 3e4 });
+    } catch {
+    }
+  }
+  getRepoPath() {
+    if (!this.repoPath) {
+      throw new Error("Repository not initialized. Call ensureRepo() first.");
+    }
+    return this.repoPath;
+  }
+  isValidRepo(path) {
+    if (!existsSync6(path)) return false;
+    const gitDir = join6(path, ".git");
+    const pluginsDir = join6(path, "plugins-official");
+    return existsSync6(gitDir) && existsSync6(pluginsDir);
+  }
+  async cloneRepo() {
+    const configDir = getCannbotConfigDir();
+    if (!existsSync6(configDir)) {
+      mkdirSync3(configDir, { recursive: true });
+    }
+    const targetPath = getCannbotRepoPath();
+    if (existsSync6(targetPath)) {
+      if (this.isValidRepo(targetPath)) {
+        this.repoPath = targetPath;
+        return targetPath;
+      }
+    }
+    try {
+      await execa2(
+        "git",
+        ["clone", "--depth", "1", REPO_URL, targetPath],
+        { timeout: 12e4 }
+      );
+      this.repoPath = targetPath;
+      return targetPath;
+    } catch (error) {
+      throw new Error(
+        `Failed to clone repository: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+};
+function createRepositoryManager(customPath) {
+  return new RepositoryManager(customPath);
+}
+
+// src/core/installer.ts
+import { existsSync as existsSync8 } from "fs";
+import { join as join8 } from "path";
+import { execa as execa3 } from "execa";
+
+// src/core/record.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, lstatSync, unlinkSync } from "fs";
+import { join as join7 } from "path";
+function getInstallsDir() {
+  return join7(getCannbotConfigDir(), "installs");
+}
+function getRecordPath(pluginId) {
+  return join7(getInstallsDir(), `${pluginId}.json`);
+}
+function readRecord(pluginId) {
+  const recordPath = getRecordPath(pluginId);
+  if (!existsSync7(recordPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync4(recordPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeRecord(record) {
+  const installsDir = getInstallsDir();
+  if (!existsSync7(installsDir)) {
+    mkdirSync4(installsDir, { recursive: true });
+  }
+  const recordPath = getRecordPath(record.pluginId);
+  writeFileSync4(recordPath, JSON.stringify(record, null, 2), "utf-8");
+}
+function deleteRecord(pluginId) {
+  const recordPath = getRecordPath(pluginId);
+  if (existsSync7(recordPath)) {
+    unlinkSync(recordPath);
+  }
+}
+function scanInstalledFiles(pluginId, displayName, tool, level, installPath, configRoot, manifest) {
+  const files = [];
+  const directories = [];
+  if (manifest) {
+    const skillsDir = join7(configRoot, "skills");
+    if (existsSync7(skillsDir)) {
+      directories.push(skillsDir);
+      for (const skillName of manifest.installed_skills || []) {
+        const skillPath = join7(skillsDir, skillName);
+        if (existsSync7(skillPath) || isSymlink(skillPath)) {
+          files.push(skillPath);
+        }
+      }
+    }
+    const agentsDir = join7(configRoot, "agents");
+    if (existsSync7(agentsDir)) {
+      directories.push(agentsDir);
+      for (const agentName of manifest.installed_agents || []) {
+        const agentPath = join7(agentsDir, agentName);
+        const agentPathMd = join7(agentsDir, agentName + ".md");
+        if (existsSync7(agentPath) || isSymlink(agentPath)) {
+          files.push(agentPath);
+        } else if (existsSync7(agentPathMd) || isSymlink(agentPathMd)) {
+          files.push(agentPathMd);
+        }
+      }
+    }
+  }
+  const workflowsLink = join7(configRoot, "workflows");
+  if (isSymlink(workflowsLink)) {
+    files.push(workflowsLink);
+  }
+  const manifestPath = join7(configRoot, "cannbot-manifest.json");
+  if (existsSync7(manifestPath)) {
+    files.push(manifestPath);
+  }
+  const pluginManifestPath = join7(configRoot, `${pluginId}-manifest.json`);
+  if (existsSync7(pluginManifestPath)) {
+    files.push(pluginManifestPath);
+  }
+  const configFileName = tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
+  const configFilePath = level === "project" ? join7(installPath, configFileName) : join7(configRoot, configFileName);
+  if (existsSync7(configFilePath)) {
+    files.push(configFilePath);
+  }
+  const repoLinks = ["asc-devkit", "pypto", "tilelang-ascend", "cann-recipes-infer", "cann-samples"];
+  for (const repoName of repoLinks) {
+    const repoLinkPath = join7(installPath, repoName);
+    if (isSymlink(repoLinkPath)) {
+      files.push(repoLinkPath);
+    }
+    const repoLinkInConfig = join7(configRoot, repoName);
+    if (isSymlink(repoLinkInConfig)) {
+      files.push(repoLinkInConfig);
+    }
+  }
+  directories.push(configRoot);
+  return {
+    pluginId,
+    displayName,
+    tool,
+    level,
+    installPath,
+    configRoot,
+    installTime: (/* @__PURE__ */ new Date()).toISOString(),
+    files,
+    directories
+  };
+}
+function isSymlink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function getSkillRecordPath() {
+  return join7(getInstallsDir(), "skills.json");
+}
+function readSkillRecord() {
+  const recordPath = getSkillRecordPath();
+  if (!existsSync7(recordPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync4(recordPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function writeSkillRecord(record) {
+  const installsDir = getInstallsDir();
+  if (!existsSync7(installsDir)) {
+    mkdirSync4(installsDir, { recursive: true });
+  }
+  const recordPath = getSkillRecordPath();
+  writeFileSync4(recordPath, JSON.stringify(record, null, 2), "utf-8");
+}
+function addSkillsToRecord(skillIds, tool, level, installPath) {
+  const record = readSkillRecord();
+  if (!record[tool]) record[tool] = {};
+  if (!record[tool][level]) record[tool][level] = {};
+  if (!record[tool][level][installPath]) {
+    record[tool][level][installPath] = { skills: [], installTime: "" };
+  }
+  const entry = record[tool][level][installPath];
+  for (const id of skillIds) {
+    if (!entry.skills.includes(id)) {
+      entry.skills.push(id);
+    }
+  }
+  entry.installTime = (/* @__PURE__ */ new Date()).toISOString();
+  writeSkillRecord(record);
+}
+function removeSkillsFromRecord(skillIds, tool, level, installPath) {
+  const record = readSkillRecord();
+  if (!record[tool]?.[level]?.[installPath]) return;
+  const entry = record[tool][level][installPath];
+  entry.skills = entry.skills.filter((id) => !skillIds.includes(id));
+  if (entry.skills.length === 0) {
+    delete record[tool][level][installPath];
+    if (Object.keys(record[tool][level]).length === 0) {
+      delete record[tool][level];
+      if (Object.keys(record[tool]).length === 0) {
+        delete record[tool];
+      }
+    }
+  }
+  writeSkillRecord(record);
+}
+function getInstalledSkills(tool, level, installPath) {
+  const record = readSkillRecord();
+  return record[tool]?.[level]?.[installPath]?.skills || [];
+}
+
+// src/core/installer.ts
+async function installPlugin(opts) {
+  const plugin = getPluginById(opts.pluginId);
+  if (!plugin) {
+    return {
+      success: false,
+      pluginId: opts.pluginId,
+      skillsCount: 0,
+      agentsCount: 0,
+      errors: [`Plugin not found: ${opts.pluginId}`],
+      warnings: []
+    };
+  }
+  const scriptPath = join8(opts.repoPath, plugin.dir, plugin.script);
+  if (!existsSync8(scriptPath)) {
+    return {
+      success: false,
+      pluginId: opts.pluginId,
+      skillsCount: 0,
+      agentsCount: 0,
+      errors: [`Script not found: ${scriptPath}`],
+      warnings: []
+    };
+  }
+  const args = [opts.level, opts.tool];
+  if (opts.installPath) {
+    args.push(opts.installPath);
+  }
+  const cwd = opts.installPath || process.cwd();
+  try {
+    await execa3("bash", [scriptPath, ...args], {
+      cwd,
+      timeout: 3e5,
+      stdio: "pipe"
+    });
+    const configRoot = getConfigRoot(opts.tool, opts.level, opts.installPath);
+    const manifest = readManifest(configRoot);
+    let skillsCount = 0;
+    let agentsCount = 0;
+    if (manifest) {
+      skillsCount = manifest.installed_skills?.length || 0;
+      agentsCount = manifest.installed_agents?.length || 0;
+    } else {
+      skillsCount = plugin.skills;
+      agentsCount = plugin.agents;
+    }
+    try {
+      const record = scanInstalledFiles(
+        opts.pluginId,
+        plugin.displayName,
+        opts.tool,
+        opts.level,
+        cwd,
+        configRoot,
+        manifest
+      );
+      writeRecord(record);
+    } catch {
+    }
+    return {
+      success: true,
+      pluginId: opts.pluginId,
+      skillsCount,
+      agentsCount,
+      errors: [],
+      warnings: []
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return {
+      success: false,
+      pluginId: opts.pluginId,
+      skillsCount: 0,
+      agentsCount: 0,
+      errors: [errorMessage],
+      warnings: []
+    };
+  }
+}
+
+// src/core/skill-installer.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync5, symlinkSync, unlinkSync as unlinkSync2, readdirSync as readdirSync3, rmdirSync, realpathSync, lstatSync as lstatSync2 } from "fs";
+import { join as join9 } from "path";
+import { select as select2, checkbox as checkbox2, Separator as Separator2 } from "@inquirer/prompts";
+import chalk3 from "chalk";
+import Table from "cli-table3";
+async function installSkills(skillIds, tool, level, repoPath) {
+  const configRoot = getConfigRoot(tool, level);
+  const skillsDir = join9(configRoot, "skills");
+  const installPath = level === "project" ? process.cwd() : configRoot;
+  if (!existsSync9(skillsDir)) {
+    mkdirSync5(skillsDir, { recursive: true });
+  }
+  const results = [];
+  const installedIds = [];
+  for (const skillId of skillIds) {
+    const skill = findSkill(skillId);
+    if (!skill) {
+      results.push({ skillId, success: false, error: "Skill not found in registry" });
+      continue;
+    }
+    const sourcePath = join9(repoPath, skill.source, skill.id);
+    const targetPath = join9(skillsDir, skillId);
+    if (!existsSync9(sourcePath)) {
+      results.push({ skillId, success: false, error: `Source not found: ${sourcePath}` });
+      continue;
+    }
+    try {
+      if (existsSync9(targetPath) || isSymlink2(targetPath)) {
+        unlinkSync2(targetPath);
+      }
+      symlinkSync(realpathSync(sourcePath), targetPath);
+      results.push({ skillId, success: true });
+      installedIds.push(skillId);
+    } catch (error) {
+      results.push({ skillId, success: false, error: error instanceof Error ? error.message : "Unknown error" });
+    }
+  }
+  if (installedIds.length > 0) {
+    addSkillsToRecord(installedIds, tool, level, installPath);
+  }
+  return results;
+}
+async function uninstallSkills(skillIds, tool, level) {
+  const configRoot = getConfigRoot(tool, level);
+  const skillsDir = join9(configRoot, "skills");
+  const installPath = level === "project" ? process.cwd() : configRoot;
+  const results = [];
+  const removedIds = [];
+  for (const skillId of skillIds) {
+    const targetPath = join9(skillsDir, skillId);
+    try {
+      if (existsSync9(targetPath) || isSymlink2(targetPath)) {
+        unlinkSync2(targetPath);
+        results.push({ skillId, success: true });
+        removedIds.push(skillId);
+        logger.step(`  \u79FB\u9664: ${skillId}`);
+      } else {
+        results.push({ skillId, success: false, error: "Not installed" });
+        logger.warn(`${skillId} \u672A\u5B89\u88C5`);
+      }
+    } catch (error) {
+      results.push({ skillId, success: false, error: error instanceof Error ? error.message : "Unknown error" });
+    }
+  }
+  if (removedIds.length > 0) {
+    removeSkillsFromRecord(removedIds, tool, level, installPath);
+  }
+  if (existsSync9(skillsDir)) {
+    try {
+      const entries = readdirSync3(skillsDir);
+      if (entries.length === 0) {
+        rmdirSync(skillsDir);
+        logger.step(`  \u6E05\u7406\u7A7A\u76EE\u5F55: skills/`);
+      }
+    } catch {
+    }
+  }
+  if (existsSync9(configRoot)) {
+    try {
+      const entries = readdirSync3(configRoot);
+      if (entries.length === 0) {
+        rmdirSync(configRoot);
+        logger.step(`  \u6E05\u7406\u7A7A\u76EE\u5F55: ${configRoot.split("/").pop()}/`);
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+async function interactiveSkillSelect() {
+  const BACK2 = "__back__";
+  const CANCEL2 = "__cancel__";
+  const categories = getAllCategories();
+  let step = 0;
+  let selectedCategoryId = "";
+  while (true) {
+    switch (step) {
+      case 0: {
+        printBoxTitle("\u9009\u62E9 Skill \u7C7B\u522B");
+        const categoryChoices = [
+          ...categories.map((cat) => ({
+            name: `> ${cat.name} (${cat.skills.length} skills)`,
+            value: cat.id
+          })),
+          new Separator2("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+          { name: "<- " + t("wizard_back"), value: BACK2 },
+          { name: "x  " + t("wizard_cancel"), value: CANCEL2 }
+        ];
+        showOperationHints();
+        selectedCategoryId = await select2({
+          message: t("skill_select_category"),
+          choices: categoryChoices,
+          loop: false,
+          theme: selectTheme
+        });
+        if (selectedCategoryId === BACK2) return "back";
+        if (selectedCategoryId === CANCEL2) return "cancel";
+        step = 1;
+        break;
+      }
+      case 1: {
+        const category = categories.find((c) => c.id === selectedCategoryId);
+        if (!category) return [];
+        printBoxTitle(`\u9009\u62E9\u8981\u5B89\u88C5\u7684 Skills \u2014 ${category.name}`);
+        const installedSkills = getInstalledSkills(
+          "opencode",
+          "project",
+          process.cwd()
+        );
+        const installedSet = new Set(installedSkills);
+        const skillChoices = category.skills.map((skill) => {
+          const isInstalled = installedSet.has(skill.id);
+          const suffix = isInstalled ? ` [${t("skill_already_installed")}]` : "";
+          return {
+            name: `${skill.id}${suffix} \u2014 ${skill.description}`,
+            value: skill.id,
+            checked: false
+          };
+        });
+        skillChoices.push(new Separator2("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+        skillChoices.push({ name: "<- " + t("wizard_back"), value: BACK2, checked: false });
+        skillChoices.push({ name: "x  " + t("wizard_cancel"), value: CANCEL2, checked: false });
+        showOperationHints(true);
+        const selectedSkills = await checkbox2({
+          message: t("skill_select_items"),
+          choices: skillChoices,
+          loop: false,
+          instructions: false,
+          theme: checkboxTheme
+        });
+        if (selectedSkills.includes(BACK2)) {
+          step = 0;
+          break;
+        }
+        if (selectedSkills.includes(CANCEL2)) return "cancel";
+        const skillIds = selectedSkills.filter((v) => v !== BACK2 && v !== CANCEL2);
+        if (skillIds.length === 0) {
+          const action = await select2({
+            message: t("wizard_no_selection"),
+            choices: [
+              new Separator2("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+              { name: "<- " + t("wizard_back_to_reselect"), value: "back" },
+              { name: "x  " + t("wizard_cancel"), value: "cancel" }
+            ],
+            loop: false,
+            theme: selectTheme
+          });
+          if (action === "back") {
+            step = 0;
+            break;
+          }
+          return "cancel";
+        }
+        return skillIds;
+      }
+    }
+  }
+}
+function listAllSkills() {
+  const categories = getAllCategories();
+  console.log();
+  console.log(chalk3.bold(`  ${t("skill_list_title")}`));
+  console.log(chalk3.dim("  " + "\u2500".repeat(60)));
+  for (const category of categories) {
+    console.log();
+    console.log(chalk3.bold(`  ${category.name}`) + chalk3.dim(` (${category.skills.length} skills)`));
+    const table = new Table({
+      style: { head: [], border: [] },
+      colWidths: [35, 45],
+      wordWrap: true
+    });
+    for (const skill of category.skills) {
+      table.push([
+        chalk3.cyan(skill.id),
+        skill.description
+      ]);
+    }
+    console.log(table.toString());
+  }
+  console.log();
+  console.log(chalk3.dim(`  \u5171 ${getAllSkills().length} \u4E2A Skills`));
+  console.log();
+}
+function isSymlink2(path) {
+  try {
+    return lstatSync2(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+// src/ui/display.ts
+import chalk4 from "chalk";
+import Table2 from "cli-table3";
+function printPluginList(plugins, installed) {
+  const table = new Table2({
+    head: [
+      chalk4.cyan(t("list_id")),
+      chalk4.cyan(t("list_name")),
+      chalk4.cyan(t("list_status")),
+      chalk4.cyan(t("list_skills")),
+      chalk4.cyan(t("list_agents"))
+    ],
+    style: { head: [], border: [] }
+  });
+  plugins.forEach((plugin, index) => {
+    const isInstalled = installed.has(plugin.id);
+    const status = isInstalled ? chalk4.green(`\u2713 ${t("status_installed")}`) : chalk4.dim(`\u2014`);
+    table.push([
+      String(index + 1),
+      plugin.displayName,
+      status,
+      String(plugin.skills),
+      String(plugin.agents)
+    ]);
+  });
+  console.log();
+  console.log(chalk4.bold(`  ${t("list_title")} (${plugins.length} \u4E2A)`));
+  console.log(table.toString());
+  console.log();
+}
+function printInstallSummary(results) {
+  const successCount = results.filter((r) => r.success).length;
+  const totalCount = results.length;
+  console.log();
+  console.log(
+    chalk4.bold(
+      `  ${t("install_done")}! ${successCount}/${totalCount} ${t("install_success")}`
+    )
+  );
+  console.log();
+  for (const result of results) {
+    if (result.success) {
+      console.log(
+        chalk4.green("  \u2713") + ` ${result.displayName} (${result.skillsCount} skills, ${result.agentsCount} agents)`
+      );
+    } else {
+      console.log(chalk4.red("  \u2717") + ` ${result.displayName}`);
+    }
+  }
+  console.log();
+}
+function printEnhancedSummary(results, tool, configRoot) {
+  const successResults = results.filter((r) => r.success);
+  const totalSkills = successResults.reduce((sum, r) => sum + r.skillsCount, 0);
+  const totalAgents = successResults.reduce((sum, r) => sum + r.agentsCount, 0);
+  if (successResults.length === 0) {
+    return;
+  }
+  const toolName = getToolDisplayName(tool);
+  const lines = [
+    chalk4.bold(`  ${t("install_done")}!`),
+    "",
+    `  ${chalk4.dim("\u5B89\u88C5\u5230:")} ${configRoot}`,
+    `  ${chalk4.dim("Skills:")} ${totalSkills} \u4E2A  ${chalk4.dim("|")}  ${chalk4.dim("Agents:")} ${totalAgents} \u4E2A`,
+    "",
+    chalk4.bold(`  ${t("install_enhanced_next_steps")}:`),
+    `    ${chalk4.cyan("1.")} ${t("install_enhanced_launch")}: ${chalk4.green(toolName.toLowerCase())}`,
+    `    ${chalk4.cyan("2.")} ${t("install_enhanced_try")}: ${chalk4.green("\u5E2E\u6211\u5F00\u53D1\u4E00\u4E2A Abs \u7B97\u5B50")}`,
+    `    ${chalk4.cyan("3.")} ${t("install_enhanced_more")}: ${chalk4.green("install-helper list")}`,
+    `    ${chalk4.cyan("4.")} ${t("install_enhanced_check")}: ${chalk4.green("install-helper doctor")}`,
+    ""
+  ];
+  if (successResults.length === 1) {
+    lines.push(
+      `  ${chalk4.dim(t("install_enhanced_docs"))}: ${chalk4.dim(`plugins-official/${successResults[0].pluginId}/quickstart.md`)}`
+    );
+  }
+  console.log();
+  for (const line of lines) {
+    console.log(line);
+  }
+  console.log();
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync10 } from "fs";
+import { join as join10 } from "path";
+async function initCommand() {
+  const cwd = process.cwd();
+  if (existsSync10(join10(cwd, "package.json")) && cwd.includes("install-helper")) {
+    logger.warn("\u5F53\u524D\u76EE\u5F55\u770B\u8D77\u6765\u662F install-helper \u5305\u76EE\u5F55");
+    logger.info("\u8BF7\u5728\u4F60\u7684\u9879\u76EE\u76EE\u5F55\u4E2D\u8FD0\u884C\u6B64\u547D\u4EE4\uFF0C\u800C\u4E0D\u662F\u5728 install-helper \u5B89\u88C5\u76EE\u5F55\u4E2D");
+    logger.info("\u793A\u4F8B\uFF1Acd ~/my-project && install-helper");
+    return;
+  }
+  printBanner(t("wizard_title"));
+  const spinner = createSpinner("\u6B63\u5728\u52A0\u8F7D Skills \u5217\u8868...");
+  spinner.start();
+  try {
+    const repoManager = createRepositoryManager();
+    await repoManager.ensureRepoAndScan();
+    spinner.succeed("Skills \u5217\u8868\u52A0\u8F7D\u5B8C\u6210");
+  } catch {
+    spinner.warn("Skills \u5217\u8868\u52A0\u8F7D\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u6570\u636E");
+  }
+  let step = 0;
+  let mode = "plugin";
+  while (true) {
+    switch (step) {
+      case 0: {
+        const result = await selectMode();
+        if (result === null) return;
+        mode = result;
+        step = 1;
+        break;
+      }
+      case 1: {
+        if (mode === "plugin") {
+          const result = await pluginInstallFlow();
+          if (result === "back") {
+            step = 0;
+            break;
+          }
+          return;
+        } else {
+          const result = await skillInstallFlow();
+          if (result === "back") {
+            step = 0;
+            break;
+          }
+          return;
+        }
+      }
+    }
+  }
+}
+async function selectMode() {
+  printBoxTitle("\u9009\u62E9\u5B89\u88C5\u7C7B\u578B");
+  const CANCEL2 = "__cancel__";
+  const choices = [
+    {
+      name: `> ${t("wizard_mode_plugin")} \u2014 ${t("wizard_mode_plugin_desc")}`,
+      value: "plugin"
+    },
+    {
+      name: `> ${t("wizard_mode_skill")} \u2014 ${t("wizard_mode_skill_desc")}`,
+      value: "skill"
+    },
+    new Separator3("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+    { name: "x  " + t("wizard_cancel"), value: CANCEL2 }
+  ];
+  showOperationHints();
+  const result = await select3({
+    message: t("wizard_select_mode"),
+    choices,
+    loop: false,
+    theme: selectTheme
+  });
+  if (result === CANCEL2) return null;
+  return result;
+}
+async function pluginInstallFlow() {
+  const answers = await runWizard();
+  if (!answers.confirmed) {
+    if (answers.back) return "back";
+    logger.info("\u5DF2\u53D6\u6D88\u5B89\u88C5");
+    return "done";
+  }
+  const repoManager = createRepositoryManager();
+  const spinner = createSpinner(t("install_cloning"));
+  spinner.start();
+  const repoPath = await repoManager.ensureRepo();
+  spinner.succeed(t("install_repo_ready"));
+  const allPlugins = getAllPlugins();
+  const selectedPlugins = answers.plugins.map(
+    (id) => allPlugins.find((p) => p.id === id)
+  );
+  const total = answers.plugins.length;
+  const results = [];
+  for (let i = 0; i < answers.plugins.length; i++) {
+    const pluginId = answers.plugins[i];
+    const plugin = selectedPlugins[i];
+    const displayName = plugin?.displayName || pluginId;
+    const progress = `[${i + 1}/${total}]`;
+    const pluginSpinner = createSpinner(`${progress} ${t("install_progress")} ${displayName}...`);
+    pluginSpinner.start();
+    const result = await installPlugin({
+      pluginId,
+      tool: answers.tool,
+      level: answers.level,
+      repoPath
+    });
+    if (result.success) {
+      pluginSpinner.succeed(
+        `${progress} ${displayName} \u2014 ${result.skillsCount} skills, ${result.agentsCount} agents`
+      );
+      addInstalledPlugin(pluginId);
+    } else {
+      pluginSpinner.fail(
+        `${progress} ${displayName} \u2014 ${result.errors.join(", ")}`
+      );
+    }
+    results.push(result);
+  }
+  const summary = results.map((result, index) => ({
+    pluginId: result.pluginId,
+    displayName: selectedPlugins[index]?.displayName || result.pluginId,
+    success: result.success,
+    skillsCount: result.skillsCount,
+    agentsCount: result.agentsCount
+  }));
+  printInstallSummary(summary);
+  const configRoot = getConfigRoot(answers.tool, answers.level);
+  printEnhancedSummary(summary, answers.tool, configRoot);
+  return "done";
+}
+async function skillInstallFlow() {
+  let step = 0;
+  let tool = "opencode";
+  while (true) {
+    switch (step) {
+      case 0: {
+        const result = await selectToolWithDetection();
+        if (result === "back") return "back";
+        if (result === "cancel") {
+          logger.info("\u5DF2\u53D6\u6D88\u5B89\u88C5");
+          return "done";
+        }
+        tool = result;
+        step = 1;
+        break;
+      }
+      case 1: {
+        const selectedSkills = await interactiveSkillSelect();
+        if (selectedSkills === "back") {
+          step = 0;
+          break;
+        }
+        if (selectedSkills === "cancel") {
+          logger.info("\u5DF2\u53D6\u6D88\u5B89\u88C5");
+          return "done";
+        }
+        if (selectedSkills.length === 0) {
+          logger.info("\u672A\u9009\u62E9\u4EFB\u4F55 Skill");
+          return "done";
+        }
+        const repoManager = createRepositoryManager();
+        const spinner = createSpinner(t("install_cloning"));
+        spinner.start();
+        const repoPath = await repoManager.ensureRepo();
+        spinner.succeed(t("install_repo_ready"));
+        logger.info(`${t("skill_install_progress")} ${chalk5.bold(selectedSkills.length)} \u4E2A Skills...`);
+        const results = await installSkills(selectedSkills, tool, "project", repoPath);
+        let successCount = 0;
+        let failCount = 0;
+        for (const result of results) {
+          if (result.success) {
+            logger.success(`${result.skillId}`);
+            successCount++;
+          } else {
+            logger.error(`${result.skillId}: ${result.error}`);
+            failCount++;
+          }
+        }
+        const configRoot = getConfigRoot(tool, "project");
+        logger.blank();
+        logger.success(`${t("skill_install_done")}: ${chalk5.green(successCount + " \u6210\u529F")}, ${failCount > 0 ? chalk5.red(failCount + " \u5931\u8D25") : chalk5.dim(failCount + " \u5931\u8D25")}`);
+        logger.blank();
+        logger.info(`\u5B89\u88C5\u5230: ${chalk5.cyan(configRoot + "/skills/")}`);
+        logger.info(`\u542F\u52A8 ${chalk5.green(tool)} \u5373\u53EF\u4F7F\u7528`);
+        logger.blank();
+        return "done";
+      }
+    }
+  }
+}
+
+// src/commands/list.ts
+async function listCommand() {
+  try {
+    const repoManager = createRepositoryManager();
+    await repoManager.ensureRepoAndScan();
+  } catch {
+  }
+  const plugins = getAllPlugins();
+  const installed = scanInstalled();
+  const installedMap = new Map(installed.map((p) => [p.id, p]));
+  printPluginList(plugins, installedMap);
+}
+
+// src/commands/doctor.ts
+import chalk6 from "chalk";
+import { existsSync as existsSync11, readdirSync as readdirSync4, lstatSync as lstatSync3, unlinkSync as unlinkSync3, mkdirSync as mkdirSync6 } from "fs";
+import { join as join11 } from "path";
+async function doctorCommand(options = {}) {
+  console.log();
+  console.log(chalk6.bold(`  ${t("doctor_title")}`));
+  console.log(chalk6.dim("  " + "\u2500".repeat(46)));
+  let errors = 0;
+  let warnings = 0;
+  let fixes = 0;
+  console.log();
+  console.log(chalk6.bold(`  ${t("doctor_tools")}`));
+  const detectedTools = await detectTools();
+  const allTools = getAllTools();
+  for (const tool of allTools) {
+    const detected = detectedTools.find((d) => d.name === tool);
+    if (detected) {
+      console.log(
+        chalk6.green("  \u2713") + ` ${getToolDisplayName(tool)}${detected.version ? ` v${detected.version}` : ""}`
+      );
+    } else {
+      console.log(chalk6.dim("  \u2014") + ` ${getToolDisplayName(tool)} \u2014 \u672A\u5B89\u88C5`);
+    }
+  }
+  console.log();
+  console.log(chalk6.bold(`  ${t("doctor_plugins")}`));
+  const plugins = getAllPlugins();
+  const installed = scanInstalled();
+  const installedMap = new Map(installed.map((p) => [p.id, p]));
+  for (const plugin of plugins) {
+    const inst = installedMap.get(plugin.id);
+    if (inst) {
+      console.log(
+        chalk6.green("  \u2713") + ` ${plugin.id.padEnd(30)} ${inst.skillsCount} skills, ${inst.agentsCount} agents`
+      );
+    } else {
+      console.log(chalk6.dim("  \u2014") + ` ${plugin.id.padEnd(30)} \u2014 \u672A\u5B89\u88C5`);
+    }
+  }
+  console.log();
+  console.log(chalk6.bold(`  ${t("doctor_links")}`));
+  const primaryTool = detectedTools[0]?.name || "opencode";
+  const configRoot = getConfigRoot(primaryTool, "project");
+  const skillsDir = getSkillsDir(configRoot);
+  const agentsDir = getAgentsDir(configRoot);
+  if (existsSync11(skillsDir)) {
+    const brokenLinks = checkBrokenLinks(skillsDir);
+    if (brokenLinks === 0) {
+      const count = readdirSync4(skillsDir).length;
+      console.log(chalk6.green("  \u2713") + ` ${skillsDir} \u2014 ${count} \u4E2A\u8F6F\u94FE\u63A5\u5747\u6709\u6548`);
+    } else {
+      console.log(chalk6.yellow("  \u26A0") + ` ${skillsDir} \u2014 ${brokenLinks} \u4E2A\u5931\u6548\u94FE\u63A5`);
+      warnings++;
+      if (options.fix) {
+        const fixed = fixBrokenLinks(skillsDir);
+        fixes += fixed;
+        console.log(chalk6.green("  \u2713") + ` ${t("doctor_fix_cleaning")}: \u5DF2\u6E05\u7406 ${fixed} \u4E2A\u5931\u6548\u94FE\u63A5`);
+      }
+    }
+  } else {
+    console.log(chalk6.dim("  \u2014") + ` ${skillsDir} \u2014 \u4E0D\u5B58\u5728`);
+    if (options.fix) {
+      mkdirSync6(skillsDir, { recursive: true });
+      fixes++;
+      console.log(chalk6.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: \u5DF2\u521B\u5EFA ${skillsDir}`);
+    }
+  }
+  if (existsSync11(agentsDir)) {
+    const brokenLinks = checkBrokenLinks(agentsDir);
+    if (brokenLinks === 0) {
+      const count = readdirSync4(agentsDir).length;
+      console.log(chalk6.green("  \u2713") + ` ${agentsDir} \u2014 ${count} \u4E2A\u8F6F\u94FE\u63A5\u5747\u6709\u6548`);
+    } else {
+      console.log(chalk6.yellow("  \u26A0") + ` ${agentsDir} \u2014 ${brokenLinks} \u4E2A\u5931\u6548\u94FE\u63A5`);
+      warnings++;
+      if (options.fix) {
+        const fixed = fixBrokenLinks(agentsDir);
+        fixes += fixed;
+        console.log(chalk6.green("  \u2713") + ` ${t("doctor_fix_cleaning")}: \u5DF2\u6E05\u7406 ${fixed} \u4E2A\u5931\u6548\u94FE\u63A5`);
+      }
+    }
+  } else {
+    console.log(chalk6.dim("  \u2014") + ` ${agentsDir} \u2014 \u4E0D\u5B58\u5728`);
+    if (options.fix) {
+      mkdirSync6(agentsDir, { recursive: true });
+      fixes++;
+      console.log(chalk6.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: \u5DF2\u521B\u5EFA ${agentsDir}`);
+    }
+  }
+  console.log();
+  console.log(chalk6.bold(`  ${t("doctor_config")}`));
+  const configFile = getConfigFileName(primaryTool);
+  const configPath = join11(process.cwd(), configFile);
+  if (existsSync11(configPath)) {
+    console.log(chalk6.green("  \u2713") + ` ${configFile} \u5B58\u5728`);
+  } else {
+    console.log(chalk6.dim("  \u2014") + ` ${configFile} \u4E0D\u5B58\u5728`);
+  }
+  console.log();
+  console.log(chalk6.dim("  " + "\u2500".repeat(46)));
+  if (options.fix && fixes > 0) {
+    console.log(
+      `  ${t("doctor_result")}: ${warnings} \u4E2A\u8B66\u544A, ${errors} \u4E2A\u9519\u8BEF, ${fixes} \u9879\u5DF2\u4FEE\u590D`
+    );
+  } else {
+    console.log(
+      `  ${t("doctor_result")}: ${warnings} \u4E2A\u8B66\u544A, ${errors} \u4E2A\u9519\u8BEF`
+    );
+  }
+  console.log();
+}
+function checkBrokenLinks(dir) {
+  let broken = 0;
+  try {
+    const entries = readdirSync4(dir);
+    for (const entry of entries) {
+      const fullPath = join11(dir, entry);
+      try {
+        const stats = lstatSync3(fullPath);
+        if (stats.isSymbolicLink()) {
+          if (!existsSync11(fullPath)) {
+            broken++;
+          }
+        }
+      } catch {
+        broken++;
+      }
+    }
+  } catch {
+  }
+  return broken;
+}
+function fixBrokenLinks(dir) {
+  let fixed = 0;
+  try {
+    const entries = readdirSync4(dir);
+    for (const entry of entries) {
+      const fullPath = join11(dir, entry);
+      try {
+        const stats = lstatSync3(fullPath);
+        if (stats.isSymbolicLink()) {
+          if (!existsSync11(fullPath)) {
+            unlinkSync3(fullPath);
+            fixed++;
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return fixed;
+}
+
+// src/commands/status.ts
+import chalk7 from "chalk";
+async function statusCommand() {
+  const plugins = getAllPlugins();
+  const installed = scanInstalled();
+  const installedMap = new Map(installed.map((p) => [p.id, p]));
+  console.log();
+  console.log(chalk7.bold("  \u5DF2\u5B89\u88C5\u63D2\u4EF6"));
+  console.log();
+  if (installed.length === 0) {
+    console.log(chalk7.dim("  \u6682\u65E0\u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6"));
+    console.log(chalk7.dim("  \u8FD0\u884C install-helper init \u5F00\u59CB\u5B89\u88C5"));
+    console.log();
+    return;
+  }
+  for (const inst of installed) {
+    console.log(
+      chalk7.green("  \u2713") + ` ${inst.displayName}` + chalk7.dim(` (${inst.tool}, ${inst.level})`)
+    );
+    console.log(
+      chalk7.dim(`    ${inst.skillsCount} skills, ${inst.agentsCount} agents`)
+    );
+    console.log(chalk7.dim(`    ${inst.configRoot}`));
+    console.log(chalk7.dim(`    \u5B89\u88C5\u65F6\u95F4: ${inst.installTime}`));
+    console.log();
+  }
+}
+
+// src/commands/install.ts
+import { confirm } from "@inquirer/prompts";
+import chalk8 from "chalk";
+async function installCommand(names, options) {
+  if (options.list) {
+    try {
+      const repoManager = createRepositoryManager();
+      await repoManager.ensureRepoAndScan();
+    } catch {
+    }
+    listAllSkills();
+    return;
+  }
+  if (names.length === 0) {
+    let tool2;
+    if (options.tool) {
+      tool2 = options.tool;
+    } else {
+      const detected = await selectToolWithDetection();
+      if (detected === "back") return;
+      tool2 = detected;
+    }
+    let step = 1;
+    while (true) {
+      switch (step) {
+        case 1: {
+          const selectedSkills = await interactiveSkillSelect();
+          if (selectedSkills === "back") {
+            const redetected = await selectToolWithDetection();
+            if (redetected === "back") return;
+            tool2 = redetected;
+            break;
+          }
+          if (selectedSkills.length === 0) {
+            logger.info("\u672A\u9009\u62E9\u4EFB\u4F55 Skill");
+            return;
+          }
+          names = selectedSkills;
+          const repoManager = createRepositoryManager();
+          const spinner = createSpinner(t("install_cloning"));
+          spinner.start();
+          const repoPath = await repoManager.ensureRepo();
+          spinner.succeed(t("install_repo_ready"));
+          logger.info(`${t("skill_install_progress")} ${chalk8.bold(names.length)} \u4E2A Skills...`);
+          const results = await installSkills(names, tool2, "project", repoPath);
+          let successCount = 0;
+          let failCount = 0;
+          for (const result of results) {
+            if (result.success) {
+              logger.success(`${result.skillId}`);
+              successCount++;
+            } else {
+              logger.error(`${result.skillId}: ${result.error}`);
+              failCount++;
+            }
+          }
+          const configRoot = getConfigRoot(tool2, "project");
+          logger.blank();
+          logger.success(`${t("skill_install_done")}: ${chalk8.green(successCount + " \u6210\u529F")}, ${failCount > 0 ? chalk8.red(failCount + " \u5931\u8D25") : chalk8.dim(failCount + " \u5931\u8D25")}`);
+          logger.blank();
+          logger.info(`\u5B89\u88C5\u5230: ${chalk8.cyan(configRoot + "/skills/")}`);
+          logger.info(`\u542F\u52A8 ${chalk8.green(tool2)} \u5373\u53EF\u4F7F\u7528`);
+          logger.blank();
+          return;
+        }
+      }
+    }
+  }
+  const scanSpinner = createSpinner("\u6B63\u5728\u52A0\u8F7D Skills \u5217\u8868...");
+  scanSpinner.start();
+  try {
+    const scanRepoManager = createRepositoryManager();
+    await scanRepoManager.ensureRepoAndScan();
+    scanSpinner.succeed("Skills \u5217\u8868\u52A0\u8F7D\u5B8C\u6210");
+  } catch {
+    scanSpinner.warn("Skills \u5217\u8868\u52A0\u8F7D\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u6570\u636E");
+  }
+  const plugins = [];
+  const skills = [];
+  for (const name of names) {
+    const plugin = findPlugin(name);
+    if (plugin) {
+      plugins.push(plugin.id);
+      continue;
+    }
+    const skill = findSkill(name);
+    if (skill) {
+      skills.push(skill.id);
+      continue;
+    }
+    logger.error(`${t("error_plugin_not_found")}: ${name}`);
+    const allPlugins = getAllPlugins();
+    logger.info("\u53EF\u7528\u63D2\u4EF6:");
+    for (const p of allPlugins) {
+      logger.step(`  ${p.id} (${p.aliases.join(", ")})`);
+    }
+    logger.info(`\u53EF\u7528 Skills: ${chalk8.cyan("install-helper install --list")}`);
+    return;
+  }
+  let tool;
+  if (options.tool) {
+    tool = options.tool;
+  } else {
+    const detected = await selectToolWithDetection();
+    if (detected === "back") return;
+    tool = detected;
+  }
+  const level = options.level || "project";
+  if (plugins.length > 0) {
+    const configRoot = getConfigRoot(tool, level);
+    const manifests = readAllManifests(configRoot);
+    const installedSet = new Set(manifests.map((m) => m.team));
+    const pluginsToInstall = [];
+    const skippedPlugins = [];
+    for (const pluginId of plugins) {
+      if (installedSet.has(pluginId) && !options.yes) {
+        const plugin = findPlugin(pluginId);
+        const displayName = plugin?.displayName || pluginId;
+        logger.warn(`${displayName} [${t("install_already_installed")}]`);
+        const shouldReinstall = await confirm({
+          message: `${t("install_reinstall_confirm")}?`,
+          default: false
+        });
+        if (shouldReinstall) {
+          pluginsToInstall.push(pluginId);
+        } else {
+          skippedPlugins.push(pluginId);
+          logger.info(`${displayName} ${t("install_skip")}`);
+        }
+      } else {
+        pluginsToInstall.push(pluginId);
+      }
+    }
+    if (pluginsToInstall.length > 0) {
+      const repoManager = createRepositoryManager();
+      const spinner = createSpinner(t("install_cloning"));
+      spinner.start();
+      const repoPath = await repoManager.ensureRepo();
+      spinner.succeed(t("install_repo_ready"));
+      const allPlugins = getAllPlugins();
+      const results = await installPlugins(
+        pluginsToInstall,
+        tool,
+        level,
+        repoPath
+      );
+      const summary = results.map((result) => {
+        const plugin = allPlugins.find((p) => p.id === result.pluginId);
+        return {
+          pluginId: result.pluginId,
+          displayName: plugin?.displayName || result.pluginId,
+          success: result.success,
+          skillsCount: result.skillsCount,
+          agentsCount: result.agentsCount
+        };
+      });
+      printInstallSummary(summary);
+      printEnhancedSummary(summary, tool, configRoot);
+    }
+  }
+  if (skills.length > 0) {
+    const repoManager = createRepositoryManager();
+    const spinner = createSpinner(t("install_cloning"));
+    spinner.start();
+    const repoPath = await repoManager.ensureRepo();
+    spinner.succeed(t("install_repo_ready"));
+    logger.info(`${t("skill_install_progress")} ${chalk8.bold(skills.length)} \u4E2A Skills...`);
+    const results = await installSkills(skills, tool, level, repoPath);
+    let successCount = 0;
+    let failCount = 0;
+    for (const result of results) {
+      if (result.success) {
+        logger.success(`${result.skillId}`);
+        successCount++;
+      } else {
+        logger.error(`${result.skillId}: ${result.error}`);
+        failCount++;
+      }
+    }
+    logger.blank();
+    logger.success(`${t("skill_install_done")}: ${chalk8.green(successCount + " \u6210\u529F")}, ${failCount > 0 ? chalk8.red(failCount + " \u5931\u8D25") : chalk8.dim(failCount + " \u5931\u8D25")}`);
+    logger.blank();
+    logger.info(`\u5B89\u88C5\u5230: ${chalk8.cyan(getConfigRoot(tool, level) + "/skills/")}`);
+    logger.info(`\u542F\u52A8 ${chalk8.green(tool)} \u5373\u53EF\u4F7F\u7528`);
+    logger.blank();
+  }
+}
+async function installPlugins(pluginIds, tool, level, repoPath) {
+  const results = [];
+  const total = pluginIds.length;
+  for (let i = 0; i < pluginIds.length; i++) {
+    const pluginId = pluginIds[i];
+    const progress = `[${i + 1}/${total}]`;
+    const spinner = createSpinner(`${progress} ${t("install_progress")} ${pluginId}...`);
+    spinner.start();
+    const result = await installPlugin({
+      pluginId,
+      tool,
+      level,
+      repoPath
+    });
+    if (result.success) {
+      spinner.succeed(
+        `${progress} ${pluginId} \u2014 ${result.skillsCount} skills, ${result.agentsCount} agents`
+      );
+      addInstalledPlugin(pluginId);
+    } else {
+      spinner.fail(`${progress} ${pluginId} \u2014 ${result.errors.join(", ")}`);
+    }
+    results.push(result);
+  }
+  return results;
+}
+
+// src/commands/uninstall.ts
+import { existsSync as existsSync12, unlinkSync as unlinkSync4, rmdirSync as rmdirSync2, readdirSync as readdirSync5, lstatSync as lstatSync4 } from "fs";
+import chalk9 from "chalk";
+async function uninstallCommand(names, options) {
+  const tool = options.tool || "opencode";
+  const level = options.level || "project";
+  const plugins = [];
+  const skills = [];
+  for (const name of names) {
+    const plugin = findPlugin(name);
+    if (plugin) {
+      plugins.push(plugin.id);
+      continue;
+    }
+    const skill = findSkill(name);
+    if (skill) {
+      skills.push(skill.id);
+      continue;
+    }
+    logger.error(`\u672A\u627E\u5230: ${name}`);
+  }
+  for (const pluginId of plugins) {
+    const plugin = findPlugin(pluginId);
+    if (!plugin) continue;
+    const record = readRecord(plugin.id);
+    if (!record) {
+      logger.warn(`${plugin.displayName} \u672A\u627E\u5230\u5B89\u88C5\u8BB0\u5F55\uFF0C\u53EF\u80FD\u672A\u5B89\u88C5\u6216\u5B89\u88C5\u8BB0\u5F55\u5DF2\u635F\u574F`);
+      logger.info(`\u5982\u9700\u5F3A\u5236\u6E05\u7406\uFF0C\u8BF7\u624B\u52A8\u5220\u9664 .opencode/ \u6216 .claude/ \u76EE\u5F55\u4E2D\u7684\u76F8\u5173\u6587\u4EF6`);
+      continue;
+    }
+    logger.info(`\u6B63\u5728\u5378\u8F7D ${plugin.displayName}...`);
+    let removedFiles = 0;
+    let removedDirs = 0;
+    for (const filePath of record.files) {
+      try {
+        if (existsSync12(filePath) || isSymlink3(filePath)) {
+          unlinkSync4(filePath);
+          const name = filePath.split("/").pop() || filePath;
+          logger.step(`  \u79FB\u9664: ${name}`);
+          removedFiles++;
+        }
+      } catch {
+      }
+    }
+    const sortedDirs = [...record.directories].sort((a, b) => b.length - a.length);
+    for (const dirPath of sortedDirs) {
+      try {
+        if (existsSync12(dirPath)) {
+          const entries = readdirSync5(dirPath);
+          if (entries.length === 0) {
+            rmdirSync2(dirPath);
+            const name = dirPath.split("/").pop() || dirPath;
+            logger.step(`  \u6E05\u7406\u7A7A\u76EE\u5F55: ${name}/`);
+            removedDirs++;
+          }
+        }
+      } catch {
+      }
+    }
+    deleteRecord(plugin.id);
+    removeInstalledPlugin(plugin.id);
+    const totalRemoved = removedFiles + removedDirs;
+    if (totalRemoved > 0) {
+      logger.success(`\u5DF2\u5378\u8F7D ${plugin.displayName}\uFF08\u79FB\u9664 ${removedFiles} \u4E2A\u6587\u4EF6\uFF0C${removedDirs} \u4E2A\u76EE\u5F55\uFF09`);
+    } else {
+      logger.warn(`${plugin.displayName} \u7684\u6587\u4EF6\u5DF2\u4E0D\u5B58\u5728\uFF0C\u5DF2\u6E05\u7406\u5B89\u88C5\u8BB0\u5F55`);
+    }
+  }
+  if (skills.length > 0) {
+    logger.info(`\u6B63\u5728\u5378\u8F7D ${skills.length} \u4E2A Skills...`);
+    const results = await uninstallSkills(skills, tool, level);
+    let successCount = 0;
+    let failCount = 0;
+    for (const result of results) {
+      if (result.success) {
+        successCount++;
+      } else {
+        failCount++;
+      }
+    }
+    logger.blank();
+    logger.success(`${t("skill_uninstall_done")}: ${chalk9.green(successCount + " \u6210\u529F")}, ${failCount > 0 ? chalk9.red(failCount + " \u5931\u8D25") : chalk9.dim(failCount + " \u5931\u8D25")}`);
+    logger.blank();
+  }
+}
+function isSymlink3(path) {
+  try {
+    return lstatSync4(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/update.ts
+import chalk10 from "chalk";
+async function updateCommand(pluginNames, options) {
+  let tool;
+  if (options.tool) {
+    tool = options.tool;
+  } else {
+    const detected = await selectToolWithDetection();
+    if (detected === "back") return;
+    tool = detected;
+  }
+  const level = options.level || "project";
+  let pluginsToUpdate = [];
+  if (pluginNames.length === 0) {
+    const configRoot = getConfigRoot(tool, level);
+    const manifests = readAllManifests(configRoot);
+    pluginsToUpdate = manifests.map((m) => m.team);
+    if (pluginsToUpdate.length === 0) {
+      logger.info(t("update_no_plugins"));
+      logger.info(`\u4F7F\u7528 ${chalk10.cyan("install-helper install <plugin>")} \u5B89\u88C5\u63D2\u4EF6`);
+      return;
+    }
+  } else {
+    for (const name of pluginNames) {
+      const plugin = findPlugin(name);
+      if (!plugin) {
+        logger.error(`${t("error_plugin_not_found")}: ${name}`);
+        return;
+      }
+      pluginsToUpdate.push(plugin.id);
+    }
+  }
+  const repoManager = createRepositoryManager();
+  const updateSpinner = createSpinner(t("update_updating") + " cannbot-skills...");
+  updateSpinner.start();
+  await repoManager.updateRepo();
+  const repoPath = repoManager.getRepoPath();
+  updateSpinner.succeed(t("install_repo_ready"));
+  const allPlugins = getAllPlugins();
+  const results = [];
+  const total = pluginsToUpdate.length;
+  for (let i = 0; i < pluginsToUpdate.length; i++) {
+    const pluginId = pluginsToUpdate[i];
+    const plugin = allPlugins.find((p) => p.id === pluginId);
+    const displayName = plugin?.displayName || pluginId;
+    const progress = `[${i + 1}/${total}]`;
+    const pluginSpinner = createSpinner(`${progress} ${t("update_updating")} ${displayName}...`);
+    pluginSpinner.start();
+    const result = await installPlugin({
+      pluginId,
+      tool,
+      level,
+      repoPath
+    });
+    if (result.success) {
+      pluginSpinner.succeed(
+        `${progress} ${displayName} \u2014 ${result.skillsCount} skills, ${result.agentsCount} agents`
+      );
+    } else {
+      pluginSpinner.fail(
+        `${progress} ${displayName} \u2014 ${result.errors.join(", ")}`
+      );
+    }
+    results.push(result);
+  }
+  const summary = results.map((result) => {
+    const plugin = allPlugins.find((p) => p.id === result.pluginId);
+    return {
+      pluginId: result.pluginId,
+      displayName: plugin?.displayName || result.pluginId,
+      success: result.success,
+      skillsCount: result.skillsCount,
+      agentsCount: result.agentsCount
+    };
+  });
+  printInstallSummary(summary);
+  logger.success(t("update_done"));
+}
+
+// src/commands/info.ts
+import chalk11 from "chalk";
+import { existsSync as existsSync13 } from "fs";
+import { join as join12 } from "path";
+async function infoCommand(pluginName) {
+  const plugin = findPlugin(pluginName);
+  if (!plugin) {
+    console.log(chalk11.red(`  ${t("info_not_found")}: ${pluginName}`));
+    return;
+  }
+  const installed = scanInstalled();
+  const isInstalled = installed.some((p) => p.id === plugin.id);
+  const statusText = isInstalled ? chalk11.green(`\u2713 ${t("status_installed")}`) : chalk11.dim(`\u2014 ${t("status_not_installed")}`);
+  console.log();
+  console.log(chalk11.bold(`  ${plugin.displayName}`));
+  console.log(chalk11.dim("  " + "\u2500".repeat(40)));
+  console.log();
+  console.log(`  ${chalk11.dim(t("info_description") + ":")} ${plugin.description}`);
+  console.log(`  ${chalk11.dim("ID:")} ${plugin.id}`);
+  console.log(`  ${chalk11.dim(t("info_status") + ":")} ${statusText}`);
+  console.log(`  ${chalk11.dim(t("info_skills") + ":")} ${plugin.skills}`);
+  console.log(`  ${chalk11.dim(t("info_agents") + ":")} ${plugin.agents}`);
+  console.log(`  ${chalk11.dim("\u522B\u540D:")} ${plugin.aliases.join(", ")}`);
+  console.log();
+  try {
+    const repoManager = createRepositoryManager();
+    const repoPath = await repoManager.ensureRepo();
+    const quickstartPath = join12(repoPath, plugin.dir, "quickstart.md");
+    if (existsSync13(quickstartPath)) {
+      console.log(`  ${chalk11.dim(t("info_quickstart") + ":")} ${quickstartPath}`);
+    }
+    const agentsDir = join12(repoPath, plugin.dir, "agents");
+    if (existsSync13(agentsDir)) {
+      const { readdirSync: readdirSync6 } = await import("fs");
+      const agentFiles = readdirSync6(agentsDir).filter((f) => f.endsWith(".md"));
+      if (agentFiles.length > 0) {
+        console.log();
+        console.log(`  ${chalk11.bold("Agents:")}`);
+        for (const agent of agentFiles) {
+          console.log(`    \u2022 ${agent.replace(".md", "")}`);
+        }
+      }
+    }
+  } catch {
+  }
+  console.log();
+}
+
+// src/commands/lang.ts
+import chalk12 from "chalk";
+async function langCommand(action, value) {
+  const config = readConfig();
+  if (!action || action === "show") {
+    console.log();
+    console.log(chalk12.bold(`  ${t("lang_title")}`));
+    console.log(chalk12.dim("  " + "\u2500".repeat(40)));
+    console.log();
+    console.log(`  ${chalk12.dim(t("lang_current") + ":")} ${config.language}`);
+    console.log();
+    console.log(chalk12.dim("  \u652F\u6301\u7684\u8BED\u8A00: zh_CN, en_US"));
+    console.log(chalk12.dim("  \u7528\u6CD5: install-helper lang set <language>"));
+    console.log();
+    return;
+  }
+  if (action === "set") {
+    if (!value) {
+      console.log(chalk12.red("  \u8BF7\u6307\u5B9A\u8BED\u8A00: install-helper lang set zh_CN"));
+      return;
+    }
+    if (value !== "zh_CN" && value !== "en_US") {
+      console.log(chalk12.red(`  ${t("lang_invalid")}`));
+      return;
+    }
+    updateConfig({ language: value });
+    setLanguage(value);
+    console.log();
+    console.log(chalk12.green(`  \u2713 ${t("lang_set")} ${value}`));
+    console.log();
+    return;
+  }
+  console.log(chalk12.red(`  \u672A\u77E5\u64CD\u4F5C: ${action}`));
+  console.log(chalk12.dim("  \u652F\u6301\u7684\u64CD\u4F5C: show, set"));
+}
+
+// src/cli.ts
+function createCLI() {
+  const config = readConfig();
+  if (config.language) {
+    setLanguage(config.language);
+  }
+  const program2 = new Command();
+  program2.name("install-helper").description("CANNBot Helper - Interactive installer for CANN operator development skills").version("0.0.1-beta.0");
+  program2.command("init", { isDefault: false }).description("Run interactive installation wizard").action(async () => {
+    await initCommand();
+  });
+  program2.command("list").description("List available plugins").action(async () => {
+    await listCommand();
+  });
+  program2.command("doctor").description("Run health check").option("--fix", "Auto-fix detected issues").action(async (options) => {
+    await doctorCommand(options);
+  });
+  program2.command("status").description("Show installed plugins").action(async () => {
+    await statusCommand();
+  });
+  program2.command("install [names...]").description("Install plugins or skills (auto-detects type)").option("-t, --tool <tool>", "AI tool (opencode, claude, trae, cursor, copilot)").option("-l, --level <level>", "Install level (project, global)", "project").option("-y, --yes", "Skip confirmation prompts").option("--list", "List all available skills by category").action(async (names, options) => {
+    await installCommand(names, options);
+  });
+  program2.command("uninstall <names...>").description("Uninstall plugins or skills (auto-detects type)").option("-t, --tool <tool>", "AI tool (opencode, claude, trae, cursor, copilot)").option("-l, --level <level>", "Install level (project, global)", "project").action(async (names, options) => {
+    await uninstallCommand(names, options);
+  });
+  program2.command("update [plugins...]").description("Update installed plugins (git pull + reinstall)").option("-t, --tool <tool>", "AI tool (opencode, claude, trae, cursor, copilot)").option("-l, --level <level>", "Install level (project, global)", "project").action(async (plugins, options) => {
+    await updateCommand(plugins, options);
+  });
+  program2.command("info <plugin>").description("Show plugin details").action(async (plugin) => {
+    await infoCommand(plugin);
+  });
+  program2.command("lang [action] [value]").description("Manage language settings (show/set)").action(async (action, value) => {
+    await langCommand(action, value);
+  });
+  program2.action(async () => {
+    await initCommand();
+  });
+  return program2;
+}
+
+// src/index.ts
+process.on("uncaughtException", (error) => {
+  if (error.name === "ExitPromptError") {
+    console.log("\n\u5DF2\u53D6\u6D88\u5B89\u88C5");
+    process.exit(0);
+  }
+  throw error;
+});
+var program = createCLI();
+program.parse();
+//# sourceMappingURL=index.js.map