@gong-ym/ai-spec-auto 0.2.3

package/bin/repair-command.js

@@ -0,0 +1,161 @@
+const fs = require('fs');
+const path = require('path');
+const { RunService } = require('../src/run/run-service');
+const { RunStore, writeJson } = require('../src/run/run-store');
+
+const MAX_REPAIR_ATTEMPTS = 2;
+
+function parseArgs(argv) {
+  const options = { runId: '', target: '.', dryRun: false };
+  const positional = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--dry-run') {
+      options.dryRun = true;
+    } else if (!arg.startsWith('-')) {
+      positional.push(arg);
+    }
+  }
+  options.runId = positional[0] || '';
+  options.target = positional[1] || '.';
+  return options;
+}
+
+function printUsage() {
+  console.log(`ai-spec-auto repair <runId> [目录] [--dry-run]
+
+说明：
+  对指定 run 执行修复流程。最大修复次数为 ${MAX_REPAIR_ATTEMPTS} 次。
+  超过次数必须中断并记录原因。修复记录进入 Evidence。`);
+}
+
+function loadHookConfig(rootDir) {
+  const configPath = path.join(rootDir, '.harness', 'hooks.config.json');
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (_e) {
+    return null;
+  }
+}
+
+function getRepairAttemptCount(rootDir, runId) {
+  const runsDir = new RunStore().getRunsDir(rootDir);
+  const runDir = path.join(runsDir, runId);
+  const repairPath = path.join(runDir, 'repair-history.json');
+  if (!fs.existsSync(repairPath)) return 0;
+  try {
+    const history = JSON.parse(fs.readFileSync(repairPath, 'utf8'));
+    return (history.repairs || []).length;
+  } catch (_e) {
+    return 0;
+  }
+}
+
+function appendRepairRecord(rootDir, runId, record) {
+  const runsDir = new RunStore().getRunsDir(rootDir);
+  const runDir = path.join(runsDir, runId);
+  if (!fs.existsSync(runDir)) {
+    fs.mkdirSync(runDir, { recursive: true });
+  }
+  const repairPath = path.join(runDir, 'repair-history.json');
+  let history = { repairs: [] };
+  if (fs.existsSync(repairPath)) {
+    try {
+      history = JSON.parse(fs.readFileSync(repairPath, 'utf8'));
+    } catch (_e) {
+      history = { repairs: [] };
+    }
+  }
+  history.repairs.push(record);
+  writeJson(repairPath, history);
+  return history;
+}
+
+async function main(argv) {
+  const options = parseArgs(argv);
+  if (options.help || !options.runId) {
+    printUsage();
+    return options.help ? 0 : 1;
+  }
+
+  const rootDir = path.resolve(process.cwd(), options.target);
+
+  // 检查 run 是否存在
+  let run;
+  try {
+    run = new RunService().loadRun(rootDir, options.runId);
+  } catch (e) {
+    console.log(`错误：未找到 run ${options.runId}`);
+    return 1;
+  }
+
+  // 加载 hook 配置
+  const hookConfig = loadHookConfig(rootDir);
+  const maxAttempts = hookConfig?.maxRepairAttempts || MAX_REPAIR_ATTEMPTS;
+
+  // 检查修复次数
+  const attemptCount = getRepairAttemptCount(rootDir, options.runId);
+  if (attemptCount >= maxAttempts) {
+    console.log(`修复次数已达上限（${attemptCount}/${maxAttempts}），无法继续修复。`);
+    console.log('必须中断并记录原因。');
+    appendRepairRecord(rootDir, options.runId, {
+      attemptNumber: attemptCount + 1,
+      status: 'blocked',
+      reason: `超过最大修复次数 ${maxAttempts}`,
+      timestamp: new Date().toISOString(),
+    });
+    return 1;
+  }
+
+  const attemptNumber = attemptCount + 1;
+  console.log(`执行修复 #${attemptNumber}（最大次数：${maxAttempts}）`);
+
+  if (options.dryRun) {
+    console.log('dry-run 模式，不执行真实修复。');
+    appendRepairRecord(rootDir, options.runId, {
+      attemptNumber,
+      status: 'dry-run',
+      reason: 'dry-run 不执行真实修复',
+      timestamp: new Date().toISOString(),
+    });
+    return 0;
+  }
+
+  // 执行修复 hook
+  const repairHook = hookConfig?.hooks?.find((h) => h.hookType === 'repair-hook');
+  if (repairHook && repairHook.enabled) {
+    console.log(`执行 repair-hook：${repairHook.command}`);
+    // 实际执行留给 AI Agent，这里只记录
+  }
+
+  // 记录修复结果
+  const record = {
+    attemptNumber,
+    status: 'completed',
+    reason: '修复流程执行完成',
+    timestamp: new Date().toISOString(),
+    hookResults: repairHook ? [{ hookId: repairHook.hookId, status: 'executed' }] : [],
+  };
+  appendRepairRecord(rootDir, options.runId, record);
+
+  // 更新 run 事件
+  new RunService().appendEvent(rootDir, options.runId, 'repair_completed', `修复 #${attemptNumber} 完成`, {
+    attemptNumber,
+    maxAttempts,
+  });
+
+  console.log(`修复 #${attemptNumber} 完成。`);
+  if (attemptNumber >= maxAttempts) {
+    console.log(`警告：已达到最大修复次数（${maxAttempts}），后续失败将无法自动修复。`);
+  }
+  return 0;
+}
+
+module.exports = {
+  main,
+  parseArgs,
+  MAX_REPAIR_ATTEMPTS,
+};

package/bin/repo-map.js

@@ -0,0 +1,177 @@
+const fs = require('fs');
+const path = require('path');
+const { resolveRuntimePaths } = require('./runtime-paths');
+
+function readJsonIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function loadPackageManifest(targetDir) {
+  return readJsonIfExists(path.join(targetDir, 'package.json'));
+}
+
+function hasDependency(pkg, names) {
+  if (!pkg) {
+    return false;
+  }
+
+  const deps = {
+    ...(pkg.dependencies || {}),
+    ...(pkg.devDependencies || {}),
+    ...(pkg.peerDependencies || {}),
+  };
+
+  return names.some((name) => Object.prototype.hasOwnProperty.call(deps, name));
+}
+
+function detectProjectProfile(targetDir) {
+  const manifestPath = path.join(targetDir, '.ai-spec', 'manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+      if (typeof manifest?.profile === 'string' && manifest.profile.trim()) {
+        return manifest.profile.trim();
+      }
+    } catch (error) {
+      // Ignore malformed local manifest and fall back to package facts.
+    }
+  }
+
+  const pkg = loadPackageManifest(targetDir);
+  if (hasDependency(pkg, ['vue', 'vue-router', 'pinia'])) {
+    return 'vue';
+  }
+  if (hasDependency(pkg, ['react', 'react-dom', 'react-router-dom'])) {
+    return 'react';
+  }
+  return 'default';
+}
+
+function detectProjectLanguage(targetDir, pkg) {
+  if (hasDependency(pkg, ['typescript']) || fs.existsSync(path.join(targetDir, 'tsconfig.json'))) {
+    return 'TypeScript';
+  }
+  return 'JavaScript';
+}
+
+function detectBuildTool(pkg) {
+  if (hasDependency(pkg, ['vite'])) {
+    return 'Vite';
+  }
+  if (hasDependency(pkg, ['next'])) {
+    return 'Next.js';
+  }
+  if (hasDependency(pkg, ['nuxt'])) {
+    return 'Nuxt';
+  }
+  if (hasDependency(pkg, ['webpack'])) {
+    return 'Webpack';
+  }
+  return 'unknown';
+}
+
+function detectPackageManager(targetDir) {
+  if (fs.existsSync(path.join(targetDir, 'pnpm-lock.yaml'))) {
+    return 'pnpm';
+  }
+  if (fs.existsSync(path.join(targetDir, 'yarn.lock'))) {
+    return 'yarn';
+  }
+  if (fs.existsSync(path.join(targetDir, 'package-lock.json'))) {
+    return 'npm';
+  }
+  return 'unknown';
+}
+
+function findExistingRelPath(targetDir, candidates) {
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(targetDir, candidate))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function collectRepoConventions(targetDir, projectProfile = detectProjectProfile(targetDir)) {
+  return {
+    project_profile: projectProfile,
+    projectContextPath: findExistingRelPath(targetDir, ['context/PROJECT.md']),
+    appEntry: findExistingRelPath(targetDir, ['src/App.vue', 'src/App.tsx', 'src/App.jsx']),
+    mainEntry: findExistingRelPath(targetDir, ['src/main.ts', 'src/main.js', 'src/main.tsx', 'src/main.jsx']),
+    viewsDir: findExistingRelPath(targetDir, ['src/views']),
+    routeEntry: findExistingRelPath(targetDir, ['src/router/index.ts', 'src/router/index.js']),
+    routeModulesDir: findExistingRelPath(targetDir, ['src/router/modules']),
+    apiDir: findExistingRelPath(targetDir, ['src/api']),
+    apiTypesDir: findExistingRelPath(targetDir, ['src/api/types']),
+    requestConfig: findExistingRelPath(targetDir, [
+      'src/config/requestConfig.ts',
+      'src/config/requestConfig.js',
+      'src/lib/request.ts',
+      'src/libs/request.ts',
+      'src/utils/request.ts',
+    ]),
+    mockDir: findExistingRelPath(targetDir, ['src/mock', 'src/mocks']),
+    storeModulesDir: findExistingRelPath(targetDir, ['src/store/modules', 'src/stores/modules', 'src/store']),
+    styleEntry: findExistingRelPath(targetDir, ['src/styles', 'src/style.css', 'src/style.scss', 'src/styles/variables.scss']),
+  };
+}
+
+function buildRepoMap(targetDir) {
+  const pkg = loadPackageManifest(targetDir);
+  const projectProfile = detectProjectProfile(targetDir);
+  const repoConventions = collectRepoConventions(targetDir, projectProfile);
+
+  return {
+    schema_version: 1,
+    kind: 'repo-map',
+    generated_at: new Date().toISOString(),
+    framework: projectProfile === 'default' ? 'unknown' : projectProfile,
+    language: detectProjectLanguage(targetDir, pkg),
+    build_tool: detectBuildTool(pkg),
+    package_manager: detectPackageManager(targetDir),
+    paths: {
+      project_context: repoConventions.projectContextPath || null,
+      app_entry: repoConventions.appEntry || null,
+      main_entry: repoConventions.mainEntry || null,
+      views_dir: repoConventions.viewsDir || null,
+      route_entry: repoConventions.routeEntry || null,
+      route_modules_dir: repoConventions.routeModulesDir || null,
+      api_dir: repoConventions.apiDir || null,
+      api_types_dir: repoConventions.apiTypesDir || null,
+      request_config: repoConventions.requestConfig || null,
+      mock_dir: repoConventions.mockDir || null,
+      store_modules_dir: repoConventions.storeModulesDir || null,
+      style_entry: repoConventions.styleEntry || null,
+    },
+  };
+}
+
+function syncRepoMap(targetDir) {
+  const resolvedTarget = path.resolve(targetDir);
+  const runtimePaths = resolveRuntimePaths(resolvedTarget);
+  const repoMap = buildRepoMap(resolvedTarget);
+
+  fs.mkdirSync(path.dirname(runtimePaths.repoMap.path), { recursive: true });
+  fs.writeFileSync(runtimePaths.repoMap.path, `${JSON.stringify(repoMap, null, 2)}\n`, 'utf8');
+
+  return {
+    path: runtimePaths.repoMap.path,
+    repo_map: repoMap,
+  };
+}
+
+module.exports = {
+  loadPackageManifest,
+  detectProjectProfile,
+  detectProjectLanguage,
+  detectBuildTool,
+  detectPackageManager,
+  findExistingRelPath,
+  collectRepoConventions,
+  buildRepoMap,
+  syncRepoMap,
+};

package/bin/report-command.js

@@ -0,0 +1,236 @@
+const fs = require('fs');
+const path = require('path');
+const { RunService } = require('../src/run/run-service');
+const { RunStore, writeJson } = require('../src/run/run-store');
+
+function parseArgs(argv) {
+  const options = { runId: '', target: '.', format: 'json' };
+  const positional = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--format') {
+      const value = argv[index + 1];
+      if (!value || value.startsWith('-')) throw new Error('缺少 --format 参数值');
+      options.format = value;
+      index += 1;
+    } else if (!arg.startsWith('-')) {
+      positional.push(arg);
+    }
+  }
+  options.runId = positional[0] || '';
+  options.target = positional[1] || '.';
+  return options;
+}
+
+function printUsage() {
+  console.log(`ai-spec-auto report <runId> [目录] [--format json|md]
+
+说明：
+  生成 Evidence Report，包含 run 的完整执行记录。`);
+}
+
+function loadRunEvents(rootDir, runId) {
+  const runsDir = new RunStore().getRunsDir(rootDir);
+  const eventsPath = path.join(runsDir, runId, 'events.ndjson');
+  if (!fs.existsSync(eventsPath)) return [];
+  try {
+    return fs.readFileSync(eventsPath, 'utf8')
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => {
+        try { return JSON.parse(line); } catch (_e) { return null; }
+      })
+      .filter(Boolean);
+  } catch (_e) {
+    return [];
+  }
+}
+
+function loadRepairHistory(rootDir, runId) {
+  const runsDir = new RunStore().getRunsDir(rootDir);
+  const repairPath = path.join(runsDir, runId, 'repair-history.json');
+  if (!fs.existsSync(repairPath)) return { repairs: [] };
+  try {
+    return JSON.parse(fs.readFileSync(repairPath, 'utf8'));
+  } catch (_e) {
+    return { repairs: [] };
+  }
+}
+
+function buildEvidenceReport(rootDir, run) {
+  const now = new Date().toISOString();
+  const configPath = path.join(rootDir, '.ai-spec', 'config.json');
+  let projectId = '';
+  if (fs.existsSync(configPath)) {
+    try {
+      projectId = JSON.parse(fs.readFileSync(configPath, 'utf8')).projectId || '';
+    } catch (_e) { /* ignore */ }
+  }
+
+  const events = loadRunEvents(rootDir, run.runId);
+  const repairHistory = loadRepairHistory(rootDir, run.runId);
+
+  // 从 run 的 executor 中获取变更文件
+  const changedFiles = run.executor?.lastResult?.changedFiles || [];
+
+  // 从 events 中提取 hook 和 test 结果
+  const hookResults = events
+    .filter((e) => e.type && e.type.includes('hook'))
+    .map((e) => ({ hookId: e.type, status: e.detail?.status || 'unknown', message: e.message }));
+
+  const testResults = events
+    .filter((e) => e.type && e.type.includes('test'))
+    .map((e) => ({ testId: e.type, status: e.detail?.status || 'unknown', message: e.message }));
+
+  const finalStatus = run.state === 'completed' ? '通过'
+    : run.state === 'suspended' ? '阻塞'
+    : run.incidents?.length > 0 ? '失败'
+    : '待执行';
+
+  return {
+    runId: run.runId,
+    projectId,
+    taskId: run.runId,
+    specId: run.runId,
+    requirement: run.requirement?.summary || '',
+    state: run.state,
+    changedFiles,
+    testResults,
+    hookResults,
+    repairResults: repairHistory.repairs || [],
+    reviewResults: [],
+    finalStatus,
+    events: events.map((e) => ({
+      type: e.type,
+      message: e.message,
+      createdAt: e.createdAt,
+    })),
+    incidents: run.incidents || [],
+    generatedAt: now,
+  };
+}
+
+function buildMarkdownReport(report) {
+  const lines = [
+    '# Evidence Report',
+    '',
+    `| 字段 | 值 |`,
+    `|------|-----|`,
+    `| runId | ${report.runId} |`,
+    `| projectId | ${report.projectId} |`,
+    `| specId | ${report.specId} |`,
+    `| 需求 | ${report.requirement} |`,
+    `| 状态 | ${report.state} |`,
+    `| 最终结论 | ${report.finalStatus} |`,
+    `| 生成时间 | ${report.generatedAt} |`,
+    '',
+    `## 变更文件`,
+    '',
+  ];
+
+  if (report.changedFiles.length === 0) {
+    lines.push('（无变更文件）');
+  } else {
+    for (const f of report.changedFiles) {
+      lines.push(`- ${f}`);
+    }
+  }
+
+  lines.push('');
+  lines.push('## Hook 结果');
+  lines.push('');
+  if (report.hookResults.length === 0) {
+    lines.push('（无 Hook 结果）');
+  } else {
+    lines.push('| Hook | 状态 | 消息 |');
+    lines.push('|------|------|------|');
+    for (const h of report.hookResults) {
+      lines.push(`| ${h.hookId} | ${h.status} | ${h.message || '-'} |`);
+    }
+  }
+
+  lines.push('');
+  lines.push('## 测试结果');
+  lines.push('');
+  if (report.testResults.length === 0) {
+    lines.push('（无测试结果）');
+  } else {
+    lines.push('| 测试 | 状态 | 消息 |');
+    lines.push('|------|------|------|');
+    for (const t of report.testResults) {
+      lines.push(`| ${t.testId} | ${t.status} | ${t.message || '-'} |`);
+    }
+  }
+
+  lines.push('');
+  lines.push('## 修复记录');
+  lines.push('');
+  if (report.repairResults.length === 0) {
+    lines.push('（无修复记录）');
+  } else {
+    for (const r of report.repairResults) {
+      lines.push(`- 修复 #${r.attemptNumber}：${r.status}（${r.reason || '-'}）`);
+    }
+  }
+
+  lines.push('');
+  lines.push('## 事件时间线');
+  lines.push('');
+  for (const e of report.events) {
+    lines.push(`- [${e.createdAt || '-'}] ${e.type}：${e.message}`);
+  }
+
+  return lines.join('\n');
+}
+
+async function main(argv) {
+  const options = parseArgs(argv);
+  if (options.help || !options.runId) {
+    printUsage();
+    return options.help ? 0 : 1;
+  }
+
+  const rootDir = path.resolve(process.cwd(), options.target);
+
+  let run;
+  try {
+    run = new RunService().loadRun(rootDir, options.runId);
+  } catch (e) {
+    console.log(`错误：未找到 run ${options.runId}`);
+    return 1;
+  }
+
+  const report = buildEvidenceReport(rootDir, run);
+
+  // 保存到 reports/ai-spec/{runId}/
+  const reportDir = path.join(rootDir, 'reports', 'ai-spec', run.runId);
+  if (!fs.existsSync(reportDir)) {
+    fs.mkdirSync(reportDir, { recursive: true });
+  }
+
+  // JSON 格式
+  const jsonPath = path.join(reportDir, 'evidence-report.json');
+  writeJson(jsonPath, report);
+
+  // Markdown 格式
+  const mdPath = path.join(reportDir, 'summary.md');
+  fs.writeFileSync(mdPath, buildMarkdownReport(report), 'utf8');
+
+  console.log('Evidence Report 已生成：');
+  console.log(`- JSON：${jsonPath}`);
+  console.log(`- Markdown：${mdPath}`);
+  console.log(`- 最终状态：${report.finalStatus}`);
+  console.log(`- 变更文件：${report.changedFiles.length} 个`);
+  console.log(`- Hook 结果：${report.hookResults.length} 个`);
+  console.log(`- 测试结果：${report.testResults.length} 个`);
+  console.log(`- 修复记录：${report.repairResults.length} 次`);
+  return 0;
+}
+
+module.exports = {
+  main,
+  parseArgs,
+  buildEvidenceReport,
+};