ccjk 13.3.18 → 13.3.19

package/dist/chunks/features.mjs

@@ -0,0 +1,812 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import process__default from 'node:process';
+import a from './index2.mjs';
+import { i as inquirer } from './index3.mjs';
+import { s as selectMcpServices, g as getMcpServices } from '../shared/ccjk.0aJQmVxS.mjs';
+import { SUPPORTED_LANGS, LANG_LABELS } from './constants.mjs';
+import { ensureI18nInitialized, i18n, changeLanguage } from './index5.mjs';
+import { updateZcfConfig, readZcfConfig } from './ccjk-config.mjs';
+import { setupCcrConfiguration } from './config.mjs';
+import { i as isCcrInstalled, a as installCcr } from '../shared/ccjk.Si-T_ccK.mjs';
+import { r as readMcpConfig, f as fixWindowsMcpConfig, w as writeMcpConfig, b as backupMcpConfig, a as buildMcpServerConfig, m as mergeMcpServers } from './claude-config.mjs';
+import { g as getExistingModelConfig, a as getExistingCustomModelConfig, u as updateCustomModel, d as updateDefaultModel, e as applyAiLanguageDirective, f as getExistingApiConfig, p as promptApiConfigurationAction, h as configureApi, s as switchToOfficialLogin } from './config2.mjs';
+import { c as configureOutputStyle, m as modifyApiConfigPartially, v as validateApiKey, f as formatApiKeyDisplay } from '../shared/ccjk.Dgq22o6V.mjs';
+import { i as isWindows } from './platform.mjs';
+import { a as addNumbersToChoices } from '../shared/ccjk.BFQ7yr5S.mjs';
+import { openSettingsJson, importRecommendedPermissions, importRecommendedEnv } from './simple-config.mjs';
+import { p as promptBoolean } from '../shared/ccjk.BWFpnOr3.mjs';
+import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
+import '../shared/ccjk.BAGoDD49.mjs';
+import 'node:readline';
+import 'stream';
+import 'node:tty';
+import 'node:async_hooks';
+import '../shared/ccjk.Cjgrln_h.mjs';
+import 'node:util';
+import 'tty';
+import 'fs';
+import 'child_process';
+import 'node:path';
+import 'node:crypto';
+import 'buffer';
+import 'string_decoder';
+import 'node:child_process';
+import 'node:url';
+import '../shared/ccjk.BBtCGd_g.mjs';
+import './index6.mjs';
+import './fs-operations.mjs';
+import 'node:fs/promises';
+import './json-config.mjs';
+import '../shared/ccjk.RyizuzOI.mjs';
+import './auto-updater.mjs';
+import './index7.mjs';
+import '../shared/ccjk.DeWpAShp.mjs';
+import './main.mjs';
+import 'module';
+import 'node:stream';
+import './version-checker.mjs';
+import '../shared/ccjk.CxpGa6MC.mjs';
+import '../shared/ccjk.DScm_NnL.mjs';
+
+const DEFAULT_MODEL_CHOICES = [
+  {
+    nameKey: "configuration:defaultModelOption",
+    fallback: "Default - Let Claude Code choose",
+    value: "default"
+  },
+  {
+    nameKey: "configuration:opusModelOption",
+    fallback: "Opus - Only use opus, high token consumption, use with caution",
+    value: "opus"
+  },
+  {
+    nameKey: "configuration:sonnetModelOption",
+    fallback: "Sonnet - Recommended balanced model for daily coding",
+    value: "sonnet"
+  },
+  {
+    nameKey: "configuration:sonnet1mModelOption",
+    fallback: "Sonnet 1M - 1M context version",
+    value: "sonnet[1m]"
+  },
+  {
+    nameKey: "configuration:customModelOption",
+    fallback: "Custom - Specify custom model names",
+    value: "custom"
+  }
+];
+async function handleCancellation() {
+  ensureI18nInitialized();
+  console.log(a.yellow(i18n.t("common:cancelled")));
+}
+async function ensureModelConfigPriority() {
+  const { readJsonConfig, writeJsonConfig } = await import('./json-config.mjs');
+  const { SETTINGS_FILE } = await import('./constants.mjs');
+  const settings = readJsonConfig(SETTINGS_FILE);
+  if (!settings)
+    return;
+  if (settings.env?.ANTHROPIC_DEFAULT_HAIKU_MODEL && settings.env.ANTHROPIC_SMALL_FAST_MODEL !== settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL) {
+    settings.env.ANTHROPIC_SMALL_FAST_MODEL = settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+    writeJsonConfig(SETTINGS_FILE, settings);
+  }
+}
+async function handleOfficialLoginMode() {
+  ensureI18nInitialized();
+  const success = switchToOfficialLogin();
+  if (success) {
+    console.log(a.green(`\u2714 ${i18n.t("api:officialLoginConfigured")}`));
+  } else {
+    console.log(a.red(i18n.t("api:officialLoginFailed")));
+  }
+}
+async function handleCustomApiMode() {
+  ensureI18nInitialized();
+  const zcfConfig = readZcfConfig();
+  const codeToolType = zcfConfig?.codeToolType || "claude-code";
+  if (codeToolType === "claude-code") {
+    const { configureIncrementalManagement } = await import('./claude-code-incremental-manager.mjs');
+    await configureIncrementalManagement();
+    return;
+  }
+  const existingConfig = getExistingApiConfig();
+  if (existingConfig) {
+    const configAction = await promptApiConfigurationAction();
+    if (configAction === "keep-existing") {
+      console.log(a.green(`\u2714 ${i18n.t("api:keepExistingConfig")}`));
+      return;
+    } else if (configAction === "modify-partial") {
+      await modifyApiConfigPartially(existingConfig);
+      return;
+    }
+  }
+  const { apiChoice } = await inquirer.prompt({
+    type: "list",
+    name: "apiChoice",
+    message: i18n.t("api:configureApi"),
+    choices: addNumbersToChoices([
+      {
+        name: `${i18n.t("api:useAuthToken")} - ${a.gray(i18n.t("api:authTokenDesc"))}`,
+        value: "auth_token",
+        short: i18n.t("api:useAuthToken")
+      },
+      {
+        name: `${i18n.t("api:useApiKey")} - ${a.gray(i18n.t("api:apiKeyDesc"))}`,
+        value: "api_key",
+        short: i18n.t("api:useApiKey")
+      },
+      { name: i18n.t("api:skipApi"), value: "skip" }
+    ])
+  });
+  if (!apiChoice || apiChoice === "skip") {
+    await handleCancellation();
+    return;
+  }
+  const { url } = await inquirer.prompt({
+    type: "input",
+    name: "url",
+    message: `${i18n.t("api:enterApiUrl")}${i18n.t("common:emptyToSkip")}`,
+    validate: (value) => {
+      if (!value) {
+        return true;
+      }
+      try {
+        void new URL(value);
+        return true;
+      } catch {
+        return i18n.t("api:invalidUrl");
+      }
+    }
+  });
+  if (url === void 0 || !url) {
+    await handleCancellation();
+    return;
+  }
+  const keyMessage = apiChoice === "auth_token" ? `${i18n.t("api:enterAuthToken")}${i18n.t("common:emptyToSkip")}` : `${i18n.t("api:enterApiKey")}${i18n.t("common:emptyToSkip")}`;
+  const { key } = await inquirer.prompt({
+    type: "input",
+    name: "key",
+    message: keyMessage,
+    validate: (value) => {
+      if (!value) {
+        return true;
+      }
+      const validation = validateApiKey(value);
+      if (!validation.isValid) {
+        return validation.error || i18n.t("api:invalidKeyFormat");
+      }
+      return true;
+    }
+  });
+  if (key === void 0 || !key) {
+    await handleCancellation();
+    return;
+  }
+  const apiConfig = { url, key, authType: apiChoice };
+  const configuredApi = configureApi(apiConfig);
+  if (configuredApi) {
+    console.log(a.green(`\u2714 ${i18n.t("api:apiConfigSuccess")}`));
+    console.log(a.gray(`  URL: ${configuredApi.url}`));
+    console.log(a.gray(`  Key: ${formatApiKeyDisplay(configuredApi.key)}`));
+  }
+}
+async function handleCcrProxyMode() {
+  ensureI18nInitialized();
+  const ccrStatus = await isCcrInstalled();
+  if (!ccrStatus.hasCorrectPackage) {
+    await installCcr();
+  } else {
+    console.log(a.green(`\u2714 ${i18n.t("ccr:ccrAlreadyInstalled")}`));
+  }
+  const ccrConfigured = await setupCcrConfiguration();
+  if (ccrConfigured) {
+    console.log(a.green(`\u2714 ${i18n.t("ccr:ccrSetupComplete")}`));
+  }
+}
+async function handleSwitchConfigMode() {
+  ensureI18nInitialized();
+  const { configSwitchCommand } = await import('./config-switch.mjs');
+  await configSwitchCommand({ codeType: "claude-code" });
+}
+async function configureApiFeature() {
+  ensureI18nInitialized();
+  const { mode } = await inquirer.prompt({
+    type: "list",
+    name: "mode",
+    message: i18n.t("api:apiModePrompt"),
+    choices: addNumbersToChoices([
+      { name: i18n.t("api:apiModeOfficial"), value: "official" },
+      { name: i18n.t("api:apiModeCustom"), value: "custom" },
+      { name: i18n.t("api:apiModeCcr"), value: "ccr" },
+      { name: i18n.t("api:apiModeSwitch"), value: "switch" },
+      { name: i18n.t("api:apiModeSkip"), value: "skip" }
+    ])
+  });
+  if (!mode || mode === "skip") {
+    await ensureModelConfigPriority();
+    await handleCancellation();
+    return;
+  }
+  switch (mode) {
+    case "official":
+      await handleOfficialLoginMode();
+      break;
+    case "custom":
+      await handleCustomApiMode();
+      break;
+    case "ccr":
+      await handleCcrProxyMode();
+      break;
+    case "switch":
+      await handleSwitchConfigMode();
+      break;
+    default:
+      await handleCancellation();
+      break;
+  }
+  await ensureModelConfigPriority();
+}
+async function configureMcpFeature() {
+  ensureI18nInitialized();
+  if (isWindows()) {
+    const fixWindows = await promptBoolean({
+      message: i18n.t("configuration:fixWindowsMcp") || "Fix Windows MCP configuration?",
+      defaultValue: true
+    });
+    if (fixWindows) {
+      const existingConfig = readMcpConfig() || { mcpServers: {} };
+      const fixedConfig = fixWindowsMcpConfig(existingConfig);
+      writeMcpConfig(fixedConfig);
+      console.log(a.green(`\u2714 ${i18n.t("configuration:windowsMcpConfigFixed")}`));
+    }
+  }
+  const selectedServices = await selectMcpServices();
+  if (!selectedServices) {
+    return;
+  }
+  if (selectedServices.length > 0) {
+    const mcpBackupPath = backupMcpConfig();
+    if (mcpBackupPath) {
+      console.log(a.gray(`\u2714 ${i18n.t("mcp:mcpBackupSuccess")}: ${mcpBackupPath}`));
+    }
+    const newServers = {};
+    for (const serviceId of selectedServices) {
+      const service = (await getMcpServices()).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,
+          validate: async (value) => !!value || i18n.t("api:keyRequired")
+        });
+        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);
+    writeMcpConfig(mergedConfig);
+    console.log(a.green(`\u2714 ${i18n.t("mcp:mcpConfigSuccess")}`));
+  }
+}
+async function configureDefaultModelFeature() {
+  ensureI18nInitialized();
+  const existingModel = getExistingModelConfig();
+  if (existingModel) {
+    console.log(`
+${a.green(`\u2139 ${i18n.t("configuration:existingModelConfig") || "Existing model configuration"}`)}`);
+    const modelDisplay = existingModel === "default" ? i18n.t("configuration:defaultModelOption") || "Default (Let Claude Code choose)" : existingModel.charAt(0).toUpperCase() + existingModel.slice(1);
+    console.log(a.gray(`  ${i18n.t("configuration:currentModel") || "Current model"}: ${modelDisplay}
+`));
+    const modify = await promptBoolean({
+      message: i18n.t("configuration:modifyModel") || "Modify model configuration?",
+      defaultValue: false
+    });
+    if (!modify) {
+      console.log(a.green(`\u2714 ${i18n.t("configuration:keepModel") || "Keeping existing model configuration"}`));
+      return;
+    }
+  }
+  const { model } = await inquirer.prompt({
+    type: "rawlist",
+    name: "model",
+    message: i18n.t("configuration:selectDefaultModel") || "Select default model",
+    choices: addNumbersToChoices(
+      DEFAULT_MODEL_CHOICES.map((choice) => ({
+        name: i18n.t(choice.nameKey) || choice.fallback,
+        value: choice.value
+      }))
+    ),
+    default: existingModel ? DEFAULT_MODEL_CHOICES.findIndex((choice) => choice.value === existingModel) : 0
+  });
+  if (!model) {
+    await handleCancellation();
+    return;
+  }
+  if (model === "custom") {
+    const existingCustomConfig = getExistingCustomModelConfig();
+    const { primaryModel, haikuModel, sonnetModel, opusModel } = await promptCustomModels(
+      existingCustomConfig?.primaryModel,
+      existingCustomConfig?.haikuModel,
+      existingCustomConfig?.sonnetModel,
+      existingCustomConfig?.opusModel
+    );
+    if (!primaryModel.trim() && !haikuModel.trim() && !sonnetModel.trim() && !opusModel.trim()) {
+      console.log(a.yellow(`\u26A0 ${i18n.t("configuration:customModelSkipped") || "Custom model configuration skipped"}`));
+      return;
+    }
+    updateCustomModel(primaryModel, haikuModel, sonnetModel, opusModel);
+    console.log(a.green(`\u2714 ${i18n.t("configuration:customModelConfigured") || "Custom model configuration completed"}`));
+    return;
+  }
+  updateDefaultModel(model);
+  console.log(a.green(`\u2714 ${i18n.t("configuration:modelConfigured") || "Default model configured"}`));
+}
+async function promptCustomModels(defaultPrimaryModel, defaultHaikuModel, defaultSonnetModel, defaultOpusModel) {
+  const { primaryModel } = await inquirer.prompt({
+    type: "input",
+    name: "primaryModel",
+    message: `${i18n.t("configuration:enterPrimaryModel")}${i18n.t("common:emptyToSkip")}`,
+    default: defaultPrimaryModel || ""
+  });
+  const { haikuModel } = await inquirer.prompt({
+    type: "input",
+    name: "haikuModel",
+    message: `${i18n.t("configuration:enterHaikuModel")}${i18n.t("common:emptyToSkip")}`,
+    default: defaultHaikuModel || ""
+  });
+  const { sonnetModel } = await inquirer.prompt({
+    type: "input",
+    name: "sonnetModel",
+    message: `${i18n.t("configuration:enterSonnetModel")}${i18n.t("common:emptyToSkip")}`,
+    default: defaultSonnetModel || ""
+  });
+  const { opusModel } = await inquirer.prompt({
+    type: "input",
+    name: "opusModel",
+    message: `${i18n.t("configuration:enterOpusModel")}${i18n.t("common:emptyToSkip")}`,
+    default: defaultOpusModel || ""
+  });
+  return { primaryModel, haikuModel, sonnetModel, opusModel };
+}
+async function configureAiMemoryFeature() {
+  ensureI18nInitialized();
+  const isZh = i18n.language === "zh-CN";
+  const { option } = await inquirer.prompt({
+    type: "list",
+    name: "option",
+    message: isZh ? "\u9009\u62E9 AI \u8BB0\u5FC6\u7BA1\u7406\u9009\u9879" : "Select AI memory management option",
+    choices: addNumbersToChoices([
+      {
+        name: isZh ? "\u{1F4C4} \u67E5\u770B\u5168\u5C40 CLAUDE.md\uFF08\u7CFB\u7EDF\u63D0\u793A\uFF09" : "\u{1F4C4} View global CLAUDE.md (system prompt)",
+        value: "viewGlobalClaudeMd"
+      },
+      {
+        name: isZh ? "\u{1F4C1} \u67E5\u770B\u9879\u76EE CLAUDE.md" : "\u{1F4C1} View project CLAUDE.md",
+        value: "viewProjectClaudeMd"
+      },
+      {
+        name: isZh ? "\u{1F52C} \u67E5\u770B Postmortem\uFF08\u5386\u53F2 Bug \u7ECF\u9A8C\uFF09" : "\u{1F52C} View Postmortem (bug lessons learned)",
+        value: "viewPostmortem"
+      },
+      {
+        name: isZh ? "\u270F\uFE0F \u7F16\u8F91\u5168\u5C40 CLAUDE.md" : "\u270F\uFE0F Edit global CLAUDE.md",
+        value: "editGlobalClaudeMd"
+      },
+      {
+        name: isZh ? "\u{1F310} \u914D\u7F6E AI \u8F93\u51FA\u8BED\u8A00" : "\u{1F310} Configure AI output language",
+        value: "language"
+      },
+      {
+        name: isZh ? "\u{1F3A8} \u914D\u7F6E\u8F93\u51FA\u98CE\u683C" : "\u{1F3A8} Configure output style",
+        value: "outputStyle"
+      }
+    ])
+  });
+  if (!option) {
+    return;
+  }
+  const cwd = process__default.cwd();
+  const globalClaudeMdPath = join(homedir(), ".claude", "CLAUDE.md");
+  const projectClaudeMdPath = join(cwd, "CLAUDE.md");
+  const localClaudeMdPath = join(cwd, ".claude", "CLAUDE.md");
+  switch (option) {
+    case "viewGlobalClaudeMd": {
+      if (existsSync(globalClaudeMdPath)) {
+        console.log(a.green.bold(`
+\u{1F4C4} ${isZh ? "\u5168\u5C40 CLAUDE.md \u5185\u5BB9" : "Global CLAUDE.md Content"}:`));
+        console.log(a.dim("\u2500".repeat(60)));
+        const content = readFileSync(globalClaudeMdPath, "utf-8");
+        console.log(content);
+        console.log(a.dim("\u2500".repeat(60)));
+        console.log(a.gray(`${isZh ? "\u8DEF\u5F84" : "Path"}: ${globalClaudeMdPath}`));
+      } else {
+        console.log(a.yellow(`
+\u26A0\uFE0F ${isZh ? "\u5168\u5C40 CLAUDE.md \u4E0D\u5B58\u5728" : "Global CLAUDE.md does not exist"}`));
+        console.log(a.gray(`${isZh ? "\u9884\u671F\u8DEF\u5F84" : "Expected path"}: ${globalClaudeMdPath}`));
+      }
+      break;
+    }
+    case "viewProjectClaudeMd": {
+      let foundPath = null;
+      if (existsSync(projectClaudeMdPath)) {
+        foundPath = projectClaudeMdPath;
+      } else if (existsSync(localClaudeMdPath)) {
+        foundPath = localClaudeMdPath;
+      }
+      if (foundPath) {
+        console.log(a.green.bold(`
+\u{1F4C1} ${isZh ? "\u9879\u76EE CLAUDE.md \u5185\u5BB9" : "Project CLAUDE.md Content"}:`));
+        console.log(a.dim("\u2500".repeat(60)));
+        const content = readFileSync(foundPath, "utf-8");
+        console.log(content);
+        console.log(a.dim("\u2500".repeat(60)));
+        console.log(a.gray(`${isZh ? "\u8DEF\u5F84" : "Path"}: ${foundPath}`));
+      } else {
+        console.log(a.yellow(`
+\u26A0\uFE0F ${isZh ? "\u9879\u76EE CLAUDE.md \u4E0D\u5B58\u5728" : "Project CLAUDE.md does not exist"}`));
+        console.log(a.gray(`${isZh ? "\u5DF2\u68C0\u67E5\u8DEF\u5F84" : "Checked paths"}:`));
+        console.log(a.gray(`  - ${projectClaudeMdPath}`));
+        console.log(a.gray(`  - ${localClaudeMdPath}`));
+      }
+      break;
+    }
+    case "viewPostmortem": {
+      const postmortemDir = join(cwd, ".postmortem");
+      if (existsSync(postmortemDir)) {
+        console.log(a.green.bold(`
+\u{1F52C} ${isZh ? "Postmortem \u62A5\u544A" : "Postmortem Reports"}:`));
+        console.log(a.dim("\u2500".repeat(60)));
+        const { readdirSync } = await import('node:fs');
+        const files = readdirSync(postmortemDir).filter((f) => f.endsWith(".md"));
+        if (files.length === 0) {
+          console.log(a.yellow(isZh ? "\u6682\u65E0 Postmortem \u62A5\u544A" : "No postmortem reports yet"));
+        } else {
+          console.log(a.green(`${isZh ? "\u627E\u5230" : "Found"} ${files.length} ${isZh ? "\u4E2A\u62A5\u544A" : "reports"}:
+`));
+          const { selectedFile } = await inquirer.prompt({
+            type: "list",
+            name: "selectedFile",
+            message: isZh ? "\u9009\u62E9\u8981\u67E5\u770B\u7684\u62A5\u544A" : "Select a report to view",
+            choices: [
+              ...files.map((f) => ({ name: f, value: f })),
+              { name: isZh ? "\u8FD4\u56DE" : "Back", value: "back" }
+            ]
+          });
+          if (selectedFile !== "back") {
+            const reportPath = join(postmortemDir, selectedFile);
+            const content = readFileSync(reportPath, "utf-8");
+            console.log(a.dim("\u2500".repeat(60)));
+            console.log(content);
+            console.log(a.dim("\u2500".repeat(60)));
+          }
+        }
+        console.log(a.gray(`
+${isZh ? "\u76EE\u5F55" : "Directory"}: ${postmortemDir}`));
+        console.log(a.gray(`\u{1F4A1} ${isZh ? "\u8FD0\u884C `ccjk postmortem init` \u4ECE\u5386\u53F2 fix commits \u751F\u6210\u62A5\u544A" : "Run `ccjk postmortem init` to generate reports from fix commits"}`));
+      } else {
+        console.log(a.yellow(`
+\u26A0\uFE0F ${isZh ? "Postmortem \u76EE\u5F55\u4E0D\u5B58\u5728" : "Postmortem directory does not exist"}`));
+        console.log(a.gray(`\u{1F4A1} ${isZh ? "\u8FD0\u884C `ccjk postmortem init` \u521D\u59CB\u5316 Postmortem \u7CFB\u7EDF" : "Run `ccjk postmortem init` to initialize the Postmortem system"}`));
+      }
+      break;
+    }
+    case "editGlobalClaudeMd": {
+      const editor = process__default.env.EDITOR || process__default.env.VISUAL || "vi";
+      if (!existsSync(globalClaudeMdPath)) {
+        const claudeDir = join(homedir(), ".claude");
+        if (!existsSync(claudeDir)) {
+          mkdirSync(claudeDir, { recursive: true });
+        }
+        writeFileSync(globalClaudeMdPath, `# Claude Global Memory
+
+<!-- Add your global instructions here -->
+`);
+        console.log(a.green(`\u2705 ${isZh ? "\u5DF2\u521B\u5EFA\u5168\u5C40 CLAUDE.md" : "Created global CLAUDE.md"}`));
+      }
+      console.log(a.green(`
+\u{1F4DD} ${isZh ? "\u6B63\u5728\u6253\u5F00\u7F16\u8F91\u5668..." : "Opening editor..."}`));
+      console.log(a.gray(`${isZh ? "\u7F16\u8F91\u5668" : "Editor"}: ${editor}`));
+      console.log(a.gray(`${isZh ? "\u6587\u4EF6" : "File"}: ${globalClaudeMdPath}`));
+      try {
+        const { execSync } = await import('node:child_process');
+        execSync(`${editor} "${globalClaudeMdPath}"`, { stdio: "inherit" });
+        console.log(a.green(`
+\u2705 ${isZh ? "\u7F16\u8F91\u5B8C\u6210" : "Edit complete"}`));
+      } catch {
+        console.log(a.yellow(`
+\u26A0\uFE0F ${isZh ? "\u7F16\u8F91\u5668\u9000\u51FA" : "Editor exited"}`));
+      }
+      break;
+    }
+    case "language": {
+      const zcfConfig = readZcfConfig();
+      const existingLang = zcfConfig?.aiOutputLang;
+      if (existingLang) {
+        console.log(
+          `
+${a.green(`\u2139 ${i18n.t("configuration:existingLanguageConfig") || "Existing AI output language configuration"}`)}`
+        );
+        console.log(a.gray(`  ${i18n.t("configuration:currentLanguage") || "Current language"}: ${existingLang}
+`));
+        const modify = await promptBoolean({
+          message: i18n.t("configuration:modifyLanguage") || "Modify AI output language?",
+          defaultValue: false
+        });
+        if (!modify) {
+          console.log(a.green(`\u2714 ${i18n.t("configuration:keepLanguage") || "Keeping existing language configuration"}`));
+          return;
+        }
+      }
+      const { selectAiOutputLanguage } = await import('./prompts.mjs');
+      const aiOutputLang = await selectAiOutputLanguage();
+      applyAiLanguageDirective(aiOutputLang);
+      updateZcfConfig({ aiOutputLang });
+      console.log(a.green(`\u2714 ${i18n.t("configuration:aiLanguageConfigured") || "AI output language configured"}`));
+      break;
+    }
+    case "outputStyle": {
+      await configureOutputStyle();
+      break;
+    }
+  }
+}
+async function changeScriptLanguageFeature(currentLang) {
+  ensureI18nInitialized();
+  const { lang } = await inquirer.prompt({
+    type: "list",
+    name: "lang",
+    message: i18n.t("language:selectScriptLang"),
+    choices: addNumbersToChoices(
+      SUPPORTED_LANGS.map((l) => ({
+        name: LANG_LABELS[l],
+        value: l
+      }))
+    ),
+    default: SUPPORTED_LANGS.indexOf(currentLang)
+  });
+  if (!lang) {
+    return currentLang;
+  }
+  updateZcfConfig({ preferredLang: lang });
+  await changeLanguage(lang);
+  console.log(a.green(`\u2714 ${i18n.t("language:languageChanged") || "Language changed"}`));
+  return lang;
+}
+async function mcpManagerFeature() {
+  ensureI18nInitialized();
+  const isZh = i18n.language === "zh-CN";
+  const { choice } = await inquirer.prompt({
+    type: "list",
+    name: "choice",
+    message: isZh ? "\u{1F527} MCP \u7BA1\u7406 \u2014 \u9009\u62E9\u64CD\u4F5C:" : "\u{1F527} MCP Manager \u2014 Select action:",
+    choices: addNumbersToChoices([
+      {
+        name: isZh ? `\u{1F4CA} \u67E5\u770B MCP \u72B6\u6001  ${a.gray("- \u5DF2\u5B89\u88C5\u670D\u52A1\u603B\u89C8 + \u6027\u80FD\u9884\u8B66")}` : `\u{1F4CA} MCP Status  ${a.gray("- Installed services overview + performance warning")}`,
+        value: "status"
+      },
+      {
+        name: isZh ? `\u{1FA7A} MCP \u8BCA\u65AD  ${a.gray("- \u5065\u5EB7\u68C0\u67E5\u3001\u51B2\u7A81\u68C0\u6D4B\u3001\u4F18\u5316\u5EFA\u8BAE")}` : `\u{1FA7A} MCP Doctor  ${a.gray("- Health check, conflict detection, optimization tips")}`,
+        value: "doctor"
+      },
+      {
+        name: isZh ? `\u{1F4CB} \u5217\u51FA\u5DF2\u5B89\u88C5\u670D\u52A1  ${a.gray("- \u67E5\u770B\u5DF2\u914D\u7F6E\u7684 MCP \u670D\u52A1\u8BE6\u60C5")}` : `\u{1F4CB} List installed services  ${a.gray("- View details of configured MCP services")}`,
+        value: "list"
+      },
+      {
+        name: isZh ? `\u{1F504} \u5207\u6362\u914D\u7F6E\u9884\u8BBE  ${a.gray("- minimal\uFF08\u8F7B\u91CF\uFF09/ dev\uFF08\u5F00\u53D1\uFF09/ full\uFF08\u5B8C\u6574\uFF09")}` : `\u{1F504} Switch profile  ${a.gray("- minimal / dev / full preset")}`,
+        value: "profile"
+      },
+      {
+        name: isZh ? `\u{1F5D1}\uFE0F \u91CA\u653E\u95F2\u7F6E\u670D\u52A1  ${a.gray("- \u505C\u7528\u957F\u671F\u672A\u4F7F\u7528\u7684\u670D\u52A1\u4EE5\u8282\u7701\u8D44\u6E90")}` : `\u{1F5D1}\uFE0F Release idle services  ${a.gray("- Disable unused services to free resources")}`,
+        value: "release"
+      },
+      {
+        name: isZh ? `\u{1F4E6} \u5B89\u88C5/\u66F4\u65B0 MCP \u670D\u52A1  ${a.gray("- \u8FDB\u5165\u670D\u52A1\u9009\u62E9\u5411\u5BFC\uFF08\u540C\u83DC\u5355\u9009\u9879 4\uFF09")}` : `\u{1F4E6} Install / Update services  ${a.gray("- Open install wizard (same as menu option 4)")}`,
+        value: "install"
+      }
+    ])
+  });
+  if (!choice) {
+    await handleCancellation();
+    return;
+  }
+  try {
+    switch (choice) {
+      case "status": {
+        const { mcpStatus } = await import('./mcp.mjs');
+        await mcpStatus();
+        break;
+      }
+      case "doctor": {
+        const { mcpDoctor } = await import('./mcp.mjs');
+        await mcpDoctor();
+        break;
+      }
+      case "list": {
+        const { mcpList } = await import('./mcp.mjs');
+        await mcpList();
+        break;
+      }
+      case "profile": {
+        const { listProfiles, useProfile } = await import('./mcp.mjs');
+        await listProfiles();
+        const { profileId } = await inquirer.prompt({
+          type: "list",
+          name: "profileId",
+          message: isZh ? "\u9009\u62E9\u8981\u5207\u6362\u7684\u9884\u8BBE:" : "Select profile to switch:",
+          choices: [
+            { name: isZh ? "minimal \u2014 \u4EC5\u6838\u5FC3\u670D\u52A1\uFF08\u6700\u4F4E\u8D44\u6E90\u5360\u7528\uFF09" : "minimal \u2014 Core services only (least resources)", value: "minimal" },
+            { name: isZh ? "dev \u2014 \u5F00\u53D1\u5E38\u7528\u670D\u52A1\u5957\u88C5" : "dev \u2014 Dev-oriented service bundle", value: "dev" },
+            { name: isZh ? "full \u2014 \u5B8C\u6574\u670D\u52A1\uFF08\u9AD8\u6027\u80FD\u673A\u5668\u63A8\u8350\uFF09" : "full \u2014 Full services (high-end machines)", value: "full" }
+          ]
+        });
+        await useProfile(profileId);
+        break;
+      }
+      case "release": {
+        const { mcpRelease } = await import('./mcp.mjs');
+        await mcpRelease();
+        break;
+      }
+      case "install": {
+        await configureMcpFeature();
+        break;
+      }
+    }
+  } catch (error) {
+    console.error(a.red(`${i18n.t("common:error")}: ${error.message}`));
+  }
+}
+async function configureMergedPermissionsFeature() {
+  ensureI18nInitialized();
+  const isZh = i18n.language === "zh-CN";
+  const { choice } = await inquirer.prompt({
+    type: "list",
+    name: "choice",
+    message: isZh ? "\u6743\u9650 & \u73AF\u5883\u914D\u7F6E \u2014 \u9009\u62E9\u64CD\u4F5C:" : "Permissions & Env Setup \u2014 Select action:",
+    choices: addNumbersToChoices([
+      {
+        name: isZh ? `\u5BFC\u5165\u63A8\u8350\u73AF\u5883\u53D8\u91CF  ${a.gray("- \u5199\u5165\u9690\u79C1\u4FDD\u62A4 env \u5230 settings.json")}` : `Import recommended env vars  ${a.gray("- Write privacy env to settings.json")}`,
+        value: "env"
+      },
+      {
+        name: isZh ? `\u5BFC\u5165\u63A8\u8350\u6743\u9650\u914D\u7F6E  ${a.gray("- \u8FFD\u52A0\u63A8\u8350 allow \u89C4\u5219\u5230 settings.json")}` : `Import recommended permissions  ${a.gray("- Append recommended allow rules")}`,
+        value: "permissions"
+      },
+      {
+        name: isZh ? `\u4E00\u952E\u6743\u9650\u9884\u8BBE  ${a.gray("- \u6700\u5927(max) / \u5F00\u53D1\u8005(dev) / \u5B89\u5168(safe) \u9884\u8BBE")}` : `Zero-config permission preset  ${a.gray("- max / dev / safe preset")}`,
+        value: "preset"
+      },
+      {
+        name: isZh ? `\u6253\u5F00 settings.json  ${a.gray("- \u5728\u7F16\u8F91\u5668\u4E2D\u67E5\u770B\u5F53\u524D\u914D\u7F6E")}` : `Open settings.json  ${a.gray("- View current config in editor")}`,
+        value: "open"
+      }
+    ])
+  });
+  if (!choice) {
+    await handleCancellation();
+    return;
+  }
+  try {
+    switch (choice) {
+      case "env":
+        await importRecommendedEnv();
+        console.log(a.green(`\u2705 ${i18n.t("configuration:envImportSuccess")}`));
+        break;
+      case "permissions":
+        await importRecommendedPermissions();
+        console.log(a.green(`\u2705 ${i18n.t("configuration:permissionsImportSuccess") || "Permissions imported"}`));
+        break;
+      case "preset": {
+        const { zeroConfig } = await import('./zero-config.mjs');
+        await zeroConfig();
+        break;
+      }
+      case "open":
+        console.log(a.green(i18n.t("configuration:openingSettingsJson") || "Opening settings.json..."));
+        await openSettingsJson();
+        break;
+    }
+  } catch (error) {
+    console.error(a.red(`${i18n.t("common:error")}: ${error.message}`));
+  }
+}
+async function configureMemoryFeature() {
+  const { AutoMemoryBridge } = await import('./auto-memory-bridge.mjs');
+  const inquirer2 = (await import('./index3.mjs').then(function (n) { return n.c; })).default;
+  const ansis2 = (await import('./index2.mjs')).default;
+  const { execSync } = await import('node:child_process');
+  const fs = await import('node:fs/promises');
+  const path = await import('node:path');
+  const os = await import('node:os');
+  console.log(ansis2.cyan(`
+${i18n.t("memory:title")}`));
+  const bridge = new AutoMemoryBridge();
+  const claudeMemoryPath = path.join(os.homedir(), ".claude", "projects", "-Users-lu-ccjk-public", "memory", "MEMORY.md");
+  const ccjkMemoryPath = path.join(os.homedir(), ".ccjk", "memory", "MEMORY.md");
+  let claudeMemoryExists = false;
+  let ccjkMemoryExists = false;
+  try {
+    await fs.access(claudeMemoryPath);
+    claudeMemoryExists = true;
+  } catch {
+  }
+  try {
+    await fs.access(ccjkMemoryPath);
+    ccjkMemoryExists = true;
+  } catch {
+  }
+  console.log(`
+${ansis2.bold(i18n.t("memory:currentStatus"))}`);
+  console.log(ansis2.gray("\u2500".repeat(50)));
+  console.log(`${ansis2.yellow(i18n.t("memory:claudeMemory"))}: ${claudeMemoryExists ? ansis2.green("\u2713") : ansis2.red("\u2717")}`);
+  console.log(`${ansis2.yellow(i18n.t("memory:ccjkMemory"))}: ${ccjkMemoryExists ? ansis2.green("\u2713") : ansis2.red("\u2717")}`);
+  console.log(ansis2.gray("\u2500".repeat(50)));
+  const { action } = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: i18n.t("memory:selectAction"),
+      choices: [
+        { name: i18n.t("memory:viewMemory"), value: "view" },
+        { name: i18n.t("memory:editMemory"), value: "edit" },
+        { name: i18n.t("memory:syncNow"), value: "sync" },
+        { name: i18n.t("memory:configureRules"), value: "rules" },
+        { name: i18n.t("memory:back"), value: "back" }
+      ]
+    }
+  ]);
+  switch (action) {
+    case "view": {
+      const memoryPath = path.join(os.homedir(), ".claude", "projects", "-Users-lu-ccjk-public", "memory", "MEMORY.md");
+      try {
+        const content = await fs.readFile(memoryPath, "utf-8");
+        console.log(`
+${ansis2.bold(i18n.t("memory:memoryContent"))}`);
+        console.log(ansis2.gray("\u2500".repeat(50)));
+        console.log(content);
+        console.log(ansis2.gray("\u2500".repeat(50)));
+      } catch (error) {
+        console.log(ansis2.red(i18n.t("memory:readError")));
+      }
+      break;
+    }
+    case "edit": {
+      const memoryPath = path.join(os.homedir(), ".claude", "projects", "-Users-lu-ccjk-public", "memory", "MEMORY.md");
+      const editor = process__default.env.EDITOR || "nano";
+      try {
+        execSync(`${editor} "${memoryPath}"`, { stdio: "inherit" });
+        console.log(ansis2.green(i18n.t("memory:editComplete")));
+      } catch (error) {
+        console.log(ansis2.red(i18n.t("memory:editError")));
+      }
+      break;
+    }
+    case "sync": {
+      console.log(ansis2.cyan(i18n.t("memory:syncing")));
+      try {
+        await bridge.syncToClaude();
+        console.log(ansis2.green(i18n.t("memory:syncComplete")));
+      } catch (error) {
+        console.log(ansis2.red(i18n.t("memory:syncError")));
+      }
+      break;
+    }
+    case "rules": {
+      console.log(ansis2.yellow(i18n.t("memory:rulesInfo")));
+      console.log(i18n.t("memory:rulesDescription"));
+      break;
+    }
+  }
+}
+
+export { DEFAULT_MODEL_CHOICES, changeScriptLanguageFeature, configureAiMemoryFeature, configureApiFeature, configureDefaultModelFeature, configureMcpFeature, configureMemoryFeature, configureMergedPermissionsFeature, handleCustomApiMode, mcpManagerFeature, promptCustomModels };