@aiready/context-analyzer 0.22.4 → 0.22.6

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/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