claude-mycelium 2.0.0

package/tests/core/signals/errors.test.ts

@@ -0,0 +1,350 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { calculateErrorRate, calculateErrorRateBatch } from '../../../src/core/signals/errors';
+
+const TEST_DIR = '.test-temp-errors';
+const ERROR_FILE = path.join(TEST_DIR, '.agent-meta', '_errors.json');
+
+describe('error signal', () => {
+  beforeEach(() => {
+    // Create test directories
+    if (!fs.existsSync(TEST_DIR)) {
+      fs.mkdirSync(TEST_DIR, { recursive: true });
+    }
+    const metaDir = path.join(TEST_DIR, '.agent-meta');
+    if (!fs.existsSync(metaDir)) {
+      fs.mkdirSync(metaDir, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe('calculateErrorRate', () => {
+    it('calculates error rate for file with errors', async () => {
+      // Create test file
+      const testFile = path.join(TEST_DIR, 'buggy.ts');
+      const content = `
+function broken(): void {
+  // This file has errors
+  console.log('test');
+}
+`.trim();
+      fs.writeFileSync(testFile, content);
+
+      // Create error data
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [
+          {
+            file: testFile,
+            count: 5,
+            types: ['TypeError', 'ReferenceError'],
+          },
+        ],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(5);
+      expect(result.types).toEqual(['TypeError', 'ReferenceError']);
+      expect(result.normalized).toBeGreaterThan(0);
+      expect(result.normalized).toBeLessThanOrEqual(1.0);
+    });
+
+    it('returns zero for file not in error data', async () => {
+      const testFile = path.join(TEST_DIR, 'clean.ts');
+      const content = `function good(): void { console.log('test'); }`;
+      fs.writeFileSync(testFile, content);
+
+      // Create error data for different file
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [
+          {
+            file: path.join(TEST_DIR, 'other.ts'),
+            count: 3,
+            types: ['TypeError'],
+          },
+        ],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(0);
+      expect(result.types).toEqual([]);
+      expect(result.normalized).toBe(0);
+    });
+
+    it('returns zero when error file does not exist', async () => {
+      const testFile = path.join(TEST_DIR, 'noerrors.ts');
+      const content = `function test(): void { console.log('test'); }`;
+      fs.writeFileSync(testFile, content);
+
+      // Don't create error file
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(0);
+      expect(result.types).toEqual([]);
+      expect(result.normalized).toBe(0);
+    });
+
+    it('normalizes error rate correctly - low errors', async () => {
+      const testFile = path.join(TEST_DIR, 'low-errors.ts');
+      // Create file with 100 LOC
+      const lines = Array(100)
+        .fill('console.log("line");')
+        .join('\n');
+      fs.writeFileSync(testFile, lines);
+
+      // 2 errors in 100 LOC = 0.02 errors/LOC
+      // (0.02) / 0.1 = 0.2
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [
+          {
+            file: testFile,
+            count: 2,
+            types: ['TypeError'],
+          },
+        ],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(2);
+      expect(result.normalized).toBeCloseTo(0.2, 1);
+    });
+
+    it('normalizes error rate correctly - high errors', async () => {
+      const testFile = path.join(TEST_DIR, 'high-errors.ts');
+      // Create file with 50 LOC
+      const lines = Array(50)
+        .fill('console.log("line");')
+        .join('\n');
+      fs.writeFileSync(testFile, lines);
+
+      // 10 errors in 50 LOC = 0.2 errors/LOC
+      // (0.2) / 0.1 = 2.0, capped at 1.0
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [
+          {
+            file: testFile,
+            count: 10,
+            types: ['TypeError', 'ReferenceError', 'SyntaxError'],
+          },
+        ],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(10);
+      expect(result.normalized).toBe(1.0); // Capped at 1.0
+    });
+
+    it('normalizes error rate correctly - exact threshold', async () => {
+      const testFile = path.join(TEST_DIR, 'threshold.ts');
+      // Create file with 100 LOC
+      const lines = Array(100)
+        .fill('console.log("line");')
+        .join('\n');
+      fs.writeFileSync(testFile, lines);
+
+      // 10 errors in 100 LOC = 0.1 errors/LOC (exactly at threshold)
+      // (0.1) / 0.1 = 1.0
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [
+          {
+            file: testFile,
+            count: 10,
+            types: ['TypeError'],
+          },
+        ],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(10);
+      expect(result.normalized).toBe(1.0);
+    });
+
+    it('handles file with single error', async () => {
+      const testFile = path.join(TEST_DIR, 'single-error.ts');
+      const content = `
+function test(): void {
+  console.log('test');
+}
+`.trim();
+      fs.writeFileSync(testFile, content);
+
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [
+          {
+            file: testFile,
+            count: 1,
+            types: ['TypeError'],
+          },
+        ],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(1);
+      expect(result.types).toEqual(['TypeError']);
+      expect(result.normalized).toBeGreaterThan(0);
+    });
+
+    it('handles file with multiple error types', async () => {
+      const testFile = path.join(TEST_DIR, 'multi-types.ts');
+      const content = `function test(): void { console.log('test'); }`;
+      fs.writeFileSync(testFile, content);
+
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [
+          {
+            file: testFile,
+            count: 8,
+            types: ['TypeError', 'ReferenceError', 'SyntaxError', 'RangeError'],
+          },
+        ],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(8);
+      expect(result.types).toHaveLength(4);
+      expect(result.types).toContain('TypeError');
+      expect(result.types).toContain('ReferenceError');
+      expect(result.types).toContain('SyntaxError');
+      expect(result.types).toContain('RangeError');
+    });
+
+    it('handles malformed error JSON gracefully', async () => {
+      const testFile = path.join(TEST_DIR, 'test.ts');
+      const content = `function test(): void { console.log('test'); }`;
+      fs.writeFileSync(testFile, content);
+
+      // Write invalid JSON
+      fs.writeFileSync(ERROR_FILE, '{invalid json}');
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      // Should fallback to zero
+      expect(result.count).toBe(0);
+      expect(result.types).toEqual([]);
+      expect(result.normalized).toBe(0);
+    });
+
+    it('handles empty error array', async () => {
+      const testFile = path.join(TEST_DIR, 'empty.ts');
+      const content = `function test(): void { console.log('test'); }`;
+      fs.writeFileSync(testFile, content);
+
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(0);
+      expect(result.types).toEqual([]);
+      expect(result.normalized).toBe(0);
+    });
+
+    it('normalizes with very small LOC file', async () => {
+      const testFile = path.join(TEST_DIR, 'tiny.ts');
+      const content = `const x = 1;`; // 1 line
+      fs.writeFileSync(testFile, content);
+
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [
+          {
+            file: testFile,
+            count: 1,
+            types: ['TypeError'],
+          },
+        ],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const result = await calculateErrorRate(testFile, ERROR_FILE);
+
+      expect(result.count).toBe(1);
+      // 1 error in 1 LOC = 1.0 errors/LOC
+      // (1.0) / 0.1 = 10.0, capped at 1.0
+      expect(result.normalized).toBe(1.0);
+    });
+  });
+
+  describe('calculateErrorRateBatch', () => {
+    it('calculates error rates for multiple files', async () => {
+      // Create test files
+      const file1 = path.join(TEST_DIR, 'file1.ts');
+      const file2 = path.join(TEST_DIR, 'file2.ts');
+      const file3 = path.join(TEST_DIR, 'file3.ts');
+
+      fs.writeFileSync(file1, Array(50).fill('console.log("line");').join('\n'));
+      fs.writeFileSync(file2, Array(100).fill('console.log("line");').join('\n'));
+      fs.writeFileSync(file3, Array(25).fill('console.log("line");').join('\n'));
+
+      // Create error data
+      const errorData = {
+        updated_at: new Date().toISOString(),
+        errors: [
+          {
+            file: file1,
+            count: 5,
+            types: ['TypeError'],
+          },
+          {
+            file: file2,
+            count: 3,
+            types: ['ReferenceError'],
+          },
+          // file3 has no errors
+        ],
+      };
+      fs.writeFileSync(ERROR_FILE, JSON.stringify(errorData, null, 2));
+
+      const results = await calculateErrorRateBatch([file1, file2, file3], ERROR_FILE);
+
+      expect(results.size).toBe(3);
+
+      const result1 = results.get(file1)!;
+      expect(result1.count).toBe(5);
+      expect(result1.normalized).toBeGreaterThan(0);
+
+      const result2 = results.get(file2)!;
+      expect(result2.count).toBe(3);
+      expect(result2.normalized).toBeGreaterThan(0);
+
+      const result3 = results.get(file3)!;
+      expect(result3.count).toBe(0);
+      expect(result3.normalized).toBe(0);
+    });
+
+    it('handles empty file list', async () => {
+      const results = await calculateErrorRateBatch([]);
+      expect(results.size).toBe(0);
+    });
+  });
+});