ai-engineering-init 1.5.0 → 1.7.0

package/bin/index.js

@@ -46,10 +46,12 @@ console.log('');
 
 // ── 参数解析 ───────────────────────────────────────────────────────────────
 const args = process.argv.slice(2);
-let command   = '';   // 'update' | 'global' | ''
+let command   = '';   // 'update' | 'global' | 'sync-back' | ''
 let tool      = '';
 let targetDir = process.cwd();
 let force     = false;
+let skillFilter = '';  // sync-back --skill <名称>
+let submitIssue = false; // sync-back --submit
 
 for (let i = 0; i < args.length; i++) {
   const arg = args[i];
@@ -60,6 +62,18 @@ for (let i = 0; i < args.length; i++) {
     case 'global':
       command = 'global';
       break;
+    case 'init':
+      command = 'init';
+      break;
+    case 'sync-back':
+      command = 'sync-back';
+      break;
+    case 'config':
+      command = 'config';
+      break;
+    case 'mcp':
+      command = 'mcp';
+      break;
     case '--tool': case '-t':
       if (i + 1 >= args.length || args[i + 1].startsWith('-')) {
         console.error(fmt('red', `错误：${arg} 需要一个值（claude | cursor | codex | all）`));
@@ -77,6 +91,16 @@ for (let i = 0; i < args.length; i++) {
     case '--force': case '-f':
       force = true;
       break;
+    case '--skill': case '-s':
+      if (i + 1 >= args.length || args[i + 1].startsWith('-')) {
+        console.error(fmt('red', `错误：${arg} 需要一个技能名称`));
+        process.exit(1);
+      }
+      skillFilter = args[++i];
+      break;
+    case '--submit':
+      submitIssue = true;
+      break;
     case '--help': case '-h':
       printHelp();
       process.exit(0);
@@ -94,14 +118,20 @@ for (let i = 0; i < args.length; i++) {
 function printHelp() {
   console.log(`用法: ${fmt('bold', 'npx ai-engineering-init')} [命令] [选项]\n`);
   console.log('命令:');
-  console.log(`  ${fmt('bold', '(无)')}            交互式初始化（安装到当前项目目录）`);
+  console.log(`  ${fmt('bold', 'init')}             交互式初始化（安装到当前项目目录）`);
   console.log(`  ${fmt('bold', 'update')}           更新已安装的框架文件（跳过用户自定义文件）`);
-  console.log(`  ${fmt('bold', 'global')}           全局安装到 ~/.claude / ~/.cursor 等，对所有项目生效\n`);
+  console.log(`  ${fmt('bold', 'global')}           全局安装到 ~/.claude / ~/.cursor 等，对所有项目生效`);
+  console.log(`  ${fmt('bold', 'sync-back')}        对比本地技能修改，生成 diff 或提交 GitHub Issue`);
+  console.log(`  ${fmt('bold', 'config')}           初始化数据库配置文件（.claude/mysql-config.json）`);
+  console.log(`  ${fmt('bold', 'mcp')}              MCP 服务器管理（安装/卸载/状态检查）\n`);
+  console.log(`无命令时显示交互式主菜单。\n`);
   console.log('选项:');
-  console.log('  --tool, -t <工具>   指定工具: claude | cursor | codex | all');
-  console.log('  --dir,  -d <目录>   目标目录（默认：当前目录，仅 init/update 有效）');
-  console.log('  --force,-f          强制覆盖（init 时覆盖已有文件；update/global 时同时更新保留文件）');
-  console.log('  --help, -h          显示此帮助\n');
+  console.log('  --tool,  -t <工具>   指定工具: claude | cursor | codex | all');
+  console.log('  --dir,   -d <目录>   目标目录（默认：当前目录，仅 init/update 有效）');
+  console.log('  --force, -f          强制覆盖（init 时覆盖已有文件；update/global 时同时更新保留文件）');
+  console.log('  --skill, -s <技能>   sync-back 时只对比指定技能');
+  console.log('  --submit             sync-back 时自动创建 GitHub Issue（需要 gh CLI）');
+  console.log('  --help,  -h          显示此帮助\n');
   console.log('示例:');
   console.log('  npx ai-engineering-init --tool claude');
   console.log('  npx ai-engineering-init --tool all --dir /path/to/project');
@@ -109,7 +139,11 @@ function printHelp() {
   console.log('  npx ai-engineering-init update --tool claude # 只更新 Claude');
   console.log('  npx ai-engineering-init update --force       # 强制更新，包括保留文件');
   console.log('  npx ai-engineering-init global               # 全局安装所有工具');
-  console.log('  npx ai-engineering-init global --tool claude # 只全局安装 Claude\n');
+  console.log('  npx ai-engineering-init global --tool claude # 只全局安装 Claude');
+  console.log('  npx ai-engineering-init sync-back                        # 扫描所有已安装工具');
+  console.log('  npx ai-engineering-init sync-back --tool claude          # 只扫描 Claude');
+  console.log('  npx ai-engineering-init sync-back --skill bug-detective  # 只对比指定技能');
+  console.log('  npx ai-engineering-init sync-back --skill bug-detective --submit # 提交 Issue\n');
 }
 
 // ── 工具定义（init 用）────────────────────────────────────────────────────
@@ -675,37 +709,942 @@ function runUpdate(selectedTool) {
   if (totalFailed > 0) process.exitCode = 1;
 }
 
-// ── 主入口 ────────────────────────────────────────────────────────────────
-if (command === 'update') {
-  runUpdate(tool);
-} else if (command === 'global') {
-  runGlobal(tool);
-} else if (tool) {
-  run(tool);
-} else {
-  // 非 TTY 环境（CI/管道）无法交互，强制要求显式指定 --tool
+// ── SYNC-BACK 逻辑 ─────────────────────────────────────────────────────────
+
+/** 技能目录名称到工具的映射 */
+const SKILL_DIRS = {
+  claude: '.claude/skills',
+  cursor: '.cursor/skills',
+  codex:  '.codex/skills',
+};
+
+/** 递归列出目录下所有文件（相对路径） */
+function listFilesRecursive(dir, prefix) {
+  prefix = prefix || '';
+  let results = [];
+  let entries;
+  try { entries = fs.readdirSync(dir); } catch { return results; }
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry);
+    const relPath = prefix ? prefix + '/' + entry : entry;
+    try {
+      if (fs.statSync(fullPath).isDirectory()) {
+        results = results.concat(listFilesRecursive(fullPath, relPath));
+      } else {
+        results.push(relPath);
+      }
+    } catch { /* 跳过不可读文件 */ }
+  }
+  return results;
+}
+
+/**
+ * 简易 unified diff 生成器（纯 Node.js，零依赖）
+ * 使用贪心 LCS 简化算法，输出标准 unified diff 格式
+ */
+function generateDiff(oldContent, newContent, oldLabel, newLabel) {
+  const oldLines = oldContent.split(/\r?\n/);
+  const newLines = newContent.split(/\r?\n/);
+
+  // 计算 LCS 表（简化版，O(n*m) 但对技能文件足够）
+  const m = oldLines.length;
+  const n = newLines.length;
+
+  // 对于大文件，跳过 LCS 直接标记全部替换
+  if (m * n > 1000000) {
+    const lines = [];
+    lines.push(`--- ${oldLabel}`);
+    lines.push(`+++ ${newLabel}`);
+    lines.push(`@@ -1,${m} +1,${n} @@`);
+    for (const line of oldLines) lines.push('-' + line);
+    for (const line of newLines) lines.push('+' + line);
+    return lines.join('\n');
+  }
+
+  // LCS 回溯表
+  const dp = Array.from({ length: m + 1 }, () => new Uint16Array(n + 1));
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (oldLines[i - 1] === newLines[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  // 回溯生成编辑操作序列
+  const ops = []; // { type: 'equal'|'delete'|'insert', line }
+  let i = m, j = n;
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      ops.push({ type: 'equal', oldIdx: i, newIdx: j, line: oldLines[i - 1] });
+      i--; j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      ops.push({ type: 'insert', newIdx: j, line: newLines[j - 1] });
+      j--;
+    } else {
+      ops.push({ type: 'delete', oldIdx: i, line: oldLines[i - 1] });
+      i--;
+    }
+  }
+  ops.reverse();
+
+  // 将操作序列组织为 hunks（上下文 3 行）
+  const CTX = 3;
+  const hunks = [];
+  let hunkOps = [];
+  let lastChangeIdx = -999;
+
+  for (let k = 0; k < ops.length; k++) {
+    if (ops[k].type !== 'equal') {
+      // 如果距离上次变更超过 2*CTX+1，开始新 hunk
+      if (k - lastChangeIdx > 2 * CTX + 1 && hunkOps.length > 0) {
+        hunks.push(hunkOps);
+        hunkOps = [];
+        // 回退加上下文
+        const start = Math.max(k - CTX, lastChangeIdx + CTX + 1);
+        for (let c = start; c < k; c++) {
+          if (ops[c]) hunkOps.push(ops[c]);
+        }
+      } else if (hunkOps.length === 0) {
+        // 新 hunk 加前上下文
+        const start = Math.max(0, k - CTX);
+        for (let c = start; c < k; c++) {
+          hunkOps.push(ops[c]);
+        }
+      } else {
+        // 补充中间的上下文行
+        for (let c = lastChangeIdx + 1; c < k; c++) {
+          if (!hunkOps.includes(ops[c])) hunkOps.push(ops[c]);
+        }
+      }
+      hunkOps.push(ops[k]);
+      lastChangeIdx = k;
+    }
+  }
+  // 最后一个 hunk 加后上下文
+  if (hunkOps.length > 0) {
+    const end = Math.min(ops.length, lastChangeIdx + CTX + 1);
+    for (let c = lastChangeIdx + 1; c < end; c++) {
+      hunkOps.push(ops[c]);
+    }
+    hunks.push(hunkOps);
+  }
+
+  if (hunks.length === 0) return ''; // 无差异
+
+  // 格式化输出
+  const lines = [];
+  lines.push(`--- ${oldLabel}`);
+  lines.push(`+++ ${newLabel}`);
+
+  for (const hunk of hunks) {
+    // 计算 hunk 头
+    let oldStart = Infinity, oldCount = 0, newStart = Infinity, newCount = 0;
+    for (const op of hunk) {
+      if (op.type === 'equal' || op.type === 'delete') {
+        if (op.oldIdx < oldStart) oldStart = op.oldIdx;
+        oldCount++;
+      }
+      if (op.type === 'equal' || op.type === 'insert') {
+        if (op.newIdx < newStart) newStart = op.newIdx;
+        newCount++;
+      }
+    }
+    lines.push(`@@ -${oldStart},${oldCount} +${newStart},${newCount} @@`);
+    for (const op of hunk) {
+      if (op.type === 'equal')  lines.push(' ' + op.line);
+      if (op.type === 'delete') lines.push('-' + op.line);
+      if (op.type === 'insert') lines.push('+' + op.line);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/** 统计 diff 中的增删行数 */
+function countDiffLines(diffText) {
+  let added = 0, removed = 0;
+  for (const line of diffText.split('\n')) {
+    if (line.startsWith('+') && !line.startsWith('+++')) added++;
+    if (line.startsWith('-') && !line.startsWith('---')) removed++;
+  }
+  return { added, removed };
+}
+
+/** 检测 gh CLI 是否可用 */
+function isGhAvailable() {
+  try {
+    const { execSync } = require('child_process');
+    execSync('gh --version', { stdio: 'pipe' });
+    return true;
+  } catch { return false; }
+}
+
+/** 通过 gh CLI 创建 GitHub Issue */
+function submitGitHubIssue(changes, allDiffText) {
+  const { execSync } = require('child_process');
+  const skillNames = changes.map(c => c.skillName).join(', ');
+  const title = `[sync-back] 技能改进：${skillNames}`;
+  const body = [
+    '## 技能修改反馈',
+    '',
+    `> 由 \`npx ai-engineering-init sync-back --submit\` 自动生成`,
+    '',
+    '### 修改的技能',
+    '',
+    ...changes.map(c => {
+      const files = c.files.map(f => `  - \`${f.relPath}\` (+${f.added}, -${f.removed})`).join('\n');
+      return `- **${c.skillName}**\n${files}`;
+    }),
+    '',
+    '### Diff',
+    '',
+    '```diff',
+    allDiffText,
+    '```',
+    '',
+    '---',
+    `CLI 版本: v${PKG_VERSION}`,
+  ].join('\n');
+
+  try {
+    const result = execSync(
+      `gh issue create --repo xu-cell/ai-engineering-init --title "${title.replace(/"/g, '\\"')}" --body-file -`,
+      { input: body, stdio: ['pipe', 'pipe', 'pipe'], encoding: 'utf8' }
+    );
+    return result.trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+/** sync-back 命令主流程 */
+function runSyncBack(selectedTool, selectedSkill, doSubmit) {
+  console.log(`  目标目录: ${fmt('bold', targetDir)}`);
+  console.log(`  本机版本: ${fmt('bold', `v${PKG_VERSION}`)}`);
+  console.log('');
+
+  // 1. 确定扫描范围
+  let toolsToScan = [];
+  if (selectedTool && selectedTool !== 'all') {
+    if (!SKILL_DIRS[selectedTool]) {
+      console.error(fmt('red', `无效工具: "${selectedTool}"。有效选项: claude | cursor | codex | all`));
+      process.exit(1);
+    }
+    toolsToScan = [selectedTool];
+  } else {
+    toolsToScan = detectInstalledTools();
+  }
+
+  if (toolsToScan.length === 0) {
+    console.log(fmt('yellow', '⚠  当前目录未检测到已安装的 AI 工具配置。'));
+    console.log(`   请先运行: ${fmt('bold', hintCmd('--tool claude'))}\n`);
+    process.exit(1);
+  }
+
+  console.log(`  扫描工具: ${fmt('bold', toolsToScan.join(', '))}`);
+  console.log('');
+  console.log(fmt('bold', '🔍 正在对比技能文件...'));
+  console.log('');
+
+  // 2. 对比每个工具的 skills 目录
+  const allChanges = []; // { toolKey, skillName, files: [{ relPath, diff, added, removed }] }
+
+  for (const toolKey of toolsToScan) {
+    const skillDir = SKILL_DIRS[toolKey];
+    const userSkillsDir = path.join(targetDir, skillDir);
+    const srcSkillsDir  = path.join(SOURCE_DIR, skillDir);
+
+    if (!isRealDir(userSkillsDir) || !isRealDir(srcSkillsDir)) continue;
+
+    // 列出用户目录中的技能
+    let skillNames;
+    try { skillNames = fs.readdirSync(userSkillsDir); } catch { continue; }
+
+    for (const name of skillNames) {
+      if (selectedSkill && name !== selectedSkill) continue;
+
+      const userSkillDir = path.join(userSkillsDir, name);
+      const srcSkillDir  = path.join(srcSkillsDir, name);
+
+      if (!isRealDir(userSkillDir)) continue;
+
+      // 列出用户技能目录下所有文件
+      const userFiles = listFilesRecursive(userSkillDir);
+      const srcFiles  = isRealDir(srcSkillDir) ? listFilesRecursive(srcSkillDir) : [];
+      const allFiles = [...new Set([...userFiles, ...srcFiles])].sort();
+
+      const changedFiles = [];
+
+      for (const relFile of allFiles) {
+        const userFile = path.join(userSkillDir, relFile);
+        const srcFile  = path.join(srcSkillDir, relFile);
+
+        const userExists = fs.existsSync(userFile);
+        const srcExists  = fs.existsSync(srcFile);
+
+        if (userExists && srcExists) {
+          // 两边都有，对比内容
+          const userContent = fs.readFileSync(userFile, 'utf8');
+          const srcContent  = fs.readFileSync(srcFile, 'utf8');
+          if (userContent !== srcContent) {
+            const diff = generateDiff(srcContent, userContent,
+              `原版 (v${PKG_VERSION})`, '本地修改');
+            if (diff) {
+              const { added, removed } = countDiffLines(diff);
+              changedFiles.push({ relPath: relFile, diff, added, removed, status: 'modified' });
+            }
+          }
+        } else if (userExists && !srcExists) {
+          // 用户新增的文件
+          const content = fs.readFileSync(userFile, 'utf8');
+          const lineCount = content.split(/\r?\n/).length;
+          changedFiles.push({
+            relPath: relFile,
+            diff: `--- /dev/null\n+++ 本地新增\n@@ -0,0 +1,${lineCount} @@\n` +
+                  content.split(/\r?\n/).map(l => '+' + l).join('\n'),
+            added: lineCount, removed: 0, status: 'added'
+          });
+        }
+        // srcExists && !userExists: 用户删除的文件（不报告，可能是有意删除）
+      }
+
+      if (changedFiles.length > 0) {
+        // 去重：只保留第一个工具的结果（多工具 skills 内容相同）
+        const existing = allChanges.find(c => c.skillName === name);
+        if (!existing) {
+          allChanges.push({ toolKey, skillName: name, files: changedFiles });
+        }
+      }
+    }
+  }
+
+  // 3. 展示结果
+  if (allChanges.length === 0) {
+    console.log(fmt('green', '  ✓ 未检测到技能修改，所有技能与包版本一致。'));
+    console.log('');
+    return;
+  }
+
+  console.log(`  检测到 ${fmt('bold', String(allChanges.length))} 个技能有修改：`);
+  console.log('');
+
+  for (let idx = 0; idx < allChanges.length; idx++) {
+    const change = allChanges[idx];
+    console.log(`  ${fmt('bold', String(idx + 1) + '.')} ${fmt('cyan', change.skillName)}`);
+    for (const file of change.files) {
+      const statusLabel = file.status === 'added' ? fmt('green', '新增文件') : fmt('yellow', '修改文件');
+      console.log(`     ${statusLabel}: ${file.relPath} (${fmt('green', '+' + file.added)} 行, ${fmt('red', '-' + file.removed)} 行)`);
+    }
+    console.log('');
+  }
+
+  // 4. 展示 diff 详情
+  const allDiffParts = [];
+
+  for (const change of allChanges) {
+    for (const file of change.files) {
+      const header = `${change.skillName}/${file.relPath}`;
+      console.log(fmt('bold', '─'.repeat(Math.min(50, header.length + 10))));
+      console.log(`📋 ${fmt('bold', header)} 的变更：`);
+      console.log(fmt('bold', '─'.repeat(Math.min(50, header.length + 10))));
+
+      // 着色 diff 输出
+      for (const line of file.diff.split('\n')) {
+        if (line.startsWith('+++') || line.startsWith('---')) {
+          console.log(fmt('bold', line));
+        } else if (line.startsWith('+')) {
+          console.log(fmt('green', line));
+        } else if (line.startsWith('-')) {
+          console.log(fmt('red', line));
+        } else if (line.startsWith('@@')) {
+          console.log(fmt('cyan', line));
+        } else {
+          console.log(line);
+        }
+      }
+      console.log('');
+
+      allDiffParts.push(`# ${header}\n${file.diff}`);
+    }
+  }
+
+  const allDiffText = allDiffParts.join('\n\n');
+
+  // 5. 提交 Issue 或提示
+  if (doSubmit) {
+    console.log(fmt('bold', '📤 正在提交 GitHub Issue...'));
+    console.log('');
+
+    if (!isGhAvailable()) {
+      console.log(fmt('yellow', '⚠  未检测到 gh CLI，无法自动提交 Issue。'));
+      console.log(`   安装方法: ${fmt('bold', 'https://cli.github.com/')}`);
+      console.log('');
+      console.log(fmt('bold', '📋 请手动复制以下内容到 GitHub Issue：'));
+      console.log('');
+      console.log(fmt('cyan', '─'.repeat(50)));
+      console.log(`标题: [sync-back] 技能改进：${allChanges.map(c => c.skillName).join(', ')}`);
+      console.log(fmt('cyan', '─'.repeat(50)));
+      console.log(allDiffText);
+      console.log(fmt('cyan', '─'.repeat(50)));
+      console.log('');
+      console.log(`提交到: ${fmt('bold', 'https://github.com/xu-cell/ai-engineering-init/issues/new')}`);
+    } else {
+      const issueUrl = submitGitHubIssue(allChanges, allDiffText);
+      if (issueUrl) {
+        console.log(fmt('green', fmt('bold', '✅ Issue 已创建！')));
+        console.log(`  ${fmt('bold', issueUrl)}`);
+      } else {
+        console.log(fmt('red', '✗ Issue 创建失败，请检查 gh 认证状态（gh auth status）'));
+        console.log('');
+        console.log(fmt('bold', '📋 请手动复制上方 diff 到 GitHub Issue：'));
+        console.log(`  ${fmt('bold', 'https://github.com/xu-cell/ai-engineering-init/issues/new')}`);
+      }
+    }
+  } else {
+    console.log(fmt('cyan', '💡 提交方式：'));
+    if (allChanges.length === 1) {
+      console.log(`  → 运行 ${fmt('bold', hintCmd(`sync-back --skill ${allChanges[0].skillName} --submit`))}`);
+    } else {
+      console.log(`  → 运行 ${fmt('bold', hintCmd('sync-back --submit'))}`);
+    }
+    console.log(`  → 或手动复制上方 diff 到 ${fmt('bold', 'https://github.com/xu-cell/ai-engineering-init/issues/new')}`);
+  }
+  console.log('');
+}
+
+// ── 数据库配置初始化 ──────────────────────────────────────────────────────
+function runConfig() {
+  if (!process.stdin.isTTY) {
+    console.error(fmt('red', '错误：config 命令需要交互式终端'));
+    process.exit(1);
+  }
+
+  const configPath = path.join(targetDir, '.claude', 'mysql-config.json');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const ask = (question) => new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+
+  const ENV_DEFAULTS = {
+    local: { host: '127.0.0.1', user: 'root', desc: '本地开发环境' },
+    dev:   { host: '',          user: '',     desc: '开发测试环境' },
+    test:  { host: '',          user: '',     desc: '测试环境' },
+    prod:  { host: '',          user: '',     desc: '生产环境' },
+  };
+
+  (async () => {
+    try {
+      // 1. 检测已有配置
+      if (fs.existsSync(configPath)) {
+        console.log(fmt('yellow', `⚠ 配置文件已存在：${configPath}`));
+        const overwrite = await ask(fmt('bold', '是否重新配置？[y/N]: '));
+        if (overwrite.toLowerCase() !== 'y') {
+          console.log('已取消。');
+          rl.close();
+          return;
+        }
+        console.log('');
+      }
+
+      // 2. 选择环境
+      console.log(fmt('cyan', '请选择要配置的数据库环境（多选，用逗号分隔）：'));
+      console.log('');
+      console.log(`  ${fmt('bold', '1')}) local  — 本地开发环境`);
+      console.log(`  ${fmt('bold', '2')}) dev    — 开发测试环境`);
+      console.log(`  ${fmt('bold', '3')}) test   — 测试环境`);
+      console.log(`  ${fmt('bold', '4')}) prod   — 生产环境`);
+      console.log('');
+      const envAnswer = await ask(fmt('bold', '请输入选项（如 1,2 或 1-3）: '));
+
+      // 解析选择
+      const envNames = ['local', 'dev', 'test', 'prod'];
+      const selected = new Set();
+      for (const part of envAnswer.split(',')) {
+        const trimmed = part.trim();
+        const rangeMatch = trimmed.match(/^(\d)-(\d)$/);
+        if (rangeMatch) {
+          const start = parseInt(rangeMatch[1], 10);
+          const end = parseInt(rangeMatch[2], 10);
+          for (let n = start; n <= end; n++) {
+            if (n >= 1 && n <= 4) selected.add(envNames[n - 1]);
+          }
+        } else {
+          const n = parseInt(trimmed, 10);
+          if (n >= 1 && n <= 4) selected.add(envNames[n - 1]);
+        }
+      }
+
+      const selectedEnvs = [...selected];
+      if (selectedEnvs.length === 0) {
+        console.error(fmt('red', '未选择任何环境，退出。'));
+        rl.close();
+        process.exit(1);
+      }
+
+      console.log('');
+      console.log(fmt('green', `已选择环境：${selectedEnvs.join(', ')}`));
+      console.log('');
+
+      // 3. 收集每个环境的配置
+      const environments = {};
+      for (const env of selectedEnvs) {
+        const defaults = ENV_DEFAULTS[env];
+        console.log(fmt('cyan', `── ${env} 环境配置 ──`));
+
+        const host = await ask(`  host [${defaults.host || '无默认'}]: `) || defaults.host;
+        const port = await ask('  port [3306]: ') || '3306';
+        const user = await ask(`  user [${defaults.user || '无默认'}]: `) || defaults.user;
+        const password = await ask('  password: ');
+        const desc = await ask(`  描述 [${defaults.desc}]: `) || defaults.desc;
+        console.log('');
+
+        if (!host) {
+          console.error(fmt('red', `错误：${env} 环境的 host 不能为空`));
+          rl.close();
+          process.exit(1);
+        }
+        if (!user) {
+          console.error(fmt('red', `错误：${env} 环境的 user 不能为空`));
+          rl.close();
+          process.exit(1);
+        }
+
+        environments[env] = {
+          host,
+          port: parseInt(port, 10),
+          user,
+          password,
+          description: desc,
+        };
+      }
+
+      // 4. 选择默认环境
+      let defaultEnv = selectedEnvs[0];
+      if (selectedEnvs.length > 1) {
+        console.log(fmt('cyan', '请选择默认环境：'));
+        selectedEnvs.forEach((env, i) => {
+          console.log(`  ${fmt('bold', String(i + 1))}) ${env}`);
+        });
+        const defaultAnswer = await ask(fmt('bold', `请输入选项 [1-${selectedEnvs.length}]: `));
+        const idx = parseInt(defaultAnswer, 10) - 1;
+        if (idx >= 0 && idx < selectedEnvs.length) {
+          defaultEnv = selectedEnvs[idx];
+        }
+        console.log('');
+      }
+
+      // 5. 写入配置文件
+      const config = { defaultEnv, environments };
+      const claudeDir = path.join(targetDir, '.claude');
+      if (!fs.existsSync(claudeDir)) {
+        fs.mkdirSync(claudeDir, { recursive: true });
+      }
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+      console.log(fmt('green', `✔ 配置已写入：${configPath}`));
+
+      // 6. 确保 .gitignore 包含该文件
+      const gitignorePath = path.join(targetDir, '.gitignore');
+      const ignoreEntry = '.claude/mysql-config.json';
+      let needAppend = true;
+      if (fs.existsSync(gitignorePath)) {
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        if (content.split('\n').some(line => line.trim() === ignoreEntry)) {
+          needAppend = false;
+        }
+      }
+      if (needAppend) {
+        const separator = fs.existsSync(gitignorePath) ? '\n' : '';
+        fs.appendFileSync(gitignorePath, `${separator}${ignoreEntry}\n`, 'utf-8');
+        console.log(fmt('green', `✔ 已添加 ${ignoreEntry} 到 .gitignore`));
+      }
+
+      console.log('');
+      console.log(fmt('green', '数据库配置初始化完成！'));
+      console.log(`使用 ${fmt('bold', 'mysql-debug')} 技能时将自动读取此配置。`);
+    } finally {
+      rl.close();
+    }
+  })();
+}
+
+// ── MCP 服务器管理 ──────────────────────────────────────────────────────────
+
+const MCP_REGISTRY = [
+  {
+    name: 'sequential-thinking',
+    package: '@modelcontextprotocol/server-sequential-thinking',
+    description: '链式推理 — 深度分析、仔细思考、全面评估时使用',
+    env: {},
+    recommended: true,
+  },
+  {
+    name: 'context7',
+    package: '@upstash/context7-mcp',
+    description: '官方文档查询 — 最佳实践、官方文档、标准写法时使用',
+    env: {},
+    recommended: true,
+  },
+  {
+    name: 'github',
+    package: '@modelcontextprotocol/server-github',
+    description: 'GitHub 集成 — 查询 Issues、PR、仓库信息',
+    env: { GITHUB_PERSONAL_ACCESS_TOKEN: '${GITHUB_TOKEN}' },
+    recommended: true,
+  },
+  {
+    name: 'filesystem',
+    package: '@modelcontextprotocol/server-filesystem',
+    description: '文件系统访问 — 读写项目外的文件',
+    env: {},
+    recommended: false,
+  },
+  {
+    name: 'fetch',
+    package: '@anthropic-ai/mcp-fetch',
+    description: '网页抓取 — 获取网页内容',
+    env: {},
+    recommended: false,
+  },
+  {
+    name: 'yunxiao',
+    package: 'alibabacloud-devops-mcp-server',
+    description: '阿里云效 — DevOps 项目管理、代码仓库、流水线集成',
+    env: { YUNXIAO_ACCESS_TOKEN: '<YOUR_TOKEN>' },
+    recommended: false,
+  },
+  {
+    name: 'yuque',
+    package: 'yuque-mcp',
+    description: '语雀 — 知识库文档读写、搜索、团队协作',
+    env: { YUQUE_TOKEN: '<YOUR_TOKEN>' },
+    recommended: false,
+  },
+];
+
+/** MCP 配置文件路径映射 */
+const MCP_CONFIG_PATHS = {
+  claude: { file: '.claude/settings.json', key: 'mcpServers' },
+  cursor: { file: '.cursor/mcp.json',      key: 'mcpServers' },
+};
+
+/** 检测项目中已有的工具配置目录 */
+function detectMcpTools() {
+  const tools = [];
+  if (isRealDir(path.join(targetDir, '.claude'))) tools.push('claude');
+  if (isRealDir(path.join(targetDir, '.cursor'))) tools.push('cursor');
+  return tools;
+}
+
+/** 读取指定工具的 MCP 已配置服务器 */
+function getMcpServers(toolName) {
+  const config = MCP_CONFIG_PATHS[toolName];
+  if (!config) return {};
+  const filePath = path.join(targetDir, config.file);
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return data[config.key] || {};
+  } catch { return {}; }
+}
+
+/** 写入指定工具的 MCP 配置（保留文件其他字段） */
+function setMcpServers(toolName, mcpServers) {
+  const config = MCP_CONFIG_PATHS[toolName];
+  if (!config) return;
+  const filePath = path.join(targetDir, config.file);
+  let data = {};
+  try { data = JSON.parse(fs.readFileSync(filePath, 'utf8')); } catch { /* 新建 */ }
+  data[config.key] = mcpServers;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+
+/** 构建单个 MCP 服务器的配置对象 */
+function buildMcpServerConfig(entry) {
+  const config = {
+    command: 'npx',
+    args: ['-y', entry.package],
+  };
+  if (Object.keys(entry.env).length > 0) {
+    config.env = { ...entry.env };
+  }
+  return config;
+}
+
+/** 获取所有工具中已安装的 MCP 服务器名称集合 */
+function getInstalledMcpNames(tools) {
+  const names = new Set();
+  for (const t of tools) {
+    const servers = getMcpServers(t);
+    for (const name of Object.keys(servers)) names.add(name);
+  }
+  return names;
+}
+
+function runMcp() {
+  if (!process.stdin.isTTY) {
+    console.error(fmt('red', '错误：mcp 命令需要交互式终端'));
+    process.exit(1);
+  }
+
+  const tools = detectMcpTools();
+  if (tools.length === 0) {
+    console.log(fmt('yellow', '⚠  当前目录未检测到 .claude/ 或 .cursor/ 配置目录。'));
+    console.log(`   请先运行: ${fmt('bold', hintCmd('init --tool claude'))}`);
+    console.log('');
+    process.exit(1);
+  }
+
+  console.log(`  检测到工具: ${fmt('bold', tools.join(', '))}`);
+  console.log('');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (question) => new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+
+  (async () => {
+    try {
+      console.log(fmt('cyan', '请选择 MCP 操作：'));
+      console.log('');
+      console.log(`  ${fmt('bold', '1')}) ${fmt('green',  '安装 MCP 服务器')}    — 从预置列表选择并安装到配置`);
+      console.log(`  ${fmt('bold', '2')}) ${fmt('red',    '卸载 MCP 服务器')}    — 从已安装列表中移除`);
+      console.log(`  ${fmt('bold', '3')}) ${fmt('cyan',   '查看状态')}           — 检查已配置的 MCP 服务器`);
+      console.log(`  ${fmt('bold', '4')}) ${fmt('yellow', '一键推荐安装')}       — 安装所有推荐的 MCP 服务器`);
+      console.log('');
+      const action = await ask(fmt('bold', '请输入选项 [1-4]: '));
+      console.log('');
+
+      switch (action) {
+        case '1': await mcpInstall(tools, ask); break;
+        case '2': await mcpUninstall(tools, ask); break;
+        case '3': mcpStatus(tools); break;
+        case '4': await mcpRecommend(tools, ask); break;
+        default:
+          console.error(fmt('red', '无效选项，退出。'));
+          process.exit(1);
+      }
+    } finally {
+      rl.close();
+    }
+  })();
+}
+
+/** 安装 MCP 服务器 */
+async function mcpInstall(tools, ask) {
+  const installed = getInstalledMcpNames(tools);
+
+  console.log(fmt('cyan', '可用的 MCP 服务器：'));
+  console.log('');
+  for (let i = 0; i < MCP_REGISTRY.length; i++) {
+    const entry = MCP_REGISTRY[i];
+    const tags = [];
+    if (installed.has(entry.name)) tags.push(fmt('green', '[已安装]'));
+    if (entry.recommended) tags.push(fmt('yellow', '[推荐]'));
+    const tagStr = tags.length > 0 ? ' ' + tags.join(' ') : '';
+    console.log(`  ${fmt('bold', String(i + 1))}) ${fmt('bold', entry.name)}${tagStr}`);
+    console.log(`     ${entry.description}`);
+  }
+  console.log('');
+  const answer = await ask(fmt('bold', '请选择要安装的服务器（逗号分隔，如 1,2,3）: '));
+  const indices = answer.split(',').map(s => parseInt(s.trim(), 10) - 1).filter(i => i >= 0 && i < MCP_REGISTRY.length);
+
+  if (indices.length === 0) {
+    console.log(fmt('yellow', '未选择任何服务器，退出。'));
+    return;
+  }
+
+  const selected = indices.map(i => MCP_REGISTRY[i]);
+  console.log('');
+
+  // 处理需要 env 的服务器
+  for (const entry of selected) {
+    if (Object.keys(entry.env).length > 0) {
+      console.log(fmt('cyan', `── ${entry.name} 环境变量配置 ──`));
+      for (const [key, defaultVal] of Object.entries(entry.env)) {
+        const val = await ask(`  ${key} [${defaultVal}]: `);
+        if (val) entry.env[key] = val;
+      }
+      console.log('');
+    }
+  }
+
+  // 写入所有检测到的工具配置
+  for (const toolName of tools) {
+    const servers = getMcpServers(toolName);
+    for (const entry of selected) {
+      servers[entry.name] = buildMcpServerConfig(entry);
+    }
+    setMcpServers(toolName, servers);
+    console.log(`  ${fmt('green', '✓')}  ${toolName}: 已写入 ${selected.map(e => e.name).join(', ')}`);
+  }
+
+  console.log('');
+  console.log(fmt('green', fmt('bold', `✅ 已安装 ${selected.length} 个 MCP 服务器！`)));
+  console.log('');
+}
+
+/** 卸载 MCP 服务器 */
+async function mcpUninstall(tools, ask) {
+  // 收集所有已安装的服务器（合并去重）
+  const allServers = new Map(); // name → 出现在哪些工具中
+  for (const toolName of tools) {
+    const servers = getMcpServers(toolName);
+    for (const name of Object.keys(servers)) {
+      if (!allServers.has(name)) allServers.set(name, []);
+      allServers.get(name).push(toolName);
+    }
+  }
+
+  if (allServers.size === 0) {
+    console.log(fmt('yellow', '  当前没有已安装的 MCP 服务器。'));
+    console.log(`  运行 ${fmt('bold', hintCmd('mcp'))} 安装服务器。`);
+    console.log('');
+    return;
+  }
+
+  const serverNames = [...allServers.keys()];
+  console.log(fmt('cyan', '已安装的 MCP 服务器：'));
+  console.log('');
+  for (let i = 0; i < serverNames.length; i++) {
+    const name = serverNames[i];
+    const toolList = allServers.get(name).join(', ');
+    console.log(`  ${fmt('bold', String(i + 1))}) ${fmt('bold', name)} ${fmt('magenta', `(${toolList})`)}`);
+  }
+  console.log('');
+  const answer = await ask(fmt('bold', '请选择要卸载的服务器（逗号分隔）: '));
+  const indices = answer.split(',').map(s => parseInt(s.trim(), 10) - 1).filter(i => i >= 0 && i < serverNames.length);
+
+  if (indices.length === 0) {
+    console.log(fmt('yellow', '未选择任何服务器，退出。'));
+    return;
+  }
+
+  const toRemove = indices.map(i => serverNames[i]);
+  console.log('');
+
+  for (const toolName of tools) {
+    const servers = getMcpServers(toolName);
+    let removed = 0;
+    for (const name of toRemove) {
+      if (name in servers) {
+        delete servers[name];
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      setMcpServers(toolName, servers);
+      console.log(`  ${fmt('green', '✓')}  ${toolName}: 已移除 ${toRemove.filter(n => !servers[n]).join(', ')}`);
+    }
+  }
+
+  console.log('');
+  console.log(fmt('green', fmt('bold', `✅ 已卸载 ${toRemove.length} 个 MCP 服务器！`)));
+  console.log('');
+}
+
+/** 查看 MCP 状态 */
+function mcpStatus(tools) {
+  let hasAny = false;
+
+  for (const toolName of tools) {
+    const servers = getMcpServers(toolName);
+    const names = Object.keys(servers);
+
+    console.log(fmt('cyan', `[${toolName}]`) + ` ${MCP_CONFIG_PATHS[toolName].file}`);
+
+    if (names.length === 0) {
+      console.log(`  ${fmt('yellow', '（无已安装的 MCP 服务器）')}`);
+    } else {
+      hasAny = true;
+      for (const name of names) {
+        const srv = servers[name];
+        const pkg = (srv.args || []).find(a => a.startsWith('@')) || '—';
+        const envKeys = srv.env ? Object.keys(srv.env).join(', ') : '—';
+        console.log(`  ${fmt('green', '●')} ${fmt('bold', name)}`);
+        console.log(`    包: ${pkg}  |  环境变量: ${envKeys}`);
+      }
+    }
+    console.log('');
+  }
+
+  if (!hasAny) {
+    console.log(fmt('yellow', '💡 未安装任何 MCP 服务器。'));
+    console.log(`   运行 ${fmt('bold', hintCmd('mcp'))} 开始安装。`);
+    console.log('');
+  }
+}
+
+/** 一键推荐安装 */
+async function mcpRecommend(tools, ask) {
+  const installed = getInstalledMcpNames(tools);
+  const toInstall = MCP_REGISTRY.filter(e => e.recommended && !installed.has(e.name));
+
+  if (toInstall.length === 0) {
+    console.log(fmt('green', '  ✓ 所有推荐的 MCP 服务器已安装！'));
+    console.log('');
+    mcpStatus(tools);
+    return;
+  }
+
+  console.log(fmt('cyan', '将安装以下推荐服务器：'));
+  console.log('');
+  for (const entry of toInstall) {
+    console.log(`  ${fmt('green', '●')} ${fmt('bold', entry.name)} — ${entry.description}`);
+  }
+  console.log('');
+
+  // 处理需要 env 的服务器
+  for (const entry of toInstall) {
+    if (Object.keys(entry.env).length > 0) {
+      console.log(fmt('cyan', `── ${entry.name} 环境变量配置 ──`));
+      for (const [key, defaultVal] of Object.entries(entry.env)) {
+        const val = await ask(`  ${key} [${defaultVal}]: `);
+        if (val) entry.env[key] = val;
+      }
+      console.log('');
+    }
+  }
+
+  // 写入配置
+  for (const toolName of tools) {
+    const servers = getMcpServers(toolName);
+    for (const entry of toInstall) {
+      servers[entry.name] = buildMcpServerConfig(entry);
+    }
+    setMcpServers(toolName, servers);
+    console.log(`  ${fmt('green', '✓')}  ${toolName}: 已写入 ${toInstall.map(e => e.name).join(', ')}`);
+  }
+
+  console.log('');
+  console.log(fmt('green', fmt('bold', `✅ 已安装 ${toInstall.length} 个推荐 MCP 服务器！`)));
+  console.log('');
+}
+
+// ── 工具选择菜单（init 用）─────────────────────────────────────────────────
+function showToolMenu() {
   if (!process.stdin.isTTY) {
     console.error(fmt('red', '错误：非交互环境下必须指定 --tool 参数'));
-    console.error(`  示例: ${fmt('bold', hintCmd('--tool claude'))}`);
+    console.error(`  示例: ${fmt('bold', hintCmd('init --tool claude'))}`);
     process.exit(1);
   }
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  console.log(fmt('cyan', '请选择操作：'));
+  console.log(fmt('cyan', '请选择要初始化的工具：'));
   console.log('');
-  console.log(`  ${fmt('bold', '1')}) ${fmt('green',   'Claude Code')}   — 初始化到当前项目 .claude/ + CLAUDE.md`);
-  console.log(`  ${fmt('bold', '2')}) ${fmt('cyan',    'Cursor')}        — 初始化到当前项目 .cursor/（Skills + Agents）`);
-  console.log(`  ${fmt('bold', '3')}) ${fmt('yellow',  'OpenAI Codex')}  — 初始化到当前项目 .codex/ + AGENTS.md`);
-  console.log(`  ${fmt('bold', '4')}) ${fmt('blue',    '全部工具')}       — 同时初始化 Claude + Cursor + Codex 到当前项目`);
-  console.log(`  ${fmt('bold', '5')}) ${fmt('magenta', '全局安装')}       — 安装到 ~/.claude / ~/.cursor，对所有项目生效`);
+  console.log(`  ${fmt('bold', '1')}) ${fmt('green',   'Claude Code')}   — .claude/ + CLAUDE.md`);
+  console.log(`  ${fmt('bold', '2')}) ${fmt('cyan',    'Cursor')}        — .cursor/（Skills + Agents）`);
+  console.log(`  ${fmt('bold', '3')}) ${fmt('yellow',  'OpenAI Codex')}  — .codex/ + AGENTS.md`);
+  console.log(`  ${fmt('bold', '4')}) ${fmt('blue',    '全部工具')}       — 同时初始化 Claude + Cursor + Codex`);
   console.log('');
-  rl.question(fmt('bold', '请输入选项 [1-5]: '), (answer) => {
+  rl.question(fmt('bold', '请输入选项 [1-4]: '), (answer) => {
     rl.close();
     const map = { '1': 'claude', '2': 'cursor', '3': 'codex', '4': 'all' };
     const selected = map[answer.trim()];
     console.log('');
-    if (answer.trim() === '5') {
-      runGlobal('all');
-    } else if (selected) {
+    if (selected) {
       run(selected);
     } else {
       console.error(fmt('red', '无效选项，退出。'));
@@ -713,3 +1652,76 @@ if (command === 'update') {
     }
   });
 }
+
+// ── 主菜单（无命令时展示）──────────────────────────────────────────────────
+function showMainMenu() {
+  if (!process.stdin.isTTY) {
+    console.error(fmt('red', '错误：非交互环境下必须指定命令'));
+    console.error(`  示例: ${fmt('bold', hintCmd('init --tool claude'))}`);
+    console.error(`  运行 ${fmt('bold', hintCmd('--help'))} 查看所有命令`);
+    process.exit(1);
+  }
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  console.log(fmt('cyan', '请选择操作：'));
+  console.log('');
+  console.log(`  ${fmt('bold', '1')}) ${fmt('green',   '初始化')}         — 安装 AI 工具配置到当前项目`);
+  console.log(`  ${fmt('bold', '2')}) ${fmt('cyan',    '更新')}           — 更新已安装的框架文件`);
+  console.log(`  ${fmt('bold', '3')}) ${fmt('yellow',  '全局安装')}       — 安装到 ~/.claude 等，对所有项目生效`);
+  console.log(`  ${fmt('bold', '4')}) ${fmt('magenta', '技能同步反馈')}   — 对比本地技能修改，生成 diff`);
+  console.log(`  ${fmt('bold', '5')}) ${fmt('blue',    '数据库配置')}     — 初始化 mysql-config.json（数据库连接信息）`);
+  console.log(`  ${fmt('bold', '6')}) ${fmt('green',   'MCP 管理')}       — MCP 服务器安装/卸载/状态检查`);
+  console.log('');
+  rl.question(fmt('bold', '请输入选项 [1-6]: '), (answer) => {
+    rl.close();
+    console.log('');
+    switch (answer.trim()) {
+      case '1':
+        showToolMenu();
+        break;
+      case '2':
+        runUpdate(tool);
+        break;
+      case '3':
+        runGlobal(tool || 'all');
+        break;
+      case '4':
+        runSyncBack(tool, skillFilter, submitIssue);
+        break;
+      case '5':
+        runConfig();
+        break;
+      case '6':
+        runMcp();
+        break;
+      default:
+        console.error(fmt('red', '无效选项，退出。'));
+        process.exit(1);
+    }
+  });
+}
+
+// ── 主入口 ────────────────────────────────────────────────────────────────
+if (command === 'init') {
+  // 显式 init 子命令
+  if (tool) {
+    run(tool);
+  } else {
+    showToolMenu();
+  }
+} else if (command === 'update') {
+  runUpdate(tool);
+} else if (command === 'global') {
+  runGlobal(tool);
+} else if (command === 'sync-back') {
+  runSyncBack(tool, skillFilter, submitIssue);
+} else if (command === 'config') {
+  runConfig();
+} else if (command === 'mcp') {
+  runMcp();
+} else if (tool) {
+  // 向后兼容：无 command 但有 --tool，当作 init 执行
+  run(tool);
+} else {
+  // 无命令无参数：显示主菜单
+  showMainMenu();
+}