zcf 2.12.13 → 3.0.1

package/README.md

@@ -1,4 +1,4 @@
-# ZCF - Zero-Config Claude-Code Flow
+# ZCF - Zero-Config Code Flow
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
@@ -10,7 +10,9 @@
 
 [中文](README_zh-CN.md) | **English** | [日本語](README_ja-JP.md) | [Changelog](CHANGELOG.md)
 
-> Zero-config, one-click setup for Claude Code with bilingual support, intelligent agent system and personalized AI assistant
+**✨ Quick Links**: [Codex Support](#-codex-support-v300-new) | [BMad Workflow](#-bmad-workflow-v27-new-feature) | [Spec Workflow](#-spec-workflow-v2124-new-feature) | [Open Web Search](#-open-web-search-v2129-new-feature) | [CCR Router](#-ccr-claude-code-router-support-v28-enhanced) | [CCometixLine](#-ccometixline-support-status-bar-tool-v299-new) | [Output Styles](#-ai-output-styles-v212-new-feature)
+
+> Zero-config, one-click setup for Claude Code & Codex with bilingual support, intelligent agent system and personalized AI assistant
 
 ![Rendering](./src/assets/screenshot-en.webp)
 
@@ -126,6 +128,83 @@ When using `--skip-prompt`, the following parameters are available:
 | `--default-output-style, -d` | Default output style                                     | Same as output styles plus built-in: `default`, `explanatory`, `learning`                          | No                                     | `engineer-professional`                                                                                                          |
 | `--install-cometix-line, -x` | Install CCometixLine statusline tool                     | `true`, `false`                                                                                    | No                                     | `true`                                                                                                                           |
 
+#### 🤖 Codex Support (v3.0.0+ New)
+
+[Codex](https://www.npmjs.com/package/@openai/codex) is OpenAI's official code generation CLI tool. ZCF now supports complete Codex integration with the same configuration convenience as Claude Code.
+
+**Key Features:**
+
+- **Unified Tool Management**: Switch between Claude Code and Codex seamlessly through ZCF menu
+- **Intelligent Configuration**: Automatic Codex CLI installation, API provider setup, and MCP service integration
+- **Comprehensive Backup System**: All configuration changes include timestamped backups with recovery capabilities
+- **Multi-Provider Support**: Configure multiple API providers (OpenAI, custom endpoints) with easy switching
+- **System Prompt Integration**: Install professional AI personalities (Engineer, Nekomata Engineer, Laowang Engineer)
+- **Workflow Templates**: Import structured development workflows optimized for code generation tasks
+- **Advanced Uninstaller**: Selective removal of Codex components with conflict resolution
+
+**Getting Started with Codex:**
+
+Switch to Codex mode in ZCF main menu:
+```bash
+npx zcf → Select S  # Switch between Claude Code and Codex
+```
+
+Or access Codex features directly:
+```bash
+# Full Codex initialization
+npx zcf → Select 1 (after switching to Codex mode)
+
+# Individual Codex configuration
+npx zcf → Select 3  # Configure Codex API providers
+npx zcf → Select 4  # Configure Codex MCP services
+```
+
+**Configuration Options:**
+
+1. **API Provider Configuration**:
+   - **Official Login**: Use OpenAI's official authentication system
+   - **Custom Providers**: Configure multiple API endpoints with provider switching
+   - **Incremental Management**: Add, edit, or remove providers without affecting existing configuration
+
+2. **System Prompt Styles**:
+   - **Engineer Professional**: SOLID, KISS, DRY, YAGNI principles for robust code
+   - **Nekomata Engineer**: Cute catgirl engineer with rigorous technical standards
+   - **Laowang Engineer**: Grumpy tech style that never tolerates substandard code
+
+3. **Workflow Integration**:
+   - **Six-Step Workflow**: Structured development process from research to optimization
+   - **Custom Workflows**: Import and configure task-specific development templates
+   - **⚠️ Important**: Due to Codex prompt limitations, `/workflow` commands cannot pass parameters directly. Use `/workflow` first, then provide task description in follow-up message
+
+4. **MCP Services**: Full compatibility with existing MCP services including:
+   - Context7, Open WebSearch, Spec Workflow
+   - DeepWiki, Playwright, EXA search
+   - Automatic service configuration with API key management
+
+**File Locations:**
+
+- Configuration: `~/.codex/config.toml`
+- Authentication: `~/.codex/auth.json`
+- System Prompts: `~/.codex/AGENTS.md`
+- Workflows: `~/.codex/prompts/`
+- Backups: `~/.codex/backup/`
+
+**Command Line Operations:**
+
+Dedicated command line tool for Codex (v3.0.0+ New):
+
+```bash
+# Codex API provider switching
+npx zcf config-switch     # Interactive provider selection
+npx zcf cs                # Using alias
+npx zcf cs provider-name  # Direct switch to specified provider
+npx zcf cs --list         # List all available providers
+```
+
+**Migration Between Tools:**
+
+ZCF allows seamless switching between Claude Code and Codex while preserving your preferences and workflow configurations. Both tools share the same MCP services and workflow templates for consistent development experience.
+
 #### 🎨 AI Output Styles (v2.12+ New Feature)
 
 ZCF now supports customizable AI output styles to personalize your Claude Code experience:
@@ -224,6 +303,7 @@ After CCR setup, ZCF automatically configures Claude Code to use CCR as the API
 
 **Important Notice for v2.9.9 Users**: If you previously installed CCometixLine using ZCF v2.9.9, please rerun the installation process to ensure that the CCometixLine configuration is correctly added. Run `npx zcf` -> `Select L` -> `Select 1` to add the CCometixLine configuration.
 
+
 #### 📊 CCometixLine Support (Status Bar Tool) (v2.9.9+ New)
 
 [CCometixLine](https://github.com/Haleclipse/CCometixLine) is a high-performance Rust-based statusline tool that provides:
@@ -270,6 +350,8 @@ After configuration:
 - `/feat <task description>` - Start new feature development, divided into plan and UI phases
 - `/workflow <task description>` - Execute complete development workflow, not automated, starts with multiple solution options, asks for user feedback at each step, allows plan modifications, maximum control
 
+> **⚠️ Important Note for Codex Users**: Due to Codex functionality limitations, prompts cannot pass parameters directly. When using `/workflow`, you need to send the workflow command first, wait for AI response, then send your task description in a separate message.
+
 > **PS**:
 >
 > - Both feat and workflow have their advantages, try both to compare
@@ -327,7 +409,7 @@ After configuration:
 ```bash
 $ npx zcf
 
- ZCF - Zero-Config Claude-Code Flow
+ ZCF - Zero-Config Code Flow
 
 ? Select ZCF display language / 选择ZCF显示语言:
   ❯ 简体中文
@@ -473,6 +555,7 @@ Enter your choice: _
 | `zcf update`        | `zcf u` | Update workflow-related md files with backup                                          |
 | `zcf ccu`           | -       | Run Claude Code usage analysis tool - [ccusage](https://github.com/ryoppippi/ccusage) |
 | `zcf ccr`           | -       | Open CCR (Claude Code Router) management menu                                         |
+| `zcf config-switch` | `zcf cs` | Codex API provider switching tool - Switch between official login and custom providers |
 | `zcf uninstall`     | -       | Interactive uninstall tool for Claude Code configurations and tools                   |
 | `zcf check-updates` | -       | Check and update Claude Code, CCR and CCometixLine versions                           |
 
@@ -524,6 +607,12 @@ npx zcf u -c en            # Using short option
 
 # Run Claude Code usage analysis tool (powered by ccusage)
 npx zcf ccu               # Daily usage (default), or use: monthly, session, blocks
+
+# Codex API provider switching (v3.0.0+ New)
+npx zcf config-switch     # Interactive provider selection
+npx zcf cs                # Using alias
+npx zcf cs provider-name  # Direct switch to specified provider
+npx zcf cs --list         # List all available providers
 ```
 
 ## 📁 Project Structure
@@ -712,11 +801,12 @@ A huge thank you to all our sponsors for their generous support!
 - Tc (first sponsor)
 - Argolinhas (first ko-fi sponsor ٩(•̤̀ᵕ•̤́๑))
 - r\*r (first anonymous sponsor🤣)
+- \*\*康 (first KFC sponsor🍗)
 - 16°C coffee (My best friend🤪, offered Claude Code max $200 package)
 
 ## 📄 License
 
-MIT License
+[MIT License](LICENSE)
 
 ---
 

package/dist/chunks/codex-config-switch.mjs

@@ -0,0 +1,419 @@
+import ansis from 'ansis';
+import inquirer from 'inquirer';
+import { X as readCodexConfig, Y as backupCodexComplete, _ as writeCodexConfig, $ as writeAuthFile, a0 as ensureI18nInitialized, a1 as detectConfigManagementMode, W as i18n, a2 as addNumbersToChoices } from './simple-config.mjs';
+import 'node:fs';
+import 'node:process';
+import 'node:child_process';
+import 'node:os';
+import 'node:util';
+import 'dayjs';
+import 'pathe';
+import 'node:url';
+import 'ora';
+import 'semver';
+import 'smol-toml';
+import 'tinyexec';
+import 'node:fs/promises';
+import 'i18next';
+import 'i18next-fs-backend';
+
+const ERROR_MESSAGES = {
+  NO_CONFIG: "No existing configuration found",
+  BACKUP_FAILED: "Failed to create backup",
+  PROVIDER_EXISTS: (id) => `Provider with ID "${id}" already exists`,
+  PROVIDER_NOT_FOUND: (id) => `Provider with ID "${id}" not found`,
+  NO_PROVIDERS_SPECIFIED: "No providers specified for deletion",
+  PROVIDERS_NOT_FOUND: (providers) => `Some providers not found: ${providers.join(", ")}`,
+  CANNOT_DELETE_ALL: "Cannot delete all providers. At least one provider must remain."
+};
+async function addProviderToExisting(provider, apiKey) {
+  try {
+    const existingConfig = readCodexConfig();
+    if (!existingConfig) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.NO_CONFIG
+      };
+    }
+    const existingProvider = existingConfig.providers.find((p) => p.id === provider.id);
+    if (existingProvider) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.PROVIDER_EXISTS(provider.id)
+      };
+    }
+    const backupPath = backupCodexComplete();
+    if (!backupPath) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.BACKUP_FAILED
+      };
+    }
+    const updatedConfig = {
+      ...existingConfig,
+      providers: [...existingConfig.providers, provider]
+    };
+    writeCodexConfig(updatedConfig);
+    const authEntries = {};
+    authEntries[provider.envKey] = apiKey;
+    writeAuthFile(authEntries);
+    return {
+      success: true,
+      backupPath,
+      addedProvider: provider
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function editExistingProvider(providerId, updates) {
+  try {
+    const existingConfig = readCodexConfig();
+    if (!existingConfig) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.NO_CONFIG
+      };
+    }
+    const providerIndex = existingConfig.providers.findIndex((p) => p.id === providerId);
+    if (providerIndex === -1) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.PROVIDER_NOT_FOUND(providerId)
+      };
+    }
+    const backupPath = backupCodexComplete();
+    if (!backupPath) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.BACKUP_FAILED
+      };
+    }
+    const updatedProvider = {
+      ...existingConfig.providers[providerIndex],
+      ...updates.name && { name: updates.name },
+      ...updates.baseUrl && { baseUrl: updates.baseUrl },
+      ...updates.wireApi && { wireApi: updates.wireApi }
+    };
+    const updatedProviders = [...existingConfig.providers];
+    updatedProviders[providerIndex] = updatedProvider;
+    const updatedConfig = {
+      ...existingConfig,
+      providers: updatedProviders
+    };
+    writeCodexConfig(updatedConfig);
+    if (updates.apiKey) {
+      const authEntries = {};
+      authEntries[updatedProvider.envKey] = updates.apiKey;
+      writeAuthFile(authEntries);
+    }
+    return {
+      success: true,
+      backupPath,
+      updatedProvider
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function deleteProviders(providerIds) {
+  try {
+    const existingConfig = readCodexConfig();
+    if (!existingConfig) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.NO_CONFIG
+      };
+    }
+    if (!providerIds || providerIds.length === 0) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.NO_PROVIDERS_SPECIFIED
+      };
+    }
+    const notFoundProviders = providerIds.filter(
+      (id) => !existingConfig.providers.some((p) => p.id === id)
+    );
+    if (notFoundProviders.length > 0) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.PROVIDERS_NOT_FOUND(notFoundProviders)
+      };
+    }
+    const remainingProviders = existingConfig.providers.filter(
+      (p) => !providerIds.includes(p.id)
+    );
+    if (remainingProviders.length === 0) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.CANNOT_DELETE_ALL
+      };
+    }
+    const backupPath = backupCodexComplete();
+    if (!backupPath) {
+      return {
+        success: false,
+        error: ERROR_MESSAGES.BACKUP_FAILED
+      };
+    }
+    let newDefaultProvider = existingConfig.modelProvider;
+    if (providerIds.includes(existingConfig.modelProvider || "")) {
+      newDefaultProvider = remainingProviders[0].id;
+    }
+    const updatedConfig = {
+      ...existingConfig,
+      modelProvider: newDefaultProvider,
+      providers: remainingProviders
+    };
+    writeCodexConfig(updatedConfig);
+    const result = {
+      success: true,
+      backupPath,
+      deletedProviders: providerIds,
+      remainingProviders
+    };
+    if (newDefaultProvider !== existingConfig.modelProvider) {
+      result.newDefaultProvider = newDefaultProvider || void 0;
+    }
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+
+async function configureIncrementalManagement() {
+  ensureI18nInitialized();
+  const managementMode = detectConfigManagementMode();
+  if (managementMode.mode !== "management" || !managementMode.hasProviders) {
+    console.log(ansis.yellow(i18n.t("codex:noExistingProviders")));
+    return;
+  }
+  console.log(ansis.cyan(i18n.t("codex:incrementalManagementTitle")));
+  console.log(ansis.gray(i18n.t("codex:currentProviderCount", { count: managementMode.providerCount })));
+  if (managementMode.currentProvider) {
+    console.log(ansis.gray(i18n.t("codex:currentDefaultProvider", { provider: managementMode.currentProvider })));
+  }
+  const choices = [
+    { name: i18n.t("codex:addProvider"), value: "add" },
+    { name: i18n.t("codex:editProvider"), value: "edit" },
+    { name: i18n.t("codex:deleteProvider"), value: "delete" },
+    { name: i18n.t("common:back"), value: "back" }
+  ];
+  const { action } = await inquirer.prompt([{
+    type: "list",
+    name: "action",
+    message: i18n.t("codex:selectAction"),
+    choices: addNumbersToChoices(choices)
+  }]);
+  if (!action || action === "back") {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  switch (action) {
+    case "add":
+      await handleAddProvider();
+      break;
+    case "edit":
+      await handleEditProvider(managementMode.providers);
+      break;
+    case "delete":
+      await handleDeleteProvider(managementMode.providers);
+      break;
+  }
+}
+async function handleAddProvider() {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "providerName",
+      message: i18n.t("codex:providerNamePrompt"),
+      validate: (input) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+          return i18n.t("codex:providerNameRequired");
+        if (!/^[\w\-\s]+$/.test(trimmed))
+          return i18n.t("codex:providerNameInvalid");
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "baseUrl",
+      message: i18n.t("codex:providerBaseUrlPrompt"),
+      default: "https://api.openai.com/v1",
+      validate: (input) => !!input.trim() || i18n.t("codex:providerBaseUrlRequired")
+    },
+    {
+      type: "list",
+      name: "wireApi",
+      message: i18n.t("codex:providerProtocolPrompt"),
+      choices: [
+        { name: i18n.t("codex:protocolResponses"), value: "responses" },
+        { name: i18n.t("codex:protocolChat"), value: "chat" }
+      ],
+      default: "responses"
+    },
+    {
+      type: "password",
+      name: "apiKey",
+      message: i18n.t("codex:providerApiKeyPrompt") + i18n.t("common:inputHidden"),
+      validate: (input) => !!input.trim() || i18n.t("codex:providerApiKeyRequired")
+    }
+  ]);
+  const providerId = answers.providerName.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9\-]/g, "");
+  const provider = {
+    id: providerId,
+    name: answers.providerName.trim(),
+    baseUrl: answers.baseUrl.trim(),
+    wireApi: answers.wireApi,
+    envKey: `${providerId.toUpperCase().replace(/-/g, "_")}_API_KEY`,
+    requiresOpenaiAuth: true
+  };
+  const result = await addProviderToExisting(provider, answers.apiKey.trim());
+  if (result.success) {
+    console.log(ansis.green(i18n.t("codex:providerAdded", { name: result.addedProvider?.name })));
+    if (result.backupPath) {
+      console.log(ansis.gray(i18n.t("common:backupCreated", { path: result.backupPath })));
+    }
+  } else {
+    console.log(ansis.red(i18n.t("codex:providerAddFailed", { error: result.error })));
+  }
+}
+async function handleEditProvider(providers) {
+  const choices = providers.map((provider2) => ({
+    name: `${provider2.name} (${provider2.baseUrl})`,
+    value: provider2.id
+  }));
+  const { selectedProviderId } = await inquirer.prompt([{
+    type: "list",
+    name: "selectedProviderId",
+    message: i18n.t("codex:selectProviderToEdit"),
+    choices: addNumbersToChoices(choices)
+  }]);
+  if (!selectedProviderId) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  const provider = providers.find((p) => p.id === selectedProviderId);
+  if (!provider) {
+    console.log(ansis.red(i18n.t("codex:providerNotFound")));
+    return;
+  }
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "providerName",
+      message: i18n.t("codex:providerNamePrompt"),
+      default: provider.name,
+      validate: (input) => {
+        const trimmed = input.trim();
+        if (!trimmed)
+          return i18n.t("codex:providerNameRequired");
+        if (!/^[\w\-\s]+$/.test(trimmed))
+          return i18n.t("codex:providerNameInvalid");
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "baseUrl",
+      message: i18n.t("codex:providerBaseUrlPrompt"),
+      default: provider.baseUrl,
+      validate: (input) => !!input.trim() || i18n.t("codex:providerBaseUrlRequired")
+    },
+    {
+      type: "list",
+      name: "wireApi",
+      message: i18n.t("codex:providerProtocolPrompt"),
+      choices: [
+        { name: i18n.t("codex:protocolResponses"), value: "responses" },
+        { name: i18n.t("codex:protocolChat"), value: "chat" }
+      ],
+      default: provider.wireApi
+    },
+    {
+      type: "password",
+      name: "apiKey",
+      message: i18n.t("codex:providerApiKeyPrompt") + i18n.t("common:inputHidden"),
+      validate: (input) => !!input.trim() || i18n.t("codex:providerApiKeyRequired")
+    }
+  ]);
+  const updates = {
+    name: answers.providerName.trim(),
+    baseUrl: answers.baseUrl.trim(),
+    wireApi: answers.wireApi,
+    apiKey: answers.apiKey.trim()
+  };
+  const result = await editExistingProvider(selectedProviderId, updates);
+  if (result.success) {
+    console.log(ansis.green(i18n.t("codex:providerUpdated", { name: result.updatedProvider?.name })));
+    if (result.backupPath) {
+      console.log(ansis.gray(i18n.t("common:backupCreated", { path: result.backupPath })));
+    }
+  } else {
+    console.log(ansis.red(i18n.t("codex:providerUpdateFailed", { error: result.error })));
+  }
+}
+async function handleDeleteProvider(providers) {
+  const choices = providers.map((provider) => ({
+    name: `${provider.name} (${provider.baseUrl})`,
+    value: provider.id
+  }));
+  const { selectedProviderIds } = await inquirer.prompt({
+    type: "checkbox",
+    name: "selectedProviderIds",
+    message: i18n.t("codex:selectProvidersToDelete"),
+    choices,
+    validate: (input) => {
+      const selected = input;
+      if (!selected || selected.length === 0) {
+        return i18n.t("codex:selectAtLeastOne");
+      }
+      if (selected.length === providers.length) {
+        return i18n.t("codex:cannotDeleteAll");
+      }
+      return true;
+    }
+  });
+  if (!selectedProviderIds || selectedProviderIds.length === 0) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  const selectedNames = selectedProviderIds.map(
+    (id) => providers.find((p) => p.id === id)?.name || id
+  ).join(", ");
+  const { confirmDelete } = await inquirer.prompt([{
+    type: "confirm",
+    name: "confirmDelete",
+    message: i18n.t("codex:confirmDeleteProviders", { providers: selectedNames }),
+    default: false
+  }]);
+  if (!confirmDelete) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  const result = await deleteProviders(selectedProviderIds);
+  if (result.success) {
+    console.log(ansis.green(i18n.t("codex:providersDeleted", { count: selectedProviderIds.length })));
+    if (result.newDefaultProvider) {
+      console.log(ansis.cyan(i18n.t("codex:newDefaultProvider", { provider: result.newDefaultProvider })));
+    }
+    if (result.backupPath) {
+      console.log(ansis.gray(i18n.t("common:backupCreated", { path: result.backupPath })));
+    }
+  } else {
+    console.log(ansis.red(i18n.t("codex:providersDeleteFailed", { error: result.error })));
+  }
+}
+const codexConfigSwitch = { configureIncrementalManagement };
+
+export { configureIncrementalManagement, codexConfigSwitch as default };