@aiready/context-analyzer 0.7.19 → 0.8.0

package/dist/chunk-Y6FXYEAI.mjs

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/cli.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,11 +30,207 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/analyzers/python-context.ts
+var python_context_exports = {};
+__export(python_context_exports, {
+  analyzePythonContext: () => analyzePythonContext
+});
+async function analyzePythonContext(files, rootDir) {
+  const results = [];
+  const parser = (0, import_core2.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 fs = await import("fs");
+      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 exports2 = 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(exports2, imports);
+      const circularDependencies = detectCircularDependencies2(file, dependencyGraph);
+      results.push({
+        file,
+        importDepth,
+        contextBudget,
+        cohesion,
+        imports,
+        exports: exports2,
+        metrics: {
+          linesOfCode,
+          importCount: imports.length,
+          exportCount: exports2.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 = (0, import_core2.getParser)("dummy.py");
+  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 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 = (0, import_path.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 = (0, import_path.dirname)(targetDir);
+    }
+    const modulePath = parts.join("/");
+    const possiblePaths = [
+      (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)) {
+        return path;
+      }
+    }
+  } else {
+    const modulePath = importPath.replace(/\./g, "/");
+    const possiblePaths = [
+      (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)) {
+        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 = (0, import_core2.estimateTokens)(code);
+  const avgTokensPerDep = 500;
+  budget += imports.length * avgTokensPerDep;
+  return budget;
+}
+function calculatePythonCohesion(exports2, imports) {
+  if (exports2.length === 0) return 1;
+  const exportCount = exports2.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 detectCircularDependencies2(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)];
+}
+var import_core2, import_path;
+var init_python_context = __esm({
+  "src/analyzers/python-context.ts"() {
+    "use strict";
+    import_core2 = require("@aiready/core");
+    import_path = require("path");
+  }
+});
+
 // src/cli.ts
 var import_commander = require("commander");
 
 // src/index.ts
-var import_core2 = require("@aiready/core");
+var import_core3 = require("@aiready/core");
 
 // src/analyzer.ts
 var import_core = require("@aiready/core");
@@ -598,20 +801,63 @@ async function analyzeContext(options) {
     includeNodeModules = false,
     ...scanOptions
   } = options;
-  const files = await (0, import_core2.scanFiles)({
+  const files = await (0, import_core3.scanFiles)({
     ...scanOptions,
     // Only add node_modules to exclude if includeNodeModules is false
     // The DEFAULT_EXCLUDE already includes node_modules, so this is only needed
     // if user overrides the default exclude list
     exclude: includeNodeModules && scanOptions.exclude ? scanOptions.exclude.filter((pattern) => pattern !== "**/node_modules/**") : scanOptions.exclude
   });
+  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
+  const tsJsFiles = files.filter((f) => !f.toLowerCase().endsWith(".py"));
   const fileContents = await Promise.all(
     files.map(async (file) => ({
       file,
-      content: await (0, import_core2.readFileContent)(file)
+      content: await (0, import_core3.readFileContent)(file)
     }))
   );
-  const graph = buildDependencyGraph(fileContents);
+  const graph = buildDependencyGraph(fileContents.filter((f) => !f.file.toLowerCase().endsWith(".py")));
+  let pythonResults = [];
+  if (pythonFiles.length > 0) {
+    const { analyzePythonContext: analyzePythonContext2 } = await Promise.resolve().then(() => (init_python_context(), python_context_exports));
+    const pythonMetrics = await analyzePythonContext2(pythonFiles, scanOptions.rootDir || options.rootDir || ".");
+    pythonResults = pythonMetrics.map((metric) => {
+      const { severity, issues, recommendations, potentialSavings } = analyzeIssues({
+        file: metric.file,
+        importDepth: metric.importDepth,
+        contextBudget: metric.contextBudget,
+        cohesionScore: metric.cohesion,
+        fragmentationScore: 0,
+        // Python analyzer doesn't calculate fragmentation yet
+        maxDepth,
+        maxContextBudget,
+        minCohesion,
+        maxFragmentation,
+        circularDeps: metric.metrics.circularDependencies.map((cycle) => cycle.split(" \u2192 "))
+      });
+      return {
+        file: metric.file,
+        tokenCost: Math.floor(metric.contextBudget / (1 + metric.imports.length || 1)),
+        // Estimate
+        linesOfCode: metric.metrics.linesOfCode,
+        importDepth: metric.importDepth,
+        dependencyCount: metric.imports.length,
+        dependencyList: metric.imports.map((imp) => imp.resolvedPath || imp.source),
+        circularDeps: metric.metrics.circularDependencies.map((cycle) => cycle.split(" \u2192 ")),
+        cohesionScore: metric.cohesion,
+        domains: ["python"],
+        // Generic for now
+        exportCount: metric.exports.length,
+        contextBudget: metric.contextBudget,
+        fragmentationScore: 0,
+        relatedFiles: [],
+        severity,
+        issues,
+        recommendations,
+        potentialSavings
+      };
+    });
+  }
   const circularDeps = detectCircularDependencies(graph);
   const clusters = detectModuleClusters(graph);
   const fragmentationMap = /* @__PURE__ */ new Map();
@@ -671,7 +917,8 @@ async function analyzeContext(options) {
       potentialSavings
     });
   }
-  const issuesOnly = results.filter((r) => r.severity !== "info");
+  const allResults = [...results, ...pythonResults];
+  const issuesOnly = allResults.filter((r) => r.severity !== "info");
   const sorted = issuesOnly.sort((a, b) => {
     const severityOrder = { critical: 0, major: 1, minor: 2, info: 3 };
     const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
@@ -876,8 +1123,8 @@ function downgradeSeverity(s) {
 // src/cli.ts
 var import_chalk = __toESM(require("chalk"));
 var import_fs = require("fs");
-var import_path = require("path");
-var import_core3 = require("@aiready/core");
+var import_path2 = require("path");
+var import_core4 = require("@aiready/core");
 var import_prompts = __toESM(require("prompts"));
 var program = new import_commander.Command();
 program.name("aiready-context").description("Analyze AI context window cost and code structure").version("0.1.0").addHelpText("after", "\nCONFIGURATION:\n  Supports config files: aiready.json, aiready.config.json, .aiready.json, .aireadyrc.json, aiready.config.js, .aireadyrc.js\n  CLI options override config file settings").argument("<directory>", "Directory to analyze").option("--max-depth <number>", "Maximum acceptable import depth").option(
@@ -908,7 +1155,7 @@ program.name("aiready-context").description("Analyze AI context window cost and
       exclude: void 0,
       maxResults: 10
     };
-    let finalOptions = await (0, import_core3.loadMergedConfig)(directory, defaults, {
+    let finalOptions = await (0, import_core4.loadMergedConfig)(directory, defaults, {
       maxDepth: options.maxDepth ? parseInt(options.maxDepth) : void 0,
       maxContextBudget: options.maxContext ? parseInt(options.maxContext) : void 0,
       minCohesion: options.minCohesion ? parseFloat(options.minCohesion) : void 0,
@@ -923,7 +1170,7 @@ program.name("aiready-context").description("Analyze AI context window cost and
       finalOptions = await runInteractiveSetup(directory, finalOptions);
     }
     const results = await analyzeContext(finalOptions);
-    const elapsedTime = (0, import_core3.getElapsedTime)(startTime);
+    const elapsedTime = (0, import_core4.getElapsedTime)(startTime);
     const summary = generateSummary(results);
     if (options.output === "json") {
       const jsonOutput = {
@@ -932,23 +1179,23 @@ program.name("aiready-context").description("Analyze AI context window cost and
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         analysisTime: elapsedTime
       };
-      const outputPath = (0, import_core3.resolveOutputPath)(
+      const outputPath = (0, import_core4.resolveOutputPath)(
         options.outputFile,
         `context-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.json`,
         directory
       );
-      (0, import_core3.handleJSONOutput)(jsonOutput, outputPath, `
+      (0, import_core4.handleJSONOutput)(jsonOutput, outputPath, `
 \u2713 JSON report saved to ${outputPath}`);
       return;
     }
     if (options.output === "html") {
       const html = generateHTMLReport(summary, results);
-      const outputPath = (0, import_core3.resolveOutputPath)(
+      const outputPath = (0, import_core4.resolveOutputPath)(
         options.outputFile,
         `context-report-${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}.html`,
         directory
       );
-      const dir = (0, import_path.dirname)(outputPath);
+      const dir = (0, import_path2.dirname)(outputPath);
       if (!(0, import_fs.existsSync)(dir)) {
         (0, import_fs.mkdirSync)(dir, { recursive: true });
       }
@@ -960,7 +1207,7 @@ program.name("aiready-context").description("Analyze AI context window cost and
     displayConsoleReport(summary, results, elapsedTime, finalOptions.maxResults);
     displayTuningGuidance(results, finalOptions);
   } catch (error) {
-    (0, import_core3.handleCLIError)(error, "Analysis");
+    (0, import_core4.handleCLIError)(error, "Analysis");
   }
 });
 program.parse();
@@ -1300,7 +1547,7 @@ function generateHTMLReport(summary, results) {
 }
 async function runInteractiveSetup(directory, current) {
   console.log(import_chalk.default.yellow("\u{1F9ED} Interactive mode: let\u2019s tailor the analysis."));
-  const pkgPath = (0, import_path.join)(directory, "package.json");
+  const pkgPath = (0, import_path2.join)(directory, "package.json");
   let deps = {};
   if ((0, import_fs.existsSync)(pkgPath)) {
     try {
@@ -1309,8 +1556,8 @@ async function runInteractiveSetup(directory, current) {
     } catch {
     }
   }
-  const hasNextJs = (0, import_fs.existsSync)((0, import_path.join)(directory, ".next")) || !!deps["next"];
-  const hasCDK = (0, import_fs.existsSync)((0, import_path.join)(directory, "cdk.out")) || !!deps["aws-cdk-lib"] || Object.keys(deps).some((d) => d.startsWith("@aws-cdk/"));
+  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 recommendedExcludes = new Set(current.exclude || []);
   if (hasNextJs && !Array.from(recommendedExcludes).some((p) => p.includes(".next"))) {
     recommendedExcludes.add("**/.next/**");

package/dist/cli.mjs

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