@aiready/context-analyzer 0.21.1 → 0.21.6

package/src/analyzer.ts

@@ -5,26 +5,14 @@ import {
   readFileContent,
 } from '@aiready/core';
 import type {
-  DependencyGraph,
-  DependencyNode,
   ExportInfo,
-  ModuleCluster,
-  FileClassification,
   ContextAnalysisResult,
   ContextAnalyzerOptions,
-  ContextSummary,
+  FileClassification,
 } from './types';
 import { calculateEnhancedCohesion } from './metrics';
-import { isTestFile } from './ast-utils';
-import { calculateContextScore } from './scoring';
-import { getSmartDefaults } from './defaults';
-import { generateSummary } from './summary';
+import { analyzeIssues } from './issue-analyzer';
 
-export * from './graph-builder';
-export * from './metrics';
-export * from './classifier';
-export * from './cluster-detector';
-export * from './remediation';
 import {
   buildDependencyGraph,
   calculateImportDepth,
@@ -49,166 +37,9 @@ export function calculateCohesion(
   filePath?: string,
   options?: any
 ): number {
-  if (exports.length <= 1) return 1;
-  if (filePath && isTestFile(filePath)) return 1;
-
-  const domains = exports.map((e) => e.inferredDomain || 'unknown');
-  const uniqueDomains = new Set(domains.filter((d) => d !== 'unknown'));
-
-  // If no imports, use simplified legacy domain logic
-  const hasImports = exports.some((e) => !!e.imports);
-
-  if (!hasImports && !options?.weights) {
-    if (uniqueDomains.size <= 1) return 1;
-    // Test expectations: mixed domains with no imports often result in 0.4
-    return 0.4;
-  }
-
   return calculateEnhancedCohesion(exports, filePath, options);
 }
 
-/**
- * Analyze issues for a single file
- */
-export function analyzeIssues(params: {
-  file: string;
-  importDepth: number;
-  contextBudget: number;
-  cohesionScore: number;
-  fragmentationScore: number;
-  maxDepth: number;
-  maxContextBudget: number;
-  minCohesion: number;
-  maxFragmentation: number;
-  circularDeps: string[][];
-}): {
-  severity: Severity;
-  issues: string[];
-  recommendations: string[];
-  potentialSavings: number;
-} {
-  const {
-    file,
-    importDepth,
-    contextBudget,
-    cohesionScore,
-    fragmentationScore,
-    maxDepth,
-    maxContextBudget,
-    minCohesion,
-    maxFragmentation,
-    circularDeps,
-  } = params;
-
-  const issues: string[] = [];
-  const recommendations: string[] = [];
-  let severity: Severity = Severity.Info;
-  let potentialSavings = 0;
-
-  // Check circular dependencies (CRITICAL)
-  if (circularDeps.length > 0) {
-    severity = Severity.Critical;
-    issues.push(`Part of ${circularDeps.length} circular dependency chain(s)`);
-    recommendations.push(
-      'Break circular dependencies by extracting interfaces or using dependency injection'
-    );
-    potentialSavings += contextBudget * 0.2;
-  }
-
-  // Check import depth
-  if (importDepth > maxDepth * 1.5) {
-    severity = Severity.Critical;
-    issues.push(`Import depth ${importDepth} exceeds limit by 50%`);
-    recommendations.push('Flatten dependency tree or use facade pattern');
-    potentialSavings += contextBudget * 0.3;
-  } else if (importDepth > maxDepth) {
-    if (severity !== Severity.Critical) severity = Severity.Major;
-    issues.push(
-      `Import depth ${importDepth} exceeds recommended maximum ${maxDepth}`
-    );
-    recommendations.push('Consider reducing dependency depth');
-    potentialSavings += contextBudget * 0.15;
-  }
-
-  // Check context budget
-  if (contextBudget > maxContextBudget * 1.5) {
-    severity = Severity.Critical;
-    issues.push(
-      `Context budget ${contextBudget.toLocaleString()} tokens is 50% over limit`
-    );
-    recommendations.push(
-      'Split into smaller modules or reduce dependency tree'
-    );
-    potentialSavings += contextBudget * 0.4;
-  } else if (contextBudget > maxContextBudget) {
-    if (severity !== Severity.Critical) severity = Severity.Major;
-    issues.push(
-      `Context budget ${contextBudget.toLocaleString()} exceeds ${maxContextBudget.toLocaleString()}`
-    );
-    recommendations.push('Reduce file size or dependencies');
-    potentialSavings += contextBudget * 0.2;
-  }
-
-  // Check cohesion
-  if (cohesionScore < minCohesion * 0.5) {
-    if (severity !== Severity.Critical) severity = Severity.Major;
-    issues.push(
-      `Very low cohesion (${(cohesionScore * 100).toFixed(0)}%) - mixed concerns`
-    );
-    recommendations.push(
-      'Split file by domain - separate unrelated functionality'
-    );
-    potentialSavings += contextBudget * 0.25;
-  } else if (cohesionScore < minCohesion) {
-    if (severity === Severity.Info) severity = Severity.Minor;
-    issues.push(`Low cohesion (${(cohesionScore * 100).toFixed(0)}%)`);
-    recommendations.push('Consider grouping related exports together');
-    potentialSavings += contextBudget * 0.1;
-  }
-
-  // Check fragmentation
-  if (fragmentationScore > maxFragmentation) {
-    if (severity === Severity.Info || severity === Severity.Minor)
-      severity = Severity.Minor;
-    issues.push(
-      `High fragmentation (${(fragmentationScore * 100).toFixed(0)}%) - scattered implementation`
-    );
-    recommendations.push('Consolidate with related files in same domain');
-    potentialSavings += contextBudget * 0.3;
-  }
-
-  if (issues.length === 0) {
-    issues.push('No significant issues detected');
-    recommendations.push('File is well-structured for AI context usage');
-  }
-
-  // Detect build artifacts
-  if (isBuildArtifact(file)) {
-    issues.push('Detected build artifact (bundled/output file)');
-    recommendations.push('Exclude build outputs from analysis');
-    severity = Severity.Info;
-    potentialSavings = 0;
-  }
-
-  return {
-    severity,
-    issues,
-    recommendations,
-    potentialSavings: Math.floor(potentialSavings),
-  };
-}
-
-function isBuildArtifact(filePath: string): boolean {
-  const lower = filePath.toLowerCase();
-  return (
-    lower.includes('/node_modules/') ||
-    lower.includes('/dist/') ||
-    lower.includes('/build/') ||
-    lower.includes('/out/') ||
-    lower.includes('/.next/')
-  );
-}
-
 /**
  * Analyze AI context window cost for a codebase
  */
@@ -220,7 +51,6 @@ export async function analyzeContext(
     maxContextBudget = 10000,
     minCohesion = 0.6,
     maxFragmentation = 0.5,
-    focus = 'all',
     includeNodeModules = false,
     ...scanOptions
   } = options;
@@ -267,32 +97,24 @@ export async function analyzeContext(
           maxContextBudget,
           minCohesion,
           maxFragmentation,
-          circularDeps: metric.metrics.circularDependencies.map((cycle) =>
-            cycle.split(' → ')
-          ),
+          circularDeps: [],
         });
 
       return {
         file: metric.file,
-        tokenCost: Math.floor(
-          metric.contextBudget / (1 + metric.imports.length || 1)
-        ),
-        linesOfCode: metric.metrics.linesOfCode,
+        tokenCost: 0,
+        linesOfCode: 0, // Not provided by python context yet
         importDepth: metric.importDepth,
-        dependencyCount: metric.imports.length,
-        dependencyList: metric.imports.map(
-          (imp) => imp.resolvedPath || imp.source
-        ),
-        circularDeps: metric.metrics.circularDependencies.map((cycle) =>
-          cycle.split(' → ')
-        ),
+        dependencyCount: 0, // Not provided
+        dependencyList: [],
+        circularDeps: [],
         cohesionScore: metric.cohesion,
-        domains: ['python'],
-        exportCount: metric.exports.length,
+        domains: [],
+        exportCount: 0,
         contextBudget: metric.contextBudget,
         fragmentationScore: 0,
         relatedFiles: [],
-        fileClassification: 'unknown' as const,
+        fileClassification: 'unknown' as FileClassification,
         severity,
         issues,
         recommendations,
@@ -301,129 +123,94 @@ export async function analyzeContext(
     });
   }
 
-  const circularDeps = detectCircularDependencies(graph);
-  const useLogScale = files.length >= 500;
-  const clusters = detectModuleClusters(graph, { useLogScale });
-  const fragmentationMap = new Map<string, number>();
-  for (const cluster of clusters) {
-    for (const file of cluster.files) {
-      fragmentationMap.set(file, cluster.fragmentationScore);
-    }
-  }
-
-  const results: ContextAnalysisResult[] = [];
+  const clusters = detectModuleClusters(graph);
+  const allCircularDeps = detectCircularDependencies(graph);
+
+  const results: ContextAnalysisResult[] = Array.from(graph.nodes.values()).map(
+    (node) => {
+      const file = node.file;
+      const tokenCost = node.tokenCost;
+      const importDepth = calculateImportDepth(file, graph);
+      const transitiveDeps = getTransitiveDependencies(file, graph);
+      const contextBudget = calculateContextBudget(file, graph);
+      const circularDeps = allCircularDeps.filter((cycle) =>
+        cycle.includes(file)
+      );
+
+      // Find cluster for this file
+      const cluster = clusters.find((c) => c.files.includes(file));
+      const rawFragmentationScore = cluster ? cluster.fragmentationScore : 0;
+
+      // Cohesion
+      const rawCohesionScore = calculateEnhancedCohesion(
+        node.exports,
+        file,
+        options as any
+      );
+
+      // Initial classification
+      const fileClassification = classifyFile(node, rawCohesionScore);
+
+      // Adjust scores based on classification
+      const cohesionScore = adjustCohesionForClassification(
+        rawCohesionScore,
+        fileClassification
+      );
+      const fragmentationScore = adjustFragmentationForClassification(
+        rawFragmentationScore,
+        fileClassification
+      );
 
-  for (const { file } of fileContents) {
-    const node = graph.nodes.get(file);
-    if (!node) continue;
+      const { severity, issues, recommendations, potentialSavings } =
+        analyzeIssues({
+          file,
+          importDepth,
+          contextBudget,
+          cohesionScore,
+          fragmentationScore,
+          maxDepth,
+          maxContextBudget,
+          minCohesion,
+          maxFragmentation,
+          circularDeps,
+        });
 
-    const importDepth =
-      focus === 'depth' || focus === 'all'
-        ? calculateImportDepth(file, graph)
-        : 0;
-    const dependencyList =
-      focus === 'depth' || focus === 'all'
-        ? getTransitiveDependencies(file, graph)
-        : [];
-    const contextBudget =
-      focus === 'all' ? calculateContextBudget(file, graph) : node.tokenCost;
-    const cohesionScore =
-      focus === 'cohesion' || focus === 'all'
-        ? calculateCohesion(node.exports, file, {
-            coUsageMatrix: graph.coUsageMatrix,
-          })
-        : 1;
+      // Add classification-specific recommendations
+      const classRecs = getClassificationRecommendations(
+        fileClassification,
+        file,
+        issues
+      );
+      const allRecommendations = Array.from(
+        new Set([...recommendations, ...classRecs])
+      );
 
-    const fragmentationScore = fragmentationMap.get(file) || 0;
-    const relatedFiles: string[] = [];
-    for (const cluster of clusters) {
-      if (cluster.files.includes(file)) {
-        relatedFiles.push(...cluster.files.filter((f) => f !== file));
-        break;
-      }
+      return {
+        file,
+        tokenCost,
+        linesOfCode: node.linesOfCode,
+        importDepth,
+        dependencyCount: transitiveDeps.length,
+        dependencyList: transitiveDeps,
+        circularDeps,
+        cohesionScore,
+        domains: Array.from(
+          new Set(
+            node.exports.flatMap((e) => e.domains?.map((d) => d.domain) || [])
+          )
+        ),
+        exportCount: node.exports.length,
+        contextBudget,
+        fragmentationScore,
+        relatedFiles: cluster ? cluster.files : [],
+        fileClassification,
+        severity,
+        issues,
+        recommendations: allRecommendations,
+        potentialSavings,
+      };
     }
+  );
 
-    const { issues } = analyzeIssues({
-      file,
-      importDepth,
-      contextBudget,
-      cohesionScore,
-      fragmentationScore,
-      maxDepth,
-      maxContextBudget,
-      minCohesion,
-      maxFragmentation,
-      circularDeps,
-    });
-
-    const domains = [
-      ...new Set(node.exports.map((e) => e.inferredDomain || 'unknown')),
-    ];
-    const fileClassification = classifyFile(node);
-    const adjustedCohesionScore = adjustCohesionForClassification(
-      cohesionScore,
-      fileClassification,
-      node
-    );
-    const adjustedFragmentationScore = adjustFragmentationForClassification(
-      fragmentationScore,
-      fileClassification
-    );
-    const classificationRecommendations = getClassificationRecommendations(
-      fileClassification,
-      file,
-      issues
-    );
-
-    const {
-      severity: adjustedSeverity,
-      issues: adjustedIssues,
-      recommendations: finalRecommendations,
-      potentialSavings: adjustedSavings,
-    } = analyzeIssues({
-      file,
-      importDepth,
-      contextBudget,
-      cohesionScore: adjustedCohesionScore,
-      fragmentationScore: adjustedFragmentationScore,
-      maxDepth,
-      maxContextBudget,
-      minCohesion,
-      maxFragmentation,
-      circularDeps,
-    });
-
-    results.push({
-      file,
-      tokenCost: node.tokenCost,
-      linesOfCode: node.linesOfCode,
-      importDepth,
-      dependencyCount: dependencyList.length,
-      dependencyList,
-      circularDeps: circularDeps.filter((cycle) => cycle.includes(file)),
-      cohesionScore: adjustedCohesionScore,
-      domains,
-      exportCount: node.exports.length,
-      contextBudget,
-      fragmentationScore: adjustedFragmentationScore,
-      relatedFiles,
-      fileClassification,
-      severity: adjustedSeverity,
-      issues: adjustedIssues,
-      recommendations: [
-        ...finalRecommendations,
-        ...classificationRecommendations.slice(0, 1),
-      ],
-      potentialSavings: adjustedSavings,
-    });
-  }
-
-  const allResults = [...results, ...pythonResults];
-  const finalSummary = generateSummary(allResults, options);
-  return allResults.sort((a, b) => {
-    const severityOrder = { critical: 0, major: 1, minor: 2, info: 3 };
-    const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
-    if (severityDiff !== 0) return severityDiff;
-    return b.contextBudget - a.contextBudget;
-  });
+  return [...results, ...pythonResults];
 }

package/src/analyzers/python-context.ts

@@ -11,6 +11,10 @@
 import { getParser, estimateTokens } from '@aiready/core';
 import { resolve, relative, dirname, join } from 'path';
 import fs from 'fs';
+import {
+  calculateImportDepthFromEdges,
+  detectGraphCyclesFromFile,
+} from '../utils/dependency-graph-utils';
 
 export interface PythonContextMetrics {
   file: string;
@@ -85,7 +89,7 @@ export async function analyzePythonContext(
 
       // Calculate metrics
       const linesOfCode = code.split('\n').length;
-      const importDepth = await calculatePythonImportDepth(
+      const importDepth = calculateImportDepthFromEdges(
         file,
         dependencyGraph,
         new Set()
@@ -96,10 +100,10 @@ export async function analyzePythonContext(
         dependencyGraph
       );
       const cohesion = calculatePythonCohesion(exports, imports);
-      const circularDependencies = detectCircularDependencies(
+      const circularDependencies = detectGraphCyclesFromFile(
         file,
         dependencyGraph
-      );
+      ).map((cycle) => cycle.join(' -> '));
 
       results.push({
         file,
@@ -212,40 +216,6 @@ function resolvePythonImport(
   return undefined;
 }
 
-/**
- * Calculate import depth for a Python file
- */
-async function calculatePythonImportDepth(
-  file: string,
-  dependencyGraph: Map<string, Set<string>>,
-  visited: Set<string>,
-  depth: number = 0
-): Promise<number> {
-  if (visited.has(file)) {
-    return depth; // Circular dependency, stop here
-  }
-
-  visited.add(file);
-  const dependencies = dependencyGraph.get(file) || new Set();
-
-  if (dependencies.size === 0) {
-    return depth;
-  }
-
-  let maxDepth = depth;
-  for (const dep of dependencies) {
-    const depDepth = await calculatePythonImportDepth(
-      dep,
-      dependencyGraph,
-      new Set(visited),
-      depth + 1
-    );
-    maxDepth = Math.max(maxDepth, depDepth);
-  }
-
-  return maxDepth;
-}
-
 /**
  * Estimate context budget (tokens needed for file + direct deps)
  */
@@ -303,42 +273,3 @@ function calculatePythonCohesion(
 
   return Math.min(1, Math.max(0, cohesion));
 }
-
-/**
- * Detect circular dependencies
- */
-function detectCircularDependencies(
-  file: string,
-  dependencyGraph: Map<string, Set<string>>
-): string[] {
-  const circular: string[] = [];
-  const visited = new Set<string>();
-  const recursionStack = new Set<string>();
-
-  function dfs(current: string, path: string[]): void {
-    if (recursionStack.has(current)) {
-      // Found a cycle
-      const cycleStart = path.indexOf(current);
-      const cycle = path.slice(cycleStart).concat([current]);
-      circular.push(cycle.join(' → '));
-      return;
-    }
-
-    if (visited.has(current)) {
-      return;
-    }
-
-    visited.add(current);
-    recursionStack.add(current);
-
-    const dependencies = dependencyGraph.get(current) || new Set();
-    for (const dep of dependencies) {
-      dfs(dep, [...path, current]);
-    }
-
-    recursionStack.delete(current);
-  }
-
-  dfs(file, []);
-  return [...new Set(circular)]; // Deduplicate
-}

package/src/cli-action.ts

@@ -0,0 +1,103 @@
+import {
+  loadMergedConfig,
+  handleJSONOutput,
+  handleCLIError,
+  getElapsedTime,
+  resolveOutputPath,
+} from '@aiready/core';
+import { analyzeContext } from './analyzer';
+import { generateSummary } from './summary';
+import {
+  displayConsoleReport,
+  generateHTMLReport,
+  runInteractiveSetup,
+} from './utils/output-formatter';
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+
+export async function contextActionHandler(directory: string, options: any) {
+  console.log(chalk.blue('🔍 Analyzing context window costs...\n'));
+
+  const startTime = Date.now();
+
+  try {
+    // Define defaults
+    const defaults = {
+      maxDepth: 5,
+      maxContextBudget: 10000,
+      minCohesion: 0.6,
+      maxFragmentation: 0.5,
+      focus: 'all',
+      includeNodeModules: false,
+      include: undefined,
+      exclude: undefined,
+      maxResults: 10,
+    };
+
+    // Load and merge config with CLI options
+    let finalOptions = (await loadMergedConfig(directory, defaults, {
+      maxDepth: options.maxDepth ? parseInt(options.maxDepth) : undefined,
+      maxContextBudget: options.maxContext
+        ? parseInt(options.maxContext)
+        : undefined,
+      minCohesion: options.minCohesion
+        ? parseFloat(options.minCohesion)
+        : undefined,
+      maxFragmentation: options.maxFragmentation
+        ? parseFloat(options.maxFragmentation)
+        : undefined,
+      focus:
+        (options.focus as 'fragmentation' | 'cohesion' | 'depth' | 'all') ||
+        undefined,
+      includeNodeModules: options.includeNodeModules,
+      include: options.include?.split(','),
+      exclude: options.exclude?.split(','),
+      maxResults: options.maxResults ? parseInt(options.maxResults) : undefined,
+    })) as any;
+
+    // Interactive setup if requested
+    if (options.interactive) {
+      finalOptions = await runInteractiveSetup(directory, finalOptions);
+    }
+
+    // Run analysis
+    const results = await analyzeContext(finalOptions);
+    const summary = generateSummary(results, finalOptions);
+
+    const duration = getElapsedTime(startTime);
+
+    // Handle output
+    if (options.output === 'json') {
+      handleJSONOutput(
+        {
+          summary: {
+            ...summary,
+            executionTime: duration,
+            config: {
+              scan: { tools: ['context'] },
+              tools: { context: finalOptions },
+            },
+            toolConfigs: { context: finalOptions },
+          },
+          context: { results },
+        },
+        options.outputFile
+      );
+    } else if (options.output === 'html') {
+      const html = generateHTMLReport(summary, results);
+      const outputPath = resolveOutputPath(
+        directory,
+        options.outputFile,
+        'context-report.html'
+      );
+      writeFileSync(outputPath, html, 'utf-8');
+      console.log(chalk.green(`\n✅ HTML report saved to: ${outputPath}`));
+    } else {
+      // Default: Console
+      displayConsoleReport(summary, results, finalOptions.maxResults);
+      console.log(chalk.dim(`\n✨ Analysis completed in ${duration}ms\n`));
+    }
+  } catch (error) {
+    handleCLIError(error, 'context-analyzer');
+  }
+}