aico-cli 0.0.1

package/dist/shared/aico-cli.D4gky7Vp.mjs

@@ -0,0 +1,2322 @@
+import inquirer$1 from 'inquirer';
+import ansis from 'ansis';
+import { existsSync, mkdirSync, copyFileSync, writeFileSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'pathe';
+import dayjs from 'dayjs';
+import { fileURLToPath } from 'node:url';
+import { exec } from 'tinyexec';
+import { rm, mkdir, copyFile as copyFile$1 } from 'node:fs/promises';
+import { homedir, platform } from 'node:os';
+
+class EscapeKeyPressed extends Error {
+  constructor() {
+    super("BACK_KEY_PRESSED");
+    this.name = "EscapeKeyPressed";
+  }
+}
+async function createEscapablePrompt(promptConfig) {
+  let modifiedConfig = promptConfig;
+  if (promptConfig.type === "list" && promptConfig.choices) {
+    const backChoice = {
+      name: ansis.gray("\u2190 \u8FD4\u56DE\u4E0A\u4E00\u6B65"),
+      value: "__BACK_KEY__",
+      short: "\u8FD4\u56DE\u4E0A\u4E00\u6B65"
+    };
+    modifiedConfig = {
+      ...promptConfig,
+      choices: [...promptConfig.choices, new inquirer$1.Separator(), backChoice]
+    };
+  }
+  if (promptConfig.type === "checkbox" && promptConfig.choices) {
+    const backChoice = {
+      name: ansis.gray("\u2190 \u8FD4\u56DE\u4E0A\u4E00\u6B65"),
+      value: "__BACK_KEY__",
+      short: "\u8FD4\u56DE\u4E0A\u4E00\u6B65"
+    };
+    modifiedConfig = {
+      ...promptConfig,
+      choices: [...promptConfig.choices, new inquirer$1.Separator(), backChoice],
+      message: `${promptConfig.message} ${ansis.gray(
+        '(\u9009\u62E9"\u8FD4\u56DE\u4E0A\u4E00\u6B65"\u6216\u4E0D\u9009\u62E9\u4EFB\u4F55\u9879\u76EE)'
+      )}`
+    };
+  }
+  const result = await inquirer$1.prompt(modifiedConfig);
+  const resultValue = result[promptConfig.name];
+  if (resultValue === "__BACK_KEY__") {
+    throw new EscapeKeyPressed();
+  }
+  if (promptConfig.type === "checkbox" && Array.isArray(resultValue)) {
+    if (resultValue.includes("__BACK_KEY__") || resultValue.length === 0) {
+      throw new EscapeKeyPressed();
+    }
+  }
+  return result;
+}
+async function executeWithEscapeSupport(processor, i18n) {
+  try {
+    await processor();
+    return true;
+  } catch (error) {
+    if (error instanceof EscapeKeyPressed) {
+      console.log(
+        ansis.yellow(`
+${i18n.common.returnToPrevious || "\u8FD4\u56DE\u4E0A\u4E00\u6B65"}`)
+      );
+      return false;
+    }
+    throw error;
+  }
+}
+
+const inquirer = {
+  ...inquirer$1,
+  prompt: createEscapablePrompt,
+  createPromptModule: inquirer$1.createPromptModule
+};
+
+const version = "0.0.1";
+
+const common$1 = {
+  // Basic
+  multiSelectHint: "\uFF08\u7A7A\u683C\u9009\u62E9\uFF0Ca\u5168\u9009\uFF0Ci\u53CD\u9009\uFF0C\u56DE\u8F66\u786E\u8BA4\uFF09",
+  yes: "\u662F",
+  no: "\u5426",
+  skip: "\u8DF3\u8FC7",
+  cancelled: "\u64CD\u4F5C\u5DF2\u53D6\u6D88",
+  error: "\u9519\u8BEF",
+  complete: "\u{1F389} \u914D\u7F6E\u5B8C\u6210\uFF01\u4F7F\u7528 'claude' \u547D\u4EE4\u5F00\u59CB\u4F53\u9A8C\u3002",
+  none: "\u65E0",
+  notConfigured: "\u672A\u914D\u7F6E",
+  spaceToSelectReturn: "- \u7A7A\u683C\u9009\u62E9\uFF0C\u56DE\u8F66\u63D0\u4EA4",
+  enterChoice: "\u8BF7\u8F93\u5165\u9009\u9879\uFF0C\u56DE\u8F66\u786E\u8BA4\uFF08\u4E0D\u533A\u5206\u5927\u5C0F\u5199\uFF09",
+  invalidChoice: "\u65E0\u6548\u9009\u62E9\u3002\u8BF7\u8F93\u5165\u6709\u6548\u9009\u9879\u3002",
+  goodbye: "\u{1F44B} \u611F\u8C22\u4F7F\u7528 \u667A\u80FD\u8F6F\u4EF6\u661F\u5DE5\u5382\uFF01\u518D\u89C1\uFF01",
+  returnToMenu: "\u8FD4\u56DE\u4E3B\u83DC\u5355\uFF1F",
+  back: "\u8FD4\u56DE"
+};
+
+const language$1 = {
+  selectScriptLang: "\u9009\u62E9AICO\u663E\u793A\u8BED\u8A00",
+  selectConfigLang: "\u9009\u62E9 Claude Code \u914D\u7F6E\u8BED\u8A00",
+  selectAiOutputLang: "\u9009\u62E9 AI \u8F93\u51FA\u8BED\u8A00",
+  aiOutputLangHint: "AI \u5C06\u4F7F\u7528\u6B64\u8BED\u8A00\u56DE\u590D\u4F60\u7684\u95EE\u9898",
+  enterCustomLanguage: "\u8BF7\u8F93\u5165\u81EA\u5B9A\u4E49\u8BED\u8A00\uFF08\u4F8B\u5982\uFF1AJapanese, French \u7B49\uFF09",
+  languageChanged: "\u8BED\u8A00\u5DF2\u66F4\u6539",
+  configLangHint: {
+    "zh-CN": "\u4FBF\u4E8E\u4E2D\u6587\u7528\u6237\u81EA\u5B9A\u4E49",
+    en: "\u63A8\u8350\uFF0Ctoken \u6D88\u8017\u66F4\u4F4E"
+  },
+  updateConfigLangPrompt: "\u9009\u62E9\u914D\u7F6E\u8BED\u8A00",
+  updateConfigLangChoice: {
+    "zh-CN": "\u4E2D\u6587\u7248\u914D\u7F6E",
+    en: "\u82F1\u6587\u7248\u914D\u7F6E"
+  }
+};
+
+const installation$1 = {
+  installPrompt: "\u68C0\u6D4B\u5230 Claude Code \u672A\u5B89\u88C5\uFF0C\u662F\u5426\u81EA\u52A8\u5B89\u88C5\uFF1F",
+  installing: "\u6B63\u5728\u5B89\u88C5 Claude Code...",
+  installSuccess: "Claude Code \u5B89\u88C5\u6210\u529F",
+  alreadyInstalled: "Claude Code \u5DF2\u5B89\u88C5",
+  installFailed: "Claude Code \u5B89\u88C5\u5931\u8D25",
+  npmNotFound: "npm \u672A\u5B89\u88C5\u3002\u8BF7\u5148\u5B89\u88C5 Node.js \u548C npm\u3002",
+  // Termux specific
+  termuxDetected: "\u68C0\u6D4B\u5230 Termux \u73AF\u5883",
+  termuxInstallHint: "\u5728 Termux \u4E2D\uFF0C\u8BF7\u5148\u8FD0\u884C: pkg install nodejs \u6216 pkg install nodejs-lts",
+  termuxPathInfo: "\u4F7F\u7528 Termux \u8DEF\u5F84: {path}",
+  termuxEnvironmentInfo: "Termux \u73AF\u5883\u901A\u8FC7 pkg \u7BA1\u7406\u5668\u63D0\u4F9B Node.js \u548C npm",
+  // Windows specific  
+  windowsDetected: "\u68C0\u6D4B\u5230 Windows \u7CFB\u7EDF\uFF0C\u5C06\u81EA\u52A8\u914D\u7F6E\u517C\u5BB9\u683C\u5F0F"
+};
+
+const api$1 = {
+  // Basic API configuration
+  configureApi: "\u9009\u62E9 API \u8BA4\u8BC1\u65B9\u5F0F",
+  useAuthToken: "\u4F7F\u7528 Auth Token (OAuth \u8BA4\u8BC1)",
+  authTokenDesc: "\u9002\u7528\u4E8E\u901A\u8FC7 OAuth \u6216\u6D4F\u89C8\u5668\u767B\u5F55\u83B7\u53D6\u7684\u4EE4\u724C",
+  useApiKey: "\u4F7F\u7528 API Key (\u5BC6\u94A5\u8BA4\u8BC1)",
+  apiKeyDesc: "\u9002\u7528\u4E8E\u4ECE Anthropic Console \u83B7\u53D6\u7684 API \u5BC6\u94A5",
+  useCcrProxy: "\u4F7F\u7528 CCR \u4EE3\u7406",
+  ccrProxyDesc: "\u901A\u8FC7 Claude Code Router \u4F7F\u7528\u591A\u4E2A AI \u6A21\u578B",
+  skipApi: "\u8DF3\u8FC7\uFF08\u7A0D\u540E\u624B\u52A8\u914D\u7F6E\uFF09",
+  enterApiUrl: "\u8BF7\u8F93\u5165 API URL",
+  enterAuthToken: "\u8BF7\u8F93\u5165 Auth Token",
+  enterApiKey: "\u8BF7\u8F93\u5165 API Key",
+  apiConfigSuccess: "API \u914D\u7F6E\u5B8C\u6210",
+  // API modification
+  existingApiConfig: "\u68C0\u6D4B\u5230\u5DF2\u6709 API \u914D\u7F6E\uFF1A",
+  apiConfigUrl: "URL",
+  apiConfigKey: "Key",
+  apiConfigAuthType: "\u8BA4\u8BC1\u7C7B\u578B",
+  selectApiAction: "\u8BF7\u9009\u62E9API\u5904\u7406\u64CD\u4F5C",
+  keepExistingConfig: "\u4FDD\u7559\u73B0\u6709\u914D\u7F6E",
+  modifyAllConfig: "\u4FEE\u6539\u5168\u90E8\u914D\u7F6E",
+  modifyPartialConfig: "\u4FEE\u6539\u90E8\u5206\u914D\u7F6E",
+  selectModifyItems: "\u8BF7\u9009\u62E9\u8981\u4FEE\u6539\u7684\u9879",
+  modifyApiUrl: "\u4FEE\u6539 API URL",
+  modifyApiKey: "\u4FEE\u6539 API Key",
+  modifyAuthType: "\u4FEE\u6539\u8BA4\u8BC1\u7C7B\u578B",
+  continueModification: "\u662F\u5426\u7EE7\u7EED\u4FEE\u6539\u5176\u4ED6\u914D\u7F6E\uFF1F",
+  modificationSaved: "\u914D\u7F6E\u5DF2\u4FDD\u5B58",
+  enterNewApiUrl: "\u8BF7\u8F93\u5165\u65B0\u7684 API URL\uFF08\u5F53\u524D\uFF1A{url}\uFF09",
+  enterNewApiKey: "\u8BF7\u8F93\u5165\u65B0\u7684 API Key\uFF08\u5F53\u524D\uFF1A{key}\uFF09",
+  selectNewAuthType: "\u9009\u62E9\u65B0\u7684\u8BA4\u8BC1\u7C7B\u578B\uFF08\u5F53\u524D\uFF1A{type}\uFF09",
+  // API validation
+  apiKeyValidation: {
+    empty: "API Key \u4E0D\u80FD\u4E3A\u7A7A",
+    example: "\u793A\u4F8B\u683C\u5F0F: sk-abcdef123456_789xyz"
+  },
+  urlRequired: "URL \u4E3A\u5FC5\u586B\u9879",
+  invalidUrl: "\u65E0\u6548\u7684 URL",
+  keyRequired: "\u5BC6\u94A5\u4E3A\u5FC5\u586B\u9879",
+  invalidKeyFormat: "\u65E0\u6548\u7684\u5BC6\u94A5\u683C\u5F0F"
+};
+
+const configuration$1 = {
+  existingConfig: "\u68C0\u6D4B\u5230\u5DF2\u6709\u914D\u7F6E\u6587\u4EF6\uFF0C\u5982\u4F55\u5904\u7406\uFF1F",
+  backupAndOverwrite: "\u5907\u4EFD\u5E76\u8986\u76D6\u5168\u90E8",
+  updateDocsOnly: "\u4EC5\u66F4\u65B0\u5DE5\u4F5C\u6D41\u76F8\u5173md\u5E76\u5907\u4EFD\u65E7\u914D\u7F6E",
+  mergeConfig: "\u5408\u5E76\u914D\u7F6E",
+  backupSuccess: "\u5DF2\u5907\u4EFD\u6240\u6709\u914D\u7F6E\u6587\u4EF6\u5230",
+  copying: "\u6B63\u5728\u590D\u5236\u914D\u7F6E\u6587\u4EF6...",
+  configSuccess: "\u914D\u7F6E\u6587\u4EF6\u5DF2\u590D\u5236\u5230",
+  noExistingConfig: "\u672A\u627E\u5230\u73B0\u6709\u914D\u7F6E\u3002\u8BF7\u5148\u8FD0\u884C `aico`\u3002",
+  updatingPrompts: "\u6B63\u5728\u66F4\u65B0 Claude Code \u8BB0\u5FC6\u6587\u6863...",
+  // Model configuration
+  selectDefaultModel: "\u9009\u62E9\u9ED8\u8BA4\u6A21\u578B",
+  modelConfigSuccess: "\u9ED8\u8BA4\u6A21\u578B\u5DF2\u914D\u7F6E",
+  // AI memory configuration
+  selectMemoryOption: "\u9009\u62E9\u914D\u7F6E\u9009\u9879",
+  configureAiLanguage: "\u914D\u7F6E AI \u8F93\u51FA\u8BED\u8A00",
+  configureAiPersonality: "\u914D\u7F6E AI \u4E2A\u6027\u98CE\u683C",
+  aiLanguageConfigured: "AI \u8F93\u51FA\u8BED\u8A00\u5DF2\u914D\u7F6E",
+  // AI personality
+  selectAiPersonality: "\u9009\u62E9 AI \u4E2A\u6027\u98CE\u683C",
+  customPersonalityHint: "\u5B9A\u4E49\u4F60\u81EA\u5DF1\u7684\u4E2A\u6027",
+  enterCustomPersonality: "\u8BF7\u8F93\u5165\u81EA\u5B9A\u4E49\u4E2A\u6027\u63CF\u8FF0",
+  personalityConfigured: "AI \u4E2A\u6027\u5DF2\u914D\u7F6E",
+  existingPersonality: "\u68C0\u6D4B\u5230\u5DF2\u6709 AI \u4E2A\u6027\u914D\u7F6E",
+  currentPersonality: "\u5F53\u524D\u4E2A\u6027",
+  modifyPersonality: "\u662F\u5426\u4FEE\u6539 AI \u4E2A\u6027\u914D\u7F6E\uFF1F",
+  keepPersonality: "\u4FDD\u6301\u5F53\u524D\u4E2A\u6027\u914D\u7F6E",
+  directiveCannotBeEmpty: "\u6307\u4EE4\u4E0D\u80FD\u4E3A\u7A7A",
+  languageRequired: "\u8BED\u8A00\u4E3A\u5FC5\u586B\u9879",
+  // Cache
+  confirmClearCache: "\u786E\u8BA4\u6E05\u9664\u6240\u6709 AICO \u504F\u597D\u7F13\u5B58\uFF1F",
+  cacheCleared: "AICO \u7F13\u5B58\u5DF2\u6E05\u9664",
+  noCacheFound: "\u672A\u627E\u5230\u7F13\u5B58\u6587\u4EF6",
+  // Environment and permissions
+  selectEnvPermissionOption: "\u8BF7\u9009\u62E9\u914D\u7F6E\u9009\u9879",
+  importRecommendedEnv: "\u5BFC\u5165 AICO \u63A8\u8350\u73AF\u5883\u53D8\u91CF",
+  importRecommendedEnvDesc: "\u9690\u79C1\u4FDD\u62A4\u53D8\u91CF\u7B49",
+  importRecommendedPermissions: "\u5BFC\u5165 AICO \u63A8\u8350\u6743\u9650\u914D\u7F6E",
+  importRecommendedPermissionsDesc: "\u51E0\u4E4E\u5168\u90E8\u6743\u9650\uFF0C\u51CF\u5C11\u9891\u7E41\u8BF7\u6C42\u6743\u9650\uFF0C\u5371\u9669\u64CD\u4F5C\u7531\u89C4\u5219\u9650\u5236",
+  openSettingsJson: "\u6253\u5F00 settings.json \u624B\u52A8\u914D\u7F6E",
+  openSettingsJsonDesc: "\u9AD8\u7EA7\u7528\u6237\u81EA\u5B9A\u4E49",
+  envImportSuccess: "\u73AF\u5883\u53D8\u91CF\u5DF2\u5BFC\u5165",
+  permissionsImportSuccess: "\u6743\u9650\u914D\u7F6E\u5DF2\u5BFC\u5165",
+  openingSettingsJson: "\u6B63\u5728\u6253\u5F00 settings.json...",
+  // JSON config related
+  invalidConfiguration: "\u914D\u7F6E\u65E0\u6548",
+  failedToParseJson: "\u89E3\u6790 JSON \u6587\u4EF6\u5931\u8D25:",
+  failedToBackupConfig: "\u5907\u4EFD\u914D\u7F6E\u5931\u8D25",
+  failedToReadTemplateSettings: "\u8BFB\u53D6\u6A21\u677F\u8BBE\u7F6E\u5931\u8D25",
+  failedToMergeSettings: "\u5408\u5E76\u8BBE\u7F6E\u5931\u8D25",
+  preservingExistingSettings: "\u4FDD\u7559\u73B0\u6709\u8BBE\u7F6E",
+  memoryDirNotFound: "\u672A\u627E\u5230\u8BB0\u5FC6\u76EE\u5F55",
+  failedToSetOnboarding: "\u8BBE\u7F6E\u5F15\u5BFC\u6807\u5FD7\u5931\u8D25",
+  fixWindowsMcp: "\u4FEE\u590D Windows MCP \u914D\u7F6E\uFF1F"
+};
+
+const mcp$1 = {
+  configureMcp: "\u662F\u5426\u914D\u7F6E MCP \u670D\u52A1\uFF1F",
+  selectMcpServices: "\u9009\u62E9\u8981\u5B89\u88C5\u7684 MCP \u670D\u52A1",
+  allServices: "\u5168\u90E8\u5B89\u88C5",
+  mcpServiceInstalled: "\u5DF2\u9009\u62E9\u7684 MCP \u670D\u52A1",
+  enterExaApiKey: "\u8BF7\u8F93\u5165 Exa API Key\uFF08\u53EF\u4ECE https://dashboard.exa.ai/api-keys \u83B7\u53D6\uFF09",
+  skipMcp: "\u8DF3\u8FC7 MCP \u914D\u7F6E",
+  mcpConfigSuccess: "MCP \u670D\u52A1\u5DF2\u914D\u7F6E",
+  mcpBackupSuccess: "\u5DF2\u5907\u4EFD\u539F\u6709 MCP \u914D\u7F6E",
+  fixWindowsMcp: "\u4FEE\u590D Windows MCP \u914D\u7F6E",
+  fixWindowsMcpDesc: "\u4FEE\u590D Windows \u5E73\u53F0 MCP \u547D\u4EE4\u914D\u7F6E\u95EE\u9898",
+  windowsMcpFixed: "Windows MCP \u914D\u7F6E\u5DF2\u4FEE\u590D",
+  configureMcpServices: "\u914D\u7F6E MCP \u670D\u52A1",
+  selectMcpOption: "\u9009\u62E9 MCP \u914D\u7F6E\u9009\u9879"
+};
+
+const menu$1 = {
+  selectFunction: "\u8BF7\u9009\u62E9\u529F\u80FD",
+  menuSections: {
+    otherTools: "\u5176\u4ED6\u5DE5\u5177"
+  },
+  menuOptions: {
+    fullInit: "\u5B8C\u6574\u521D\u59CB\u5316\u914D\u7F6E",
+    importWorkflow: "\u5BFC\u5165\u5DE5\u4F5C\u6D41",
+    configureApiOrCcr: "\u914D\u7F6E API \u6216 CCR \u4EE3\u7406",
+    configureApi: "\u914D\u7F6E API",
+    configureMcp: "\u914D\u7F6E MCP",
+    configureModel: "\u914D\u7F6E\u9ED8\u8BA4\u6A21\u578B",
+    configureAiMemory: "\u914D\u7F6E Claude \u5168\u5C40\u8BB0\u5FC6",
+    configureEnvPermission: "\u5BFC\u5165\u63A8\u8350\u73AF\u5883\u53D8\u91CF\u548C\u6743\u9650\u914D\u7F6E",
+    configureCcr: "\u914D\u7F6E\u6A21\u578B\u4EE3\u7406 (CCR)",
+    ccrManagement: "CCR",
+    ccusage: "ccusage",
+    installBmad: "\u5B89\u88C5 BMad Method",
+    clearCache: "\u6E05\u9664\u504F\u597D\u7F13\u5B58",
+    changeLanguage: "\u66F4\u6539\u663E\u793A\u8BED\u8A00 / Select display language",
+    exit: "\u9000\u51FA"
+  },
+  menuDescriptions: {
+    fullInit: "\u4F1A\u4E3A\u60A8\u5B89\u88C5Claude Code\u5E76\u5BFC\u5165\u5DE5\u4F5C\u6D41\uFF0C\u4EE5\u53CA\u914D\u7F6E API \u548C\u914D\u7F6E MCP \u670D\u52A1",
+    importWorkflow: "\u4EC5\u5BFC\u5165/\u66F4\u65B0\u5DE5\u4F5C\u6D41\u76F8\u5173\u6587\u4EF6",
+    configureApiOrCcr: "\u914D\u7F6E API URL\u3001\u8BA4\u8BC1\u4FE1\u606F\u6216 CCR \u4EE3\u7406",
+    configureApi: "\u914D\u7F6E API URL \u548C\u8BA4\u8BC1\u4FE1\u606F",
+    configureMcp: "\u914D\u7F6E MCP \u670D\u52A1\uFF08\u542B Windows \u4FEE\u590D\uFF09",
+    configureModel: "\u8BBE\u7F6E\u9ED8\u8BA4\u6A21\u578B\uFF08opus/sonnet\uFF09",
+    configureAiMemory: "\u914D\u7F6E AI \u8F93\u51FA\u8BED\u8A00\u548C\u89D2\u8272\u98CE\u683C",
+    configureEnvPermission: "\u5BFC\u5165\u9690\u79C1\u4FDD\u62A4\u73AF\u5883\u53D8\u91CF\u548C\u7CFB\u7EDF\u6743\u9650\u914D\u7F6E",
+    configureCcr: "\u914D\u7F6E Claude Code Router \u4EE5\u4F7F\u7528\u591A\u4E2A AI \u6A21\u578B",
+    ccrManagement: "\u914D\u7F6E Claude Code Router \u4EE5\u4F7F\u7528\u591A\u4E2A AI \u6A21\u578B",
+    ccusage: "Claude Code \u7528\u91CF\u5206\u6790",
+    installBmad: "AI \u9A71\u52A8\u7684\u5F00\u53D1\u65B9\u6CD5\u8BBA\u6846\u67B6",
+    clearCache: "\u6E05\u9664\u504F\u597D\u8BED\u8A00\u7B49\u7F13\u5B58",
+    changeLanguage: "\u66F4\u6539\u754C\u9762\u8BED\u8A00"
+  }
+};
+
+const workflow$1 = {
+  selectWorkflowType: "\u9009\u62E9\u8981\u5B89\u88C5\u7684\u5DE5\u4F5C\u6D41\u7C7B\u578B",
+  workflowOption: {
+    featPlanUx: "\u529F\u80FD\u89C4\u5212\u548C UX \u8BBE\u8BA1 (feat + planner + ui-ux-designer)",
+    sixStepsWorkflow: "\u516D\u6B65\u5DE5\u4F5C\u6D41 (workflow)",
+    bmadWorkflow: "BMAD-Method \u6269\u5C55\u5B89\u88C5\u5668 (\u652F\u6301\u654F\u6377\u5F00\u53D1\u5DE5\u4F5C\u6D41)"
+  },
+  // BMAD workflow
+  bmadInitPrompt: "\u2728 \u8BF7\u5728\u9879\u76EE\u4E2D\u8FD0\u884C /bmad-init \u547D\u4EE4\u6765\u521D\u59CB\u5316\u6216\u66F4\u65B0 BMAD-Method \u6269\u5C55",
+  bmadInstallSuccess: "\u6210\u529F\u5B89\u88C5 BMAD-Method \u5B89\u88C5\u5668",
+  // General workflow installation
+  installingWorkflow: "\u6B63\u5728\u5B89\u88C5\u5DE5\u4F5C\u6D41",
+  installedCommand: "\u5DF2\u5B89\u88C5\u547D\u4EE4",
+  installedAgent: "\u5DF2\u5B89\u88C5\u4EE3\u7406",
+  failedToInstallCommand: "\u5B89\u88C5\u547D\u4EE4\u5931\u8D25",
+  failedToInstallAgent: "\u5B89\u88C5\u4EE3\u7406\u5931\u8D25",
+  workflowInstallSuccess: "\u5DE5\u4F5C\u6D41\u5B89\u88C5\u6210\u529F",
+  workflowInstallError: "\u5DE5\u4F5C\u6D41\u5B89\u88C5\u51FA\u9519",
+  cleaningOldFiles: "\u6E05\u7406\u65E7\u7248\u672C\u6587\u4EF6",
+  removedOldFile: "\u5DF2\u5220\u9664\u65E7\u6587\u4EF6"
+};
+
+const cli$1 = {
+  runFullInit: "\u76F4\u63A5\u8FD0\u884C\u5B8C\u6574\u521D\u59CB\u5316",
+  forceOverwrite: "\u5F3A\u5236\u8986\u76D6\u73B0\u6709\u914D\u7F6E",
+  initClaudeConfig: "\u521D\u59CB\u5316 Claude Code \u914D\u7F6E",
+  updatePromptsOnly: "\u4EC5\u66F4\u65B0 Claude Code \u63D0\u793A"
+};
+
+const bmad$1 = {
+  // BMad CLI command
+  description: "\u5B89\u88C5 BMad Method \u7528\u4E8E AI \u9A71\u52A8\u7684\u5F00\u53D1",
+  directoryOption: "\u5B89\u88C5\u7684\u76EE\u6807\u76EE\u5F55",
+  forceOption: "\u5F3A\u5236\u91CD\u65B0\u5B89\u88C5\uFF0C\u5373\u4F7F\u5DF2\u5B58\u5728",
+  versionOption: "\u8981\u5B89\u88C5\u7684\u7279\u5B9A BMad \u7248\u672C",
+  // Installation messages
+  checkingExisting: "\u6B63\u5728\u68C0\u67E5\u73B0\u6709 BMad \u5B89\u88C5...",
+  alreadyInstalled: "BMad \u5DF2\u5B89\u88C5\uFF08\u7248\u672C\uFF1A{version}\uFF09",
+  existingAction: "\u9009\u62E9\u64CD\u4F5C\uFF1A",
+  actionUpdate: "\u66F4\u65B0\u5230\u6700\u65B0\u7248\u672C",
+  actionReinstall: "\u91CD\u65B0\u5B89\u88C5",
+  actionSkip: "\u8DF3\u8FC7\u5B89\u88C5",
+  installationSkipped: "\u5DF2\u8DF3\u8FC7 BMad \u5B89\u88C5",
+  installing: "\u6B63\u5728\u5B89\u88C5 BMad Method...",
+  installSuccess: "\u2705 BMad Method \u5B89\u88C5\u6210\u529F\uFF01",
+  installFailed: "\u274C BMad Method \u5B89\u88C5\u5931\u8D25",
+  installError: "\u274C BMad \u5B89\u88C5\u9519\u8BEF",
+  nextSteps: "\u4E0B\u4E00\u6B65\uFF1A\u8FDB\u5165 {directory} \u76EE\u5F55\u5F00\u59CB\u4F7F\u7528 BMad",
+  // BMad workflow messages
+  installingBmadWorkflow: "\u6B63\u5728\u5B89\u88C5 BMAD \u5DE5\u4F5C\u6D41...",
+  bmadWorkflowInstalled: "BMAD \u5DE5\u4F5C\u6D41\u5DF2\u5B89\u88C5",
+  bmadWorkflowFailed: "\u5B89\u88C5 BMAD \u5DE5\u4F5C\u6D41\u5931\u8D25",
+  // BMad agent messages
+  installingAgent: "\u6B63\u5728\u5B89\u88C5 {agent} \u4EE3\u7406...",
+  agentInstalled: "{agent} \u4EE3\u7406\u5DF2\u5B89\u88C5",
+  agentFailed: "\u5B89\u88C5 {agent} \u4EE3\u7406\u5931\u8D25",
+  // BMad user prompts
+  selectBmadOption: "\u9009\u62E9 BMAD \u9009\u9879",
+  confirmInstallBmad: "\u786E\u8BA4\u5B89\u88C5 BMAD \u5DE5\u4F5C\u6D41\uFF1F",
+  bmadInstallComplete: "BMAD \u5B89\u88C5\u5B8C\u6210",
+  // BMad log messages
+  checkingBmadDependencies: "\u68C0\u67E5 BMAD \u4F9D\u8D56...",
+  bmadDependenciesMet: "BMAD \u4F9D\u8D56\u6EE1\u8DB3",
+  bmadDependenciesMissing: "\u7F3A\u5C11 BMAD \u4F9D\u8D56\uFF1A{deps}",
+  // BMad commands
+  runningBmadCommand: "\u6267\u884C BMAD \u547D\u4EE4\uFF1A{command}",
+  bmadCommandSuccess: "BMAD \u547D\u4EE4\u6267\u884C\u6210\u529F",
+  bmadCommandFailed: "BMAD \u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF1A{error}",
+  // BMad configuration
+  configuringBmad: "\u914D\u7F6E BMAD \u8BBE\u7F6E...",
+  bmadConfigured: "BMAD \u5DF2\u914D\u7F6E",
+  bmadConfigFailed: "BMAD \u914D\u7F6E\u5931\u8D25"
+};
+
+const errors$1 = {
+  // General errors
+  failedToSetOnboarding: "\u8BBE\u7F6E\u5165\u95E8\u5B8C\u6210\u6807\u5FD7\u5931\u8D25\uFF1A",
+  failedToWriteMcpConfig: "\u5199\u5165 MCP \u914D\u7F6E\u5931\u8D25\uFF1A",
+  templateDirNotFound: "\u6A21\u677F\u76EE\u5F55\u672A\u627E\u5230\uFF1A",
+  failedToReadTemplateSettings: "\u8BFB\u53D6\u6A21\u677F settings.json \u5931\u8D25\uFF1A",
+  failedToMergeSettings: "\u5408\u5E76 settings.json \u5931\u8D25\uFF1A",
+  preservingExistingSettings: "\u7531\u4E8E\u5408\u5E76\u9519\u8BEF\uFF0C\u4FDD\u7559\u73B0\u6709\u7684 settings.json",
+  // File system errors
+  failedToReadFile: "\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25\uFF1A",
+  failedToWriteFile: "\u5199\u5165\u6587\u4EF6\u5931\u8D25\uFF1A",
+  failedToCopyFile: "\u590D\u5236\u6587\u4EF6\u5931\u8D25\uFF1A",
+  failedToRemoveFile: "\u5220\u9664\u6587\u4EF6\u5931\u8D25\uFF1A",
+  failedToReadDirectory: "\u8BFB\u53D6\u76EE\u5F55\u5931\u8D25\uFF1A",
+  failedToGetStats: "\u83B7\u53D6\u6587\u4EF6\u72B6\u6001\u5931\u8D25\uFF1A",
+  sourceDirNotExist: "\u6E90\u76EE\u5F55\u4E0D\u5B58\u5728\uFF1A",
+  memoryDirNotFound: "\u8BB0\u5FC6\u76EE\u5F55\u672A\u627E\u5230\uFF1A",
+  // JSON config errors
+  invalidConfiguration: "\u914D\u7F6E\u65E0\u6548\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u503C",
+  failedToParseJson: "\u89E3\u6790 JSON \u6587\u4EF6\u5931\u8D25\uFF1A",
+  failedToBackupConfig: "\u5907\u4EFD\u914D\u7F6E\u6587\u4EF6\u5931\u8D25\uFF1A",
+  invalidEnvConfig: "\u65E0\u6548\u7684 env \u914D\u7F6E\uFF1A\u671F\u671B\u5BF9\u8C61",
+  invalidApiUrl: "\u65E0\u6548\u7684 ANTHROPIC_BASE_URL\uFF1A\u671F\u671B\u5B57\u7B26\u4E32",
+  invalidApiKey: "\u65E0\u6548\u7684 ANTHROPIC_API_KEY\uFF1A\u671F\u671B\u5B57\u7B26\u4E32",
+  invalidAuthToken: "\u65E0\u6548\u7684 ANTHROPIC_AUTH_TOKEN\uFF1A\u671F\u671B\u5B57\u7B26\u4E32",
+  invalidPermissionsConfig: "\u65E0\u6548\u7684\u6743\u9650\u914D\u7F6E\uFF1A\u671F\u671B\u5BF9\u8C61",
+  invalidPermissionsAllow: "\u65E0\u6548\u7684 permissions.allow\uFF1A\u671F\u671B\u6570\u7EC4",
+  // MCP errors
+  failedToAddOnboardingFlag: "\u6DFB\u52A0 hasCompletedOnboarding \u6807\u5FD7\u5931\u8D25\uFF1A",
+  // AI personality errors
+  failedToApplyPersonality: "\u5E94\u7528\u4E2A\u6027\u6307\u4EE4\u5931\u8D25\uFF1A"
+};
+
+const tools$1 = {
+  // CCUsage
+  runningCcusage: "\u6B63\u5728\u8FD0\u884C Claude Code \u7528\u91CF\u5206\u6790\u5DE5\u5177...",
+  ccusageDescription: "\u5206\u6790\u4EE4\u724C\u4F7F\u7528\u91CF\u548C\u6210\u672C - https://github.com/ryoppippi/ccusage",
+  selectAnalysisMode: "\u9009\u62E9\u5206\u6790\u6A21\u5F0F:",
+  ccusageModes: {
+    daily: "\u6BCF\u65E5\u4F7F\u7528\u91CF",
+    monthly: "\u6BCF\u6708\u4F7F\u7528\u91CF",
+    session: "\u4F1A\u8BDD\u7EDF\u8BA1",
+    blocks: "\u533A\u5757\u7EDF\u8BA1",
+    custom: "\u81EA\u5B9A\u4E49\u53C2\u6570"
+  },
+  enterCustomArgs: "\u8F93\u5165\u81EA\u5B9A\u4E49\u53C2\u6570 (\u4F8B\u5982: daily --json):",
+  pressEnterToContinue: "\u6309 Enter \u952E\u7EE7\u7EED...",
+  ccusageFailed: "\u8FD0\u884C ccusage \u5931\u8D25",
+  checkNetworkConnection: "\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5\u5E76\u91CD\u8BD5",
+  errorDetails: "\u9519\u8BEF\u8BE6\u60C5:"
+};
+
+const ccrMessages$1 = {
+  // Installation
+  installingCcr: "\u6B63\u5728\u5B89\u88C5 Claude Code Router...",
+  ccrInstallSuccess: "Claude Code Router \u5B89\u88C5\u6210\u529F",
+  ccrInstallFailed: "\u5B89\u88C5 Claude Code Router \u5931\u8D25",
+  ccrAlreadyInstalled: "Claude Code Router \u5DF2\u5B89\u88C5",
+  // Configuration
+  configureCcr: "\u914D\u7F6E\u6A21\u578B\u4EE3\u7406 (CCR)",
+  useCcrProxy: "\u4F7F\u7528 CCR \u4EE3\u7406",
+  ccrProxyDesc: "\u901A\u8FC7 Claude Code Router \u8FDE\u63A5\u591A\u4E2A AI \u6A21\u578B",
+  fetchingPresets: "\u6B63\u5728\u83B7\u53D6\u63D0\u4F9B\u5546\u9884\u8BBE...",
+  noPresetsAvailable: "\u6CA1\u6709\u53EF\u7528\u7684\u9884\u8BBE",
+  selectCcrPreset: "\u9009\u62E9\u4E00\u4E2A\u63D0\u4F9B\u5546\u9884\u8BBE\uFF1A",
+  keyRequired: "API \u5BC6\u94A5\u4E0D\u80FD\u4E3A\u7A7A",
+  // Existing config
+  existingCcrConfig: "\u53D1\u73B0\u73B0\u6709\u7684 CCR \u914D\u7F6E",
+  overwriteCcrConfig: "\u662F\u5426\u5907\u4EFD\u73B0\u6709\u7684 CCR \u914D\u7F6E\u5E76\u91CD\u65B0\u914D\u7F6E\uFF1F",
+  keepingExistingConfig: "\u4FDD\u7559\u73B0\u6709\u914D\u7F6E",
+  backupCcrConfig: "\u6B63\u5728\u5907\u4EFD\u73B0\u6709\u7684 CCR \u914D\u7F6E...",
+  ccrBackupSuccess: "CCR \u914D\u7F6E\u5DF2\u5907\u4EFD\u5230\uFF1A{path}",
+  ccrBackupFailed: "\u5907\u4EFD CCR \u914D\u7F6E\u5931\u8D25",
+  // Model selection
+  selectDefaultModelForProvider: "\u9009\u62E9 {provider} \u7684\u9ED8\u8BA4\u6A21\u578B\uFF1A",
+  enterApiKeyForProvider: "\u8BF7\u8F93\u5165 {provider} \u7684 API \u5BC6\u94A5\uFF1A",
+  // Skip option
+  skipOption: "\u8DF3\u8FC7\uFF0C\u5728 CCR \u4E2D\u81EA\u884C\u914D\u7F6E",
+  skipConfiguring: "\u8DF3\u8FC7\u9884\u8BBE\u914D\u7F6E\uFF0C\u5C06\u521B\u5EFA\u7A7A\u914D\u7F6E\u6846\u67B6",
+  // Success/Error messages
+  ccrConfigSuccess: "CCR \u914D\u7F6E\u5DF2\u4FDD\u5B58",
+  proxyConfigSuccess: "\u4EE3\u7406\u8BBE\u7F6E\u5DF2\u914D\u7F6E",
+  ccrConfigFailed: "\u914D\u7F6E CCR \u5931\u8D25",
+  ccrSetupComplete: "CCR \u8BBE\u7F6E\u5B8C\u6210",
+  fetchPresetsError: "\u83B7\u53D6\u63D0\u4F9B\u5546\u9884\u8BBE\u5931\u8D25",
+  failedToStartCcrService: "\u542F\u52A8 CCR \u670D\u52A1\u5931\u8D25",
+  errorStartingCcrService: "\u542F\u52A8 CCR \u670D\u52A1\u65F6\u51FA\u9519",
+  // CCR service status
+  ccrRestartSuccess: "CCR \u670D\u52A1\u5DF2\u91CD\u542F",
+  ccrRestartFailed: "CCR \u670D\u52A1\u91CD\u542F\u5931\u8D25",
+  // Configuration tips
+  configTips: "\u914D\u7F6E\u63D0\u793A",
+  useClaudeCommand: "\u8BF7\u4F7F\u7528 claude \u547D\u4EE4\u542F\u52A8 Claude Code\uFF08\u800C\u975E ccr code\uFF09",
+  advancedConfigTip: "\u60A8\u53EF\u4EE5\u4F7F\u7528 ccr ui \u547D\u4EE4\u8FDB\u884C\u66F4\u9AD8\u7EA7\u7684\u914D\u7F6E",
+  manualConfigTip: "\u624B\u52A8\u4FEE\u6539\u914D\u7F6E\u6587\u4EF6\u540E\uFF0C\u8BF7\u6267\u884C ccr restart \u4F7F\u914D\u7F6E\u751F\u6548",
+  // CCR Menu
+  ccrMenuTitle: "CCR - Claude Code Router \u7BA1\u7406",
+  ccrMenuOptions: {
+    initCcr: "\u521D\u59CB\u5316 CCR",
+    startUi: "\u542F\u52A8 CCR UI",
+    checkStatus: "\u67E5\u8BE2 CCR \u72B6\u6001",
+    restart: "\u91CD\u542F CCR",
+    start: "\u542F\u52A8 CCR",
+    stop: "\u505C\u6B62 CCR",
+    back: "\u8FD4\u56DE\u4E3B\u83DC\u5355"
+  },
+  ccrMenuDescriptions: {
+    initCcr: "\u5B89\u88C5\u5E76\u914D\u7F6E CCR",
+    startUi: "\u6253\u5F00 Web \u754C\u9762\u7BA1\u7406 CCR",
+    checkStatus: "\u67E5\u770B CCR \u670D\u52A1\u8FD0\u884C\u72B6\u6001",
+    restart: "\u91CD\u542F CCR \u670D\u52A1",
+    start: "\u542F\u52A8 CCR \u670D\u52A1",
+    stop: "\u505C\u6B62 CCR \u670D\u52A1"
+  },
+  // Command execution messages
+  startingCcrUi: "\u6B63\u5728\u542F\u52A8 CCR UI...",
+  ccrUiStarted: "CCR UI \u5DF2\u542F\u52A8",
+  checkingCcrStatus: "\u6B63\u5728\u67E5\u8BE2 CCR \u72B6\u6001...",
+  ccrStatusTitle: "CCR \u72B6\u6001\u4FE1\u606F\uFF1A",
+  restartingCcr: "\u6B63\u5728\u91CD\u542F CCR...",
+  ccrRestarted: "CCR \u5DF2\u91CD\u542F",
+  startingCcr: "\u6B63\u5728\u542F\u52A8 CCR...",
+  ccrStarted: "CCR \u5DF2\u542F\u52A8",
+  stoppingCcr: "\u6B63\u5728\u505C\u6B62 CCR...",
+  ccrStopped: "CCR \u5DF2\u505C\u6B62",
+  ccrCommandFailed: "\u6267\u884C CCR \u547D\u4EE4\u5931\u8D25",
+  // Configuration check messages
+  ccrNotConfigured: "CCR \u5C1A\u672A\u914D\u7F6E\u3002\u8BF7\u5148\u521D\u59CB\u5316 CCR\u3002",
+  pleaseInitFirst: "\u8BF7\u9009\u62E9\u9009\u9879 1 \u6765\u521D\u59CB\u5316 CCR\u3002",
+  // UI API Key messages
+  ccrUiApiKey: "CCR UI \u767B\u5F55\u5BC6\u94A5",
+  ccrUiApiKeyHint: "\u4F7F\u7528\u6B64\u5BC6\u94A5\u767B\u5F55 CCR UI \u754C\u9762"
+};
+
+const zhCN = {
+  common: common$1,
+  language: language$1,
+  installation: installation$1,
+  api: api$1,
+  configuration: configuration$1,
+  mcp: mcp$1,
+  menu: menu$1,
+  workflow: workflow$1,
+  cli: cli$1,
+  bmad: bmad$1,
+  errors: errors$1,
+  tools: tools$1,
+  ccr: ccrMessages$1
+};
+
+const common = {
+  // Basic
+  multiSelectHint: " (Space to select, a to select all, i to invert, Enter to confirm)",
+  yes: "Yes",
+  no: "No",
+  skip: "Skip",
+  cancelled: "Operation cancelled",
+  error: "Error",
+  complete: "\u{1F389} Setup complete! Use 'claude' command to start.",
+  none: "None",
+  notConfigured: "Not configured",
+  spaceToSelectReturn: "- Space to select. Return to submit",
+  enterChoice: "Enter your choice and press enter (case-insensitive)",
+  invalidChoice: "Invalid choice. Please enter a valid option.",
+  goodbye: "\u{1F44B} Thanks for using AICO! Goodbye!",
+  returnToMenu: "Return to main menu?",
+  back: "Back"
+};
+
+const language = {
+  selectScriptLang: "Select AICO display language",
+  selectConfigLang: "Select Claude Code configuration language",
+  selectAiOutputLang: "Select AI output language",
+  aiOutputLangHint: "AI will respond to you in this language",
+  enterCustomLanguage: "Enter custom language (e.g., Japanese, French, etc.)",
+  languageChanged: "Language changed",
+  configLangHint: {
+    "zh-CN": "easier for Chinese users to customize",
+    en: "recommended, lower token consumption"
+  },
+  updateConfigLangPrompt: "Select configuration language",
+  updateConfigLangChoice: {
+    "zh-CN": "Chinese configuration",
+    en: "English configuration"
+  }
+};
+
+const installation = {
+  installPrompt: "Claude Code not found. Install automatically?",
+  installing: "Installing Claude Code...",
+  installSuccess: "Claude Code installed successfully",
+  alreadyInstalled: "Claude Code is already installed",
+  installFailed: "Failed to install Claude Code",
+  npmNotFound: "npm is not installed. Please install Node.js and npm first.",
+  // Termux specific
+  termuxDetected: "Termux environment detected",
+  termuxInstallHint: "In Termux, please run first: pkg install nodejs or pkg install nodejs-lts",
+  termuxPathInfo: "Using Termux path: {path}",
+  termuxEnvironmentInfo: "Termux environment provides Node.js and npm through pkg manager",
+  // Windows specific
+  windowsDetected: "Windows detected, will configure compatible format"
+};
+
+const api = {
+  // Basic API configuration
+  configureApi: "Select API authentication method",
+  useAuthToken: "Use Auth Token (OAuth authentication)",
+  authTokenDesc: "For tokens obtained via OAuth or browser login",
+  useApiKey: "Use API Key (Key authentication)",
+  apiKeyDesc: "For API keys from Anthropic Console",
+  useCcrProxy: "Use CCR Proxy",
+  ccrProxyDesc: "Use multiple AI models via Claude Code Router",
+  skipApi: "Skip (configure manually later)",
+  enterApiUrl: "Enter API URL",
+  enterAuthToken: "Enter Auth Token",
+  enterApiKey: "Enter API Key",
+  apiConfigSuccess: "API configured",
+  // API modification
+  existingApiConfig: "Existing API configuration detected:",
+  apiConfigUrl: "URL",
+  apiConfigKey: "Key",
+  apiConfigAuthType: "Auth Type",
+  selectApiAction: "Select API processing operation",
+  keepExistingConfig: "Keep existing configuration",
+  modifyAllConfig: "Modify all configuration",
+  modifyPartialConfig: "Modify partial configuration",
+  selectModifyItems: "Select items to modify",
+  modifyApiUrl: "Modify API URL",
+  modifyApiKey: "Modify API Key",
+  modifyAuthType: "Modify auth type",
+  continueModification: "Continue modifying other configurations?",
+  modificationSaved: "Configuration saved",
+  enterNewApiUrl: "Enter new API URL (current: {url})",
+  enterNewApiKey: "Enter new API Key (current: {key})",
+  selectNewAuthType: "Select new auth type (current: {type})",
+  // API validation
+  apiKeyValidation: {
+    empty: "API Key cannot be empty",
+    example: "Example format: sk-abcdef123456_789xyz"
+  },
+  urlRequired: "URL is required",
+  invalidUrl: "Invalid URL",
+  keyRequired: "Key is required",
+  invalidKeyFormat: "Invalid key format"
+};
+
+const configuration = {
+  existingConfig: "Existing config detected. How to proceed?",
+  backupAndOverwrite: "Backup and overwrite all",
+  updateDocsOnly: "Update workflow-related md files only with backup",
+  mergeConfig: "Merge config",
+  backupSuccess: "All config files backed up to",
+  copying: "Copying configuration files...",
+  configSuccess: "Config files copied to",
+  noExistingConfig: "No existing configuration found. Please run `aico` first.",
+  updatingPrompts: "Updating Claude Code memory documents...",
+  // Model configuration
+  selectDefaultModel: "Select default model",
+  modelConfigSuccess: "Default model configured",
+  // AI memory configuration
+  selectMemoryOption: "Select configuration option",
+  configureAiLanguage: "Configure AI output language",
+  configureAiPersonality: "Configure AI personality",
+  aiLanguageConfigured: "AI output language configured",
+  // AI personality
+  selectAiPersonality: "Select AI personality",
+  customPersonalityHint: "Define your own personality",
+  enterCustomPersonality: "Enter custom personality description",
+  personalityConfigured: "AI personality configured",
+  existingPersonality: "Existing AI personality configuration",
+  currentPersonality: "Current personality",
+  modifyPersonality: "Modify AI personality?",
+  keepPersonality: "Keeping existing personality",
+  directiveCannotBeEmpty: "Directive cannot be empty",
+  languageRequired: "Language is required",
+  // Cache
+  confirmClearCache: "Confirm clear all AICO preference cache?",
+  cacheCleared: "AICO cache cleared",
+  noCacheFound: "No cache file found",
+  // Environment and permissions
+  selectEnvPermissionOption: "Select configuration option",
+  importRecommendedEnv: "Import AICO recommended environment variables",
+  importRecommendedEnvDesc: "Privacy protection variables, etc.",
+  importRecommendedPermissions: "Import AICO recommended permissions",
+  importRecommendedPermissionsDesc: "Almost all permissions, reduce frequent permission requests, dangerous ops limited by rules",
+  openSettingsJson: "Open settings.json for manual configuration",
+  openSettingsJsonDesc: "Advanced user customization",
+  envImportSuccess: "Environment variables imported",
+  permissionsImportSuccess: "Permissions imported",
+  openingSettingsJson: "Opening settings.json...",
+  // JSON config related
+  invalidConfiguration: "Invalid configuration",
+  failedToParseJson: "Failed to parse JSON file:",
+  failedToBackupConfig: "Failed to backup config",
+  failedToReadTemplateSettings: "Failed to read template settings",
+  failedToMergeSettings: "Failed to merge settings",
+  preservingExistingSettings: "Preserving existing settings",
+  memoryDirNotFound: "Memory directory not found",
+  failedToSetOnboarding: "Failed to set onboarding flag",
+  fixWindowsMcp: "Fix Windows MCP configuration?"
+};
+
+const mcp = {
+  configureMcp: "Configure MCP services?",
+  selectMcpServices: "Select MCP services to install",
+  allServices: "Install all",
+  mcpServiceInstalled: "Selected MCP services",
+  enterExaApiKey: "Enter Exa API Key (get from https://dashboard.exa.ai/api-keys)",
+  skipMcp: "Skip MCP configuration",
+  mcpConfigSuccess: "MCP services configured",
+  mcpBackupSuccess: "Original MCP config backed up",
+  fixWindowsMcp: "Fix Windows MCP Configuration",
+  fixWindowsMcpDesc: "Fix Windows platform MCP command configuration issues",
+  windowsMcpFixed: "Windows MCP configuration fixed",
+  configureMcpServices: "Configure MCP Services",
+  selectMcpOption: "Select MCP configuration option"
+};
+
+const menu = {
+  selectFunction: "Select function",
+  menuSections: {
+    otherTools: "Other Tools"
+  },
+  menuOptions: {
+    fullInit: "Full initialization",
+    importWorkflow: "Import workflow",
+    configureApiOrCcr: "Configure API / CCR proxy",
+    configureApi: "Configure API",
+    configureMcp: "Configure MCP",
+    configureModel: "Configure default model",
+    configureAiMemory: "Configure Claude global memory",
+    configureEnvPermission: "Import recommended environment variables and permissions",
+    configureCcr: "Configure Model Proxy (CCR)",
+    ccrManagement: "CCR",
+    ccusage: "ccusage",
+    installBmad: "Install BMad Method",
+    clearCache: "Clear preference cache",
+    changeLanguage: "Select display language / \u66F4\u6539\u663E\u793A\u8BED\u8A00",
+    exit: "Exit"
+  },
+  menuDescriptions: {
+    fullInit: "Install Claude Code + Import workflow + Configure API or CCR proxy + Configure MCP services",
+    importWorkflow: "Import/update workflow-related files only",
+    configureApiOrCcr: "Configure API URL, authentication or CCR proxy",
+    configureApi: "Configure API URL and authentication",
+    configureMcp: "Configure MCP services (includes Windows fix)",
+    configureModel: "Set default model (opus/sonnet)",
+    configureAiMemory: "Configure AI output language and personality",
+    configureEnvPermission: "Import privacy protection environment variables and system permissions",
+    configureCcr: "Configure Claude Code Router to use multiple AI models",
+    ccrManagement: "Configure Claude Code Router to use multiple AI models",
+    ccusage: "Claude Code usage analysis",
+    installBmad: "AI-driven development methodology framework",
+    clearCache: "Clear preference language and other caches",
+    changeLanguage: "Change AICO interface language"
+  }
+};
+
+const workflow = {
+  selectWorkflowType: "Select workflow type to install",
+  workflowOption: {
+    featPlanUx: "Feature Planning and UX Design (feat + planner + ui-ux-designer)",
+    sixStepsWorkflow: "Six Steps Workflow (workflow)",
+    bmadWorkflow: "BMAD-Method Extension Installer (Agile Development Workflow)"
+  },
+  // BMAD workflow
+  bmadInitPrompt: "\u2728 Please run /bmad-init command in your project to initialize or update BMAD-Method extension",
+  bmadInstallSuccess: "Successfully installed BMAD-Method installer",
+  // General workflow installation
+  installingWorkflow: "Installing workflow",
+  installedCommand: "Installed command",
+  installedAgent: "Installed agent",
+  failedToInstallCommand: "Failed to install command",
+  failedToInstallAgent: "Failed to install agent",
+  workflowInstallSuccess: "workflow installed successfully",
+  workflowInstallError: "workflow installation had errors",
+  cleaningOldFiles: "Cleaning up old version files",
+  removedOldFile: "Removed old file"
+};
+
+const cli = {
+  runFullInit: "Run full initialization directly",
+  forceOverwrite: "Force overwrite existing configuration",
+  initClaudeConfig: "Initialize Claude Code configuration",
+  updatePromptsOnly: "Update Claude Code prompts only"
+};
+
+const bmad = {
+  // BMad CLI command
+  description: "Install BMad Method for AI-driven development",
+  directoryOption: "Target directory for installation",
+  forceOption: "Force reinstall even if already exists",
+  versionOption: "Specific BMad version to install",
+  // Installation messages
+  checkingExisting: "Checking for existing BMad installation...",
+  alreadyInstalled: "BMad is already installed (version: {version})",
+  existingAction: "Choose an action:",
+  actionUpdate: "Update to latest version",
+  actionReinstall: "Reinstall",
+  actionSkip: "Skip installation",
+  installationSkipped: "BMad installation skipped",
+  installing: "Installing BMad Method...",
+  installSuccess: "\u2705 BMad Method installed successfully!",
+  installFailed: "\u274C BMad Method installation failed",
+  installError: "\u274C BMad installation error",
+  nextSteps: "Next steps: Navigate to {directory} to start using BMad",
+  // BMad workflow messages
+  installingBmadWorkflow: "Installing BMAD workflow...",
+  bmadWorkflowInstalled: "BMAD workflow installed",
+  bmadWorkflowFailed: "Failed to install BMAD workflow",
+  // BMad agent messages
+  installingAgent: "Installing {agent} agent...",
+  agentInstalled: "{agent} agent installed",
+  agentFailed: "Failed to install {agent} agent",
+  // BMad user prompts
+  selectBmadOption: "Select BMAD option",
+  confirmInstallBmad: "Confirm install BMAD workflow?",
+  bmadInstallComplete: "BMAD installation complete",
+  // BMad log messages
+  checkingBmadDependencies: "Checking BMAD dependencies...",
+  bmadDependenciesMet: "BMAD dependencies met",
+  bmadDependenciesMissing: "Missing BMAD dependencies: {deps}",
+  // BMad commands
+  runningBmadCommand: "Running BMAD command: {command}",
+  bmadCommandSuccess: "BMAD command executed successfully",
+  bmadCommandFailed: "BMAD command failed: {error}",
+  // BMad configuration
+  configuringBmad: "Configuring BMAD settings...",
+  bmadConfigured: "BMAD configured",
+  bmadConfigFailed: "BMAD configuration failed"
+};
+
+const errors = {
+  // General errors
+  failedToSetOnboarding: "Failed to set onboarding completion flag:",
+  failedToWriteMcpConfig: "Failed to write MCP config:",
+  templateDirNotFound: "Template directory not found:",
+  failedToReadTemplateSettings: "Failed to read template settings.json:",
+  failedToMergeSettings: "Failed to merge settings.json:",
+  preservingExistingSettings: "Preserving existing settings.json due to merge error",
+  // File system errors
+  failedToReadFile: "Failed to read file:",
+  failedToWriteFile: "Failed to write file:",
+  failedToCopyFile: "Failed to copy file:",
+  failedToRemoveFile: "Failed to remove file:",
+  failedToReadDirectory: "Failed to read directory:",
+  failedToGetStats: "Failed to get stats for:",
+  sourceDirNotExist: "Source directory does not exist:",
+  memoryDirNotFound: "Memory directory not found:",
+  // JSON config errors
+  invalidConfiguration: "Invalid configuration, using default value",
+  failedToParseJson: "Failed to parse JSON file:",
+  failedToBackupConfig: "Failed to backup config file:",
+  invalidEnvConfig: "Invalid env configuration: expected object",
+  invalidApiUrl: "Invalid ANTHROPIC_BASE_URL: expected string",
+  invalidApiKey: "Invalid ANTHROPIC_API_KEY: expected string",
+  invalidAuthToken: "Invalid ANTHROPIC_AUTH_TOKEN: expected string",
+  invalidPermissionsConfig: "Invalid permissions configuration: expected object",
+  invalidPermissionsAllow: "Invalid permissions.allow: expected array",
+  // MCP errors
+  failedToAddOnboardingFlag: "Failed to add hasCompletedOnboarding flag:",
+  // AI personality errors
+  failedToApplyPersonality: "Failed to apply personality directive:"
+};
+
+const tools = {
+  // CCUsage
+  runningCcusage: "Running Claude Code usage analysis tool...",
+  ccusageDescription: "Analyze token usage and costs - https://github.com/ryoppippi/ccusage",
+  selectAnalysisMode: "Select analysis mode:",
+  ccusageModes: {
+    daily: "Daily usage",
+    monthly: "Monthly usage",
+    session: "Session statistics",
+    blocks: "Block statistics",
+    custom: "Custom parameters"
+  },
+  enterCustomArgs: "Enter custom arguments (e.g., daily --json):",
+  pressEnterToContinue: "Press Enter to continue...",
+  ccusageFailed: "Failed to run ccusage",
+  checkNetworkConnection: "Please check your network connection and try again",
+  errorDetails: "Error details:"
+};
+
+const ccrMessages = {
+  // Installation
+  installingCcr: "Installing Claude Code Router...",
+  ccrInstallSuccess: "Claude Code Router installed successfully",
+  ccrInstallFailed: "Failed to install Claude Code Router",
+  ccrAlreadyInstalled: "Claude Code Router is already installed",
+  // Configuration
+  configureCcr: "Configure Model Proxy (CCR)",
+  useCcrProxy: "Use CCR Proxy",
+  ccrProxyDesc: "Connect to multiple AI models via Claude Code Router",
+  fetchingPresets: "Fetching provider presets...",
+  noPresetsAvailable: "No presets available",
+  selectCcrPreset: "Select a provider preset:",
+  keyRequired: "API key is required",
+  // Existing config
+  existingCcrConfig: "Existing CCR configuration found",
+  overwriteCcrConfig: "Backup existing CCR configuration and reconfigure?",
+  keepingExistingConfig: "Keeping existing configuration",
+  backupCcrConfig: "Backing up existing CCR configuration...",
+  ccrBackupSuccess: "CCR configuration backed up to: {path}",
+  ccrBackupFailed: "Failed to backup CCR configuration",
+  // Model selection
+  selectDefaultModelForProvider: "Select default model for {provider}:",
+  enterApiKeyForProvider: "Enter API key for {provider}:",
+  // Skip option
+  skipOption: "Skip, configure in CCR manually",
+  skipConfiguring: "Skipping preset configuration, will create empty configuration framework",
+  // Success/Error messages
+  ccrConfigSuccess: "CCR configuration saved",
+  proxyConfigSuccess: "Proxy settings configured",
+  ccrConfigFailed: "Failed to configure CCR",
+  ccrSetupComplete: "CCR setup complete",
+  fetchPresetsError: "Failed to fetch provider presets",
+  failedToStartCcrService: "Failed to start CCR service",
+  errorStartingCcrService: "Error starting CCR service",
+  // CCR service status
+  ccrRestartSuccess: "CCR service restarted",
+  ccrRestartFailed: "Failed to restart CCR service",
+  // Configuration tips
+  configTips: "Configuration Tips",
+  useClaudeCommand: "Use the claude command to start Claude Code (not ccr code)",
+  advancedConfigTip: "You can use the ccr ui command for advanced configuration",
+  manualConfigTip: "After manually modifying the configuration file, run ccr restart to apply changes",
+  // CCR Menu
+  ccrMenuTitle: "CCR - Claude Code Router Management",
+  ccrMenuOptions: {
+    initCcr: "Initialize CCR",
+    startUi: "Start CCR UI",
+    checkStatus: "Check CCR Status",
+    restart: "Restart CCR",
+    start: "Start CCR",
+    stop: "Stop CCR",
+    back: "Back to Main Menu"
+  },
+  ccrMenuDescriptions: {
+    initCcr: "Install and configure CCR",
+    startUi: "Open web interface to manage CCR",
+    checkStatus: "View CCR service status",
+    restart: "Restart CCR service",
+    start: "Start CCR service",
+    stop: "Stop CCR service"
+  },
+  // Command execution messages
+  startingCcrUi: "Starting CCR UI...",
+  ccrUiStarted: "CCR UI started",
+  checkingCcrStatus: "Checking CCR status...",
+  ccrStatusTitle: "CCR Status:",
+  restartingCcr: "Restarting CCR...",
+  ccrRestarted: "CCR restarted",
+  startingCcr: "Starting CCR...",
+  ccrStarted: "CCR started",
+  stoppingCcr: "Stopping CCR...",
+  ccrStopped: "CCR stopped",
+  ccrCommandFailed: "Failed to execute CCR command",
+  // Configuration check messages
+  ccrNotConfigured: "CCR is not configured yet. Please initialize CCR first.",
+  pleaseInitFirst: "Please select option 1 to initialize CCR.",
+  // UI API Key messages
+  ccrUiApiKey: "CCR UI API Key",
+  ccrUiApiKeyHint: "Use this API key to login to CCR UI"
+};
+
+const en = {
+  common,
+  language,
+  installation,
+  api,
+  configuration,
+  mcp,
+  menu,
+  workflow,
+  cli,
+  bmad,
+  errors,
+  tools,
+  ccr: ccrMessages
+};
+
+const I18N$1 = {
+  "zh-CN": zhCN,
+  en
+};
+function getTranslation(lang) {
+  return I18N$1[lang];
+}
+
+const CLAUDE_DIR = join(homedir(), ".claude");
+const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
+const CLAUDE_MD_FILE = join(CLAUDE_DIR, "CLAUDE.md");
+const ClAUDE_CONFIG_FILE = join(homedir(), ".claude.json");
+const LEGACY_AICO_CONFIG_FILE = join(homedir(), ".aico.json");
+const AICO_CONFIG_FILE = join(CLAUDE_DIR, ".aico-config.json");
+const SUPPORTED_LANGS = ["zh-CN", "en"];
+const LANG_LABELS = {
+  "zh-CN": "\u7B80\u4F53\u4E2D\u6587",
+  en: "English"
+};
+const AI_OUTPUT_LANGUAGES = {
+  "zh-CN": {
+    label: "\u7B80\u4F53\u4E2D\u6587",
+    directive: "Always respond in Chinese-simplified"
+  },
+  en: { label: "English", directive: "Always respond in English" },
+  custom: { label: "Custom", directive: "" }
+};
+const I18N = I18N$1;
+const MCP_SERVICES = [
+  {
+    id: "intention-coding",
+    name: { "zh-CN": "Intention Coding", en: "Intention Coding" },
+    description: {
+      "zh-CN": "\u667A\u80FD\u8F6F\u4EF6\u661F\u5DE5\u5382mcp\u670D\u52A1-\u667A\u80FD\u4EE3\u7801\u751F\u6210\u548C\u7F16\u7A0B\u8F85\u52A9\u5DE5\u5177",
+      en: "Intelligent code generation and programming assistance"
+    },
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "intention-coding"],
+      env: {}
+    }
+  },
+  {
+    id: "context7",
+    name: { "zh-CN": "Context7 \u6587\u6863\u67E5\u8BE2", en: "Context7 Docs" },
+    description: {
+      "zh-CN": "\u67E5\u8BE2\u6700\u65B0\u7684\u5E93\u6587\u6863\u548C\u4EE3\u7801\u793A\u4F8B",
+      en: "Query latest library documentation and code examples"
+    },
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@upstash/context7-mcp"],
+      env: {}
+    }
+  },
+  {
+    id: "mcp-deepwiki",
+    name: { "zh-CN": "DeepWiki", en: "DeepWiki" },
+    description: {
+      "zh-CN": "\u67E5\u8BE2 GitHub \u4ED3\u5E93\u6587\u6863\u548C\u793A\u4F8B",
+      en: "Query GitHub repository documentation and examples"
+    },
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "mcp-deepwiki@latest"],
+      env: {}
+    }
+  },
+  {
+    id: "Playwright",
+    name: {
+      "zh-CN": "Playwright \u6D4F\u89C8\u5668\u63A7\u5236",
+      en: "Playwright Browser Control"
+    },
+    description: {
+      "zh-CN": "\u76F4\u63A5\u63A7\u5236\u6D4F\u89C8\u5668\u8FDB\u884C\u81EA\u52A8\u5316\u64CD\u4F5C",
+      en: "Direct browser control for automation"
+    },
+    requiresApiKey: false,
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@playwright/mcp@latest"],
+      env: {}
+    }
+  },
+  {
+    id: "exa",
+    name: { "zh-CN": "Exa AI \u641C\u7D22", en: "Exa AI Search" },
+    description: {
+      "zh-CN": "\u4F7F\u7528 Exa AI \u8FDB\u884C\u7F51\u9875\u641C\u7D22",
+      en: "Web search using Exa AI"
+    },
+    requiresApiKey: true,
+    apiKeyPrompt: {
+      "zh-CN": "\u8BF7\u8F93\u5165 Exa API Key\uFF08\u53EF\u4ECE https://dashboard.exa.ai/api-keys \u83B7\u53D6\uFF09",
+      en: "Enter Exa API Key (get from https://dashboard.exa.ai/api-keys)"
+    },
+    apiKeyEnvVar: "EXA_API_KEY",
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "exa-mcp-server"],
+      env: {
+        EXA_API_KEY: "YOUR_EXA_API_KEY"
+      }
+    }
+  }
+];
+
+function addNumbersToChoices(choices, startFrom = 1, format = (n) => `${n}. `) {
+  let currentNumber = startFrom;
+  return choices.map((choice) => {
+    if (choice.disabled) {
+      return choice;
+    }
+    const numbered = {
+      ...choice,
+      name: `${format(currentNumber)}${choice.name}`
+    };
+    currentNumber++;
+    return numbered;
+  });
+}
+
+class FileSystemError extends Error {
+  constructor(message, path, cause) {
+    super(message);
+    this.path = path;
+    this.cause = cause;
+    this.name = "FileSystemError";
+  }
+}
+function exists(path) {
+  return existsSync(path);
+}
+function ensureDir(path) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+function ensureFileDir(filePath) {
+  const dir = dirname(filePath);
+  ensureDir(dir);
+}
+function readFile(path, encoding = "utf-8") {
+  try {
+    return readFileSync(path, encoding);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to read file: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function writeFile(path, content, encoding = "utf-8") {
+  try {
+    ensureFileDir(path);
+    writeFileSync(path, content, encoding);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to write file: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function copyFile(src, dest) {
+  try {
+    ensureFileDir(dest);
+    copyFileSync(src, dest);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to copy file from ${src} to ${dest}`,
+      src,
+      error
+    );
+  }
+}
+function readDir(path) {
+  try {
+    return readdirSync(path);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to read directory: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function getStats(path) {
+  try {
+    return statSync(path);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to get stats for: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function copyDir(src, dest, options = {}) {
+  const { filter, overwrite = true } = options;
+  if (!exists(src)) {
+    throw new FileSystemError(`Source directory does not exist: ${src}`, src);
+  }
+  ensureDir(dest);
+  const entries = readDir(src);
+  for (const entry of entries) {
+    const srcPath = `${src}/${entry}`;
+    const destPath = `${dest}/${entry}`;
+    const stats = getStats(srcPath);
+    if (filter && !filter(srcPath, stats)) {
+      continue;
+    }
+    if (stats.isDirectory()) {
+      copyDir(srcPath, destPath, options);
+    } else {
+      if (!overwrite && exists(destPath)) {
+        continue;
+      }
+      copyFile(srcPath, destPath);
+    }
+  }
+}
+
+function readJsonConfig(path, options = {}) {
+  const { defaultValue = null, validate, sanitize } = options;
+  if (!exists(path)) {
+    return defaultValue;
+  }
+  try {
+    const content = readFile(path);
+    const data = JSON.parse(content);
+    if (validate && !validate(data)) {
+      const i18n = getTranslation(readZcfConfig()?.preferredLang || "en");
+      console.warn(`${i18n.configuration.invalidConfiguration} (${path})`);
+      return defaultValue;
+    }
+    if (sanitize) {
+      return sanitize(data);
+    }
+    return data;
+  } catch (error) {
+    const i18n = getTranslation(readZcfConfig()?.preferredLang || "en");
+    console.error(`${i18n.configuration.failedToParseJson} ${path}`, error);
+    return defaultValue;
+  }
+}
+function writeJsonConfig(path, data, options = {}) {
+  const { pretty = true, backup = false, backupDir } = options;
+  if (backup && exists(path)) {
+    backupJsonConfig(path, backupDir);
+  }
+  const content = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+  writeFile(path, content);
+}
+function backupJsonConfig(path, backupDir) {
+  if (!exists(path)) {
+    return null;
+  }
+  const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+  const fileName = path.split("/").pop() || "config.json";
+  const baseDir = backupDir || join(path, "..", "backup");
+  const backupPath = join(baseDir, `${fileName}.backup_${timestamp}`);
+  try {
+    ensureDir(baseDir);
+    copyFile(path, backupPath);
+    return backupPath;
+  } catch (error) {
+    const i18n = getTranslation(readZcfConfig()?.preferredLang || "en");
+    console.error(i18n.configuration.failedToBackupConfig, error);
+    return null;
+  }
+}
+
+function readZcfConfig() {
+  let config = readJsonConfig(AICO_CONFIG_FILE);
+  if (!config && existsSync(LEGACY_AICO_CONFIG_FILE)) {
+    config = readJsonConfig(LEGACY_AICO_CONFIG_FILE);
+  }
+  return config;
+}
+async function readZcfConfigAsync() {
+  return readZcfConfig();
+}
+function writeZcfConfig(config) {
+  try {
+    writeJsonConfig(AICO_CONFIG_FILE, config);
+  } catch (error) {
+  }
+}
+function updateZcfConfig(updates) {
+  const existingConfig = readZcfConfig();
+  const newConfig = {
+    version: updates.version || existingConfig?.version || "1.0.0",
+    preferredLang: updates.preferredLang || existingConfig?.preferredLang || "en",
+    aiOutputLang: updates.aiOutputLang || existingConfig?.aiOutputLang,
+    aiPersonality: updates.aiPersonality !== void 0 ? updates.aiPersonality : existingConfig?.aiPersonality,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeZcfConfig(newConfig);
+}
+
+const AI_PERSONALITIES = [
+  {
+    id: "professional",
+    name: { "zh-CN": "\u4E13\u4E1A\u52A9\u624B(\u9ED8\u8BA4)", en: "Professional Assistant(Default)" },
+    directive: {
+      "zh-CN": "\u4F60\u662F\u4E00\u540D\u7ECF\u9A8C\u4E30\u5BCC\u7684[\u4E13\u4E1A\u9886\u57DF\uFF0C\u4F8B\u5982\uFF1A\u8F6F\u4EF6\u5F00\u53D1\u5DE5\u7A0B\u5E08 / \u7CFB\u7EDF\u8BBE\u8BA1\u5E08 / \u4EE3\u7801\u67B6\u6784\u5E08]\uFF0C\u4E13\u6CE8\u4E8E\u6784\u5EFA[\u6838\u5FC3\u7279\u957F\uFF0C\u4F8B\u5982\uFF1A\u9AD8\u6027\u80FD / \u53EF\u7EF4\u62A4 / \u5065\u58EE / \u9886\u57DF\u9A71\u52A8]\u7684\u89E3\u51B3\u65B9\u6848\u3002",
+      en: "You are an experienced [professional domain, e.g., Software Development Engineer / System Designer / Code Architect], specializing in building [core strengths, e.g., high-performance / maintainable / robust / domain-driven] solutions."
+    }
+  },
+  {
+    id: "friendly",
+    name: { "zh-CN": "\u53CB\u597D\u52A9\u624B", en: "Friendly Assistant" },
+    directive: {
+      "zh-CN": "\u4F60\u662F\u4E00\u4F4D\u53CB\u597D\u3001\u8010\u5FC3\u3001\u5584\u4E8E\u89E3\u91CA\u7684\u7F16\u7A0B\u52A9\u624B\u3002\u4F1A\u7528\u901A\u4FD7\u6613\u61C2\u7684\u65B9\u5F0F\u89E3\u91CA\u590D\u6742\u6982\u5FF5\uFF0C\u5E76\u7ECF\u5E38\u7ED9\u4E88\u9F13\u52B1\u3002",
+      en: "You are a friendly, patient, and explanatory programming assistant. You explain complex concepts in easy-to-understand ways and often provide encouragement."
+    }
+  },
+  {
+    id: "mentor",
+    name: { "zh-CN": "\u5BFC\u5E08\u6A21\u5F0F", en: "Mentor Mode" },
+    directive: {
+      "zh-CN": "\u4F60\u662F\u4E00\u4F4D\u7ECF\u9A8C\u4E30\u5BCC\u7684\u7F16\u7A0B\u5BFC\u5E08\u3002\u4E0D\u4EC5\u63D0\u4F9B\u89E3\u51B3\u65B9\u6848\uFF0C\u8FD8\u4F1A\u89E3\u91CA\u80CC\u540E\u7684\u539F\u7406\uFF0C\u5F15\u5BFC\u7528\u6237\u601D\u8003\uFF0C\u57F9\u517B\u72EC\u7ACB\u89E3\u51B3\u95EE\u9898\u7684\u80FD\u529B\u3002",
+      en: "You are an experienced programming mentor. You not only provide solutions but also explain the principles behind them, guide users to think, and cultivate their ability to solve problems independently."
+    }
+  },
+  {
+    id: "custom",
+    name: { "zh-CN": "\u81EA\u5B9A\u4E49", en: "Custom" },
+    directive: { "zh-CN": "", en: "" }
+  }
+];
+function getExistingPersonality() {
+  const config = readZcfConfig();
+  return config?.aiPersonality || null;
+}
+function getPersonalityInfo(personalityId) {
+  return AI_PERSONALITIES.find((p) => p.id === personalityId);
+}
+async function configureAiPersonality(scriptLang, showExisting = true) {
+  const i18n = getTranslation(scriptLang);
+  const existingPersonality = getExistingPersonality();
+  if (showExisting && existingPersonality) {
+    const personalityInfo = getPersonalityInfo(existingPersonality);
+    if (personalityInfo) {
+      console.log("\n" + ansis.blue(`\u2139 ${i18n.configuration.existingPersonality || "Existing AI personality configuration"}`));
+      console.log(
+        ansis.gray(`  ${i18n.configuration.currentPersonality || "Current personality"}: ${personalityInfo.name[scriptLang]}`)
+      );
+      const { modify } = await inquirer.prompt({
+        type: "confirm",
+        name: "modify",
+        message: i18n.configuration.modifyPersonality || "Modify AI personality?",
+        default: false
+      });
+      if (!modify) {
+        console.log(ansis.green(`\u2714 ${i18n.configuration.keepPersonality || "Keeping existing personality"}`));
+        return;
+      }
+    }
+  }
+  const { personality } = await inquirer.prompt({
+    type: "list",
+    name: "personality",
+    message: i18n.configuration.selectAiPersonality || "Select AI personality",
+    choices: addNumbersToChoices(AI_PERSONALITIES.map((p) => ({
+      name: p.id !== "custom" ? `${p.name[scriptLang]} - ${ansis.gray(p.directive[scriptLang].substring(0, 50) + "...")}` : `${p.name[scriptLang]} - ${ansis.gray(i18n.configuration.customPersonalityHint || "Define your own personality")}`,
+      value: p.id,
+      short: p.name[scriptLang]
+    }))),
+    default: existingPersonality ? AI_PERSONALITIES.findIndex((p) => p.id === existingPersonality) : 0
+  });
+  if (!personality) {
+    console.log(ansis.yellow(i18n.common.cancelled));
+    return;
+  }
+  let directive = "";
+  if (personality === "custom") {
+    const { customDirective } = await inquirer.prompt({
+      type: "input",
+      name: "customDirective",
+      message: i18n.configuration.enterCustomPersonality || "Enter custom personality directive",
+      validate: (value) => !!value || i18n.configuration.directiveCannotBeEmpty
+    });
+    if (!customDirective) {
+      console.log(ansis.yellow(i18n.common.cancelled));
+      return;
+    }
+    directive = customDirective;
+  } else {
+    const selected = AI_PERSONALITIES.find((p) => p.id === personality);
+    if (selected) {
+      directive = selected.directive[scriptLang];
+    }
+  }
+  await applyPersonalityDirective(directive);
+  updateZcfConfig({ aiPersonality: personality });
+  console.log(ansis.green(`\u2714 ${i18n.configuration.personalityConfigured || "AI personality configured"}`));
+}
+async function applyPersonalityDirective(directive) {
+  try {
+    const personalityFile = join(CLAUDE_DIR, "personality.md");
+    writeFile(personalityFile, directive);
+  } catch (error) {
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const errorI18n = getTranslation(lang);
+    console.error(ansis.red(errorI18n.configuration.failedToApplyPersonality || "Failed to apply personality"), error);
+  }
+}
+
+function displayBanner(subtitle) {
+  const defaultSubtitle = "\u4E00\u952E\u914D\u7F6E\u4F60\u7684\u5F00\u53D1\u73AF\u5883";
+  const subtitleText = subtitle || defaultSubtitle;
+  const paddedSubtitle = subtitleText.padEnd(60, " ");
+  console.log(
+    ansis.cyan.bold(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                                \u2551
+\u2551    \u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557                              \u2551
+\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557                             \u2551
+\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551                             \u2551
+\u2551   \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2551     \u2588\u2588\u2551   \u2588\u2588\u2551                             \u2551
+\u2551   \u2588\u2588\u2551  \u2588\u2588\u2551  \u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D                             \u2551
+\u2551   \u255A\u2550\u255D  \u255A\u2550\u255D  \u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D                              \u2551
+\u2551                                                                \u2551
+\u2551   ${ansis.white.bold("\u667A\u80FD\u8F6F\u4EF6\u661F\u5DE5\u5382")}                                               \u2551
+\u2551   ${ansis.gray(paddedSubtitle)}\u2551
+\u2551                                                                \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`)
+  );
+}
+function displayBannerWithInfo(subtitle) {
+  displayBanner(subtitle);
+  console.log(ansis.gray(`  Version: ${ansis.cyan(version)}`));
+}
+
+function handleExitPromptError(error) {
+  if (error instanceof Error && error.name === "ExitPromptError") {
+    const zcfConfig = readZcfConfig();
+    const defaultLang = zcfConfig?.preferredLang || "zh-CN";
+    const i18n = getTranslation(defaultLang);
+    console.log(ansis.cyan(`
+${i18n.common.goodbye}
+`));
+    process.exit(0);
+  }
+  if (error instanceof EscapeKeyPressed) {
+    return true;
+  }
+  return false;
+}
+function handleGeneralError(error, lang) {
+  const zcfConfig = readZcfConfig();
+  const defaultLang = lang || zcfConfig?.preferredLang || "en";
+  const i18n = getTranslation(defaultLang);
+  const errorMsg = i18n.common.error || "Error";
+  console.error(ansis.red(`${errorMsg}:`), error);
+  if (error instanceof Error) {
+    console.error(ansis.gray(`Stack: ${error.stack}`));
+  }
+  process.exit(1);
+}
+
+function mergeArraysUnique(arr1, arr2) {
+  const combined = [...arr1 || [], ...arr2 || []];
+  return [...new Set(combined)];
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && value.constructor === Object && Object.prototype.toString.call(value) === "[object Object]";
+}
+function deepMerge(target, source, options = {}) {
+  const { mergeArrays = false, arrayMergeStrategy = "replace" } = options;
+  const result = { ...target };
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue === void 0) {
+      continue;
+    }
+    if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue, options);
+    } else if (Array.isArray(sourceValue)) {
+      if (!mergeArrays || !Array.isArray(targetValue)) {
+        result[key] = sourceValue;
+      } else {
+        switch (arrayMergeStrategy) {
+          case "concat":
+            result[key] = [...targetValue, ...sourceValue];
+            break;
+          case "unique":
+            result[key] = mergeArraysUnique(targetValue, sourceValue);
+            break;
+          case "replace":
+          default:
+            result[key] = sourceValue;
+            break;
+        }
+      }
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (isPlainObject(obj)) {
+    const cloned = {};
+    for (const key in obj) {
+      cloned[key] = deepClone(obj[key]);
+    }
+    return cloned;
+  }
+  return obj;
+}
+
+function cleanupPermissions(templatePermissions, userPermissions) {
+  const templateSet = new Set(templatePermissions);
+  const cleanedPermissions = userPermissions.filter((permission) => {
+    if (["mcp__.*", "mcp__*", "mcp__(*)"].includes(permission)) {
+      return false;
+    }
+    for (const templatePerm of templatePermissions) {
+      if (permission === templatePerm) {
+        continue;
+      }
+      if (permission.startsWith(templatePerm)) {
+        return false;
+      }
+    }
+    return true;
+  });
+  const merged = [...templateSet];
+  for (const permission of cleanedPermissions) {
+    if (!templateSet.has(permission)) {
+      merged.push(permission);
+    }
+  }
+  return merged;
+}
+function mergeAndCleanPermissions(templatePermissions, userPermissions) {
+  const template = templatePermissions || [];
+  const user = userPermissions || [];
+  return cleanupPermissions(template, user);
+}
+
+function getPlatform() {
+  const p = platform();
+  if (p === "win32") return "windows";
+  if (p === "darwin") return "macos";
+  return "linux";
+}
+function isTermux() {
+  return !!(process.env.PREFIX && process.env.PREFIX.includes("com.termux")) || !!process.env.TERMUX_VERSION || existsSync("/data/data/com.termux/files/usr");
+}
+function getTermuxPrefix() {
+  return process.env.PREFIX || "/data/data/com.termux/files/usr";
+}
+function isWindows() {
+  return getPlatform() === "windows";
+}
+function getMcpCommand() {
+  if (isWindows()) {
+    return ["cmd", "/c", "npx"];
+  }
+  return ["npx"];
+}
+async function commandExists(command) {
+  try {
+    const cmd = getPlatform() === "windows" ? "where" : "which";
+    const res = await exec(cmd, [command]);
+    if (res.exitCode === 0) {
+      return true;
+    }
+  } catch {
+  }
+  if (isTermux()) {
+    const termuxPrefix = getTermuxPrefix();
+    const possiblePaths = [
+      `${termuxPrefix}/bin/${command}`,
+      `${termuxPrefix}/usr/bin/${command}`,
+      `/data/data/com.termux/files/usr/bin/${command}`
+    ];
+    for (const path of possiblePaths) {
+      if (existsSync(path)) {
+        return true;
+      }
+    }
+  }
+  if (getPlatform() !== "windows") {
+    const commonPaths = [
+      `/usr/local/bin/${command}`,
+      `/usr/bin/${command}`,
+      `/bin/${command}`,
+      `${process.env.HOME}/.local/bin/${command}`
+    ];
+    for (const path of commonPaths) {
+      if (existsSync(path)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function getMcpConfigPath() {
+  return ClAUDE_CONFIG_FILE;
+}
+function readMcpConfig() {
+  return readJsonConfig(ClAUDE_CONFIG_FILE);
+}
+function writeMcpConfig(config) {
+  writeJsonConfig(ClAUDE_CONFIG_FILE, config);
+}
+function backupMcpConfig() {
+  const backupBaseDir = join(CLAUDE_DIR, "backup");
+  return backupJsonConfig(ClAUDE_CONFIG_FILE, backupBaseDir);
+}
+function mergeMcpServers(existing, newServers) {
+  const config = existing || { mcpServers: {} };
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  Object.assign(config.mcpServers, newServers);
+  return config;
+}
+function applyPlatformCommand(config) {
+  if (config.command === "npx" && isWindows()) {
+    const mcpCmd = getMcpCommand();
+    config.command = mcpCmd[0];
+    config.args = [...mcpCmd.slice(1), ...config.args || []];
+  }
+}
+function buildMcpServerConfig(baseConfig, apiKey, placeholder = "YOUR_EXA_API_KEY", envVarName) {
+  const config = deepClone(baseConfig);
+  applyPlatformCommand(config);
+  if (!apiKey) {
+    return config;
+  }
+  if (envVarName && config.env) {
+    config.env[envVarName] = apiKey;
+    return config;
+  }
+  if (config.args) {
+    config.args = config.args.map((arg) => arg.replace(placeholder, apiKey));
+  }
+  if (config.url) {
+    config.url = config.url.replace(placeholder, apiKey);
+  }
+  return config;
+}
+function fixWindowsMcpConfig(config) {
+  if (!isWindows() || !config.mcpServers) {
+    return config;
+  }
+  const fixed = { ...config };
+  for (const [, serverConfig] of Object.entries(fixed.mcpServers)) {
+    if (serverConfig && typeof serverConfig === "object" && "command" in serverConfig) {
+      applyPlatformCommand(serverConfig);
+    }
+  }
+  return fixed;
+}
+function addCompletedOnboarding() {
+  try {
+    let config = readMcpConfig();
+    if (!config) {
+      config = { mcpServers: {} };
+    }
+    if (config.hasCompletedOnboarding === true) {
+      return;
+    }
+    config.hasCompletedOnboarding = true;
+    writeMcpConfig(config);
+  } catch (error) {
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const i18n = getTranslation(lang);
+    console.error(i18n.configuration?.failedToAddOnboardingFlag || "Failed to add onboarding flag", error);
+    throw error;
+  }
+}
+
+function ensureClaudeDir() {
+  ensureDir(CLAUDE_DIR);
+}
+function backupExistingConfig() {
+  if (!exists(CLAUDE_DIR)) {
+    return null;
+  }
+  const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+  const backupBaseDir = join(CLAUDE_DIR, "backup");
+  const backupDir = join(backupBaseDir, `backup_${timestamp}`);
+  ensureDir(backupDir);
+  const filter = (path) => {
+    return !path.includes("/backup");
+  };
+  copyDir(CLAUDE_DIR, backupDir, { filter });
+  return backupDir;
+}
+function copyConfigFiles(lang, onlyMd = false) {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const distDir = dirname(dirname(currentFilePath));
+  const rootDir = dirname(distDir);
+  const baseTemplateDir = join(rootDir, "templates");
+  copyClaudeMemoryFiles(lang, rootDir);
+  if (!onlyMd) {
+    const baseSettingsPath = join(baseTemplateDir, "settings.json");
+    const destSettingsPath = join(CLAUDE_DIR, "settings.json");
+    if (exists(baseSettingsPath)) {
+      mergeSettingsFile(baseSettingsPath, destSettingsPath);
+    }
+  }
+  const claudeMdSource = join(baseTemplateDir, "CLAUDE.md");
+  const claudeMdDest = join(CLAUDE_DIR, "CLAUDE.md");
+  if (exists(claudeMdSource)) {
+    copyFile(claudeMdSource, claudeMdDest);
+  }
+}
+function copyClaudeMemoryFiles(lang, rootDir) {
+  const memorySourceDir = join(rootDir, "templates", lang, "memory");
+  if (!exists(memorySourceDir)) {
+    const i18n = getTranslation(lang);
+    throw new Error(`${i18n.configuration.memoryDirNotFound || "Memory directory not found:"} ${memorySourceDir}`);
+  }
+  const files = readDir(memorySourceDir);
+  files?.forEach((file) => {
+    if (file.endsWith(".md")) {
+      const sourcePath = join(memorySourceDir, file);
+      const destPath = join(CLAUDE_DIR, file);
+      copyFile(sourcePath, destPath);
+    }
+  });
+}
+function getDefaultSettings() {
+  try {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const distDir = dirname(dirname(currentFilePath));
+    const rootDir = dirname(distDir);
+    const templateSettingsPath = join(rootDir, "templates", "settings.json");
+    return readJsonConfig(templateSettingsPath) || {};
+  } catch (error) {
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const i18n = getTranslation(lang);
+    console.error(i18n.configuration.failedToReadTemplateSettings || "Failed to read template settings", error);
+    return {};
+  }
+}
+function configureApi(apiConfig) {
+  if (!apiConfig) return null;
+  let settings = getDefaultSettings();
+  const existingSettings = readJsonConfig(SETTINGS_FILE);
+  if (existingSettings) {
+    settings = deepMerge(settings, existingSettings);
+  }
+  if (!settings.env) {
+    settings.env = {};
+  }
+  if (apiConfig.authType === "api_key") {
+    settings.env.ANTHROPIC_API_KEY = apiConfig.key;
+    delete settings.env.ANTHROPIC_AUTH_TOKEN;
+  } else if (apiConfig.authType === "auth_token") {
+    settings.env.ANTHROPIC_AUTH_TOKEN = apiConfig.key;
+    delete settings.env.ANTHROPIC_API_KEY;
+  }
+  if (apiConfig.url) {
+    settings.env.ANTHROPIC_BASE_URL = apiConfig.url;
+  }
+  writeJsonConfig(SETTINGS_FILE, settings);
+  try {
+    addCompletedOnboarding();
+  } catch (error) {
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const i18n = getTranslation(lang);
+    console.error(i18n.configuration.failedToSetOnboarding || "Failed to set onboarding flag", error);
+  }
+  return apiConfig;
+}
+function mergeConfigs(sourceFile, targetFile) {
+  if (!exists(sourceFile)) return;
+  const target = readJsonConfig(targetFile) || {};
+  const source = readJsonConfig(sourceFile) || {};
+  const merged = deepMerge(target, source);
+  writeJsonConfig(targetFile, merged);
+}
+function updateDefaultModel(model) {
+  let settings = getDefaultSettings();
+  const existingSettings = readJsonConfig(SETTINGS_FILE);
+  if (existingSettings) {
+    settings = existingSettings;
+  }
+  settings.model = model;
+  writeJsonConfig(SETTINGS_FILE, settings);
+}
+function mergeSettingsFile(templatePath, targetPath) {
+  try {
+    const templateSettings = readJsonConfig(templatePath);
+    if (!templateSettings) {
+      const lang = readZcfConfig()?.preferredLang || "en";
+      const i18n = getTranslation(lang);
+      console.error(i18n.configuration?.failedToReadTemplateSettings || "Failed to read template settings");
+      return;
+    }
+    if (!exists(targetPath)) {
+      writeJsonConfig(targetPath, templateSettings);
+      return;
+    }
+    const existingSettings = readJsonConfig(targetPath) || {};
+    const mergedEnv = {
+      ...templateSettings.env || {},
+      // Template env vars first
+      ...existingSettings.env || {}
+      // User's env vars override (preserving API keys, etc.)
+    };
+    const mergedSettings = deepMerge(templateSettings, existingSettings, {
+      mergeArrays: true,
+      arrayMergeStrategy: "unique"
+    });
+    mergedSettings.env = mergedEnv;
+    if (mergedSettings.permissions && mergedSettings.permissions.allow) {
+      mergedSettings.permissions.allow = mergeAndCleanPermissions(
+        templateSettings.permissions?.allow,
+        existingSettings.permissions?.allow
+      );
+    }
+    writeJsonConfig(targetPath, mergedSettings);
+  } catch (error) {
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const i18n = getTranslation(lang);
+    console.error(i18n.configuration.failedToMergeSettings || "Failed to merge settings", error);
+    if (exists(targetPath)) {
+      const lang2 = readZcfConfig()?.preferredLang || "en";
+      const i18n2 = getTranslation(lang2);
+      console.warn(i18n2.configuration.preservingExistingSettings || "Preserving existing settings");
+    } else {
+      copyFile(templatePath, targetPath);
+    }
+  }
+}
+function getExistingApiConfig() {
+  const settings = readJsonConfig(SETTINGS_FILE);
+  if (!settings || !settings.env) {
+    return null;
+  }
+  const { ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, ANTHROPIC_BASE_URL } = settings.env;
+  if (!ANTHROPIC_BASE_URL && !ANTHROPIC_API_KEY && !ANTHROPIC_AUTH_TOKEN) {
+    return null;
+  }
+  let authType;
+  let key;
+  if (ANTHROPIC_AUTH_TOKEN) {
+    authType = "auth_token";
+    key = ANTHROPIC_AUTH_TOKEN;
+  } else if (ANTHROPIC_API_KEY) {
+    authType = "api_key";
+    key = ANTHROPIC_API_KEY;
+  }
+  return {
+    url: ANTHROPIC_BASE_URL || "",
+    key: key || "",
+    authType
+  };
+}
+function applyAiLanguageDirective(aiOutputLang) {
+  const languageFile = join(CLAUDE_DIR, "language.md");
+  let directive = "";
+  if (aiOutputLang === "custom") {
+    return;
+  } else if (AI_OUTPUT_LANGUAGES[aiOutputLang]) {
+    directive = AI_OUTPUT_LANGUAGES[aiOutputLang].directive;
+  } else {
+    directive = `Always respond in ${aiOutputLang}`;
+  }
+  writeFile(languageFile, directive);
+}
+
+async function isClaudeCodeInstalled() {
+  return await commandExists("claude");
+}
+async function installClaudeCode(lang) {
+  const i18n = getTranslation(lang);
+  if (isTermux()) {
+    console.log(ansis.yellow(`\u2139 ${i18n.installation.termuxDetected}`));
+    const termuxPrefix = getTermuxPrefix();
+    console.log(ansis.gray(i18n.installation.termuxPathInfo.replace("{path}", termuxPrefix)));
+    console.log(ansis.gray(`Node.js: ${termuxPrefix}/bin/node`));
+    console.log(ansis.gray(`npm: ${termuxPrefix}/bin/npm`));
+  }
+  console.log(i18n.installation.installing);
+  try {
+    await exec("npm", ["install", "-g", "@anthropic-ai/claude-code"]);
+    console.log(`\u2714 ${i18n.installation.installSuccess}`);
+    if (isTermux()) {
+      console.log(ansis.gray(`
+Claude Code installed to: ${getTermuxPrefix()}/bin/claude`));
+    }
+  } catch (error) {
+    console.error(`\u2716 ${i18n.installation.installFailed}`);
+    if (isTermux()) {
+      console.error(ansis.yellow(`
+${i18n.installation.termuxInstallHint}
+`));
+    }
+    throw error;
+  }
+}
+
+async function selectMcpServices(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  try {
+    const choices = MCP_SERVICES.map((service) => ({
+      name: `${service.name[scriptLang]} - ${ansis.gray(service.description[scriptLang])}`,
+      value: service.id,
+      selected: false
+    }));
+    const { services } = await inquirer.prompt({
+      type: "checkbox",
+      name: "services",
+      message: `${i18n.mcp.selectMcpServices}${i18n.common.multiSelectHint}`,
+      choices
+    });
+    return services;
+  } catch (error) {
+    if (error instanceof EscapeKeyPressed) {
+      console.log(ansis.yellow(i18n.common.cancelled));
+      return void 0;
+    }
+    throw error;
+  }
+}
+
+const WORKFLOW_CONFIGS = [
+  {
+    id: "sixStepsWorkflow",
+    nameKey: "workflowOption.sixStepsWorkflow",
+    descriptionKey: "workflowDescription.sixStepsWorkflow",
+    defaultSelected: true,
+    order: 1,
+    commands: ["workflow.md"],
+    agents: [],
+    autoInstallAgents: false,
+    category: "sixStep",
+    outputDir: "workflow"
+  },
+  {
+    id: "featPlanUx",
+    nameKey: "workflowOption.featPlanUx",
+    descriptionKey: "workflowDescription.featPlanUx",
+    defaultSelected: true,
+    order: 2,
+    commands: ["feat.md"],
+    agents: [
+      { id: "planner", filename: "planner.md", required: true },
+      { id: "ui-ux-designer", filename: "ui-ux-designer.md", required: true }
+    ],
+    autoInstallAgents: true,
+    category: "plan",
+    outputDir: "feat"
+  },
+  {
+    id: "bmadWorkflow",
+    nameKey: "workflowOption.bmadWorkflow",
+    descriptionKey: "workflowDescription.bmadWorkflow",
+    defaultSelected: true,
+    order: 3,
+    commands: ["bmad-init.md"],
+    agents: [],
+    autoInstallAgents: false,
+    category: "bmad",
+    outputDir: "bmad"
+  }
+];
+function getWorkflowConfig(workflowId) {
+  return WORKFLOW_CONFIGS.find((config) => config.id === workflowId);
+}
+function getOrderedWorkflows() {
+  return [...WORKFLOW_CONFIGS].sort((a, b) => a.order - b.order);
+}
+
+function getRootDir() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const distDir = dirname(dirname(currentFilePath));
+  return dirname(distDir);
+}
+async function selectAndInstallWorkflows(configLang, scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  const workflows = getOrderedWorkflows();
+  const choices = workflows.map((workflow) => {
+    const nameKey = workflow.id;
+    const name = i18n.workflow.workflowOption[nameKey] || workflow.id;
+    return {
+      name,
+      value: workflow.id,
+      checked: workflow.defaultSelected
+    };
+  });
+  const { selectedWorkflows } = await inquirer.prompt({
+    type: "checkbox",
+    name: "selectedWorkflows",
+    message: `${i18n.workflow.selectWorkflowType}${i18n.common.multiSelectHint}`,
+    choices
+  });
+  if (!selectedWorkflows || selectedWorkflows.length === 0) {
+    console.log(ansis.yellow(i18n.common.cancelled));
+    return;
+  }
+  await cleanupOldVersionFiles(scriptLang);
+  for (const workflowId of selectedWorkflows) {
+    const config = getWorkflowConfig(workflowId);
+    if (config) {
+      await installWorkflowWithDependencies(config, configLang, scriptLang);
+    }
+  }
+}
+async function installWorkflowWithDependencies(config, configLang, scriptLang) {
+  const rootDir = getRootDir();
+  const i18n = getTranslation(scriptLang);
+  const result = {
+    workflow: config.id,
+    success: true,
+    installedCommands: [],
+    installedAgents: [],
+    errors: []
+  };
+  const workflowName = i18n.workflow.workflowOption[config.id] || config.id;
+  console.log(ansis.cyan(`
+\u{1F4E6} ${i18n.workflow.installingWorkflow}: ${workflowName}...`));
+  const commandsDir = join(CLAUDE_DIR, "commands", "aico");
+  if (!existsSync(commandsDir)) {
+    await mkdir(commandsDir, { recursive: true });
+  }
+  for (const commandFile of config.commands) {
+    const commandSource = join(rootDir, "templates", configLang, "workflow", config.category, "commands", commandFile);
+    const destFileName = commandFile;
+    const commandDest = join(commandsDir, destFileName);
+    if (existsSync(commandSource)) {
+      try {
+        await copyFile$1(commandSource, commandDest);
+        result.installedCommands.push(destFileName);
+        console.log(ansis.gray(`  \u2714 ${i18n.workflow.installedCommand}: aico/${destFileName}`));
+      } catch (error) {
+        const errorMsg = `${i18n.workflow.failedToInstallCommand} ${commandFile}: ${error}`;
+        result.errors?.push(errorMsg);
+        console.error(ansis.red(`  \u2717 ${errorMsg}`));
+        result.success = false;
+      }
+    }
+  }
+  if (config.autoInstallAgents && config.agents.length > 0) {
+    const agentsCategoryDir = join(CLAUDE_DIR, "agents", "aico", config.category);
+    if (!existsSync(agentsCategoryDir)) {
+      await mkdir(agentsCategoryDir, { recursive: true });
+    }
+    for (const agent of config.agents) {
+      const agentSource = join(rootDir, "templates", configLang, "workflow", config.category, "agents", agent.filename);
+      const agentDest = join(agentsCategoryDir, agent.filename);
+      if (existsSync(agentSource)) {
+        try {
+          await copyFile$1(agentSource, agentDest);
+          result.installedAgents.push(agent.filename);
+          console.log(ansis.gray(`  \u2714 ${i18n.workflow.installedAgent}: aico/${config.category}/${agent.filename}`));
+        } catch (error) {
+          const errorMsg = `${i18n.workflow.failedToInstallAgent} ${agent.filename}: ${error}`;
+          result.errors?.push(errorMsg);
+          console.error(ansis.red(`  \u2717 ${errorMsg}`));
+          if (agent.required) {
+            result.success = false;
+          }
+        }
+      }
+    }
+  }
+  if (result.success) {
+    console.log(ansis.green(`\u2714 ${workflowName} ${i18n.workflow.workflowInstallSuccess}`));
+    if (config.id === "bmadWorkflow") {
+      console.log(ansis.cyan(`
+${i18n.bmad.bmadInitPrompt}`));
+    }
+  } else {
+    console.log(ansis.red(`\u2717 ${workflowName} ${i18n.workflow.workflowInstallError}`));
+  }
+  return result;
+}
+async function cleanupOldVersionFiles(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  console.log(ansis.cyan(`
+\u{1F9F9} ${i18n.workflow.cleaningOldFiles || "Cleaning up old version files"}...`));
+  const oldCommandFiles = [
+    join(CLAUDE_DIR, "commands", "workflow.md"),
+    join(CLAUDE_DIR, "commands", "feat.md")
+  ];
+  const oldAgentFiles = [
+    join(CLAUDE_DIR, "agents", "planner.md"),
+    join(CLAUDE_DIR, "agents", "ui-ux-designer.md")
+  ];
+  for (const file of oldCommandFiles) {
+    if (existsSync(file)) {
+      try {
+        await rm(file, { force: true });
+        console.log(ansis.gray(`  \u2714 ${i18n.workflow.removedOldFile || "Removed old file"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
+      } catch (error) {
+        console.error(ansis.yellow(`  \u26A0 ${i18n.workflow.failedToRemoveFile || "Failed to remove"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
+      }
+    }
+  }
+  for (const file of oldAgentFiles) {
+    if (existsSync(file)) {
+      try {
+        await rm(file, { force: true });
+        console.log(ansis.gray(`  \u2714 ${i18n.workflow.removedOldFile || "Removed old file"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
+      } catch (error) {
+        console.error(ansis.yellow(`  \u26A0 ${i18n.workflow.failedToRemoveFile || "Failed to remove"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
+      }
+    }
+  }
+}
+
+async function init(options = {}) {
+  try {
+    if (!options.skipBanner) {
+      displayBannerWithInfo();
+    }
+    const scriptLang = "zh-CN";
+    const configLang = "zh-CN";
+    const i18n = I18N[scriptLang];
+    if (isTermux()) {
+      console.log(ansis.yellow(`
+\u2139 ${i18n.installation.termuxDetected}`));
+      console.log(ansis.gray(i18n.installation.termuxEnvironmentInfo));
+    }
+    const aiOutputLang = "zh-CN";
+    const installed = await isClaudeCodeInstalled();
+    if (!installed) {
+      const { shouldInstall } = await inquirer.prompt({
+        type: "confirm",
+        name: "shouldInstall",
+        message: i18n.installation.installPrompt,
+        default: true
+      });
+      if (shouldInstall === void 0) {
+        console.log(ansis.yellow(i18n.common.cancelled));
+        process.exit(0);
+      }
+      if (shouldInstall) {
+        await installClaudeCode(scriptLang);
+      } else {
+        console.log(ansis.yellow(i18n.common.skip));
+      }
+    } else {
+      console.log(ansis.green(`\u2714 ${i18n.installation.alreadyInstalled}`));
+    }
+    ensureClaudeDir();
+    let action = "new";
+    if (existsSync(SETTINGS_FILE) && !options.force) {
+      const { action: userAction } = await inquirer.prompt({
+        type: "list",
+        name: "action",
+        message: i18n.configuration.existingConfig,
+        choices: addNumbersToChoices([
+          { name: i18n.configuration.backupAndOverwrite, value: "backup" },
+          { name: i18n.configuration.updateDocsOnly, value: "docs-only" },
+          { name: i18n.configuration.mergeConfig, value: "merge" },
+          { name: i18n.common.skip, value: "skip" }
+        ])
+      });
+      if (!userAction) {
+        console.log(ansis.yellow(i18n.common.cancelled));
+        process.exit(0);
+      }
+      action = userAction;
+      if (action === "skip") {
+        console.log(ansis.yellow(i18n.common.skip));
+        return;
+      }
+    }
+    let apiConfig = null;
+    const isNewInstall = !existsSync(SETTINGS_FILE);
+    if (action !== "docs-only" && (isNewInstall || ["backup", "merge"].includes(action))) {
+      apiConfig = {
+        url: "http://11.0.166.20:13456",
+        key: "sk-4730d06849b5fea00f551bd60a0902e1",
+        authType: "auth_token"
+      };
+      console.log(ansis.green(`\u2714 \u4F7F\u7528\u9884\u914D\u7F6EAPI\u4FE1\u606F`));
+    }
+    if (["backup", "docs-only", "merge"].includes(action)) {
+      const backupDir = backupExistingConfig();
+      if (backupDir) {
+        console.log(ansis.gray(`\u2714 ${i18n.configuration.backupSuccess}: ${backupDir}`));
+      }
+    }
+    if (action === "docs-only") {
+      copyConfigFiles(configLang, true);
+      await selectAndInstallWorkflows(configLang, scriptLang);
+    } else if (["backup", "merge", "new"].includes(action)) {
+      copyConfigFiles(configLang, false);
+      await selectAndInstallWorkflows(configLang, scriptLang);
+    }
+    applyAiLanguageDirective(aiOutputLang);
+    await configureAiPersonality(scriptLang);
+    if (apiConfig && action !== "docs-only") {
+      const configuredApi = configureApi(apiConfig);
+      if (configuredApi) {
+        console.log(ansis.green(`\u2714 ${i18n.api.apiConfigSuccess}`));
+        console.log(ansis.gray(`  URL: ${configuredApi.url}`));
+        console.log(ansis.gray(`  Key: sk-***...***`));
+      }
+    }
+    if (action !== "docs-only") {
+      const { shouldConfigureMcp } = await inquirer.prompt({
+        type: "confirm",
+        name: "shouldConfigureMcp",
+        message: i18n.mcp.configureMcp,
+        default: true
+      });
+      if (shouldConfigureMcp === void 0) {
+        console.log(ansis.yellow(i18n.common.cancelled));
+        process.exit(0);
+      }
+      if (shouldConfigureMcp) {
+        if (isWindows()) {
+          console.log(ansis.blue(`\u2139 ${i18n.installation.windowsDetected}`));
+        }
+        const selectedServices = await selectMcpServices(scriptLang);
+        if (selectedServices === void 0) {
+          process.exit(0);
+        }
+        if (selectedServices.length > 0) {
+          const mcpBackupPath = backupMcpConfig();
+          if (mcpBackupPath) {
+            console.log(ansis.gray(`\u2714 ${i18n.mcp.mcpBackupSuccess}: ${mcpBackupPath}`));
+          }
+          const newServers = {};
+          for (const serviceId of selectedServices) {
+            const service = MCP_SERVICES.find((s) => s.id === serviceId);
+            if (!service) continue;
+            let config = service.config;
+            if (service.requiresApiKey) {
+              const { apiKey } = await inquirer.prompt({
+                type: "input",
+                name: "apiKey",
+                message: service.apiKeyPrompt[scriptLang],
+                validate: (value) => !!value || i18n.api.keyRequired
+              });
+              if (apiKey === void 0) {
+                console.log(ansis.yellow(`${i18n.common.skip}: ${service.name[scriptLang]}`));
+                continue;
+              }
+              if (apiKey) {
+                config = buildMcpServerConfig(service.config, apiKey, service.apiKeyPlaceholder, service.apiKeyEnvVar);
+              } else {
+                continue;
+              }
+            }
+            newServers[service.id] = config;
+          }
+          const existingConfig = readMcpConfig();
+          let mergedConfig = mergeMcpServers(existingConfig, newServers);
+          mergedConfig = fixWindowsMcpConfig(mergedConfig);
+          try {
+            writeMcpConfig(mergedConfig);
+            console.log(ansis.green(`\u2714 ${i18n.mcp.mcpConfigSuccess}`));
+          } catch (error) {
+            console.error(ansis.red(`${i18n.configuration.failedToWriteMcpConfig} ${error}`));
+          }
+        }
+      }
+    }
+    updateZcfConfig({
+      version,
+      preferredLang: scriptLang,
+      aiOutputLang
+    });
+    console.log(ansis.green(`\u2714 ${i18n.configuration.configSuccess} ${CLAUDE_DIR}`));
+    console.log("\n" + ansis.cyan(i18n.common.complete));
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error, options.lang);
+    }
+  }
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getTemplateSettings() {
+  const templatePath = join(__dirname, "../../templates/settings.json");
+  const content = readFileSync(templatePath, "utf-8");
+  return JSON.parse(content);
+}
+function loadCurrentSettings() {
+  if (!existsSync(SETTINGS_FILE)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(SETTINGS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function saveSettings(settings) {
+  ensureDir(CLAUDE_DIR);
+  writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+}
+async function importRecommendedEnv() {
+  const templateSettings = getTemplateSettings();
+  const currentSettings = loadCurrentSettings();
+  currentSettings.env = {
+    ...currentSettings.env,
+    ...templateSettings.env
+  };
+  saveSettings(currentSettings);
+}
+async function importRecommendedPermissions() {
+  const templateSettings = getTemplateSettings();
+  const currentSettings = loadCurrentSettings();
+  if (templateSettings.permissions && templateSettings.permissions.allow) {
+    currentSettings.permissions = {
+      ...templateSettings.permissions,
+      allow: mergeAndCleanPermissions(
+        templateSettings.permissions.allow,
+        currentSettings.permissions?.allow
+      )
+    };
+  } else {
+    currentSettings.permissions = templateSettings.permissions;
+  }
+  saveSettings(currentSettings);
+}
+async function openSettingsJson() {
+  ensureDir(CLAUDE_DIR);
+  if (!existsSync(SETTINGS_FILE)) {
+    saveSettings({});
+  }
+  const platform = getPlatform();
+  let command;
+  switch (platform) {
+    case "macos":
+      command = "open";
+      break;
+    case "windows":
+      command = "start";
+      break;
+    default:
+      command = "xdg-open";
+  }
+  try {
+    await exec(command, [SETTINGS_FILE]);
+  } catch (error) {
+    try {
+      await exec("code", [SETTINGS_FILE]);
+    } catch {
+      try {
+        await exec("vim", [SETTINGS_FILE]);
+      } catch {
+        await exec("nano", [SETTINGS_FILE]);
+      }
+    }
+  }
+}
+
+export { displayBannerWithInfo as $, AICO_CONFIG_FILE as A, writeMcpConfig as B, CLAUDE_DIR as C, backupMcpConfig as D, mergeMcpServers as E, buildMcpServerConfig as F, fixWindowsMcpConfig as G, addCompletedOnboarding as H, I18N as I, readZcfConfig as J, inquirer as K, LEGACY_AICO_CONFIG_FILE as L, MCP_SERVICES as M, addNumbersToChoices as N, updateZcfConfig as O, getTranslation as P, version as Q, configureAiPersonality as R, SETTINGS_FILE as S, readJsonConfig as T, writeJsonConfig as U, isWindows as V, selectMcpServices as W, displayBanner as X, selectAndInstallWorkflows as Y, handleExitPromptError as Z, handleGeneralError as _, importRecommendedEnv as a, readZcfConfigAsync as a0, executeWithEscapeSupport as a1, EscapeKeyPressed as a2, importRecommendedPermissions as b, commandExists as c, cleanupPermissions as d, CLAUDE_MD_FILE as e, ClAUDE_CONFIG_FILE as f, getPlatform as g, SUPPORTED_LANGS as h, init as i, LANG_LABELS as j, AI_OUTPUT_LANGUAGES as k, isClaudeCodeInstalled as l, mergeAndCleanPermissions as m, installClaudeCode as n, openSettingsJson as o, ensureClaudeDir as p, backupExistingConfig as q, copyConfigFiles as r, configureApi as s, mergeConfigs as t, updateDefaultModel as u, mergeSettingsFile as v, getExistingApiConfig as w, applyAiLanguageDirective as x, getMcpConfigPath as y, readMcpConfig as z };