zcf 1.2.0 → 2.0.0

package/dist/cli.mjs

@@ -1,17 +1,20 @@
 #!/usr/bin/env node
 import cac from 'cac';
 import ansis from 'ansis';
-import { v as displayBanner, x as selectScriptLanguage, y as readZcfConfig, I as I18N, S as SETTINGS_FILE, d as SUPPORTED_LANGS, L as LANG_LABELS, z as resolveAiOutputLanguage, B as updatePromptOnly, D as updateZcfConfig, E as version, i as init } from './shared/zcf.D3MMT8L8.mjs';
+import { z as displayBanner, B as selectScriptLanguage, D as readZcfConfig, I as I18N, S as SETTINGS_FILE, d as SUPPORTED_LANGS, L as LANG_LABELS, E as resolveAiOutputLanguage, F as updatePromptOnly, G as updateZcfConfig, H as version, Z as ZCF_CONFIG_FILE, p as applyAiLanguageDirective, J as configureAiPersonality, u as updateDefaultModel, K as isWindows, r as readMcpConfig, x as fixWindowsMcpConfig, w as writeMcpConfig, M as MCP_SERVICES, s as backupMcpConfig, v as buildMcpServerConfig, t as mergeMcpServers, o as getExistingApiConfig, N as formatApiKeyDisplay, O as modifyApiConfigPartially, P as validateApiKey, l as configureApi, Q as displayBannerWithInfo, i as init } from './shared/zcf.DGNSM22u.mjs';
 import prompts from '@posva/prompts';
-import { existsSync } from 'node:fs';
+import { existsSync, unlinkSync } from 'node:fs';
 import 'node:os';
 import 'pathe';
 import 'dayjs';
+import 'node:url';
 import 'tinyexec';
 
 async function update(options = {}) {
   try {
-    displayBanner("Update configuration for Claude Code");
+    if (!options.skipBanner) {
+      displayBanner("Update configuration for Claude Code");
+    }
     const scriptLang = await selectScriptLanguage();
     const zcfConfig = readZcfConfig();
     const i18n = I18N[scriptLang];
@@ -58,11 +61,426 @@ ${i18n.updatingPrompts}
   }
 }
 
+function handleCancellation(scriptLang) {
+  console.log(ansis.yellow(I18N[scriptLang].cancelled));
+}
+async function configureApiFeature(scriptLang) {
+  const i18n = I18N[scriptLang];
+  const existingApiConfig = getExistingApiConfig();
+  if (existingApiConfig) {
+    console.log("\n" + ansis.blue(`\u2139 ${i18n.existingApiConfig}`));
+    console.log(ansis.gray(`  ${i18n.apiConfigUrl}: ${existingApiConfig.url || i18n.notConfigured}`));
+    console.log(ansis.gray(`  ${i18n.apiConfigKey}: ${existingApiConfig.key ? formatApiKeyDisplay(existingApiConfig.key) : i18n.notConfigured}`));
+    console.log(ansis.gray(`  ${i18n.apiConfigAuthType}: ${existingApiConfig.authType || i18n.notConfigured}
+`));
+    const actionResponse = await prompts({
+      type: "select",
+      name: "action",
+      message: i18n.selectApiAction,
+      choices: [
+        { title: i18n.keepExistingConfig, value: "keep" },
+        { title: i18n.modifyAllConfig, value: "modify-all" },
+        { title: i18n.modifyPartialConfig, value: "modify-partial" }
+      ]
+    });
+    if (!actionResponse.action) {
+      handleCancellation(scriptLang);
+      return;
+    }
+    if (actionResponse.action === "keep") {
+      console.log(ansis.green(`\u2714 ${i18n.keepExistingConfig}`));
+      return;
+    } else if (actionResponse.action === "modify-partial") {
+      await modifyApiConfigPartially(existingApiConfig, i18n, scriptLang);
+      return;
+    }
+  }
+  const apiResponse = await prompts({
+    type: "select",
+    name: "apiChoice",
+    message: i18n.configureApi,
+    choices: [
+      {
+        title: i18n.useAuthToken,
+        value: "auth_token",
+        description: ansis.gray(i18n.authTokenDesc)
+      },
+      {
+        title: i18n.useApiKey,
+        value: "api_key",
+        description: ansis.gray(i18n.apiKeyDesc)
+      },
+      {
+        title: i18n.skipApi,
+        value: "skip"
+      }
+    ]
+  });
+  if (!apiResponse.apiChoice || apiResponse.apiChoice === "skip") {
+    return;
+  }
+  const apiChoice = apiResponse.apiChoice;
+  const urlResponse = await prompts({
+    type: "text",
+    name: "url",
+    message: i18n.enterApiUrl,
+    validate: (value) => {
+      if (!value) return i18n.urlRequired;
+      try {
+        new URL(value);
+        return true;
+      } catch {
+        return i18n.invalidUrl;
+      }
+    }
+  });
+  if (!urlResponse.url) {
+    handleCancellation(scriptLang);
+    return;
+  }
+  const keyMessage = apiChoice === "auth_token" ? i18n.enterAuthToken : i18n.enterApiKey;
+  const keyResponse = await prompts({
+    type: "text",
+    name: "key",
+    message: keyMessage,
+    validate: (value) => {
+      if (!value) {
+        return i18n.keyRequired;
+      }
+      const validation = validateApiKey(value, scriptLang);
+      if (!validation.isValid) {
+        return validation.error || i18n.invalidKeyFormat;
+      }
+      return true;
+    }
+  });
+  if (!keyResponse.key) {
+    handleCancellation(scriptLang);
+    return;
+  }
+  const apiConfig = { url: urlResponse.url, key: keyResponse.key, authType: apiChoice };
+  const configuredApi = configureApi(apiConfig);
+  if (configuredApi) {
+    console.log(ansis.green(`\u2714 ${i18n.apiConfigSuccess}`));
+    console.log(ansis.gray(`  URL: ${configuredApi.url}`));
+    console.log(ansis.gray(`  Key: ${formatApiKeyDisplay(configuredApi.key)}`));
+  }
+}
+async function configureMcpFeature(scriptLang) {
+  const i18n = I18N[scriptLang];
+  if (isWindows()) {
+    const fixResponse = await prompts({
+      type: "confirm",
+      name: "fixWindows",
+      message: i18n.fixWindowsMcp || "Fix Windows MCP configuration?",
+      initial: true
+    });
+    if (fixResponse.fixWindows) {
+      const existingConfig = readMcpConfig() || { mcpServers: {} };
+      const fixedConfig = fixWindowsMcpConfig(existingConfig);
+      writeMcpConfig(fixedConfig);
+      console.log(ansis.green(`\u2714 ${i18n.windowsMcpFixed || "Windows MCP configuration fixed"}`));
+    }
+  }
+  const choices = [
+    {
+      title: ansis.bold(i18n.allServices),
+      value: "ALL",
+      selected: false
+    },
+    ...MCP_SERVICES.map((service) => ({
+      title: `${service.name[scriptLang]} - ${ansis.gray(service.description[scriptLang])}`,
+      value: service.id,
+      selected: false
+    }))
+  ];
+  const selectedResponse = await prompts({
+    type: "multiselect",
+    name: "services",
+    message: i18n.selectMcpServices,
+    choices,
+    instructions: false,
+    hint: i18n.spaceToSelectReturn
+  });
+  if (!selectedResponse.services) {
+    return;
+  }
+  let selectedServices = selectedResponse.services || [];
+  if (selectedServices.includes("ALL")) {
+    selectedServices = MCP_SERVICES.map((s) => s.id);
+  }
+  if (selectedServices.length > 0) {
+    const mcpBackupPath = backupMcpConfig();
+    if (mcpBackupPath) {
+      console.log(ansis.gray(`\u2714 ${i18n.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 apiKeyResponse = await prompts({
+          type: "text",
+          name: "apiKey",
+          message: service.apiKeyPrompt[scriptLang],
+          validate: (value) => !!value || i18n.keyRequired
+        });
+        if (apiKeyResponse.apiKey) {
+          config = buildMcpServerConfig(service.config, apiKeyResponse.apiKey, service.apiKeyPlaceholder);
+        } else {
+          continue;
+        }
+      }
+      newServers[service.id] = config;
+    }
+    const existingConfig = readMcpConfig();
+    let mergedConfig = mergeMcpServers(existingConfig, newServers);
+    mergedConfig = fixWindowsMcpConfig(mergedConfig);
+    writeMcpConfig(mergedConfig);
+    console.log(ansis.green(`\u2714 ${i18n.mcpConfigSuccess}`));
+  }
+}
+async function configureDefaultModelFeature(scriptLang) {
+  const i18n = I18N[scriptLang];
+  const modelResponse = await prompts({
+    type: "select",
+    name: "model",
+    message: i18n.selectDefaultModel || "Select default model",
+    choices: [
+      { title: "Opus", value: "opus" },
+      { title: "Sonnet", value: "sonnet" }
+    ]
+  });
+  if (!modelResponse.model) {
+    handleCancellation(scriptLang);
+    return;
+  }
+  updateDefaultModel(modelResponse.model);
+  console.log(ansis.green(`\u2714 ${i18n.modelConfigSuccess || "Default model configured"}`));
+}
+async function configureAiMemoryFeature(scriptLang) {
+  const i18n = I18N[scriptLang];
+  const memoryResponse = await prompts({
+    type: "select",
+    name: "option",
+    message: i18n.selectMemoryOption || "Select configuration option",
+    choices: [
+      {
+        title: i18n.configureAiLanguage || "Configure AI output language",
+        value: "language"
+      },
+      {
+        title: i18n.configureAiPersonality || "Configure AI personality",
+        value: "personality"
+      }
+    ]
+  });
+  if (!memoryResponse.option) {
+    return;
+  }
+  if (memoryResponse.option === "language") {
+    const zcfConfig = readZcfConfig();
+    const aiOutputLang = await resolveAiOutputLanguage(scriptLang, void 0, zcfConfig);
+    applyAiLanguageDirective(aiOutputLang);
+    updateZcfConfig({ aiOutputLang });
+    console.log(ansis.green(`\u2714 ${i18n.aiLanguageConfigured || "AI output language configured"}`));
+  } else {
+    await configureAiPersonality(scriptLang);
+  }
+}
+async function clearZcfCacheFeature(scriptLang) {
+  const i18n = I18N[scriptLang];
+  const confirmResponse = await prompts({
+    type: "confirm",
+    name: "confirm",
+    message: i18n.confirmClearCache || "Clear all ZCF preferences cache?",
+    initial: false
+  });
+  if (!confirmResponse.confirm) {
+    handleCancellation(scriptLang);
+    return;
+  }
+  if (existsSync(ZCF_CONFIG_FILE)) {
+    unlinkSync(ZCF_CONFIG_FILE);
+    console.log(ansis.green(`\u2714 ${i18n.cacheCleared || "ZCF cache cleared"}`));
+  } else {
+    console.log(ansis.yellow(i18n.noCacheFound || "No cache found"));
+  }
+}
+async function changeScriptLanguageFeature(currentLang) {
+  const i18n = I18N[currentLang];
+  const langResponse = await prompts({
+    type: "select",
+    name: "lang",
+    message: i18n.selectScriptLang,
+    choices: SUPPORTED_LANGS.map((l) => ({
+      title: LANG_LABELS[l],
+      value: l
+    })),
+    initial: SUPPORTED_LANGS.indexOf(currentLang)
+  });
+  if (!langResponse.lang) {
+    return currentLang;
+  }
+  updateZcfConfig({ preferredLang: langResponse.lang });
+  console.log(ansis.green(`\u2714 ${I18N[langResponse.lang].languageChanged || "Language changed"}`));
+  return langResponse.lang;
+}
+
+async function showMainMenu() {
+  try {
+    displayBannerWithInfo();
+    const zcfConfig = readZcfConfig();
+    let scriptLang = zcfConfig?.preferredLang || await selectScriptLanguage();
+    let exitMenu = false;
+    while (!exitMenu) {
+      const i18n = I18N[scriptLang];
+      console.log(ansis.cyan(i18n.selectFunction));
+      console.log("  -------- Claude Code --------");
+      console.log(
+        `  ${ansis.cyan("1.")} ${i18n.menuOptions.fullInit} ${ansis.gray("- " + i18n.menuDescriptions.fullInit)}`
+      );
+      console.log(
+        `  ${ansis.cyan("2.")} ${i18n.menuOptions.importWorkflow} ${ansis.gray(
+          "- " + i18n.menuDescriptions.importWorkflow
+        )}`
+      );
+      console.log(
+        `  ${ansis.cyan("3.")} ${i18n.menuOptions.configureApi} ${ansis.gray(
+          "- " + i18n.menuDescriptions.configureApi
+        )}`
+      );
+      console.log(
+        `  ${ansis.cyan("4.")} ${i18n.menuOptions.configureMcp} ${ansis.gray(
+          "- " + i18n.menuDescriptions.configureMcp
+        )}`
+      );
+      console.log(
+        `  ${ansis.cyan("5.")} ${i18n.menuOptions.configureModel} ${ansis.gray(
+          "- " + i18n.menuDescriptions.configureModel
+        )}`
+      );
+      console.log(
+        `  ${ansis.cyan("6.")} ${i18n.menuOptions.configureAiMemory} ${ansis.gray(
+          "- " + i18n.menuDescriptions.configureAiMemory
+        )}`
+      );
+      console.log("");
+      console.log("  ------------ ZCF ------------");
+      console.log(
+        `  ${ansis.cyan("0.")} ${i18n.menuOptions.changeLanguage} ${ansis.gray(
+          "- " + i18n.menuDescriptions.changeLanguage
+        )}`
+      );
+      console.log(
+        `  ${ansis.cyan("-.")} ${i18n.menuOptions.clearCache} ${ansis.gray("- " + i18n.menuDescriptions.clearCache)}`
+      );
+      console.log(`  ${ansis.red("q.")} ${ansis.red(i18n.menuOptions.exit)}`);
+      console.log("");
+      const response = await prompts({
+        type: "text",
+        name: "choice",
+        message: i18n.enterChoice || "Enter your choice",
+        validate: (value) => {
+          const valid = ["1", "2", "3", "4", "5", "6", "0", "-", "q", "Q"];
+          return valid.includes(value) || i18n.invalidChoice;
+        }
+      });
+      if (!response.choice) {
+        console.log(ansis.yellow(i18n.cancelled));
+        exitMenu = true;
+        break;
+      }
+      switch (response.choice.toLowerCase()) {
+        case "1":
+          await init({ lang: scriptLang, skipBanner: true });
+          break;
+        case "2":
+          await update({ skipBanner: true });
+          break;
+        case "3":
+          await configureApiFeature(scriptLang);
+          break;
+        case "4":
+          await configureMcpFeature(scriptLang);
+          break;
+        case "5":
+          await configureDefaultModelFeature(scriptLang);
+          break;
+        case "6":
+          await configureAiMemoryFeature(scriptLang);
+          break;
+        case "-":
+          await clearZcfCacheFeature(scriptLang);
+          break;
+        case "0":
+          const newLang = await changeScriptLanguageFeature(scriptLang);
+          if (newLang !== scriptLang) {
+            scriptLang = newLang;
+            console.log("\n" + ansis.dim("\u2500".repeat(50)) + "\n");
+            const newI18n = I18N[scriptLang];
+            const continueResponse = await prompts({
+              type: "confirm",
+              name: "continue",
+              message: newI18n.returnToMenu,
+              initial: true
+            });
+            if (!continueResponse.continue) {
+              exitMenu = true;
+              console.log(ansis.cyan(newI18n.goodbye));
+            }
+            continue;
+          }
+          break;
+        case "q":
+          exitMenu = true;
+          console.log(ansis.cyan(i18n.goodbye));
+          break;
+      }
+      if (!exitMenu && response.choice.toLowerCase() !== "q") {
+        console.log("\n" + ansis.dim("\u2500".repeat(50)) + "\n");
+        const continueResponse = await prompts({
+          type: "confirm",
+          name: "continue",
+          message: i18n.returnToMenu,
+          initial: true
+        });
+        if (!continueResponse.continue) {
+          exitMenu = true;
+          console.log(ansis.cyan(i18n.goodbye));
+        }
+      }
+    }
+  } catch (error) {
+    const zcfConfig = readZcfConfig();
+    const defaultLang = zcfConfig?.preferredLang || "en";
+    const errorMsg = I18N[defaultLang].error;
+    console.error(ansis.red(`${errorMsg}:`), error);
+    if (error instanceof Error) {
+      console.error(ansis.gray(`Stack: ${error.stack}`));
+    }
+    process.exit(1);
+  }
+}
+
 const cli = cac("zcf");
-cli.command("[lang]", "Initialize Claude Code configuration (default)").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").option("--force, -f", "Force overwrite existing configuration").action(async (lang, options) => {
+cli.command("[lang]", "Show interactive menu (default)").option("--init", "Run full initialization directly").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").option("--force, -f", "Force overwrite existing configuration").action(async (lang, options) => {
+  if (options.init) {
+    await init({
+      lang: lang || options.lang,
+      configLang: options.configLang,
+      force: options.force
+    });
+  } else {
+    await showMainMenu();
+  }
+});
+cli.command("init", "Initialize Claude Code configuration").alias("i").option("--lang, -l <lang>", "ZCF display language (zh-CN, en)").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").option("--ai-output-lang, -a <lang>", "AI output language").option("--force, -f", "Force overwrite existing configuration").action(async (options) => {
   await init({
-    lang: lang || options.lang,
+    lang: options.lang,
     configLang: options.configLang,
+    aiOutputLang: options.aiOutputLang,
     force: options.force
   });
 });
@@ -77,16 +495,19 @@ cli.help((sections) => {
   sections.push({
     title: ansis.yellow("Commands / \u547D\u4EE4:"),
     body: [
-      `  ${ansis.cyan("zcf")}              Initialize configuration (default) / \u521D\u59CB\u5316\u914D\u7F6E\uFF08\u9ED8\u8BA4\uFF09`,
+      `  ${ansis.cyan("zcf")}              Show interactive menu (default) / \u663E\u793A\u4EA4\u4E92\u5F0F\u83DC\u5355\uFF08\u9ED8\u8BA4\uFF09`,
+      `  ${ansis.cyan("zcf init")} | ${ansis.cyan("i")}     Initialize Claude Code configuration / \u521D\u59CB\u5316 Claude Code \u914D\u7F6E`,
       `  ${ansis.cyan("zcf update")} | ${ansis.cyan("u")}   Update workflow-related md files / \u4EC5\u66F4\u65B0\u5DE5\u4F5C\u6D41\u76F8\u5173md`,
       "",
-      ansis.gray("  Shortcut / \u5FEB\u6377\u65B9\u5F0F:"),
+      ansis.gray("  Shortcuts / \u5FEB\u6377\u65B9\u5F0F:"),
+      `  ${ansis.cyan("zcf i")}            Quick init / \u5FEB\u901F\u521D\u59CB\u5316`,
       `  ${ansis.cyan("zcf u")}            Quick update / \u5FEB\u901F\u66F4\u65B0`
     ].join("\n")
   });
   sections.push({
     title: ansis.yellow("Options / \u9009\u9879:"),
     body: [
+      `  ${ansis.green("--init")}                    Run full initialization directly / \u76F4\u63A5\u8FD0\u884C\u5B8C\u6574\u521D\u59CB\u5316`,
       `  ${ansis.green("--config-lang, -c")} <lang>  Configuration language / \u914D\u7F6E\u8BED\u8A00 (zh-CN, en)`,
       `  ${ansis.green("--force, -f")}               Force overwrite / \u5F3A\u5236\u8986\u76D6\u73B0\u6709\u914D\u7F6E`,
       `  ${ansis.green("--help, -h")}                Display help / \u663E\u793A\u5E2E\u52A9`,
@@ -96,15 +517,20 @@ cli.help((sections) => {
   sections.push({
     title: ansis.yellow("Examples / \u793A\u4F8B:"),
     body: [
-      ansis.gray("  # Initialize with interactive prompts / \u4EA4\u4E92\u5F0F\u521D\u59CB\u5316"),
+      ansis.gray("  # Show interactive menu / \u663E\u793A\u4EA4\u4E92\u5F0F\u83DC\u5355"),
       `  ${ansis.cyan("npx zcf")}`,
       "",
+      ansis.gray("  # Run full initialization / \u8FD0\u884C\u5B8C\u6574\u521D\u59CB\u5316"),
+      `  ${ansis.cyan("npx zcf init")}`,
+      `  ${ansis.cyan("npx zcf i")}`,
+      `  ${ansis.cyan("npx zcf --init")}`,
+      "",
       ansis.gray("  # Update workflow-related md files only / \u4EC5\u66F4\u65B0\u5DE5\u4F5C\u6D41\u76F8\u5173md\u6587\u4EF6"),
       `  ${ansis.cyan("npx zcf u")}`,
       "",
       ansis.gray("  # Force overwrite with Chinese config / \u5F3A\u5236\u4F7F\u7528\u4E2D\u6587\u914D\u7F6E\u8986\u76D6"),
-      `  ${ansis.cyan("npx zcf -c zh-CN -f")}`,
-      `  ${ansis.cyan("npx zcf --config-lang zh-CN --force")}`
+      `  ${ansis.cyan("npx zcf --init -c zh-CN -f")}`,
+      `  ${ansis.cyan("npx zcf --init --config-lang zh-CN --force")}`
     ].join("\n")
   });
   return sections;