@aiready/context-analyzer 0.21.22 → 0.21.24

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);
+  });
+});

package/src/__tests__/python-context.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as pythonContext from '../analyzers/python-context';
+
+// Mock @aiready/core
+vi.mock('@aiready/core', () => ({
+  getParser: vi.fn(async (filename: string) => {
+    if (filename.endsWith('.py')) {
+      return {
+        initialize: vi.fn().mockResolvedValue(undefined),
+        parse: vi.fn(() => ({
+          imports: [
+            { source: 'os', specifiers: ['path'], isRelative: false },
+            { source: '.utils', specifiers: ['helper'], isRelative: true },
+          ],
+          exports: [
+            { name: 'MyClass', type: 'class' },
+            { name: 'my_function', type: 'function' },
+          ],
+        })),
+        language: 'python',
+      };
+    }
+    return null;
+  }),
+  estimateTokens: vi.fn((code: string) => Math.ceil(code.length / 4)),
+}));
+
+// Mock fs
+vi.mock('fs', () => ({
+  promises: {
+    readFile: vi.fn(),
+  },
+  existsSync: vi.fn(),
+}));
+
+describe('python-context', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('analyzePythonContext', () => {
+    it('should return empty array when parser is not available', async () => {
+      const { getParser } = await import('@aiready/core');
+      vi.mocked(getParser).mockResolvedValueOnce(null);
+
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const results = await pythonContext.analyzePythonContext([], '/test');
+
+      expect(results).toEqual([]);
+      consoleSpy.mockRestore();
+    });
+
+    it('should filter for Python files only', async () => {
+      const files = ['src/file1.ts', 'src/file2.py', 'src/file3.js'];
+
+      const results = await pythonContext.analyzePythonContext(files, '/test');
+
+      // Should handle gracefully even if files don't exist
+      expect(Array.isArray(results)).toBe(true);
+    });
+
+    it('should analyze Python files and return metrics', async () => {
+      const fs = await import('fs');
+      vi.mocked(fs.promises.readFile).mockResolvedValue(`
+import os
+from .utils import helper
+
+class MyClass:
+    pass
+
+def my_function():
+    pass
+      `);
+
+      const files = ['src/test.py'];
+
+      const results = await pythonContext.analyzePythonContext(files, '/test');
+
+      // Results may be empty if parser returns null in mock
+      expect(Array.isArray(results)).toBe(true);
+    });
+
+    it('should handle file read errors gracefully', async () => {
+      const fs = await import('fs');
+      vi.mocked(fs.promises.readFile).mockRejectedValueOnce(
+        new Error('File not found')
+      );
+
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const files = ['src/bad.py'];
+      const results = await pythonContext.analyzePythonContext(files, '/test');
+
+      // Should return empty results or partial results
+      expect(Array.isArray(results)).toBe(true);
+      consoleSpy.mockRestore();
+    });
+  });
+});

package/src/__tests__/report/console-report.test.ts

@@ -0,0 +1,292 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { displayConsoleReport } from '../../report/console-report';
+import type { ContextSummary, ContextAnalysisResult } from '../../types';
+
+// Mock chalk to avoid ANSI codes in tests
+vi.mock('chalk', () => ({
+  default: {
+    bold: (str: string) => str,
+    cyan: (str: string) => str,
+    green: (str: string) => str,
+    red: (str: string) => str,
+    yellow: (str: string) => str,
+    blue: (str: string) => str,
+    white: (str: string) => str,
+    dim: (str: string) => str,
+  },
+}));
+
+// Mock the analyzer to provide the results type
+vi.mock('../../analyzer', () => ({
+  analyzeContext: vi.fn(),
+}));
+
+describe('displayConsoleReport', () => {
+  let consoleLogSpy: any;
+
+  beforeEach(() => {
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+  });
+
+  const createMockSummary = (
+    overrides: Partial<ContextSummary> = {}
+  ): ContextSummary => ({
+    totalFiles: 10,
+    totalTokens: 50000,
+    avgContextBudget: 5000,
+    maxContextBudget: 10000,
+    avgImportDepth: 3,
+    maxImportDepth: 7,
+    deepFiles: [{ file: 'src/deep/file.ts', depth: 7 }],
+    avgFragmentation: 0.3,
+    fragmentedModules: [],
+    avgCohesion: 0.7,
+    lowCohesionFiles: [],
+    criticalIssues: 2,
+    majorIssues: 5,
+    minorIssues: 3,
+    totalPotentialSavings: 10000,
+    topExpensiveFiles: [],
+    config: {},
+    ...overrides,
+  });
+
+  const createMockResults = (): ContextAnalysisResult[] => [
+    {
+      file: 'src/services/user-service.ts',
+      tokenCost: 5000,
+      linesOfCode: 500,
+      importDepth: 5,
+      dependencyCount: 10,
+      dependencyList: [],
+      circularDeps: [],
+      cohesionScore: 0.8,
+      domains: ['user'],
+      exportCount: 5,
+      contextBudget: 15000,
+      fragmentationScore: 0.3,
+      relatedFiles: [],
+      fileClassification: 'service-file',
+      severity: 'critical',
+      issues: ['High context budget'],
+      recommendations: ['Split into smaller modules'],
+      potentialSavings: 5000,
+    },
+    {
+      file: 'src/utils/helper.ts',
+      tokenCost: 1000,
+      linesOfCode: 100,
+      importDepth: 2,
+      dependencyCount: 3,
+      dependencyList: [],
+      circularDeps: [],
+      cohesionScore: 0.9,
+      domains: ['utils'],
+      exportCount: 3,
+      contextBudget: 3000,
+      fragmentationScore: 0.1,
+      relatedFiles: [],
+      fileClassification: 'utility-module',
+      severity: 'info',
+      issues: [],
+      recommendations: [],
+      potentialSavings: 0,
+    },
+  ];
+
+  it('should display summary with all metrics', () => {
+    const summary = createMockSummary();
+    const results = createMockResults();
+
+    displayConsoleReport(summary, results);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Context Analysis Summary')
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Total Files:')
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Total Tokens:')
+    );
+  });
+
+  it('should display issues when present', () => {
+    const summary = createMockSummary({
+      criticalIssues: 2,
+      majorIssues: 5,
+      minorIssues: 3,
+    });
+    const results = createMockResults();
+
+    displayConsoleReport(summary, results);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Issues Detected')
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Critical:')
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Major:')
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Minor:')
+    );
+  });
+
+  it('should display no issues message when all counts are zero', () => {
+    const summary = createMockSummary({
+      criticalIssues: 0,
+      majorIssues: 0,
+      minorIssues: 0,
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    displayConsoleReport(summary, results);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('No significant context issues detected')
+    );
+  });
+
+  it('should display fragmented modules when present', () => {
+    const summary = createMockSummary({
+      fragmentedModules: [
+        {
+          domain: 'src/features',
+          files: [
+            'src/features/a.ts',
+            'src/features/b.ts',
+            'src/features/c.ts',
+          ],
+          totalTokens: 3000,
+          fragmentationScore: 0.75,
+          avgCohesion: 0.4,
+          suggestedStructure: {
+            targetFiles: 2,
+            consolidationPlan: ['Consolidate into fewer modules'],
+          },
+        },
+      ],
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    displayConsoleReport(summary, results);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Fragmented Modules')
+    );
+  });
+
+  it('should display top expensive files when present', () => {
+    const summary = createMockSummary({
+      topExpensiveFiles: [
+        {
+          file: 'src/services/user-service.ts',
+          contextBudget: 15000,
+          severity: 'critical',
+        },
+        {
+          file: 'src/services/order-service.ts',
+          contextBudget: 12000,
+          severity: 'major',
+        },
+      ],
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    displayConsoleReport(summary, results);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Most Expensive Files')
+    );
+  });
+
+  it('should display recommendations for critical and major issues', () => {
+    const summary = createMockSummary({
+      criticalIssues: 1,
+      majorIssues: 1,
+      minorIssues: 0,
+    });
+    const results: ContextAnalysisResult[] = [
+      {
+        file: 'src/bad/file.ts',
+        tokenCost: 10000,
+        linesOfCode: 1000,
+        importDepth: 8,
+        dependencyCount: 20,
+        dependencyList: [],
+        circularDeps: [],
+        cohesionScore: 0.2,
+        domains: [],
+        exportCount: 20,
+        contextBudget: 30000,
+        fragmentationScore: 0.8,
+        relatedFiles: [],
+        fileClassification: 'mixed-concerns',
+        severity: 'critical',
+        issues: ['Very high context budget', 'Deep import chain'],
+        recommendations: ['Split into multiple files', 'Reduce dependencies'],
+        potentialSavings: 15000,
+      },
+    ];
+
+    displayConsoleReport(summary, results);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Recommendations')
+    );
+  });
+
+  it('should respect maxResults parameter', () => {
+    const summary = createMockSummary({
+      topExpensiveFiles: [
+        { file: 'src/file1.ts', contextBudget: 15000, severity: 'critical' },
+        { file: 'src/file2.ts', contextBudget: 12000, severity: 'critical' },
+        { file: 'src/file3.ts', contextBudget: 10000, severity: 'major' },
+        { file: 'src/file4.ts', contextBudget: 8000, severity: 'major' },
+      ],
+      fragmentedModules: [
+        {
+          domain: 'src/domain1',
+          files: ['a.ts', 'b.ts', 'c.ts', 'd.ts'],
+          totalTokens: 2000,
+          fragmentationScore: 0.6,
+          avgCohesion: 0.5,
+          suggestedStructure: { targetFiles: 2, consolidationPlan: [] },
+        },
+        {
+          domain: 'src/domain2',
+          files: ['e.ts', 'f.ts'],
+          totalTokens: 1000,
+          fragmentationScore: 0.5,
+          avgCohesion: 0.6,
+          suggestedStructure: { targetFiles: 1, consolidationPlan: [] },
+        },
+      ],
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    displayConsoleReport(summary, results, 2);
+
+    // With maxResults=2, should only show top 2 items
+    // The function uses slice(0, maxResults) internally
+    expect(consoleLogSpy).toHaveBeenCalled();
+  });
+
+  it('should display footer with links', () => {
+    const summary = createMockSummary();
+    const results: ContextAnalysisResult[] = [];
+
+    displayConsoleReport(summary, results);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('github.com')
+    );
+  });
+});