ai-unit-test-generator 1.4.6 → 2.0.1

package/CHANGELOG.md

@@ -5,6 +5,137 @@ 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).
 
+## [2.0.0] - 2025-01-11
+
+### 🎉 Major Release: AI-Enhanced Configuration
+
+This is a **major refactor** with breaking changes. The package has been completely restructured to support AI-powered codebase analysis and intelligent scoring configuration.
+
+### 🔥 Hotfix (same day)
+- **Fixed**: AI enhancement logic now correctly applied in `scorer.mjs` scoring loop
+- **Optimized**: File-level import caching in `scanner.mjs` (30-40% performance improvement)
+- **Configurable**: Business entity keywords moved to `aiEnhancement.entityKeywords`
+- **Updated**: README reflects v2.0 architecture
+- **Added**: `matchPattern` helper function for glob pattern matching in AI suggestions
+
+### Added
+
+#### New Commands
+- **`ai-test init`**: Initialize configuration file (was implicit in `scan`)
+- **`ai-test analyze`**: AI-powered codebase analysis
+  - Automatically samples representative code from your codebase
+  - Calls Cursor Agent to analyze business logic and risk patterns
+  - Interactive review UI with category-by-category approval
+  - Generates project-specific scoring suggestions
+  - Supports score adjustment for individual suggestions
+
+#### New Modules
+- **`lib/utils/config-manager.mjs`**: Configuration file management
+- **`lib/utils/scan-manager.mjs`**: Scan result management and staleness detection
+- **`lib/ai/sampler.mjs`**: Intelligent code sampling for AI analysis
+- **`lib/ai/context-builder.mjs`**: Project context extraction (framework, deps)
+- **`lib/ai/analyzer-prompt.mjs`**: Constrained AI analysis prompt builder
+- **`lib/ai/validator.mjs`**: Strict JSON schema validation for AI responses
+- **`lib/ai/reviewer.mjs`**: Interactive suggestion review UI
+- **`lib/ai/config-writer.mjs`**: Safe configuration updates (locked paths protection)
+- **`lib/workflows/init.mjs`**: Init workflow
+- **`lib/workflows/analyze.mjs`**: AI analysis workflow
+- **`lib/workflows/scan.mjs`**: Scan workflow (extracted from CLI)
+- **`lib/workflows/generate.mjs`**: Generate workflow (extracted from CLI)
+
+#### AI Enhancement Configuration
+- Added `aiEnhancement` section to config schema
+  - `businessCriticalPaths`: AI-identified critical business logic paths
+  - `highRiskModules`: AI-identified high-risk modules  
+  - `testabilityAdjustments`: AI-suggested testability modifiers
+- Locked/writable path protection mechanism
+- AI can only write to `aiEnhancement.suggestions`
+- Core scoring rules remain immutable
+
+#### Enhanced Metadata Extraction
+- `lib/core/scanner.mjs` now extracts rich metadata:
+  - Critical imports (payment, auth, API libraries)
+  - Business entity types (Payment, Order, Booking, etc.)
+  - JSDoc documentation
+  - Error handling patterns (try-catch count)
+  - External API calls (fetch, axios)
+  - Return types and parameter types
+
+### Changed
+
+#### Breaking Changes
+- **CLI Structure**: Removed implicit config creation from `scan`, added explicit `init` command
+- **Command Workflow**: Now requires `ai-test init` before other commands
+- **Module Structure**: Reorganized `lib/` directory with clear separation:
+  - `core/`: AST, Git, Scoring
+  - `ai/`: Analysis & Test Generation
+  - `workflows/`: High-level orchestration
+  - `utils/`: Shared utilities
+  - `testing/`: Test running & analysis
+- **Config Schema**: Added `aiEnhancement` section (backward compatible)
+
+#### Improvements
+- **CLI Simplification**: `bin/cli.js` now purely delegates to workflow modules
+- **Better Error Messages**: More helpful hints when config is missing
+- **Modular Design**: Each workflow is independently importable
+- **Type Safety**: All modules use ESM with proper exports
+
+### Architecture
+
+```
+User Workflow:
+  1. ai-test init      → Create config
+  2. ai-test analyze   → AI analysis (optional)
+  3. ai-test scan      → Scan & score
+  4. ai-test generate  → Generate tests
+
+Module Hierarchy:
+  bin/cli.js
+    ↓
+  lib/workflows/     (init, analyze, scan, generate)
+    ↓
+  lib/core/         (scanner, scorer, git-analyzer)
+  lib/ai/           (sampler, validator, reviewer, etc.)
+  lib/utils/        (config-manager, scan-manager)
+```
+
+### Migration Guide
+
+For users upgrading from v1.x:
+
+1. **Config file**: Your existing `ai-test.config.jsonc` will continue to work
+2. **New workflow**:
+   ```bash
+   # Old (v1.x)
+   ai-test scan          # Would create config if missing
+   
+   # New (v2.0)
+   ai-test init          # Explicit init step
+   ai-test analyze       # Optional: Let AI optimize config
+   ai-test scan          # Scan with AI enhancements
+   ```
+3. **AI features are optional**: If you don't run `analyze`, scoring works exactly as before
+4. **Programmatic API**: Can now import workflows directly:
+   ```js
+   import { init, analyze, scan, generate } from 'ai-unit-test-generator/workflows'
+   ```
+
+### Technical Details
+
+- **AI Prompt Engineering**: Highly constrained prompts with strict JSON schema
+- **Validation**: Multi-layer validation (schema, confidence thresholds, evidence requirements)
+- **Safety**: Locked configuration paths prevent AI from modifying core scoring logic
+- **Interactive UX**: Category-by-category review with score adjustment support
+- **Token Optimization**: Intelligent code sampling (max 25 files, 1500 chars each)
+
+### Credits
+
+- Inspired by Meta's TestGen-LLM for assurance filters
+- Scoring methodology based on software testing research
+- Built on top of `ts-morph` for robust AST analysis
+
+---
+
 ## [1.4.6] - 2025-01-11
 
 ### Fixed

package/README.md

@@ -379,27 +379,52 @@ ai-unit-test-generator/
 ├── bin/
 │   └── cli.js                    # CLI entry point
 ├── lib/
-│   ├── core/
-│   │   ├── scanner.mjs          # Code scanning
-│   │   ├── git-analyzer.mjs     # Git history analysis
-│   │   └── scorer.mjs           # Scoring engine
-│   ├── ai/
-│   │   ├── prompter.mjs         # AI prompt generation
-│   │   ├── generator.mjs        # Cursor Agent invocation
-│   │   └── extractor.mjs        # Test extraction
-│   ├── testing/
-│   │   ├── runner.mjs           # Jest runner
-│   │   └── analyzer.mjs         # Failure analysis
-│   ├── workflows/
-│   │   └── batch.mjs            # Batch processing workflow
-│   └── utils/
-│       ├── file.mjs             # File operations
-│       ├── status.mjs           # Status management
-│       └── deps.mjs             # Dependency analysis
+│   ├── core/                     # 核心分析层（无 AI 依赖）
+│   │   ├── scanner.mjs          # AST 扫描 + 元数据提取
+│   │   ├── git-analyzer.mjs     # Git 历史分析
+│   │   ├── scorer.mjs           # 评分引擎 + AI 增强
+│   │   └── index.mjs            # 模块导出
+│   ├── ai/                       # AI 交互层
+│   │   ├── sampler.mjs          # 智能代码采样
+│   │   ├── context-builder.mjs  # 项目上下文构建
+│   │   ├── analyzer-prompt.mjs  # AI 分析 Prompt
+│   │   ├── validator.mjs        # 响应验证
+│   │   ├── reviewer.mjs         # 交互式审核 UI
+│   │   ├── config-writer.mjs    # 安全配置写入
+│   │   ├── prompt-builder.mjs   # 测试生成 Prompt
+│   │   ├── client.mjs           # Cursor Agent 调用
+│   │   ├── extractor.mjs        # 测试提取
+│   │   └── index.mjs            # 模块导出
+│   ├── testing/                  # 测试执行层
+│   │   ├── runner.mjs           # Jest 运行器
+│   │   ├── analyzer.mjs         # 失败分析
+│   │   ├── coverage-runner.mjs  # 覆盖率分析
+│   │   └── index.mjs            # 模块导出
+│   ├── workflows/                # 工作流编排层
+│   │   ├── init.mjs             # 初始化工作流
+│   │   ├── analyze.mjs          # AI 分析工作流
+│   │   ├── scan.mjs             # 扫描工作流
+│   │   ├── generate.mjs         # 生成工作流
+│   │   ├── batch.mjs            # 批处理
+│   │   ├── all.mjs              # 全自动
+│   │   └── index.mjs            # 模块导出
+│   ├── utils/                    # 工具层
+│   │   ├── config-manager.mjs   # 配置管理
+│   │   ├── scan-manager.mjs     # 扫描管理
+│   │   ├── marker.mjs           # 状态标记
+│   │   └── index.mjs            # 模块导出
+│   └── index.mjs                 # 根导出
 └── templates/
-    └── default.config.jsonc      # Default config template
+    └── default.config.jsonc      # 默认配置模板
 ```
 
+### Architecture Principles
+
+- **Layered Design**: Clear separation between core analysis, AI interaction, testing, and workflows
+- **Zero AI Dependency in Core**: `lib/core/` can be used without AI features
+- **Modular Exports**: Each layer has `index.mjs` for clean API
+- **Programmatic API**: All workflows can be imported and used programmatically
+
 ## 🤝 Contributing
 
 Contributions are welcome! Please submit issues or pull requests.

package/bin/cli.js

@@ -1,248 +1,137 @@
 #!/usr/bin/env node
 
+/**
+ * AI-Unit-Test-Generator CLI
+ * 
+ * Commands:
+ *   init     - Initialize configuration file
+ *   analyze  - AI-powered codebase analysis
+ *   scan     - Scan code and generate priority scoring
+ *   generate - Generate unit tests
+ */
+
 import { program } from 'commander'
 import { fileURLToPath } from 'url'
-import { dirname, join, resolve } from 'path'
-import { existsSync, copyFileSync, mkdirSync, readFileSync } from 'fs'
-import { spawn } from 'child_process'
+import { dirname, join } from 'path'
+import { readFileSync } from 'fs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
-const PKG_ROOT = resolve(__dirname, '..')
-
-// 辅助函数：移除 JSON 注释
-function stripJsonComments(str) {
-  return String(str)
-    .replace(/\/\*[\s\S]*?\*\//g, '')
-    .replace(/(^|\s)\/\/.*$/gm, '')
-}
+const PKG_ROOT = join(__dirname, '..')
 
-// 读取 package.json 版本
+// 读取版本号
 const pkgJson = JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf-8'))
 
 program
   .name('ai-test')
   .description('AI-powered unit test generator with smart priority scoring')
   .version(pkgJson.version)
+  .addHelpText('after', `
+Quick Start:
+  1. $ ai-test init              # Create config file
+  2. $ ai-test analyze           # Let AI analyze your codebase (optional)
+  3. $ ai-test scan              # Scan & score functions
+  4. $ ai-test generate          # Generate tests
+
+Examples:
+  $ ai-test init
+  $ ai-test analyze
+  $ ai-test scan --skip-git
+  $ ai-test generate -n 20 --all
+
+Documentation: https://github.com/YuhengZhou/ai-unit-test-generator
+  `)
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// 命令 1: init - 初始化配置
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+program
+  .command('init')
+  .description('Initialize ai-test configuration file')
+  .option('-c, --config <path>', 'Config file path', 'ai-test.config.jsonc')
+  .action(async (options) => {
+    const { init } = await import('../lib/workflows/init.mjs')
+    await init(options)
+  })
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// 命令 2: analyze - AI 配置分析
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+program
+  .command('analyze')
+  .description('AI-powered codebase analysis for scoring optimization')
+  .option('-c, --config <path>', 'Config file path')
+  .option('-o, --output <dir>', 'Output directory', 'reports')
+  .addHelpText('after', `
+How it works:
+  1. Samples representative code from your codebase
+  2. Calls Cursor Agent to analyze business logic
+  3. Generates scoring suggestions (business critical paths, high risk modules)
+  4. Interactive review - you choose which suggestions to apply
+  5. Updates ai-test.config.jsonc with approved suggestions
+
+Note: Requires cursor-agent CLI to be installed
+  `)
+  .action(async (options) => {
+    const { analyze } = await import('../lib/workflows/analyze.mjs')
+    await analyze(options)
+  })
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// 命令 1: scan - 扫描代码并生成优先级报告
+// 命令 3: scan - 扫描代码并打分
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 program
   .command('scan')
   .description('Scan code and generate priority scoring report')
-  .option('-c, --config <path>', 'Config file path', 'ai-test.config.jsonc')
+  .option('-c, --config <path>', 'Config file path')
   .option('-o, --output <dir>', 'Output directory', 'reports')
   .option('--skip-git', 'Skip Git signals generation')
+  .addHelpText('after', `
+Generates:
+  - reports/targets.json       (AST + complexity data)
+  - reports/git_signals.json   (Git history signals)
+  - reports/ut_scores.md       (Human-readable report)
+  - reports/ut_scores.csv      (Machine-readable scores)
+
+Scoring modes:
+  - Layered: Different weights for each layer (foundation, business, state, UI)
+  - Legacy: Unified weights across all code
+
+AI enhancement:
+  - If you ran 'ai-test analyze', scores will automatically use AI suggestions
+  - AI-identified business critical paths get higher priority
+  `)
   .action(async (options) => {
-    let { config, output, skipGit } = options
-
-    // 自动探测现有配置 & 初始化（不存在则创建）
-    const detectOrder = [config, 'ai-test.config.jsonc', 'ai-test.config.json']
-    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.jsonc')
-      copyFileSync(templatePath, config)
-      console.log(`✅ Config created: ${config}\n`)
-    }
-
-    // 创建输出目录
-    if (!existsSync(output)) {
-      mkdirSync(output, { recursive: true })
-    }
-
-    // 可选：在扫描前自动运行覆盖率（由配置控制）
-    try {
-      const cfgText = existsSync(config) ? readFileSync(config, 'utf-8') : '{}'
-      const cfg = JSON.parse(stripJsonComments(cfgText))
-      const covCfg = cfg?.coverage || { runBeforeScan: false }
-      if (covCfg.runBeforeScan) {
-        console.log('🧪 Running coverage before scan...')
-        await new Promise((resolve) => {
-          const cmd = covCfg.command || 'npx jest --coverage --silent'
-          const child = spawn(cmd, { stdio: 'inherit', shell: true, cwd: process.cwd() })
-          // 即使失败也继续（有些测试可能失败，但仍能生成部分覆盖率数据）
-          child.on('close', () => resolve())
-          child.on('error', () => resolve())
-        })
-        console.log('✅ Coverage analysis completed.\n')
-      }
-    } catch (err) {
-      console.warn('⚠️  Coverage step failed or Jest not installed. Skipping coverage and continuing scan.')
-      console.warn('    - npm i -D jest@29 ts-jest@29 @types/jest@29 jest-environment-jsdom@29 --legacy-peer-deps')
-    }
-
-    console.log('🚀 Starting code scan...\n')
-
-    try {
-      // Step 1: 生成目标列表
-      console.log('📋 Step 1: Scanning targets...')
-      await runScript('core/scanner.mjs', [
-        '--config', config,
-        '--out', join(output, 'targets.json')
-      ])
-
-      // Step 2: 生成 Git 信号 (可选)
-      if (!skipGit) {
-        console.log('\n📊 Step 2: Analyzing Git history...')
-        await runScript('core/git-analyzer.mjs', [
-          '--targets', join(output, 'targets.json'),
-          '--out', join(output, 'git_signals.json')
-        ])
-      }
-
-      // Step 3: 运行评分（保留现有状态）
-      console.log('\n🎯 Step 3: Scoring targets...')
-      const scoreArgs = [
-        '--targets', join(output, 'targets.json'),
-        '--config', config,
-        '--out-md', join(output, 'ut_scores.md'),
-        '--out-csv', join(output, 'ut_scores.csv')
-      ]
-      if (!skipGit && existsSync(join(output, 'git_signals.json'))) {
-        scoreArgs.push('--git', join(output, 'git_signals.json'))
-      }
-      await runScript('core/scorer.mjs', scoreArgs)
-
-      // 统计 TODO/DONE
-      const reportPath = join(output, 'ut_scores.md')
-      if (existsSync(reportPath)) {
-        const content = readFileSync(reportPath, 'utf-8')
-        const todoCount = (content.match(/\| TODO \|/g) || []).length
-        const doneCount = (content.match(/\| DONE \|/g) || []).length
-        
-        console.log('\n✅ Scan completed!')
-        console.log(`\n📊 Status:`)
-        console.log(`   TODO: ${todoCount}`)
-        console.log(`   DONE: ${doneCount}`)
-        console.log(`   Total: ${todoCount + doneCount}`)
-        console.log(`\n📄 Report: ${reportPath}`)
-        console.log(`\n💡 Next: ai-test generate`)
-      }
-    } catch (err) {
-      console.error('❌ Scan failed:', err.message)
-      process.exit(1)
-    }
+    const { scan } = await import('../lib/workflows/scan.mjs')
+    await scan(options)
   })
 
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// 命令 2: generate - 生成测试
+// 命令 4: generate - 生成测试
 // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 program
   .command('generate')
-  .description('Generate tests (default: 10 TODO functions)')
+  .description('Generate unit tests for untested functions')
   .option('-n, --count <number>', 'Number of functions to generate', parseInt, 10)
   .option('-p, --priority <level>', 'Priority filter (P0, P1, P2, P3)', 'P0')
   .option('--all', 'Generate all remaining TODO functions')
   .option('--report <path>', 'Report file path', 'reports/ut_scores.md')
+  .addHelpText('after', `
+Examples:
+  $ ai-test generate                 # Generate 10 P0 functions
+  $ ai-test generate -n 20           # Generate 20 P0 functions
+  $ ai-test generate -p P1 -n 15     # Generate 15 P1 functions
+  $ ai-test generate --all           # Generate all P0 TODO functions
+
+Features:
+  - Automatic test generation using Cursor Agent
+  - Jest integration with coverage tracking
+  - Failure retry with hints
+  - Auto-marking DONE on success
+  `)
   .action(async (options) => {
-    const { count, priority, all, report } = options
-
-    // 检查报告是否存在
-    if (!existsSync(report)) {
-      console.error(`❌ Report not found: ${report}`)
-      console.log(`   Run: ai-test scan`)
-      process.exit(1)
-    }
-
-    if (all) {
-      // 持续生成直到所有 TODO 完成
-      console.log(`🚀 Generating all ${priority} TODO functions...\n`)
-      
-      let batchNum = 1
-      let totalGenerated = 0
-      let totalPassed = 0
-      
-      while (true) {
-        // 检查还有多少 TODO
-        const content = readFileSync(report, 'utf-8')
-        const lines = content.split('\n')
-        const todoLines = lines.filter(line => 
-          line.includes('| TODO |') && line.includes(`| ${priority} |`)
-        )
-        
-        if (todoLines.length === 0) {
-          console.log(`\n✅ All ${priority} functions completed!`)
-          console.log(`   Total generated: ${totalGenerated}`)
-          console.log(`   Total passed: ${totalPassed}`)
-          break
-        }
-        
-        console.log(`\n━━━━ Batch ${batchNum} (${todoLines.length} TODO remaining) ━━━━`)
-        
-        try {
-          const result = await generateBatch(priority, Math.min(count, todoLines.length), 0, report)
-          totalGenerated += result.generated
-          totalPassed += result.passed
-          batchNum++
-        } catch (err) {
-          console.error(`❌ Batch ${batchNum} failed:`, err.message)
-          break
-        }
-      }
-    } else {
-      // 生成指定数量
-      console.log(`🚀 Generating ${count} ${priority} functions...\n`)
-      try {
-        await generateBatch(priority, count, 0, report)
-      } catch (err) {
-        console.error('❌ Generation failed:', err.message)
-        process.exit(1)
-      }
-    }
-  })
-
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-// 辅助函数
-// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-/**
- * 生成单批测试
- */
-async function generateBatch(priority, count, skip, report) {
-  const batchScript = join(PKG_ROOT, 'lib/workflows/batch.mjs')
-  
-  return new Promise((resolve, reject) => {
-    const child = spawn('node', [batchScript, priority, String(count), String(skip), report], {
-      stdio: 'inherit',
-      cwd: process.cwd()
-    })
-    
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve({ generated: count, passed: count }) // TODO: 从 batch 输出获取实际数字
-      } else {
-        reject(new Error(`Batch generation failed with code ${code}`))
-      }
-    })
-    
-    child.on('error', reject)
-  })
-}
-
-/**
- * 运行脚本
- */
-function runScript(scriptPath, args) {
-  return new Promise((resolve, reject) => {
-    const fullPath = join(PKG_ROOT, 'lib', scriptPath)
-    const child = spawn('node', [fullPath, ...args], {
-      stdio: 'inherit',
-      cwd: process.cwd()
-    })
-
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve()
-      } else {
-        reject(new Error(`Script ${scriptPath} exited with code ${code}`))
-      }
-    })
-
-    child.on('error', reject)
+    const { generate } = await import('../lib/workflows/generate.mjs')
+    await generate(options)
   })
-}
 
 program.parse()

package/lib/ai/analyzer-prompt.mjs

@@ -0,0 +1,120 @@
+/**
+ * AI 分析 Prompt 构建器
+ */
+
+/**
+ * 构建分析 Prompt
+ */
+export function buildAnalysisPrompt(samples, stats, projectCtx) {
+  return `You are analyzing a ${projectCtx.framework} codebase to identify business-critical paths and high-risk modules.
+
+## 📊 Project Overview
+
+- **Framework**: ${projectCtx.framework}
+- **Total Files**: ${stats.totalFiles}
+- **Total Lines**: ${stats.totalLines}
+- **Key Dependencies**: ${projectCtx.criticalDeps.join(', ') || 'None detected'}
+
+## 📂 Code Samples (${samples.length} files)
+
+${samples.map((s, i) => `
+### Sample ${i + 1}: ${s.path}
+**Layer**: ${s.layer}
+**Reason**: ${s.reason}
+
+\`\`\`typescript
+${s.preview}
+\`\`\`
+`).join('\n')}
+
+## 🎯 Your Task
+
+**YOU HAVE ACCESS TO THE FULL CODEBASE** via Cursor's indexing. The samples above are just for quick reference.
+
+Please analyze the ENTIRE codebase (not just the samples) and suggest:
+
+1. **businessCriticalPaths**: Which paths handle core business logic?
+   - Look for: payment, booking, pricing, checkout, order processing
+   - Use your codebase index to find all relevant files
+   
+2. **highRiskModules**: Which modules have high error risk?
+   - Look for: date/time handling, external APIs, money calculations, parsing
+   - Check for complex logic, many try-catch blocks
+   
+3. **testabilityAdjustments**: Which paths are easier/harder to test?
+   - Look for: pure functions (easier), heavy dependencies (harder)
+   - Consider side effects, I/O operations
+
+## 💡 Use Your Codebase Knowledge
+
+- You can search the codebase using @codebase
+- You know the full dependency graph
+- You understand the business logic from code context
+
+## OUTPUT SCHEMA
+
+\`\`\`json
+{
+  "suggestions": {
+    "businessCriticalPaths": [
+      {
+        "pattern": "services/payment/**",
+        "confidence": 0.95,
+        "reason": "Handles Stripe payment processing",
+        "suggestedBC": 10,
+        "evidence": [
+          "Contains processPayment function with Stripe API calls",
+          "Referenced by checkout flow in multiple places",
+          "Handles money transactions"
+        ]
+      }
+    ],
+    "highRiskModules": [
+      {
+        "pattern": "utils/date/**",
+        "confidence": 0.88,
+        "reason": "Complex timezone and date calculations",
+        "suggestedER": 8,
+        "evidence": [
+          "Multiple timezone conversion functions",
+          "Handles daylight saving time"
+        ]
+      }
+    ],
+    "testabilityAdjustments": [
+      {
+        "pattern": "utils/**",
+        "confidence": 0.92,
+        "reason": "Pure utility functions with no side effects",
+        "adjustment": "+1",
+        "evidence": [
+          "All exports are pure functions",
+          "No external dependencies observed"
+        ]
+      }
+    ]
+  }
+}
+\`\`\`
+
+## CRITICAL RULES
+
+1. **Output ONLY JSON** - No explanations, no markdown wrapper
+2. **Match Schema Exactly** - Any deviation will be rejected
+3. **Stay Within Bounds** - All scores must be within specified ranges
+4. **Require Evidence** - Each suggestion needs 2-3 concrete evidence points
+5. **No Assumptions** - Only suggest what you can directly observe
+
+## CONSTRAINTS
+
+- confidence ≥ 0.70 (businessCriticalPaths ≥ 0.85)
+- 2-3 evidence items per suggestion
+- Pattern must match actual paths in codebase
+- Max 10 suggestions per category
+- suggestedBC: 8 | 9 | 10
+- suggestedER: 7 | 8 | 9 | 10
+- adjustment: "-2" | "-1" | "+1" | "+2"
+
+Output ONLY the JSON, no explanation.`
+}
+