cxg-workflow 0.1.2

package/dist/shared/cxg-workflow.BdjkxkKP.mjs

@@ -0,0 +1,701 @@
+import fs from 'fs-extra';
+import { homedir } from 'node:os';
+import { join, dirname } from 'pathe';
+import { fileURLToPath } from 'node:url';
+import { stringify, parse } from 'smol-toml';
+
+const version = "0.1.2";
+
+function isWindows() {
+  return process.platform === "win32";
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+
+const CODEX_HOME = join(homedir(), ".codex");
+const CXG_DIR = join(CODEX_HOME, ".cxg");
+const CONFIG_FILE = join(CXG_DIR, "config.toml");
+function getCodexHome() {
+  return CODEX_HOME;
+}
+function getCxgDir() {
+  return CXG_DIR;
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+async function ensureCxgDir() {
+  await fs.ensureDir(CXG_DIR);
+}
+async function readCxgConfig() {
+  try {
+    if (await fs.pathExists(CONFIG_FILE)) {
+      const content = await fs.readFile(CONFIG_FILE, "utf-8");
+      return parse(content);
+    }
+  } catch {
+  }
+  return null;
+}
+async function writeCxgConfig(config) {
+  await ensureCxgDir();
+  const tmpPath = `${CONFIG_FILE}.tmp`;
+  await fs.writeFile(tmpPath, stringify(config), "utf-8");
+  await fs.rename(tmpPath, CONFIG_FILE);
+}
+function createDefaultConfig(options) {
+  return {
+    general: {
+      version: version,
+      created_at: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    runtime: {
+      backend: "codex",
+      lite_mode: options?.liteMode || false
+    },
+    paths: {
+      prompts: join(CODEX_HOME, "prompts"),
+      skills: join(CODEX_HOME, "skills", "cxg"),
+      roles: join(CXG_DIR, "roles", "codex"),
+      wrapper: join(CODEX_HOME, "bin", isWindows() ? "codeagent-wrapper.exe" : "codeagent-wrapper")
+    },
+    commands: {
+      installed: []
+    },
+    mcp: {
+      provider: options?.mcpProvider || "skip"
+    }
+  };
+}
+
+const ALL_COMMANDS = [
+  "cxg-workflow",
+  "cxg-plan",
+  "cxg-execute",
+  "cxg-feat",
+  "cxg-analyze",
+  "cxg-debug",
+  "cxg-optimize",
+  "cxg-test",
+  "cxg-review",
+  "cxg-enhance",
+  "cxg-commit",
+  "cxg-init"
+];
+const WORKFLOW_CONFIGS = [
+  { id: "cxg-workflow", name: "\u4E3B\u5DE5\u4F5C\u6D41", nameEn: "Main Workflow", category: "core", description: "5\u9636\u6BB5\u5355\u6A21\u578B\u5F00\u53D1\u4E3B\u6D41\u7A0B\uFF08\u7814\u7A76\u2192\u8BA1\u5212\u2192\u6267\u884C\u2192\u4F18\u5316\u2192\u8BC4\u5BA1\uFF09", descriptionEn: "5-phase single-model workflow", order: 1 },
+  { id: "cxg-plan", name: "\u89C4\u5212", nameEn: "Plan", category: "core", description: "\u751F\u6210\u5B9E\u65BD\u8BA1\u5212", descriptionEn: "Generate implementation plan", order: 2 },
+  { id: "cxg-execute", name: "\u6267\u884C", nameEn: "Execute", category: "core", description: "\u6839\u636E\u8BA1\u5212\u6267\u884C\u5B9E\u73B0", descriptionEn: "Execute from approved plan", order: 3 },
+  { id: "cxg-feat", name: "\u529F\u80FD\u5F00\u53D1", nameEn: "Feature", category: "development", description: "\u667A\u80FD\u529F\u80FD\u5F00\u53D1", descriptionEn: "Smart feature development", order: 4 },
+  { id: "cxg-analyze", name: "\u6280\u672F\u5206\u6790", nameEn: "Analyze", category: "development", description: "\u53EA\u5206\u6790\u4E0D\u6539\u52A8\u4EE3\u7801", descriptionEn: "Analysis without code changes", order: 5 },
+  { id: "cxg-debug", name: "\u8C03\u8BD5\u4FEE\u590D", nameEn: "Debug", category: "development", description: "\u95EE\u9898\u5B9A\u4F4D\u4E0E\u4FEE\u590D", descriptionEn: "Debug and fix", order: 6 },
+  { id: "cxg-optimize", name: "\u6027\u80FD\u4F18\u5316", nameEn: "Optimize", category: "development", description: "\u6027\u80FD\u4E0E\u8D44\u6E90\u4F18\u5316", descriptionEn: "Performance optimization", order: 7 },
+  { id: "cxg-test", name: "\u6D4B\u8BD5\u751F\u6210", nameEn: "Test", category: "quality", description: "\u6D4B\u8BD5\u8BBE\u8BA1\u4E0E\u751F\u6210", descriptionEn: "Test generation", order: 8 },
+  { id: "cxg-review", name: "\u4EE3\u7801\u5BA1\u67E5", nameEn: "Review", category: "quality", description: "\u8D28\u91CF\u4E0E\u5B89\u5168\u5BA1\u67E5", descriptionEn: "Code quality review", order: 9 },
+  { id: "cxg-enhance", name: "Prompt \u589E\u5F3A", nameEn: "Enhance", category: "quality", description: "\u9700\u6C42\u7ED3\u6784\u5316\u589E\u5F3A", descriptionEn: "Prompt enhancement", order: 10 },
+  { id: "cxg-commit", name: "\u63D0\u4EA4\u4FE1\u606F", nameEn: "Commit", category: "delivery", description: "Conventional Commit \u751F\u6210", descriptionEn: "Commit message generation", order: 11 },
+  { id: "cxg-init", name: "\u4E0A\u4E0B\u6587\u521D\u59CB\u5316", nameEn: "Init Context", category: "bootstrap", description: "\u521D\u59CB\u5316 AGENTS.md", descriptionEn: "Initialize AGENTS.md context", order: 12 }
+];
+const GITHUB_REPO = "fengshao1227/ccg-workflow";
+const RELEASE_TAG = "preset";
+const BINARY_DOWNLOAD_URL = `https://github.com/${GITHUB_REPO}/releases/download/${RELEASE_TAG}`;
+
+function resolveBinaryName() {
+  const platform = process.platform;
+  const arch = process.arch;
+  if (platform === "darwin") {
+    return arch === "arm64" ? "codeagent-wrapper-darwin-arm64" : "codeagent-wrapper-darwin-amd64";
+  }
+  if (platform === "linux") {
+    return arch === "arm64" ? "codeagent-wrapper-linux-arm64" : "codeagent-wrapper-linux-amd64";
+  }
+  if (platform === "win32") {
+    return arch === "arm64" ? "codeagent-wrapper-windows-arm64.exe" : "codeagent-wrapper-windows-amd64.exe";
+  }
+  throw new Error(`Unsupported platform: ${platform}/${arch}`);
+}
+async function downloadBinary(binaryName, destPath) {
+  const url = `${BINARY_DOWNLOAD_URL}/${binaryName}`;
+  const response = await fetch(url, { redirect: "follow" });
+  if (!response.ok) {
+    return false;
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  await fs.writeFile(destPath, buffer);
+  if (!isWindows()) {
+    await fs.chmod(destPath, 493);
+  }
+  return true;
+}
+async function verifyBinary(binaryPath) {
+  try {
+    const { execSync } = await import('node:child_process');
+    execSync(`"${binaryPath}" --version`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function injectTemplateVariables(content, config) {
+  let processed = content;
+  const liteModeFlag = config.liteMode ? "--lite " : "";
+  processed = processed.replace(/\{\{LITE_MODE_FLAG\}\}/g, liteModeFlag);
+  const mcpProvider = config.mcpProvider || "skip";
+  if (mcpProvider === "skip") {
+    processed = processed.replace(/\{\{MCP_SEARCH_TOOL\}\}/g, "Glob + Grep");
+    processed = processed.replace(/\{\{MCP_SEARCH_PARAM\}\}/g, "");
+  } else if (mcpProvider === "contextweaver") {
+    processed = processed.replace(/\{\{MCP_SEARCH_TOOL\}\}/g, "mcp__contextweaver__codebase-retrieval");
+    processed = processed.replace(/\{\{MCP_SEARCH_PARAM\}\}/g, "information_request");
+  } else {
+    processed = processed.replace(/\{\{MCP_SEARCH_TOOL\}\}/g, "mcp__ace-tool__search_context");
+    processed = processed.replace(/\{\{MCP_SEARCH_PARAM\}\}/g, "query");
+  }
+  return processed;
+}
+function replaceHomePathsInTemplate(content, codexHome) {
+  const userHome = homedir();
+  const cxgDir = join(codexHome, ".cxg");
+  const rolesDir = join(cxgDir, "roles", "codex");
+  const binDir = join(codexHome, "bin");
+  const norm = (path) => normalizePath(path);
+  let processed = content;
+  const wrapperName = isWindows() ? "codeagent-wrapper.exe" : "codeagent-wrapper";
+  const wrapperPath = `${norm(binDir)}/${wrapperName}`;
+  processed = processed.replace(/\{\{WRAPPER_BIN\}\}/g, wrapperPath);
+  processed = processed.replace(/\{\{ROLE_ANALYZER\}\}/g, `${norm(rolesDir)}/analyzer.md`);
+  processed = processed.replace(/\{\{ROLE_ARCHITECT\}\}/g, `${norm(rolesDir)}/architect.md`);
+  processed = processed.replace(/\{\{ROLE_REVIEWER\}\}/g, `${norm(rolesDir)}/reviewer.md`);
+  processed = processed.replace(/~\/\.codex\/\.cxg/g, norm(cxgDir));
+  processed = processed.replace(/~\/\.codex\/bin/g, norm(binDir));
+  processed = processed.replace(/~\/\.codex/g, norm(codexHome));
+  processed = processed.replace(/~\//g, `${norm(userHome)}/`);
+  return processed;
+}
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
+function findPackageRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 5; i++) {
+    if (fs.existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return startDir;
+}
+const PACKAGE_ROOT = findPackageRoot(__dirname$1);
+function getWorkflowConfigs() {
+  return [...WORKFLOW_CONFIGS].sort((a, b) => a.order - b.order);
+}
+function getAllCommandIds() {
+  return [...ALL_COMMANDS];
+}
+async function installCxg(options = {}) {
+  const { force = false, liteMode = false, mcpProvider = "skip" } = options;
+  const codexHome = join(homedir(), ".codex");
+  const promptsDir = join(codexHome, "prompts");
+  const skillsDir = join(codexHome, "skills", "cxg");
+  const rolesDir = join(codexHome, ".cxg", "roles", "codex");
+  const binDir = join(codexHome, "bin");
+  const templateDir = join(PACKAGE_ROOT, "templates");
+  const installConfig = { liteMode, mcpProvider };
+  const result = {
+    success: true,
+    installedPrompts: [],
+    installedSkills: [],
+    installedRoles: [],
+    errors: []
+  };
+  await fs.ensureDir(promptsDir);
+  await fs.ensureDir(skillsDir);
+  await fs.ensureDir(rolesDir);
+  await fs.ensureDir(binDir);
+  const promptsTemplateDir = join(templateDir, "prompts");
+  if (await fs.pathExists(promptsTemplateDir)) {
+    for (const cmd of ALL_COMMANDS) {
+      const srcFile = join(promptsTemplateDir, `${cmd}.md`);
+      const destFile = join(promptsDir, `${cmd}.md`);
+      try {
+        if (await fs.pathExists(srcFile)) {
+          if (force || !await fs.pathExists(destFile)) {
+            let content = await fs.readFile(srcFile, "utf-8");
+            content = injectTemplateVariables(content, installConfig);
+            content = replaceHomePathsInTemplate(content, codexHome);
+            await fs.writeFile(destFile, content, "utf-8");
+            result.installedPrompts.push(cmd);
+          }
+        }
+      } catch (error) {
+        result.errors.push(`Failed to install prompt ${cmd}: ${error}`);
+        result.success = false;
+      }
+    }
+  }
+  const skillsTemplateDir = join(templateDir, "skills", "cxg");
+  if (await fs.pathExists(skillsTemplateDir)) {
+    try {
+      await fs.copy(skillsTemplateDir, skillsDir, {
+        overwrite: force,
+        errorOnExist: false
+      });
+      const replacePathsInDir = async (dir) => {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = join(dir, entry.name);
+          if (entry.isDirectory()) {
+            await replacePathsInDir(fullPath);
+          } else if (entry.name.endsWith(".md")) {
+            const original = await fs.readFile(fullPath, "utf-8");
+            let processed = injectTemplateVariables(original, installConfig);
+            processed = replaceHomePathsInTemplate(processed, codexHome);
+            if (processed !== original) {
+              await fs.writeFile(fullPath, processed, "utf-8");
+            }
+          }
+        }
+      };
+      await replacePathsInDir(skillsDir);
+      const countSkills = async (dir) => {
+        const skills = [];
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const skillFile = join(dir, entry.name, "SKILL.md");
+            if (await fs.pathExists(skillFile)) {
+              skills.push(entry.name);
+            }
+          }
+        }
+        return skills;
+      };
+      result.installedSkills = await countSkills(skillsDir);
+    } catch (error) {
+      result.errors.push(`Failed to install skills: ${error}`);
+      result.success = false;
+    }
+  }
+  const rolesTemplateDir = join(templateDir, "roles", "codex");
+  if (await fs.pathExists(rolesTemplateDir)) {
+    try {
+      const files = await fs.readdir(rolesTemplateDir);
+      for (const file of files) {
+        if (file.endsWith(".md")) {
+          const srcFile = join(rolesTemplateDir, file);
+          const destFile = join(rolesDir, file);
+          if (force || !await fs.pathExists(destFile)) {
+            const content = await fs.readFile(srcFile, "utf-8");
+            const processed = replaceHomePathsInTemplate(content, codexHome);
+            await fs.writeFile(destFile, processed, "utf-8");
+            result.installedRoles.push(file.replace(".md", ""));
+          }
+        }
+      }
+    } catch (error) {
+      result.errors.push(`Failed to install roles: ${error}`);
+      result.success = false;
+    }
+  }
+  try {
+    const binaryName = resolveBinaryName();
+    const destBinary = join(binDir, isWindows() ? "codeagent-wrapper.exe" : "codeagent-wrapper");
+    const installed = await downloadBinary(binaryName, destBinary);
+    if (installed) {
+      const verified = await verifyBinary(destBinary);
+      if (verified) {
+        result.binInstalled = true;
+        result.binPath = binDir;
+      } else {
+        result.errors.push("Binary verification failed");
+        result.success = false;
+      }
+    } else {
+      result.errors.push(`Failed to download binary: ${binaryName}`);
+      result.success = false;
+    }
+  } catch (error) {
+    result.errors.push(`Failed to install codeagent-wrapper: ${error}`);
+    result.success = false;
+  }
+  return result;
+}
+async function uninstallCxg() {
+  const codexHome = join(homedir(), ".codex");
+  const promptsDir = join(codexHome, "prompts");
+  const skillsDir = join(codexHome, "skills", "cxg");
+  const rolesDir = join(codexHome, ".cxg", "roles");
+  const cxgDir = join(codexHome, ".cxg");
+  const binDir = join(codexHome, "bin");
+  const result = {
+    success: true,
+    removedPrompts: [],
+    removedSkills: [],
+    removedRoles: [],
+    removedBin: false,
+    errors: []
+  };
+  if (await fs.pathExists(promptsDir)) {
+    try {
+      const files = await fs.readdir(promptsDir);
+      for (const file of files) {
+        if (file.startsWith("cxg-") && file.endsWith(".md")) {
+          await fs.remove(join(promptsDir, file));
+          result.removedPrompts.push(file.replace(".md", ""));
+        }
+      }
+    } catch (error) {
+      result.errors.push(`Failed to remove prompts: ${error}`);
+      result.success = false;
+    }
+  }
+  if (await fs.pathExists(skillsDir)) {
+    try {
+      const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          result.removedSkills.push(entry.name);
+        }
+      }
+      await fs.remove(skillsDir);
+    } catch (error) {
+      result.errors.push(`Failed to remove skills: ${error}`);
+      result.success = false;
+    }
+  }
+  if (await fs.pathExists(cxgDir)) {
+    try {
+      if (await fs.pathExists(rolesDir)) {
+        const files = await fs.readdir(join(rolesDir, "codex")).catch(() => []);
+        for (const file of files) {
+          if (typeof file === "string") {
+            result.removedRoles.push(file.replace(".md", ""));
+          }
+        }
+      }
+      await fs.remove(cxgDir);
+    } catch (error) {
+      result.errors.push(`Failed to remove .cxg directory: ${error}`);
+      result.success = false;
+    }
+  }
+  if (await fs.pathExists(binDir)) {
+    try {
+      const wrapperName = isWindows() ? "codeagent-wrapper.exe" : "codeagent-wrapper";
+      const wrapperPath = join(binDir, wrapperName);
+      if (await fs.pathExists(wrapperPath)) {
+        await fs.remove(wrapperPath);
+        result.removedBin = true;
+      }
+    } catch (error) {
+      result.errors.push(`Failed to remove binary: ${error}`);
+      result.success = false;
+    }
+  }
+  return result;
+}
+
+const CODEX_CONFIG_PATH = join(homedir(), ".codex", "config.toml");
+async function readCodexConfig() {
+  if (await fs.pathExists(CODEX_CONFIG_PATH)) {
+    const content = await fs.readFile(CODEX_CONFIG_PATH, "utf-8");
+    return parse(content);
+  }
+  return {};
+}
+async function writeCodexConfig(config) {
+  const dir = join(homedir(), ".codex");
+  await fs.ensureDir(dir);
+  const tmpPath = `${CODEX_CONFIG_PATH}.tmp`;
+  await fs.writeFile(tmpPath, stringify(config), "utf-8");
+  await fs.rename(tmpPath, CODEX_CONFIG_PATH);
+}
+async function installAceTool(config) {
+  try {
+    const codexConfig = await readCodexConfig();
+    if (!codexConfig.mcp_servers) {
+      codexConfig.mcp_servers = {};
+    }
+    const args = ["-y", "ace-tool@latest"];
+    if (config.baseUrl) {
+      args.push("--base-url", config.baseUrl);
+    }
+    if (config.token) {
+      args.push("--token", config.token);
+    }
+    codexConfig.mcp_servers["ace-tool"] = {
+      type: "stdio",
+      command: "npx",
+      args
+    };
+    await writeCodexConfig(codexConfig);
+    return { success: true, message: "ace-tool MCP configured in ~/.codex/config.toml" };
+  } catch (error) {
+    return { success: false, message: `Failed to configure ace-tool: ${error}` };
+  }
+}
+async function installContextWeaver(config) {
+  try {
+    const contextWeaverDir = join(homedir(), ".contextweaver");
+    await fs.ensureDir(contextWeaverDir);
+    const envContent = `# ContextWeaver config (auto-generated by CXG)
+EMBEDDINGS_API_KEY=${config.siliconflowApiKey}
+EMBEDDINGS_BASE_URL=https://api.siliconflow.cn/v1/embeddings
+EMBEDDINGS_MODEL=Qwen/Qwen3-Embedding-8B
+EMBEDDINGS_MAX_CONCURRENCY=10
+EMBEDDINGS_DIMENSIONS=1024
+RERANK_API_KEY=${config.siliconflowApiKey}
+RERANK_BASE_URL=https://api.siliconflow.cn/v1/rerank
+RERANK_MODEL=Qwen/Qwen3-Reranker-8B
+RERANK_TOP_N=20
+`;
+    const envPath = join(contextWeaverDir, ".env");
+    await fs.writeFile(envPath, envContent, { encoding: "utf-8", mode: 384 });
+    const codexConfig = await readCodexConfig();
+    if (!codexConfig.mcp_servers) {
+      codexConfig.mcp_servers = {};
+    }
+    codexConfig.mcp_servers.contextweaver = {
+      type: "stdio",
+      command: "contextweaver",
+      args: ["mcp"]
+    };
+    await writeCodexConfig(codexConfig);
+    return { success: true, message: "ContextWeaver MCP configured in ~/.codex/config.toml" };
+  } catch (error) {
+    return { success: false, message: `Failed to configure ContextWeaver: ${error}` };
+  }
+}
+async function uninstallMcpServer(id) {
+  try {
+    const codexConfig = await readCodexConfig();
+    if (codexConfig.mcp_servers?.[id]) {
+      delete codexConfig.mcp_servers[id];
+      await writeCodexConfig(codexConfig);
+    }
+    return { success: true, message: `${id} MCP removed from config` };
+  } catch (error) {
+    return { success: false, message: `Failed to uninstall ${id}: ${error}` };
+  }
+}
+
+async function init(options = {}) {
+  console.log();
+  console.log(`  CXG Workflow v${version}`);
+  console.log(`  Codex \u5355\u6A21\u578B\u534F\u4F5C\u5DE5\u4F5C\u6D41`);
+  console.log();
+  const { force = false, liteMode = false, mcpProvider = "skip" } = options;
+  console.log("  [1/3] \u5B89\u88C5\u5DE5\u4F5C\u6D41\u7EC4\u4EF6...");
+  const result = await installCxg({ force, liteMode, mcpProvider });
+  if (result.installedPrompts.length > 0) {
+    console.log(`    \u2713 Custom Prompts: ${result.installedPrompts.length} \u4E2A`);
+  }
+  if (result.installedSkills.length > 0) {
+    console.log(`    \u2713 Skills: ${result.installedSkills.length} \u4E2A`);
+  }
+  if (result.installedRoles.length > 0) {
+    console.log(`    \u2713 \u89D2\u8272\u63D0\u793A\u8BCD: ${result.installedRoles.join(", ")}`);
+  }
+  if (result.binInstalled) {
+    console.log(`    \u2713 codeagent-wrapper \u2192 ${result.binPath}`);
+  }
+  if (mcpProvider !== "skip") {
+    console.log();
+    console.log("  [2/3] \u914D\u7F6E MCP \u4EE3\u7801\u68C0\u7D22...");
+    if (mcpProvider === "ace-tool") {
+      const aceResult = await installAceTool({});
+      if (aceResult.success) {
+        console.log(`    \u2713 ${aceResult.message}`);
+      } else {
+        console.log(`    \u2717 ${aceResult.message}`);
+      }
+    } else if (mcpProvider === "contextweaver") {
+      console.log(`    \u26A0 ContextWeaver \u9700\u8981 SiliconFlow API Key`);
+      console.log(`      \u8BF7\u624B\u52A8\u914D\u7F6E: ~/.contextweaver/.env`);
+    }
+  } else {
+    console.log();
+    console.log("  [2/3] MCP \u914D\u7F6E (\u5DF2\u8DF3\u8FC7)");
+    console.log("    \u63D0\u793A: \u4F7F\u7528 --mcp ace-tool \u6216 --mcp contextweaver \u542F\u7528\u4EE3\u7801\u68C0\u7D22");
+  }
+  console.log();
+  console.log("  [3/3] \u4FDD\u5B58\u914D\u7F6E...");
+  const config = createDefaultConfig({ mcpProvider, liteMode });
+  config.commands.installed = result.installedPrompts;
+  await writeCxgConfig(config);
+  console.log("    \u2713 ~/.codex/.cxg/config.toml");
+  console.log();
+  if (result.errors.length > 0) {
+    console.log("  \u26A0 \u5B89\u88C5\u5B8C\u6210\uFF0C\u4F46\u6709\u4EE5\u4E0B\u9519\u8BEF:");
+    for (const error of result.errors) {
+      console.log(`    \u2717 ${error}`);
+    }
+  } else {
+    console.log("  \u2713 \u5B89\u88C5\u5B8C\u6210!");
+  }
+  console.log();
+  console.log("  \u5DF2\u5B89\u88C5\u547D\u4EE4:");
+  for (const cmd of result.installedPrompts) {
+    console.log(`    /${cmd}`);
+  }
+  console.log();
+  console.log("  \u4F7F\u7528\u65B9\u6CD5: \u5728 Codex CLI \u4E2D\u8F93\u5165 /<\u547D\u4EE4\u540D> \u8C03\u7528");
+  console.log();
+}
+
+async function uninstall() {
+  console.log();
+  console.log("  \u5378\u8F7D CXG Workflow...");
+  console.log();
+  const result = await uninstallCxg();
+  if (result.removedPrompts.length > 0) {
+    console.log(`  \u2713 \u5DF2\u79FB\u9664 ${result.removedPrompts.length} \u4E2A Custom Prompts`);
+  }
+  if (result.removedSkills.length > 0) {
+    console.log(`  \u2713 \u5DF2\u79FB\u9664 ${result.removedSkills.length} \u4E2A Skills`);
+  }
+  if (result.removedRoles.length > 0) {
+    console.log(`  \u2713 \u5DF2\u79FB\u9664\u89D2\u8272\u63D0\u793A\u8BCD: ${result.removedRoles.join(", ")}`);
+  }
+  if (result.removedBin) {
+    console.log("  \u2713 \u5DF2\u79FB\u9664 codeagent-wrapper");
+  }
+  const mcpErrors = [];
+  const aceResult = await uninstallMcpServer("ace-tool");
+  if (!aceResult.success) {
+    mcpErrors.push(aceResult.message);
+  }
+  const cwResult = await uninstallMcpServer("contextweaver");
+  if (!cwResult.success) {
+    mcpErrors.push(cwResult.message);
+  }
+  if (mcpErrors.length > 0) {
+    console.log("  \u26A0 MCP \u6E05\u7406\u90E8\u5206\u5931\u8D25:");
+    for (const err of mcpErrors) {
+      console.log(`    \u2717 ${err}`);
+    }
+  } else {
+    console.log("  \u2713 \u5DF2\u6E05\u7406 MCP \u914D\u7F6E");
+  }
+  const configPath = getConfigPath();
+  if (await fs.pathExists(configPath)) {
+    await fs.remove(configPath);
+    console.log("  \u2713 \u5DF2\u79FB\u9664\u914D\u7F6E\u6587\u4EF6");
+  }
+  console.log();
+  if (result.errors.length > 0) {
+    console.log("  \u26A0 \u5378\u8F7D\u5B8C\u6210\uFF0C\u4F46\u6709\u4EE5\u4E0B\u9519\u8BEF:");
+    for (const error of result.errors) {
+      console.log(`    \u2717 ${error}`);
+    }
+  } else {
+    console.log("  \u2713 \u5378\u8F7D\u5B8C\u6210!");
+  }
+  console.log();
+}
+
+async function doctor() {
+  console.log();
+  console.log(`  CXG Workflow Doctor v${version}`);
+  console.log();
+  const codexHome = join(homedir(), ".codex");
+  const results = [];
+  const config = await readCxgConfig();
+  results.push({
+    label: "\u914D\u7F6E\u6587\u4EF6 (~/.codex/.cxg/config.toml)",
+    ok: config !== null,
+    detail: config ? `v${config.general.version}` : "\u672A\u627E\u5230"
+  });
+  const promptsDir = join(codexHome, "prompts");
+  let promptCount = 0;
+  const missingPrompts = [];
+  for (const cmd of ALL_COMMANDS) {
+    const promptPath = join(promptsDir, `${cmd}.md`);
+    if (await fs.pathExists(promptPath)) {
+      promptCount++;
+    } else {
+      missingPrompts.push(cmd);
+    }
+  }
+  results.push({
+    label: `Custom Prompts (${promptCount}/${ALL_COMMANDS.length})`,
+    ok: promptCount === ALL_COMMANDS.length,
+    detail: missingPrompts.length > 0 ? `\u7F3A\u5931: ${missingPrompts.join(", ")}` : void 0
+  });
+  const skillsDir = join(codexHome, "skills", "cxg");
+  let skillCount = 0;
+  const missingSkills = [];
+  for (const cmd of ALL_COMMANDS) {
+    const shortName = cmd.replace("cxg-", "");
+    const skillPath = join(skillsDir, shortName, "SKILL.md");
+    if (await fs.pathExists(skillPath)) {
+      skillCount++;
+    } else {
+      missingSkills.push(shortName);
+    }
+  }
+  results.push({
+    label: `Skills (${skillCount}/${ALL_COMMANDS.length})`,
+    ok: skillCount === ALL_COMMANDS.length,
+    detail: missingSkills.length > 0 ? `\u7F3A\u5931: ${missingSkills.join(", ")}` : void 0
+  });
+  const rolesDir = join(codexHome, ".cxg", "roles", "codex");
+  const roleNames = ["analyzer", "architect", "reviewer"];
+  const missingRoles = [];
+  for (const role of roleNames) {
+    if (!await fs.pathExists(join(rolesDir, `${role}.md`))) {
+      missingRoles.push(role);
+    }
+  }
+  results.push({
+    label: `\u89D2\u8272\u63D0\u793A\u8BCD (${roleNames.length - missingRoles.length}/${roleNames.length})`,
+    ok: missingRoles.length === 0,
+    detail: missingRoles.length > 0 ? `\u7F3A\u5931: ${missingRoles.join(", ")}` : void 0
+  });
+  const wrapperName = isWindows() ? "codeagent-wrapper.exe" : "codeagent-wrapper";
+  const wrapperPath = join(codexHome, "bin", wrapperName);
+  const binExists = await fs.pathExists(wrapperPath);
+  let binVersion = "";
+  if (binExists) {
+    try {
+      const { execSync } = await import('node:child_process');
+      binVersion = execSync(`"${wrapperPath}" --version`, { stdio: "pipe", encoding: "utf-8" }).trim();
+    } catch {
+      binVersion = "(\u7248\u672C\u68C0\u6D4B\u5931\u8D25)";
+    }
+  }
+  results.push({
+    label: "codeagent-wrapper",
+    ok: binExists,
+    detail: binExists ? binVersion : "\u672A\u5B89\u88C5"
+  });
+  if (config?.mcp?.provider && config.mcp.provider !== "skip") {
+    const codexConfig = join(codexHome, "config.toml");
+    const codexConfigExists = await fs.pathExists(codexConfig);
+    results.push({
+      label: `MCP (${config.mcp.provider})`,
+      ok: codexConfigExists,
+      detail: codexConfigExists ? "\u5DF2\u914D\u7F6E" : "config.toml \u672A\u627E\u5230"
+    });
+  }
+  let allOk = true;
+  for (const r of results) {
+    const icon = r.ok ? "\u2713" : "\u2717";
+    const detail = r.detail ? ` \u2014 ${r.detail}` : "";
+    console.log(`  ${icon} ${r.label}${detail}`);
+    if (!r.ok) {
+      allOk = false;
+    }
+  }
+  console.log();
+  if (allOk) {
+    console.log("  \u6240\u6709\u68C0\u67E5\u901A\u8FC7!");
+  } else {
+    console.log("  \u90E8\u5206\u68C0\u67E5\u672A\u901A\u8FC7\uFF0C\u8FD0\u884C npx cxg-workflow init --force \u4FEE\u590D");
+  }
+  console.log();
+}
+
+export { ALL_COMMANDS as A, WORKFLOW_CONFIGS as W, getCodexHome as a, getConfigPath as b, createDefaultConfig as c, doctor as d, getCxgDir as e, getWorkflowConfigs as f, getAllCommandIds as g, installAceTool as h, init as i, installContextWeaver as j, installCxg as k, uninstallCxg as l, uninstallMcpServer as m, readCxgConfig as r, uninstall as u, version as v, writeCxgConfig as w };