@aiready/context-analyzer 0.6.0 → 0.7.1

package/dist/cli.js

@@ -31,12 +31,176 @@ var import_core2 = require("@aiready/core");
 
 // src/analyzer.ts
 var import_core = require("@aiready/core");
+
+// src/semantic-analysis.ts
+function buildCoUsageMatrix(graph) {
+  const coUsageMatrix = /* @__PURE__ */ new Map();
+  for (const [sourceFile, node] of graph.nodes) {
+    const imports = node.imports;
+    for (let i = 0; i < imports.length; i++) {
+      const fileA = imports[i];
+      if (!coUsageMatrix.has(fileA)) {
+        coUsageMatrix.set(fileA, /* @__PURE__ */ new Map());
+      }
+      for (let j = i + 1; j < imports.length; j++) {
+        const fileB = imports[j];
+        const fileAUsage = coUsageMatrix.get(fileA);
+        fileAUsage.set(fileB, (fileAUsage.get(fileB) || 0) + 1);
+        if (!coUsageMatrix.has(fileB)) {
+          coUsageMatrix.set(fileB, /* @__PURE__ */ new Map());
+        }
+        const fileBUsage = coUsageMatrix.get(fileB);
+        fileBUsage.set(fileA, (fileBUsage.get(fileA) || 0) + 1);
+      }
+    }
+  }
+  return coUsageMatrix;
+}
+function buildTypeGraph(graph) {
+  const typeGraph = /* @__PURE__ */ new Map();
+  for (const [file, node] of graph.nodes) {
+    for (const exp of node.exports) {
+      if (exp.typeReferences) {
+        for (const typeRef of exp.typeReferences) {
+          if (!typeGraph.has(typeRef)) {
+            typeGraph.set(typeRef, /* @__PURE__ */ new Set());
+          }
+          typeGraph.get(typeRef).add(file);
+        }
+      }
+    }
+  }
+  return typeGraph;
+}
+function calculateDomainConfidence(signals) {
+  const weights = {
+    coUsage: 0.35,
+    // Strongest signal: actual usage patterns
+    typeReference: 0.3,
+    // Strong signal: shared types
+    exportName: 0.15,
+    // Medium signal: identifier semantics
+    importPath: 0.1,
+    // Weaker signal: path structure
+    folderStructure: 0.1
+    // Weakest signal: organization convention
+  };
+  let confidence = 0;
+  if (signals.coUsage) confidence += weights.coUsage;
+  if (signals.typeReference) confidence += weights.typeReference;
+  if (signals.exportName) confidence += weights.exportName;
+  if (signals.importPath) confidence += weights.importPath;
+  if (signals.folderStructure) confidence += weights.folderStructure;
+  return confidence;
+}
+function inferDomainFromSemantics(file, exportName, graph, coUsageMatrix, typeGraph, exportTypeRefs) {
+  const assignments = [];
+  const domainSignals = /* @__PURE__ */ new Map();
+  const coUsages = coUsageMatrix.get(file) || /* @__PURE__ */ new Map();
+  const strongCoUsages = Array.from(coUsages.entries()).filter(([_, count]) => count >= 3).map(([coFile]) => coFile);
+  for (const coFile of strongCoUsages) {
+    const coNode = graph.nodes.get(coFile);
+    if (coNode) {
+      for (const exp of coNode.exports) {
+        if (exp.inferredDomain && exp.inferredDomain !== "unknown") {
+          const domain = exp.inferredDomain;
+          if (!domainSignals.has(domain)) {
+            domainSignals.set(domain, {
+              coUsage: false,
+              typeReference: false,
+              exportName: false,
+              importPath: false,
+              folderStructure: false
+            });
+          }
+          domainSignals.get(domain).coUsage = true;
+        }
+      }
+    }
+  }
+  if (exportTypeRefs) {
+    for (const typeRef of exportTypeRefs) {
+      const filesWithType = typeGraph.get(typeRef);
+      if (filesWithType) {
+        for (const typeFile of filesWithType) {
+          if (typeFile !== file) {
+            const typeNode = graph.nodes.get(typeFile);
+            if (typeNode) {
+              for (const exp of typeNode.exports) {
+                if (exp.inferredDomain && exp.inferredDomain !== "unknown") {
+                  const domain = exp.inferredDomain;
+                  if (!domainSignals.has(domain)) {
+                    domainSignals.set(domain, {
+                      coUsage: false,
+                      typeReference: false,
+                      exportName: false,
+                      importPath: false,
+                      folderStructure: false
+                    });
+                  }
+                  domainSignals.get(domain).typeReference = true;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  for (const [domain, signals] of domainSignals) {
+    const confidence = calculateDomainConfidence(signals);
+    if (confidence >= 0.3) {
+      assignments.push({ domain, confidence, signals });
+    }
+  }
+  assignments.sort((a, b) => b.confidence - a.confidence);
+  return assignments;
+}
+
+// src/analyzer.ts
+function extractDomainKeywordsFromPaths(files) {
+  const folderNames = /* @__PURE__ */ new Set();
+  for (const { file } of files) {
+    const segments = file.split("/");
+    const skipFolders = /* @__PURE__ */ new Set(["src", "lib", "dist", "build", "node_modules", "test", "tests", "__tests__", "spec", "e2e", "scripts", "components", "utils", "helpers", "util", "helper", "api", "apis"]);
+    for (const segment of segments) {
+      const normalized = segment.toLowerCase();
+      if (normalized && !skipFolders.has(normalized) && !normalized.includes(".")) {
+        const singular = singularize(normalized);
+        folderNames.add(singular);
+      }
+    }
+  }
+  return Array.from(folderNames);
+}
+function singularize(word) {
+  const irregulars = {
+    people: "person",
+    children: "child",
+    men: "man",
+    women: "woman"
+  };
+  if (irregulars[word]) {
+    return irregulars[word];
+  }
+  if (word.endsWith("ies")) {
+    return word.slice(0, -3) + "y";
+  }
+  if (word.endsWith("ses")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && word.length > 3) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
 function buildDependencyGraph(files) {
   const nodes = /* @__PURE__ */ new Map();
   const edges = /* @__PURE__ */ new Map();
+  const autoDetectedKeywords = extractDomainKeywordsFromPaths(files);
   for (const { file, content } of files) {
     const imports = extractImportsFromContent(content);
-    const exports2 = extractExportsWithAST(content, file);
+    const exports2 = extractExportsWithAST(content, file, { domainKeywords: autoDetectedKeywords }, imports);
     const tokenCost = (0, import_core.estimateTokens)(content);
     const linesOfCode = content.split("\n").length;
     nodes.set(file, {
@@ -48,7 +212,28 @@ function buildDependencyGraph(files) {
     });
     edges.set(file, new Set(imports));
   }
-  return { nodes, edges };
+  const graph = { nodes, edges };
+  const coUsageMatrix = buildCoUsageMatrix(graph);
+  const typeGraph = buildTypeGraph(graph);
+  graph.coUsageMatrix = coUsageMatrix;
+  graph.typeGraph = typeGraph;
+  for (const [file, node] of nodes) {
+    for (const exp of node.exports) {
+      const semanticAssignments = inferDomainFromSemantics(
+        file,
+        exp.name,
+        graph,
+        coUsageMatrix,
+        typeGraph,
+        exp.typeReferences
+      );
+      exp.domains = semanticAssignments;
+      if (semanticAssignments.length > 0) {
+        exp.inferredDomain = semanticAssignments[0].domain;
+      }
+    }
+  }
+  return graph;
 }
 function extractImportsFromContent(content) {
   const imports = [];
@@ -64,7 +249,7 @@ function extractImportsFromContent(content) {
     let match;
     while ((match = pattern.exec(content)) !== null) {
       const importPath = match[1];
-      if (importPath && !importPath.startsWith("@") && !importPath.startsWith("node:")) {
+      if (importPath && !importPath.startsWith("node:")) {
         imports.push(importPath);
       }
     }
@@ -204,7 +389,7 @@ function detectModuleClusters(graph) {
   }
   return clusters.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
 }
-function extractExports(content) {
+function extractExports(content, filePath, domainOptions, fileImports) {
   const exports2 = [];
   const patterns = [
     /export\s+function\s+(\w+)/g,
@@ -227,15 +412,20 @@ function extractExports(content) {
     while ((match = pattern.exec(content)) !== null) {
       const name = match[1] || "default";
       const type = types[index];
-      const inferredDomain = inferDomain(name);
+      const inferredDomain = inferDomain(name, filePath, domainOptions, fileImports);
       exports2.push({ name, type, inferredDomain });
     }
   });
   return exports2;
 }
-function inferDomain(name) {
+function inferDomain(name, filePath, domainOptions, fileImports) {
   const lower = name.toLowerCase();
-  const domainKeywords = [
+  const tokens = Array.from(
+    new Set(
+      lower.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^a-z0-9]+/gi, " ").split(" ").filter(Boolean)
+    )
+  );
+  const defaultKeywords = [
     "authentication",
     "authorization",
     "payment",
@@ -252,14 +442,11 @@ function inferDomain(name) {
     "config",
     "model",
     "view",
-    "auth",
-    "api",
-    "helper",
-    "util"
+    "auth"
   ];
+  const domainKeywords = domainOptions?.domainKeywords && domainOptions.domainKeywords.length ? [...domainOptions.domainKeywords, ...defaultKeywords] : defaultKeywords;
   for (const keyword of domainKeywords) {
-    const wordBoundaryPattern = new RegExp(`\\b${keyword}\\b`, "i");
-    if (wordBoundaryPattern.test(name)) {
+    if (tokens.includes(keyword)) {
       return keyword;
     }
   }
@@ -268,6 +455,37 @@ function inferDomain(name) {
       return keyword;
     }
   }
+  if (fileImports && fileImports.length > 0) {
+    for (const importPath of fileImports) {
+      const allSegments = importPath.split("/");
+      const relevantSegments = allSegments.filter((s) => {
+        if (!s) return false;
+        if (s === "." || s === "..") return false;
+        if (s.startsWith("@") && s.length === 1) return false;
+        return true;
+      }).map((s) => s.startsWith("@") ? s.slice(1) : s);
+      for (const segment of relevantSegments) {
+        const segLower = segment.toLowerCase();
+        const singularSegment = singularize(segLower);
+        for (const keyword of domainKeywords) {
+          if (singularSegment === keyword || segLower === keyword || segLower.includes(keyword)) {
+            return keyword;
+          }
+        }
+      }
+    }
+  }
+  if (filePath) {
+    const pathSegments = filePath.toLowerCase().split("/");
+    for (const segment of pathSegments) {
+      const singularSegment = singularize(segment);
+      for (const keyword of domainKeywords) {
+        if (singularSegment === keyword || segment === keyword || segment.includes(keyword)) {
+          return keyword;
+        }
+      }
+    }
+  }
   return "unknown";
 }
 function generateConsolidationPlan(domain, files, targetFiles) {
@@ -296,18 +514,18 @@ function generateConsolidationPlan(domain, files, targetFiles) {
   );
   return plan;
 }
-function extractExportsWithAST(content, filePath) {
+function extractExportsWithAST(content, filePath, domainOptions, fileImports) {
   try {
     const { exports: astExports } = (0, import_core.parseFileExports)(content, filePath);
     return astExports.map((exp) => ({
       name: exp.name,
       type: exp.type,
-      inferredDomain: inferDomain(exp.name),
+      inferredDomain: inferDomain(exp.name, filePath, domainOptions, fileImports),
       imports: exp.imports,
       dependencies: exp.dependencies
     }));
   } catch (error) {
-    return extractExports(content);
+    return extractExports(content, filePath, domainOptions, fileImports);
   }
 }
 function calculateEnhancedCohesion(exports2, filePath) {

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import {
   analyzeContext,
   generateSummary
-} from "./chunk-DD7UVNE3.mjs";
+} from "./chunk-DMRZMS2U.mjs";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.d.mts

@@ -66,6 +66,95 @@ interface ContextSummary {
         severity: string;
     }>;
 }
+interface DependencyGraph {
+    nodes: Map<string, DependencyNode>;
+    edges: Map<string, Set<string>>;
+    coUsageMatrix?: Map<string, Map<string, number>>;
+    typeGraph?: Map<string, Set<string>>;
+}
+interface DependencyNode {
+    file: string;
+    imports: string[];
+    exports: ExportInfo[];
+    tokenCost: number;
+    linesOfCode: number;
+    exportedBy?: string[];
+    sharedTypes?: string[];
+}
+interface ExportInfo {
+    name: string;
+    type: 'function' | 'class' | 'const' | 'type' | 'interface' | 'default';
+    inferredDomain?: string;
+    domains?: DomainAssignment[];
+    imports?: string[];
+    dependencies?: string[];
+    typeReferences?: string[];
+}
+interface DomainAssignment {
+    domain: string;
+    confidence: number;
+    signals: DomainSignals;
+}
+interface DomainSignals {
+    folderStructure: boolean;
+    importPath: boolean;
+    typeReference: boolean;
+    coUsage: boolean;
+    exportName: boolean;
+}
+interface CoUsageData {
+    file: string;
+    coImportedWith: Map<string, number>;
+    sharedImporters: string[];
+}
+interface TypeDependency {
+    typeName: string;
+    definedIn: string;
+    usedBy: string[];
+}
+
+/**
+ * Build co-usage matrix: track which files are imported together
+ *
+ * Files frequently imported together likely belong to the same semantic domain
+ */
+declare function buildCoUsageMatrix(graph: DependencyGraph): Map<string, Map<string, number>>;
+/**
+ * Extract type dependencies from AST exports
+ *
+ * Files that share types are semantically related
+ */
+declare function buildTypeGraph(graph: DependencyGraph): Map<string, Set<string>>;
+/**
+ * Find semantic clusters using co-usage patterns
+ *
+ * Files with high co-usage counts belong in the same cluster
+ */
+declare function findSemanticClusters(coUsageMatrix: Map<string, Map<string, number>>, minCoUsage?: number): Map<string, string[]>;
+/**
+ * Calculate confidence score for domain assignment based on multiple signals
+ */
+declare function calculateDomainConfidence(signals: DomainSignals): number;
+/**
+ * Infer domain from semantic analysis (co-usage + types)
+ *
+ * This replaces the folder-based heuristic with actual code relationships
+ */
+declare function inferDomainFromSemantics(file: string, exportName: string, graph: DependencyGraph, coUsageMatrix: Map<string, Map<string, number>>, typeGraph: Map<string, Set<string>>, exportTypeRefs?: string[]): DomainAssignment[];
+/**
+ * Get co-usage data for a specific file
+ */
+declare function getCoUsageData(file: string, coUsageMatrix: Map<string, Map<string, number>>): CoUsageData;
+/**
+ * Find files that should be consolidated based on semantic similarity
+ *
+ * High co-usage + shared types = strong consolidation candidate
+ */
+declare function findConsolidationCandidates(graph: DependencyGraph, coUsageMatrix: Map<string, Map<string, number>>, typeGraph: Map<string, Set<string>>, minCoUsage?: number, minSharedTypes?: number): Array<{
+    files: string[];
+    reason: string;
+    strength: number;
+}>;
 
 /**
  * Generate smart defaults for context analysis based on repository size
@@ -81,4 +170,4 @@ declare function analyzeContext(options: ContextAnalyzerOptions): Promise<Contex
  */
 declare function generateSummary(results: ContextAnalysisResult[]): ContextSummary;
 
-export { type ContextAnalysisResult, type ContextAnalyzerOptions, type ContextSummary, type ModuleCluster, analyzeContext, generateSummary, getSmartDefaults };
+export { type CoUsageData, type ContextAnalysisResult, type ContextAnalyzerOptions, type ContextSummary, type DomainAssignment, type DomainSignals, type ModuleCluster, type TypeDependency, analyzeContext, buildCoUsageMatrix, buildTypeGraph, calculateDomainConfidence, findConsolidationCandidates, findSemanticClusters, generateSummary, getCoUsageData, getSmartDefaults, inferDomainFromSemantics };

package/dist/index.d.ts

@@ -66,6 +66,95 @@ interface ContextSummary {
         severity: string;
     }>;
 }
+interface DependencyGraph {
+    nodes: Map<string, DependencyNode>;
+    edges: Map<string, Set<string>>;
+    coUsageMatrix?: Map<string, Map<string, number>>;
+    typeGraph?: Map<string, Set<string>>;
+}
+interface DependencyNode {
+    file: string;
+    imports: string[];
+    exports: ExportInfo[];
+    tokenCost: number;
+    linesOfCode: number;
+    exportedBy?: string[];
+    sharedTypes?: string[];
+}
+interface ExportInfo {
+    name: string;
+    type: 'function' | 'class' | 'const' | 'type' | 'interface' | 'default';
+    inferredDomain?: string;
+    domains?: DomainAssignment[];
+    imports?: string[];
+    dependencies?: string[];
+    typeReferences?: string[];
+}
+interface DomainAssignment {
+    domain: string;
+    confidence: number;
+    signals: DomainSignals;
+}
+interface DomainSignals {
+    folderStructure: boolean;
+    importPath: boolean;
+    typeReference: boolean;
+    coUsage: boolean;
+    exportName: boolean;
+}
+interface CoUsageData {
+    file: string;
+    coImportedWith: Map<string, number>;
+    sharedImporters: string[];
+}
+interface TypeDependency {
+    typeName: string;
+    definedIn: string;
+    usedBy: string[];
+}
+
+/**
+ * Build co-usage matrix: track which files are imported together
+ *
+ * Files frequently imported together likely belong to the same semantic domain
+ */
+declare function buildCoUsageMatrix(graph: DependencyGraph): Map<string, Map<string, number>>;
+/**
+ * Extract type dependencies from AST exports
+ *
+ * Files that share types are semantically related
+ */
+declare function buildTypeGraph(graph: DependencyGraph): Map<string, Set<string>>;
+/**
+ * Find semantic clusters using co-usage patterns
+ *
+ * Files with high co-usage counts belong in the same cluster
+ */
+declare function findSemanticClusters(coUsageMatrix: Map<string, Map<string, number>>, minCoUsage?: number): Map<string, string[]>;
+/**
+ * Calculate confidence score for domain assignment based on multiple signals
+ */
+declare function calculateDomainConfidence(signals: DomainSignals): number;
+/**
+ * Infer domain from semantic analysis (co-usage + types)
+ *
+ * This replaces the folder-based heuristic with actual code relationships
+ */
+declare function inferDomainFromSemantics(file: string, exportName: string, graph: DependencyGraph, coUsageMatrix: Map<string, Map<string, number>>, typeGraph: Map<string, Set<string>>, exportTypeRefs?: string[]): DomainAssignment[];
+/**
+ * Get co-usage data for a specific file
+ */
+declare function getCoUsageData(file: string, coUsageMatrix: Map<string, Map<string, number>>): CoUsageData;
+/**
+ * Find files that should be consolidated based on semantic similarity
+ *
+ * High co-usage + shared types = strong consolidation candidate
+ */
+declare function findConsolidationCandidates(graph: DependencyGraph, coUsageMatrix: Map<string, Map<string, number>>, typeGraph: Map<string, Set<string>>, minCoUsage?: number, minSharedTypes?: number): Array<{
+    files: string[];
+    reason: string;
+    strength: number;
+}>;
 
 /**
  * Generate smart defaults for context analysis based on repository size
@@ -81,4 +170,4 @@ declare function analyzeContext(options: ContextAnalyzerOptions): Promise<Contex
  */
 declare function generateSummary(results: ContextAnalysisResult[]): ContextSummary;
 
-export { type ContextAnalysisResult, type ContextAnalyzerOptions, type ContextSummary, type ModuleCluster, analyzeContext, generateSummary, getSmartDefaults };
+export { type CoUsageData, type ContextAnalysisResult, type ContextAnalyzerOptions, type ContextSummary, type DomainAssignment, type DomainSignals, type ModuleCluster, type TypeDependency, analyzeContext, buildCoUsageMatrix, buildTypeGraph, calculateDomainConfidence, findConsolidationCandidates, findSemanticClusters, generateSummary, getCoUsageData, getSmartDefaults, inferDomainFromSemantics };