devassist-agent 1.0.0

package/src/cli/commands/watch.js

@@ -0,0 +1,212 @@
+/**
+ * devassist watch - Real-time file monitoring
+ *
+ * Watches project files for changes and runs checks on modified files.
+ * Provides instant feedback during AI-assisted development.
+ *
+ * Usage:
+ *   devassist watch              # Watch all source files
+ *   devassist watch --ai         # Watch + AI analysis on findings
+ *   devassist watch --dir src    # Watch specific directory
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Core
+const { engine, RuleEngine } = 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');
+
+// Shared utilities
+const { loadConfig } = require('../shared/config-loader');
+const { filterIgnored } = require('../shared/inline-ignore');
+
+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 useAI = args.includes('--ai');
+  const watchDir = args.includes('--dir') ? args[args.indexOf('--dir') + 1] : null;
+
+  printHeader('监控模式');
+
+  console.log(`  ${c.gray('监控目录：')} ${watchDir || '整个项目'}`);
+  console.log(`  ${c.gray('AI 分析：')} ${useAI ? '已启用' : '已禁用'}`);
+  console.log(`  ${c.gray('按 Ctrl+C 停止')}\n`);
+
+  // Initialize convention store
+  const conventionStore = new ConventionStore(projectRoot);
+  const archAssessor = new ArchRiskAssessor(projectRoot);
+
+  // Register rules
+  engine.registerBatch(codeQualityRules);
+  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;
+    }
+  });
+
+  // Track watchers for cleanup
+  const watchers = [];
+  const debounceTimers = new Map();
+
+  // Watch a single file
+  function watchFile(filePath) {
+    try {
+      const watcher = fs.watch(filePath, { persistent: true }, (eventType) => {
+        if (eventType !== 'change') return;
+
+        // Debounce: wait 300ms after last change before checking
+        if (debounceTimers.has(filePath)) {
+          clearTimeout(debounceTimers.get(filePath));
+        }
+        debounceTimers.set(filePath, setTimeout(() => {
+          debounceTimers.delete(filePath);
+          checkFile(filePath);
+        }, 300));
+      });
+      watcher.on('error', () => {});
+      watchers.push(watcher);
+    } catch (_) {}
+  }
+
+  // Recursively set up watchers on directories
+  function watchDirRecursive(dir) {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+
+    for (const entry of entries) {
+      if (SKIP_DIRS.includes(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        watchDirRecursive(full);
+      } else if (CODE_EXTENSIONS.test(entry.name) || /\.html?$/.test(entry.name)) {
+        watchFile(full);
+      }
+    }
+  }
+
+  // Check a single file
+  function checkFile(filePath) {
+    const relPath = path.relative(projectRoot, filePath);
+    const timestamp = new Date().toLocaleTimeString();
+
+    let content = '';
+    try { content = fs.readFileSync(filePath, 'utf-8'); } catch (_) { return; }
+
+    // Quick skip for HTML without script tags
+    if (/\.html?$/.test(filePath) && !/<script[\s>]/i.test(content)) return;
+
+    const ctx = {
+      files: [{ path: relPath, content, fullPath: filePath }],
+      projectRoot,
+      config: loadConfig(projectRoot),
+    };
+
+    const { findings: ruleFindings } = engine.run(ctx);
+    const archFindings = archAssessor.analyzeFile(relPath, content);
+    let allFindings = [...ruleFindings, ...archFindings];
+
+    // Apply inline ignores
+    allFindings = filterIgnored(allFindings, [{ path: relPath, content }]);
+
+    // Save findings for ai --analyze
+    saveWatchFindings(projectRoot, allFindings);
+
+    // Print header
+    console.log(`\n  ${c.gray(`[${timestamp}]`)} ${c.bold(relPath)}`);
+
+    if (allFindings.length === 0) {
+      console.log(`  ${c.green('OK')} — 未发现问题`);
+      return;
+    }
+
+    // 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)}`);
+    }
+
+    // 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(' · '))}`);
+  }
+
+  // Start watching
+  const targetDir = watchDir ? path.join(projectRoot, watchDir) : projectRoot;
+  watchDirRecursive(targetDir);
+
+  console.log(`  ${c.cyan(`正在监控 ${watchers.length} 个文件...`)}\n`);
+
+  // Initial full check
+  console.log(`  ${c.gray('正在执行初始检查...')}`);
+  const checkCmd = require('./check');
+  await checkCmd(projectRoot, useAI ? ['--ai'] : [], ui);
+  console.log(`\n  ${c.cyan('开始监控变更...')}`);
+
+  // Handle new files being added (watch parent dirs for new entries)
+  const dirWatcher = fs.watch(targetDir, { recursive: true }, (eventType, filename) => {
+    if (!filename) return;
+    const fullPath = path.join(targetDir, filename);
+
+    // If a new file was added that we're not watching yet
+    if (eventType === 'rename' && fs.existsSync(fullPath)) {
+      try {
+        const stat = fs.statSync(fullPath);
+        if (stat.isFile() && CODE_EXTENSIONS.test(filename) && !watchers.some(w => w._path === fullPath)) {
+          watchFile(fullPath);
+        }
+      } catch (_) {}
+    }
+  });
+  watchers.push(dirWatcher);
+
+  // Cleanup on exit
+  process.on('SIGINT', () => {
+    console.log(`\n  ${c.gray('正在停止监控...')}`);
+    watchers.forEach(w => w.close());
+    process.exit(0);
+  });
+};
+
+function saveWatchFindings(projectRoot, findings) {
+  const reportDir = path.join(projectRoot, '.devassist', 'reports');
+  if (!fs.existsSync(reportDir)) fs.mkdirSync(reportDir, { recursive: true });
+  const reportPath = path.join(reportDir, 'latest.json');
+  fs.writeFileSync(reportPath, JSON.stringify({
+    generatedAt: new Date().toISOString(),
+    source: 'watch',
+    findings,
+    stats: {
+      total: findings.length,
+      blocks: findings.filter(f => f.severity === 'block').length,
+      warnings: findings.filter(f => f.severity === 'warn').length,
+      infos: findings.filter(f => f.severity === 'info').length,
+    },
+  }, null, 2), 'utf-8');
+}

package/src/cli/shared/code-context.js

@@ -0,0 +1,51 @@
+/**
+ * Code context extractor for AI analysis.
+ *
+ * When sending findings to AI, we include the surrounding code lines
+ * so the AI can see the actual code it's analyzing — not just a message.
+ */
+
+/**
+ * Extract code context (surrounding lines) for a finding.
+ * @param {string} content - full file content
+ * @param {number} line - 1-indexed line number
+ * @param {number} radius - lines before and after (default 5)
+ * @returns {string} - the code snippet with line numbers
+ */
+function extractContext(content, line, radius = 5) {
+  if (!content || !line) return '';
+  const lines = content.split('\n');
+  const start = Math.max(0, line - radius - 1);
+  const end = Math.min(lines.length, line + radius);
+  const snippet = [];
+  for (let i = start; i < end; i++) {
+    const lineNum = i + 1;
+    const marker = lineNum === line ? ' >>> ' : '     ';
+    snippet.push(`${String(lineNum).padStart(4)}${marker}${lines[i]}`);
+  }
+  return snippet.join('\n');
+}
+
+/**
+ * Enrich findings with code context from the files that produced them.
+ * @param {Array} findings
+ * @param {Array<{ path: string, content: string }>} fileContents
+ * @returns {Array} - findings with added `codeContext` field
+ */
+function enrichWithContext(findings, fileContents) {
+  const contentMap = new Map();
+  for (const f of fileContents) {
+    contentMap.set(f.path, f.content);
+  }
+
+  return findings.map(f => {
+    const content = contentMap.get(f.file);
+    if (!content || !f.line) return f;
+    return {
+      ...f,
+      codeContext: extractContext(content, f.line),
+    };
+  });
+}
+
+module.exports = { extractContext, enrichWithContext };

package/src/cli/shared/config-loader.js

@@ -0,0 +1,89 @@
+/**
+ * Project-level configuration loader.
+ *
+ * Reads .devassist/config.json for:
+ *   - Custom thresholds (maxFileLines, todoThreshold, consoleLogThreshold, etc.)
+ *   - Rule enable/disable overrides
+ *   - Severity overrides (downgrade block -> warn, etc.)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_CONFIG = {
+  // Thresholds
+  maxFileLines: 800,
+  todoThreshold: 3,
+  consoleLogThreshold: 5,
+  magicNumberMinDigits: 3,
+  maxEventListenerFiles: 100,
+
+  // Rule overrides: { 'rule-id': { enabled: false } } or { 'rule-id': { severity: 'warn' } }
+  rules: {},
+
+  // AI settings
+  ai: {
+    autoAnalyze: false,
+    maxFindingsToAI: 20,
+  },
+};
+
+/**
+ * Load project config from .devassist/config.json.
+ * Falls back to defaults if not found.
+ * @param {string} projectRoot
+ * @returns {object} merged config
+ */
+function loadConfig(projectRoot) {
+  const configPath = path.join(projectRoot, '.devassist', 'config.json');
+  if (!fs.existsSync(configPath)) return { ...DEFAULT_CONFIG };
+  try {
+    const userConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    return {
+      ...DEFAULT_CONFIG,
+      ...userConfig,
+      rules: { ...DEFAULT_CONFIG.rules, ...(userConfig.rules || {}) },
+      ai: { ...DEFAULT_CONFIG.ai, ...(userConfig.ai || {}) },
+    };
+  } catch (err) {
+    return { ...DEFAULT_CONFIG, _error: err.message };
+  }
+}
+
+/**
+ * Get the effective severity for a rule, applying config overrides.
+ * @param {object} config - from loadConfig()
+ * @param {string} ruleId
+ * @param {string} defaultSeverity
+ * @returns {string|null} - 'block'|'warn'|'info'|null (null = disabled)
+ */
+function getEffectiveSeverity(config, ruleId, defaultSeverity) {
+  if (!config || !config.rules) return defaultSeverity;
+  const override = config.rules[ruleId];
+  if (!override) return defaultSeverity;
+  if (override.enabled === false) return null; // disabled
+  if (override.severity) return override.severity;
+  return defaultSeverity;
+}
+
+/**
+ * Filter an array of findings by config-based rule overrides.
+ * Removes findings from disabled rules and adjusts severity.
+ * @param {object} config
+ * @param {Array} findings
+ * @returns {Array}
+ */
+function applyConfigToFindings(config, findings) {
+  if (!config || !config.rules) return findings;
+  return findings
+    .map(f => {
+      const override = config.rules[f.ruleId];
+      if (!override) return f;
+      if (override.enabled === false) return null; // skip
+      if (override.severity) return { ...f, severity: override.severity };
+      return f;
+    })
+    .filter(Boolean);
+}
+
+module.exports = { loadConfig, getEffectiveSeverity, applyConfigToFindings, DEFAULT_CONFIG };

package/src/cli/shared/file-collector.js

@@ -0,0 +1,116 @@
+/**
+ * Shared file collection utilities.
+ *
+ * Extracted from check.js / report.js / diff.js to eliminate ~180 lines
+ * of duplicated walkDir/collectFiles/loadIgnorePatterns code.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const DEFAULT_SKIP_DIRS = ['node_modules', '.git', '.devassist', 'dist', 'build', 'vendor', '.gradle', '__pycache__'];
+const DEFAULT_SKIP_FILES = [/\.min\.(js|css)$/, /\.map$/, /^vendor\./];
+const CODE_EXTENSIONS = /\.(js|ts|jsx|tsx|py|java)$/;
+
+/**
+ * Load .devassistignore patterns from the project root.
+ * @param {string} projectRoot
+ * @returns {{ dirs: string[], globs: RegExp[] }}
+ */
+function loadIgnorePatterns(projectRoot) {
+  const patterns = { dirs: [], globs: [] };
+  const ignorePath = path.join(projectRoot, '.devassistignore');
+  if (!fs.existsSync(ignorePath)) return patterns;
+  try {
+    const content = fs.readFileSync(ignorePath, 'utf-8');
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      if (trimmed.endsWith('/')) {
+        patterns.dirs.push(trimmed.slice(0, -1));
+      } else if (trimmed.includes('*')) {
+        patterns.globs.push(new RegExp('^' + trimmed.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$'));
+      } else {
+        patterns.dirs.push(trimmed);
+      }
+    }
+  } catch (_) {}
+  return patterns;
+}
+
+/**
+ * Recursively collect all source files from a project root.
+ * @param {string} projectRoot
+ * @returns {string[]} absolute file paths
+ */
+function collectFiles(projectRoot) {
+  const results = [];
+  const ignorePatterns = loadIgnorePatterns(projectRoot);
+  const allSkipDirs = [...DEFAULT_SKIP_DIRS, ...ignorePatterns.dirs];
+  _walkDir(projectRoot, results, allSkipDirs, DEFAULT_SKIP_FILES, projectRoot, ignorePatterns);
+  return results;
+}
+
+/**
+ * Collect files and return them as { path, content, fullPath } objects.
+ * @param {string} projectRoot
+ * @returns {Array<{ path: string, content: string, fullPath: string }>}
+ */
+function collectFileContents(projectRoot) {
+  const files = collectFiles(projectRoot);
+  return files.map(f => {
+    let content = '';
+    try { content = fs.readFileSync(f, 'utf-8'); } catch (_) {}
+    return { path: path.relative(projectRoot, f), content, fullPath: f };
+  });
+}
+
+/**
+ * Filter a list of changed files (from git diff) by ignore patterns.
+ * @param {string[]} changedFiles
+ * @param {string} projectRoot
+ * @returns {string[]}
+ */
+function filterByIgnorePatterns(changedFiles, projectRoot) {
+  const ignorePatterns = loadIgnorePatterns(projectRoot);
+  return changedFiles.filter(f => {
+    for (const dir of ignorePatterns.dirs) {
+      if (f.startsWith(dir + '/') || f.startsWith(dir + '\\')) return false;
+    }
+    for (const re of ignorePatterns.globs) {
+      if (re.test(f)) return false;
+    }
+    return true;
+  });
+}
+
+function _walkDir(dir, results, skipDirs, skipFiles, projectRoot, ignorePatterns) {
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch (_) { return; }
+  for (const entry of entries) {
+    if (skipDirs.includes(entry.name)) continue;
+    const full = path.join(dir, entry.name);
+    const relPath = path.relative(projectRoot, full);
+    if (ignorePatterns.globs.some(re => re.test(relPath) || re.test(entry.name))) continue;
+    if (entry.isDirectory()) {
+      _walkDir(full, results, skipDirs, skipFiles, projectRoot, ignorePatterns);
+    } else if (entry.isFile()) {
+      if (skipFiles.some(re => re.test(entry.name))) continue;
+      if (CODE_EXTENSIONS.test(entry.name)) {
+        results.push(full);
+        continue;
+      }
+      if (/\.html?$/.test(entry.name)) {
+        try {
+          const content = fs.readFileSync(full, 'utf-8');
+          if (/<script[\s>]/i.test(content)) {
+            results.push(full);
+          }
+        } catch (_) {}
+        continue;
+      }
+    }
+  }
+}
+
+module.exports = { collectFiles, collectFileContents, loadIgnorePatterns, filterByIgnorePatterns, DEFAULT_SKIP_DIRS };

package/src/cli/shared/inline-ignore.js

@@ -0,0 +1,142 @@
+/**
+ * Inline ignore comment processor.
+ *
+ * Supports:
+ *   // devassist-ignore-next-line          — skip the next line's findings
+ *   // devassist-ignore-next-line cq-rule-id — skip specific rule on next line
+ *   /* devassist-disable *​/                — disable all rules for the rest of the file
+ *   /* devassist-disable cq-rule-id *​/     — disable specific rule for the rest of the file
+ *   /* devassist-enable *​/                 — re-enable all rules
+ *   /* devassist-enable cq-rule-id *​/      — re-enable specific rule
+ *
+ * Also supports HTML: <!-- devassist-ignore-next-line -->
+ */
+
+/**
+ * Parse a file's content and build an ignore map.
+ * @param {string} content
+ * @returns {{ lineIgnores: Map<number, Set<string>>, rangeIgnores: Array<{start:number, end:number, rules:Set<string>}> }}
+ */
+function parseIgnores(content) {
+  const lines = content.split('\n');
+  const lineIgnores = new Map(); // line number -> Set of rule IDs (or '*' for all)
+  const rangeIgnores = []; // { start, end: Infinity, rules: Set }
+
+  // Patterns for different comment styles
+  const ignoreNextRe = /(\/\/|<!--|\/\*)\s*devassist-ignore-next-line(?:\s+(\S+))?\s*(-->|\*\/)?/;
+  const disableRe = /\/\*\s*devassist-disable(?:\s+([\w,\s-]+))?\s*\*\/|<!--\s*devassist-disable(?:\s+([\w,\s-]+))?\s*-->/;
+  const enableRe = /\/\*\s*devassist-enable(?:\s+([\w,\s-]+))?\s*\*\/|<!--\s*devassist-enable(?:\s+([\w,\s-]+))?\s*-->/;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Check for ignore-next-line
+    const ignoreMatch = line.match(ignoreNextRe);
+    if (ignoreMatch) {
+      const ruleId = ignoreMatch[2] || '*';
+      const targetLine = i + 2; // next line (1-indexed)
+      if (!lineIgnores.has(targetLine)) lineIgnores.set(targetLine, new Set());
+      lineIgnores.get(targetLine).add(ruleId);
+    }
+
+    // Check for devassist-disable
+    const disableMatch = line.match(disableRe);
+    if (disableMatch) {
+      const ruleStr = (disableMatch[1] || disableMatch[2] || '').trim();
+      const rules = ruleStr ? new Set(ruleStr.split(/[\s,]+/)) : new Set(['*']);
+      rangeIgnores.push({ start: i + 1, end: Infinity, rules });
+    }
+
+    // Check for devassist-enable
+    const enableMatch = line.match(enableRe);
+    if (enableMatch) {
+      const ruleStr = (enableMatch[1] || enableMatch[2] || '').trim();
+      const rules = ruleStr ? new Set(ruleStr.split(/[\s,]+/)) : new Set(['*']);
+      // Close the most recent open range
+      for (let j = rangeIgnores.length - 1; j >= 0; j--) {
+        if (rangeIgnores[j].end === Infinity) {
+          // If enabling specific rules, only close those
+          if (rules.has('*')) {
+            rangeIgnores[j].end = i + 1;
+          } else {
+            // Partial: just remove those rules from the active range
+            for (const r of rules) rangeIgnores[j].rules.delete(r);
+            if (rangeIgnores[j].rules.size === 0) rangeIgnores[j].end = i + 1;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  return { lineIgnores, rangeIgnores };
+}
+
+/**
+ * Check if a specific finding should be ignored based on inline comments.
+ * @param {object} finding - { file, line, ruleId }
+ * @param {Map} fileContentsMap - Map<filePath, content>
+ * @returns {boolean} true if should be ignored
+ */
+function shouldIgnore(finding, fileContentsMap) {
+  if (!finding.line || !finding.file) return false;
+  const content = fileContentsMap.get(finding.file);
+  if (!content) return false;
+
+  const { lineIgnores, rangeIgnores } = parseIgnores(content);
+  const line = finding.line;
+  const ruleId = finding.ruleId || '*';
+
+  // Check line-level ignores
+  if (lineIgnores.has(line)) {
+    const rules = lineIgnores.get(line);
+    if (rules.has('*') || rules.has(ruleId)) return true;
+  }
+
+  // Check range ignores
+  for (const range of rangeIgnores) {
+    if (line >= range.start && line <= range.end) {
+      if (range.rules.has('*') || range.rules.has(ruleId)) return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Filter an array of findings, removing those covered by inline ignore comments.
+ * @param {Array} findings
+ * @param {Array<{ path: string, content: string }>} fileContents
+ * @returns {Array}
+ */
+function filterIgnored(findings, fileContents) {
+  const contentMap = new Map();
+  for (const f of fileContents) {
+    contentMap.set(f.path, f.content);
+  }
+
+  return findings.filter(f => {
+    const content = contentMap.get(f.file);
+    if (!content) return true; // can't check, keep it
+    const { lineIgnores, rangeIgnores } = parseIgnores(content);
+    const line = f.line;
+    const ruleId = f.ruleId || '*';
+
+    // Check line-level ignores
+    if (line && lineIgnores.has(line)) {
+      const rules = lineIgnores.get(line);
+      if (rules.has('*') || rules.has(ruleId)) return false;
+    }
+
+    // Check range ignores
+    for (const range of rangeIgnores) {
+      if (line && line >= range.start && line <= range.end) {
+        if (range.rules.has('*') || range.rules.has(ruleId)) return false;
+      }
+    }
+
+    return true;
+  });
+}
+
+module.exports = { parseIgnores, shouldIgnore, filterIgnored };