sillyspec 3.12.8 → 3.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.12.8",
+  "version": "3.14.0",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",
@@ -27,6 +27,7 @@
     "@inquirer/prompts": "^7.10.1",
     "chalk": "^5.6.2",
     "chokidar": "^4.0",
+    "js-yaml": "^4.2.0",
     "open": "^10.1",
     "ora": "^9.3.0",
     "sql.js": "^1.14.1",

package/src/index.js

@@ -94,6 +94,7 @@ async function main() {
 
   // 解析全局选项
   let json = false;
+  let saveWorkflowRunFlag = false;
   let targetDir = process.cwd();
   let tool = null;
   let interactive = false;
@@ -102,6 +103,8 @@ async function main() {
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '--json') {
       json = true;
+    } else if (args[i] === '--save') {
+      saveWorkflowRunFlag = true;
     } else if (args[i] === '--dir' && args[i + 1]) {
       targetDir = resolve(args[i + 1]);
       i++;
@@ -474,6 +477,176 @@ SillySpec platform — SillyHub 平台同步
       }
       break;
     }
+    case 'change-rename': {
+      const oldName = filteredArgs[1];
+      const newName = filteredArgs[2];
+      if (!oldName || !newName) {
+        console.error('❌ 用法: sillyspec change-rename <旧变更名> <新变更名>');
+        process.exit(1);
+      }
+      const pm = new ProgressManager();
+      await pm.renameChange(dir, oldName, newName);
+      break;
+    }
+    case 'workflow': {
+      const wfSub = filteredArgs[1];
+      if (!wfSub || wfSub === 'help' || wfSub === '--help') {
+        console.log(`
+SillySpec workflow — 工作流管理
+
+用法:
+  sillyspec workflow check <name> [--project <project>] [--json]
+  sillyspec workflow list
+`);
+        break;
+      }
+      if (wfSub === 'list') {
+        const { listWorkflows } = await import('./workflow.js');
+        const names = listWorkflows(dir);
+        if (names.length === 0) {
+          console.log('未找到 workflow 定义（.sillyspec/workflows/*.yaml）');
+        } else {
+          console.log(`可用 workflow：`);
+          for (const name of names) {
+            const { loadWorkflow } = await import('./workflow.js');
+            const wf = loadWorkflow(dir, name);
+            const specVer = wf?.spec_version || wf?.version || '?';
+            const mode = wf?.orchestration?.mode || '?';
+            const roles = wf?.roles?.length || 0;
+            console.log(`  ${name} (spec v${specVer}, ${mode}, ${roles} roles)`);
+          }
+        }
+        break;
+      }
+      if (wfSub === 'check') {
+        const { loadWorkflow, runPostCheck, listWorkflows, saveWorkflowRun } = await import('./workflow.js');
+        const wfName = filteredArgs[2];
+        if (!wfName) {
+          console.error('❌ 请指定 workflow 名称，例如：sillyspec workflow check scan-docs --project sillyspec');
+          process.exit(2);
+        }
+        const wf = loadWorkflow(dir, wfName);
+        if (!wf) {
+          console.error(`❌ 未找到 workflow: ${wfName}`);
+          console.error(`可用 workflow：${listWorkflows(dir).join(', ') || '无'}`);
+          process.exit(2);
+        }
+        // depends_on 校验
+        if (wf._validationErrors && wf._validationErrors.length > 0) {
+          console.error('❌ workflow YAML 校验失败：');
+          for (const err of wf._validationErrors) {
+            console.error(`   ${err}`);
+          }
+          process.exit(2);
+        }
+        // spec_version 校验
+        const specVer = wf.spec_version || wf.version;
+        if (!specVer) {
+          console.error('❌ workflow YAML 缺少 spec_version 字段');
+          process.exit(2);
+        }
+        const SUPPORTED_SPECS = [1];
+        if (!SUPPORTED_SPECS.includes(specVer)) {
+          console.error(`❌ 不支持的 spec_version: ${specVer}（支持: ${SUPPORTED_SPECS.join(', ')}）`);
+          process.exit(2);
+        }
+        // 解析 --project
+        const projectIdx = filteredArgs.indexOf('--project');
+        const project = projectIdx !== -1 && filteredArgs[projectIdx + 1] ? filteredArgs[projectIdx + 1] : null;
+        // 解析 --json（已在顶层解析）
+        const isJson = json;
+        // 解析 --change
+        const changeIdx = filteredArgs.indexOf('--change');
+        const changeName = changeIdx !== -1 && filteredArgs[changeIdx + 1] ? filteredArgs[changeIdx + 1] : null;
+
+        if (!project && wfName !== 'archive-impact') {
+          console.error('❌ 请指定 --project，例如：--project sillyspec');
+          process.exit(2);
+        }
+
+        // 执行检查
+        let resolvedWf = wf;
+        const placeholders = {};
+        if (changeName) placeholders['change-name'] = changeName;
+        // 替换占位符
+        let jsonStr = JSON.stringify(resolvedWf);
+        if (changeName) jsonStr = jsonStr.replace(/<change-name>/g, changeName);
+        resolvedWf = JSON.parse(jsonStr);
+
+        const projectName = project || 'sillyspec';
+        const result = runPostCheck(resolvedWf, dir, projectName, placeholders);
+
+        if (isJson) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          // 带项目维度前缀的输出（从统一结果对象格式化）
+          const lines = [`\n📋 Workflow Post-Check: ${result.workflow} (project: ${result.project})\n`];
+          for (const r of (result.roles || [])) {
+            const icon = r.status === 'pass' ? '✅' : '❌';
+            lines.push(`${icon} [${result.project}] ${r.name} (${r.id})`);
+            const roleFailures = (result.failures || []).filter(f => f.role_id === r.id);
+            for (const f of roleFailures) {
+              lines.push(`   └─ ${f.message}`);
+            }
+          }
+          const wfFailures = (result.workflow_checks || []).filter(c => c.status === 'fail');
+          if (wfFailures.length > 0) {
+            lines.push('');
+            for (const f of wfFailures) {
+              lines.push(`❌ [${result.project}] 全局: ${f.detail}`);
+            }
+          }
+          lines.push('');
+          if (result.status === 'pass') {
+            lines.push('✅ 全部检查通过');
+          } else {
+            lines.push('❌ 存在失败项');
+          }
+          console.log(lines.join('\n'));
+        }
+
+        // exit code: 0=通过, 1=检查失败, 2=参数/YAML错误
+        if (saveWorkflowRunFlag) {
+          const saved = saveWorkflowRun(result, { cwd: dir, source: 'cli' });
+          if (saved) {
+            if (!isJson) console.log(`\n📁 结果已归档：${saved}`);
+          }
+        }
+        process.exit(result.status === 'pass' ? 0 : 1);
+      } else {
+        console.error(`❌ 未知子命令: workflow ${wfSub}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case 'modules': {
+      const modulesSub = filteredArgs[1];
+      if (!modulesSub || modulesSub === 'help' || modulesSub === '--help') {
+        console.log(`
+SillySpec modules — 模块文档管理
+
+用法:
+  sillyspec modules rebuild        从模块卡片 + 源码重建 _module-map.yaml
+  sillyspec modules status         显示模块索引状态
+  sillyspec modules migrate        旧格式模块文档迁移到新格式
+`);
+        break;
+      }
+      if (modulesSub === 'rebuild') {
+        const { rebuildModuleMap } = await import('./modules.js');
+        await rebuildModuleMap(dir);
+      } else if (modulesSub === 'status') {
+        const { showModuleStatus } = await import('./modules.js');
+        await showModuleStatus(dir);
+      } else if (modulesSub === 'migrate') {
+        const { migrateModuleDocs } = await import('./modules.js');
+        await migrateModuleDocs(dir);
+      } else {
+        console.error(`❌ 未知子命令: modules ${modulesSub}`);
+        process.exit(1);
+      }
+      break;
+    }
     default:
       console.error(`❌ 未知命令: ${command}`);
       printUsage();

package/src/modules.js

@@ -0,0 +1,427 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { DB } from './db.js';
+
+/**
+ * 查找项目下的 _module-map.yaml 路径
+ */
+function findModuleMapPath(cwd) {
+  // 查找 .sillyspec/docs/<project>/modules/_module-map.yaml
+  const docsDir = join(cwd, '.sillyspec', 'docs');
+  if (!existsSync(docsDir)) return null;
+
+  const projects = readdirSync(docsDir, { withFileTypes: true })
+    .filter(e => e.isDirectory());
+
+  for (const proj of projects) {
+    const mapPath = join(docsDir, proj.name, 'modules', '_module-map.yaml');
+    if (existsSync(mapPath)) return mapPath;
+  }
+
+  // 如果没有找到已有的，返回第一个项目的路径（用于创建）
+  if (projects.length > 0) {
+    return join(docsDir, projects[0].name, 'modules', '_module-map.yaml');
+  }
+
+  return null;
+}
+
+/**
+ * 从模块卡片文件名提取 module_id
+ */
+function parseModuleIdFromFilename(filename) {
+  return filename.replace(/\.md$/, '');
+}
+
+/**
+ * 从模块卡片读取 frontmatter 中的 module_id
+ */
+function parseModuleCardFrontmatter(content) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return {};
+  const fm = fmMatch[1];
+  const moduleIdMatch = fm.match(/^module_id:\s*(.+)$/m);
+  return {
+    module_id: moduleIdMatch ? moduleIdMatch[1].trim() : null
+  };
+}
+
+/**
+ * rebuild: 从模块卡片 + 源码重建 _module-map.yaml
+ */
+export async function rebuildModuleMap(cwd) {
+  const mapPath = findModuleMapPath(cwd);
+  if (!mapPath) {
+    console.error('❌ 未找到 .sillyspec/docs/<project>/modules/ 目录');
+    console.log('   提示：先运行 sillyspec run scan 生成模块文档');
+    return;
+  }
+
+  const modulesDir = join(mapPath, '..');
+  const existingMap = existsSync(mapPath) ? readFileSync(mapPath, 'utf8') : null;
+
+  // 收集现有模块卡片
+  const cards = [];
+  if (existsSync(modulesDir)) {
+    const files = readdirSync(modulesDir).filter(f => f.endsWith('.md') && f !== '_module-map.yaml');
+    for (const f of files) {
+      const content = readFileSync(join(modulesDir, f), 'utf8');
+      const fm = parseModuleCardFrontmatter(content);
+      const moduleId = fm.module_id || parseModuleIdFromFilename(f);
+      cards.push({ filename: f, moduleId });
+    }
+  }
+
+  // 解析现有 _module-map.yaml 保留已有字段
+  let existingModules = {};
+  if (existingMap) {
+    // 简单解析：提取 modules: 下的条目
+    const lines = existingMap.split('\n');
+    let currentModule = null;
+    let inModules = false;
+    for (const line of lines) {
+      if (line.startsWith('modules:')) { inModules = true; continue; }
+      if (!inModules) continue;
+      if (line.startsWith('  ') === false && line.trim() !== '') break;
+      const moduleMatch = line.match(/^  ([a-zA-Z0-9_-]+):/);
+      if (moduleMatch) {
+        currentModule = moduleMatch[1];
+        existingModules[currentModule] = existingModules[currentModule] || { paths: [] };
+      }
+    }
+  }
+
+  // 如果没有模块卡片也没有已有映射
+  if (cards.length === 0 && Object.keys(existingModules).length === 0) {
+    console.log('📭 没有模块卡片，也没有已有的模块映射');
+    console.log('   提示：先运行 sillyspec run scan 生成模块文档');
+    return;
+  }
+
+  // 生成新的 _module-map.yaml
+  // 保留已有的完整字段，补齐新卡片
+  const now = new Date().toISOString().replace('T', ' ').slice(0, 19);
+  let headCommit = '';
+  try {
+    const { execSync } = await import('child_process');
+    headCommit = execSync('git rev-parse --short HEAD', { cwd, encoding: 'utf8', timeout: 5000 }).trim();
+  } catch { /* ignore */ }
+
+  let yaml = `schema_version: 1\n`;
+  yaml += `generated_at: ${now}\n`;
+  yaml += `generator: sillyspec-modules-rebuild\n`;
+  if (headCommit) yaml += `source_commit: ${headCommit}\n`;
+  yaml += `\nmodules:\n`;
+
+  // 合并：已有映射 + 新卡片
+  const allModuleIds = new Set([
+    ...Object.keys(existingModules),
+    ...cards.map(c => c.moduleId)
+  ]);
+
+  for (const moduleId of allModuleIds) {
+    const card = cards.find(c => c.moduleId === moduleId);
+    yaml += `  ${moduleId}:\n`;
+    yaml += `    status: active\n`;
+    if (card) yaml += `    doc: modules/${card.filename}\n`;
+    else yaml += `    doc: modules/${moduleId}.md\n`;
+    // 保留已有 _module-map.yaml 中的 paths 等字段（如果有的话）
+    yaml += `    needs_review: false\n`;
+    yaml += `    review_reasons: []\n`;
+    yaml += `\n`;
+  }
+
+  writeFileSync(mapPath, yaml, 'utf8');
+  console.log(`✅ _module-map.yaml 已重建：${mapPath}`);
+  console.log(`   模块数量：${allModuleIds.size}`);
+  for (const id of allModuleIds) {
+    console.log(`   - ${id}`);
+  }
+  console.log(`\n⚠️  注意：rebuild 只重建骨架。tags/entrypoints/main_symbols/depends_on/used_by 需要重新运行 scan 或手动补充。`);
+}
+
+/**
+ * status: 显示模块索引状态
+ */
+export async function showModuleStatus(cwd) {
+  const mapPath = findModuleMapPath(cwd);
+  if (!mapPath || !existsSync(mapPath)) {
+    console.log('📭 未找到 _module-map.yaml');
+    console.log('   提示：先运行 sillyspec run scan 生成模块文档');
+    return;
+  }
+
+  const content = readFileSync(mapPath, 'utf8');
+
+  // 简单解析
+  const lines = content.split('\n');
+  const modules = [];
+  let currentModule = null;
+  let needsReview = false;
+
+  for (const line of lines) {
+    const moduleMatch = line.match(/^  ([a-zA-Z0-9_-]+):$/);
+    if (moduleMatch) {
+      if (currentModule) modules.push(currentModule);
+      currentModule = { id: moduleMatch[1], hasTags: false, hasEntryPoints: false, hasDepends: false, needsReview: false };
+    }
+    if (currentModule) {
+      if (line.includes('tags:')) currentModule.hasTags = true;
+      if (line.includes('entrypoints:')) currentModule.hasEntryPoints = true;
+      if (line.includes('depends_on:')) currentModule.hasDepends = true;
+      if (line.includes('needs_review: true')) { currentModule.needsReview = true; needsReview = true; }
+    }
+  }
+  if (currentModule) modules.push(currentModule);
+
+  console.log(`\n_module-map.yaml: ${mapPath}`);
+  console.log(`模块数量：${modules.length}\n`);
+
+  const maxId = Math.max(5, ...modules.map(m => m.id.length));
+  console.log(`  ${'模块'.padEnd(maxId)}  tags  entry  deps  review`);
+  console.log(`  ${'─'.repeat(maxId)}  ────  ─────  ────  ──────`);
+  for (const m of modules) {
+    const tags = m.hasTags ? '✅' : '⬜';
+    const entry = m.hasEntryPoints ? '✅' : '⬜';
+    const deps = m.hasDepends ? '✅' : '⬜';
+    const review = m.needsReview ? '⚠️' : '✅';
+    console.log(`  ${m.id.padEnd(maxId)}  ${tags}     ${entry}     ${deps}     ${review}`);
+  }
+
+  if (needsReview) {
+    console.log(`\n⚠️  有模块标记为 needs_review，建议检查或重新 scan`);
+  }
+}
+
+/**
+ * 从 _module-map.yaml 聚合生成 dependencies.md
+ */
+export async function generateDependenciesMd(cwd) {
+  const mapPath = findModuleMapPath(cwd);
+  if (!mapPath || !existsSync(mapPath)) return;
+
+  const content = readFileSync(mapPath, 'utf8');
+  const modules = parseModuleMapSimple(content);
+
+  if (Object.keys(modules).length === 0) return;
+
+  const depsPath = join(mapPath, '..', 'dependencies.md');
+  const maxName = Math.max(6, ...Object.keys(modules).map(k => k.length));
+
+  let md = `# Module Dependencies\n\n`;
+  md += `> 自动生成，由 sillyspec 维护\n\n`;
+  md += `| ${'Module'.padEnd(maxName)} | Depends On | Used By |\n`;
+  md += `| ${''.padEnd(maxName, '-')}:--- | :--- | :--- |\n`;
+
+  for (const [id, data] of Object.entries(modules)) {
+    const depends = (data.depends_on || []).join(', ') || '—';
+    const usedBy = (data.used_by || []).join(', ') || '—';
+    md += `| ${id.padEnd(maxName)} | ${depends} | ${usedBy} |\n`;
+  }
+
+  writeFileSync(depsPath, md, 'utf8');
+  console.log(`✅ dependencies.md 已生成`);
+}
+
+function parseModuleMapSimple(content) {
+  const modules = {};
+  let currentModule = null;
+  let currentKey = null;
+  let currentArray = null;
+
+  for (const line of content.split('\n')) {
+    const moduleMatch = line.match(/^  ([a-zA-Z0-9_-]+):$/);
+    if (moduleMatch) {
+      if (currentArray && currentModule && currentKey) {
+        modules[currentModule][currentKey] = currentArray;
+      }
+      currentModule = moduleMatch[1];
+      modules[currentModule] = {};
+      currentKey = null;
+      currentArray = null;
+      continue;
+    }
+    if (!currentModule) continue;
+
+    // Array field like depends_on:\n  - xxx
+    const arrayFieldMatch = line.match(/^    (depends_on|used_by|paths|tags|aliases|entrypoints|main_symbols|review_reasons):$/);
+    if (arrayFieldMatch) {
+      if (currentArray && currentKey) modules[currentModule][currentKey] = currentArray;
+      currentKey = arrayFieldMatch[1];
+      currentArray = [];
+      continue;
+    }
+
+    // Inline array like tags: [a, b]
+    const inlineArrayMatch = line.match(/^    (depends_on|used_by|paths|tags|aliases|entrypoints|main_symbols|review_reasons): \[(.*)\]$/);
+    if (inlineArrayMatch) {
+      if (currentArray && currentKey) modules[currentModule][currentKey] = currentArray;
+      const vals = inlineArrayMatch[2].split(',').map(v => v.trim()).filter(Boolean);
+      modules[currentModule][inlineArrayMatch[1]] = vals;
+      currentKey = null;
+      currentArray = null;
+      continue;
+    }
+
+    // Scalar field
+    const scalarMatch = line.match(/^    (status|doc|needs_review): (.+)$/);
+    if (scalarMatch) {
+      if (currentArray && currentKey) { modules[currentModule][currentKey] = currentArray; currentArray = null; currentKey = null; }
+      modules[currentModule][scalarMatch[1]] = scalarMatch[2];
+      continue;
+    }
+
+    // Array item
+    const itemMatch = line.match(/^      - (.+)$/);
+    if (itemMatch && currentArray !== null) {
+      currentArray.push(itemMatch[1].trim());
+      continue;
+    }
+  }
+
+  // Flush last
+  if (currentArray && currentModule && currentKey) {
+    modules[currentModule][currentKey] = currentArray;
+  }
+
+  return modules;
+}
+
+/**
+ * migrate: 旧格式模块文档迁移到新格式
+ */
+export async function migrateModuleDocs(cwd) {
+  const mapPath = findModuleMapPath(cwd);
+  if (!mapPath || !existsSync(mapPath)) {
+    console.error('❌ 未找到 _module-map.yaml');
+    return;
+  }
+
+  const modulesDir = join(mapPath, '..');
+  const files = readdirSync(modulesDir).filter(f => f.endsWith('.md') && f !== '_module-map.yaml');
+
+  if (files.length === 0) {
+    console.log('📭 没有模块文档需要迁移');
+    return;
+  }
+
+  let migrated = 0;
+  let skipped = 0;
+
+  for (const f of files) {
+    const filePath = join(modulesDir, f);
+    const content = readFileSync(filePath, 'utf8');
+
+    // 检查是否已经是新格式（有 schema_version + doc_type: module-card）
+    if (content.includes('schema_version:') && content.includes('doc_type: module-card')) {
+      skipped++;
+      continue;
+    }
+
+    // 提取模块名（从 H1 或文件名）
+    const h1Match = content.match(/^# (.+)$/m);
+    const moduleId = h1Match ? h1Match[1].trim().replace(/\s+/g, '-').toLowerCase() : f.replace('.md', '');
+
+    // 提取旧的“职责”和“注意事项”作为语义内容保留
+    const dutyMatch = content.match(/## 职责\n([\s\S]*?)(?=\n##|$)/);
+    const notesMatch = content.match(/## 注意事项\n([\s\S]*?)(?=\n##|$)/);
+    const designMatch = content.match(/## 当前设计\n([\s\S]*?)(?=\n##|$)/);
+    const interfaceMatch = content.match(/## 对外接口[\s\S]*?(?=\n##|$)/);
+
+    const duty = dutyMatch ? dutyMatch[1].trim() : '';
+    const notes = notesMatch ? notesMatch[1].trim() : '';
+    const design = designMatch ? designMatch[1].trim() : '';
+
+    // 检查是否有人工备注
+    const manualMatch = content.match(/<!-- MANUAL_NOTES_START -->([\s\S]*?)<!-- MANUAL_NOTES_END -->/);
+    const manualContent = manualMatch ? manualMatch[1].trim() : '';
+
+    // 生成新格式
+    let newContent = `---
+schema_version: 1
+doc_type: module-card
+module_id: ${moduleId}
+---
+
+# ${moduleId}
+
+`;
+
+    if (duty) {
+      newContent += `## 定位
+
+${duty}
+
+`;
+    } else {
+      newContent += `## 定位
+
+（待补充）
+
+`;
+    }
+
+    if (design || interfaceMatch) {
+      newContent += `## 契约摘要
+
+`;
+      if (interfaceMatch) newContent += `${interfaceMatch[0].replace('## 对外接口', '').trim()}
+
+`;
+      else newContent += `（待从源码提取）
+
+`;
+    } else {
+      newContent += `## 契约摘要
+
+（待从源码提取）
+
+`;
+    }
+
+    if (design) {
+      newContent += `## 关键逻辑
+
+${design}
+
+`;
+    } else {
+      newContent += `## 关键逻辑
+
+（待补充）
+
+`;
+    }
+
+    if (notes) {
+      newContent += `## 注意事项
+
+${notes}
+
+`;
+    } else {
+      newContent += `## 注意事项
+
+（待补充）
+
+`;
+    }
+
+    newContent += `## 人工备注
+
+<!-- MANUAL_NOTES_START -->
+${manualContent}
+<!-- MANUAL_NOTES_END -->
+`;
+
+    writeFileSync(filePath, newContent, 'utf8');
+    migrated++;
+  }
+
+  console.log(`✅ 迁移完成`);
+  console.log(`   已迁移：${migrated} 个`);
+  console.log(`   已跳过（新格式）：${skipped} 个`);
+  if (migrated > 0) {
+    console.log(`\n⚠️  迁移后的卡片可能需要补充内容，建议检查并运行 sillyspec modules status`);
+  }
+}

package/src/progress.js

@@ -393,6 +393,57 @@ export class ProgressManager {
     });
   }
 
+  /**
+   * 重命名变更：同步更新 DB + 目录
+   * @param {string} cwd - 项目根目录
+   * @param {string} oldName - 旧变更名
+   * @param {string} newName - 新变更名
+   */
+  async renameChange(cwd, oldName, newName) {
+    if (!oldName || !newName) {
+      console.warn('⚠️  renameChange: 旧名或新名为空，跳过');
+      return;
+    }
+    if (oldName === newName) {
+      console.warn('⚠️  renameChange: 新旧名称相同，跳过');
+      return;
+    }
+    const db = await this._ensureDB(cwd);
+    // 检查旧名是否存在
+    const existing = db.transaction((sqlDb) => {
+      const row = sqlDb.exec(`SELECT name, status FROM changes WHERE name = ?`, [oldName]);
+      if (!row || !row[0] || row[0].values.length === 0) return null;
+      return { name: row[0].values[0][0], status: row[0].values[0][1] };
+    });
+    if (!existing) {
+      console.error(`❌ 变更 ${oldName} 不存在`);
+      return;
+    }
+    // 检查新名是否已存在
+    const conflict = db.transaction((sqlDb) => {
+      const row = sqlDb.exec(`SELECT name FROM changes WHERE name = ?`, [newName]);
+      return row && row[0] && row[0].values.length > 0;
+    });
+    if (conflict) {
+      console.error(`❌ 变更 ${newName} 已存在`);
+      return;
+    }
+    // 重命名目录
+    const oldDir = this._changePath(cwd, oldName);
+    const newDir = this._changePath(cwd, newName);
+    if (existsSync(oldDir)) {
+      renameSync(oldDir, newDir);
+    } else {
+      mkdirSync(newDir, { recursive: true });
+    }
+    // 更新 DB
+    const now = new Date().toISOString();
+    db.transaction((sqlDb) => {
+      sqlDb.run(`UPDATE changes SET name = ?, last_active = ? WHERE name = ?`, [newName, now, oldName]);
+    });
+    console.log(`✅ 变更已重命名：${oldName} → ${newName}`);
+  }
+
   /**
    * 从活跃列表移除变更（归档时调用，不物理删除）
    * SQL: UPDATE changes SET status = 'archived'