@aiready/context-analyzer 0.21.22 → 0.21.23

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

@@ -0,0 +1,98 @@
+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((filename: string) => {
+    if (filename.endsWith('.py')) {
+      return {
+        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' },
+          ],
+        })),
+      };
+    }
+    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).mockReturnValueOnce(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')
+    );
+  });
+});

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

@@ -0,0 +1,232 @@
+import { describe, it, expect, vi } from 'vitest';
+import { generateHTMLReport } from '../../report/html-report';
+import type { ContextSummary, ContextAnalysisResult } from '../../types';
+
+// Mock @aiready/core
+vi.mock('@aiready/core', () => ({
+  generateReportHead: (title: string) => `<head><title>${title}</title></head>`,
+  generateStatCards: (stats: any[]) =>
+    `<div class="stats">${stats.map((s) => s.label).join(', ')}</div>`,
+  generateTable: (options: { headers: string[]; rows: string[][] }) =>
+    `<table><thead><tr>${options.headers.map((h) => `<th>${h}</th>`).join('')}</thead><tbody>${options.rows.map((r) => `<tr>${r.map((c) => `<td>${c}</td>`).join('')}</tr>`).join('')}</tbody></table>`,
+  generateReportFooter: (options: any) =>
+    `<footer>${options.title} - ${options.packageUrl}</footer>`,
+}));
+
+describe('generateHTMLReport', () => {
+  const createMockSummary = (
+    overrides: Partial<ContextSummary> = {}
+  ): ContextSummary => ({
+    totalFiles: 10,
+    totalTokens: 50000,
+    avgContextBudget: 5000,
+    maxContextBudget: 10000,
+    avgImportDepth: 3,
+    maxImportDepth: 7,
+    deepFiles: [],
+    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,
+    },
+  ];
+
+  it('should generate HTML report with all sections', () => {
+    const summary = createMockSummary({
+      criticalIssues: 2,
+      majorIssues: 1,
+      minorIssues: 1,
+    });
+    const results = createMockResults();
+
+    const html = generateHTMLReport(summary, results);
+
+    expect(html).toContain('AIReady Context Analysis Report');
+    expect(html).toContain('head');
+    expect(html).toContain('body');
+  });
+
+  it('should include stats cards', () => {
+    const summary = createMockSummary();
+    const results: ContextAnalysisResult[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    expect(html).toContain('Files Analyzed');
+    expect(html).toContain('Total Tokens');
+    expect(html).toContain('Avg Context Budget');
+    expect(html).toContain('Total Issues');
+  });
+
+  it('should include issues summary when issues exist', () => {
+    const summary = createMockSummary({
+      criticalIssues: 2,
+      majorIssues: 3,
+      minorIssues: 1,
+      totalPotentialSavings: 5000,
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    expect(html).toContain('Issues Summary');
+    expect(html).toContain('Critical:');
+    expect(html).toContain('Major:');
+    expect(html).toContain('Minor:');
+    expect(html).toContain('Potential Savings');
+  });
+
+  it('should not include issues section when no issues', () => {
+    const summary = createMockSummary({
+      criticalIssues: 0,
+      majorIssues: 0,
+      minorIssues: 0,
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    expect(html).not.toContain('Issues Summary');
+  });
+
+  it('should include fragmented modules when present', () => {
+    const summary = createMockSummary({
+      fragmentedModules: [
+        {
+          domain: 'src/features',
+          files: ['a.ts', 'b.ts', 'c.ts'],
+          totalTokens: 3000,
+          fragmentationScore: 0.75,
+          avgCohesion: 0.4,
+          suggestedStructure: {
+            targetFiles: 2,
+            consolidationPlan: ['Consolidate into fewer modules'],
+          },
+        },
+      ],
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    expect(html).toContain('Fragmented Modules');
+    expect(html).toContain('src/features');
+    expect(html).toContain('Domain');
+    expect(html).toContain('Files');
+    expect(html).toContain('Fragmentation');
+  });
+
+  it('should not include fragmented modules when none exist', () => {
+    const summary = createMockSummary({
+      fragmentedModules: [],
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    expect(html).not.toContain('Fragmented Modules');
+  });
+
+  it('should include 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[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    expect(html).toContain('Most Expensive Files');
+    expect(html).toContain('src/services/user-service.ts');
+    expect(html).toContain('Context Budget');
+    expect(html).toContain('Severity');
+  });
+
+  it('should not include expensive files when none exist', () => {
+    const summary = createMockSummary({
+      topExpensiveFiles: [],
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    expect(html).not.toContain('Most Expensive Files');
+  });
+
+  it('should include footer with package info', () => {
+    const summary = createMockSummary();
+    const results: ContextAnalysisResult[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    expect(html).toContain('<footer>');
+    expect(html).toContain('context-analyzer');
+    expect(html).toContain('github.com');
+  });
+
+  it('should include token values in stats', () => {
+    const summary = createMockSummary({
+      totalTokens: 50000,
+      avgContextBudget: 5000,
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    // Should include stats section
+    expect(html).toContain('Total Tokens');
+  });
+
+  it('should show issues when present', () => {
+    const summary = createMockSummary({
+      criticalIssues: 1,
+      majorIssues: 0,
+      minorIssues: 0,
+    });
+    const results: ContextAnalysisResult[] = [];
+
+    const html = generateHTMLReport(summary, results);
+
+    // Should show issues section
+    expect(html).toContain('Issues Summary');
+  });
+});