@aiready/context-analyzer 0.21.22 → 0.21.23

package/src/__tests__/consolidation.test.ts

@@ -0,0 +1,247 @@
+import { describe, it, expect } from 'vitest';
+import { findConsolidationCandidates } from '../semantic/consolidation';
+import type { DependencyGraph, DependencyNode } from '../types';
+
+describe('findConsolidationCandidates', () => {
+  const createMockGraph = (
+    nodes: Map<string, DependencyNode>
+  ): DependencyGraph => ({
+    nodes,
+    edges: new Map(),
+    coUsageMatrix: new Map(),
+    typeGraph: new Map(),
+  });
+
+  it('should return empty array for empty coUsageMatrix', () => {
+    const graph = createMockGraph(new Map());
+    const coUsageMatrix = new Map<string, Map<string, number>>();
+    const typeGraph = new Map<string, Set<string>>();
+
+    const candidates = findConsolidationCandidates(
+      graph,
+      coUsageMatrix,
+      typeGraph
+    );
+
+    expect(candidates).toEqual([]);
+  });
+
+  it('should find candidates with high co-usage', () => {
+    const nodes = new Map<string, DependencyNode>([
+      [
+        'fileA.ts',
+        {
+          file: 'fileA.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+      [
+        'fileB.ts',
+        {
+          file: 'fileB.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+    ]);
+    const graph = createMockGraph(nodes);
+
+    const coUsageMatrix = new Map<string, Map<string, number>>();
+    coUsageMatrix.set('fileA.ts', new Map([['fileB.ts', 10]]));
+    coUsageMatrix.set('fileB.ts', new Map([['fileA.ts', 10]]));
+
+    const typeGraph = new Map<string, Set<string>>();
+
+    const candidates = findConsolidationCandidates(
+      graph,
+      coUsageMatrix,
+      typeGraph
+    );
+
+    // Should have at least one candidate
+    expect(candidates.length).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should filter out candidates below minCoUsage threshold', () => {
+    const nodes = new Map<string, DependencyNode>([
+      [
+        'fileA.ts',
+        {
+          file: 'fileA.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+      [
+        'fileB.ts',
+        {
+          file: 'fileB.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+    ]);
+    const graph = createMockGraph(nodes);
+
+    const coUsageMatrix = new Map<string, Map<string, number>>();
+    coUsageMatrix.set('fileA.ts', new Map([['fileB.ts', 2]]));
+
+    const typeGraph = new Map<string, Set<string>>();
+
+    const candidates = findConsolidationCandidates(
+      graph,
+      coUsageMatrix,
+      typeGraph,
+      5,
+      2
+    );
+
+    expect(candidates).toEqual([]);
+  });
+
+  it('should handle files with exports but no type references', () => {
+    const nodes = new Map<string, DependencyNode>([
+      [
+        'fileA.ts',
+        {
+          file: 'fileA.ts',
+          imports: [],
+          exports: [{ name: 'MyClass', type: 'class' }],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+      [
+        'fileB.ts',
+        {
+          file: 'fileB.ts',
+          imports: [],
+          exports: [{ name: 'OtherClass', type: 'class' }],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+    ]);
+    const graph = createMockGraph(nodes);
+
+    const coUsageMatrix = new Map<string, Map<string, number>>();
+    coUsageMatrix.set('fileA.ts', new Map([['fileB.ts', 20]]));
+
+    const typeGraph = new Map<string, Set<string>>();
+
+    const candidates = findConsolidationCandidates(
+      graph,
+      coUsageMatrix,
+      typeGraph,
+      5,
+      10
+    );
+
+    // With very high co-usage, should find candidates
+    expect(Array.isArray(candidates)).toBe(true);
+  });
+
+  it('should sort candidates by strength descending', () => {
+    const nodes = new Map<string, DependencyNode>([
+      [
+        'fileA.ts',
+        {
+          file: 'fileA.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+      [
+        'fileB.ts',
+        {
+          file: 'fileB.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+      [
+        'fileC.ts',
+        {
+          file: 'fileC.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+    ]);
+    const graph = createMockGraph(nodes);
+
+    const coUsageMatrix = new Map<string, Map<string, number>>();
+    coUsageMatrix.set('fileA.ts', new Map([['fileB.ts', 5]]));
+    coUsageMatrix.set(
+      'fileB.ts',
+      new Map([
+        ['fileA.ts', 5],
+        ['fileC.ts', 20],
+      ])
+    );
+    coUsageMatrix.set('fileC.ts', new Map([['fileB.ts', 20]]));
+
+    const typeGraph = new Map<string, Set<string>>();
+
+    const candidates = findConsolidationCandidates(
+      graph,
+      coUsageMatrix,
+      typeGraph,
+      5,
+      2
+    );
+
+    // If sorted, verify ordering
+    if (candidates.length > 1) {
+      for (let i = 0; i < candidates.length - 1; i++) {
+        expect(candidates[i].strength).toBeGreaterThanOrEqual(
+          candidates[i + 1].strength
+        );
+      }
+    }
+  });
+
+  it('should skip files not in graph', () => {
+    const nodes = new Map<string, DependencyNode>([
+      [
+        'fileA.ts',
+        {
+          file: 'fileA.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+    ]);
+    const graph = createMockGraph(nodes);
+
+    const coUsageMatrix = new Map<string, Map<string, number>>();
+    coUsageMatrix.set('fileA.ts', new Map([['unknownFile.ts', 10]]));
+
+    const typeGraph = new Map<string, Set<string>>();
+
+    const candidates = findConsolidationCandidates(
+      graph,
+      coUsageMatrix,
+      typeGraph
+    );
+
+    expect(candidates).toEqual([]);
+  });
+});

package/src/__tests__/defaults.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getSmartDefaults } from '../defaults';
+import * as core from '@aiready/core';
+
+vi.mock('@aiready/core', async () => {
+  const actual = await vi.importActual('@aiready/core');
+  return {
+    ...actual,
+    scanFiles: vi.fn(),
+  };
+});
+
+describe('getSmartDefaults', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return small repo defaults for <100 files', async () => {
+    vi.mocked(core.scanFiles).mockResolvedValue(
+      Array(50)
+        .fill('')
+        .map((_, i) => `file${i}.ts`)
+    );
+
+    const defaults = await getSmartDefaults('.', {});
+
+    expect(defaults.maxDepth).toBe(5);
+    expect(defaults.maxContextBudget).toBe(8000);
+    expect(defaults.minCohesion).toBe(0.5);
+    expect(defaults.maxFragmentation).toBe(0.5);
+  });
+
+  it('should return medium repo defaults for 100-500 files', async () => {
+    vi.mocked(core.scanFiles).mockResolvedValue(
+      Array(200)
+        .fill('')
+        .map((_, i) => `file${i}.ts`)
+    );
+
+    const defaults = await getSmartDefaults('.', {});
+
+    expect(defaults.maxDepth).toBe(6);
+    expect(defaults.maxContextBudget).toBe(15000);
+    expect(defaults.minCohesion).toBe(0.45);
+    expect(defaults.maxFragmentation).toBe(0.6);
+  });
+
+  it('should return large repo defaults for 500-2000 files', async () => {
+    vi.mocked(core.scanFiles).mockResolvedValue(
+      Array(1000)
+        .fill('')
+        .map((_, i) => `file${i}.ts`)
+    );
+
+    const defaults = await getSmartDefaults('.', {});
+
+    expect(defaults.maxDepth).toBe(8);
+    expect(defaults.maxContextBudget).toBe(25000);
+    expect(defaults.minCohesion).toBe(0.4);
+    expect(defaults.maxFragmentation).toBe(0.7);
+  });
+
+  it('should return enterprise repo defaults for >2000 files', async () => {
+    vi.mocked(core.scanFiles).mockResolvedValue(
+      Array(3000)
+        .fill('')
+        .map((_, i) => `file${i}.ts`)
+    );
+
+    const defaults = await getSmartDefaults('.', {});
+
+    expect(defaults.maxDepth).toBe(12);
+    expect(defaults.maxContextBudget).toBe(40000);
+    expect(defaults.minCohesion).toBe(0.35);
+    expect(defaults.maxFragmentation).toBe(0.8);
+  });
+
+  it('should always return hardcoded focus and includeNodeModules', async () => {
+    vi.mocked(core.scanFiles).mockResolvedValue(
+      Array(50)
+        .fill('')
+        .map((_, i) => `file${i}.ts`)
+    );
+
+    const defaults = await getSmartDefaults('.', {
+      includeNodeModules: true,
+      focus: 'dependencies' as 'all' | 'fragmentation' | 'cohesion' | 'depth',
+    });
+
+    // Note: getSmartDefaults hardcodes focus='all' and includeNodeModules=false
+    expect(defaults.focus).toBe('all');
+    expect(defaults.includeNodeModules).toBe(false);
+  });
+
+  it('should use provided rootDir or fall back to directory', async () => {
+    vi.mocked(core.scanFiles).mockResolvedValue([]);
+
+    const defaults1 = await getSmartDefaults('/project', {});
+    expect(defaults1.rootDir).toBe('/project');
+
+    const defaults2 = await getSmartDefaults('/project', {
+      rootDir: '/custom',
+    });
+    expect(defaults2.rootDir).toBe('/custom');
+  });
+
+  it('should pass include/exclude to scanFiles', async () => {
+    vi.mocked(core.scanFiles).mockResolvedValue([]);
+
+    await getSmartDefaults('.', {
+      include: ['**/*.ts'],
+      exclude: ['**/node_modules/**'],
+    });
+
+    expect(core.scanFiles).toHaveBeenCalledWith({
+      rootDir: '.',
+      include: ['**/*.ts'],
+      exclude: ['**/node_modules/**'],
+    });
+  });
+});