claude-mycelium 2.0.0

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

@@ -0,0 +1,355 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+import {
+  calculateChurn,
+  calculateChurnBatch,
+  clearChurnCache,
+  getChurnCacheStats,
+} from '../../../src/core/signals/churn';
+
+const TEST_DIR = '.test-temp-churn';
+
+describe('churn signal', () => {
+  beforeEach(() => {
+    // Clean up any previous test artifacts
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+
+    // Clear cache before each test
+    clearChurnCache();
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+    clearChurnCache();
+  });
+
+  describe('calculateChurn', () => {
+    it('returns zero churn for non-git directory', async () => {
+      const testFile = path.join(TEST_DIR, 'test.ts');
+      fs.writeFileSync(testFile, 'console.log("test");');
+
+      const result = await calculateChurn(testFile);
+
+      expect(result.commits).toBe(0);
+      expect(result.normalized).toBe(0);
+    });
+
+    it('calculates churn for git repository', async () => {
+      // Initialize git repo
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      // Create and commit a file
+      const testFile = path.join(TEST_DIR, 'test.ts');
+      fs.writeFileSync(testFile, 'console.log("test");');
+      execSync('git add test.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Initial commit"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const result = await calculateChurn(testFile);
+
+      expect(result.commits).toBe(1);
+      expect(result.normalized).toBeGreaterThanOrEqual(0);
+      expect(result.normalized).toBeLessThanOrEqual(1);
+      expect(result.cachedAt).toBeInstanceOf(Date);
+    });
+
+    it('normalizes churn correctly with multiple files', async () => {
+      // Initialize git repo
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      // Create files with different churn rates
+      const file1 = path.join(TEST_DIR, 'high-churn.ts');
+      const file2 = path.join(TEST_DIR, 'low-churn.ts');
+
+      // File 1: 3 commits
+      fs.writeFileSync(file1, 'console.log("v1");');
+      execSync('git add high-churn.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Commit 1"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      fs.writeFileSync(file1, 'console.log("v2");');
+      execSync('git add high-churn.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Commit 2"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      fs.writeFileSync(file1, 'console.log("v3");');
+      execSync('git add high-churn.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Commit 3"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      // File 2: 1 commit
+      fs.writeFileSync(file2, 'console.log("stable");');
+      execSync('git add low-churn.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Commit 4"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      // Clear cache to force rebuild
+      clearChurnCache();
+
+      const result1 = await calculateChurn(file1);
+      const result2 = await calculateChurn(file2);
+
+      // High churn file should have normalized = 1.0 (max)
+      expect(result1.commits).toBe(3);
+      expect(result1.normalized).toBe(1.0);
+
+      // Low churn file should have normalized = 1/3
+      expect(result2.commits).toBe(1);
+      expect(result2.normalized).toBeCloseTo(1 / 3, 2);
+    });
+
+    it('uses cache for subsequent calls', async () => {
+      // Initialize git repo with one commit
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const testFile = path.join(TEST_DIR, 'test.ts');
+      fs.writeFileSync(testFile, 'console.log("test");');
+      execSync('git add test.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Initial"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      // First call
+      const result1 = await calculateChurn(testFile);
+
+      // Second call should use cache (same cachedAt timestamp)
+      const result2 = await calculateChurn(testFile);
+
+      expect(result1.cachedAt).toEqual(result2.cachedAt);
+      expect(result1.commits).toBe(result2.commits);
+    });
+
+    it('handles files with no commits', async () => {
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      // Create file but don't commit
+      const testFile = path.join(TEST_DIR, 'untracked.ts');
+      fs.writeFileSync(testFile, 'console.log("untracked");');
+
+      // Commit another file to have some git history
+      const committedFile = path.join(TEST_DIR, 'committed.ts');
+      fs.writeFileSync(committedFile, 'console.log("committed");');
+      execSync('git add committed.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Commit"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      clearChurnCache();
+
+      const result = await calculateChurn(testFile);
+
+      expect(result.commits).toBe(0);
+      expect(result.normalized).toBe(0);
+    });
+
+    it('respects 30-day lookback window', async () => {
+      // This test verifies the implementation uses --since="30 days"
+      // We can't easily create old commits in a unit test,
+      // so we just verify the behavior with recent commits
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const testFile = path.join(TEST_DIR, 'test.ts');
+      fs.writeFileSync(testFile, 'console.log("test");');
+      execSync('git add test.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Recent commit"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const result = await calculateChurn(testFile);
+
+      // Recent commit should be counted
+      expect(result.commits).toBeGreaterThan(0);
+    });
+  });
+
+  describe('cache behavior', () => {
+    it('cache expires after TTL', async () => {
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const testFile = path.join(TEST_DIR, 'test.ts');
+      fs.writeFileSync(testFile, 'console.log("test");');
+      execSync('git add test.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Commit"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      // First call builds cache
+      await calculateChurn(testFile);
+
+      const stats = getChurnCacheStats();
+      expect(stats).not.toBeNull();
+      expect(stats?.cached).toBe(true);
+      expect(stats?.fileCount).toBeGreaterThan(0);
+      expect(stats?.expiresIn).toBeGreaterThan(0);
+    });
+
+    it('clearChurnCache removes cached data', async () => {
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const testFile = path.join(TEST_DIR, 'test.ts');
+      fs.writeFileSync(testFile, 'console.log("test");');
+      execSync('git add test.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Commit"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      await calculateChurn(testFile);
+
+      let stats = getChurnCacheStats();
+      expect(stats).not.toBeNull();
+
+      clearChurnCache();
+
+      stats = getChurnCacheStats();
+      expect(stats).toBeNull();
+    });
+  });
+
+  describe('calculateChurnBatch', () => {
+    it('calculates churn for multiple files efficiently', async () => {
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      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, 'console.log("file1");');
+      fs.writeFileSync(file2, 'console.log("file2");');
+      fs.writeFileSync(file3, 'console.log("file3");');
+
+      execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Add files"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      fs.writeFileSync(file1, 'console.log("file1 v2");');
+      execSync('git add file1.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Update file1"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      clearChurnCache();
+
+      const results = await calculateChurnBatch([file1, file2, file3]);
+
+      expect(results.size).toBe(3);
+      expect(results.get(file1)?.commits).toBe(2);
+      expect(results.get(file2)?.commits).toBe(1);
+      expect(results.get(file3)?.commits).toBe(1);
+
+      // File1 should have max normalized value
+      expect(results.get(file1)?.normalized).toBe(1.0);
+    });
+
+    it('reuses cache across batch operations', async () => {
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const file1 = path.join(TEST_DIR, 'file1.ts');
+      fs.writeFileSync(file1, 'console.log("file1");');
+      execSync('git add file1.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Commit"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      clearChurnCache();
+
+      const results = await calculateChurnBatch([file1]);
+
+      // Cache should be built
+      const stats = getChurnCacheStats();
+      expect(stats).not.toBeNull();
+      expect(stats?.fileCount).toBeGreaterThan(0);
+
+      // All results should have same cachedAt timestamp
+      const cachedAt = results.get(file1)?.cachedAt;
+      expect(cachedAt).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('handles empty git repository', async () => {
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const testFile = path.join(TEST_DIR, 'test.ts');
+      fs.writeFileSync(testFile, 'console.log("test");');
+
+      const result = await calculateChurn(testFile);
+
+      expect(result.commits).toBe(0);
+      expect(result.normalized).toBe(0);
+    });
+
+    it('handles files with special characters in name', async () => {
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const testFile = path.join(TEST_DIR, 'test-file.component.ts');
+      fs.writeFileSync(testFile, 'console.log("test");');
+      execSync('git add "test-file.component.ts"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Add file"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      clearChurnCache();
+
+      const result = await calculateChurn(testFile);
+
+      expect(result.commits).toBe(1);
+      expect(result.normalized).toBeGreaterThanOrEqual(0);
+    });
+
+    it('handles large number of commits gracefully', async () => {
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const testFile = path.join(TEST_DIR, 'active-file.ts');
+
+      // Create 10 commits (representing high churn)
+      for (let i = 1; i <= 10; i++) {
+        fs.writeFileSync(testFile, `console.log("version ${i}");`);
+        execSync('git add active-file.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+        execSync(`git commit -m "Update ${i}"`, { cwd: TEST_DIR, stdio: 'ignore' });
+      }
+
+      clearChurnCache();
+
+      const result = await calculateChurn(testFile);
+
+      expect(result.commits).toBe(10);
+      expect(result.normalized).toBe(1.0);
+    });
+  });
+
+  describe('getChurnCacheStats', () => {
+    it('returns null when no cache exists', () => {
+      const stats = getChurnCacheStats();
+      expect(stats).toBeNull();
+    });
+
+    it('returns cache statistics when cache exists', async () => {
+      execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git config user.email "test@example.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      const testFile = path.join(TEST_DIR, 'test.ts');
+      fs.writeFileSync(testFile, 'console.log("test");');
+      execSync('git add test.ts', { cwd: TEST_DIR, stdio: 'ignore' });
+      execSync('git commit -m "Commit"', { cwd: TEST_DIR, stdio: 'ignore' });
+
+      await calculateChurn(testFile);
+
+      const stats = getChurnCacheStats();
+
+      expect(stats).not.toBeNull();
+      expect(stats?.cached).toBe(true);
+      expect(stats?.fileCount).toBeGreaterThan(0);
+      expect(stats?.maxChurn).toBeGreaterThan(0);
+      expect(stats?.expiresIn).toBeGreaterThan(0);
+      expect(stats?.expiresIn).toBeLessThanOrEqual(300); // 5 minutes max
+    });
+  });
+});

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

@@ -0,0 +1,284 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { calculateComplexity } from '../../../src/core/signals/complexity';
+
+const TEST_DIR = '.test-temp-complexity';
+
+describe('complexity signal', () => {
+  beforeEach(() => {
+    if (!fs.existsSync(TEST_DIR)) {
+      fs.mkdirSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe('calculateComplexity', () => {
+    it('calculates complexity for simple function', async () => {
+      const testFile = path.join(TEST_DIR, 'simple.ts');
+      const content = `
+function add(a: number, b: number): number {
+  return a + b;
+}
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      expect(result.cyclomaticComplexity).toBe(1); // Base complexity
+      expect(result.loc).toBeGreaterThan(0);
+      expect(result.normalized).toBeGreaterThanOrEqual(0);
+      expect(result.normalized).toBeLessThanOrEqual(1);
+    });
+
+    it('counts if statements', async () => {
+      const testFile = path.join(TEST_DIR, 'if.ts');
+      const content = `
+function checkValue(x: number): string {
+  if (x > 0) {
+    return 'positive';
+  } else if (x < 0) {
+    return 'negative';
+  } else {
+    return 'zero';
+  }
+}
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      // Base (1) + if (1) + else if (1) = 3
+      expect(result.cyclomaticComplexity).toBe(3);
+    });
+
+    it('counts loops', async () => {
+      const testFile = path.join(TEST_DIR, 'loops.ts');
+      const content = `
+function process(items: number[]): void {
+  for (let i = 0; i < items.length; i++) {
+    console.log(items[i]);
+  }
+
+  while (items.length > 0) {
+    items.pop();
+  }
+
+  for (const item of items) {
+    console.log(item);
+  }
+}
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      // Base (1) + for (1) + while (1) + for-of (1) = 4
+      expect(result.cyclomaticComplexity).toBe(4);
+    });
+
+    it('counts switch cases', async () => {
+      const testFile = path.join(TEST_DIR, 'switch.ts');
+      const content = `
+function getDay(day: number): string {
+  switch (day) {
+    case 1:
+      return 'Monday';
+    case 2:
+      return 'Tuesday';
+    case 3:
+      return 'Wednesday';
+    default:
+      return 'Unknown';
+  }
+}
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      // Base (1) + case1 (1) + case2 (1) + case3 (1) = 4
+      // (default doesn't count)
+      expect(result.cyclomaticComplexity).toBe(4);
+    });
+
+    it('counts logical operators', async () => {
+      const testFile = path.join(TEST_DIR, 'logical.ts');
+      const content = `
+function validate(x: number, y: number): boolean {
+  return x > 0 && y > 0 || x === 0 && y === 0;
+}
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      // Base (1) + && (1) + || (1) + && (1) = 4
+      expect(result.cyclomaticComplexity).toBe(4);
+    });
+
+    it('counts try-catch', async () => {
+      const testFile = path.join(TEST_DIR, 'trycatch.ts');
+      const content = `
+function riskyOperation(): void {
+  try {
+    throw new Error('test');
+  } catch (error) {
+    console.error(error);
+  }
+}
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      // Base (1) + catch (1) = 2
+      expect(result.cyclomaticComplexity).toBe(2);
+    });
+
+    it('counts ternary operators', async () => {
+      const testFile = path.join(TEST_DIR, 'ternary.ts');
+      const content = `
+function classify(x: number): string {
+  return x > 0 ? 'positive' : x < 0 ? 'negative' : 'zero';
+}
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      // Base (1) + ternary (1) + nested ternary (1) = 3
+      expect(result.cyclomaticComplexity).toBe(3);
+    });
+
+    it('normalizes complexity correctly', async () => {
+      const testFile = path.join(TEST_DIR, 'normalize.ts');
+      // Create file with complexity 10, 20 LOC
+      // (10 / 20) / 0.5 = 1.0
+      const content = `
+function complex(x: number): number {
+  if (x > 0) {
+    if (x > 10) {
+      if (x > 20) {
+        return 1;
+      }
+    }
+  }
+  if (x < 0) {
+    if (x < -10) {
+      if (x < -20) {
+        return -1;
+      }
+    }
+  }
+  return 0;
+}
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      expect(result.normalized).toBeGreaterThan(0);
+      expect(result.normalized).toBeLessThanOrEqual(1.0);
+    });
+
+    it('excludes comments from LOC', async () => {
+      const testFile = path.join(TEST_DIR, 'comments.ts');
+      const content = `
+// This is a comment
+function add(a: number, b: number): number {
+  // Another comment
+  return a + b; // Inline comment
+}
+
+/*
+ * Block comment
+ * Multiple lines
+ */
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      // Should only count actual code lines, not comments
+      expect(result.loc).toBeLessThan(content.split('\n').length);
+    });
+
+    it('handles complex real-world function', async () => {
+      const testFile = path.join(TEST_DIR, 'realworld.ts');
+      const content = `
+function processData(data: any[]): any[] {
+  const result = [];
+
+  for (const item of data) {
+    if (item.type === 'user') {
+      if (item.active && item.verified) {
+        result.push(item);
+      }
+    } else if (item.type === 'admin') {
+      if (item.permissions.includes('write')) {
+        result.push(item);
+      }
+    }
+
+    try {
+      if (item.metadata) {
+        item.metadata.processed = true;
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
+  return result.length > 0 ? result : [];
+}
+`.trim();
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      // Should have significant complexity
+      expect(result.cyclomaticComplexity).toBeGreaterThan(5);
+      expect(result.normalized).toBeGreaterThan(0);
+    });
+
+    it('returns zero for non-TypeScript files', async () => {
+      const testFile = path.join(TEST_DIR, 'data.json');
+      fs.writeFileSync(testFile, '{"key": "value"}');
+
+      const result = await calculateComplexity(testFile);
+
+      expect(result.cyclomaticComplexity).toBe(0);
+      expect(result.normalized).toBe(0);
+    });
+
+    it('handles syntax errors gracefully', async () => {
+      const testFile = path.join(TEST_DIR, 'invalid.ts');
+      const content = 'function broken() { this is not valid typescript';
+
+      fs.writeFileSync(testFile, content);
+
+      const result = await calculateComplexity(testFile);
+
+      // Should fallback to zero complexity
+      expect(result.cyclomaticComplexity).toBe(0);
+      expect(result.normalized).toBe(0);
+      expect(result.loc).toBeGreaterThan(0);
+    });
+  });
+});