zcf 1.0.0

package/dist/shared/zcf.DMG6psxU.mjs

@@ -0,0 +1,622 @@
+import prompts from '@posva/prompts';
+import ansis from 'ansis';
+import { existsSync, mkdirSync, readdirSync, statSync, copyFileSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { join, dirname } from 'pathe';
+import dayjs from 'dayjs';
+import { exec } from 'tinyexec';
+
+const CLAUDE_DIR = join(homedir(), ".claude");
+const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
+const CLAUDE_MD_FILE = join(CLAUDE_DIR, "CLAUDE.md");
+const MCP_CONFIG_FILE = join(homedir(), ".claude.json");
+const SUPPORTED_LANGS = ["zh-CN", "en"];
+const LANG_LABELS = {
+  "zh-CN": "\u7B80\u4F53\u4E2D\u6587",
+  "en": "English"
+};
+const I18N = {
+  "zh-CN": {
+    selectScriptLang: "\u9009\u62E9\u811A\u672C\u8BED\u8A00",
+    selectConfigLang: "\u9009\u62E9 Claude Code \u914D\u7F6E\u8BED\u8A00",
+    configLangHint: {
+      "zh-CN": "\u4E2D\u6587\u7248\uFF08\u4FBF\u4E8E\u4E2D\u6587\u7528\u6237\u81EA\u5B9A\u4E49\uFF09",
+      "en": "\u82F1\u6587\u7248\uFF08\u63A8\u8350\uFF0Ctoken \u6D88\u8017\u66F4\u4F4E\uFF09"
+    },
+    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",
+    installFailed: "Claude Code \u5B89\u88C5\u5931\u8D25",
+    npmNotFound: "npm \u672A\u5B89\u88C5\u3002\u8BF7\u5148\u5B89\u88C5 Node.js \u548C npm\u3002",
+    configureApi: "\u662F\u5426\u914D\u7F6E API\uFF1F",
+    customApi: "\u914D\u7F6E API",
+    skipApi: "\u8DF3\u8FC7\uFF08\u7A0D\u540E\u5728 claude \u547D\u4EE4\u4E2D\u81EA\u884C\u914D\u7F6E\uFF0C\u5982 OAuth\uFF09",
+    enterApiUrl: "\u8BF7\u8F93\u5165 API URL",
+    enterApiKey: "\u8BF7\u8F93\u5165 API Key",
+    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 Prompt \u6587\u6863\u5E76\u5907\u4EFD\u65E7\u914D\u7F6E",
+    mergeConfig: "\u5408\u5E76\u914D\u7F6E",
+    skip: "\u8DF3\u8FC7",
+    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",
+    apiConfigSuccess: "API \u914D\u7F6E\u5B8C\u6210",
+    mcpConfigSuccess: "MCP \u670D\u52A1\u5DF2\u914D\u7F6E",
+    selectMcpServices: "\u9009\u62E9\u8981\u5B89\u88C5\u7684 MCP \u670D\u52A1\uFF08\u7A7A\u683C\u9009\u62E9\uFF0C\u56DE\u8F66\u786E\u8BA4\uFF09",
+    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",
+    configureMcp: "\u662F\u5426\u914D\u7F6E MCP \u670D\u52A1\uFF1F",
+    mcpBackupSuccess: "\u5DF2\u5907\u4EFD\u539F\u6709 MCP \u914D\u7F6E",
+    complete: "\u{1F389} \u914D\u7F6E\u5B8C\u6210\uFF01\u4F7F\u7528 'claude' \u547D\u4EE4\u5F00\u59CB\u4F53\u9A8C\u3002",
+    error: "\u9519\u8BEF",
+    yes: "\u662F",
+    no: "\u5426"
+  },
+  "en": {
+    selectScriptLang: "Select script language",
+    selectConfigLang: "Select Claude Code configuration language",
+    configLangHint: {
+      "zh-CN": "Chinese (easier for Chinese users to customize)",
+      "en": "English (recommended, lower token consumption)"
+    },
+    installPrompt: "Claude Code not found. Install automatically?",
+    installing: "Installing Claude Code...",
+    installSuccess: "Claude Code installed successfully",
+    installFailed: "Failed to install Claude Code",
+    npmNotFound: "npm is not installed. Please install Node.js and npm first.",
+    configureApi: "Configure API?",
+    customApi: "Configure API",
+    skipApi: "Skip (configure later in claude command, e.g., OAuth)",
+    enterApiUrl: "Enter API URL",
+    enterApiKey: "Enter API Key",
+    existingConfig: "Existing config detected. How to proceed?",
+    backupAndOverwrite: "Backup and overwrite all",
+    updateDocsOnly: "Update Prompt documents only with backup",
+    mergeConfig: "Merge config",
+    skip: "Skip",
+    backupSuccess: "All config files backed up to",
+    copying: "Copying configuration files...",
+    configSuccess: "Config files copied to",
+    apiConfigSuccess: "API configured",
+    mcpConfigSuccess: "MCP services configured",
+    selectMcpServices: "Select MCP services to install (space to select, enter to confirm)",
+    allServices: "Install all",
+    mcpServiceInstalled: "Selected MCP services",
+    enterExaApiKey: "Enter Exa API Key (get from https://dashboard.exa.ai/api-keys)",
+    skipMcp: "Skip MCP configuration",
+    configureMcp: "Configure MCP services?",
+    mcpBackupSuccess: "Original MCP config backed up",
+    complete: "\u{1F389} Setup complete! Use 'claude' command to start.",
+    error: "Error",
+    yes: "Yes",
+    no: "No"
+  }
+};
+const MCP_SERVICES = [
+  {
+    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",
+      en: "Enter Exa API Key"
+    },
+    apiKeyPlaceholder: "YOUR_EXA_API_KEY",
+    config: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "mcp-remote", "https://mcp.exa.ai/mcp?exaApiKey=YOUR_EXA_API_KEY"],
+      env: {}
+    }
+  }
+];
+
+function ensureClaudeDir() {
+  if (!existsSync(CLAUDE_DIR)) {
+    mkdirSync(CLAUDE_DIR, { recursive: true });
+  }
+}
+function backupExistingConfig() {
+  if (!existsSync(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}`);
+  mkdirSync(backupDir, { recursive: true });
+  const entries = readdirSync(CLAUDE_DIR);
+  for (const entry of entries) {
+    if (entry === "backup") continue;
+    const srcPath = join(CLAUDE_DIR, entry);
+    const destPath = join(backupDir, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+  return backupDir;
+}
+function copyConfigFiles(lang, onlyMd = false) {
+  const currentFileUrl = new URL(import.meta.url);
+  const currentFilePath = currentFileUrl.pathname;
+  const distDir = dirname(dirname(currentFilePath));
+  const rootDir = dirname(distDir);
+  const sourceDir = join(rootDir, "templates", lang);
+  if (!existsSync(sourceDir)) {
+    throw new Error(`Template directory not found: ${sourceDir}`);
+  }
+  if (onlyMd) {
+    copyMdFiles(sourceDir, CLAUDE_DIR);
+  } else {
+    copyDirectory(sourceDir, CLAUDE_DIR);
+  }
+}
+function copyMdFiles(src, dest) {
+  if (!existsSync(dest)) {
+    mkdirSync(dest, { recursive: true });
+  }
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyMdFiles(srcPath, destPath);
+    } else if (entry.endsWith(".md")) {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function copyDirectory(src, dest) {
+  if (!existsSync(dest)) {
+    mkdirSync(dest, { recursive: true });
+  }
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function configureApi(apiConfig) {
+  if (!apiConfig) return;
+  let settings = {
+    $schema: "https://json.schemastore.org/claude-code-settings.json",
+    env: {},
+    includeCoAuthoredBy: false,
+    permissions: {
+      allow: [
+        "Bash(*)",
+        "LS(*)",
+        "Read(*)",
+        "Write(*)",
+        "Edit(*)",
+        "MultiEdit(*)",
+        "Glob(*)",
+        "Grep(*)",
+        "WebFetch(*)",
+        "WebSearch(*)",
+        "TodoWrite(*)",
+        "NotebookRead(*)",
+        "NotebookEdit(*)"
+      ],
+      deny: []
+    },
+    hooks: {},
+    model: "opus"
+  };
+  if (existsSync(SETTINGS_FILE)) {
+    const content = readFileSync(SETTINGS_FILE, "utf-8");
+    try {
+      const existingSettings = JSON.parse(content);
+      settings = { ...settings, ...existingSettings };
+      if (existingSettings.env) {
+        settings.env = { ...settings.env, ...existingSettings.env };
+      }
+    } catch (error) {
+      console.error("Failed to parse existing settings.json, using defaults:", error);
+    }
+  }
+  settings.env.ANTHROPIC_API_KEY = apiConfig.key;
+  settings.env.ANTHROPIC_BASE_URL = apiConfig.url;
+  writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+}
+function mergeConfigs(sourceFile, targetFile) {
+  if (!existsSync(sourceFile)) return;
+  let target = {};
+  if (existsSync(targetFile)) {
+    const content = readFileSync(targetFile, "utf-8");
+    try {
+      target = JSON.parse(content);
+    } catch {
+      target = {};
+    }
+  }
+  const source = JSON.parse(readFileSync(sourceFile, "utf-8"));
+  const merged = deepMerge(target, source);
+  writeFileSync(targetFile, JSON.stringify(merged, null, 2));
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      result[key] = deepMerge(result[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+function getPlatform() {
+  const p = platform();
+  if (p === "win32") return "windows";
+  if (p === "darwin") return "macos";
+  return "linux";
+}
+async function commandExists(command) {
+  try {
+    const cmd = getPlatform() === "windows" ? "where" : "which";
+    await exec(cmd, [command]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function isClaudeCodeInstalled() {
+  return await commandExists("claude");
+}
+async function installClaudeCode(lang) {
+  const i18n = I18N[lang];
+  console.log(i18n.installing);
+  try {
+    if (!await commandExists("npm")) {
+      throw new Error(i18n.npmNotFound);
+    }
+    await exec("npm", ["install", "-g", "@anthropic-ai/claude-code"]);
+    console.log(`\u2714 ${i18n.installSuccess}`);
+  } catch (error) {
+    console.error(`\u2716 ${i18n.installFailed}`);
+    throw error;
+  }
+}
+
+function getMcpConfigPath() {
+  return MCP_CONFIG_FILE;
+}
+function readMcpConfig() {
+  if (!existsSync(MCP_CONFIG_FILE)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(MCP_CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error("Failed to parse MCP config:", error);
+    return null;
+  }
+}
+function writeMcpConfig(config) {
+  const dir = dirname(MCP_CONFIG_FILE);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(MCP_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function backupMcpConfig() {
+  if (!existsSync(MCP_CONFIG_FILE)) {
+    return null;
+  }
+  const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+  const backupBaseDir = join(CLAUDE_DIR, "backup");
+  const backupPath = join(backupBaseDir, `.claude.json.backup_${timestamp}.json`);
+  try {
+    if (!existsSync(backupBaseDir)) {
+      mkdirSync(backupBaseDir, { recursive: true });
+    }
+    const content = readFileSync(MCP_CONFIG_FILE, "utf-8");
+    writeFileSync(backupPath, content);
+    return backupPath;
+  } catch (error) {
+    console.error("Failed to backup MCP config:", error);
+    return null;
+  }
+}
+function mergeMcpServers(existing, newServers) {
+  const config = existing || { mcpServers: {} };
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  Object.assign(config.mcpServers, newServers);
+  return config;
+}
+function buildMcpServerConfig(baseConfig, apiKey, placeholder = "YOUR_EXA_API_KEY") {
+  if (!apiKey) {
+    return { ...baseConfig };
+  }
+  const config = JSON.parse(JSON.stringify(baseConfig));
+  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;
+}
+
+async function init(options = {}) {
+  try {
+    let scriptLang = options.lang;
+    if (!scriptLang) {
+      const response = await prompts({
+        type: "select",
+        name: "lang",
+        message: "Select script language / \u9009\u62E9\u811A\u672C\u8BED\u8A00",
+        choices: SUPPORTED_LANGS.map((l) => ({
+          title: LANG_LABELS[l],
+          value: l
+        }))
+      });
+      scriptLang = response.lang;
+    }
+    if (!scriptLang) {
+      console.error(ansis.red("Language not selected"));
+      process.exit(1);
+    }
+    const i18n = I18N[scriptLang];
+    let configLang = options.configLang;
+    if (!configLang) {
+      const response = await prompts({
+        type: "select",
+        name: "lang",
+        message: i18n.selectConfigLang,
+        choices: SUPPORTED_LANGS.map((l) => ({
+          title: `${LANG_LABELS[l]} - ${i18n.configLangHint[l]}`,
+          value: l
+        }))
+      });
+      configLang = response.lang;
+    }
+    if (!options.skipInstall) {
+      const installed = await isClaudeCodeInstalled();
+      if (!installed) {
+        const response = await prompts({
+          type: "confirm",
+          name: "shouldInstall",
+          message: i18n.installPrompt,
+          initial: true
+        });
+        if (response.shouldInstall) {
+          await installClaudeCode(scriptLang);
+        } else {
+          console.log(ansis.yellow(i18n.skip));
+        }
+      } else {
+        console.log(ansis.green(`\u2714 Claude Code ${i18n.installSuccess}`));
+      }
+    }
+    ensureClaudeDir();
+    let onlyUpdateDocs = false;
+    let action = "new";
+    if (existsSync(SETTINGS_FILE) && !options.force) {
+      const actionResponse = await prompts({
+        type: "select",
+        name: "action",
+        message: i18n.existingConfig,
+        choices: [
+          { title: i18n.backupAndOverwrite, value: "backup" },
+          { title: i18n.updateDocsOnly, value: "docs-only" },
+          { title: i18n.mergeConfig, value: "merge" },
+          { title: i18n.skip, value: "skip" }
+        ]
+      });
+      action = actionResponse.action;
+      if (action === "skip") {
+        console.log(ansis.yellow(i18n.skip));
+        return;
+      }
+      if (action === "docs-only") {
+        onlyUpdateDocs = true;
+      }
+    }
+    let apiConfig = null;
+    const isNewInstall = !existsSync(SETTINGS_FILE);
+    if (!onlyUpdateDocs && (isNewInstall || action === "backup" || action === "merge")) {
+      const apiResponse = await prompts({
+        type: "select",
+        name: "apiChoice",
+        message: i18n.configureApi,
+        choices: [
+          { title: i18n.customApi, value: "custom" },
+          { title: i18n.skipApi, value: "skip" }
+        ]
+      });
+      const apiChoice = apiResponse.apiChoice;
+      if (apiChoice === "custom") {
+        const urlResponse = await prompts({
+          type: "text",
+          name: "url",
+          message: i18n.enterApiUrl,
+          validate: (value) => {
+            if (!value) return "URL is required";
+            try {
+              new URL(value);
+              return true;
+            } catch {
+              return "Invalid URL";
+            }
+          }
+        });
+        const url = urlResponse.url;
+        const keyResponse = await prompts({
+          type: "text",
+          name: "key",
+          message: i18n.enterApiKey,
+          validate: (value) => !!value || "API Key is required"
+        });
+        const key = keyResponse.key;
+        apiConfig = { url, key };
+      }
+    }
+    if (action === "backup") {
+      const backupDir = backupExistingConfig();
+      if (backupDir) {
+        console.log(ansis.gray(`\u2714 ${i18n.backupSuccess}: ${backupDir}`));
+      }
+      copyConfigFiles(configLang, false);
+    } else if (action === "docs-only") {
+      const backupDir = backupExistingConfig();
+      if (backupDir) {
+        console.log(ansis.gray(`\u2714 ${i18n.backupSuccess}: ${backupDir}`));
+      }
+      copyConfigFiles(configLang, true);
+    } else if (action === "merge") {
+      const backupDir = backupExistingConfig();
+      if (backupDir) {
+        console.log(ansis.gray(`\u2714 ${i18n.backupSuccess}: ${backupDir}`));
+      }
+      copyConfigFiles(configLang, false);
+    } else if (action === "new") {
+      copyConfigFiles(configLang, false);
+    }
+    if (apiConfig && !onlyUpdateDocs) {
+      configureApi(apiConfig);
+      console.log(ansis.green(`\u2714 ${i18n.apiConfigSuccess}`));
+    }
+    if (!onlyUpdateDocs) {
+      const mcpResponse = await prompts({
+        type: "confirm",
+        name: "shouldConfigureMcp",
+        message: i18n.configureMcp,
+        initial: true
+      });
+      if (mcpResponse.shouldConfigureMcp) {
+        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: "- Space to select. Return to submit"
+        });
+        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 || "API Key is required"
+              });
+              if (apiKeyResponse.apiKey) {
+                config = buildMcpServerConfig(service.config, apiKeyResponse.apiKey, service.apiKeyPlaceholder);
+              } else {
+                continue;
+              }
+            }
+            newServers[service.id] = config;
+          }
+          const existingConfig = readMcpConfig();
+          const mergedConfig = mergeMcpServers(existingConfig, newServers);
+          try {
+            writeMcpConfig(mergedConfig);
+            console.log(ansis.green(`\u2714 ${i18n.mcpConfigSuccess}`));
+          } catch (error) {
+            console.error(ansis.red(`Failed to write MCP config: ${error}`));
+          }
+        }
+      }
+    }
+    console.log(ansis.green(`\u2714 ${i18n.configSuccess} ${CLAUDE_DIR}`));
+    console.log("\n" + ansis.cyan(i18n.complete));
+  } catch (error) {
+    console.error(ansis.red(`${I18N[options.lang || "en"].error}:`), error);
+    process.exit(1);
+  }
+}
+
+export { CLAUDE_DIR as C, I18N as I, LANG_LABELS as L, MCP_CONFIG_FILE as M, SETTINGS_FILE as S, CLAUDE_MD_FILE as a, SUPPORTED_LANGS as b, commandExists as c, MCP_SERVICES as d, isClaudeCodeInstalled as e, installClaudeCode as f, getPlatform as g, ensureClaudeDir as h, init as i, backupExistingConfig as j, copyConfigFiles as k, configureApi as l, mergeConfigs as m, getMcpConfigPath as n, backupMcpConfig as o, mergeMcpServers as p, buildMcpServerConfig as q, readMcpConfig as r, writeMcpConfig as w };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "zcf",
+  "type": "module",
+  "version": "1.0.0",
+  "packageManager": "pnpm@9.0.0",
+  "description": "Zero-Config Claude-Code Flow - One-click configuration tool for Claude Code",
+  "license": "MIT",
+  "homepage": "https://github.com/UfoMiao/claude-code-config#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/UfoMiao/claude-code-config.git"
+  },
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "bin": {
+    "zcf": "bin/zcf.mjs"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "templates"
+  ],
+  "scripts": {
+    "dev": "tsx ./src/cli.ts",
+    "build": "unbuild",
+    "typecheck": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "npm run build && node bin/zcf.mjs"
+  },
+  "dependencies": {
+    "@posva/prompts": "^2.4.4",
+    "ansis": "^3.3.2",
+    "cac": "^6.7.14",
+    "dayjs": "^1.11.13",
+    "find-up-simple": "^1.0.1",
+    "pathe": "^2.0.0",
+    "tinyexec": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.12",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "unbuild": "^3.5.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "config",
+    "cli",
+    "setup",
+    "zero-config",
+    "zcf",
+    "anthropic",
+    "ai",
+    "automation",
+    "mcp"
+  ]
+}