@aiready/context-analyzer 0.9.31 → 0.9.34

package/dist/cli.js

@@ -46,8 +46,7 @@ async function analyzePythonContext(files, rootDir) {
   const dependencyGraph = await buildPythonDependencyGraph(pythonFiles, rootDir);
   for (const file of pythonFiles) {
     try {
-      const fs = await import("fs");
-      const code = await fs.promises.readFile(file, "utf-8");
+      const code = await import_fs.default.promises.readFile(file, "utf-8");
       const result = parser.parse(code, file);
       const imports = result.imports.map((imp) => ({
         source: imp.source,
@@ -90,8 +89,7 @@ async function buildPythonDependencyGraph(files, rootDir) {
   if (!parser) return graph;
   for (const file of files) {
     try {
-      const fs = await import("fs");
-      const code = await fs.promises.readFile(file, "utf-8");
+      const code = await import_fs.default.promises.readFile(file, "utf-8");
       const result = parser.parse(code, file);
       const dependencies = /* @__PURE__ */ new Set();
       for (const imp of result.imports) {
@@ -124,9 +122,8 @@ function resolvePythonImport(fromFile, importPath, rootDir) {
       (0, import_path.resolve)(targetDir, `${modulePath}.py`),
       (0, import_path.resolve)(targetDir, modulePath, "__init__.py")
     ];
-    const fs = require("fs");
     for (const path of possiblePaths) {
-      if (fs.existsSync(path)) {
+      if (import_fs.default.existsSync(path)) {
         return path;
       }
     }
@@ -136,9 +133,8 @@ function resolvePythonImport(fromFile, importPath, rootDir) {
       (0, import_path.resolve)(rootDir, `${modulePath}.py`),
       (0, import_path.resolve)(rootDir, modulePath, "__init__.py")
     ];
-    const fs = require("fs");
     for (const path of possiblePaths) {
-      if (fs.existsSync(path)) {
+      if (import_fs.default.existsSync(path)) {
         return path;
       }
     }
@@ -217,12 +213,13 @@ function detectCircularDependencies2(file, dependencyGraph) {
   dfs(file, []);
   return [...new Set(circular)];
 }
-var import_core3, import_path;
+var import_core3, import_path, import_fs;
 var init_python_context = __esm({
   "src/analyzers/python-context.ts"() {
     "use strict";
     import_core3 = require("@aiready/core");
     import_path = require("path");
+    import_fs = __toESM(require("fs"));
   }
 });
 
@@ -1887,7 +1884,7 @@ function downgradeSeverity(s) {
 
 // src/cli.ts
 var import_chalk = __toESM(require("chalk"));
-var import_fs = require("fs");
+var import_fs2 = require("fs");
 var import_path2 = require("path");
 var import_core5 = require("@aiready/core");
 var import_prompts = __toESM(require("prompts"));
@@ -1961,10 +1958,10 @@ program.name("aiready-context").description("Analyze AI context window cost and
         directory
       );
       const dir = (0, import_path2.dirname)(outputPath);
-      if (!(0, import_fs.existsSync)(dir)) {
-        (0, import_fs.mkdirSync)(dir, { recursive: true });
+      if (!(0, import_fs2.existsSync)(dir)) {
+        (0, import_fs2.mkdirSync)(dir, { recursive: true });
       }
-      (0, import_fs.writeFileSync)(outputPath, html);
+      (0, import_fs2.writeFileSync)(outputPath, html);
       console.log(import_chalk.default.green(`
 \u2713 HTML report saved to ${outputPath}`));
       return;
@@ -2314,15 +2311,15 @@ async function runInteractiveSetup(directory, current) {
   console.log(import_chalk.default.yellow("\u{1F9ED} Interactive mode: let\u2019s tailor the analysis."));
   const pkgPath = (0, import_path2.join)(directory, "package.json");
   let deps = {};
-  if ((0, import_fs.existsSync)(pkgPath)) {
+  if ((0, import_fs2.existsSync)(pkgPath)) {
     try {
-      const pkg = JSON.parse((0, import_fs.readFileSync)(pkgPath, "utf-8"));
+      const pkg = JSON.parse((0, import_fs2.readFileSync)(pkgPath, "utf-8"));
       deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
     } catch {
     }
   }
-  const hasNextJs = (0, import_fs.existsSync)((0, import_path2.join)(directory, ".next")) || !!deps["next"];
-  const hasCDK = (0, import_fs.existsSync)((0, import_path2.join)(directory, "cdk.out")) || !!deps["aws-cdk-lib"] || Object.keys(deps).some((d) => d.startsWith("@aws-cdk/"));
+  const hasNextJs = (0, import_fs2.existsSync)((0, import_path2.join)(directory, ".next")) || !!deps["next"];
+  const hasCDK = (0, import_fs2.existsSync)((0, import_path2.join)(directory, "cdk.out")) || !!deps["aws-cdk-lib"] || Object.keys(deps).some((d) => d.startsWith("@aws-cdk/"));
   const recommendedExcludes = new Set(current.exclude || []);
   if (hasNextJs && !Array.from(recommendedExcludes).some((p) => p.includes(".next"))) {
     recommendedExcludes.add("**/.next/**");

package/dist/cli.mjs

@@ -2,8 +2,7 @@
 import {
   analyzeContext,
   generateSummary
-} from "./chunk-M64RHH4D.mjs";
-import "./chunk-Y6FXYEAI.mjs";
+} from "./chunk-EVX2W2BK.mjs";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.js

@@ -46,8 +46,7 @@ async function analyzePythonContext(files, rootDir) {
   const dependencyGraph = await buildPythonDependencyGraph(pythonFiles, rootDir);
   for (const file of pythonFiles) {
     try {
-      const fs = await import("fs");
-      const code = await fs.promises.readFile(file, "utf-8");
+      const code = await import_fs.default.promises.readFile(file, "utf-8");
       const result = parser.parse(code, file);
       const imports = result.imports.map((imp) => ({
         source: imp.source,
@@ -90,8 +89,7 @@ async function buildPythonDependencyGraph(files, rootDir) {
   if (!parser) return graph;
   for (const file of files) {
     try {
-      const fs = await import("fs");
-      const code = await fs.promises.readFile(file, "utf-8");
+      const code = await import_fs.default.promises.readFile(file, "utf-8");
       const result = parser.parse(code, file);
       const dependencies = /* @__PURE__ */ new Set();
       for (const imp of result.imports) {
@@ -124,9 +122,8 @@ function resolvePythonImport(fromFile, importPath, rootDir) {
       (0, import_path.resolve)(targetDir, `${modulePath}.py`),
       (0, import_path.resolve)(targetDir, modulePath, "__init__.py")
     ];
-    const fs = require("fs");
     for (const path of possiblePaths) {
-      if (fs.existsSync(path)) {
+      if (import_fs.default.existsSync(path)) {
         return path;
       }
     }
@@ -136,9 +133,8 @@ function resolvePythonImport(fromFile, importPath, rootDir) {
       (0, import_path.resolve)(rootDir, `${modulePath}.py`),
       (0, import_path.resolve)(rootDir, modulePath, "__init__.py")
     ];
-    const fs = require("fs");
     for (const path of possiblePaths) {
-      if (fs.existsSync(path)) {
+      if (import_fs.default.existsSync(path)) {
         return path;
       }
     }
@@ -217,12 +213,13 @@ function detectCircularDependencies2(file, dependencyGraph) {
   dfs(file, []);
   return [...new Set(circular)];
 }
-var import_core3, import_path;
+var import_core3, import_path, import_fs;
 var init_python_context = __esm({
   "src/analyzers/python-context.ts"() {
     "use strict";
     import_core3 = require("@aiready/core");
     import_path = require("path");
+    import_fs = __toESM(require("fs"));
   }
 });
 

package/dist/index.mjs

@@ -12,8 +12,7 @@ import {
   getCoUsageData,
   getSmartDefaults,
   inferDomainFromSemantics
-} from "./chunk-M64RHH4D.mjs";
-import "./chunk-Y6FXYEAI.mjs";
+} from "./chunk-EVX2W2BK.mjs";
 export {
   adjustFragmentationForClassification,
   analyzeContext,

package/dist/python-context-PAETRLDY.mjs

@@ -0,0 +1,185 @@
+// src/analyzers/python-context.ts
+import { getParser, estimateTokens } from "@aiready/core";
+import { resolve, dirname } 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"));
+  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) {
+    }
+  }
+  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.31",
+  "version": "0.9.34",
   "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.28"
+    "@aiready/core": "0.9.31"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/analyzers/python-context.ts

@@ -10,6 +10,7 @@
 
 import { getParser, estimateTokens } from '@aiready/core';
 import { resolve, relative, dirname, join } from 'path';
+import fs from 'fs';
 
 export interface PythonContextMetrics {
   file: string;
@@ -54,13 +55,12 @@ export async function analyzePythonContext(
   }
 
   const pythonFiles = files.filter(f => f.toLowerCase().endsWith('.py'));
-  
+
   // Build dependency graph first
   const dependencyGraph = await buildPythonDependencyGraph(pythonFiles, rootDir);
 
   for (const file of pythonFiles) {
     try {
-      const fs = await import('fs');
       const code = await fs.promises.readFile(file, 'utf-8');
       const result = parser.parse(code, file);
 
@@ -119,7 +119,6 @@ async function buildPythonDependencyGraph(
 
   for (const file of files) {
     try {
-      const fs = await import('fs');
       const code = await fs.promises.readFile(file, 'utf-8');
       const result = parser.parse(code, file);
 
@@ -167,7 +166,6 @@ function resolvePythonImport(fromFile: string, importPath: string, rootDir: stri
       resolve(targetDir, modulePath, '__init__.py'),
     ];
 
-    const fs = require('fs');
     for (const path of possiblePaths) {
       if (fs.existsSync(path)) {
         return path;
@@ -181,7 +179,6 @@ function resolvePythonImport(fromFile: string, importPath: string, rootDir: stri
       resolve(rootDir, modulePath, '__init__.py'),
     ];
 
-    const fs = require('fs');
     for (const path of possiblePaths) {
       if (fs.existsSync(path)) {
         return path;