@aiready/context-analyzer 0.9.36 → 0.9.40

package/dist/cli.js

@@ -180,6 +180,7 @@ async function calculatePythonImportDepth(file, dependencyGraph, visited, depth
   return maxDepth;
 }
 function estimateContextBudget(code, imports, dependencyGraph) {
+  void dependencyGraph;
   let budget = (0, import_core3.estimateTokens)(code);
   const avgTokensPerDep = 500;
   budget += imports.length * avgTokensPerDep;
@@ -253,6 +254,7 @@ var import_core = require("@aiready/core");
 function buildCoUsageMatrix(graph) {
   const coUsageMatrix = /* @__PURE__ */ new Map();
   for (const [sourceFile, node] of graph.nodes) {
+    void sourceFile;
     const imports = node.imports;
     for (let i = 0; i < imports.length; i++) {
       const fileA = imports[i];
@@ -314,7 +316,7 @@ function inferDomainFromSemantics(file, exportName, graph, coUsageMatrix, typeGr
   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);
+  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) {
@@ -430,10 +432,10 @@ function singularize(word) {
   }
   return word;
 }
-function buildDependencyGraph(files) {
+function buildDependencyGraph(files, options) {
   const nodes = /* @__PURE__ */ new Map();
   const edges = /* @__PURE__ */ new Map();
-  const autoDetectedKeywords = extractDomainKeywordsFromPaths(files);
+  const autoDetectedKeywords = options?.domainKeywords ?? extractDomainKeywordsFromPaths(files);
   void import_core.calculateImportSimilarity;
   for (const { file, content } of files) {
     const imports = extractImportsFromContent(content);

package/dist/cli.mjs

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

package/dist/index.js

@@ -180,6 +180,7 @@ async function calculatePythonImportDepth(file, dependencyGraph, visited, depth
   return maxDepth;
 }
 function estimateContextBudget(code, imports, dependencyGraph) {
+  void dependencyGraph;
   let budget = (0, import_core3.estimateTokens)(code);
   const avgTokensPerDep = 500;
   budget += imports.length * avgTokensPerDep;
@@ -267,6 +268,7 @@ var import_core = require("@aiready/core");
 function buildCoUsageMatrix(graph) {
   const coUsageMatrix = /* @__PURE__ */ new Map();
   for (const [sourceFile, node] of graph.nodes) {
+    void sourceFile;
     const imports = node.imports;
     for (let i = 0; i < imports.length; i++) {
       const fileA = imports[i];
@@ -347,7 +349,7 @@ function inferDomainFromSemantics(file, exportName, graph, coUsageMatrix, typeGr
   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);
+  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) {
@@ -509,10 +511,10 @@ function singularize(word) {
   }
   return word;
 }
-function buildDependencyGraph(files) {
+function buildDependencyGraph(files, options) {
   const nodes = /* @__PURE__ */ new Map();
   const edges = /* @__PURE__ */ new Map();
-  const autoDetectedKeywords = extractDomainKeywordsFromPaths(files);
+  const autoDetectedKeywords = options?.domainKeywords ?? extractDomainKeywordsFromPaths(files);
   void import_core.calculateImportSimilarity;
   for (const { file, content } of files) {
     const imports = extractImportsFromContent(content);

package/dist/index.mjs

@@ -12,7 +12,7 @@ import {
   getCoUsageData,
   getSmartDefaults,
   inferDomainFromSemantics
-} from "./chunk-7LUSCLGR.mjs";
+} from "./chunk-EBXG2Q5Y.mjs";
 export {
   adjustFragmentationForClassification,
   analyzeContext,

package/dist/python-context-TBI5FVFY.mjs

@@ -0,0 +1,203 @@
+// src/analyzers/python-context.ts
+import { getParser, estimateTokens } from "@aiready/core";
+import { resolve, relative, dirname, join } from "path";
+import fs from "fs";
+async function analyzePythonContext(files, rootDir) {
+  const results = [];
+  const parser = getParser("dummy.py");
+  if (!parser) {
+    console.warn("Python parser not available");
+    return results;
+  }
+  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
+  void relative;
+  void join;
+  const dependencyGraph = await buildPythonDependencyGraph(
+    pythonFiles,
+    rootDir
+  );
+  for (const file of pythonFiles) {
+    try {
+      const code = await fs.promises.readFile(file, "utf-8");
+      const result = parser.parse(code, file);
+      const imports = result.imports.map((imp) => ({
+        source: imp.source,
+        specifiers: imp.specifiers,
+        isRelative: imp.source.startsWith("."),
+        resolvedPath: resolvePythonImport(file, imp.source, rootDir)
+      }));
+      const exports = result.exports.map((exp) => ({
+        name: exp.name,
+        type: exp.type
+      }));
+      const linesOfCode = code.split("\n").length;
+      const importDepth = await calculatePythonImportDepth(
+        file,
+        dependencyGraph,
+        /* @__PURE__ */ new Set()
+      );
+      const contextBudget = estimateContextBudget(
+        code,
+        imports,
+        dependencyGraph
+      );
+      const cohesion = calculatePythonCohesion(exports, imports);
+      const circularDependencies = detectCircularDependencies(
+        file,
+        dependencyGraph
+      );
+      results.push({
+        file,
+        importDepth,
+        contextBudget,
+        cohesion,
+        imports,
+        exports,
+        metrics: {
+          linesOfCode,
+          importCount: imports.length,
+          exportCount: exports.length,
+          circularDependencies
+        }
+      });
+    } catch (error) {
+      console.warn(`Failed to analyze ${file}:`, error);
+    }
+  }
+  return results;
+}
+async function buildPythonDependencyGraph(files, rootDir) {
+  const graph = /* @__PURE__ */ new Map();
+  const parser = getParser("dummy.py");
+  if (!parser) return graph;
+  for (const file of files) {
+    try {
+      const code = await fs.promises.readFile(file, "utf-8");
+      const result = parser.parse(code, file);
+      const dependencies = /* @__PURE__ */ new Set();
+      for (const imp of result.imports) {
+        const resolved = resolvePythonImport(file, imp.source, rootDir);
+        if (resolved && files.includes(resolved)) {
+          dependencies.add(resolved);
+        }
+      }
+      graph.set(file, dependencies);
+    } catch (error) {
+      void error;
+    }
+  }
+  return graph;
+}
+function resolvePythonImport(fromFile, importPath, rootDir) {
+  const dir = dirname(fromFile);
+  if (importPath.startsWith(".")) {
+    const parts = importPath.split(".");
+    let upCount = 0;
+    while (parts[0] === "") {
+      upCount++;
+      parts.shift();
+    }
+    let targetDir = dir;
+    for (let i = 0; i < upCount - 1; i++) {
+      targetDir = dirname(targetDir);
+    }
+    const modulePath = parts.join("/");
+    const possiblePaths = [
+      resolve(targetDir, `${modulePath}.py`),
+      resolve(targetDir, modulePath, "__init__.py")
+    ];
+    for (const path of possiblePaths) {
+      if (fs.existsSync(path)) {
+        return path;
+      }
+    }
+  } else {
+    const modulePath = importPath.replace(/\./g, "/");
+    const possiblePaths = [
+      resolve(rootDir, `${modulePath}.py`),
+      resolve(rootDir, modulePath, "__init__.py")
+    ];
+    for (const path of possiblePaths) {
+      if (fs.existsSync(path)) {
+        return path;
+      }
+    }
+  }
+  return void 0;
+}
+async function calculatePythonImportDepth(file, dependencyGraph, visited, depth = 0) {
+  if (visited.has(file)) {
+    return depth;
+  }
+  visited.add(file);
+  const dependencies = dependencyGraph.get(file) || /* @__PURE__ */ 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;
+}
+function estimateContextBudget(code, imports, dependencyGraph) {
+  void dependencyGraph;
+  let budget = estimateTokens(code);
+  const avgTokensPerDep = 500;
+  budget += imports.length * avgTokensPerDep;
+  return budget;
+}
+function calculatePythonCohesion(exports, imports) {
+  if (exports.length === 0) return 1;
+  const exportCount = exports.length;
+  const importCount = imports.length;
+  let cohesion = 1;
+  if (exportCount > 10) {
+    cohesion *= 0.6;
+  } else if (exportCount > 5) {
+    cohesion *= 0.8;
+  }
+  if (exportCount > 0) {
+    const ratio = importCount / exportCount;
+    if (ratio > 2) {
+      cohesion *= 1.1;
+    } else if (ratio < 0.5) {
+      cohesion *= 0.9;
+    }
+  }
+  return Math.min(1, Math.max(0, cohesion));
+}
+function detectCircularDependencies(file, dependencyGraph) {
+  const circular = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(current, path) {
+    if (recursionStack.has(current)) {
+      const cycleStart = path.indexOf(current);
+      const cycle = path.slice(cycleStart).concat([current]);
+      circular.push(cycle.join(" \u2192 "));
+      return;
+    }
+    if (visited.has(current)) {
+      return;
+    }
+    visited.add(current);
+    recursionStack.add(current);
+    const dependencies = dependencyGraph.get(current) || /* @__PURE__ */ new Set();
+    for (const dep of dependencies) {
+      dfs(dep, [...path, current]);
+    }
+    recursionStack.delete(current);
+  }
+  dfs(file, []);
+  return [...new Set(circular)];
+}
+export {
+  analyzePythonContext
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/context-analyzer",
-  "version": "0.9.36",
+  "version": "0.9.40",
   "description": "AI context window cost analysis - detect fragmented code, deep import chains, and expensive context budgets",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -49,7 +49,7 @@
     "commander": "^14.0.0",
     "chalk": "^5.3.0",
     "prompts": "^2.4.2",
-    "@aiready/core": "0.9.33"
+    "@aiready/core": "0.9.37"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/__tests__/file-classification.test.ts

@@ -5,7 +5,7 @@ import {
   adjustCohesionForClassification,
   getClassificationRecommendations,
 } from '../analyzer';
-import type { DependencyNode, FileClassification } from '../types';
+import type { DependencyNode } from '../types';
 
 describe('file classification', () => {
   const createNode = (overrides: Partial<DependencyNode>): DependencyNode => ({

package/src/analyzer.ts

@@ -102,12 +102,16 @@ function singularize(word: string): string {
 /**
  * Build a dependency graph from file contents
  */
-export function buildDependencyGraph(files: FileContent[]): DependencyGraph {
+export function buildDependencyGraph(
+  files: FileContent[],
+  options?: { domainKeywords?: string[] }
+): DependencyGraph {
   const nodes = new Map<string, DependencyNode>();
   const edges = new Map<string, Set<string>>();
 
-  // Auto-detect domain keywords from workspace folder structure
-  const autoDetectedKeywords = extractDomainKeywordsFromPaths(files);
+  // Auto-detect domain keywords from workspace folder structure (allow override)
+  const autoDetectedKeywords =
+    options?.domainKeywords ?? extractDomainKeywordsFromPaths(files);
 
   // Some imported helpers are optional for future features; reference to avoid lint warnings
   void calculateImportSimilarity;

package/src/analyzers/python-context.ts

@@ -255,6 +255,7 @@ function estimateContextBudget(
   dependencyGraph: Map<string, Set<string>>
 ): number {
   // File tokens
+  void dependencyGraph;
   let budget = estimateTokens(code);
 
   // Add tokens for direct dependencies (simplified)

package/src/index.ts

@@ -299,11 +299,11 @@ export async function analyzeContext(
         maxFragmentation,
         circularDeps,
       });
-      // Some returned fields are not needed for the Python mapping here
-      void severity;
-      void issues;
-      void recommendations;
-      void potentialSavings;
+    // Some returned fields are not needed for the Python mapping here
+    void severity;
+    void issues;
+    void recommendations;
+    void potentialSavings;
 
     // Get domains from exports
     const domains = [

package/src/semantic-analysis.ts

@@ -17,6 +17,7 @@ export function buildCoUsageMatrix(
 
   // For each file, track which other files are imported alongside it
   for (const [sourceFile, node] of graph.nodes) {
+    void sourceFile;
     const imports = node.imports;
 
     // For each pair of imports in this file, increment their co-usage count
@@ -149,7 +150,7 @@ export function inferDomainFromSemantics(
   // 1. Check co-usage patterns
   const coUsages = coUsageMatrix.get(file) || new Map();
   const strongCoUsages = Array.from(coUsages.entries())
-    .filter(([_, count]) => count >= 3)
+    .filter(([, count]) => count >= 3)
     .map(([coFile]) => coFile);
 
   // Extract domains from frequently co-imported files