ai-unit-test-generator 1.3.0

package/lib/ai/client.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+/**
+ * 使用 cursor-agent 生成 AI 回复
+ * - 从文件或 stdin 读取 prompt
+ * - 通过 cursor-agent chat 调用模型
+ * - 将回复写入到输出文件
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs'
+import { dirname } from 'path'
+import { spawn } from 'child_process'
+
+function parseArgs(argv) {
+  const args = {}
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i]
+    if (a.startsWith('--')) {
+      const [k, v] = a.includes('=') ? a.split('=') : [a, argv[i + 1]]
+      args[k.replace(/^--/, '')] = v === undefined || v.startsWith('--') ? true : v
+      if (v !== undefined && !v.startsWith('--') && !a.includes('=')) i++
+    }
+  }
+  return args
+}
+
+export async function runOnce({ prompt, promptFile, out = 'reports/ai_response.txt', model, timeoutSec = 600 }) {
+  if (!prompt) {
+    if (!promptFile || !existsSync(promptFile)) throw new Error(`Prompt file not found: ${promptFile}`)
+    prompt = readFileSync(promptFile, 'utf8')
+  }
+
+  return new Promise((resolve, reject) => {
+    const args = ['chat']
+    if (model) args.push('-m', model)
+
+    const child = spawn('cursor-agent', args, { stdio: ['pipe', 'pipe', 'inherit'] })
+
+    const chunks = []
+    child.stdout.on('data', d => chunks.push(Buffer.from(d)))
+
+    // 写入 prompt 到 stdin
+    child.stdin.write(prompt)
+    child.stdin.end()
+
+    const to = setTimeout(() => {
+      child.kill('SIGKILL')
+      reject(new Error(`cursor-agent timeout after ${timeoutSec}s`))
+    }, Number(timeoutSec) * 1000)
+
+    child.on('close', code => {
+      clearTimeout(to)
+      const outText = Buffer.concat(chunks).toString('utf8')
+      try { mkdirSync(dirname(out), { recursive: true }); writeFileSync(out, outText) } catch {}
+      if (code !== 0) return reject(new Error(`cursor-agent exited with code ${code}`))
+      resolve({ out, bytes: outText.length })
+    })
+    child.on('error', reject)
+  })
+}
+
+export async function runCLI(argv = process.argv) {
+  const args = parseArgs(argv)
+  const promptFile = args['prompt'] || args['prompt-file'] || null
+  const out = args['out'] || 'reports/ai_response.txt'
+  const model = args['model'] || null
+  const timeoutSec = args['timeout'] ? Number(args['timeout']) : 600
+
+  try {
+    await runOnce({ promptFile, out, model, timeoutSec })
+    console.log(`✅ AI response saved: ${out}`)
+  } catch (err) {
+    console.error(`❌ AI generate failed: ${err.message}`)
+    process.exit(1)
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) runCLI()
+
+

package/lib/ai/extractor.mjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * 从 AI 回复中提取测试文件并自动创建
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+
+/**
+ * 从 AI 响应中提取测试文件
+ */
+export function extractTests(content, options = {}) {
+  const { overwrite = false, dryRun = false } = options;
+
+  // 先尝试解析 JSON Manifest（优先）
+  // 形如：```json { version: 1, files: [{ path, source, ... }] }
+  let manifest = null;
+  const manifestRegex = /```json\s*\n([\s\S]*?)\n```/gi;
+  let m;
+  while ((m = manifestRegex.exec(content)) !== null) {
+    const jsonStr = m[1].trim();
+    try {
+      const obj = JSON.parse(jsonStr);
+      if (obj && Array.isArray(obj.files)) {
+        manifest = obj;
+        break;
+      }
+    } catch {}
+  }
+  const manifestPaths = manifest?.files?.map(f => String(f.path).trim()) ?? [];
+
+  // 再匹配多种文件代码块格式（回退/兼容，增强鲁棒性）
+  const patterns = [
+    // 格式1: ### 测试文件: path (有/无反引号)
+    /###\s*测试文件\s*[:：]\s*`?([^\n`]+?)`?\s*\n```(?:typescript|ts|tsx|javascript|js|jsx|json|text)?\s*\n([\s\S]*?)\n```/gi,
+    // 格式2: **测试文件**: path
+    /\*\*测试文件\*\*\s*[:：]\s*`?([^\n`]+)`?\s*\n```(?:typescript|ts|tsx|javascript|js|jsx|json|text)?\s*\n([\s\S]*?)\n```/gi,
+    // 格式3: 文件路径: path
+    /文件路径\s*[:：]\s*`?([^\n`]+)`?\s*\n```(?:typescript|ts|tsx|javascript|js|jsx|json|text)?\s*\n([\s\S]*?)\n```/gi,
+    // 格式4: # path.test.ts (仅文件名标题)
+    /^#+\s+([^\n]+\.test\.[jt]sx?)\s*\n```(?:typescript|ts|tsx|javascript|js|jsx)?\s*\n([\s\S]*?)\n```/gim,
+    // 格式5: 更宽松的匹配（任意"path"后接代码块，路径必须含 .test.）
+    /(?:path|文件|file)\s*[:：]?\s*`?([^\n`]*\.test\.[jt]sx?[^\n`]*?)`?\s*\n```(?:typescript|ts|tsx|javascript|js|jsx)?\s*\n([\s\S]*?)\n```/gi,
+  ];
+
+  const created = [];
+  const skipped = [];
+  const errors = [];
+
+  patterns.forEach(fileRegex => {
+    let match;
+    while ((match = fileRegex.exec(content)) !== null) {
+      const [, filePath, testCode] = match;
+      const cleanPath = filePath.trim();
+
+      // 若存在 Manifest，则只允许清单内的路径
+      if (manifestPaths.length > 0 && !manifestPaths.includes(cleanPath)) {
+        continue;
+      }
+
+      // 跳过已处理的文件
+      if (created.some(f => f.path === cleanPath) || 
+          skipped.some(f => f.path === cleanPath)) {
+        continue;
+      }
+
+      // 检查文件是否已存在
+      if (existsSync(cleanPath) && !overwrite) {
+        skipped.push({ path: cleanPath, reason: 'exists' });
+        continue;
+      }
+
+      if (dryRun) {
+        created.push({ path: cleanPath, code: testCode.trim(), dryRun: true });
+        continue;
+      }
+
+      try {
+        // 确保目录存在
+        mkdirSync(dirname(cleanPath), { recursive: true });
+
+        // 写入测试文件
+        const cleanCode = testCode.trim();
+        writeFileSync(cleanPath, cleanCode + '\n');
+        created.push({ path: cleanPath, code: cleanCode });
+      } catch (err) {
+        errors.push({ path: cleanPath, error: err.message });
+      }
+    }
+  });
+
+  // 若有 Manifest 但未生成任何文件，则报告可能缺失代码块
+  if (manifestPaths.length > 0) {
+    const createdPaths = new Set(created.map(f => f.path));
+    const missing = manifestPaths.filter(p => !createdPaths.has(p));
+    missing.forEach(p => errors.push({ path: p, error: 'missing code block for manifest entry' }));
+  }
+
+  return { created, skipped, errors };
+}
+
+/**
+ * CLI 入口
+ */
+export function runCLI(argv = process.argv) {
+  const args = argv.slice(2);
+  
+  if (args.length === 0) {
+    console.error('❌ 缺少参数\n');
+    console.error('用法: ai-test extract-tests <response-file> [options]\n');
+    console.error('选项:');
+    console.error('  --overwrite    覆盖已存在的文件');
+    console.error('  --dry-run      仅显示将要创建的文件，不实际写入\n');
+    console.error('示例:');
+    console.error('  ai-test extract-tests response.txt');
+    console.error('  ai-test extract-tests response.txt --overwrite');
+    process.exit(1);
+  }
+  
+  const responseFile = args[0];
+  const options = {
+    overwrite: args.includes('--overwrite'),
+    dryRun: args.includes('--dry-run')
+  };
+  
+  if (!existsSync(responseFile)) {
+    console.error(`❌ 文件不存在: ${responseFile}`);
+    process.exit(1);
+  }
+  
+  try {
+    const content = readFileSync(responseFile, 'utf8');
+    const { created, skipped, errors } = extractTests(content, options);
+    
+    // 输出结果
+    created.forEach(f => {
+      if (f.dryRun) {
+        console.log(`[DRY-RUN] 将创建: ${f.path}`);
+      } else {
+        console.log(`✅ 创建测试文件: ${f.path}`);
+      }
+    });
+    
+    skipped.forEach(f => {
+      if (f.reason === 'exists') {
+        console.log(`⚠️  跳过（已存在）: ${f.path}`);
+      }
+    });
+    
+    errors.forEach(f => {
+      console.error(`❌ 创建失败: ${f.path} - ${f.error}`);
+    });
+    
+    console.log('');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log(`✨ 总共创建 ${created.length} 个测试文件`);
+    if (skipped.length > 0) {
+      console.log(`⚠️  跳过 ${skipped.length} 个已存在的文件`);
+    }
+    if (errors.length > 0) {
+      console.log(`❌ ${errors.length} 个文件创建失败`);
+    }
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('');
+    
+    if (created.length > 0 && !options.dryRun) {
+      console.log('🧪 运行测试:');
+      console.log('   npm test');
+      console.log('');
+      console.log('📝 标记完成（如需）:');
+      const functionNames = created
+        .map(f => f.path.match(/\/([^/]+)\.test\./)?.[1])
+        .filter(Boolean)
+        .join(',');
+      if (functionNames) {
+        console.log(`   ai-test mark-done "${functionNames}"`);
+      }
+    } else if (created.length === 0) {
+      console.log('❌ 未找到任何测试文件');
+      console.log('');
+      console.log('请检查 AI 回复格式是否正确。预期格式：');
+      console.log('  ### 测试文件: src/utils/xxx.test.ts');
+      console.log('  ```typescript');
+      console.log('  // 测试代码');
+      console.log('  ```');
+    }
+    
+    process.exit(errors.length > 0 ? 1 : 0);
+  } catch (err) {
+    console.error(`❌ 错误: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// 作为脚本直接运行时
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runCLI();
+}
+

package/lib/ai/index.mjs

@@ -0,0 +1,11 @@
+/**
+ * AI 模块：AI 交互与测试生成
+ * 
+ * 提供 Prompt 构建、AI 调用和测试提取功能
+ * 支持多种 LLM（目前实现：cursor-agent）
+ */
+
+export { buildBatchPrompt, runCLI as buildPrompt } from './prompt-builder.mjs'
+export { main as callAI } from './client.mjs'
+export { extractTests } from './extractor.mjs'
+

package/lib/ai/prompt-builder.mjs

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+/**
+ * 生成批量测试的 AI Prompt
+ * 从评分报告中提取目标，构建包含源码上下文的 Prompt
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+
+/**
+ * 从 ut_scores.md 中解析测试目标
+ */
+export function parseTargets(mdPath, filter = {}) {
+  if (!existsSync(mdPath)) {
+    throw new Error(`报告文件不存在: ${mdPath}`);
+  }
+  
+  const content = readFileSync(mdPath, 'utf8');
+  const lines = content.split('\n');
+  const targets = [];
+  
+  lines.forEach(line => {
+    if (!line.includes('| TODO |')) return;
+    
+    const parts = line.split('|').map(s => s.trim());
+    if (parts.length < 8) return;
+    
+    const [, status, score, priority, name, type, layer, path] = parts;
+    
+    // 应用过滤器
+    if (filter.priority && priority !== filter.priority) return;
+    if (filter.layer && !layer.includes(filter.layer)) return;
+    if (filter.minScore && parseFloat(score) < filter.minScore) return;
+    if (filter.onlyPaths && Array.isArray(filter.onlyPaths) && filter.onlyPaths.length > 0) {
+      const allow = filter.onlyPaths.some(p => path === p || path.endsWith(p));
+      if (!allow) return;
+    }
+    
+    targets.push({ 
+      name, 
+      type, 
+      layer, 
+      path, 
+      priority, 
+      score: parseFloat(score) 
+    });
+  });
+  
+  return targets;
+}
+
+/**
+ * 提取函数源码
+ */
+export function extractFunctionCode(filePath, functionName) {
+  if (!existsSync(filePath)) {
+    return `// 文件不存在: ${filePath}`;
+  }
+  
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    
+    // 多种函数定义模式
+    const patterns = [
+      new RegExp(`export\\s+(async\\s+)?function\\s+${functionName}\\s*\\([^)]*\\)`, 'm'),
+      new RegExp(`export\\s+const\\s+${functionName}\\s*=`, 'm'),
+      new RegExp(`function\\s+${functionName}\\s*\\([^)]*\\)`, 'm'),
+      new RegExp(`const\\s+${functionName}\\s*=`, 'm'),
+    ];
+    
+    let matchIndex = -1;
+    
+    for (const pattern of patterns) {
+      const match = content.match(pattern);
+      if (match) {
+        matchIndex = content.indexOf(match[0]);
+        break;
+      }
+    }
+    
+    if (matchIndex === -1) {
+      return `// 未找到函数: ${functionName}`;
+    }
+    
+    // 提取函数体
+    let braceCount = 0;
+    let inFunction = false;
+    let funcCode = '';
+    
+    for (let i = matchIndex; i < content.length; i++) {
+      const char = content[i];
+      funcCode += char;
+      
+      if (char === '{') {
+        braceCount++;
+        inFunction = true;
+      } else if (char === '}') {
+        braceCount--;
+        if (inFunction && braceCount === 0) break;
+      }
+      
+      // 简单处理箭头函数
+      if (funcCode.includes('=>') && !inFunction && char === ';') break;
+    }
+    
+    return funcCode || content.slice(matchIndex, Math.min(matchIndex + 1000, content.length));
+  } catch (err) {
+    return `// 读取失败: ${err.message}`;
+  }
+}
+
+/**
+ * 构建测试生成 Prompt
+ */
+export function buildBatchPrompt(targets, options = {}) {
+  const {
+    framework = 'React + TypeScript',
+    testFramework = 'Jest',
+    coverageTarget = 80,
+    customInstructions = ''
+  } = options;
+  
+  // 预先计算测试文件清单（用于 JSON manifest 与展示）
+  const files = targets.map(t => {
+    const testPath = t.path.replace(/\.(ts|tsx|js|jsx)$/i, m => `.test${m}`)
+    return {
+      path: testPath,
+      source: t.path,
+      name: t.name,
+      type: t.type,
+      layer: t.layer,
+      priority: t.priority,
+      score: t.score
+    }
+  })
+
+  let prompt = `# 批量生成单元测试
+
+你是一个单元测试专家。我需要为以下 ${targets.length} 个函数生成单元测试。
+
+## 项目信息
+- 框架：${framework}
+- 测试框架：${testFramework} + Testing Library
+- 要求：每个函数覆盖率 >= ${coverageTarget}%
+
+## 测试要求
+1. 使用 ${testFramework} 的标准语法 (describe、test/it、expect)
+2. 覆盖正常情况、边界条件、异常情况
+3. 对于 React Hooks，使用 @testing-library/react-hooks
+4. 对于 React 组件，使用 @testing-library/react
+5. 对于工具函数，直接测试输入输出
+6. 必要时使用 mock 模拟依赖
+7. 测试文件命名：与原文件同名，加 .test 后缀
+8. 严禁修改被测源码与新增依赖；避免使用真实时间/网络/随机数（请使用 fake timers、模块化 mock）
+${customInstructions ? `\n${customInstructions}\n` : ''}
+---
+
+`;
+
+  // 严格输出协议：先输出 JSON manifest，再输出逐文件代码块
+  prompt += `## 测试文件清单（JSON Manifest）
+请首先输出一个 JSON，包含将要生成的所有测试文件路径与源信息：
+
+\`\`\`json
+${JSON.stringify({ version: 1, files }, null, 2)}
+\`\`\`
+
+---
+`;
+
+  targets.forEach((target, index) => {
+    const code = extractFunctionCode(target.path, target.name);
+    const testPath = target.path.replace(/\.(ts|tsx|js|jsx)$/i, m => `.test${m}`)
+    
+    prompt += `
+## 测试 ${index + 1}/${targets.length}: ${target.name}
+
+**文件路径**: \`${target.path}\`
+**函数类型**: ${target.type}
+**所属层级**: ${target.layer}
+**优先级**: ${target.priority} (分数: ${target.score})
+
+**函数源码**:
+\`\`\`typescript
+${code}
+\`\`\`
+
+**测试文件路径**: \`${testPath}\`
+
+---
+`;
+  });
+  
+  prompt += `
+## 输出格式
+
+请严格按照以下顺序与格式输出：
+
+1) 先输出“测试文件清单（JSON Manifest）”——与上文格式一致，包含所有 \"path\"。
+2) 然后依次输出每个测试文件的代码块：
+
+### 测试文件: [文件路径]
+\`\`\`typescript
+[完整的测试代码]
+\`\`\`
+
+### 测试文件: [下一个文件路径]
+...
+
+要求：
+- 代码块语言可为 ts/tsx/typescript/js/javascript/jsx 之一
+- 文件路径必须与 JSON Manifest 中的 path 一致
+- 不要省略任何测试文件
+
+---
+
+现在开始生成 ${targets.length} 个测试文件：
+`;
+  
+  return prompt;
+}
+
+/**
+ * CLI 入口
+ */
+export function runCLI(argv = process.argv) {
+  const args = argv.slice(2);
+  const filter = {};
+  const options = {};
+  
+  // 解析参数
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--priority' || arg === '-p') {
+      filter.priority = args[++i];
+    } else if (arg === '--layer' || arg === '-l') {
+      filter.layer = args[++i];
+    } else if (arg === '--limit' || arg === '-n') {
+      filter.limit = parseInt(args[++i]);
+    } else if (arg === '--skip') {
+      filter.skip = parseInt(args[++i]);
+    } else if (arg === '--min-score') {
+      filter.minScore = parseFloat(args[++i]);
+    } else if (arg === '--report') {
+      options.reportPath = args[++i];
+    } else if (arg === '--framework') {
+      options.framework = args[++i];
+    } else if (arg === '--hints') {
+      options.customInstructions = (options.customInstructions || '') + `\n${args[++i]}`;
+    } else if (arg === '--hints-file') {
+      const p = args[++i];
+      try { options.customInstructions = (options.customInstructions || '') + `\n${readFileSync(p, 'utf8')}` } catch {}
+    } else if (arg === '--only-paths') {
+      const csv = args[++i] || '';
+      filter.onlyPaths = csv.split(',').map(s => s.trim()).filter(Boolean);
+    }
+  }
+  
+  const mdPath = options.reportPath || 'reports/ut_scores.md';
+  
+  try {
+    let targets = parseTargets(mdPath, filter);
+    
+    // 支持跳过前 N 个（用于分页）
+    const skip = Number.isInteger(filter.skip) && filter.skip > 0 ? filter.skip : 0;
+    if (skip) targets = targets.slice(skip);
+    
+    if (filter.limit) targets = targets.slice(0, filter.limit);
+    
+    if (targets.length === 0) {
+      console.error('❌ 没有找到匹配的目标\n');
+      console.error('用法示例:');
+      console.error('  ai-test gen-prompt -p P0 -l Foundation -n 5');
+      console.error('  ai-test gen-prompt -p P0 --min-score 7.5 -n 10\n');
+      console.error('参数:');
+      console.error('  -p, --priority     优先级过滤 (P0, P1, P2, P3)');
+      console.error('  -l, --layer        层级过滤 (Foundation, Business, State, UI)');
+      console.error('  -n, --limit        限制数量');
+      console.error('      --skip         跳过前 N 个');
+      console.error('  --min-score        最低分数');
+      console.error('  --report           报告文件路径 (默认: reports/ut_scores.md)');
+      console.error('  --framework        项目框架 (默认: React + TypeScript)');
+      process.exit(1);
+    }
+    
+    console.error(`✅ 找到 ${targets.length} 个目标\n`);
+    console.log(buildBatchPrompt(targets, options));
+  } catch (err) {
+    console.error(`❌ 错误: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// 作为脚本直接运行时
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runCLI();
+}
+