devassist-agent 1.0.2 → 1.0.4

package/bin/devassist.js

@@ -166,7 +166,7 @@ function printHelp() {
   printHeader('开发守护 CLI');
   console.log(`${c.bold('用法：')} devassist <命令> [选项]\n`);
   console.log(`${c.bold('命令：')}`);
-  console.log(`  ${c.green('start')}                 一键启动：自动初始化 + AI多引擎实时监控`);
+  console.log(`  ${c.green('start')}                 一键启动：自动初始化 + AI双引擎实时监控 + 自动修复`);
   console.log(`  ${c.green('init')}                  初始化项目——创建 .devassist/ 配置与基础代码`);
   console.log(`  ${c.green('check')}                 运行全部开发时检查（代码质量 + 约定 + 模式 + 架构）`);
   console.log(`  ${c.green('watch')}                 实时监控文件变更并运行检查`);
@@ -189,18 +189,19 @@ function printHelp() {
   console.log(`  ${c.gray('--ai')}                启用 AI 深度分析（需配置）`);
   console.log(`  ${c.gray('--compare')}           多引擎对比分析（所有引擎并行）`);
   console.log(`  ${c.gray('--json')}              输出 JSON 格式（用于 CI 集成）`);
+  console.log(`  ${c.gray('--fix')}               自动修复安全项（watch 模式下生效）`);
   console.log(`  ${c.gray('--fail-on <级别>')}    在以下级别非零退出：block（默认）或 warn`);
   console.log(`  ${c.gray('--base-code')}         安装运行时基础设施（Layer 2）`);
   console.log(`  ${c.gray('--force')}             覆盖已有配置`);
   console.log(`  ${c.gray('-v, --version')}       显示版本`);
   console.log(`  ${c.gray('-h, --help')}          显示帮助\n`);
   console.log(`${c.bold('示例：')}`);
-  console.log(`  ${c.gray('$')} devassist start                # 一键启动（自动init+AI多引擎监控）`);
+  console.log(`  ${c.gray('$')} devassist start                # 一键启动（自动init+AI双引擎+自动修复）`);
   console.log(`  ${c.gray('$')} devassist start --check        # 一键检查（不启动监控）`);
   console.log(`  ${c.gray('$')} devassist init`);
   console.log(`  ${c.gray('$')} devassist check --ai`);
   console.log(`  ${c.gray('$')} devassist watch              # 开发时实时监控`);
-  console.log(`  ${c.gray('$')} devassist watch --ai --compare # 实时监控+AI多引擎对比`);
+  console.log(`  ${c.gray('$')} devassist watch --ai --compare --fix  # 全自动：检测+AI+修复`);
   console.log(`  ${c.gray('$')} devassist diff --staged       # 提交前检查暂存文件`);
   console.log(`  ${c.gray('$')} devassist report --open       # 生成并查看 HTML 报告`);
   console.log(`  ${c.gray('$')} devassist convention add --id naming-list --rule "使用 data.list 而非 data.items" --severity block`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devassist-agent",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "AI Agent 开发质量守护工具 — 30+规则检测代码缺陷/安全漏洞/性能反模式，多引擎AI根因分析，零外部依赖",
   "main": "src/index.js",
   "bin": {

package/src/cli/commands/start.js

@@ -3,12 +3,13 @@
  *
  * Automatically:
  *   1. Initialize project (if not already initialized)
- *   2. Verify AI config (global or project-level)
+ *   2. Verify AI config (global or project-level, with real API keys)
  *   3. Start watch mode with --ai --compare
  *
  * Usage:
- *   devassist start              # Full auto: init + watch --ai --compare
+ *   devassist start              # Full auto: init + watch --ai --compare --fix
  *   devassist start --no-ai      # Init + watch (rules only, no AI)
+ *   devassist start --no-fix     # Init + watch --ai --compare (no auto-fix)
  *   devassist start --check      # Init + one-time check --ai --compare (no watch)
  */
 
@@ -20,6 +21,7 @@ module.exports = async function start(projectRoot, args, ui) {
   const { printHeader, printFinding, printStats, c } = ui;
 
   const noAI = args.includes('--no-ai');
+  const noFix = args.includes('--no-fix');
   const checkOnly = args.includes('--check');
 
   printHeader('一键启动');
@@ -36,26 +38,31 @@ module.exports = async function start(projectRoot, args, ui) {
   }
 
   // ─── Step 2: Verify AI config ─────────────────────
-  const projectAIConfig = path.join(projectRoot, '.devassist', 'ai-config.json');
-  const globalAIConfig = path.join(os.homedir(), '.devassist', 'ai-config.json');
+  // Use loadAIConfig to check if real API keys are configured
+  const aiCmd = require('./ai');
+  const config = aiCmd.loadAIConfig(projectRoot);
+  const readyEngines = config ? config.engines.filter(e => e.enabled && e.apiKey) : [];
+  const aiReady = readyEngines.length >= 2;
 
-  let aiReady = false;
-  let configSource = '';
-
-  if (fs.existsSync(projectAIConfig)) {
-    aiReady = true;
-    configSource = '项目配置';
-  } else if (fs.existsSync(globalAIConfig)) {
-    aiReady = true;
-    configSource = '全局配置';
-  }
+  // Determine config source
+  const projectConfigPath = path.join(projectRoot, '.devassist', 'ai-config.json');
+  const globalConfigPath = path.join(os.homedir(), '.devassist', 'ai-config.json');
+  const configSource = fs.existsSync(projectConfigPath) ? '项目配置' :
+                       (fs.existsSync(globalConfigPath) ? '全局配置' : '');
 
   if (aiReady && !noAI) {
-    console.log(`  ${c.green('2/3')} AI 引擎已就绪 ✓ (${configSource}：通义千问 + 腾讯混元)`);
-  } else if (!aiReady && !noAI) {
+    const engineNames = readyEngines.map(e => e.name || e.provider).join(' + ');
+    console.log(`  ${c.green('2/3')} AI 引擎已就绪 ✓ (${configSource}：${engineNames})`);
+    if (!noFix) {
+      console.log(`         ${c.gray('自动修复已启用（--fix）')}`);
+    }
+  } else if (readyEngines.length === 1 && !noAI) {
+    console.log(`  ${c.green('2/3')} AI 引擎已就绪 ✓ (${configSource}：${readyEngines[0].name}，仅单引擎)`);
+    console.log(`         ${c.gray('提示：配置第二个引擎可启用对比模式')}`);
+  } else if (!noAI) {
     console.log(`  ${c.yellow('2/3')} 未检测到 AI 配置`);
-    console.log(`         ${c.gray('将仅使用规则引擎检查（28条规则）')}`);
-    console.log(`         ${c.gray('配置 AI 后可启用多引擎对比：devassist ai --setup --provider qwen --key <key>')}`);
+    console.log(`         ${c.gray('将仅使用规则引擎检查（30条规则）')}`);
+    console.log(`         ${c.gray('配置 AI：devassist ai --setup --provider qwen --key <key>')}`);
     noAI = true; // fallback to rules-only
   } else {
     console.log(`  ${c.green('2/3')} 规则引擎模式 ✓`);
@@ -77,6 +84,9 @@ module.exports = async function start(projectRoot, args, ui) {
     if (!noAI) {
       watchArgs.push('--ai', '--compare');
     }
+    if (!noFix) {
+      watchArgs.push('--fix');
+    }
     await watchCmd(projectRoot, watchArgs, ui);
   }
 };

package/src/cli/commands/watch.js

@@ -1,18 +1,20 @@
 /**
- * devassist watch - Real-time file monitoring
+ * devassist watch - Real-time file monitoring with full automation
  *
  * Watches project files for changes and runs checks on modified files.
- * Provides instant feedback during AI-assisted development.
+ * With --ai flag, automatically runs AI analysis on findings.
+ * With --compare flag, runs multi-engine comparison.
+ * With --fix flag, automatically applies safe fixes.
  *
  * Usage:
- *   devassist watch              # Watch all source files
- *   devassist watch --ai         # Watch + AI analysis on findings
- *   devassist watch --dir src    # Watch specific directory
+ *   devassist watch                    # Watch all source files (rules only)
+ *   devassist watch --ai               # Watch + AI analysis on findings
+ *   devassist watch --ai --compare     # Watch + multi-engine comparison
+ *   devassist watch --ai --compare --fix  # Full auto: detect + AI + fix
  */
 
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
 
 // Core
 const { engine, RuleEngine } = require('../../core/rule-engine');
@@ -25,14 +27,29 @@ const { ArchRiskAssessor } = require('../../modules/dev-time/arch-risk-assessor'
 // Shared utilities
 const { loadConfig } = require('../shared/config-loader');
 const { filterIgnored } = require('../shared/inline-ignore');
+const { enrichWithContext } = require('../shared/code-context');
+
+// AI
+const ai = require('../../ai/adapter');
+const qwen = require('../../ai/providers/qwen');
+const openai = require('../../ai/providers/openai');
+const claude = require('../../ai/providers/claude');
+const hunyuan = require('../../ai/providers/hunyuan');
+
+// Register AI providers
+ai.registerProvider('qwen', qwen);
+ai.registerProvider('openai', openai);
+ai.registerProvider('claude', claude);
+ai.registerProvider('hunyuan', hunyuan);
 
 const CODE_EXTENSIONS = /\.(js|ts|jsx|tsx|py|java)$/;
 const SKIP_DIRS = ['node_modules', '.git', '.devassist', 'dist', 'build', 'vendor', '.gradle', '__pycache__'];
 
 module.exports = async function watch(projectRoot, args, ui) {
-  const { printHeader, printFinding, c } = ui;
+  const { printHeader, printFinding, printStats, c } = ui;
   const useAI = args.includes('--ai');
   const useCompare = args.includes('--compare');
+  const autoFix = args.includes('--fix');
   const watchDir = args.includes('--dir') ? args[args.indexOf('--dir') + 1] : null;
 
   printHeader('监控模式');
@@ -40,6 +57,7 @@ module.exports = async function watch(projectRoot, args, ui) {
   console.log(`  ${c.gray('监控目录：')} ${watchDir || '整个项目'}`);
   console.log(`  ${c.gray('AI 分析：')} ${useAI ? '已启用' : '已禁用'}`);
   console.log(`  ${c.gray('多引擎对比：')} ${useCompare ? '已启用' : '已禁用'}`);
+  console.log(`  ${c.gray('自动修复：')} ${autoFix ? '已启用' : '已禁用'}`);
   console.log(`  ${c.gray('按 Ctrl+C 停止')}\n`);
 
   // Initialize convention store
@@ -62,9 +80,28 @@ module.exports = async function watch(projectRoot, args, ui) {
     }
   });
 
+  // Load AI config (global or project-level)
+  let aiConfig = null;
+  let readyEngines = [];
+  if (useAI) {
+    const { loadAIConfig } = require('./ai');
+    aiConfig = loadAIConfig(projectRoot);
+    if (aiConfig && aiConfig.engines) {
+      readyEngines = aiConfig.engines.filter(e => e.enabled && e.apiKey);
+    }
+    if (readyEngines.length === 0) {
+      console.log(`  ${c.yellow('警告：')} 未检测到可用的 AI 引擎，将仅使用规则引擎\n`);
+    } else if (useCompare && readyEngines.length < 2) {
+      console.log(`  ${c.yellow('提示：')} 对比模式需要 2+ 引擎，当前仅 ${readyEngines.length} 个，将使用单引擎\n`);
+    } else {
+      console.log(`  ${c.green('AI 引擎就绪：')} ${readyEngines.map(e => e.name || e.provider).join(' + ')}\n`);
+    }
+  }
+
   // Track watchers for cleanup
   const watchers = [];
   const debounceTimers = new Map();
+  const analyzingFiles = new Set(); // Lock: prevent overlapping AI analysis on same file
 
   // Watch a single file
   function watchFile(filePath) {
@@ -72,14 +109,17 @@ module.exports = async function watch(projectRoot, args, ui) {
       const watcher = fs.watch(filePath, { persistent: true }, (eventType) => {
         if (eventType !== 'change') return;
 
-        // Debounce: wait 300ms after last change before checking
+        // Debounce: wait 500ms after last change before checking (longer with AI)
+        const debounceMs = useAI ? 500 : 300;
         if (debounceTimers.has(filePath)) {
           clearTimeout(debounceTimers.get(filePath));
         }
         debounceTimers.set(filePath, setTimeout(() => {
           debounceTimers.delete(filePath);
-          checkFile(filePath);
-        }, 300));
+          checkFile(filePath).catch(err => {
+            console.log(`  ${c.red('检查出错：')} ${err.message}`);
+          });
+        }, debounceMs));
       });
       watcher.on('error', () => {});
       watchers.push(watcher);
@@ -102,61 +142,144 @@ module.exports = async function watch(projectRoot, args, ui) {
     }
   }
 
-  // Check a single file
-  function checkFile(filePath) {
-    const relPath = path.relative(projectRoot, filePath);
-    const timestamp = new Date().toLocaleTimeString();
+  // Check a single file — async for AI analysis
+  async function checkFile(filePath) {
+    // Skip if already analyzing this file (AI takes time)
+    if (analyzingFiles.has(filePath)) return;
+    analyzingFiles.add(filePath);
 
-    let content = '';
-    try { content = fs.readFileSync(filePath, 'utf-8'); } catch (_) { return; }
+    try {
+      const relPath = path.relative(projectRoot, filePath);
+      const timestamp = new Date().toLocaleTimeString();
 
-    // Quick skip for HTML without script tags
-    if (/\.html?$/.test(filePath) && !/<script[\s>]/i.test(content)) return;
+      let content = '';
+      try { content = fs.readFileSync(filePath, 'utf-8'); } catch (_) { return; }
 
-    const ctx = {
-      files: [{ path: relPath, content, fullPath: filePath }],
-      projectRoot,
-      config: loadConfig(projectRoot),
-    };
+      // Quick skip for HTML without script tags
+      if (/\.html?$/.test(filePath) && !/<script[\s>]/i.test(content)) return;
 
-    const { findings: ruleFindings } = engine.run(ctx);
-    const archFindings = archAssessor.analyzeFile(relPath, content);
-    let allFindings = [...ruleFindings, ...archFindings];
+      const ctx = {
+        files: [{ path: relPath, content, fullPath: filePath }],
+        projectRoot,
+        config: loadConfig(projectRoot),
+      };
 
-    // Apply inline ignores
-    allFindings = filterIgnored(allFindings, [{ path: relPath, content }]);
+      const { findings: ruleFindings } = engine.run(ctx);
+      const archFindings = archAssessor.analyzeFile(relPath, content);
+      let allFindings = [...ruleFindings, ...archFindings];
 
-    // Save findings for ai --analyze
-    saveWatchFindings(projectRoot, allFindings);
+      // Apply inline ignores
+      allFindings = filterIgnored(allFindings, [{ path: relPath, content }]);
 
-    // Print header
-    console.log(`\n  ${c.gray(`[${timestamp}]`)} ${c.bold(relPath)}`);
+      // Save findings for ai --analyze
+      saveWatchFindings(projectRoot, allFindings);
 
-    if (allFindings.length === 0) {
-      console.log(`  ${c.green('OK')} — 未发现问题`);
-      return;
-    }
+      // Print header
+      console.log(`\n  ${c.gray(`[${timestamp}]`)} ${c.bold(relPath)}`);
 
-    // Print findings
-    const blocks = allFindings.filter(f => f.severity === 'block');
-    const warns = allFindings.filter(f => f.severity === 'warn');
-    const infos = allFindings.filter(f => f.severity === 'info');
-
-    for (const f of allFindings) {
-      const icon = f.severity === 'block' ? c.red('[阻断]') :
-                   f.severity === 'warn' ? c.yellow('[警告]') :
-                   c.gray('[提示]');
-      console.log(`  ${icon} ${f.message}`);
-      if (f.line) console.log(`         ${c.gray(`第 ${f.line} 行`)}`);
-      if (f.suggestion) console.log(`         ${c.gray(f.suggestion)}`);
-    }
+      if (allFindings.length === 0) {
+        console.log(`  ${c.green('OK')} — 未发现问题`);
+        return;
+      }
 
-    // Summary
-    const parts = [];
-    if (blocks.length > 0) parts.push(c.red(`${blocks.length} 阻断`));
-    if (warns.length > 0) parts.push(c.yellow(`${warns.length} 警告`));
-    if (infos.length > 0) parts.push(c.gray(`${infos.length} 提示`));
-    console.log(`  ${c.gray('—')} ${parts.join(c.gray(' · '))}`);
+      // --- AI Analysis (if enabled and there are warn/block findings) ---
+      let finalFindings = allFindings;
+      const suspectFindings = allFindings.filter(f => f.severity === 'block' || f.severity === 'warn');
+
+      if (useAI && readyEngines.length > 0 && suspectFindings.length > 0) {
+        console.log(`  ${c.cyan('AI 分析中...')} (${suspectFindings.length} 个疑似问题)`);
+
+        // Enrich with code context
+        const fileContents = [{ path: relPath, content }];
+        finalFindings = enrichWithContext(allFindings, fileContents);
+
+        const aiContext = {
+          conventions: conventionStore.getRelevant({}),
+          projectInfo: { root: projectRoot },
+        };
+
+        try {
+          if (useCompare && readyEngines.length >= 2) {
+            finalFindings = await ai.multiAnalyze(readyEngines, finalFindings, aiContext);
+          } else {
+            finalFindings = await ai.analyze(readyEngines[0], finalFindings, aiContext);
+          }
+        } catch (err) {
+          console.log(`  ${c.yellow('AI 分析失败：')} ${err.message}`);
+          console.log(`  ${c.gray('已回退到规则引擎结果')}`);
+        }
+      }
+
+      // --- Print findings ---
+      const blocks = finalFindings.filter(f => f.severity === 'block');
+      const warns = finalFindings.filter(f => f.severity === 'warn');
+      const infos = finalFindings.filter(f => f.severity === 'info');
+
+      for (const f of finalFindings) {
+        const icon = f.severity === 'block' ? c.red('[阻断]') :
+                     f.severity === 'warn' ? c.yellow('[警告]') :
+                     c.gray('[提示]');
+        console.log(`  ${icon} ${f.message}`);
+        if (f.line) console.log(`         ${c.gray(`第 ${f.line} 行`)}`);
+        if (f.suggestion) console.log(`         ${c.gray(f.suggestion)}`);
+
+        // Print AI analysis if available
+        if (f.aiAnalysis) {
+          const a = f.aiAnalysis;
+          if (a.falsePositive) {
+            console.log(`         ${c.gray('AI 判定：误报 — ' + (a.falsePositiveReason || '不适用'))}`);
+          } else {
+            const rootCause = a.rootCause || a.root_cause || '';
+            const fixSuggestion = a.fixSuggestion || a.fix_suggestion || '';
+            const confidence = a.confidence || '';
+            if (rootCause) console.log(`         ${c.cyan('AI 根因：')} ${rootCause}`);
+            if (fixSuggestion) console.log(`         ${c.cyan('AI 建议：')} ${fixSuggestion}`);
+            if (confidence) console.log(`         ${c.gray(`置信度：${confidence}`)}`);
+          }
+        }
+
+        // Print multi-engine comparison
+        if (f.aiAnalyses && f.aiAnalyses.length >= 2) {
+          for (const ea of f.aiAnalyses) {
+            if (ea.analysis && !ea.failed) {
+              const engineName = ea.engineName || ea.provider;
+              const a = ea.analysis;
+              if (a.falsePositive) {
+                console.log(`         ${c.gray(`[${engineName}] 误报 — ${a.falsePositiveReason || ''}`)}`);
+              } else {
+                const rootCause = a.rootCause || a.root_cause || '';
+                if (rootCause) console.log(`         ${c.cyan(`[${engineName}]`)} ${rootCause}`);
+              }
+            } else if (ea.failed) {
+              console.log(`         ${c.gray(`[${ea.engineName || ea.provider}] 分析失败`)}`);
+            }
+          }
+          // Agreement indicator
+          if (f.aiAnalyses.filter(ea => ea.analysis && !ea.failed && !ea.analysis.falsePositive).length === 0
+              && f.aiAnalyses.filter(ea => ea.analysis && !ea.failed && ea.analysis.falsePositive).length >= 2) {
+            console.log(`         ${c.green('引擎一致：均判定为误报')}`);
+          }
+        }
+      }
+
+      // --- Summary ---
+      const parts = [];
+      if (blocks.length > 0) parts.push(c.red(`${blocks.length} 阻断`));
+      if (warns.length > 0) parts.push(c.yellow(`${warns.length} 警告`));
+      if (infos.length > 0) parts.push(c.gray(`${infos.length} 提示`));
+      console.log(`  ${c.gray('—')} ${parts.join(c.gray(' · '))}`);
+
+      // --- Auto Fix (if enabled) ---
+      if (autoFix && suspectFindings.length > 0) {
+        const fixedCount = await autoFixFile(filePath, content, projectRoot, c);
+        if (fixedCount > 0) {
+          console.log(`  ${c.green('自动修复')} ${fixedCount} 处问题`);
+        }
+      }
+
+    } finally {
+      analyzingFiles.delete(filePath);
+    }
   }
 
   // Start watching
@@ -199,6 +322,78 @@ module.exports = async function watch(projectRoot, args, ui) {
   });
 };
 
+/**
+ * Auto-fix a single file in-place (safe fixes only).
+ * Returns the number of fixes applied.
+ */
+async function autoFixFile(filePath, content, projectRoot, c) {
+  const lines = content.split('\n');
+  let fixCount = 0;
+  const changes = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*(\/\/|\/\*|\*)/.test(line)) continue;
+
+    // Fix 1: fetch() without .catch()
+    if (/\bfetch\s*\(/.test(line)) {
+      const context = lines.slice(i, Math.min(i + 5, lines.length)).join('\n');
+      if (/\.catch\s*\(/.test(context)) continue;
+      const hasAwait = /\bawait\b/.test(line);
+      const hasTryCatch = /try\s*\{/.test(lines.slice(Math.max(0, i - 5), i + 1).join('\n'));
+      if (hasAwait && hasTryCatch) continue;
+
+      const trimmed = line.trimEnd();
+      if (trimmed.endsWith(')') && !trimmed.endsWith('.catch()')) {
+        const fixedLine = trimmed.replace(/\)\s*$/, ").catch(err => console.error('fetch error:', err))");
+        changes.push({ line: i, newLine: fixedLine, type: 'fetch-catch' });
+        fixCount++;
+        continue;
+      }
+    }
+
+    // Fix 2: Add await to async calls (fetch, axios, etc.)
+    if (!/\bawait\b/.test(line)) {
+      const asyncMatch = line.match(/(?<![\w.])(fetch|axios\.(get|post|put|delete|patch)|\.save\(|\.findOne\(|\.findById\(|\.create\()\s*/);
+      if (asyncMatch) {
+        const trimmed = line.trim();
+        if (/^\s*(const|let|var|if|while|return|throw)/.test(trimmed)) continue;
+        if (/^\s*(async\s+)?function\s+/.test(line)) continue;
+        if (/\.then\s*\(|\.catch\s*\(|\.finally\s*\(/.test(line)) continue;
+
+        const fixedLine = line.replace(
+          new RegExp('(?<![\\w.])(' + asyncMatch[1] + '\\w+)\\s*\\('),
+          'await $1('
+        );
+        if (fixedLine !== line) {
+          changes.push({ line: i, newLine: fixedLine, type: 'add-await' });
+          fixCount++;
+          continue;
+        }
+      }
+    }
+  }
+
+  if (fixCount === 0) return 0;
+
+  // Apply changes
+  for (const ch of changes) {
+    lines[ch.line] = ch.newLine;
+  }
+  const newContent = lines.join('\n');
+
+  // Backup original
+  const backupDir = path.join(projectRoot, '.devassist', 'backups', `watch-fix-${Date.now()}`);
+  if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+  const backupPath = path.join(backupDir, path.basename(filePath));
+  fs.writeFileSync(backupPath, content, 'utf-8');
+
+  // Write fixed content
+  fs.writeFileSync(filePath, newContent, 'utf-8');
+
+  return fixCount;
+}
+
 function saveWatchFindings(projectRoot, findings) {
   const reportDir = path.join(projectRoot, '.devassist', 'reports');
   if (!fs.existsSync(reportDir)) fs.mkdirSync(reportDir, { recursive: true });