ai-unit-test-generator 1.4.1 → 1.4.3

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.3] - 2025-01-10
+
+### Changed
+- **Config file format**: Changed default config from `.json` to `.jsonc` with comprehensive inline comments
+- **Report simplification**: Removed redundant `Notes` column from reports (info now in config comments)
+- **Better documentation**: Config file now self-documenting with detailed explanations of each scoring parameter
+- Auto-detection order: `ai-test.config.jsonc` → `ai-test.config.json` → `ut_scoring_config.json` (deprecated)
+
+### Fixed
+- Config file now properly supports JSONC format (JSON with comments)
+
 ## [1.0.0] - 2025-01-10
 
 ### Breaking Changes

package/bin/cli.js

@@ -24,13 +24,16 @@ program
 program
   .command('scan')
   .description('Scan code and generate priority scoring report')
-  .option('-c, --config <path>', 'Config file path', 'ut_scoring_config.json')
+  .option('-c, --config <path>', 'Config file path', 'ai-test.config.jsonc')
   .option('-o, --output <dir>', 'Output directory', 'reports')
   .option('--skip-git', 'Skip Git signals generation')
   .action(async (options) => {
-    const { config, output, skipGit } = options
+    let { config, output, skipGit } = options
 
-    // 自动初始化配置（如果不存在）
+    // 自动探测现有配置 & 初始化（不存在则创建）
+    const detectOrder = [config, 'ai-test.config.json', 'ai-test.config.jsonc']
+    const detected = detectOrder.find(p => existsSync(p))
+    if (detected) config = detected
     if (!existsSync(config)) {
       console.log('⚙️  Config not found, creating default config...')
       const templatePath = join(PKG_ROOT, 'templates', 'default.config.json')

package/lib/core/scanner.mjs

@@ -22,7 +22,12 @@ function parseArgs(argv) {
   return args
 }
 
-function loadJson(p) { try { return JSON.parse(readFileSync(p, 'utf8')) } catch { return null } }
+function stripJsonComments(s) {
+  return String(s)
+    .replace(/\/\*[\s\S]*?\*\//g, '') // block comments
+    .replace(/(^|\s)\/\/.*$/gm, '')     // line comments
+}
+function loadJson(p) { try { return JSON.parse(stripJsonComments(readFileSync(p, 'utf8'))) } catch { return null } }
 
 async function listFiles(excludeDirs = []) {
   const fg = (await req('fast-glob', 'fast-glob')).default

package/lib/core/scorer.mjs

@@ -25,7 +25,25 @@ function loadJson(p) {
 function toFixedDown(num, digits = 2) { const m = Math.pow(10, digits); return Math.floor(num * m) / m }
 function clamp(n, min, max) { return Math.max(min, Math.min(max, n)) }
 
-function loadConfig(pathFromArg) { return loadJson(pathFromArg) || loadJson('ut_scoring_config.json') || {} }
+function stripJsonComments(s) {
+  return String(s)
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/(^|\s)\/\/.*$/gm, '')
+}
+function loadConfig(pathFromArg) {
+  const fs = require('fs')
+  const paths = [pathFromArg, 'ai-test.config.jsonc', 'ai-test.config.json']
+  for (const p of paths) {
+    if (!p) continue
+    try {
+      if (fs.existsSync(p)) {
+        const raw = fs.readFileSync(p, 'utf8')
+        return JSON.parse(stripJsonComments(raw))
+      }
+    } catch {}
+  }
+  return {}
+}
 function pickWeight(cfg, key, def) { return cfg?.weights?.[key] ?? def }
 function pickThreshold(cfg, key, def) { return cfg?.thresholds?.[key] ?? def }
 
@@ -276,14 +294,14 @@ function defaultMd(rows, statusMap = new Map()) {
   let md = '<!-- UT Priority Scoring Report -->\n'
   md += '<!-- Format: Status can be "TODO" | "DONE" | "SKIP" -->\n'
   md += '<!-- You can mark status by replacing TODO with DONE or SKIP -->\n\n'
-  md += '| Status | Score | Priority | Name | Type | Layer | Path | Coverage | CS | BC | CC | ER | Testability | DepCount | Notes |\n'
-  md += '|--------|-------|----------|------|------|-------|------|----------|----|----|----|----|-----------|---------| ------- |\n'
+  md += '| Status | Score | Priority | Name | Type | Layer | Path | Coverage | CS | BC | CC | ER | Testability | DepCount |\n'
+  md += '|--------|-------|----------|------|------|-------|------|----------|----|----|----|----|-----------|----------|\n'
   
   sorted.forEach(r => {
     // 从状态映射中查找现有状态，否则默认为 TODO
     const key = `${r.path}#${r.name}`
     const status = statusMap.get(key) || 'TODO'
-    md += `| ${status} | ${r.score} | ${r.priority} | ${r.name} | ${r.type} | ${r.layerName || r.layer} | ${r.path} | ${typeof r.coveragePct === 'number' ? r.coveragePct.toFixed(1) + '%':'N/A'} | ${r.coverageScore ?? 'N/A'} | ${r.BC} | ${r.CC} | ${r.ER} | ${r.testability || r.ROI} | ${r.dependencyCount || 'N/A'} | ${r.notes} |\n` 
+    md += `| ${status} | ${r.score} | ${r.priority} | ${r.name} | ${r.type} | ${r.layerName || r.layer} | ${r.path} | ${typeof r.coveragePct === 'number' ? r.coveragePct.toFixed(1) + '%':'N/A'} | ${r.coverageScore ?? 'N/A'} | ${r.BC} | ${r.CC} | ${r.ER} | ${r.testability || r.ROI} | ${r.dependencyCount || 'N/A'} |\n` 
   })
   
   // 添加统计信息
@@ -315,7 +333,7 @@ function defaultCsv(rows) {
   // 按总分降序排序（高分在前）
   const sorted = [...rows].sort((a, b) => b.score - a.score)
   
-  const head = ['status','score','priority','name','path','type','layer','layerName','coveragePct','coverageScore','BC','CC','ER','testability','dependencyCount','notes'].join(',')
+  const head = ['status','score','priority','name','path','type','layer','layerName','coveragePct','coverageScore','BC','CC','ER','testability','dependencyCount'].join(',')
   const body = sorted.map(r => [
     'TODO',
     r.score,
@@ -331,8 +349,7 @@ function defaultCsv(rows) {
     r.CC,
     r.ER,
     r.testability || r.ROI,
-    r.dependencyCount || 'N/A',
-    `"${r.notes}"`
+    r.dependencyCount || 'N/A'
   ].join(',')).join('\n')
   return head + '\n' + body + '\n'
 }
@@ -583,28 +600,6 @@ async function main() {
       }
     }
     
-    // 构建 notes
-    const notesParts = []
-        const cognitive = eslintCognitive?.[`${path}#${name}`]
-        if (cognitive !== undefined) notesParts.push('CC:fused')
-        else notesParts.push('CC:cyclo-only')
-    if (internal && loc >= (cfg?.ccAdjust?.locBonusThreshold ?? 50)) notesParts.push(`CC+${cfg?.ccAdjust?.locBonus ?? 1}loc`)
-    if (CCFinal > CC) notesParts.push('CC+platform')
-    if (depGraphData && depGraphData.crossModuleScore > 0) notesParts.push(`ER+depGraph(${depGraphData.crossModuleScore})`)
-    if (!git) notesParts.push('ER:fallback')
-    else notesParts.push('ER:git')
-    if (overrides) {
-      const key = `${path}#${name}`
-      if (overrides.BC?.[key]) notesParts.push('BC:override')
-      if (overrides.CC?.[key]) notesParts.push('CC:override')
-      if (overrides.ER?.[key]) notesParts.push('ER:override')
-      if (overrides.ROI?.[key]) notesParts.push('ROI:override')
-    }
-    if (localImpact) notesParts.push('Impact:local')
-    if (localROI) notesParts.push('ROI:local')
-    notesParts.push(internal ? 'Internal:Y' : 'Internal:N')
-    if (!isMainChain(path, cfg)) notesParts.push(`BC:cap≤${cfg?.bcCapForNonMainChain ?? 8}`)
-    
     rows.push({ 
       name, 
       path, 
@@ -620,8 +615,7 @@ async function main() {
       coveragePct: coveragePct ?? 'N/A',
       coverageScore: coverageScore ?? 'N/A',
       score, 
-      priority, 
-      notes: notesParts.join('; ') 
+      priority
     })
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-unit-test-generator",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "AI-powered unit test generator with smart priority scoring",
   "keywords": [
     "unit-test",

package/templates/default.config.jsonc

@@ -0,0 +1,314 @@
+{
+  // ========== 核心评分配置 ==========
+  "scoringMode": "layered", // 评分模式: "layered"(分层) 或 "legacy"(传统)
+  "round": { 
+    "mode": "floor",        // 取整模式: floor(向下) / ceil(向上) / round(四舍五入)
+    "digits": 2             // 保留小数位数
+  },
+
+  // ========== 扫描目标配置 ==========
+  "providers": ["func"],    // 扫描目标类型: func(函数) / class(类) / method(方法)
+  "targetGeneration": {
+    "excludeDirs": []       // 排除的目录，例如: ["__tests__", "node_modules"]
+  },
+  "internalInclude": true,  // 是否包含内部函数（非导出函数）
+  "internalThresholds": {
+    "minLoc": 15,           // 内部函数最小行数阈值
+    "bonusLoc": 50,         // 超过此行数给予额外关注
+    "excludePatterns": [    // 排除的文件模式
+      "**/__tests__/**", 
+      "**/*.spec.ts", 
+      "**/*.spec.tsx"
+    ]
+  },
+
+  // ========== 分层架构配置 ==========
+  // 测试金字塔：Foundation(底层) -> Business Logic -> State Management -> UI Components(顶层)
+  "layers": {
+    // 基础工具层：纯函数、工具函数、无依赖的基础代码
+    "foundation": {
+      "name": "Foundation (基础工具层)",
+      "description": "纯函数、工具函数、无依赖的基础代码",
+      "patterns": ["utils/**", "constants/**", "config/**", "types/**"],
+      "characteristics": {
+        "isPure": true,             // 是否为纯函数
+        "noDependencies": true,     // 是否无依赖
+        "multipleReferences": true  // 是否被多处引用
+      },
+      "weights": {
+        "testability": 0.45,        // 可测试性权重（最高）
+        "dependencyCount": 0.25,    // 依赖数量权重
+        "complexity": 0.20,         // 复杂度权重
+        "coverage": 0.10            // 覆盖率权重
+      },
+      "thresholds": { "P0": 7.5, "P1": 6.0, "P2": 4.0 },
+      "coverageTarget": 100,        // 目标覆盖率 100%
+      "autoP0": false
+    },
+    
+    // 业务逻辑层：包含业务规则的函数，不包含UI
+    "business": {
+      "name": "Business Logic (业务逻辑层)",
+      "description": "包含业务规则的函数，不包含UI",
+      "patterns": ["services/**", "stores/**", "hooks/**"],
+      "characteristics": {
+        "hasBusinessRules": true,
+        "noUI": true,
+        "mayDependOnUtils": true
+      },
+      "weights": {
+        "businessCriticality": 0.35,  // 业务关键度权重（最高）
+        "complexity": 0.25,
+        "errorRisk": 0.25,
+        "coverage": 0.15
+      },
+      "thresholds": { "P0": 8.0, "P1": 6.5, "P2": 4.5 },
+      "coverageTarget": 80
+    },
+    
+    // 状态管理层：Jotai atoms、Zustand stores等
+    "state": {
+      "name": "State Management (状态管理层)",
+      "description": "Jotai atoms、Zustand stores等状态管理",
+      "patterns": ["atoms/**", "stores/**"],
+      "characteristics": {
+        "isStateManagement": true,
+        "connectsLogicAndUI": true
+      },
+      "weights": {
+        "businessCriticality": 0.45,
+        "complexity": 0.25,
+        "errorRisk": 0.20,
+        "coverage": 0.10
+      },
+      "thresholds": { "P0": 8.0, "P1": 6.5, "P2": 4.5 },
+      "coverageTarget": 70
+    },
+    
+    // UI组件层：React组件、包含交互逻辑
+    "ui": {
+      "name": "UI Components (UI组件层)",
+      "description": "React组件、包含交互逻辑",
+      "patterns": ["components/**", "pages/**", "context/**"],
+      "characteristics": {
+        "isReactComponent": true,
+        "hasInteraction": true
+      },
+      "weights": {
+        "businessCriticality": 0.35,
+        "complexity": 0.25,
+        "testability": 0.25,
+        "coverage": 0.15
+      },
+      "thresholds": { "P0": 8.5, "P1": 7.0, "P2": 5.0 },
+      "coverageTarget": 50        // UI层目标覆盖率适当降低
+    }
+  },
+
+  // ========== 覆盖率评分配置 ==========
+  // 参考: Meta TestGen-LLM 覆盖率增量验证
+  "coverageScoring": {
+    "naScore": 5,            // 无覆盖率数据时的默认分数
+    "mapping": [             // 覆盖率百分比到分数的映射（覆盖率越低，分数越高，优先级越高）
+      { "lte": 0, "score": 10 },      // 0% 覆盖率 -> 最高优先级
+      { "lte": 40, "score": 8 },      // ≤40% -> 高优先级
+      { "lte": 70, "score": 6 },      // ≤70% -> 中等优先级
+      { "lte": 90, "score": 3 },      // ≤90% -> 低优先级
+      { "lte": 100, "score": 1 }      // 100% 覆盖率 -> 最低优先级
+    ]
+  },
+
+  // ========== 覆盖率自动扫描配置 ==========
+  "coverage": {
+    "runBeforeScan": true,                    // 是否在扫描前自动运行覆盖率分析
+    "command": "npx jest --coverage --silent" // 覆盖率分析命令
+  },
+
+  // ========== 传统评分模式的权重配置 ==========
+  // 仅在 scoringMode: "legacy" 时使用
+  "weights": {
+    "BC": 0.25,              // Business Criticality (业务关键度)
+    "CC": 0.15,              // Cyclomatic Complexity (圈复杂度)
+    "ER": 0.15,              // Error Risk (错误风险)
+    "ROI": 0.15,             // Return on Investment (投资回报率，即可测试性)
+    "dependencyCount": 0.10, // 依赖数量
+    "coverage": 0.20         // 覆盖率权重（新增，参考 CodeScene 的热点分析）
+  },
+  "thresholds": { "P0": 8.0, "P1": 6.5, "P2": 4.5 },
+
+  // ========== 覆盖率加成配置 ==========
+  // 参考: ISTQB 风险驱动测试
+  "coverageBoost": { 
+    "enable": true,
+    "threshold": 60,   // 覆盖率低于此值时启用加成
+    "scale": 0.5,      // 加成系数
+    "maxBoost": 0.5    // 最大加成值
+  },
+
+  // ========== 复杂度融合配置 ==========
+  // 圈复杂度 + 认知复杂度融合
+  "ccFusion": {
+    "useCognitive": true,  // 是否启用认知复杂度
+    "cyclomaticT": 15,     // 圈复杂度阈值
+    "cognitiveT": 25,      // 认知复杂度阈值
+    "wC": 0.7,             // 圈复杂度权重
+    "wK": 0.3,             // 认知复杂度权重
+    "cap": 10              // 最大分数上限
+  },
+
+  // ========== 复杂度调整配置 ==========
+  "ccAdjust": {
+    "depthW": 0.2,           // 深度权重
+    "branchesW": 0.2,        // 分支数权重
+    "paramsW": 0.1,          // 参数数量权重
+    "locBonusThreshold": 50, // 行数加成阈值
+    "locBonus": 1            // 行数加成分数
+  },
+
+  // ========== 业务关键度关键词配置 ==========
+  // 参考: ISTQB 风险驱动测试 - API表面暴露度
+  "bcKeywords": {
+    "10": ["price", "booking", "payment", "checkout"],  // 支付核心
+    "9": ["recommend", "search"],                       // 搜索推荐
+    "8": ["filter", "list"],                            // 列表筛选
+    "7": ["login", "order", "config"],                  // 登录配置
+    "5": ["navigation", "seo", "header"],               // 导航SEO
+    "3": ["log", "trace", "decor"]                      // 日志装饰
+  },
+
+  // ========== 主链路配置 ==========
+  "mainChainPaths": [],           // 主链路路径，例如: ["src/services/booking/**"]
+  "bcCapForNonMainChain": 8,      // 非主链路业务关键度上限
+
+  // ========== 圈复杂度映射配置 ==========
+  "ccMapping": {
+    "cyclomatic": [
+      { "gt": 15, "score": 10 },              // >15 -> 最复杂
+      { "gte": 11, "lte": 15, "score": 10 },  // 11-15 -> 高复杂
+      { "gte": 6, "lte": 10, "score": 9 },    // 6-10 -> 中等复杂
+      { "gte": 3, "lte": 5, "score": 7 },     // 3-5 -> 低复杂
+      { "lte": 2, "score": 6 }                // ≤2 -> 简单
+    ],
+    "adjustments": [  // 额外复杂度调整规则
+      { "field": "maxDepth", "op": ">=", "value": 4, "delta": 1 },    // 深度≥4 +1分
+      { "field": "branches", "op": ">=", "value": 12, "delta": 1 },   // 分支≥12 +1分
+      { "field": "params", "op": ">=", "value": 6, "delta": 1 },      // 参数≥6 +1分
+      { "field": "statements", "op": ">=", "value": 80, "delta": 1 }, // 语句≥80 +1分
+      { "field": "cognitive", "op": ">=", "value": 25, "delta": 1 }   // 认知≥25 +1分
+    ],
+    "cap": 10,
+    "platformAdjust": { 
+      "delta": 1,              // 平台相关代码额外+1分
+      "cap": 10, 
+      "skipIfLikelihoodGte": 4 // 如果错误可能性≥4则跳过此调整
+    }
+  },
+
+  // ========== 降级复杂度映射配置 ==========
+  "fallbackMapping": {
+    "conditions": [
+      { "gt": 12, "score": 10 },
+      { "gte": 8, "lte": 12, "score": 8 },
+      { "gte": 5, "lte": 7, "score": 6 },
+      { "gte": 3, "lte": 4, "score": 4 },
+      { "lte": 2, "score": 2 }
+    ],
+    "nesting": [
+      { "gte": 4, "delta": 2 },
+      { "eq": 3, "delta": 1 }
+    ],
+    "earlyReturns": [
+      { "gte": 4, "delta": 1 }
+    ],
+    "paramsOrSources": [
+      { "paramsGte": 6, "delta": 1 },
+      { "sourcesGte": 3, "delta": 1 }
+    ],
+    "cap": 10
+  },
+
+  // ========== 依赖图配置 ==========
+  "depGraph": {
+    "enable": true,
+    "neighborCategoryBoost": 2,  // 邻近类别加成
+    "degreeBoost": 8             // 依赖度加成
+  },
+
+  // ========== 错误风险矩阵配置 ==========
+  // 参考: Meta TestGen-LLM 稳定性重跑验证
+  // ER = 错误可能性 (Likelihood) × 影响度 (Impact)
+  "erMatrix": {
+    "5": { "5": 10, "4": 9, "3": 8, "2": 7, "1": 6 },  // 可能性=5
+    "4": { "5": 9, "4": 8, "3": 7, "2": 6, "1": 5 },   // 可能性=4
+    "3": { "5": 8, "4": 7, "3": 6, "2": 5, "1": 4 },   // 可能性=3
+    "2": { "5": 7, "4": 6, "3": 5, "2": 4, "1": 3 },   // 可能性=2
+    "1": { "5": 6, "4": 5, "3": 4, "2": 3, "1": 2 }    // 可能性=1
+  },
+
+  // ========== 错误可能性规则配置 ==========
+  // 参考: CodeScene 的变更频率（Churn）分析
+  "likelihoodRules": [
+    { "field": "commits30d", "op": ">=", "value": 6, "score": 5 },           // 30天内≥6次提交 -> 高频变更
+    { "field": "commits30d", "op": "between", "min": 3, "max": 5, "score": 4 },
+    { "field": "commits30d", "op": "between", "min": 1, "max": 2, "score": 3 },
+    { "field": "fallback90d", "op": "gt", "value": 0, "score": 2 },          // 90天内有变更
+    { "field": "fallback180dZero", "op": "eq", "value": true, "score": 1 }   // 180天内无变更
+  ],
+
+  // ========== 加成规则配置 ==========
+  "boostRules": {
+    "authors30dGte": 3,    // 30天内贡献者≥3人
+    "crossModule": true,   // 跨模块引用
+    "multiPlatform": true, // 多平台代码
+    "cap": 5               // 加成上限
+  },
+
+  // ========== 跨模块类别配置 ==========
+  "crossModuleCategories": ["components", "hooks", "utils", "services", "pages"],
+
+  // ========== 本地提示映射配置 ==========
+  "hintMaps": {
+    "impactLocal": "configs/impact.local.json",
+    "roiLocal": "configs/roi.local.json"
+  },
+
+  // ========== 覆盖配置 ==========
+  "overrides": "reports/overrides.json",
+
+  // ========== 影响度关键词配置 ==========
+  "impactKeywords": {
+    "5": ["payment", "booking", "price"],
+    "4": ["filter", "list", "display"],
+    "3": ["interaction"],
+    "2": ["minor", "ui"],
+    "1": ["decor", "cosmetic"]
+  },
+
+  // ========== 可测试性规则配置 ==========
+  // 纯函数和可注入函数最适合AI生成测试
+  "testabilityRules": {
+    "pure": 10,             // 纯函数 -> 最易测试
+    "injectable": 9,        // 依赖注入 -> 很易测试
+    "multiContext": 7,      // 多上下文 -> 中等难度
+    "nativeOrNetwork": 5,   // 原生API/网络 -> 需要Mock
+    "needsUI": 3            // 需要UI环境 -> 较难测试
+  },
+
+  // ========== 依赖数量映射配置 ==========
+  // 依赖越多，集成风险越高，测试价值越高
+  "dependencyCountMapping": [
+    { "gte": 10, "score": 10 },       // ≥10个依赖 -> 高集成风险
+    { "gte": 5, "lt": 10, "score": 10 },
+    { "gte": 3, "lt": 5, "score": 9 },
+    { "gte": 1, "lt": 3, "score": 7 },
+    { "eq": 0, "score": 5 }           // 0个依赖 -> 纯函数（低风险但高可测试性）
+  ],
+
+  // ========== 降级默认值配置 ==========
+  "fallbacks": { 
+    "BC": 6,           // 业务关键度默认值
+    "CC": 6,           // 复杂度默认值
+    "ERLikelihood": 3, // 错误可能性默认值
+    "Testability": 6   // 可测试性默认值
+  }
+}

package/lib/extract-tests.mjs

@@ -1,199 +0,0 @@
-#!/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/index.js

@@ -1,18 +0,0 @@
-/**
- * @ctrip/ut-priority-scorer
- * 
- * AI-friendly Unit Test priority scoring system
- * Based on layered architecture and testability metrics
- */
-
-export { default as genTargets } from './gen-targets.mjs'
-export { default as genGitSignals } from './gen-git-signals.mjs'
-export { default as score } from './score-ut.mjs'
-
-// 版本信息
-export const version = '1.0.0'
-
-// 默认配置路径
-export const DEFAULT_CONFIG_PATH = 'ut_scoring_config.json'
-export const DEFAULT_OUTPUT_DIR = 'reports'
-

package/lib/run-batch.mjs

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-/**
- * 单批次：生成 prompt → 调用 AI → 提取测试 → 运行 Jest → 输出失败摘要
- */
-
-import { spawn } from 'child_process'
-import { existsSync, readFileSync } from 'fs'
-
-function sh(cmd, args = []) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args, { stdio: 'inherit', cwd: process.cwd() })
-    child.on('close', code => code === 0 ? resolve(0) : reject(new Error(`${cmd} exited ${code}`)))
-    child.on('error', reject)
-  })
-}
-
-function readCoverageSummary() {
-  const path = 'coverage/coverage-summary.json'
-  if (!existsSync(path)) return null
-  try { return JSON.parse(readFileSync(path, 'utf8')) } catch { return null }
-}
-
-function getCoveragePercent(summary) {
-  if (!summary || !summary.total) return 0
-  return summary.total.lines?.pct ?? 0
-}
-
-async function main(argv = process.argv) {
-  const args = argv.slice(2)
-  const priority = args[0] || 'P0'
-  const limit = Number(args[1] || 10)
-  const skip = Number(args[2] || 0)
-  const minCovDelta = priority === 'P0' ? 2 : (priority === 'P1' ? 1 : 0)
-
-  // 记录初始覆盖率
-  const beforeCov = getCoveragePercent(readCoverageSummary())
-
-  // 1) 生成 Prompt（加入上一轮失败提示 hints.txt 如存在）
-  const promptArgs = ['ai-test-generator/lib/gen-test-prompt.mjs', '--report', 'reports/ut_scores.md', '-p', priority, '-n', String(limit), '--skip', String(skip)]
-  try { await sh('node', [...promptArgs, '--hints-file', 'reports/hints.txt']) } catch { await sh('node', promptArgs) }
-
-  // 2) 调用 AI
-  await sh('node', ['ai-test-generator/lib/ai-generate.mjs', '--prompt', 'prompt.txt', '--out', 'reports/ai_response.txt'])
-
-  // 3) 提取测试
-  await sh('node', ['ai-test-generator/lib/extract-tests.mjs', 'reports/ai_response.txt', '--overwrite'])
-
-  // 4) 运行 Jest（按优先级自适应重跑与覆盖率增量）
-  const reruns = priority === 'P0' ? 1 : (priority === 'P1' ? 0 : 0)
-  for (let i = 0; i < Math.max(1, reruns + 1); i++) {
-    try { await sh('node', ['ai-test-generator/lib/jest-runner.mjs']) } catch { /* 继续做失败分析 */ }
-  }
-
-  // 校验覆盖率增量（P0/P1）
-  if (minCovDelta > 0) {
-    const afterCov = getCoveragePercent(readCoverageSummary())
-    const delta = afterCov - beforeCov
-    if (delta < minCovDelta) {
-      console.warn(`⚠️  Coverage delta ${delta.toFixed(2)}% < required ${minCovDelta}% (before: ${beforeCov.toFixed(2)}%, after: ${afterCov.toFixed(2)}%)`)
-    } else {
-      console.log(`✅ Coverage improved: ${beforeCov.toFixed(2)}% → ${afterCov.toFixed(2)}% (+${delta.toFixed(2)}%)`)
-    }
-  }
-
-  // 5) 失败分析并落盘 hints
-  const { spawn } = await import('child_process')
-  const { writeFileSync } = await import('fs')
-  await new Promise((resolve) => {
-    const child = spawn('node', ['ai-test-generator/lib/jest-failure-analyzer.mjs'], { stdio: ['inherit','pipe','inherit'] })
-    const chunks = []
-    child.stdout.on('data', d => chunks.push(Buffer.from(d)))
-    child.on('close', () => {
-      try { const obj = JSON.parse(Buffer.concat(chunks).toString('utf8')); writeFileSync('reports/hints.txt', obj.hints?.length ? `# 上一轮失败修复建议\n- ${obj.hints.join('\n- ')}` : '') } catch {}
-      resolve()
-    })
-  })
-}
-
-if (import.meta.url === `file://${process.argv[1]}`) main()
-
-

package/templates/default.config.json

@@ -1,227 +0,0 @@
-{
-  "scoringMode": "layered",
-  "round": { "mode": "floor", "digits": 2 },
-  "providers": ["func"],
-  "targetGeneration": {
-    "excludeDirs": []
-  },
-  "internalInclude": true,
-  "internalThresholds": {
-    "minLoc": 15,
-    "bonusLoc": 50,
-    "excludePatterns": ["**/__tests__/**", "**/*.spec.ts", "**/*.spec.tsx"]
-  },
-  "layers": {
-    "foundation": {
-      "name": "Foundation (基础工具层)",
-      "description": "纯函数、工具函数、无依赖的基础代码",
-      "patterns": ["utils/**", "constants/**", "config/**", "types/**"],
-      "characteristics": {
-        "isPure": true,
-        "noDependencies": true,
-        "multipleReferences": true
-      },
-      "weights": {
-        "testability": 0.45,
-        "dependencyCount": 0.25,
-        "complexity": 0.20,
-        "coverage": 0.10
-      },
-      "thresholds": { "P0": 7.5, "P1": 6.0, "P2": 4.0 },
-      "coverageTarget": 100,
-      "autoP0": false,
-      "notes": "测试金字塔底层，优先级最高；AI生成友好层"
-    },
-    "business": {
-      "name": "Business Logic (业务逻辑层)",
-      "description": "包含业务规则的函数，不包含UI",
-      "patterns": ["services/**", "stores/**", "hooks/**"],
-      "characteristics": {
-        "hasBusinessRules": true,
-        "noUI": true,
-        "mayDependOnUtils": true
-      },
-      "weights": {
-        "businessCriticality": 0.35,
-        "complexity": 0.25,
-        "errorRisk": 0.25,
-        "coverage": 0.15
-      },
-      "thresholds": { "P0": 8.0, "P1": 6.5, "P2": 4.5 },
-      "coverageTarget": 80,
-      "notes": "核心业务逻辑，高优先级"
-    },
-    "state": {
-      "name": "State Management (状态管理层)",
-      "description": "Jotai atoms、Zustand stores等状态管理",
-      "patterns": ["atoms/**", "stores/**"],
-      "characteristics": {
-        "isStateManagement": true,
-        "connectsLogicAndUI": true
-      },
-      "weights": {
-        "businessCriticality": 0.45,
-        "complexity": 0.25,
-        "errorRisk": 0.20,
-        "coverage": 0.10
-      },
-      "thresholds": { "P0": 8.0, "P1": 6.5, "P2": 4.5 },
-      "coverageTarget": 70,
-      "notes": "状态管理，连接逻辑和UI"
-    },
-    "ui": {
-      "name": "UI Components (UI组件层)",
-      "description": "React组件、包含交互逻辑",
-      "patterns": ["components/**", "pages/**", "context/**"],
-      "characteristics": {
-        "isReactComponent": true,
-        "hasInteraction": true
-      },
-      "weights": {
-        "businessCriticality": 0.35,
-        "complexity": 0.25,
-        "testability": 0.25,
-        "coverage": 0.15
-      },
-      "thresholds": { "P0": 8.5, "P1": 7.0, "P2": 5.0 },
-      "coverageTarget": 50,
-      "notes": "UI层，更适合集成测试"
-    }
-  },
-  "coverageScoring": {
-    "naScore": 5,
-    "mapping": [
-      { "lte": 0, "score": 10 },
-      { "lte": 40, "score": 8 },
-      { "lte": 70, "score": 6 },
-      { "lte": 90, "score": 3 },
-      { "lte": 100, "score": 1 }
-    ]
-  },
-  "coverage": {
-    "runBeforeScan": true,
-    "command": "npx jest --coverage --silent"
-  },
-  "weights": {
-    "BC": 0.25,
-    "CC": 0.15,
-    "ER": 0.15,
-    "ROI": 0.15,
-    "dependencyCount": 0.10,
-    "coverage": 0.20
-  },
-  "thresholds": { "P0": 8.0, "P1": 6.5, "P2": 4.5 },
-  "coverageBoost": { "enable": true, "threshold": 60, "scale": 0.5, "maxBoost": 0.5 },
-  "ccFusion": {
-    "useCognitive": true,
-    "cyclomaticT": 15,
-    "cognitiveT": 25,
-    "wC": 0.7,
-    "wK": 0.3,
-    "cap": 10
-  },
-  "ccAdjust": {
-    "depthW": 0.2,
-    "branchesW": 0.2,
-    "paramsW": 0.1,
-    "locBonusThreshold": 50,
-    "locBonus": 1
-  },
-  "bcKeywords": {
-    "10": ["price", "booking", "payment", "checkout"],
-    "9": ["recommend", "search"],
-    "8": ["filter", "list"],
-    "7": ["login", "order", "config"],
-    "5": ["navigation", "seo", "header"],
-    "3": ["log", "trace", "decor"]
-  },
-  "mainChainPaths": [],
-  "bcCapForNonMainChain": 8,
-  "ccMapping": {
-    "cyclomatic": [
-      { "gt": 15, "score": 10 },
-      { "gte": 11, "lte": 15, "score": 10 },
-      { "gte": 6, "lte": 10, "score": 9 },
-      { "gte": 3, "lte": 5, "score": 7 },
-      { "lte": 2, "score": 6 }
-    ],
-    "adjustments": [
-      { "field": "maxDepth", "op": ">=", "value": 4, "delta": 1 },
-      { "field": "branches", "op": ">=", "value": 12, "delta": 1 },
-      { "field": "params", "op": ">=", "value": 6, "delta": 1 },
-      { "field": "statements", "op": ">=", "value": 80, "delta": 1 },
-      { "field": "cognitive", "op": ">=", "value": 25, "delta": 1 }
-    ],
-    "cap": 10,
-    "platformAdjust": { "delta": 1, "cap": 10, "skipIfLikelihoodGte": 4 }
-  },
-  "fallbackMapping": {
-    "conditions": [
-      { "gt": 12, "score": 10 },
-      { "gte": 8, "lte": 12, "score": 8 },
-      { "gte": 5, "lte": 7, "score": 6 },
-      { "gte": 3, "lte": 4, "score": 4 },
-      { "lte": 2, "score": 2 }
-    ],
-    "nesting": [{ "gte": 4, "delta": 2 }, { "eq": 3, "delta": 1 }],
-    "earlyReturns": [{ "gte": 4, "delta": 1 }],
-    "paramsOrSources": [
-      { "paramsGte": 6, "delta": 1 },
-      { "sourcesGte": 3, "delta": 1 }
-    ],
-    "cap": 10
-  },
-  "depGraph": {
-    "enable": true,
-    "neighborCategoryBoost": 2,
-    "degreeBoost": 8
-  },
-  "erMatrix": {
-    "5": { "5": 10, "4": 9, "3": 8, "2": 7, "1": 6 },
-    "4": { "5": 9, "4": 8, "3": 7, "2": 6, "1": 5 },
-    "3": { "5": 8, "4": 7, "3": 6, "2": 5, "1": 4 },
-    "2": { "5": 7, "4": 6, "3": 5, "2": 4, "1": 3 },
-    "1": { "5": 6, "4": 5, "3": 4, "2": 3, "1": 2 }
-  },
-  "likelihoodRules": [
-    { "field": "commits30d", "op": ">=", "value": 6, "score": 5 },
-    { "field": "commits30d", "op": "between", "min": 3, "max": 5, "score": 4 },
-    { "field": "commits30d", "op": "between", "min": 1, "max": 2, "score": 3 },
-    { "field": "fallback90d", "op": "gt", "value": 0, "score": 2 },
-    { "field": "fallback180dZero", "op": "eq", "value": true, "score": 1 }
-  ],
-  "boostRules": {
-    "authors30dGte": 3,
-    "crossModule": true,
-    "multiPlatform": true,
-    "cap": 5
-  },
-  "crossModuleCategories": ["components", "hooks", "utils", "services", "pages"],
-  "hintMaps": {
-    "impactLocal": "configs/impact.local.json",
-    "roiLocal": "configs/roi.local.json"
-  },
-  "overrides": "reports/overrides.json",
-  "impactKeywords": {
-    "5": ["payment", "booking", "price"],
-    "4": ["filter", "list", "display"],
-    "3": ["interaction"],
-    "2": ["minor", "ui"],
-    "1": ["decor", "cosmetic"]
-  },
-  "testabilityRules": {
-    "pure": 10,
-    "injectable": 9,
-    "multiContext": 7,
-    "nativeOrNetwork": 5,
-    "needsUI": 3
-  },
-  "dependencyCountMapping": [
-    { "gte": 10, "score": 10 },
-    { "gte": 5, "lt": 10, "score": 10 },
-    { "gte": 3, "lt": 5, "score": 9 },
-    { "gte": 1, "lt": 3, "score": 7 },
-    { "eq": 0, "score": 5 }
-  ],
-  "fallbacks": { "BC": 6, "CC": 6, "ERLikelihood": 3, "Testability": 6 }
-}