devassist-agent 1.0.0

package/tests/run-all.js

@@ -0,0 +1,434 @@
+/**
+ * DevAssist test suite - verifies core functionality
+ *
+ * Tests:
+ * 1. EventBus pub/sub
+ * 2. RuleEngine registration and execution
+ * 3. FSM state transitions and loop protection
+ * 4. ConventionStore add/check/violation detection
+ * 5. CodeQualityGuard rules (null safety, duplicates, race condition)
+ * 6. ImpactAnalyzer change detection (massive reduction)
+ * 7. SchemaRegistry drift detection (data.list vs data.items)
+ * 8. VersionManager non-destructive restore
+ * 9. AI adapter degradation (no provider configured)
+ * 10. ArchRiskAssessor recovery loop detection
+ * 11. API naming drift detection (Phase 3)
+ * 12. fetch without catch detection (Phase 3)
+ * 13. console.log residual detection (Phase 3)
+ * 14. Missing await detection (Phase 3)
+ * 15. Event listener leak detection (Phase 3)
+ * 16. Inject command - convention file generation (Phase 3)
+ * 17. AI adapter Chinese prompt + code context (Phase 3)
+ * 18. Inline ignore comments (Phase 4)
+ * 19. Config loader - rule enable/disable, severity override (Phase 4)
+ * 20. Code context extractor (Phase 4)
+ * 21. Shared file collector (Phase 4)
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+function assert(condition, message) {
+  if (condition) {
+    passed++;
+  } else {
+    failed++;
+    failures.push(message);
+    console.log(`  FAIL: ${message}`);
+  }
+}
+
+async function runTests() {
+  console.log('\n  DevAssist Test Suite\n  ====================\n');
+
+  // --- Test 1: EventBus ---
+  console.log('  [1] EventBus...');
+  const { EventBus } = require('../src/core/event-bus');
+  const bus = new EventBus();
+  let received = null;
+  bus.on('test-event', (payload) => { received = payload; });
+  await bus.emit('test-event', { data: 'hello' });
+  assert(received && received.data === 'hello', 'EventBus should deliver payload');
+  assert(bus.getHistory('test-event').length === 1, 'EventBus should record history');
+  console.log('  OK\n');
+
+  // --- Test 2: RuleEngine ---
+  console.log('  [2] RuleEngine...');
+  const { RuleEngine } = require('../src/core/rule-engine');
+  const re = new RuleEngine();
+  re.register({
+    id: 'test-rule',
+    severity: 'warn',
+    category: 'test',
+    check(ctx) {
+      if (ctx.value > 10) return { message: 'value too high', file: 'test.js' };
+      return null;
+    }
+  });
+  const result1 = re.run({ value: 5 });
+  assert(result1.stats.passed === 1 && result1.findings.length === 0, 'Rule should pass when value < 10');
+  const result2 = re.run({ value: 15 });
+  assert(result2.findings.length === 1 && result2.findings[0].severity === 'warn', 'Rule should warn when value > 10');
+  console.log('  OK\n');
+
+  // --- Test 3: FSM ---
+  console.log('  [3] FSM...');
+  const { FSM, STATES } = require('../src/core/fsm');
+  const fsm = new FSM();
+  assert(fsm.state === STATES.IDLE, 'FSM should start in IDLE');
+  fsm.transition(STATES.PERCEIVING, 'test');
+  assert(fsm.state === STATES.PERCEIVING, 'FSM should transition to PERCEIVING');
+  fsm.transition(STATES.ANALYZING, 'test');
+  fsm.transition(STATES.DECIDING, 'test');
+  fsm.transition(STATES.ACTING, 'test');
+  fsm.transition(STATES.LEARNING, 'test');
+  fsm.transition(STATES.IDLE, 'done');
+  assert(fsm.state === STATES.IDLE, 'FSM should return to IDLE after full cycle');
+  // Test invalid transition
+  try {
+    fsm.transition(STATES.ACTING, 'invalid');
+    assert(false, 'FSM should reject invalid transition IDLE -> ACTING');
+  } catch (err) {
+    assert(true, 'FSM correctly rejected invalid transition');
+  }
+  console.log('  OK\n');
+
+  // --- Test 4: ConventionStore ---
+  console.log('  [4] ConventionStore...');
+  const { ConventionStore } = require('../src/modules/dev-time/convention-store');
+  const tmpDir = path.join(os.tmpdir(), 'devassist-test-' + Date.now());
+  fs.mkdirSync(tmpDir, { recursive: true });
+  const store = new ConventionStore(tmpDir);
+  store.add({
+    id: 'naming-test',
+    rule: 'Use data.list not data.items',
+    severity: 'block',
+    forbid: 'data\\.items',
+  });
+  const findings = store.check('test.js', 'const items = data.items;');
+  assert(findings.length > 0, 'ConventionStore should detect data.items violation');
+  assert(findings[0].severity === 'block', 'Convention violation should be block severity');
+  const clean = store.check('test.js', 'const items = data.list;');
+  assert(clean.length === 0, 'ConventionStore should not flag data.list');
+  console.log('  OK\n');
+
+  // --- Test 5: CodeQualityGuard ---
+  console.log('  [5] CodeQualityGuard...');
+  const { codeQualityRules } = require('../src/modules/dev-time/code-quality-guard');
+  const nullRule = codeQualityRules.find(r => r.id === 'cq-null-safety');
+  const nullResult = nullRule.check({
+    files: [{ path: 'test.js', content: 'const x = data.response.result.method();' }]
+  });
+  assert(nullResult && nullResult.length > 0, 'Should detect deep property access without null check');
+
+  const dupRule = codeQualityRules.find(r => r.id === 'cq-duplicate-declaration');
+  const dupResult = dupRule.check({
+    files: [{ path: 'test.js', content: 'var foo = 1;\nvar foo = 2;\n' }]
+  });
+  assert(dupResult && dupResult.length > 0, 'Should detect duplicate variable declaration');
+
+  const largeRule = codeQualityRules.find(r => r.id === 'cq-file-too-large');
+  const bigContent = 'x\n'.repeat(900);
+  const largeResult = largeRule.check({
+    files: [{ path: 'big.js', content: bigContent }],
+    config: { maxFileLines: 800 },
+  });
+  assert(largeResult && largeResult.length > 0, 'Should detect file too large (900 > 800)');
+  console.log('  OK\n');
+
+  // --- Test 6: ImpactAnalyzer ---
+  console.log('  [6] ImpactAnalyzer...');
+  const { ImpactAnalyzer } = require('../src/modules/dev-time/impact-analyzer');
+  const ia = new ImpactAnalyzer(tmpDir);
+  // Simulate a file that was 2720 lines, now being reduced to 106 lines
+  ia.graph.set('app.js', { imports: new Set(), importedBy: new Set(['index.html', 'main.js']), lines: 2720, exports: new Set(['init']) });
+  const impact = ia.analyzeChange(path.join(tmpDir, 'app.js'), 'const x = 1;\n'.repeat(106));
+  assert(impact.risk === 'critical', 'Should detect massive line reduction as critical');
+  assert(impact.findings.some(f => f.ruleId === 'ia-massive-reduction'), 'Should flag ia-massive-reduction');
+  console.log('  OK\n');
+
+  // --- Test 7: SchemaRegistry ---
+  console.log('  [7] SchemaRegistry...');
+  const { SchemaRegistry } = require('../src/modules/dev-time/schema-registry');
+  const sr = new SchemaRegistry(tmpDir);
+  // Register a table
+  sr.registerTable('sessions', { columns: [{ name: 'id', type: 'INT' }, { name: 'data', type: 'JSON' }] });
+  // Register API contract with data.list
+  sr.registerAPI('GET /api/sessions', { dataKey: 'data.list' });
+  // Check response that returns data.items instead of data.list
+  const apiFindings = sr.checkAPIResponse('GET /api/sessions', { code: 200, data: { items: [{ id: 1 }] } });
+  assert(apiFindings && apiFindings.length > 0, 'Should detect data.items vs data.list drift');
+  assert(apiFindings[0].ruleId === 'sr-api-key-drift', 'Should flag sr-api-key-drift');
+  // Check correct response
+  const okFindings = sr.checkAPIResponse('GET /api/sessions', { code: 200, data: { list: [{ id: 1 }] } });
+  assert(!okFindings || okFindings.length === 0, 'Should not flag correct data.list response');
+  console.log('  OK\n');
+
+  // --- Test 8: VersionManager ---
+  console.log('  [8] VersionManager...');
+  const { VersionManager } = require('../src/modules/dev-time/version-manager');
+  // Create test files
+  fs.mkdirSync(path.join(tmpDir, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(tmpDir, 'src', 'app.js'), 'console.log("hello");');
+  const vm = new VersionManager(tmpDir);
+  const backup1 = vm.backup('first backup');
+  assert(backup1.files.length > 0, 'Backup should contain files');
+  // Add a new file after backup
+  fs.writeFileSync(path.join(tmpDir, 'src', 'new.js'), 'console.log("new");');
+  // Prepare restore — should warn about new file
+  const restoreReport = vm.prepareRestore(backup1.versionId);
+  assert(restoreReport.newFilesNotInBackup.length > 0, 'Should detect new files not in backup');
+  assert(restoreReport.newFilesNotInBackup.some(f => f.includes('new.js')), 'Should list new.js as not in backup');
+  console.log('  OK\n');
+
+  // --- Test 9: AI Adapter degradation ---
+  console.log('  [9] AI Adapter degradation...');
+  const ai = require('../src/ai/adapter');
+  const findings_input = [{ ruleId: 'test', severity: 'warn', message: 'test', file: 'test.js' }];
+  const aiResult = await ai.analyze(null, findings_input, {});
+  assert(aiResult[0].aiAnalysisUnavailable === true, 'Should mark AI analysis as unavailable when no provider');
+  console.log('  OK\n');
+
+  // --- Test 10: ArchRiskAssessor ---
+  console.log('  [10] ArchRiskAssessor...');
+  const { ArchRiskAssessor } = require('../src/modules/dev-time/arch-risk-assessor');
+  const ar = new ArchRiskAssessor(tmpDir);
+  const recoveryCode = `
+function recover(error) {
+  try {
+    doSomething();
+  } catch (e) {
+    recover(e);  // self-invocation in catch — infinite loop risk!
+  }
+}
+`;
+  const archFindings = ar.analyzeFile('recovery.js', recoveryCode);
+  assert(archFindings.some(f => f.ruleId === 'ar-recovery-loop'), 'Should detect recovery loop pattern');
+  console.log('  OK\n');
+
+  // --- Test 11-17: Phase 3 new rules ---
+  // Reuse codeQualityRules already imported in Test 5
+  const ruleMap = {};
+  for (const r of codeQualityRules) ruleMap[r.id] = r;
+  const api_response_naming = ruleMap['cq-api-naming-drift'];
+  const fetch_no_catch = ruleMap['cq-fetch-no-catch'];
+  const console_log_residual = ruleMap['cq-console-log'];
+  const missing_await = ruleMap['cq-missing-await'];
+  const event_listener_leak = ruleMap['cq-event-listener-leak'];
+
+  // --- Test 11: Phase 3 new rules - API naming drift ---
+  console.log('  [11] API naming drift detection...');
+  const namingCtx = {
+    files: [
+      { path: 'api1.js', content: 'const data = response.data.items.map(x => x);' },
+      { path: 'api2.js', content: 'const data = response.data.records.map(x => x);' },
+      { path: 'api3.js', content: 'const data = response.data.list.map(x => x);' },
+    ],
+  };
+  const namingResult = api_response_naming.check(namingCtx);
+  assert(namingResult && namingResult.length > 0, 'Should detect API naming drift with 3 variants');
+  assert(namingResult.some(f => f.severity === 'block'), 'API naming drift should be block severity');
+  console.log('  OK\n');
+
+  // --- Test 12: fetch without catch ---
+  console.log('  [12] fetch no-catch detection...');
+  const fetchCtx = {
+    files: [
+      { path: 'app.js', content: 'fetch("/api/data").then(r => r.json())' },
+    ],
+  };
+  const fetchResult = fetch_no_catch.check(fetchCtx);
+  assert(fetchResult && fetchResult.length > 0, 'Should detect fetch without .catch()');
+  console.log('  OK\n');
+
+  // --- Test 13: console.log residual ---
+  console.log('  [13] console.log residual detection...');
+  const consoleCtx = {
+    files: [
+      { path: 'app.js', content: 'console.log("debug1");\nconsole.log("debug2");\nconsole.log("debug3");\nconsole.log("debug4");\nconsole.log("debug5");\nconsole.log("debug6");' },
+    ],
+  };
+  const consoleResult = console_log_residual.check(consoleCtx);
+  assert(consoleResult && consoleResult.some(f => f.severity === 'warn'), 'Should warn on excessive console.log');
+  console.log('  OK\n');
+
+  // --- Test 14: missing await ---
+  console.log('  [14] missing await detection...');
+  const awaitCtx = {
+    files: [
+      { path: 'app.js', content: 'loadData();\nfetchData();' },
+    ],
+  };
+  const awaitResult = missing_await.check(awaitCtx);
+  assert(awaitResult && awaitResult.length > 0, 'Should detect missing await on async-like calls');
+  console.log('  OK\n');
+
+  // --- Test 15: event listener leak ---
+  console.log('  [15] event listener leak detection...');
+  const leakCtx = {
+    files: [
+      { path: 'app.js', content: Array(101).fill('document.addEventListener("click", handler);').join('\n') },
+    ],
+  };
+  const leakResult = event_listener_leak.check(leakCtx);
+  assert(leakResult && leakResult.length > 0, 'Should detect event listener without cleanup');
+  console.log('  OK\n');
+
+  // --- Test 16: inject command generates .cursorrules ---
+  console.log('  [16] inject command (convention file generation)...');
+  // Test by generating content directly (reuse ConventionStore from Test 4)
+  const injectStore = new ConventionStore(tmpDir);
+  injectStore.add({ id: 'test-rule', rule: 'Test rule', severity: 'block', category: 'api' });
+  const promptBlock = injectStore.getPromptBlock({});
+  assert(promptBlock.includes('test-rule'), 'Prompt block should contain convention id');
+  assert(promptBlock.includes('Test rule'), 'Prompt block should contain convention rule');
+  console.log('  OK\n');
+
+  // --- Test 17: AI adapter Chinese prompt ---
+  console.log('  [17] AI adapter Chinese prompt...');
+  const { buildPrompt } = ai;
+  const testFindings = [{ ruleId: 'test', severity: 'warn', message: '测试问题', file: 'test.js' }];
+  const { systemPrompt, userPrompt } = buildPrompt(testFindings, {});
+  assert(systemPrompt.includes('根因分析'), 'System prompt should be in Chinese');
+  assert(userPrompt.includes('测试问题'), 'User prompt should contain finding message');
+  assert(userPrompt.includes('发现'), 'User prompt should use Chinese labels');
+  console.log('  OK\n');
+
+  // --- Test 18: Inline ignore comments ---
+  console.log('  [18] inline ignore comments...');
+  const { filterIgnored } = require('../src/cli/shared/inline-ignore');
+  const ignoreCode = [
+    'const x = data.items.map(i => i);',
+    '// devassist-ignore-next-line',
+    'const y = data.records.map(r => r);',
+    'const z = data.list.map(l => l);',
+  ].join('\n');
+  const ignoreFindings = [
+    { file: 'test.js', line: 1, ruleId: 'cq-api-naming-drift', severity: 'block', message: 'items' },
+    { file: 'test.js', line: 3, ruleId: 'cq-api-naming-drift', severity: 'block', message: 'records' },
+    { file: 'test.js', line: 4, ruleId: 'cq-api-naming-drift', severity: 'block', message: 'list' },
+  ];
+  const filtered = filterIgnored(ignoreFindings, [{ path: 'test.js', content: ignoreCode }]);
+  assert(filtered.length === 2, 'Should filter out the ignored line (line 3), keeping 2 of 3');
+  assert(!filtered.some(f => f.line === 3), 'Line 3 should be filtered out by ignore-next-line');
+  console.log('  OK\n');
+
+  // --- Test 19: Config loader ---
+  console.log('  [19] config loader...');
+  const { loadConfig, applyConfigToFindings } = require('../src/cli/shared/config-loader');
+  const testConfig = { maxFileLines: 500, rules: { 'cq-magic-numbers': { enabled: false }, 'cq-console-log': { severity: 'warn' } } };
+  const testFindings2 = [
+    { ruleId: 'cq-magic-numbers', severity: 'info', message: 'magic number 42', file: 'a.js', line: 1 },
+    { ruleId: 'cq-console-log', severity: 'info', message: 'console.log', file: 'b.js', line: 2 },
+    { ruleId: 'cq-null-safety', severity: 'warn', message: 'null risk', file: 'c.js', line: 3 },
+  ];
+  const filtered2 = applyConfigToFindings(testConfig, testFindings2);
+  assert(filtered2.length === 2, 'Should disable magic-numbers rule, keeping 2 of 3');
+  assert(!filtered2.some(f => f.ruleId === 'cq-magic-numbers'), 'Magic numbers should be disabled');
+  assert(filtered2.some(f => f.ruleId === 'cq-console-log' && f.severity === 'warn'), 'Console log severity should be overridden to warn');
+  console.log('  OK\n');
+
+  // --- Test 20: Code context extractor ---
+  console.log('  [20] code context extractor...');
+  const { extractContext, enrichWithContext } = require('../src/cli/shared/code-context');
+  const testCode = 'line1\nline2\nline3\nline4\nline5\nconst bad = data.items;\nline7\nline8\nline9\nline10\nline11';
+  const ctx2 = extractContext(testCode, 6, 2);
+  assert(ctx2.includes('>>>'), 'Context should mark the target line with >>>');
+  assert(ctx2.includes('data.items'), 'Context should include the problematic line');
+  const enriched = enrichWithContext(
+    [{ file: 'test.js', line: 6, ruleId: 'test', severity: 'warn', message: 'test' }],
+    [{ path: 'test.js', content: testCode }]
+  );
+  assert(enriched[0].codeContext && enriched[0].codeContext.includes('>>>'), 'Finding should be enriched with code context');
+  console.log('  OK\n');
+
+  // --- Test 21: Shared file collector ---
+  console.log('  [21] shared file collector...');
+  const { collectFileContents } = require('../src/cli/shared/file-collector');
+  // Collect files from the devassist project itself
+  const collected = collectFileContents(path.join(__dirname, '..'));
+  assert(collected.length > 0, 'Should collect source files from devassist project');
+  assert(collected.some(f => f.path.includes('check.js')), 'Should include check.js');
+  assert(collected.every(f => typeof f.content === 'string'), 'All files should have content');
+  console.log('  OK\n');
+
+  // --- Test 22: Security and performance rules (Phase 5) ---
+  console.log('  [22] security and performance rules...');
+  {
+    const { engine: eng } = require('../src/core/rule-engine');
+    const { codeQualityRules: rules5 } = require('../src/modules/dev-time/code-quality-guard');
+    eng.registerBatch(rules5);
+
+    const secCode = `
+const crypto = require('crypto');
+const { exec } = require('child_process');
+function parseConfig(str) { return eval(str); }
+function getUser(name) { return db.query(\`SELECT * FROM users WHERE name = '\${name}'\`); }
+const apiKey = 'sk-1234567890abcdef1234567890abcdef';
+const password = 'supersecret123';
+function runCmd(input) { exec('ls ' + input, () => {}); }
+function hashPwd(pwd) { return crypto.createHash('md5').update(pwd).digest('hex'); }
+function render(data) { document.getElementById('out').innerHTML = data; }
+function merge(body) { return Object.assign({}, JSON.parse(body)); }
+`;
+    const perfCode = `
+const fs = require('fs');
+async function readFile(p) { return fs.readFileSync(p, 'utf-8'); }
+async function process(users) { for (const u of users) { await fetchProfile(u.id); } }
+function buildHTML(items) { let html = ''; for (const i of items) { html += '<li>' + i + '</li>'; } return html; }
+function validateAll(inputs) { for (const input of inputs) { const re = new RegExp('^[a-z]+$'); if (!re.test(input)) return false; } return true; }
+function parseData(raw) { return JSON.parse(raw); }
+async function getAll() { return await Model.find({}); }
+`;
+    const ctx5 = {
+      files: [
+        { path: 'security-sample.js', content: secCode },
+        { path: 'perf-sample.js', content: perfCode },
+      ],
+      projectRoot: '.',
+      config: {},
+    };
+    const result5 = eng.run(ctx5);
+    const ids = result5.findings.map(f => f.ruleId);
+    assert(ids.includes('sec-eval-usage'), 'sec-eval-usage triggers');
+    assert(ids.includes('sec-sql-injection'), 'sec-sql-injection triggers');
+    assert(ids.includes('sec-hardcoded-secrets'), 'sec-hardcoded-secrets triggers');
+    assert(ids.includes('sec-command-injection'), 'sec-command-injection triggers');
+    assert(ids.includes('sec-insecure-crypto'), 'sec-insecure-crypto triggers');
+    assert(ids.includes('sec-xss-risk'), 'sec-xss-risk triggers');
+    assert(ids.includes('sec-proto-pollution'), 'sec-proto-pollution triggers');
+    assert(ids.includes('perf-sync-io-in-async'), 'perf-sync-io-in-async triggers');
+    assert(ids.includes('perf-n-plus-1'), 'perf-n-plus-1 triggers');
+    assert(ids.includes('perf-string-concat-loop'), 'perf-string-concat-loop triggers');
+    assert(ids.includes('perf-regex-in-loop'), 'perf-regex-in-loop triggers');
+    assert(ids.includes('perf-json-parse-unsafe'), 'perf-json-parse-unsafe triggers');
+    assert(ids.includes('perf-no-pagination'), 'perf-no-pagination triggers');
+  }
+  console.log('  OK\n');
+
+  // --- Summary ---
+  console.log('  ====================');
+  console.log(`  ${passed} passed, ${failed} failed`);
+  if (failed > 0) {
+    console.log('\n  Failures:');
+    failures.forEach(f => console.log(`    - ${f}`));
+  }
+  console.log();
+
+  // Cleanup
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
+
+  return failed === 0;
+}
+
+runTests().then(success => {
+  process.exit(success ? 0 : 1);
+}).catch(err => {
+  console.error('Test suite error:', err);
+  process.exit(1);
+});