@aiready/context-analyzer 0.9.34 → 0.9.36

package/dist/python-context-GOH747QU.mjs

@@ -0,0 +1,202 @@
+// 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) {
+  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.34",
+  "version": "0.9.36",
   "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.31"
+    "@aiready/core": "0.9.33"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/__tests__/analyzer.test.ts

@@ -38,8 +38,14 @@ describe('calculateImportDepth', () => {
   it('should calculate import depth correctly', () => {
     const files = [
       { file: 'a.ts', content: 'export const a = 1;' },
-      { file: 'b.ts', content: 'import { a } from "a.ts";\nexport const b = a;' },
-      { file: 'c.ts', content: 'import { b } from "b.ts";\nexport const c = b;' },
+      {
+        file: 'b.ts',
+        content: 'import { a } from "a.ts";\nexport const b = a;',
+      },
+      {
+        file: 'c.ts',
+        content: 'import { b } from "b.ts";\nexport const c = b;',
+      },
     ];
 
     const graph = buildDependencyGraph(files);
@@ -51,8 +57,14 @@ describe('calculateImportDepth', () => {
 
   it('should handle circular dependencies gracefully', () => {
     const files = [
-      { file: 'a.ts', content: 'import { b } from "./b";\nexport const a = 1;' },
-      { file: 'b.ts', content: 'import { a } from "./a";\nexport const b = 2;' },
+      {
+        file: 'a.ts',
+        content: 'import { b } from "./b";\nexport const a = 1;',
+      },
+      {
+        file: 'b.ts',
+        content: 'import { a } from "./a";\nexport const b = 2;',
+      },
     ];
 
     const graph = buildDependencyGraph(files);
@@ -67,8 +79,14 @@ describe('getTransitiveDependencies', () => {
   it('should get all transitive dependencies', () => {
     const files = [
       { file: 'a.ts', content: 'export const a = 1;' },
-      { file: 'b.ts', content: 'import { a } from "a.ts";\nexport const b = a;' },
-      { file: 'c.ts', content: 'import { b } from "b.ts";\nexport const c = b;' },
+      {
+        file: 'b.ts',
+        content: 'import { a } from "a.ts";\nexport const b = a;',
+      },
+      {
+        file: 'c.ts',
+        content: 'import { b } from "b.ts";\nexport const c = b;',
+      },
     ];
 
     const graph = buildDependencyGraph(files);
@@ -84,7 +102,10 @@ describe('calculateContextBudget', () => {
   it('should calculate total token cost including dependencies', () => {
     const files = [
       { file: 'a.ts', content: 'export const a = 1;'.repeat(10) }, // ~40 tokens
-      { file: 'b.ts', content: 'import { a } from "./a";\nexport const b = a;'.repeat(10) }, // ~60 tokens
+      {
+        file: 'b.ts',
+        content: 'import { a } from "./a";\nexport const b = a;'.repeat(10),
+      }, // ~60 tokens
     ];
 
     const graph = buildDependencyGraph(files);
@@ -98,8 +119,14 @@ describe('calculateContextBudget', () => {
 describe('detectCircularDependencies', () => {
   it('should detect circular dependencies', () => {
     const files = [
-      { file: 'a.ts', content: 'import { b } from "b.ts";\nexport const a = 1;' },
-      { file: 'b.ts', content: 'import { a } from "a.ts";\nexport const b = 2;' },
+      {
+        file: 'a.ts',
+        content: 'import { b } from "b.ts";\nexport const a = 1;',
+      },
+      {
+        file: 'b.ts',
+        content: 'import { a } from "a.ts";\nexport const b = 2;',
+      },
     ];
 
     const graph = buildDependencyGraph(files);
@@ -111,7 +138,10 @@ describe('detectCircularDependencies', () => {
   it('should return empty for no circular dependencies', () => {
     const files = [
       { file: 'a.ts', content: 'export const a = 1;' },
-      { file: 'b.ts', content: 'import { a } from "a.ts";\nexport const b = a;' },
+      {
+        file: 'b.ts',
+        content: 'import { a } from "a.ts";\nexport const b = a;',
+      },
     ];
 
     const graph = buildDependencyGraph(files);
@@ -123,7 +153,9 @@ describe('detectCircularDependencies', () => {
 
 describe('calculateCohesion', () => {
   it('should return 1 for single export', () => {
-    const exports = [{ name: 'foo', type: 'function' as const, inferredDomain: 'user' }];
+    const exports = [
+      { name: 'foo', type: 'function' as const, inferredDomain: 'user' },
+    ];
     expect(calculateCohesion(exports)).toBe(1);
   });
 
@@ -142,7 +174,11 @@ describe('calculateCohesion', () => {
     const exports = [
       { name: 'getUser', type: 'function' as const, inferredDomain: 'user' },
       { name: 'getOrder', type: 'function' as const, inferredDomain: 'order' },
-      { name: 'parseConfig', type: 'function' as const, inferredDomain: 'config' },
+      {
+        name: 'parseConfig',
+        type: 'function' as const,
+        inferredDomain: 'config',
+      },
     ];
 
     const cohesion = calculateCohesion(exports);
@@ -153,23 +189,39 @@ describe('calculateCohesion', () => {
     const exports = [
       { name: 'mockUser', type: 'function' as const, inferredDomain: 'user' },
       { name: 'mockOrder', type: 'function' as const, inferredDomain: 'order' },
-      { name: 'setupTestDb', type: 'function' as const, inferredDomain: 'helper' },
+      {
+        name: 'setupTestDb',
+        type: 'function' as const,
+        inferredDomain: 'helper',
+      },
     ];
 
     // Test file - should return 1 despite mixed domains
-    const cohesionTestFile = calculateCohesion(exports, 'src/__tests__/helpers.test.ts');
+    const cohesionTestFile = calculateCohesion(
+      exports,
+      'src/__tests__/helpers.test.ts'
+    );
     expect(cohesionTestFile).toBe(1);
 
     // Mock file - should return 1 despite mixed domains
-    const cohesionMockFile = calculateCohesion(exports, 'src/test-utils/mocks.ts');
+    const cohesionMockFile = calculateCohesion(
+      exports,
+      'src/test-utils/mocks.ts'
+    );
     expect(cohesionMockFile).toBe(1);
 
     // Fixture file - should return 1 despite mixed domains
-    const cohesionFixtureFile = calculateCohesion(exports, 'src/fixtures/data.ts');
+    const cohesionFixtureFile = calculateCohesion(
+      exports,
+      'src/fixtures/data.ts'
+    );
     expect(cohesionFixtureFile).toBe(1);
 
     // Regular file - should have low cohesion
-    const cohesionRegularFile = calculateCohesion(exports, 'src/utils/helpers.ts');
+    const cohesionRegularFile = calculateCohesion(
+      exports,
+      'src/utils/helpers.ts'
+    );
     expect(cohesionRegularFile).toBeLessThan(0.5);
   });
 });

package/src/__tests__/auto-detection.test.ts

@@ -20,7 +20,7 @@ describe('Auto-detection from folder structure', () => {
 
     // Should detect 'payment' from processPayment (now part of auto-detected keywords)
     expect(paymentsNode?.exports[0].inferredDomain).toBe('payment');
-    
+
     // Should detect 'order' from createOrder
     expect(ordersNode?.exports[0].inferredDomain).toBe('order');
   });

package/src/__tests__/enhanced-cohesion.test.ts

@@ -10,7 +10,7 @@ describe('Enhanced Cohesion Calculation', () => {
     ];
 
     const cohesion = calculateCohesion(exports);
-    
+
     // With mixed domains (user, product) and no import data, should use domain-based calculation
     // Domain entropy for 2 different domains = low cohesion
     expect(cohesion).toBeLessThan(0.5);
@@ -33,7 +33,7 @@ describe('Enhanced Cohesion Calculation', () => {
     ];
 
     const cohesion = calculateCohesion(exports);
-    
+
     // Even though domains differ, imports are identical (Jaccard = 1.0)
     // Enhanced cohesion = 0.6 * 1.0 + 0.4 * 0.0 (different domains) = 0.6
     // Should be >= 0.6 (import-based weight)
@@ -72,8 +72,10 @@ describe('Enhanced Cohesion Calculation', () => {
     ];
 
     const cohesionWithShared = calculateCohesion(exportsWithSharedImports);
-    const cohesionWithoutShared = calculateCohesion(exportsWithoutSharedImports);
-    
+    const cohesionWithoutShared = calculateCohesion(
+      exportsWithoutSharedImports
+    );
+
     // Shared imports should result in higher cohesion
     expect(cohesionWithShared).toBeGreaterThan(cohesionWithoutShared);
   });
@@ -95,7 +97,7 @@ describe('Enhanced Cohesion Calculation', () => {
     ];
 
     const cohesion = calculateCohesion(exports);
-    
+
     // Should fall back to domain-based when not all exports have import data
     expect(cohesion).toBeGreaterThan(0);
     expect(cohesion).toBeLessThan(1);
@@ -116,8 +118,18 @@ describe('Enhanced Cohesion Calculation', () => {
 
   it('should return 1 for test files regardless of domains or imports', () => {
     const exports: ExportInfo[] = [
-      { name: 'testUserLogin', type: 'function', inferredDomain: 'user', imports: ['react'] },
-      { name: 'testProductView', type: 'function', inferredDomain: 'product', imports: [] },
+      {
+        name: 'testUserLogin',
+        type: 'function',
+        inferredDomain: 'user',
+        imports: ['react'],
+      },
+      {
+        name: 'testProductView',
+        type: 'function',
+        inferredDomain: 'product',
+        imports: [],
+      },
     ];
 
     const cohesion = calculateCohesion(exports, 'src/utils/test-helpers.ts');