@aiready/context-analyzer 0.22.5 → 0.22.7

package/src/metrics.ts

@@ -1,5 +1,5 @@
 import { calculateImportSimilarity, isTestFile } from '@aiready/core';
-import type { ExportInfo } from './types';
+import type { ExportInfo } from '@aiready/core';
 
 /**
  * Calculates a cohesion score (0-1) for a module based on its exports,
@@ -29,7 +29,7 @@ export function calculateEnhancedCohesion(
   if (filePath && isTestFile(filePath)) return 1;
 
   // 1. Domain-based cohesion using entropy
-  const domains = exports.map((e) => e.inferredDomain || 'unknown');
+  const domains = exports.map((e: any) => e.inferredDomain || 'unknown');
   const domainCounts = new Map<string, number>();
   for (const domain of domains)
     domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1);

package/src/orchestrator.ts

@@ -56,7 +56,7 @@ function mapNodeToResult(
   const rawCohesionScore = calculateEnhancedCohesion(
     node.exports,
     file,
-    options as any
+    options as unknown as Record<string, unknown>
   );
 
   // Initial classification
@@ -108,7 +108,9 @@ function mapNodeToResult(
     cohesionScore,
     domains: Array.from(
       new Set(
-        node.exports.flatMap((e) => e.domains?.map((d) => d.domain) || [])
+        node.exports.flatMap(
+          (e: any) => e.domains?.map((d: any) => d.domain) || []
+        )
       )
     ),
     exportCount: node.exports.length,

package/src/provider.ts

@@ -10,7 +10,11 @@ import {
   SpokeOutputSchema,
 } from '@aiready/core';
 import { calculateContextScore } from './scoring';
-import type { ContextAnalyzerOptions, ContextAnalysisResult } from './types';
+import type {
+  ContextAnalyzerOptions,
+  ContextAnalysisResult,
+  ContextSummary,
+} from './types';
 
 /**
  * Context Analyzer Tool Provider
@@ -58,8 +62,8 @@ export const ContextAnalyzerProvider: ToolProvider = {
   },
 
   score(output: SpokeOutput, options: ScanOptions): ToolScoringOutput {
-    const summary = output.summary as any;
-    return calculateContextScore(summary, (options as any).costConfig);
+    const summary = output.summary as unknown as ContextSummary;
+    return calculateContextScore(summary, options.costConfig);
   },
 
   defaultWeight: 19,

package/src/remediation.ts

@@ -155,5 +155,9 @@ export function getGeneralRecommendations(
     if (severity === 'info') severity = 'minor';
   }
 
-  return { recommendations, issues, severity: severity as any };
+  return {
+    recommendations,
+    issues,
+    severity: severity as 'critical' | 'major' | 'minor' | 'info',
+  };
 }

package/src/scoring.ts

@@ -49,15 +49,15 @@ export function calculateContextScore(
   costConfig?: Partial<CostConfig>
 ): ToolScoringOutput {
   const {
-    avgContextBudget,
-    maxContextBudget,
-    avgImportDepth,
-    maxImportDepth,
-    avgFragmentation,
-    criticalIssues,
-    majorIssues,
-    totalFiles,
-  } = summary;
+    avgContextBudget = 0,
+    maxContextBudget = 0,
+    avgImportDepth = 0,
+    maxImportDepth = 0,
+    avgFragmentation = 0.5, // neutral
+    criticalIssues = 0,
+    majorIssues = 0,
+    totalFiles = 0,
+  } = summary || {};
 
   // More reasonable thresholds for modern codebases
   const budgetScore =

package/src/semantic/domain-inference.ts

@@ -2,8 +2,8 @@ import type {
   DependencyGraph,
   DomainAssignment,
   DomainSignals,
-  ExportInfo,
 } from '../types';
+import type { ExportInfo } from '@aiready/core';
 import { singularize } from '../utils/string-utils';
 
 /**
@@ -59,8 +59,12 @@ export function inferDomainFromSemantics(
     const coNode = graph.nodes.get(coFile);
     if (coNode) {
       for (const exp of coNode.exports) {
-        if (exp.inferredDomain && exp.inferredDomain !== 'unknown') {
-          const domain = exp.inferredDomain;
+        const expAny = exp as {
+          inferredDomain?: string;
+          domains?: Array<{ domain: string }>;
+        };
+        if (expAny.inferredDomain && expAny.inferredDomain !== 'unknown') {
+          const domain = expAny.inferredDomain;
           if (!domainSignals.has(domain)) {
             domainSignals.set(domain, {
               coUsage: false,
@@ -85,8 +89,15 @@ export function inferDomainFromSemantics(
           const typeNode = graph.nodes.get(typeFile);
           if (typeNode) {
             for (const exp of typeNode.exports) {
-              if (exp.inferredDomain && exp.inferredDomain !== 'unknown') {
-                const domain = exp.inferredDomain;
+              const expAny = exp as {
+                inferredDomain?: string;
+                domains?: Array<{ domain: string }>;
+              };
+              if (
+                expAny.inferredDomain &&
+                expAny.inferredDomain !== 'unknown'
+              ) {
+                const domain = expAny.inferredDomain;
                 if (!domainSignals.has(domain)) {
                   domainSignals.set(domain, {
                     coUsage: false,
@@ -160,7 +171,7 @@ export function extractExports(
         domainOptions,
         fileImports
       );
-      exports.push({ name, type, inferredDomain });
+      exports.push({ name, type, inferredDomain } as any);
     }
   });
 

package/src/types.ts

@@ -1,4 +1,5 @@
-import type { ScanOptions, Severity } from '@aiready/core';
+import type { ScanOptions, Severity, ExportInfo } from '@aiready/core';
+export type { ExportInfo };
 
 /**
  * Options for the Context Analyzer tool.
@@ -159,16 +160,6 @@ export interface DependencyNode {
   sharedTypes?: string[]; // Types shared with other files
 }
 
-export interface ExportInfo {
-  name: string;
-  type: 'function' | 'class' | 'const' | 'type' | 'interface' | 'default';
-  inferredDomain?: string; // Inferred from name/usage (legacy single domain)
-  domains?: DomainAssignment[]; // Multi-domain support with confidence scores
-  imports?: string[]; // Imports used by this export (for import-based cohesion)
-  dependencies?: string[]; // Other exports from same file this depends on
-  typeReferences?: string[]; // TypeScript types referenced by this export
-}
-
 export interface DomainAssignment {
   domain: string;
   confidence: number; // 0-1, how confident are we in this assignment