@aiready/context-analyzer 0.22.14 → 0.22.16

package/dist/index.js

@@ -177,6 +177,7 @@ function analyzeIssues(params) {
   const {
     file,
     importDepth,
+    tokenCost,
     contextBudget,
     cohesionScore,
     fragmentationScore,
@@ -211,21 +212,29 @@ function analyzeIssues(params) {
     recommendations.push("Consider reducing dependency depth");
     potentialSavings += contextBudget * 0.15;
   }
-  if (contextBudget > maxContextBudget * 1.5) {
-    severity = import_core3.Severity.Critical;
+  const MAX_FILE_TOKENS = 1e4;
+  if (tokenCost > MAX_FILE_TOKENS) {
+    if (severity !== import_core3.Severity.Critical) severity = import_core3.Severity.Major;
     issues.push(
-      `Context budget ${contextBudget.toLocaleString()} tokens is 50% over limit`
+      `File is excessively large (${tokenCost.toLocaleString()} tokens)`
     );
     recommendations.push(
-      "Split into smaller modules or reduce dependency tree"
+      "Split file into smaller, single-responsibility modules"
     );
+  }
+  if (contextBudget > maxContextBudget * 1.5) {
+    severity = import_core3.Severity.Critical;
+    issues.push(
+      `Total context budget ${contextBudget.toLocaleString()} tokens is 50% over limit`
+    );
+    recommendations.push("Reduce dependency tree width or reduce deep imports");
     potentialSavings += contextBudget * 0.4;
   } else if (contextBudget > maxContextBudget) {
     if (severity !== import_core3.Severity.Critical) severity = import_core3.Severity.Major;
     issues.push(
-      `Context budget ${contextBudget.toLocaleString()} exceeds ${maxContextBudget.toLocaleString()}`
+      `Total context budget ${contextBudget.toLocaleString()} exceeds ${maxContextBudget.toLocaleString()}`
     );
-    recommendations.push("Reduce file size or dependencies");
+    recommendations.push("Optimize dependency graph and reduce deep imports");
     potentialSavings += contextBudget * 0.2;
   }
   if (cohesionScore < minCohesion * 0.5) {
@@ -310,19 +319,27 @@ function calculateImportDepthFromEdges(file, edges, visited = /* @__PURE__ */ ne
   return maxDepth;
 }
 function getTransitiveDependenciesFromEdges(file, edges, visited = /* @__PURE__ */ new Set()) {
-  if (visited.has(file)) return [];
-  const nextVisited = new Set(visited);
-  nextVisited.add(file);
-  const dependencies = edges.get(file);
-  if (!dependencies || dependencies.size === 0) return [];
-  const allDeps = [];
-  for (const dep of dependencies) {
-    allDeps.push(dep);
-    allDeps.push(
-      ...getTransitiveDependenciesFromEdges(dep, edges, nextVisited)
-    );
+  const result = /* @__PURE__ */ new Map();
+  function dfs(current, depth) {
+    if (visited.has(current)) {
+      const existingDepth = result.get(current);
+      if (existingDepth !== void 0 && depth < existingDepth) {
+        result.set(current, depth);
+      }
+      return;
+    }
+    visited.add(current);
+    if (current !== file) {
+      result.set(current, depth);
+    }
+    const dependencies = edges.get(current);
+    if (!dependencies) return;
+    for (const dep of dependencies) {
+      dfs(dep, depth + 1);
+    }
   }
-  return [...new Set(allDeps)];
+  dfs(file, 0);
+  return result;
 }
 function detectGraphCycles(edges) {
   const cycles = [];
@@ -647,6 +664,30 @@ var init_ast_utils = __esm({
 // src/graph-builder.ts
 function resolveImport(source, importingFile, allFiles) {
   if (!source.startsWith(".") && !source.startsWith("/")) {
+    const externalIgnores = [
+      "react",
+      "next",
+      "lucide-react",
+      "framer-motion",
+      "@aws-sdk",
+      "stripe",
+      "clsx",
+      "tailwind-merge",
+      "zod",
+      "commander",
+      "chalk",
+      "fs",
+      "path",
+      "util",
+      "child_process",
+      "os",
+      "crypto"
+    ];
+    if (externalIgnores.some(
+      (pkg) => source === pkg || source.startsWith(`${pkg}/`)
+    )) {
+      return null;
+    }
     if (source.startsWith("@aiready/")) {
       const pkgName = source.split("/")[1];
       const possiblePaths = [
@@ -725,8 +766,9 @@ async function buildDependencyGraph(files, options) {
   const allFilePaths = new Set(files.map((f) => f.file));
   for (const { file, content } of files) {
     const { imports: astImports } = await (0, import_core5.parseFileExports)(content, file);
-    const resolvedImports = astImports.map((i) => resolveImport(i.source, file, allFilePaths)).filter((path) => path !== null);
-    const importSources = astImports.map((i) => i.source);
+    const runtimeImports = astImports.filter((i) => !i.isTypeOnly);
+    const resolvedImports = runtimeImports.map((i) => resolveImport(i.source, file, allFilePaths)).filter((path) => path !== null);
+    const importSources = runtimeImports.map((i) => i.source);
     const exports2 = await extractExportsWithAST(
       content,
       file,
@@ -779,13 +821,14 @@ function calculateContextBudget(file, graph) {
   if (!node) return 0;
   let totalTokens = node.tokenCost;
   const deps = getTransitiveDependencies(file, graph);
-  for (const dep of deps) {
+  for (const [dep, depth] of deps.entries()) {
     const depNode = graph.nodes.get(dep);
     if (depNode) {
-      totalTokens += depNode.tokenCost;
+      const discountFactor = Math.pow(0.8, depth - 1);
+      totalTokens += depNode.tokenCost * discountFactor;
     }
   }
-  return totalTokens;
+  return Math.round(totalTokens);
 }
 function detectCircularDependencies(graph) {
   return detectGraphCycles(graph.edges);
@@ -1604,6 +1647,7 @@ function mapNodeToResult(node, graph, clusters, allCircularDeps, options) {
     {
       file,
       importDepth,
+      tokenCost,
       contextBudget,
       cohesionScore,
       fragmentationScore,
@@ -1627,8 +1671,8 @@ function mapNodeToResult(node, graph, clusters, allCircularDeps, options) {
     tokenCost,
     linesOfCode: node.linesOfCode,
     importDepth,
-    dependencyCount: transitiveDeps.length,
-    dependencyList: transitiveDeps,
+    dependencyCount: transitiveDeps.size,
+    dependencyList: Array.from(transitiveDeps.keys()),
     circularDeps,
     cohesionScore,
     domains: Array.from(
@@ -1688,6 +1732,8 @@ async function analyzeContext(options) {
       const { severity, issues, recommendations, potentialSavings } = analyzeIssues({
         file: metric.file,
         importDepth: metric.importDepth,
+        tokenCost: metric.contextBudget,
+        // For Python, we use the reported budget as self-cost for now
         contextBudget: metric.contextBudget,
         cohesionScore: metric.cohesion,
         fragmentationScore: 0,

package/dist/index.mjs

@@ -12,8 +12,8 @@ import {
   getClassificationRecommendations,
   getGeneralRecommendations,
   getTransitiveDependencies
-} from "./chunk-ISWPFG2C.mjs";
-import "./chunk-64U3PNO3.mjs";
+} from "./chunk-2LEHY2GV.mjs";
+import "./chunk-RQ5BQLT6.mjs";
 import {
   generateSummary
 } from "./chunk-HD4Y3GYL.mjs";
@@ -230,7 +230,7 @@ var CONTEXT_ANALYZER_PROVIDER = {
   id: ToolName2.ContextAnalyzer,
   alias: ["context", "fragmentation", "budget"],
   async analyze(options) {
-    const { analyzeContext: analyzeContext2 } = await import("./orchestrator-QNE2E4TE.mjs");
+    const { analyzeContext: analyzeContext2 } = await import("./orchestrator-66ZVNOLR.mjs");
     const { generateSummary: generateSummary2 } = await import("./summary-TZFB6ZFM.mjs");
     const results = await analyzeContext2(options);
     const summary = generateSummary2(results, options);

package/dist/orchestrator-2KQNMO2L.mjs

@@ -0,0 +1,10 @@
+import {
+  analyzeContext,
+  calculateCohesion
+} from "./chunk-QTB4KYCX.mjs";
+import "./chunk-64U3PNO3.mjs";
+import "./chunk-JSM7Q5CY.mjs";
+export {
+  analyzeContext,
+  calculateCohesion
+};

package/dist/orchestrator-66ZVNOLR.mjs

@@ -0,0 +1,10 @@
+import {
+  analyzeContext,
+  calculateCohesion
+} from "./chunk-2LEHY2GV.mjs";
+import "./chunk-RQ5BQLT6.mjs";
+import "./chunk-JSM7Q5CY.mjs";
+export {
+  analyzeContext,
+  calculateCohesion
+};

package/dist/orchestrator-KM2OJPZD.mjs

@@ -0,0 +1,10 @@
+import {
+  analyzeContext,
+  calculateCohesion
+} from "./chunk-P2ZQGQAO.mjs";
+import "./chunk-64U3PNO3.mjs";
+import "./chunk-JSM7Q5CY.mjs";
+export {
+  analyzeContext,
+  calculateCohesion
+};

package/dist/orchestrator-MKDZPRBA.mjs

@@ -0,0 +1,10 @@
+import {
+  analyzeContext,
+  calculateCohesion
+} from "./chunk-QGI23DBA.mjs";
+import "./chunk-WLXLBWDU.mjs";
+import "./chunk-JSM7Q5CY.mjs";
+export {
+  analyzeContext,
+  calculateCohesion
+};

package/dist/orchestrator-QSHWWBWS.mjs

@@ -0,0 +1,10 @@
+import {
+  analyzeContext,
+  calculateCohesion
+} from "./chunk-VYFHSGV6.mjs";
+import "./chunk-RQ5BQLT6.mjs";
+import "./chunk-JSM7Q5CY.mjs";
+export {
+  analyzeContext,
+  calculateCohesion
+};

package/dist/orchestrator-WFQPMNSD.mjs

@@ -0,0 +1,10 @@
+import {
+  analyzeContext,
+  calculateCohesion
+} from "./chunk-XDYPMFCH.mjs";
+import "./chunk-64U3PNO3.mjs";
+import "./chunk-JSM7Q5CY.mjs";
+export {
+  analyzeContext,
+  calculateCohesion
+};

package/dist/python-context-H2OLC5JN.mjs

@@ -0,0 +1,162 @@
+import {
+  calculateImportDepthFromEdges,
+  detectGraphCyclesFromFile
+} from "./chunk-WLXLBWDU.mjs";
+
+// 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 = await 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 = calculateImportDepthFromEdges(
+        file,
+        dependencyGraph,
+        /* @__PURE__ */ new Set()
+      );
+      const contextBudget = estimateContextBudget(
+        code,
+        imports,
+        dependencyGraph
+      );
+      const cohesion = calculatePythonCohesion(exports, imports);
+      const circularDependencies = detectGraphCyclesFromFile(
+        file,
+        dependencyGraph
+      ).map((cycle) => cycle.join(" -> "));
+      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 = await 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;
+}
+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));
+}
+export {
+  analyzePythonContext
+};

package/dist/python-context-OBP7JD5P.mjs

@@ -0,0 +1,162 @@
+import {
+  calculateImportDepthFromEdges,
+  detectGraphCyclesFromFile
+} from "./chunk-RQ5BQLT6.mjs";
+
+// 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 = await 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 = calculateImportDepthFromEdges(
+        file,
+        dependencyGraph,
+        /* @__PURE__ */ new Set()
+      );
+      const contextBudget = estimateContextBudget(
+        code,
+        imports,
+        dependencyGraph
+      );
+      const cohesion = calculatePythonCohesion(exports, imports);
+      const circularDependencies = detectGraphCyclesFromFile(
+        file,
+        dependencyGraph
+      ).map((cycle) => cycle.join(" -> "));
+      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 = await 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;
+}
+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));
+}
+export {
+  analyzePythonContext
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/context-analyzer",
-  "version": "0.22.14",
+  "version": "0.22.16",
   "description": "AI context window cost analysis - detect fragmented code, deep import chains, and expensive context budgets",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -39,17 +39,17 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/caopengau/aiready-context-analyzer.git"
+    "url": "https://github.com/getaiready/aiready-context-analyzer.git"
   },
-  "homepage": "https://github.com/caopengau/aiready-context-analyzer",
+  "homepage": "https://github.com/getaiready/aiready-context-analyzer",
   "bugs": {
-    "url": "https://github.com/caopengau/aiready-context-analyzer/issues"
+    "url": "https://github.com/getaiready/aiready-context-analyzer/issues"
   },
   "dependencies": {
     "commander": "^14.0.0",
     "chalk": "^5.3.0",
     "prompts": "^2.4.2",
-    "@aiready/core": "0.24.15"
+    "@aiready/core": "0.24.19"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
@@ -70,6 +70,8 @@
     "clean": "rm -rf dist",
     "release": "pnpm build && pnpm publish --no-git-checks",
     "type-check": "tsc --noEmit",
-    "format-check": "prettier --check . --ignore-path ../../.prettierignore"
+    "format-check": "prettier --check . --ignore-path ../../.prettierignore",
+    "format": "prettier --write . --ignore-path ../../.prettierignore",
+    "lint:fix": "eslint . --fix"
   }
 }

package/src/__tests__/analyzer.test.ts

@@ -93,9 +93,10 @@ describe('getTransitiveDependencies', () => {
     const graph = await buildDependencyGraph(files);
     const deps = getTransitiveDependencies('c.ts', graph);
 
-    expect(deps).toContain('b.ts');
-    expect(deps).toContain('a.ts');
-    expect(deps.length).toBe(2);
+    const depKeys = Array.from(deps.keys());
+    expect(depKeys).toContain('b.ts');
+    expect(depKeys).toContain('a.ts');
+    expect(deps.size).toBe(2);
   });
 });
 

package/src/__tests__/issue-analyzer.test.ts

@@ -4,9 +4,11 @@ import { Severity } from '@aiready/core';
 
 describe('analyzeIssues', () => {
   const baseParams = {
-    file: 'src/test.ts',
+    file: 'test.ts',
     importDepth: 2,
-    contextBudget: 10000,
+    tokenCost: 1000,
+    contextBudget: 5000,
+
     cohesionScore: 0.8,
     fragmentationScore: 0.3,
     maxDepth: 5,