@aiready/context-analyzer 0.22.15 → 0.22.17

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.15",
+  "version": "0.22.17",
   "description": "AI context window cost analysis - detect fragmented code, deep import chains, and expensive context budgets",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -46,18 +46,18 @@
     "url": "https://github.com/getaiready/aiready-context-analyzer/issues"
   },
   "dependencies": {
-    "commander": "^14.0.0",
-    "chalk": "^5.3.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
     "prompts": "^2.4.2",
-    "@aiready/core": "0.24.16"
+    "@aiready/core": "0.24.20"
   },
   "devDependencies": {
-    "@types/node": "^24.0.0",
+    "@types/node": "^24.12.2",
     "@types/prompts": "^2.4.9",
-    "tsup": "^8.3.5",
-    "typescript": "^5.7.3",
-    "vitest": "^4.0.0",
-    "eslint": "^10.0.0"
+    "eslint": "^10.2.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -70,6 +70,9 @@
     "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",
+    "test:coverage": "vitest run --coverage"
   }
 }

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,

package/src/classify/file-classifiers.ts

@@ -1,4 +1,5 @@
 import { DependencyNode } from '../types';
+import type { ExportInfo } from '@aiready/core';
 import {
   BARREL_EXPORT_MIN_EXPORTS,
   BARREL_EXPORT_TOKEN_LIMIT,
@@ -23,7 +24,7 @@ export function isBoilerplateBarrel(node: DependencyNode): boolean {
   if (!exports || exports.length === 0) return false;
 
   // 1. Must be purely re-exports
-  const isPurelyReexports = exports.every((exp: any) => !!exp.source);
+  const isPurelyReexports = exports.every((exp: ExportInfo) => !!exp.source);
   if (!isPurelyReexports) return false;
 
   // 2. Must be low local token cost (no actual logic)
@@ -31,7 +32,7 @@ export function isBoilerplateBarrel(node: DependencyNode): boolean {
 
   // 3. Detect "Architectural Theater"
   // If it re-exports everything from exactly ONE source, it's a pass-through
-  const sources = new Set(exports.map((exp: any) => exp.source));
+  const sources = new Set(exports.map((exp: ExportInfo) => exp.source));
 
   // Pattern: export * from '../actual'
   const isSingleSourcePassThrough = sources.size === 1;
@@ -63,7 +64,7 @@ export function isBarrelExport(node: DependencyNode): boolean {
 
   const isReexportPattern =
     (exports || []).length >= BARREL_EXPORT_MIN_EXPORTS &&
-    (exports || []).every((exp: any) =>
+    (exports || []).every((exp: ExportInfo) =>
       ['const', 'function', 'type', 'interface'].includes(exp.type)
     );
 
@@ -86,7 +87,7 @@ export function isTypeDefinition(node: DependencyNode): boolean {
   const areAllTypes =
     hasExports &&
     nodeExports.every(
-      (exp: any) => exp.type === 'type' || exp.type === 'interface'
+      (exp: ExportInfo) => exp.type === 'type' || exp.type === 'interface'
     );
 
   const isTypePath = /\/(types|interfaces|models)\//i.test(file);
@@ -124,7 +125,7 @@ export function isLambdaHandler(node: DependencyNode): boolean {
   );
   const isHandlerPath = /\/(handlers|lambdas|lambda|functions)\//i.test(file);
   const hasHandlerExport = (exports || []).some(
-    (exp: any) =>
+    (exp: ExportInfo) =>
       ['handler', 'main', 'lambdahandler'].includes(exp.name.toLowerCase()) ||
       exp.name.toLowerCase().endsWith('handler')
   );
@@ -146,11 +147,11 @@ export function isServiceFile(node: DependencyNode): boolean {
     fileName.includes(pattern)
   );
   const isServicePath = file.toLowerCase().includes('/services/');
-  const hasServiceNamedExport = (exports || []).some((exp: any) =>
+  const hasServiceNamedExport = (exports || []).some((exp: ExportInfo) =>
     exp.name.toLowerCase().includes('service')
   );
   const hasClassExport = (exports || []).some(
-    (exp: any) => exp.type === 'class'
+    (exp: ExportInfo) => exp.type === 'class'
   );
   return (
     isServiceName || isServicePath || (hasServiceNamedExport && hasClassExport)
@@ -173,7 +174,7 @@ export function isEmailTemplate(node: DependencyNode): boolean {
   );
   const isEmailPath = /\/(emails|mail|notifications)\//i.test(file);
   const hasTemplateFunction = (exports || []).some(
-    (exp: any) =>
+    (exp: ExportInfo) =>
       exp.type === 'function' &&
       (exp.name.toLowerCase().startsWith('render') ||
         exp.name.toLowerCase().startsWith('generate'))
@@ -197,7 +198,7 @@ export function isParserFile(node: DependencyNode): boolean {
   );
   const isParserPath = /\/(parsers|transformers)\//i.test(file);
   const hasParseFunction = (exports || []).some(
-    (exp: any) =>
+    (exp: ExportInfo) =>
       exp.type === 'function' &&
       (exp.name.toLowerCase().startsWith('parse') ||
         exp.name.toLowerCase().startsWith('transform'))
@@ -220,7 +221,7 @@ export function isSessionFile(node: DependencyNode): boolean {
     fileName.includes(pattern)
   );
   const isSessionPath = /\/(sessions|state)\//i.test(file);
-  const hasSessionExport = (exports || []).some((exp: any) =>
+  const hasSessionExport = (exports || []).some((exp: ExportInfo) =>
     ['session', 'state', 'store'].some((pattern: string) =>
       exp.name.toLowerCase().includes(pattern)
     )
@@ -246,10 +247,10 @@ export function isNextJsPage(node: DependencyNode): boolean {
     return false;
 
   const hasDefaultExport = (exports || []).some(
-    (exp: any) => exp.type === 'default'
+    (exp: ExportInfo) => exp.type === 'default'
   );
 
-  const hasNextJsExport = (exports || []).some((exp: any) =>
+  const hasNextJsExport = (exports || []).some((exp: ExportInfo) =>
     NEXTJS_METADATA_EXPORTS.includes(exp.name.toLowerCase())
   );
 
@@ -272,7 +273,7 @@ export function isConfigFile(node: DependencyNode): boolean {
     fileName.includes(pattern)
   );
   const isConfigPath = /\/(config|settings|schemas)\//i.test(lowerPath);
-  const hasSchemaExport = (exports || []).some((exp: any) =>
+  const hasSchemaExport = (exports || []).some((exp: ExportInfo) =>
     ['schema', 'config', 'setting'].some((pattern: string) =>
       exp.name.toLowerCase().includes(pattern)
     )

package/src/cli-action.ts

@@ -7,6 +7,7 @@ import {
 } from '@aiready/core';
 import { analyzeContext } from './orchestrator';
 import { generateSummary } from './summary';
+import type { ContextAnalyzerOptions } from './types';
 import chalk from 'chalk';
 import { writeFileSync } from 'fs';
 
@@ -28,7 +29,7 @@ export async function contextActionHandler(directory: string, options: any) {
   try {
     // Define defaults
     const defaults = {
-      maxDepth: 5,
+      maxDepth: 10,
       maxContextBudget: 10000,
       minCohesion: 0.6,
       maxFragmentation: 0.5,
@@ -68,7 +69,9 @@ export async function contextActionHandler(directory: string, options: any) {
     }
 
     // Run analysis
-    const results = await analyzeContext(finalOptions as any);
+    const results = await analyzeContext(
+      finalOptions as ContextAnalyzerOptions
+    );
     const summary = generateSummary(results, finalOptions);
 
     const duration = getElapsedTime(startTime);
@@ -104,7 +107,7 @@ export async function contextActionHandler(directory: string, options: any) {
     } else {
       // Default: Console (Dynamic Import)
       const { displayConsoleReport } = await import('./report/console-report');
-      displayConsoleReport(summary, results, (finalOptions as any).maxResults);
+      displayConsoleReport(summary, results, finalOptions.maxResults);
       console.log(chalk.dim(`\n✨ Analysis completed in ${duration}ms\n`));
     }
   } catch (error) {

package/src/graph-builder.ts

@@ -23,6 +23,35 @@ function resolveImport(
   // If it's not a relative import, we treat it as an external dependency for now
   // (unless it's an absolute path that exists in our set)
   if (!source.startsWith('.') && !source.startsWith('/')) {
+    // Ignore standard libraries and external packages we don't control
+    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;
+    }
+
     // Handle monorepo package imports (@aiready/*)
     if (source.startsWith('@aiready/')) {
       const pkgName = source.split('/')[1];
@@ -144,12 +173,15 @@ export async function buildDependencyGraph(
     // 1. Get high-fidelity AST-based imports & exports
     const { imports: astImports } = await parseFileExports(content, file);
 
-    // 2. Resolve imports to absolute paths in the graph
-    const resolvedImports = astImports
+    // 2. Filter out type-only imports (they don't create runtime dependencies)
+    const runtimeImports = astImports.filter((i) => !i.isTypeOnly);
+
+    // 3. Resolve imports to absolute paths in the graph
+    const resolvedImports = runtimeImports
       .map((i) => resolveImport(i.source, file, allFilePaths))
       .filter((path): path is string => path !== null);
 
-    const importSources = astImports.map((i) => i.source);
+    const importSources = runtimeImports.map((i) => i.source);
 
     // 3. Wrap with platform-specific metadata (v0.11+)
     const exports = await extractExportsWithAST(
@@ -233,7 +265,7 @@ export function getTransitiveDependencies(
   file: string,
   graph: DependencyGraph,
   visited = new Set<string>()
-): string[] {
+): Map<string, number> {
   return getTransitiveDependenciesFromEdges(file, graph.edges, visited);
 }
 
@@ -242,7 +274,7 @@ export function getTransitiveDependencies(
  *
  * @param file - File path to calculate budget for.
  * @param graph - The dependency graph.
- * @returns Total token count including recursive dependencies.
+ * @returns Total token count including recursive dependencies (discounted by depth).
  */
 export function calculateContextBudget(
   file: string,
@@ -254,14 +286,17 @@ export function calculateContextBudget(
   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;
+      // Discount token cost by depth (20% reduction per level)
+      // This prevents "barrel file" false positives where a facade pulls in the entire project
+      const discountFactor = Math.pow(0.8, depth - 1);
+      totalTokens += depNode.tokenCost * discountFactor;
     }
   }
 
-  return totalTokens;
+  return Math.round(totalTokens);
 }
 
 /**