@aiready/context-analyzer 0.21.22 → 0.21.23

package/src/__tests__/domain-inference.test.ts

@@ -0,0 +1,420 @@
+import { describe, it, expect } from 'vitest';
+import {
+  calculateDomainConfidence,
+  inferDomainFromSemantics,
+  extractExports,
+  inferDomain,
+} from '../semantic/domain-inference';
+import type { DependencyGraph, DependencyNode } from '../types';
+
+describe('calculateDomainConfidence', () => {
+  it('should return 0 for no signals', () => {
+    const confidence = calculateDomainConfidence({
+      coUsage: false,
+      typeReference: false,
+      exportName: false,
+      importPath: false,
+      folderStructure: false,
+    });
+    expect(confidence).toBe(0);
+  });
+
+  it('should return weighted confidence for single signal', () => {
+    const confidence = calculateDomainConfidence({
+      coUsage: true,
+      typeReference: false,
+      exportName: false,
+      importPath: false,
+      folderStructure: false,
+    });
+    expect(confidence).toBe(0.35);
+  });
+
+  it('should return weighted confidence for multiple signals', () => {
+    const confidence = calculateDomainConfidence({
+      coUsage: true,
+      typeReference: true,
+      exportName: true,
+      importPath: false,
+      folderStructure: false,
+    });
+    // coUsage(0.35) + typeReference(0.3) + exportName(0.15) = 0.8, but max is 1
+    expect(confidence).toBeGreaterThan(0.7);
+  });
+
+  it('should return 1 for all signals', () => {
+    const confidence = calculateDomainConfidence({
+      coUsage: true,
+      typeReference: true,
+      exportName: true,
+      importPath: true,
+      folderStructure: true,
+    });
+    // Sum is 1.0 but function may cap or floor
+    expect(confidence).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('inferDomainFromSemantics', () => {
+  const createMockGraph = (
+    nodes: Map<string, DependencyNode>
+  ): DependencyGraph => ({
+    nodes,
+    edges: new Map(),
+    coUsageMatrix: new Map(),
+    typeGraph: new Map(),
+  });
+
+  it('should return empty array for no co-usage or type refs', () => {
+    const nodes = new Map<string, DependencyNode>();
+    const graph = createMockGraph(nodes);
+    const coUsageMatrix = new Map<string, Map<string, number>>();
+    const typeGraph = new Map<string, Set<string>>();
+
+    const assignments = inferDomainFromSemantics(
+      'fileA.ts',
+      'testExport',
+      graph,
+      coUsageMatrix,
+      typeGraph
+    );
+
+    expect(assignments).toEqual([]);
+  });
+
+  it('should find domain from strong 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: [
+            { name: 'UserService', type: 'class', inferredDomain: 'user' },
+          ],
+          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]]));
+
+    const typeGraph = new Map<string, Set<string>>();
+
+    const assignments = inferDomainFromSemantics(
+      'fileA.ts',
+      'testExport',
+      graph,
+      coUsageMatrix,
+      typeGraph
+    );
+
+    expect(assignments.length).toBeGreaterThan(0);
+    expect(assignments[0].domain).toBe('user');
+  });
+
+  it('should find domain from type references', () => {
+    const nodes = new Map<string, DependencyNode>([
+      [
+        'fileA.ts',
+        {
+          file: 'fileA.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+      [
+        'fileB.ts',
+        {
+          file: 'fileB.ts',
+          imports: [],
+          exports: [
+            { name: 'UserType', type: 'interface', inferredDomain: 'user' },
+          ],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+    ]);
+    const graph = createMockGraph(nodes);
+
+    const coUsageMatrix = new Map<string, Map<string, number>>();
+
+    const typeGraph = new Map<string, Set<string>>();
+    typeGraph.set('UserType', new Set(['fileB.ts']));
+
+    const assignments = inferDomainFromSemantics(
+      'fileA.ts',
+      'testExport',
+      graph,
+      coUsageMatrix,
+      typeGraph,
+      ['UserType']
+    );
+
+    expect(assignments.length).toBeGreaterThan(0);
+  });
+
+  it('should filter out low confidence assignments', () => {
+    const nodes = new Map<string, DependencyNode>([
+      [
+        'fileA.ts',
+        {
+          file: 'fileA.ts',
+          imports: [],
+          exports: [],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+      [
+        'fileB.ts',
+        {
+          file: 'fileB.ts',
+          imports: [],
+          exports: [{ name: 'test', type: 'const', inferredDomain: 'unknown' }],
+          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]])); // Below threshold
+
+    const typeGraph = new Map<string, Set<string>>();
+
+    const assignments = inferDomainFromSemantics(
+      'fileA.ts',
+      'testExport',
+      graph,
+      coUsageMatrix,
+      typeGraph
+    );
+
+    // Should be filtered out due to low confidence
+    expect(assignments.length).toBe(0);
+  });
+
+  it('should sort assignments by confidence 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: [
+            { name: 'UserService', type: 'class', inferredDomain: 'user' },
+          ],
+          tokenCost: 100,
+          linesOfCode: 50,
+        },
+      ],
+      [
+        'fileC.ts',
+        {
+          file: 'fileC.ts',
+          imports: [],
+          exports: [
+            { name: 'AuthService', type: 'class', inferredDomain: 'auth' },
+          ],
+          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],
+        ['fileC.ts', 5],
+      ])
+    );
+
+    const typeGraph = new Map<string, Set<string>>();
+
+    const assignments = inferDomainFromSemantics(
+      'fileA.ts',
+      'testExport',
+      graph,
+      coUsageMatrix,
+      typeGraph
+    );
+
+    expect(assignments.length).toBeGreaterThan(0);
+    for (let i = 0; i < assignments.length - 1; i++) {
+      expect(assignments[i].confidence).toBeGreaterThanOrEqual(
+        assignments[i + 1].confidence
+      );
+    }
+  });
+});
+
+describe('extractExports', () => {
+  it('should extract function exports', () => {
+    const content = `
+      export function foo() {}
+      export function bar() {}
+    `;
+    const exports = extractExports(content);
+
+    expect(exports.length).toBe(2);
+    expect(exports[0].name).toBe('foo');
+    expect(exports[0].type).toBe('function');
+  });
+
+  it('should extract class exports', () => {
+    const content = `
+      export class MyClass {}
+    `;
+    const exports = extractExports(content);
+
+    expect(exports.length).toBe(1);
+    expect(exports[0].name).toBe('MyClass');
+    expect(exports[0].type).toBe('class');
+  });
+
+  it('should extract const exports', () => {
+    const content = `
+      export const foo = 1;
+      export const bar = 2;
+    `;
+    const exports = extractExports(content);
+
+    expect(exports.length).toBe(2);
+    expect(exports[0].type).toBe('const');
+  });
+
+  it('should extract type exports', () => {
+    const content = `
+      export type Foo = string;
+    `;
+    const exports = extractExports(content);
+
+    expect(exports.length).toBe(1);
+    expect(exports[0].type).toBe('type');
+  });
+
+  it('should extract interface exports', () => {
+    const content = `
+      export interface User {}
+    `;
+    const exports = extractExports(content);
+
+    expect(exports.length).toBe(1);
+    expect(exports[0].type).toBe('interface');
+  });
+
+  it('should extract default exports', () => {
+    const content = `
+      export default function() {}
+    `;
+    const exports = extractExports(content);
+
+    expect(exports.length).toBe(1);
+    expect(exports[0].type).toBe('default');
+  });
+
+  it('should infer domain from export name', () => {
+    const content = `
+      export function getUser() {}
+    `;
+    const exports = extractExports(content, 'src/user-service.ts');
+
+    expect(exports[0].inferredDomain).toBe('user');
+  });
+
+  it('should return empty for no exports', () => {
+    const content = `
+      const foo = 1;
+      function bar() {}
+    `;
+    const exports = extractExports(content);
+
+    expect(exports).toEqual([]);
+  });
+});
+
+describe('inferDomain', () => {
+  it('should return unknown for unrecognized names', () => {
+    const domain = inferDomain('xyz123');
+    expect(domain).toBe('unknown');
+  });
+
+  it('should infer domain from name tokens', () => {
+    const domain = inferDomain('getUser');
+    expect(domain).toBe('user');
+  });
+
+  it('should infer domain from name keywords', () => {
+    const domain = inferDomain('UserService');
+    expect(domain).toBe('user');
+  });
+
+  it('should infer domain from import paths', () => {
+    const domain = inferDomain('test', undefined, undefined, [
+      './user/api',
+      './auth/login',
+    ]);
+    expect(domain).toBe('user');
+  });
+
+  it('should infer domain from file path', () => {
+    const domain = inferDomain('test', 'src/auth/login.ts');
+    expect(domain).toBe('auth');
+  });
+
+  it('should use custom domain keywords', () => {
+    const domain = inferDomain('customFunc', undefined, {
+      domainKeywords: ['custom'],
+    });
+    expect(domain).toBe('custom');
+  });
+
+  it('should return domain from recognized keywords', () => {
+    const domain = inferDomain('getUser');
+    // Should match 'user' from keyword list
+    expect(domain).toBe('user');
+  });
+
+  it('should handle camelCase splitting', () => {
+    const domain = inferDomain('getUserById');
+    // Should find 'user' in the tokens
+    expect(domain).toBe('user');
+  });
+
+  it('should handle singularization', () => {
+    const domain = inferDomain('users', 'src/users/controller.ts');
+    // Should singularize and match
+    expect(domain).toBe('user');
+  });
+});

package/src/__tests__/issue-analyzer.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect } from 'vitest';
+import { analyzeIssues, isBuildArtifact } from '../issue-analyzer';
+import { Severity } from '@aiready/core';
+
+describe('analyzeIssues', () => {
+  const baseParams = {
+    file: 'src/test.ts',
+    importDepth: 2,
+    contextBudget: 10000,
+    cohesionScore: 0.8,
+    fragmentationScore: 0.3,
+    maxDepth: 5,
+    maxContextBudget: 25000,
+    minCohesion: 0.6,
+    maxFragmentation: 0.5,
+    circularDeps: [] as string[][],
+  };
+
+  it('should return info severity for no issues', () => {
+    const result = analyzeIssues(baseParams);
+
+    expect(result.severity).toBe(Severity.Info);
+    expect(result.issues).toContain('No significant issues detected');
+    expect(result.potentialSavings).toBe(0);
+  });
+
+  it('should detect circular dependencies as critical', () => {
+    const result = analyzeIssues({
+      ...baseParams,
+      circularDeps: [['a.ts', 'b.ts', 'a.ts']],
+    });
+
+    expect(result.severity).toBe(Severity.Critical);
+    expect(result.issues[0]).toContain('1 circular dependency chain(s)');
+    expect(result.potentialSavings).toBeGreaterThan(0);
+  });
+
+  it('should detect high import depth as critical when 50% over limit', () => {
+    const result = analyzeIssues({
+      ...baseParams,
+      importDepth: 8, // > 5 * 1.5
+    });
+
+    expect(result.severity).toBe(Severity.Critical);
+    expect(result.issues[0]).toContain('exceeds limit by 50%');
+  });
+
+  it('should detect import depth over limit as major', () => {
+    const result = analyzeIssues({
+      ...baseParams,
+      importDepth: 6, // > 5
+    });
+
+    expect(result.severity).toBe(Severity.Major);
+    expect(result.issues[0]).toContain('exceeds recommended maximum');
+  });
+
+  it('should detect high context budget as critical when 50% over limit', () => {
+    const result = analyzeIssues({
+      ...baseParams,
+      contextBudget: 40000, // > 25000 * 1.5
+    });
+
+    expect(result.severity).toBe(Severity.Critical);
+    expect(result.issues[0]).toContain('50% over limit');
+  });
+
+  it('should detect context budget over limit as major', () => {
+    const result = analyzeIssues({
+      ...baseParams,
+      contextBudget: 30000, // > 25000
+    });
+
+    expect(result.severity).toBe(Severity.Major);
+    expect(result.issues[0]).toContain('exceeds');
+  });
+
+  it('should detect very low cohesion as major', () => {
+    const result = analyzeIssues({
+      ...baseParams,
+      cohesionScore: 0.2, // < 0.6 * 0.5
+    });
+
+    expect(result.severity).toBe(Severity.Major);
+    expect(result.issues[0]).toContain('Very low cohesion');
+  });
+
+  it('should detect low cohesion as minor', () => {
+    const result = analyzeIssues({
+      ...baseParams,
+      cohesionScore: 0.4, // < 0.6
+    });
+
+    expect(result.severity).toBe(Severity.Minor);
+    expect(result.issues[0]).toContain('Low cohesion');
+  });
+
+  it('should detect high fragmentation', () => {
+    const result = analyzeIssues({
+      ...baseParams,
+      fragmentationScore: 0.8, // > 0.5
+    });
+
+    expect(result.issues[0]).toContain('High fragmentation');
+  });
+
+  it('should handle build artifact files and override severity to info', () => {
+    // Use values that don't trigger any other issues, and a path that matches /dist/
+    const result = analyzeIssues({
+      ...baseParams,
+      file: '/project/dist/bundle.js',
+      importDepth: 1,
+      contextBudget: 5000,
+      cohesionScore: 0.9,
+      fragmentationScore: 0.1,
+    });
+
+    expect(result.severity).toBe(Severity.Info);
+    expect(result.issues).toContain(
+      'Detected build artifact (bundled/output file)'
+    );
+    expect(result.potentialSavings).toBe(0);
+  });
+});
+
+describe('isBuildArtifact', () => {
+  it('should detect node_modules', () => {
+    expect(isBuildArtifact('/project/node_modules/pkg/index.js')).toBe(true);
+  });
+
+  it('should detect dist folder', () => {
+    expect(isBuildArtifact('/project/dist/bundle.js')).toBe(true);
+  });
+
+  it('should detect build folder', () => {
+    expect(isBuildArtifact('/project/build/output.js')).toBe(true);
+  });
+
+  it('should detect out folder', () => {
+    expect(isBuildArtifact('/project/out/main.js')).toBe(true);
+  });
+
+  it('should detect .next folder', () => {
+    expect(isBuildArtifact('/project/.next/server.js')).toBe(true);
+  });
+
+  it('should not flag regular source files', () => {
+    expect(isBuildArtifact('/project/src/index.ts')).toBe(false);
+  });
+
+  it('should be case insensitive', () => {
+    expect(isBuildArtifact('/project/Node_Modules/pkg/index.js')).toBe(true);
+    expect(isBuildArtifact('/project/DIST/bundle.js')).toBe(true);
+  });
+});

package/src/__tests__/orchestrator.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { analyzeContext, calculateCohesion } from '../orchestrator';
+import * as core from '@aiready/core';
+
+// Mock the core module
+vi.mock('@aiready/core', async () => {
+  const actual = await vi.importActual('@aiready/core');
+  return {
+    ...actual,
+    scanFiles: vi.fn(),
+    readFileContent: vi.fn(),
+  };
+});
+
+describe('analyzeContext', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should analyze TypeScript files and return results', async () => {
+    const mockFiles = ['src/file1.ts', 'src/file2.ts'];
+    const mockContents: Record<string, string> = {
+      'src/file1.ts': `
+        import { b } from './file2';
+        export const a = 1;
+      `,
+      'src/file2.ts': `
+        export const b = 2;
+      `,
+    };
+
+    vi.mocked(core.scanFiles).mockResolvedValue(mockFiles);
+    vi.mocked(core.readFileContent).mockImplementation(async (path: string) => {
+      return mockContents[path] || '';
+    });
+
+    const results = await analyzeContext({
+      rootDir: '.',
+      maxDepth: 5,
+      maxContextBudget: 25000,
+      minCohesion: 0.6,
+      maxFragmentation: 0.5,
+    });
+
+    expect(results.length).toBe(2);
+    expect(results[0].file).toBeDefined();
+    expect(results[0].importDepth).toBeDefined();
+    expect(results[0].contextBudget).toBeDefined();
+    expect(core.scanFiles).toHaveBeenCalled();
+    expect(core.readFileContent).toHaveBeenCalledTimes(2);
+  });
+
+  it('should handle empty file list', async () => {
+    vi.mocked(core.scanFiles).mockResolvedValue([]);
+
+    const results = await analyzeContext({
+      rootDir: '.',
+    });
+
+    expect(results).toEqual([]);
+  });
+
+  it('should filter Python files when not present', async () => {
+    const mockFiles = ['src/file1.ts', 'src/file2.py'];
+    vi.mocked(core.scanFiles).mockResolvedValue(mockFiles);
+    vi.mocked(core.readFileContent).mockResolvedValue('export const a = 1;');
+
+    const results = await analyzeContext({
+      rootDir: '.',
+    });
+
+    // Should only process TypeScript files
+    expect(results.length).toBe(1);
+    expect(results[0].file).toBe('src/file1.ts');
+  });
+
+  it('should use default options when not provided', async () => {
+    vi.mocked(core.scanFiles).mockResolvedValue([]);
+    vi.mocked(core.readFileContent).mockResolvedValue('');
+
+    const results = await analyzeContext({
+      rootDir: '.',
+    });
+
+    expect(results).toEqual([]);
+    expect(core.scanFiles).toHaveBeenCalledWith(
+      expect.objectContaining({
+        rootDir: '.',
+      })
+    );
+  });
+
+  it('should handle includeNodeModules option', async () => {
+    const mockFiles = ['node_modules/pkg/index.js', 'src/file.ts'];
+    vi.mocked(core.scanFiles).mockResolvedValue(mockFiles);
+    vi.mocked(core.readFileContent).mockResolvedValue('export const a = 1;');
+
+    const results = await analyzeContext({
+      rootDir: '.',
+      includeNodeModules: true,
+      exclude: ['**/node_modules/**'],
+    });
+
+    // When includeNodeModules is true, node_modules should be processed
+    expect(results.length).toBe(2);
+  });
+});
+
+describe('calculateCohesion', () => {
+  it('should delegate to calculateEnhancedCohesion', () => {
+    const exports = [
+      { name: 'getUser', type: 'function' as const, inferredDomain: 'user' },
+      { name: 'updateUser', type: 'function' as const, inferredDomain: 'user' },
+    ];
+
+    const cohesion = calculateCohesion(exports);
+
+    // Should return a valid cohesion score
+    expect(cohesion).toBeGreaterThan(0);
+    expect(cohesion).toBeLessThanOrEqual(1);
+  });
+
+  it('should handle empty exports', () => {
+    const cohesion = calculateCohesion([]);
+    expect(cohesion).toBe(1); // Empty exports should have perfect cohesion
+  });
+
+  it('should pass through file path and options', () => {
+    const exports = [
+      { name: 'test', type: 'function' as const, inferredDomain: 'test' },
+    ];
+
+    // Test with file path
+    const cohesion = calculateCohesion(exports, 'src/test.ts');
+    expect(cohesion).toBe(1);
+
+    // Test with options
+    const cohesionWithOptions = calculateCohesion(exports, undefined, {
+      someOption: true,
+    });
+    expect(cohesionWithOptions).toBe(1);
+  });
+});