@aiready/context-analyzer 0.17.5 → 0.19.0

package/src/metrics.ts

@@ -69,16 +69,12 @@ export function calculateEnhancedCohesion(
     pairsWithData > 0 ? importScoreTotal / pairsWithData : 0;
 
   // Weighted average
-  let score = 0;
-
-  if (anyImportData) {
-    // If we have any import data, use 0.6 weight for imports
-    score = domainScore * 0.4 + avgImportScore * 0.6;
-    // Legacy test fallback for mixed case: ensure > 0
-    if (score === 0 && domainScore === 0) score = 0.1;
-  } else {
-    // Fallback to domain-based
-    score = domainScore;
+  let score = anyImportData
+    ? domainScore * 0.4 + avgImportScore * 0.6
+    : domainScore;
+
+  if (anyImportData && score === 0 && domainScore === 0) {
+    score = 0.1;
   }
 
   // Structural boost
@@ -150,19 +146,13 @@ export function calculateFragmentation(
   );
   const uniqueDirs = directories.size;
 
-  let score = 0;
-  if (options?.useLogScale) {
-    if (uniqueDirs <= 1) score = 0;
-    else {
-      const total = files.length;
-      const base = options.logBase || Math.E;
-      const num = Math.log(uniqueDirs) / Math.log(base);
-      const den = Math.log(total) / Math.log(base);
-      score = den > 0 ? num / den : 0;
-    }
-  } else {
-    score = (uniqueDirs - 1) / (files.length - 1);
-  }
+  let score = options?.useLogScale
+    ? uniqueDirs <= 1
+      ? 0
+      : Math.log(uniqueDirs) /
+        Math.log(options.logBase || Math.E) /
+        (Math.log(files.length) / Math.log(options.logBase || Math.E))
+    : (uniqueDirs - 1) / (files.length - 1);
 
   // Coupling Discount
   if (options?.sharedImportRatio && options.sharedImportRatio > 0.5) {

package/src/provider.ts

@@ -0,0 +1,65 @@
+import {
+  ToolProvider,
+  ToolName,
+  SpokeOutput,
+  ScanOptions,
+  ToolScoringOutput,
+  AnalysisResult,
+  Severity,
+  IssueType,
+  SpokeOutputSchema,
+} from '@aiready/core';
+import { analyzeContext, generateSummary } from './index';
+import { calculateContextScore } from './scoring';
+import { ContextAnalyzerOptions, ContextAnalysisResult } from './types';
+
+/**
+ * Context Analyzer Tool Provider
+ */
+export const ContextAnalyzerProvider: ToolProvider = {
+  id: ToolName.ContextAnalyzer,
+  alias: ['context', 'fragmentation', 'budget'],
+
+  async analyze(options: ScanOptions): Promise<SpokeOutput> {
+    const results = await analyzeContext(options as ContextAnalyzerOptions);
+    const summary = generateSummary(results);
+
+    // Normalize to SpokeOutput format
+    const normalizedResults: AnalysisResult[] = results.map(
+      (r: ContextAnalysisResult) => ({
+        fileName: r.file,
+        issues: r.issues.map((msg) => ({
+          type: IssueType.ContextFragmentation,
+          severity: r.severity as Severity,
+          message: msg,
+          location: { file: r.file, line: 1 },
+          suggestion: r.recommendations[0],
+        })),
+        metrics: {
+          tokenCost: r.tokenCost,
+          complexityScore: r.importDepth,
+          // Map other context-specific metrics if needed
+        },
+      })
+    );
+
+    return SpokeOutputSchema.parse({
+      results: normalizedResults,
+      summary: {
+        ...summary,
+      },
+      metadata: {
+        toolName: ToolName.ContextAnalyzer,
+        version: '0.17.5',
+        timestamp: new Date().toISOString(),
+      },
+    });
+  },
+
+  score(output: SpokeOutput, options: ScanOptions): ToolScoringOutput {
+    const summary = output.summary as any;
+    return calculateContextScore(summary, (options as any).costConfig);
+  },
+
+  defaultWeight: 19,
+};

package/src/scoring.ts

@@ -3,6 +3,7 @@ import {
   calculateProductivityImpact,
   DEFAULT_COST_CONFIG,
   type CostConfig,
+  ToolName,
 } from '@aiready/core';
 import type { ToolScoringOutput } from '@aiready/core';
 import type { ContextSummary } from './types';
@@ -150,7 +151,7 @@ export function calculateContextScore(
   const productivityImpact = calculateProductivityImpact(issues);
 
   return {
-    toolName: 'context-analyzer',
+    toolName: ToolName.ContextAnalyzer,
     score,
     rawMetrics: {
       avgContextBudget: Math.round(avgContextBudget),