@cannbot-ai/install-helper 1.0.2 → 1.0.4

package/dist/index.js

@@ -12,108 +12,46 @@ 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"
+import { readdirSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function loadPluginsFromYaml() {
+  const pluginsDir = join(__dirname, "plugins.d");
+  const defaultsPath = join(pluginsDir, "_defaults.yml");
+  let defaults = {};
+  try {
+    defaults = parseYaml(readFileSync(defaultsPath, "utf-8")) || {};
+  } catch {
   }
-];
+  const plugins = [];
+  try {
+    for (const file of readdirSync(pluginsDir)) {
+      if (file.startsWith("_") || !file.endsWith(".yml")) continue;
+      try {
+        const content = parseYaml(readFileSync(join(pluginsDir, file), "utf-8"));
+        if (!content || !content.id) continue;
+        plugins.push({
+          id: content.id,
+          dir: content.dir,
+          displayName: content.displayName || content.id,
+          script: content.script || defaults.script || "init.sh",
+          aliases: content.aliases || [],
+          skills: content.skills ?? defaults.skills ?? 0,
+          agents: content.agents ?? defaults.agents ?? 0,
+          description: content.description || ""
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  plugins.sort((a, b) => a.displayName < b.displayName ? -1 : a.displayName > b.displayName ? 1 : 0);
+  return plugins;
+}
+var PLUGIN_REGISTRY = loadPluginsFromYaml();
 function findPlugin(query) {
   const normalized = query.toLowerCase().trim();
   const exactMatch = PLUGIN_REGISTRY.find(
@@ -139,356 +77,42 @@ function getPluginById(id) {
 import { execa } from "execa";
 import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 
 // src/utils/paths.ts
 import { homedir } from "os";
-import { join } from "path";
+import { join as join3 } from "path";
 import { existsSync } from "fs";
 
 // src/utils/i18n.ts
-var zh_CN = {
-  wizard_title: "CANNBot Install Helper",
-  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",
-  error_invalid_tool: "\u6682\u4E0D\u652F\u6301\u7684 AI \u5DE5\u5177: {tool}\n\u652F\u6301\u7684\u5DE5\u5177: {tools}",
-  error_invalid_level: "\u6682\u4E0D\u652F\u6301\u7684\u5B89\u88C5\u7EA7\u522B: {level}\n\u652F\u6301\u7684\u7EA7\u522B: {levels}",
-  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",
-  status_title: "\u5DF2\u5B89\u88C5\u63D2\u4EF6",
-  status_none: "\u6682\u65E0\u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6",
-  status_hint: "\u8FD0\u884C install-helper init \u5F00\u59CB\u5B89\u88C5",
-  status_install_time: "\u5B89\u88C5\u65F6\u95F4",
-  install_installed_to: "\u5B89\u88C5\u5230",
-  install_skills_count: "Skills",
-  install_agents_count: "Agents",
-  lang_supported: "\u652F\u6301\u7684\u8BED\u8A00: zh_CN, en_US",
-  lang_usage: "\u7528\u6CD5: install-helper lang set <language>",
-  lang_specify: "\u8BF7\u6307\u5B9A\u8BED\u8A00: install-helper lang set zh_CN",
-  lang_unknown_action: "\u672A\u77E5\u64CD\u4F5C",
-  lang_supported_actions: "\u652F\u6301\u7684\u64CD\u4F5C: show, set",
-  info_aliases: "\u522B\u540D",
-  uninstall_not_found: "\u672A\u627E\u5230",
-  uninstall_no_record: "\u672A\u627E\u5230\u5B89\u88C5\u8BB0\u5F55\uFF0C\u53EF\u80FD\u672A\u5B89\u88C5\u6216\u5B89\u88C5\u8BB0\u5F55\u5DF2\u635F\u574F",
-  uninstall_no_record_hint: "\u5982\u9700\u5F3A\u5236\u6E05\u7406\uFF0C\u8BF7\u624B\u52A8\u5220\u9664 .opencode/ \u6216 .claude/ \u76EE\u5F55\u4E2D\u7684\u76F8\u5173\u6587\u4EF6",
-  uninstall_in_progress: "\u6B63\u5728\u5378\u8F7D",
-  uninstall_removed: "\u5DF2\u5378\u8F7D",
-  uninstall_files_gone: "\u7684\u6587\u4EF6\u5DF2\u4E0D\u5B58\u5728\uFF0C\u5DF2\u6E05\u7406\u5B89\u88C5\u8BB0\u5F55",
-  uninstall_skills_in_progress: "\u6B63\u5728\u5378\u8F7D",
-  init_pkg_dir_warn: "\u5F53\u524D\u76EE\u5F55\u770B\u8D77\u6765\u662F install-helper \u5305\u76EE\u5F55",
-  init_pkg_dir_hint: "\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",
-  init_pkg_dir_example: "\u793A\u4F8B\uFF1Acd ~/my-project && install-helper",
-  init_cancelled: "\u5DF2\u53D6\u6D88\u5B89\u88C5",
-  backup_detected: "\u68C0\u6D4B\u5230\u5F53\u524D\u76EE\u5F55\u5DF2\u5B89\u88C5\u63D2\u4EF6",
-  backup_current: "\u5F53\u524D\u5B89\u88C5",
-  backup_installing: "\u5373\u5C06\u5B89\u88C5",
-  backup_overwrite_warning: "\u7EE7\u7EED\u5B89\u88C5\u5C06\u8986\u76D6\u73B0\u6709\u7684 AGENTS.md \u914D\u7F6E\u6587\u4EF6\u3002",
-  backup_auto_create: "\u7CFB\u7EDF\u4F1A\u81EA\u52A8\u521B\u5EFA\u5907\u4EFD\uFF0C\u4EE5\u4FBF\u540E\u7EED\u6062\u590D\u3002",
-  backup_overwrite: "\u8986\u76D6\u5B89\u88C5\uFF08\u81EA\u52A8\u5907\u4EFD\uFF09",
-  backup_cancel: "\u53D6\u6D88\u5B89\u88C5",
-  backup_restore_prompt: "\u68C0\u6D4B\u5230\u5907\u4EFD\u914D\u7F6E\uFF0C\u662F\u5426\u6062\u590D\uFF1F",
-  backup_restore: "\u6062\u590D",
-  backup_only_uninstall: "\u4EC5\u5378\u8F7D\uFF08\u4E0D\u6062\u590D\uFF09",
-  backup_select_action: "\u8BF7\u9009\u62E9\u64CD\u4F5C",
-  backup_restore_success: "\u5DF2\u6062\u590D\u914D\u7F6E",
-  backup_created: "\u5DF2\u521B\u5EFA\u5907\u4EFD",
-  loading_skills_list: "\u6B63\u5728\u52A0\u8F7D Skills \u5217\u8868...",
-  loading_skills_list_complete: "Skills \u5217\u8868\u52A0\u8F7D\u5B8C\u6210",
-  loading_plugin_data: "\u6B63\u5728\u52A0\u8F7D\u63D2\u4EF6\u6570\u636E...",
-  loading_plugin_data_complete: "\u63D2\u4EF6\u6570\u636E\u52A0\u8F7D\u5B8C\u6210",
-  loading_skills_list_failed: "Skills \u5217\u8868\u52A0\u8F7D\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u6570\u636E",
-  install_no_skill_selected: "\u672A\u9009\u62E9\u4EFB\u4F55 Skill",
-  install_to: "\u5B89\u88C5\u5230",
-  start_to_use: "\u542F\u52A8 {tool} \u5373\u53EF\u4F7F\u7528",
-  wizard_step_1_title: "[1/4] \u9009\u62E9 AI \u7F16\u7A0B\u5DE5\u5177",
-  wizard_step_2_title: "[2/4] \u9009\u62E9\u5B89\u88C5\u4F4D\u7F6E",
-  wizard_step_3_title: "[3/4] \u9009\u62E9\u8981\u5B89\u88C5\u7684\u63D2\u4EF6",
-  wizard_step_4_title: "[4/4] \u786E\u8BA4\u5B89\u88C5",
-  wizard_step_3_skill_title: "[3/4] \u9009\u62E9 Skill \u7C7B\u522B",
-  wizard_step_4_skill_title: "[4/4] \u9009\u62E9\u8981\u5B89\u88C5\u7684 Skills \u2014 {category}",
-  install_level_project: "\u5B89\u88C5\u5230\u5F53\u524D\u76EE\u5F55\uFF08\u63A8\u8350\uFF0C\u4EC5\u5F53\u524D\u9879\u76EE\u53EF\u7528\uFF09",
-  install_level_global: "\u5B89\u88C5\u5230\u5168\u5C40\uFF08\u6240\u6709\u9879\u76EE\u5171\u4EAB\uFF09",
-  wizard_select_mode_title: "\u9009\u62E9\u5B89\u88C5\u7C7B\u578B",
-  skill_count_format: "{count} \u4E2A Skills",
-  result_success_format: "{count} \u6210\u529F",
-  result_failed_format: "{count} \u5931\u8D25",
-  uninstall_remove_label: "\u79FB\u9664",
-  uninstall_remove_file_format: "\u79FB\u9664 {count} \u4E2A\u6587\u4EF6",
-  uninstall_remove_dir_format: "{count} \u4E2A\u76EE\u5F55",
-  uninstall_clean_empty_dir: "\u6E05\u7406\u7A7A\u76EE\u5F55",
-  uninstall_skill_not_installed: "\u672A\u5B89\u88C5",
-  available_plugins: "\u53EF\u7528\u63D2\u4EF6",
-  available_skills: "\u53EF\u7528 Skills",
-  skill_total_count: "\u5171 {count} \u4E2A Skills",
-  wizard_confirm_install_format: "\u5373\u5C06\u5B89\u88C5 {count} \u4E2A\u63D2\u4EF6\u5230 {tool}\uFF08{level} \u7EA7\u522B\uFF09\uFF1A",
-  wizard_install_path: "\u5B89\u88C5\u8DEF\u5F84",
-  update_install_hint: "\u4F7F\u7528 {cmd} \u5B89\u88C5\u63D2\u4EF6",
-  hint_select_move: "\u79FB\u52A8",
-  hint_select_space: "\u7A7A\u683C",
-  hint_select_check: "\u52FE\u9009",
-  hint_select_confirm: "\u786E\u8BA4",
-  hint_checkbox_suffix: "\u4E0D\u9009\u6309\u56DE\u8F66\u53EF\u8FD4\u56DE",
-  doctor_not_installed: "\u672A\u5B89\u88C5",
-  doctor_links_valid: "{count} \u4E2A\u8F6F\u94FE\u63A5\u5747\u6709\u6548",
-  doctor_broken_links: "{count} \u4E2A\u5931\u6548\u94FE\u63A5",
-  doctor_fixed: "\u5DF2\u6E05\u7406 {count} \u4E2A\u5931\u6548\u94FE\u63A5",
-  doctor_not_exist: "\u4E0D\u5B58\u5728",
-  doctor_created: "\u5DF2\u521B\u5EFA {path}",
-  doctor_config_exists: "\u5B58\u5728",
-  doctor_config_not_exist: "\u4E0D\u5B58\u5728",
-  doctor_result_with_fix: "{warnings} \u4E2A\u8B66\u544A, {errors} \u4E2A\u9519\u8BEF, {fixes} \u9879\u5DF2\u4FEE\u590D",
-  doctor_result_without_fix: "{warnings} \u4E2A\u8B66\u544A, {errors} \u4E2A\u9519\u8BEF",
-  count_suffix: "\u4E2A",
-  try_prompt: "\u5E2E\u6211\u5F00\u53D1\u4E00\u4E2A Abs \u7B97\u5B50"
-};
-var en_US = {
-  wizard_title: "CANNBot Install Helper",
-  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",
-  error_invalid_tool: "Unsupported AI tool: {tool}\nSupported tools: {tools}",
-  error_invalid_level: "Unsupported install level: {level}\nSupported levels: {levels}",
-  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",
-  status_title: "Installed Plugins",
-  status_none: "No installed plugins",
-  status_hint: "Run install-helper init to start",
-  status_install_time: "Installed at",
-  install_installed_to: "Installed to",
-  install_skills_count: "Skills",
-  install_agents_count: "Agents",
-  lang_supported: "Supported languages: zh_CN, en_US",
-  lang_usage: "Usage: install-helper lang set <language>",
-  lang_specify: "Please specify language: install-helper lang set zh_CN",
-  lang_unknown_action: "Unknown action",
-  lang_supported_actions: "Supported actions: show, set",
-  info_aliases: "Aliases",
-  uninstall_not_found: "Not found",
-  uninstall_no_record: "No install record found, may not be installed or record is corrupted",
-  uninstall_no_record_hint: "For manual cleanup, delete related files in .opencode/ or .claude/ directory",
-  uninstall_in_progress: "Uninstalling",
-  uninstall_removed: "Uninstalled",
-  uninstall_files_gone: " files no longer exist, install record cleaned",
-  uninstall_skills_in_progress: "Uninstalling",
-  init_pkg_dir_warn: "Current directory appears to be the install-helper package directory",
-  init_pkg_dir_hint: "Please run this command in your project directory, not in the install-helper package directory",
-  init_pkg_dir_example: "Example: cd ~/my-project && install-helper",
-  init_cancelled: "Installation cancelled",
-  backup_detected: "Plugin already installed in current directory",
-  backup_current: "Currently installed",
-  backup_installing: "About to install",
-  backup_overwrite_warning: "Continuing will overwrite existing AGENTS.md configuration.",
-  backup_auto_create: "System will automatically create backup for future restoration.",
-  backup_overwrite: "Overwrite (auto backup)",
-  backup_cancel: "Cancel installation",
-  backup_restore_prompt: "Backup configuration detected, restore?",
-  backup_restore: "Restore",
-  backup_only_uninstall: "Uninstall only (no restore)",
-  backup_select_action: "Please select an action",
-  backup_restore_success: "Configuration restored",
-  backup_created: "Backup created",
-  loading_skills_list: "Loading Skills list...",
-  loading_skills_list_complete: "Skills list loaded",
-  loading_plugin_data: "Loading plugin data...",
-  loading_plugin_data_complete: "Plugin data loaded",
-  loading_skills_list_failed: "Failed to load Skills list, using built-in data",
-  install_no_skill_selected: "No Skill selected",
-  install_to: "Install to",
-  start_to_use: "Start {tool} to use",
-  wizard_step_1_title: "[1/4] Select AI coding tool",
-  wizard_step_2_title: "[2/4] Select installation location",
-  wizard_step_3_title: "[3/4] Select plugins to install",
-  wizard_step_4_title: "[4/4] Confirm installation",
-  wizard_step_3_skill_title: "[3/4] Select Skill category",
-  wizard_step_4_skill_title: "[4/4] Select Skills to install \u2014 {category}",
-  install_level_project: "Install to current directory (recommended, current project only)",
-  install_level_global: "Install globally (all projects)",
-  wizard_select_mode_title: "Select installation type",
-  skill_count_format: "{count} Skills",
-  result_success_format: "{count} succeeded",
-  result_failed_format: "{count} failed",
-  uninstall_remove_label: "Removed",
-  uninstall_remove_file_format: "Removed {count} files",
-  uninstall_remove_dir_format: "{count} directories",
-  uninstall_clean_empty_dir: "Cleaned empty directory",
-  uninstall_skill_not_installed: "Not installed",
-  available_plugins: "Available plugins",
-  available_skills: "Available Skills",
-  skill_total_count: "Total {count} Skills",
-  wizard_confirm_install_format: "About to install {count} plugins to {tool} ({level} level):",
-  wizard_install_path: "Install path",
-  update_install_hint: "Use {cmd} to install plugins",
-  hint_select_move: "Navigate",
-  hint_select_space: "Space",
-  hint_select_check: "Toggle",
-  hint_select_confirm: "Confirm",
-  hint_checkbox_suffix: "Press enter without selection to go back",
-  doctor_not_installed: "Not installed",
-  doctor_links_valid: "{count} symlinks all valid",
-  doctor_broken_links: "{count} broken links",
-  doctor_fixed: "Cleaned {count} broken links",
-  doctor_not_exist: "Does not exist",
-  doctor_created: "Created {path}",
-  doctor_config_exists: "Exists",
-  doctor_config_not_exist: "Does not exist",
-  doctor_result_with_fix: "{warnings} warnings, {errors} errors, {fixes} fixed",
-  doctor_result_without_fix: "{warnings} warnings, {errors} errors",
-  count_suffix: "",
-  try_prompt: "help me develop an Abs operator"
-};
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+function loadLocale(locale) {
+  const localePath = join2(__dirname2, "locales", `${locale}.json`);
+  try {
+    const content = readFileSync2(localePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    const fallbackPath = join2(__dirname2, "locales", "zh_CN.json");
+    try {
+      const content = readFileSync2(fallbackPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+}
 var currentLang = "zh_CN";
+var messages = loadLocale("zh_CN");
 function setLanguage(lang) {
   currentLang = lang;
+  messages = loadLocale(lang);
 }
 function t(key) {
-  return currentLang === "zh_CN" ? zh_CN[key] : en_US[key];
+  return messages[key] !== void 0 ? messages[key] : key;
 }
 
 // src/utils/paths.ts
@@ -512,9 +136,9 @@ function validateLevel(level) {
 }
 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";
+  if (existsSync(join3(home, ".trae-cn"))) return "ide";
+  if (existsSync(join3(home, ".marscode"))) return "plugin";
+  if (existsSync(join3(home, ".traecli"))) return "cli";
   return "unknown";
 }
 function getConfigRoot(tool, level, base) {
@@ -522,24 +146,24 @@ function getConfigRoot(tool, level, base) {
   if (level === "global") {
     switch (tool) {
       case "opencode":
-        return join(home, ".config", "opencode");
+        return join3(home, ".config", "opencode");
       case "claude":
-        return join(home, ".claude");
+        return join3(home, ".claude");
       case "trae": {
         const variant = detectTraeVariant();
         switch (variant) {
           case "plugin":
-            return join(home, ".marscode");
+            return join3(home, ".marscode");
           case "cli":
-            return join(home, ".traecli");
+            return join3(home, ".traecli");
           default:
-            return join(home, ".trae-cn");
+            return join3(home, ".trae-cn");
         }
       }
       case "cursor":
-        return join(home, ".cursor");
+        return join3(home, ".cursor");
       case "copilot":
-        return join(home, ".copilot");
+        return join3(home, ".copilot");
       default:
         throw new Error(
           t("error_invalid_tool").replace("{tool}", tool).replace("{tools}", VALID_TOOLS.join(", "))
@@ -549,24 +173,24 @@ function getConfigRoot(tool, level, base) {
   const baseDir = base || process.cwd();
   switch (tool) {
     case "opencode":
-      return join(baseDir, ".opencode");
+      return join3(baseDir, ".opencode");
     case "claude":
-      return join(baseDir, ".claude");
+      return join3(baseDir, ".claude");
     case "trae": {
       const variant = detectTraeVariant();
       switch (variant) {
         case "plugin":
-          return join(baseDir, ".marscode");
+          return join3(baseDir, ".marscode");
         case "cli":
-          return join(baseDir, ".traecli");
+          return join3(baseDir, ".traecli");
         default:
-          return join(baseDir, ".trae");
+          return join3(baseDir, ".trae");
       }
     }
     case "cursor":
-      return join(baseDir, ".cursor");
+      return join3(baseDir, ".cursor");
     case "copilot":
-      return join(baseDir, ".github");
+      return join3(baseDir, ".github");
     default:
       throw new Error(
         t("error_invalid_tool").replace("{tool}", tool).replace("{tools}", VALID_TOOLS.join(", "))
@@ -577,19 +201,19 @@ function getConfigFileName(tool) {
   return tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
 }
 function getSkillsDir(configRoot) {
-  return join(configRoot, "skills");
+  return join3(configRoot, "skills");
 }
 function getAgentsDir(configRoot) {
-  return join(configRoot, "agents");
+  return join3(configRoot, "agents");
 }
 function getManifestPath(configRoot) {
-  return join(configRoot, "cannbot-manifest.json");
+  return join3(configRoot, "cannbot-manifest.json");
 }
 function getCannbotConfigDir() {
-  return join(homedir(), ".cannbot");
+  return join3(homedir(), ".cannbot");
 }
 function getCannbotRepoPath() {
-  return join(getCannbotConfigDir(), "repo");
+  return join3(getCannbotConfigDir(), "repo");
 }
 
 // src/core/detector.ts
@@ -627,12 +251,12 @@ 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");
+  if (variant === "ide" && existsSync2(join4(home, ".trae-cn"))) {
+    path = join4(home, ".trae-cn");
+  } else if (variant === "plugin" && existsSync2(join4(home, ".marscode"))) {
+    path = join4(home, ".marscode");
+  } else if (variant === "cli" && existsSync2(join4(home, ".traecli"))) {
+    path = join4(home, ".traecli");
   } else if (variant === "unknown") {
     const cmdPath = await getCommandPath("trae");
     if (cmdPath) path = cmdPath;
@@ -696,13 +320,13 @@ function getAllTools() {
 }
 
 // src/core/manifest.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
 function readManifest(configRoot) {
   const manifestPath = getManifestPath(configRoot);
   if (existsSync3(manifestPath)) {
     try {
-      const content = readFileSync(manifestPath, "utf-8");
+      const content = readFileSync3(manifestPath, "utf-8");
       return JSON.parse(content);
     } catch {
     }
@@ -715,16 +339,16 @@ function readAllManifests(configRoot) {
   const standardPath = getManifestPath(configRoot);
   if (existsSync3(standardPath)) {
     try {
-      const content = readFileSync(standardPath, "utf-8");
+      const content = readFileSync3(standardPath, "utf-8");
       manifests.push(JSON.parse(content));
     } catch {
     }
   }
   for (const plugin of plugins) {
-    const pluginManifestPath = join3(configRoot, `${plugin.id}-manifest.json`);
+    const pluginManifestPath = join5(configRoot, `${plugin.id}-manifest.json`);
     if (existsSync3(pluginManifestPath)) {
       try {
-        const content = readFileSync(pluginManifestPath, "utf-8");
+        const content = readFileSync3(pluginManifestPath, "utf-8");
         manifests.push(JSON.parse(content));
       } catch {
       }
@@ -767,27 +391,27 @@ function scanInstalled() {
   return installed;
 }
 function verifyPluginFilesExist(configRoot, manifest, tool, level) {
-  const skillsDir = join3(configRoot, "skills");
-  const agentsDir = join3(configRoot, "agents");
+  const skillsDir = join5(configRoot, "skills");
+  const agentsDir = join5(configRoot, "agents");
   if (manifest.installed_skills && manifest.installed_skills.length > 0) {
     const hasAnySkill = manifest.installed_skills.some((skillId) => {
-      const skillPath = join3(skillsDir, skillId);
+      const skillPath = join5(skillsDir, skillId);
       return existsSync3(skillPath);
     });
     if (!hasAnySkill) return false;
   }
   if (manifest.installed_agents && manifest.installed_agents.length > 0) {
     const hasAnyAgent = manifest.installed_agents.some((agentId) => {
-      const agentPath = join3(agentsDir, agentId);
+      const agentPath = join5(agentsDir, agentId);
       return existsSync3(agentPath);
     });
     if (!hasAnyAgent) return false;
   }
   let agentsMdPath;
   if (tool === "opencode" && level === "project") {
-    agentsMdPath = join3(configRoot, "..", "AGENTS.md");
+    agentsMdPath = join5(configRoot, "..", "AGENTS.md");
   } else {
-    agentsMdPath = join3(configRoot, "AGENTS.md");
+    agentsMdPath = join5(configRoot, "AGENTS.md");
   }
   if (!existsSync3(agentsMdPath)) return false;
   return true;
@@ -856,15 +480,15 @@ function showOperationHints(isCheckbox = false) {
 }
 
 // src/utils/config.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { join as join6 } from "path";
 import { homedir as homedir3 } from "os";
 import { parse, stringify } from "yaml";
 function getConfigDir() {
-  return join4(homedir3(), ".cannbot");
+  return join6(homedir3(), ".cannbot");
 }
 function getConfigPath() {
-  return join4(getConfigDir(), "config.yaml");
+  return join6(getConfigDir(), "config.yaml");
 }
 function readConfig() {
   const configPath = getConfigPath();
@@ -875,7 +499,7 @@ function readConfig() {
     };
   }
   try {
-    const content = readFileSync2(configPath, "utf-8");
+    const content = readFileSync4(configPath, "utf-8");
     const parsed = parse(content);
     return {
       language: parsed.language || "zh_CN",
@@ -1181,14 +805,19 @@ async function stepConfirm(tool, level, plugins) {
 }
 
 // src/core/repository.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6 } from "fs";
+import { join as join8, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { execa as execa2 } from "execa";
+import { parse as parseYaml3 } from "yaml";
 
 // 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";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { parse as parseYaml2 } from "yaml";
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = dirname3(__filename3);
 var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -1209,36 +838,43 @@ var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "docs",
   "scripts"
 ]);
-var SKILL_SCAN_DIRS = [
-  "ops",
-  "model",
-  "graph",
-  "infra",
-  "ops-lab"
-];
-var PLUGIN_SCAN_DIRS = [
-  "plugins-official",
-  "plugins-community"
-];
+function loadScanConfig() {
+  const configPath = join7(__dirname3, "config", "repository.yaml");
+  try {
+    const config = parseYaml2(readFileSync5(configPath, "utf-8"));
+    return {
+      skillDirs: config.scanDirs || ["ops", "model", "graph", "infra", "ops-lab"],
+      pluginDirs: config.pluginDirs || ["plugins-official", "plugins-community"]
+    };
+  } catch {
+    return {
+      skillDirs: ["ops", "model", "graph", "infra", "ops-lab"],
+      pluginDirs: ["plugins-official", "plugins-community"]
+    };
+  }
+}
+var scanConfig = loadScanConfig();
+var SKILL_SCAN_DIRS = scanConfig.skillDirs;
+var PLUGIN_SCAN_DIRS = scanConfig.pluginDirs;
 function scanSkills(repoPath) {
   const skills = [];
   const seen = /* @__PURE__ */ new Set();
   for (const dir of SKILL_SCAN_DIRS) {
-    const fullPath = join5(repoPath, dir);
+    const fullPath = join7(repoPath, dir);
     if (!existsSync5(fullPath)) continue;
     scanDirectory(fullPath, repoPath, dir, skills, seen);
   }
   for (const pluginDir of PLUGIN_SCAN_DIRS) {
-    const pluginParent = join5(repoPath, pluginDir);
+    const pluginParent = join7(repoPath, pluginDir);
     if (!existsSync5(pluginParent)) continue;
     for (const plugin of safeReaddir(pluginParent)) {
-      const pluginPath = join5(pluginParent, plugin);
+      const pluginPath = join7(pluginParent, plugin);
       if (!isDirectory(pluginPath)) continue;
-      const skillsDir = join5(pluginPath, "skills");
+      const skillsDir = join7(pluginPath, "skills");
       if (existsSync5(skillsDir)) {
         scanDirectory(skillsDir, repoPath, `${pluginDir}/${plugin}/skills`, skills, seen);
       }
-      const skillDir = join5(pluginPath, "skill");
+      const skillDir = join7(pluginPath, "skill");
       if (existsSync5(skillDir)) {
         scanDirectory(skillDir, repoPath, `${pluginDir}/${plugin}/skill`, skills, seen);
       }
@@ -1248,7 +884,7 @@ function scanSkills(repoPath) {
 }
 function parseFrontmatter(filePath) {
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     const lines = content.split("\n");
     if (lines.length < 3) return null;
     if (lines[0].trim() !== "---") return null;
@@ -1261,7 +897,7 @@ function parseFrontmatter(filePath) {
     }
     if (endIndex === -1) return null;
     const yamlBlock = lines.slice(1, endIndex).map((l) => l.replace(/\r$/, "")).join("\n");
-    const parsed = parseYaml(yamlBlock);
+    const parsed = parseYaml2(yamlBlock);
     if (!parsed || typeof parsed !== "object") return null;
     if (!parsed.name || typeof parsed.name !== "string") return null;
     return {
@@ -1274,17 +910,17 @@ function parseFrontmatter(filePath) {
 }
 function getCurrentCommit(repoPath) {
   try {
-    const headFile = join5(repoPath, ".git", "HEAD");
+    const headFile = join7(repoPath, ".git", "HEAD");
     if (!existsSync5(headFile)) return "unknown";
-    const headContent = readFileSync3(headFile, "utf-8").trim();
+    const headContent = readFileSync5(headFile, "utf-8").trim();
     if (headContent.startsWith("ref: ")) {
-      const refPath = join5(repoPath, ".git", headContent.slice(5));
+      const refPath = join7(repoPath, ".git", headContent.slice(5));
       if (existsSync5(refPath)) {
-        return readFileSync3(refPath, "utf-8").trim();
+        return readFileSync5(refPath, "utf-8").trim();
       }
-      const packedRefsPath = join5(repoPath, ".git", "packed-refs");
+      const packedRefsPath = join7(repoPath, ".git", "packed-refs");
       if (existsSync5(packedRefsPath)) {
-        const packedRefs = readFileSync3(packedRefsPath, "utf-8");
+        const packedRefs = readFileSync5(packedRefsPath, "utf-8");
         const refName = headContent.slice(5);
         const lines = packedRefs.split("\n");
         for (const line of lines) {
@@ -1303,7 +939,7 @@ function readScanCache() {
   try {
     const cachePath = getCachePath();
     if (!existsSync5(cachePath)) return null;
-    const content = readFileSync3(cachePath, "utf-8");
+    const content = readFileSync5(cachePath, "utf-8");
     const cache = JSON.parse(content);
     if (!cache.skills || !cache.timestamp) return null;
     const age = Date.now() - cache.timestamp;
@@ -1316,7 +952,7 @@ function readScanCache() {
 function writeScanCache(cache) {
   try {
     const cachePath = getCachePath();
-    const cacheDir = dirname(cachePath);
+    const cacheDir = dirname3(cachePath);
     if (!existsSync5(cacheDir)) {
       mkdirSync2(cacheDir, { recursive: true });
     }
@@ -1325,10 +961,10 @@ function writeScanCache(cache) {
   }
 }
 function getCachePath() {
-  return join5(getCannbotConfigDir(), "scan-cache.json");
+  return join7(getCannbotConfigDir(), "scan-cache.json");
 }
 function scanDirectory(dirPath, repoPath, sourcePrefix, skills, seen) {
-  const selfSkillMd = join5(dirPath, "SKILL.md");
+  const selfSkillMd = join7(dirPath, "SKILL.md");
   if (existsSync5(selfSkillMd)) {
     const frontmatter = parseFrontmatter(selfSkillMd);
     if (frontmatter && !seen.has(frontmatter.name)) {
@@ -1343,10 +979,10 @@ function scanDirectory(dirPath, repoPath, sourcePrefix, skills, seen) {
     return;
   }
   for (const entry of safeReaddir(dirPath)) {
-    const fullPath = join5(dirPath, entry);
+    const fullPath = join7(dirPath, entry);
     if (EXCLUDE_DIRS.has(entry)) continue;
     if (!isDirectory(fullPath)) continue;
-    const skillMd = join5(fullPath, "SKILL.md");
+    const skillMd = join7(fullPath, "SKILL.md");
     if (existsSync5(skillMd)) {
       const frontmatter = parseFrontmatter(skillMd);
       if (frontmatter && !seen.has(frontmatter.name)) {
@@ -1365,7 +1001,7 @@ function scanDirectory(dirPath, repoPath, sourcePrefix, skills, seen) {
 }
 function safeReaddir(dir) {
   try {
-    return readdirSync(dir);
+    return readdirSync2(dir);
   } catch {
     return [];
   }
@@ -1605,7 +1241,21 @@ function getAllCategories() {
 }
 
 // src/core/repository.ts
-var REPO_URL = "https://gitcode.com/cann/cannbot-skills.git";
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = dirname4(__filename4);
+function loadRepoUrl() {
+  if (process.env.CANNBOT_REPO_URL) {
+    return process.env.CANNBOT_REPO_URL;
+  }
+  const configPath = join8(__dirname4, "config", "repository.yaml");
+  try {
+    const config = parseYaml3(readFileSync6(configPath, "utf-8"));
+    return config.repository?.url || "https://gitcode.com/cann/cannbot-skills.git";
+  } catch {
+    return "https://gitcode.com/cann/cannbot-skills.git";
+  }
+}
+var REPO_URL = loadRepoUrl();
 var RepositoryManager = class {
   repoPath;
   constructor(customPath) {
@@ -1663,8 +1313,8 @@ var RepositoryManager = class {
   }
   isValidRepo(path) {
     if (!existsSync6(path)) return false;
-    const gitDir = join6(path, ".git");
-    const pluginsDir = join6(path, "plugins-official");
+    const gitDir = join8(path, ".git");
+    const pluginsDir = join8(path, "plugins-official");
     return existsSync6(gitDir) && existsSync6(pluginsDir);
   }
   async cloneRepo() {
@@ -1700,17 +1350,17 @@ function createRepositoryManager(customPath) {
 
 // src/core/installer.ts
 import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
+import { join as join11 } 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";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4, lstatSync, unlinkSync } from "fs";
+import { join as join9 } from "path";
 function getInstallsDir() {
-  return join7(getCannbotConfigDir(), "installs");
+  return join9(getCannbotConfigDir(), "installs");
 }
 function getRecordPath(pluginId) {
-  return join7(getInstallsDir(), `${pluginId}.json`);
+  return join9(getInstallsDir(), `${pluginId}.json`);
 }
 function readRecord(pluginId) {
   const recordPath = getRecordPath(pluginId);
@@ -1718,7 +1368,7 @@ function readRecord(pluginId) {
     return null;
   }
   try {
-    const content = readFileSync4(recordPath, "utf-8");
+    const content = readFileSync7(recordPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -1742,22 +1392,22 @@ function scanInstalledFiles(pluginId, displayName, tool, level, installPath, con
   const files = [];
   const directories = [];
   if (manifest) {
-    const skillsDir = join7(configRoot, "skills");
+    const skillsDir = join9(configRoot, "skills");
     if (existsSync7(skillsDir)) {
       directories.push(skillsDir);
       for (const skillName of manifest.installed_skills || []) {
-        const skillPath = join7(skillsDir, skillName);
+        const skillPath = join9(skillsDir, skillName);
         if (existsSync7(skillPath) || isSymlink(skillPath)) {
           files.push(skillPath);
         }
       }
     }
-    const agentsDir = join7(configRoot, "agents");
+    const agentsDir = join9(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");
+        const agentPath = join9(agentsDir, agentName);
+        const agentPathMd = join9(agentsDir, agentName + ".md");
         if (existsSync7(agentPath) || isSymlink(agentPath)) {
           files.push(agentPath);
         } else if (existsSync7(agentPathMd) || isSymlink(agentPathMd)) {
@@ -1766,30 +1416,30 @@ function scanInstalledFiles(pluginId, displayName, tool, level, installPath, con
       }
     }
   }
-  const workflowsLink = join7(configRoot, "workflows");
+  const workflowsLink = join9(configRoot, "workflows");
   if (isSymlink(workflowsLink)) {
     files.push(workflowsLink);
   }
-  const manifestPath = join7(configRoot, "cannbot-manifest.json");
+  const manifestPath = join9(configRoot, "cannbot-manifest.json");
   if (existsSync7(manifestPath)) {
     files.push(manifestPath);
   }
-  const pluginManifestPath = join7(configRoot, `${pluginId}-manifest.json`);
+  const pluginManifestPath = join9(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);
+  const configFilePath = level === "project" ? join9(installPath, configFileName) : join9(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);
+    const repoLinkPath = join9(installPath, repoName);
     if (isSymlink(repoLinkPath)) {
       files.push(repoLinkPath);
     }
-    const repoLinkInConfig = join7(configRoot, repoName);
+    const repoLinkInConfig = join9(configRoot, repoName);
     if (isSymlink(repoLinkInConfig)) {
       files.push(repoLinkInConfig);
     }
@@ -1814,7 +1464,7 @@ function isSymlink(path) {
   }
 }
 function getSkillRecordPath() {
-  return join7(getInstallsDir(), "skills.json");
+  return join9(getInstallsDir(), "skills.json");
 }
 function readSkillRecord() {
   const recordPath = getSkillRecordPath();
@@ -1822,7 +1472,7 @@ function readSkillRecord() {
     return {};
   }
   try {
-    const content = readFileSync4(recordPath, "utf-8");
+    const content = readFileSync7(recordPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -1872,16 +1522,16 @@ function getInstalledSkills(tool, level, installPath) {
   const record = readSkillRecord();
   const recordedSkills = record[tool]?.[level]?.[installPath]?.skills || [];
   const configRoot = getConfigRoot(tool, level);
-  const skillsDir = join7(configRoot, "skills");
+  const skillsDir = join9(configRoot, "skills");
   return recordedSkills.filter((skillId) => {
-    const skillPath = join7(skillsDir, skillId);
+    const skillPath = join9(skillsDir, skillId);
     return existsSync7(skillPath) || isSymlink(skillPath);
   });
 }
 
 // src/core/backup.ts
-import { existsSync as existsSync8, copyFileSync, readdirSync as readdirSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8, copyFileSync, readdirSync as readdirSync3, unlinkSync as unlinkSync2 } from "fs";
+import { join as join10 } from "path";
 function getAgentsFileName(tool) {
   return tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
 }
@@ -1896,7 +1546,7 @@ function detectCurrentPlugin(configRoot, tool) {
       };
     }
   }
-  const agentsFile = join8(configRoot, getAgentsFileName(tool));
+  const agentsFile = join10(configRoot, getAgentsFileName(tool));
   if (!existsSync8(agentsFile)) {
     return null;
   }
@@ -1915,13 +1565,13 @@ function detectCurrentPlugin(configRoot, tool) {
   return null;
 }
 function createBackup(configRoot, tool, fromPluginId, fromPluginName) {
-  const agentsFile = join8(configRoot, getAgentsFileName(tool));
+  const agentsFile = join10(configRoot, getAgentsFileName(tool));
   if (!existsSync8(agentsFile)) {
     return null;
   }
   const timestamp = formatTimestamp(/* @__PURE__ */ new Date());
   const backupFileName = `${getAgentsFileName(tool)}.cannbot-backup.${fromPluginId}.${timestamp}`;
-  const backupPath = join8(configRoot, backupFileName);
+  const backupPath = join10(configRoot, backupFileName);
   try {
     copyFileSync(agentsFile, backupPath);
     return {
@@ -1938,7 +1588,7 @@ function findBackups(configRoot) {
   if (!existsSync8(configRoot)) {
     return [];
   }
-  const files = readdirSync2(configRoot);
+  const files = readdirSync3(configRoot);
   const backups = [];
   for (const file of files) {
     if (file.includes(".cannbot-backup.")) {
@@ -1951,7 +1601,7 @@ function findBackups(configRoot) {
           const timestamp = pluginIdAndTime.substring(lastDotIndex + 1);
           const plugin = findPlugin(pluginId);
           backups.push({
-            filePath: join8(configRoot, file),
+            filePath: join10(configRoot, file),
             pluginId,
             pluginName: plugin?.displayName || pluginId,
             backupTime: timestamp
@@ -1964,7 +1614,7 @@ function findBackups(configRoot) {
 }
 function restoreBackup(backupPath, configRoot, tool) {
   try {
-    const agentsFile = join8(configRoot, getAgentsFileName(tool));
+    const agentsFile = join10(configRoot, getAgentsFileName(tool));
     copyFileSync(backupPath, agentsFile);
     return true;
   } catch {
@@ -2065,7 +1715,7 @@ async function installPlugin(opts) {
       warnings: []
     };
   }
-  const scriptPath = join9(opts.repoPath, plugin.dir, plugin.script);
+  const scriptPath = join11(opts.repoPath, plugin.dir, plugin.script);
   if (!existsSync9(scriptPath)) {
     return {
       success: false,
@@ -2082,7 +1732,7 @@ async function installPlugin(opts) {
   }
   const cwd = opts.installPath || process.cwd();
   const configRoot = getConfigRoot(opts.tool, opts.level, opts.installPath);
-  const agentsFile = join9(configRoot, getAgentsFileName(opts.tool));
+  const agentsFile = join11(configRoot, getAgentsFileName(opts.tool));
   let backupInfo = null;
   if (existsSync9(agentsFile)) {
     const currentPlugin = detectCurrentPlugin(configRoot, opts.tool);
@@ -2177,14 +1827,14 @@ async function installPlugin(opts) {
 }
 
 // src/core/skill-installer.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, symlinkSync, unlinkSync as unlinkSync3, readdirSync as readdirSync3, rmdirSync, realpathSync, lstatSync as lstatSync2 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, symlinkSync, unlinkSync as unlinkSync3, readdirSync as readdirSync4, rmdirSync, realpathSync, lstatSync as lstatSync2 } from "fs";
+import { join as join12 } from "path";
 import { select as select3, checkbox as checkbox2, Separator as Separator2 } from "@inquirer/prompts";
 import chalk4 from "chalk";
 import Table from "cli-table3";
 async function installSkills(skillIds, tool, level, repoPath) {
   const configRoot = getConfigRoot(tool, level);
-  const skillsDir = join10(configRoot, "skills");
+  const skillsDir = join12(configRoot, "skills");
   const installPath = level === "project" ? process.cwd() : configRoot;
   if (!existsSync10(skillsDir)) {
     mkdirSync5(skillsDir, { recursive: true });
@@ -2197,8 +1847,8 @@ async function installSkills(skillIds, tool, level, repoPath) {
       results.push({ skillId, success: false, error: "Skill not found in registry" });
       continue;
     }
-    const sourcePath = join10(repoPath, skill.source, skill.id);
-    const targetPath = join10(skillsDir, skillId);
+    const sourcePath = join12(repoPath, skill.source, skill.id);
+    const targetPath = join12(skillsDir, skillId);
     if (!existsSync10(sourcePath)) {
       results.push({ skillId, success: false, error: `Source not found: ${sourcePath}` });
       continue;
@@ -2221,12 +1871,12 @@ async function installSkills(skillIds, tool, level, repoPath) {
 }
 async function uninstallSkills(skillIds, tool, level) {
   const configRoot = getConfigRoot(tool, level);
-  const skillsDir = join10(configRoot, "skills");
+  const skillsDir = join12(configRoot, "skills");
   const installPath = level === "project" ? process.cwd() : configRoot;
   const results = [];
   const removedIds = [];
   for (const skillId of skillIds) {
-    const targetPath = join10(skillsDir, skillId);
+    const targetPath = join12(skillsDir, skillId);
     try {
       if (existsSync10(targetPath) || isSymlink2(targetPath)) {
         unlinkSync3(targetPath);
@@ -2246,7 +1896,7 @@ async function uninstallSkills(skillIds, tool, level) {
   }
   if (existsSync10(skillsDir)) {
     try {
-      const entries = readdirSync3(skillsDir);
+      const entries = readdirSync4(skillsDir);
       if (entries.length === 0) {
         rmdirSync(skillsDir);
         logger.step(`  ${t("uninstall_clean_empty_dir")}: skills/`);
@@ -2444,8 +2094,10 @@ function printEnhancedSummary(results, tool, configRoot) {
     ""
   ];
   if (successResults.length === 1) {
+    const plugin = findPlugin(successResults[0].pluginId);
+    const docsPath = plugin ? `${plugin.dir}/quickstart.md` : `${successResults[0].pluginId}/quickstart.md`;
     lines.push(
-      `  ${chalk5.dim(t("install_enhanced_docs"))}: ${chalk5.dim(`plugins-official/${successResults[0].pluginId}/quickstart.md`)}`
+      `  ${chalk5.dim(t("install_enhanced_docs"))}: ${chalk5.dim(docsPath)}`
     );
   }
   console.log();
@@ -2456,15 +2108,15 @@ function printEnhancedSummary(results, tool, configRoot) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync11, readFileSync as readFileSync5 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { join as join13 } from "path";
 var BACK2 = "__back__";
 var CANCEL2 = "__cancel__";
 async function initCommand() {
   const cwd = process.cwd();
-  if (existsSync11(join11(cwd, "package.json")) && (() => {
+  if (existsSync11(join13(cwd, "package.json")) && (() => {
     try {
-      const pkg = JSON.parse(readFileSync5(join11(cwd, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync8(join13(cwd, "package.json"), "utf-8"));
       return pkg.name === "@cannbot-ai/install-helper";
     } catch {
       return false;
@@ -2690,8 +2342,8 @@ async function listCommand() {
 
 // src/commands/doctor.ts
 import chalk7 from "chalk";
-import { existsSync as existsSync12, readdirSync as readdirSync4, lstatSync as lstatSync3, unlinkSync as unlinkSync4, mkdirSync as mkdirSync6 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync5, lstatSync as lstatSync3, unlinkSync as unlinkSync4, mkdirSync as mkdirSync6 } from "fs";
+import { join as join14 } from "path";
 async function doctorCommand(options = {}) {
   console.log();
   console.log(chalk7.bold(`  ${t("doctor_title")}`));
@@ -2737,7 +2389,7 @@ async function doctorCommand(options = {}) {
   if (existsSync12(skillsDir)) {
     const brokenLinks = checkBrokenLinks(skillsDir);
     if (brokenLinks === 0) {
-      const count = readdirSync4(skillsDir).length;
+      const count = readdirSync5(skillsDir).length;
       console.log(chalk7.green("  \u2713") + ` ${skillsDir} \u2014 ${t("doctor_links_valid").replace("{count}", String(count))}`);
     } else {
       console.log(chalk7.yellow("  \u26A0") + ` ${skillsDir} \u2014 ${t("doctor_broken_links").replace("{count}", String(brokenLinks))}`);
@@ -2759,7 +2411,7 @@ async function doctorCommand(options = {}) {
   if (existsSync12(agentsDir)) {
     const brokenLinks = checkBrokenLinks(agentsDir);
     if (brokenLinks === 0) {
-      const count = readdirSync4(agentsDir).length;
+      const count = readdirSync5(agentsDir).length;
       console.log(chalk7.green("  \u2713") + ` ${agentsDir} \u2014 ${t("doctor_links_valid").replace("{count}", String(count))}`);
     } else {
       console.log(chalk7.yellow("  \u26A0") + ` ${agentsDir} \u2014 ${t("doctor_broken_links").replace("{count}", String(brokenLinks))}`);
@@ -2781,7 +2433,7 @@ async function doctorCommand(options = {}) {
   console.log();
   console.log(chalk7.bold(`  ${t("doctor_config")}`));
   const configFile = getConfigFileName(primaryTool);
-  const configPath = join12(process.cwd(), configFile);
+  const configPath = join14(process.cwd(), configFile);
   if (existsSync12(configPath)) {
     console.log(chalk7.green("  \u2713") + ` ${configFile} ${t("doctor_config_exists")}`);
   } else {
@@ -2803,9 +2455,9 @@ async function doctorCommand(options = {}) {
 function checkBrokenLinks(dir) {
   let broken = 0;
   try {
-    const entries = readdirSync4(dir);
+    const entries = readdirSync5(dir);
     for (const entry of entries) {
-      const fullPath = join12(dir, entry);
+      const fullPath = join14(dir, entry);
       try {
         const stats = lstatSync3(fullPath);
         if (stats.isSymbolicLink()) {
@@ -2824,9 +2476,9 @@ function checkBrokenLinks(dir) {
 function fixBrokenLinks(dir) {
   let fixed = 0;
   try {
-    const entries = readdirSync4(dir);
+    const entries = readdirSync5(dir);
     for (const entry of entries) {
-      const fullPath = join12(dir, entry);
+      const fullPath = join14(dir, entry);
       try {
         const stats = lstatSync3(fullPath);
         if (stats.isSymbolicLink()) {
@@ -3105,7 +2757,7 @@ async function installPlugins(pluginIds, tool, level, repoPath) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync13, unlinkSync as unlinkSync5, rmdirSync as rmdirSync2, readdirSync as readdirSync5, lstatSync as lstatSync4 } from "fs";
+import { existsSync as existsSync13, unlinkSync as unlinkSync5, rmdirSync as rmdirSync2, readdirSync as readdirSync6, lstatSync as lstatSync4 } from "fs";
 import chalk10 from "chalk";
 async function uninstallCommand(names, options) {
   const tool = options.tool ? validateTool(options.tool) : "opencode";
@@ -3156,7 +2808,7 @@ async function uninstallCommand(names, options) {
           continue;
         }
         if (existsSync13(dirPath)) {
-          const entries = readdirSync5(dirPath);
+          const entries = readdirSync6(dirPath);
           if (entries.length === 0) {
             rmdirSync2(dirPath);
             const name = dirPath.split("/").pop() || dirPath;
@@ -3300,8 +2952,8 @@ async function updateCommand(pluginNames, options) {
 
 // src/commands/info.ts
 import chalk12 from "chalk";
-import { existsSync as existsSync14, readdirSync as readdirSync6 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync7 } from "fs";
+import { join as join15 } from "path";
 async function infoCommand(pluginName) {
   const plugin = findPlugin(pluginName);
   if (!plugin) {
@@ -3325,13 +2977,13 @@ async function infoCommand(pluginName) {
   try {
     const repoManager = createRepositoryManager();
     const repoPath = await repoManager.ensureRepo();
-    const quickstartPath = join13(repoPath, plugin.dir, "quickstart.md");
+    const quickstartPath = join15(repoPath, plugin.dir, "quickstart.md");
     if (existsSync14(quickstartPath)) {
       console.log(`  ${chalk12.dim(t("info_quickstart") + ":")} ${quickstartPath}`);
     }
-    const agentsDir = join13(repoPath, plugin.dir, "agents");
+    const agentsDir = join15(repoPath, plugin.dir, "agents");
     if (existsSync14(agentsDir)) {
-      const agentFiles = readdirSync6(agentsDir).filter((f) => f.endsWith(".md"));
+      const agentFiles = readdirSync7(agentsDir).filter((f) => f.endsWith(".md"));
       if (agentFiles.length > 0) {
         console.log();
         console.log(`  ${chalk12.bold("Agents:")}`);
@@ -3388,7 +3040,7 @@ function createCLI() {
     setLanguage(config.language);
   }
   const program2 = new Command();
-  program2.name("install-helper").description("CANNBot Install Helper - Interactive installer for CANN operator development skills").version("1.0.2");
+  program2.name("install-helper").description("CANNBot Install Helper - Interactive installer for CANN operator development skills").version("1.0.4");
   program2.command("init", { isDefault: false }).description("Run interactive installation wizard").action(async () => {
     await initCommand();
   });