devassist-agent 1.0.0

package/src/cli/commands/diff.js

@@ -0,0 +1,193 @@
+/**
+ * devassist diff - Check only changed files (CI mode)
+ *
+ * Uses git diff to identify changed files and runs checks only on those.
+ * Ideal for CI/CD pipelines and pre-commit hooks.
+ *
+ * Usage:
+ *   devassist diff                  # Check unstaged changes
+ *   devassist diff --staged         # Check only staged files
+ *   devassist diff --base main      # Compare against branch
+ *   devassist diff --json           # JSON output for CI integration
+ *   devassist diff --fail-on warn   # Exit non-zero on warnings (default: block only)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Core
+const { engine } = require('../../core/rule-engine');
+
+// Modules
+const { ConventionStore } = require('../../modules/dev-time/convention-store');
+const { codeQualityRules } = require('../../modules/dev-time/code-quality-guard');
+const { ArchRiskAssessor } = require('../../modules/dev-time/arch-risk-assessor');
+const { ImpactAnalyzer } = require('../../modules/dev-time/impact-analyzer');
+
+// Shared utilities
+const { loadIgnorePatterns, filterByIgnorePatterns } = require('../shared/file-collector');
+const { loadConfig, applyConfigToFindings } = require('../shared/config-loader');
+const { filterIgnored } = require('../shared/inline-ignore');
+
+const CODE_EXTENSIONS = /\.(js|ts|jsx|tsx|py|java|html)$/;
+
+module.exports = async function diff(projectRoot, args, ui) {
+  const { printHeader, printFinding, printStats, c } = ui;
+  const staged = args.includes('--staged');
+  const jsonOutput = args.includes('--json');
+  const baseBranch = args.includes('--base') ? args[args.indexOf('--base') + 1] : null;
+  const failOn = args.includes('--fail-on') ? args[args.indexOf('--fail-on') + 1] : 'block';
+
+  if (!jsonOutput) printHeader('差异检查');
+
+  // Get changed files from git
+  let changedFiles = [];
+  try {
+    let gitCmd;
+    if (staged) {
+      gitCmd = 'git diff --cached --name-only --diff-filter=ACMR';
+    } else if (baseBranch) {
+      gitCmd = `git diff ${baseBranch}...HEAD --name-only --diff-filter=ACMR`;
+    } else {
+      gitCmd = 'git diff --name-only --diff-filter=ACMR';
+    }
+    const output = execSync(gitCmd, { cwd: projectRoot, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    changedFiles = output ? output.split('\n').filter(f => f) : [];
+  } catch (e) {
+    if (jsonOutput) {
+      console.log(JSON.stringify({ error: '非 Git 仓库或 Git 不可用', findings: [] }));
+    } else {
+      console.log(`  ${c.yellow('非 Git 仓库或未检测到变更。')}\n`);
+    }
+    return;
+  }
+
+  // Filter to code files that exist
+  changedFiles = changedFiles.filter(f => {
+    if (!CODE_EXTENSIONS.test(f)) return false;
+    const fullPath = path.join(projectRoot, f);
+    return fs.existsSync(fullPath);
+  });
+
+  // Also skip files in ignored directories
+  changedFiles = filterByIgnorePatterns(changedFiles, projectRoot);
+
+  if (changedFiles.length === 0) {
+    if (jsonOutput) {
+      console.log(JSON.stringify({ findings: [], stats: { filesChecked: 0 } }));
+    } else {
+      console.log(`  ${c.green('无代码文件变更。')}\n`);
+    }
+    return;
+  }
+
+  if (!jsonOutput) {
+    console.log(`  ${c.gray('正在检查')} ${changedFiles.length} ${c.gray('个变更文件：')}`);
+    for (const f of changedFiles) {
+      console.log(`    ${c.gray(f)}`);
+    }
+    console.log('');
+  }
+
+  // Read file contents
+  const fileContents = changedFiles.map(f => {
+    const fullPath = path.join(projectRoot, f);
+    let content = '';
+    try { content = fs.readFileSync(fullPath, 'utf-8'); } catch (_) {}
+    return { path: f, content, fullPath };
+  });
+
+  // Skip HTML without script tags
+  const validFiles = fileContents.filter(f => {
+    if (/\.html?$/.test(f.path) && !/<script[\s>]/i.test(f.content)) return false;
+    return true;
+  });
+
+  const ctx = {
+    files: validFiles,
+    projectRoot,
+    config: loadConfig(projectRoot),
+  };
+
+  // Register and run rules
+  engine.registerBatch(codeQualityRules);
+
+  const conventionStore = new ConventionStore(projectRoot);
+  engine.register({
+    id: 'convention-check',
+    severity: 'warn',
+    category: 'convention',
+    check(ctx) {
+      const allFindings = [];
+      for (const file of ctx.files) {
+        const findings = conventionStore.check(file.path, file.content);
+        allFindings.push(...findings);
+      }
+      return allFindings.length > 0 ? allFindings : null;
+    }
+  });
+
+  const { findings: ruleFindings } = engine.run(ctx);
+
+  // Arch assessment
+  const archAssessor = new ArchRiskAssessor(projectRoot);
+  const archFindings = [];
+  for (const file of validFiles) {
+    const findings = archAssessor.analyzeFile(file.path, file.content);
+    archFindings.push(...findings);
+  }
+
+  // Impact analysis on changed files
+  let impactFindings = [];
+  try {
+    const impactAnalyzer = new ImpactAnalyzer(projectRoot);
+    impactAnalyzer.buildGraph();
+    for (const file of validFiles) {
+      const result = impactAnalyzer.analyzeChange(file.fullPath, file.content);
+      impactFindings.push(...result.findings);
+    }
+  } catch (_) {}
+
+  let allFindings = [...ruleFindings, ...archFindings, ...impactFindings];
+
+  // Apply config overrides and inline ignores
+  allFindings = applyConfigToFindings(ctx.config, allFindings);
+  allFindings = filterIgnored(allFindings, validFiles);
+
+  // Output
+  if (jsonOutput) {
+    console.log(JSON.stringify({
+      findings: allFindings,
+      stats: {
+        filesChecked: validFiles.length,
+        blocks: allFindings.filter(f => f.severity === 'block').length,
+        warnings: allFindings.filter(f => f.severity === 'warn').length,
+        infos: allFindings.filter(f => f.severity === 'info').length,
+      },
+    }, null, 2));
+  } else {
+    if (allFindings.length === 0) {
+      console.log(`  ${c.green('所有变更文件检查通过！')}\n`);
+    } else {
+      for (const f of allFindings) {
+        printFinding(f);
+      }
+      printStats({
+        blocks: allFindings.filter(f => f.severity === 'block').length,
+        warnings: allFindings.filter(f => f.severity === 'warn').length,
+        infos: allFindings.filter(f => f.severity === 'info').length,
+      });
+    }
+  }
+
+  // Exit code for CI
+  const hasBlocks = allFindings.some(f => f.severity === 'block');
+  const hasWarns = allFindings.some(f => f.severity === 'warn');
+  if (hasBlocks || (failOn === 'warn' && hasWarns)) {
+    if (!jsonOutput) {
+      console.log(`\n  ${c.red('检查未通过。')} ${hasBlocks ? '发现阻断级别问题。' : '警告被视为失败（--fail-on warn）。'}\n`);
+    }
+    process.exit(1);
+  }
+};

package/src/cli/commands/doctor.js

@@ -0,0 +1,186 @@
+/**
+ * devassist doctor - Environment diagnostics
+ *
+ * Checks:
+ *   1. Node.js version
+ *   2. Git availability
+ *   3. .devassist/ config completeness
+ *   4. AI provider configuration
+ *   5. .devassistignore presence
+ *   6. Git pre-commit hook
+ *   7. Report/backup/history directories
+ *   8. config.json validity
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+module.exports = function doctor(projectRoot, args, ui) {
+  const { printHeader, c } = ui;
+  printHeader('环境诊断');
+
+  const configDir = path.join(projectRoot, '.devassist');
+  const checks = [];
+
+  // 1. Node.js version
+  try {
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1).split('.')[0]);
+    const ok = major >= 14;
+    checks.push({
+      name: 'Node.js 版本',
+      status: ok ? 'pass' : 'fail',
+      detail: `${nodeVersion} ${ok ? '' : '(需要 v14+)'}`,
+    });
+  } catch (_) {
+    checks.push({ name: 'Node.js 版本', status: 'fail', detail: '无法检测' });
+  }
+
+  // 2. Git availability
+  try {
+    const gitVersion = execSync('git --version', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    checks.push({ name: 'Git 可用性', status: 'pass', detail: gitVersion });
+  } catch (_) {
+    checks.push({ name: 'Git 可用性', status: 'warn', detail: 'Git 未安装或不在 PATH 中' });
+  }
+
+  // 3. .devassist/ directory
+  if (fs.existsSync(configDir)) {
+    checks.push({ name: '.devassist/ 目录', status: 'pass', detail: '存在' });
+  } else {
+    checks.push({ name: '.devassist/ 目录', status: 'fail', detail: '不存在——运行 devassist init' });
+  }
+
+  // 4. Config files
+  const requiredFiles = [
+    'conventions.json',
+    'schema-registry.json',
+    'tech-debt.json',
+    'ai-config.json',
+    'config.json',
+  ];
+  for (const file of requiredFiles) {
+    const filePath = path.join(configDir, file);
+    if (fs.existsSync(filePath)) {
+      // Validate JSON
+      try {
+        JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        checks.push({ name: `配置文件 ${file}`, status: 'pass', detail: '存在且格式正确' });
+      } catch (e) {
+        checks.push({ name: `配置文件 ${file}`, status: 'fail', detail: `JSON 格式错误：${e.message}` });
+      }
+    } else {
+      checks.push({ name: `配置文件 ${file}`, status: 'warn', detail: '不存在' });
+    }
+  }
+
+  // 5. AI provider configuration (multi-engine)
+  const aiConfigPath = path.join(configDir, 'ai-config.json');
+  if (fs.existsSync(aiConfigPath)) {
+    try {
+      const aiConfig = JSON.parse(fs.readFileSync(aiConfigPath, 'utf-8'));
+      const envMap = { qwen: 'DASHSCOPE_API_KEY', openai: 'OPENAI_API_KEY', claude: 'ANTHROPIC_API_KEY', hunyuan: 'HUNYUAN_API_KEY' };
+
+      // Collect all engines from config
+      const allEngines = [];
+      if (aiConfig.provider) {
+        allEngines.push({ provider: aiConfig.provider, apiKey: aiConfig.apiKey, enabled: aiConfig.enabled !== false, isPrimary: true });
+      }
+      if (aiConfig.secondary && aiConfig.secondary.provider) {
+        allEngines.push({ provider: aiConfig.secondary.provider, apiKey: aiConfig.secondary.apiKey, enabled: aiConfig.secondary.enabled !== false, isPrimary: false });
+      }
+      if (Array.isArray(aiConfig.engines)) {
+        for (const eng of aiConfig.engines) {
+          if (eng && eng.provider) {
+            allEngines.push({ provider: eng.provider, apiKey: eng.apiKey, enabled: eng.enabled !== false, isPrimary: false });
+          }
+        }
+      }
+
+      // Deduplicate by provider
+      const seen = new Set();
+      const uniqueEngines = allEngines.filter(e => {
+        if (seen.has(e.provider)) return false;
+        seen.add(e.provider);
+        return true;
+      });
+
+      if (uniqueEngines.length === 0) {
+        checks.push({ name: 'AI 引擎', status: 'warn', detail: '未启用（可选功能）' });
+      } else {
+        for (let i = 0; i < uniqueEngines.length; i++) {
+          const eng = uniqueEngines[i];
+          const envVar = envMap[eng.provider];
+          const hasKey = eng.apiKey || (envVar && process.env[envVar]);
+          const label = `AI 引擎 [${i}]${eng.isPrimary ? ' 主' : ''}`;
+          checks.push({
+            name: label,
+            status: hasKey ? 'pass' : 'warn',
+            detail: `${eng.provider} ${hasKey ? '(API Key 已配置)' : '(API Key 未设置)'}`,
+          });
+        }
+        if (uniqueEngines.filter(e => e.apiKey || process.env[envMap[e.provider]]).length >= 2) {
+          checks.push({ name: 'AI 多引擎', status: 'pass', detail: `${uniqueEngines.length} 个引擎就绪，可运行 --compare` });
+        }
+      }
+    } catch (_) {
+      checks.push({ name: 'AI 引擎', status: 'warn', detail: '配置文件无法读取' });
+    }
+  }
+
+  // 6. .devassistignore
+  const ignorePath = path.join(projectRoot, '.devassistignore');
+  checks.push({
+    name: '.devassistignore',
+    status: fs.existsSync(ignorePath) ? 'pass' : 'warn',
+    detail: fs.existsSync(ignorePath) ? '存在' : '不存在（建议创建）',
+  });
+
+  // 7. Git pre-commit hook
+  const hookPath = path.join(projectRoot, '.git', 'hooks', 'pre-commit');
+  if (fs.existsSync(hookPath)) {
+    const hookContent = fs.readFileSync(hookPath, 'utf-8');
+    if (hookContent.includes('devassist')) {
+      checks.push({ name: 'Git pre-commit 钩子', status: 'pass', detail: '已安装' });
+    } else {
+      checks.push({ name: 'Git pre-commit 钩子', status: 'warn', detail: '存在但不包含 DevAssist' });
+    }
+  } else {
+    checks.push({ name: 'Git pre-commit 钩子', status: 'warn', detail: '未安装（可选）' });
+  }
+
+  // 8. Directories
+  const dirs = ['reports', 'backups', 'history'];
+  for (const dir of dirs) {
+    const dirPath = path.join(configDir, dir);
+    checks.push({
+      name: `目录 .devassist/${dir}/`,
+      status: fs.existsSync(dirPath) ? 'pass' : 'warn',
+      detail: fs.existsSync(dirPath) ? '存在' : '不存在',
+    });
+  }
+
+  // Print results
+  let passCount = 0, warnCount = 0, failCount = 0;
+  for (const check of checks) {
+    const icon = check.status === 'pass' ? c.green('[通过]') :
+                 check.status === 'warn' ? c.yellow('[警告]') :
+                 c.red('[失败]');
+    console.log(`  ${icon} ${c.bold(check.name)}：${c.gray(check.detail)}`);
+    if (check.status === 'pass') passCount++;
+    else if (check.status === 'warn') warnCount++;
+    else failCount++;
+  }
+
+  console.log(c.gray('  ────────────────────────────────────────'));
+  console.log(`  ${c.green(`${passCount} 通过`)}  ${c.yellow(`${warnCount} 警告`)}  ${c.red(`${failCount} 失败`)}`);
+
+  if (failCount > 0) {
+    console.log(`\n  ${c.red('存在失败项。')} 请按上述提示修复后再使用。\n`);
+  } else if (warnCount > 0) {
+    console.log(`\n  ${c.yellow('存在警告项。')} 这些不影响基本功能，但建议修复以获得完整体验。\n`);
+  } else {
+    console.log(`\n  ${c.green('全部检查通过！')} 环境配置完整。\n`);
+  }
+};

package/src/cli/commands/fix.js

@@ -0,0 +1,195 @@
+/**
+ * devassist fix - Auto-fix common code issues
+ *
+ * Supported fixes:
+ *   --fetch-catch    Add .catch() to unhandled fetch() calls
+ *   --remove-console Remove console.log statements (replace with comment)
+ *   --add-await      Add await to async function calls missing it
+ *   --all            Apply all safe fixes
+ *   --dry-run        Show what would be fixed without modifying files
+ *
+ * Safety:
+ *   - Always creates a .devassist/backups/fix-<timestamp>/ backup before modifying
+ *   - Only applies fixes that are unlikely to change behavior
+ *   - Prints a summary of all changes
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { collectFileContents } = require('../shared/file-collector');
+
+module.exports = function fix(projectRoot, args, ui) {
+  const { printHeader, c } = ui;
+  printHeader('自动修复');
+
+  const dryRun = args.includes('--dry-run');
+  const fixAll = args.includes('--all');
+  const fixFetchCatch = fixAll || args.includes('--fetch-catch');
+  const fixRemoveConsole = fixAll || args.includes('--remove-console');
+  const fixAddAwait = fixAll || args.includes('--add-await');
+
+  if (!fixFetchCatch && !fixRemoveConsole && !fixAddAwait) {
+    console.log(`  ${c.yellow('未指定修复项。')}\n`);
+    console.log(`  ${c.bold('可用修复项：')}`);
+    console.log(`    ${c.green('--fetch-catch')}     为 fetch() 调用添加 .catch() 错误处理`);
+    console.log(`    ${c.green('--remove-console')}  移除 console.log 调试语句`);
+    console.log(`    ${c.green('--add-await')}       为 async 函数调用添加 await`);
+    console.log(`    ${c.green('--all')}             应用所有安全修复`);
+    console.log(`    ${c.gray('--dry-run')}          仅预览，不实际修改文件\n`);
+    return;
+  }
+
+  const fileContents = collectFileContents(projectRoot);
+  const changes = []; // { file, line, before, after, type }
+
+  for (const file of fileContents) {
+    if (!file.content || !/\.(js|ts|jsx|tsx)$/.test(file.path)) continue;
+    // Skip this tool's own source
+    if (/devassist|node_modules/.test(file.path)) continue;
+
+    let content = file.content;
+    const lines = content.split('\n');
+
+    // Fix 1: fetch() without .catch()
+    if (fixFetchCatch) {
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^\s*(\/\/|\/\*|\*)/.test(line)) continue; // skip comments
+        if (!/\bfetch\s*\(/.test(line)) continue;
+
+        // Check if .catch is already present nearby
+        const context = lines.slice(i, Math.min(i + 5, lines.length)).join('\n');
+        if (/\.catch\s*\(/.test(context)) continue;
+
+        // Check if it's an await fetch in try/catch
+        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;
+
+        // Add .catch() — simple case: single-line fetch call
+        const trimmed = line.trimEnd();
+        if (trimmed.endsWith(')') && !trimmed.endsWith('.catch()')) {
+          const indent = line.match(/^\s*/)[0];
+          const fixedLine = trimmed.replace(/\)\s*$/, ').catch(err => console.error(\'fetch error:\', err))');
+          changes.push({
+            file: file.path, line: i + 1, type: 'fetch-catch',
+            before: line, after: fixedLine,
+          });
+          if (!dryRun) lines[i] = fixedLine;
+        }
+      }
+    }
+
+    // Fix 2: Remove console.log
+    if (fixRemoveConsole) {
+      // Skip CLI command files — they use console.log for intentional terminal output
+      const isCliFile = /cli[\\/]/.test(file.path);
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (isCliFile) break; // skip entire file
+        if (/^\s*(\/\/|\/\*|\*)/.test(line)) continue;
+        if (!/console\.log\s*\(/.test(line)) continue;
+        // Skip logger files
+        if (/logger/i.test(file.path)) continue;
+
+        const indent = line.match(/^\s*/)[0];
+        const fixedLine = `${indent}// devassist-fix: removed console.log`;
+        changes.push({
+          file: file.path, line: i + 1, type: 'remove-console',
+          before: line.trim(), after: fixedLine.trim(),
+        });
+        if (!dryRun) lines[i] = fixedLine;
+      }
+    }
+
+    // Fix 3: Add await to async calls
+    if (fixAddAwait) {
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^\s*(\/\/|\/\*|\*)/.test(line)) continue;
+        if (/\bawait\b/.test(line)) continue;
+
+        // Only match known async patterns (not generic function names)
+        const asyncMatch = line.match(/(?<![\w.])(fetch|axios\.(get|post|put|delete|patch)|\.save\(|\.findOne\(|\.findById\(|\.create\()\s*/);
+        if (!asyncMatch) continue;
+
+        // Skip if it's part of assignment or condition
+        const trimmed = line.trim();
+        if (/^\s*(const|let|var|if|while|return|throw)/.test(trimmed)) continue;
+        // Skip function declarations (function getProvider(...) is not a call)
+        if (/^\s*(async\s+)?function\s+/.test(line)) continue;
+        if (/^\s*(export\s+)?(async\s+)?function\s+/.test(line)) continue;
+        if (/\.then\s*\(|\.catch\s*\(|\.finally\s*\(/.test(line)) continue;
+
+        // Add await before the function call
+        const fixedLine = line.replace(
+          new RegExp('(?<![\\w.])(' + asyncMatch[1] + '\\w+)\\s*\\('),
+          'await $1('
+        );
+        if (fixedLine !== line) {
+          changes.push({
+            file: file.path, line: i + 1, type: 'add-await',
+            before: line.trim(), after: fixedLine.trim(),
+          });
+          if (!dryRun) lines[i] = fixedLine;
+        }
+      }
+    }
+
+    // Write back if changes were made
+    if (!dryRun && changes.some(ch => ch.file === file.path)) {
+      const newContent = lines.join('\n');
+      if (newContent !== content) {
+        // Create backup of original file
+        const backupDir = path.join(projectRoot, '.devassist', 'backups', `fix-${Date.now()}`);
+        if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+        const backupPath = path.join(backupDir, file.path.replace(/[\\/]/g, '_'));
+        fs.writeFileSync(backupPath, content, 'utf-8');
+        fs.writeFileSync(file.fullPath, newContent, 'utf-8');
+      }
+    }
+  }
+
+  // Print summary
+  if (changes.length === 0) {
+    console.log(`  ${c.green('无需修复。')} 没有发现可自动修复的问题。\n`);
+    return;
+  }
+
+  // Group by type
+  const byType = {};
+  for (const ch of changes) {
+    if (!byType[ch.type]) byType[ch.type] = [];
+    byType[ch.type].push(ch);
+  }
+
+  const typeLabels = {
+    'fetch-catch': 'fetch 添加 .catch()',
+    'remove-console': '移除 console.log',
+    'add-await': '添加 await',
+  };
+
+  console.log(`  ${c.bold('修复摘要：')}\n`);
+  for (const [type, items] of Object.entries(byType)) {
+    console.log(`    ${c.green(typeLabels[type] || type)}：${items.length} 处`);
+  }
+
+  // Show details
+  console.log(`\n  ${c.bold('详情：')}\n`);
+  for (const ch of changes.slice(0, 20)) {
+    console.log(`    ${c.gray(ch.file + ':' + ch.line)} [${typeLabels[ch.type] || ch.type}]`);
+    console.log(`      ${c.red('-')} ${ch.before.substring(0, 80)}`);
+    console.log(`      ${c.green('+')} ${ch.after.substring(0, 80)}`);
+  }
+  if (changes.length > 20) {
+    console.log(`    ${c.gray(`...还有 ${changes.length - 20} 处修改`)}`);
+  }
+
+  if (dryRun) {
+    console.log(`\n  ${c.gray('（--dry-run 模式，未实际修改文件。移除 --dry-run 执行修复。）')}`);
+  } else {
+    console.log(`\n  ${c.green('已修复 ' + changes.length + ' 处问题。')} 原文件已备份到 .devassist/backups/`);
+  }
+  console.log('');
+};