@aiready/context-analyzer 0.3.8 → 0.4.1

package/.github/FUNDING.yml

@@ -0,0 +1,5 @@
+github: ["caopengau"]
+custom:
+  - https://github.com/sponsors/caopengau
+  - https://receiptclaimer.com
+  - mailto:caopengau@gmail.com

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/context-analyzer@0.3.8 build /Users/pengcao/projects/aiready/packages/context-analyzer
+> @aiready/context-analyzer@0.4.1 build /Users/pengcao/projects/aiready/packages/context-analyzer
 > tsup src/index.ts src/cli.ts --format cjs,esm --dts
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -9,15 +9,15 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-ESM dist/chunk-5N5DCJOV.mjs 18.32 KB
+CJS dist/index.js 20.26 KB
+CJS dist/cli.js   35.91 KB
+CJS ⚡️ Build success in 58ms
 ESM dist/index.mjs          164.00 B
-ESM dist/cli.mjs            13.36 KB
-ESM ⚡️ Build success in 22ms
-CJS dist/index.js 19.47 KB
-CJS dist/cli.js   32.57 KB
-CJS ⚡️ Build success in 23ms
+ESM dist/chunk-HDFXSEFW.mjs 19.11 KB
+ESM dist/cli.mjs            15.74 KB
+ESM ⚡️ Build success in 57ms
 DTS Build start
-DTS ⚡️ Build success in 705ms
+DTS ⚡️ Build success in 848ms
 DTS dist/cli.d.ts    20.00 B
 DTS dist/index.d.ts  2.37 KB
 DTS dist/cli.d.mts   20.00 B

package/.turbo/turbo-test.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/context-analyzer@0.1.0 test /Users/pengcao/projects/aiready/packages/context-analyzer
+> @aiready/context-analyzer@0.3.8 test /Users/pengcao/projects/aiready/packages/context-analyzer
 > vitest run
 
 
@@ -30,7 +30,7 @@
 
  Test Files  1 passed (1)
       Tests  13 passed (13)
-   Start at  03:16:28
-   Duration  314ms (transform 75ms, setup 0ms, collect 86ms, tests 4ms, environment 0ms, prepare 38ms)
+   Start at  03:56:27
+   Duration  286ms (transform 65ms, setup 0ms, collect 76ms, tests 3ms, environment 0ms, prepare 45ms)
 
 [?25h

package/README.md

@@ -265,7 +265,7 @@ By default, these patterns are excluded (unless `--include-node-modules` is used
 **/node_modules/**
 
 # Build outputs
-**/dist/**, **/build/**, **/out/**, **/output/**, **/target/**, **/bin/**, **/obj/**
+**/dist/**, **/build/**, **/out/**, **/output/**, **/target/**, **/bin/**, **/obj/**, **/cdk.out/**
 
 # Framework-specific build dirs
 **/.next/**, **/.nuxt/**, **/.vuepress/**, **/.cache/**, **/.turbo/**
@@ -357,6 +357,20 @@ Shareable report with tables and visualizations. Perfect for stakeholders:
 aiready-context ./src --output html --output-file context-report.html
 ```
 
+## 🧭 Interactive Mode
+
+For first-time users, enable interactive guidance to apply smart defaults and focus areas:
+
+```bash
+# Suggest excludes for common frameworks (Next.js, AWS CDK) and choose focus
+aiready-context ./src --interactive
+```
+
+Interactive mode:
+- Detects frameworks and recommends excludes (e.g., .next, cdk.out)
+- Lets you choose focus areas: frontend, backend, or both
+- Applies configuration without modifying your files
+
 ## 🔗 Integration
 
 ### CI/CD

package/dist/chunk-HDFXSEFW.mjs

@@ -0,0 +1,605 @@
+// src/index.ts
+import { scanFiles, readFileContent } from "@aiready/core";
+
+// src/analyzer.ts
+import { estimateTokens } from "@aiready/core";
+function buildDependencyGraph(files) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  for (const { file, content } of files) {
+    const imports = extractImportsFromContent(content);
+    const exports = extractExports(content);
+    const tokenCost = estimateTokens(content);
+    const linesOfCode = content.split("\n").length;
+    nodes.set(file, {
+      file,
+      imports,
+      exports,
+      tokenCost,
+      linesOfCode
+    });
+    edges.set(file, new Set(imports));
+  }
+  return { nodes, edges };
+}
+function extractImportsFromContent(content) {
+  const imports = [];
+  const patterns = [
+    /import\s+.*?\s+from\s+['"](.+?)['"]/g,
+    // import ... from '...'
+    /import\s+['"](.+?)['"]/g,
+    // import '...'
+    /require\(['"](.+?)['"]\)/g
+    // require('...')
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath && !importPath.startsWith("@") && !importPath.startsWith("node:")) {
+        imports.push(importPath);
+      }
+    }
+  }
+  return [...new Set(imports)];
+}
+function calculateImportDepth(file, graph, visited = /* @__PURE__ */ new Set(), depth = 0) {
+  if (visited.has(file)) {
+    return depth;
+  }
+  const dependencies = graph.edges.get(file);
+  if (!dependencies || dependencies.size === 0) {
+    return depth;
+  }
+  visited.add(file);
+  let maxDepth = depth;
+  for (const dep of dependencies) {
+    const depDepth = calculateImportDepth(dep, graph, visited, depth + 1);
+    maxDepth = Math.max(maxDepth, depDepth);
+  }
+  visited.delete(file);
+  return maxDepth;
+}
+function getTransitiveDependencies(file, graph, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(file)) {
+    return [];
+  }
+  visited.add(file);
+  const dependencies = graph.edges.get(file);
+  if (!dependencies || dependencies.size === 0) {
+    return [];
+  }
+  const allDeps = [];
+  for (const dep of dependencies) {
+    allDeps.push(dep);
+    allDeps.push(...getTransitiveDependencies(dep, graph, visited));
+  }
+  return [...new Set(allDeps)];
+}
+function calculateContextBudget(file, graph) {
+  const node = graph.nodes.get(file);
+  if (!node) return 0;
+  let totalTokens = node.tokenCost;
+  const deps = getTransitiveDependencies(file, graph);
+  for (const dep of deps) {
+    const depNode = graph.nodes.get(dep);
+    if (depNode) {
+      totalTokens += depNode.tokenCost;
+    }
+  }
+  return totalTokens;
+}
+function detectCircularDependencies(graph) {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const recursionStack = /* @__PURE__ */ new Set();
+  function dfs(file, path) {
+    if (recursionStack.has(file)) {
+      const cycleStart = path.indexOf(file);
+      if (cycleStart !== -1) {
+        cycles.push([...path.slice(cycleStart), file]);
+      }
+      return;
+    }
+    if (visited.has(file)) {
+      return;
+    }
+    visited.add(file);
+    recursionStack.add(file);
+    path.push(file);
+    const dependencies = graph.edges.get(file);
+    if (dependencies) {
+      for (const dep of dependencies) {
+        dfs(dep, [...path]);
+      }
+    }
+    recursionStack.delete(file);
+  }
+  for (const file of graph.nodes.keys()) {
+    if (!visited.has(file)) {
+      dfs(file, []);
+    }
+  }
+  return cycles;
+}
+function calculateCohesion(exports) {
+  if (exports.length === 0) return 1;
+  if (exports.length === 1) return 1;
+  const domains = exports.map((e) => e.inferredDomain || "unknown");
+  const domainCounts = /* @__PURE__ */ new Map();
+  for (const domain of domains) {
+    domainCounts.set(domain, (domainCounts.get(domain) || 0) + 1);
+  }
+  const total = domains.length;
+  let entropy = 0;
+  for (const count of domainCounts.values()) {
+    const p = count / total;
+    if (p > 0) {
+      entropy -= p * Math.log2(p);
+    }
+  }
+  const maxEntropy = Math.log2(total);
+  return maxEntropy > 0 ? 1 - entropy / maxEntropy : 1;
+}
+function calculateFragmentation(files, domain) {
+  if (files.length <= 1) return 0;
+  const directories = new Set(files.map((f) => f.split("/").slice(0, -1).join("/")));
+  return (directories.size - 1) / (files.length - 1);
+}
+function detectModuleClusters(graph) {
+  const domainMap = /* @__PURE__ */ new Map();
+  for (const [file, node] of graph.nodes.entries()) {
+    const domains = node.exports.map((e) => e.inferredDomain || "unknown");
+    const primaryDomain = domains[0] || "unknown";
+    if (!domainMap.has(primaryDomain)) {
+      domainMap.set(primaryDomain, []);
+    }
+    domainMap.get(primaryDomain).push(file);
+  }
+  const clusters = [];
+  for (const [domain, files] of domainMap.entries()) {
+    if (files.length < 2) continue;
+    const totalTokens = files.reduce((sum, file) => {
+      const node = graph.nodes.get(file);
+      return sum + (node?.tokenCost || 0);
+    }, 0);
+    const fragmentationScore = calculateFragmentation(files, domain);
+    const avgCohesion = files.reduce((sum, file) => {
+      const node = graph.nodes.get(file);
+      return sum + (node ? calculateCohesion(node.exports) : 0);
+    }, 0) / files.length;
+    const targetFiles = Math.max(1, Math.ceil(files.length / 3));
+    const consolidationPlan = generateConsolidationPlan(
+      domain,
+      files,
+      targetFiles
+    );
+    clusters.push({
+      domain,
+      files,
+      totalTokens,
+      fragmentationScore,
+      avgCohesion,
+      suggestedStructure: {
+        targetFiles,
+        consolidationPlan
+      }
+    });
+  }
+  return clusters.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
+}
+function extractExports(content) {
+  const exports = [];
+  const patterns = [
+    /export\s+function\s+(\w+)/g,
+    /export\s+class\s+(\w+)/g,
+    /export\s+const\s+(\w+)/g,
+    /export\s+type\s+(\w+)/g,
+    /export\s+interface\s+(\w+)/g,
+    /export\s+default/g
+  ];
+  const types = [
+    "function",
+    "class",
+    "const",
+    "type",
+    "interface",
+    "default"
+  ];
+  patterns.forEach((pattern, index) => {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const name = match[1] || "default";
+      const type = types[index];
+      const inferredDomain = inferDomain(name);
+      exports.push({ name, type, inferredDomain });
+    }
+  });
+  return exports;
+}
+function inferDomain(name) {
+  const lower = name.toLowerCase();
+  const domainKeywords = [
+    "user",
+    "auth",
+    "order",
+    "product",
+    "payment",
+    "cart",
+    "invoice",
+    "customer",
+    "admin",
+    "api",
+    "util",
+    "helper",
+    "config",
+    "service",
+    "repository",
+    "controller",
+    "model",
+    "view"
+  ];
+  for (const keyword of domainKeywords) {
+    if (lower.includes(keyword)) {
+      return keyword;
+    }
+  }
+  return "unknown";
+}
+function generateConsolidationPlan(domain, files, targetFiles) {
+  const plan = [];
+  if (files.length <= targetFiles) {
+    return [`No consolidation needed for ${domain}`];
+  }
+  plan.push(
+    `Consolidate ${files.length} ${domain} files into ${targetFiles} cohesive file(s):`
+  );
+  const dirGroups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const dir = file.split("/").slice(0, -1).join("/");
+    if (!dirGroups.has(dir)) {
+      dirGroups.set(dir, []);
+    }
+    dirGroups.get(dir).push(file);
+  }
+  plan.push(`1. Create unified ${domain} module file`);
+  plan.push(
+    `2. Move related functionality from ${files.length} scattered files`
+  );
+  plan.push(`3. Update imports in dependent files`);
+  plan.push(
+    `4. Remove old files after consolidation (verify with tests first)`
+  );
+  return plan;
+}
+
+// src/index.ts
+async function getSmartDefaults(directory, userOptions) {
+  const files = await scanFiles({
+    rootDir: directory,
+    include: userOptions.include,
+    exclude: userOptions.exclude
+  });
+  const estimatedBlocks = files.length;
+  let maxDepth;
+  let maxContextBudget;
+  let minCohesion;
+  let maxFragmentation;
+  if (estimatedBlocks < 100) {
+    maxDepth = 3;
+    maxContextBudget = 5e3;
+    minCohesion = 0.7;
+    maxFragmentation = 0.3;
+  } else if (estimatedBlocks < 500) {
+    maxDepth = 4;
+    maxContextBudget = 8e3;
+    minCohesion = 0.65;
+    maxFragmentation = 0.4;
+  } else if (estimatedBlocks < 2e3) {
+    maxDepth = 5;
+    maxContextBudget = 12e3;
+    minCohesion = 0.6;
+    maxFragmentation = 0.5;
+  } else {
+    maxDepth = 6;
+    maxContextBudget = 2e4;
+    minCohesion = 0.55;
+    maxFragmentation = 0.6;
+  }
+  return {
+    maxDepth,
+    maxContextBudget,
+    minCohesion,
+    maxFragmentation,
+    focus: "all",
+    includeNodeModules: false,
+    rootDir: userOptions.rootDir || directory,
+    include: userOptions.include,
+    exclude: userOptions.exclude
+  };
+}
+async function analyzeContext(options) {
+  const {
+    maxDepth = 5,
+    maxContextBudget = 1e4,
+    minCohesion = 0.6,
+    maxFragmentation = 0.5,
+    focus = "all",
+    includeNodeModules = false,
+    ...scanOptions
+  } = options;
+  const files = await scanFiles({
+    ...scanOptions,
+    exclude: includeNodeModules ? scanOptions.exclude : [...scanOptions.exclude || [], "**/node_modules/**"]
+  });
+  const fileContents = await Promise.all(
+    files.map(async (file) => ({
+      file,
+      content: await readFileContent(file)
+    }))
+  );
+  const graph = buildDependencyGraph(fileContents);
+  const circularDeps = detectCircularDependencies(graph);
+  const clusters = detectModuleClusters(graph);
+  const fragmentationMap = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const file of cluster.files) {
+      fragmentationMap.set(file, cluster.fragmentationScore);
+    }
+  }
+  const results = [];
+  for (const { file } of fileContents) {
+    const node = graph.nodes.get(file);
+    if (!node) continue;
+    const importDepth = focus === "depth" || focus === "all" ? calculateImportDepth(file, graph) : 0;
+    const dependencyList = focus === "depth" || focus === "all" ? getTransitiveDependencies(file, graph) : [];
+    const contextBudget = focus === "all" ? calculateContextBudget(file, graph) : node.tokenCost;
+    const cohesionScore = focus === "cohesion" || focus === "all" ? calculateCohesion(node.exports) : 1;
+    const fragmentationScore = fragmentationMap.get(file) || 0;
+    const relatedFiles = [];
+    for (const cluster of clusters) {
+      if (cluster.files.includes(file)) {
+        relatedFiles.push(...cluster.files.filter((f) => f !== file));
+        break;
+      }
+    }
+    const { severity, issues, recommendations, potentialSavings } = analyzeIssues({
+      file,
+      importDepth,
+      contextBudget,
+      cohesionScore,
+      fragmentationScore,
+      maxDepth,
+      maxContextBudget,
+      minCohesion,
+      maxFragmentation,
+      circularDeps
+    });
+    const domains = [
+      ...new Set(node.exports.map((e) => e.inferredDomain || "unknown"))
+    ];
+    results.push({
+      file,
+      tokenCost: node.tokenCost,
+      linesOfCode: node.linesOfCode,
+      importDepth,
+      dependencyCount: dependencyList.length,
+      dependencyList,
+      circularDeps: circularDeps.filter((cycle) => cycle.includes(file)),
+      cohesionScore,
+      domains,
+      exportCount: node.exports.length,
+      contextBudget,
+      fragmentationScore,
+      relatedFiles,
+      severity,
+      issues,
+      recommendations,
+      potentialSavings
+    });
+  }
+  return results.sort((a, b) => {
+    const severityOrder = { critical: 0, major: 1, minor: 2, info: 3 };
+    const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
+    if (severityDiff !== 0) return severityDiff;
+    return b.contextBudget - a.contextBudget;
+  });
+}
+function generateSummary(results) {
+  if (results.length === 0) {
+    return {
+      totalFiles: 0,
+      totalTokens: 0,
+      avgContextBudget: 0,
+      maxContextBudget: 0,
+      avgImportDepth: 0,
+      maxImportDepth: 0,
+      deepFiles: [],
+      avgFragmentation: 0,
+      fragmentedModules: [],
+      avgCohesion: 0,
+      lowCohesionFiles: [],
+      criticalIssues: 0,
+      majorIssues: 0,
+      minorIssues: 0,
+      totalPotentialSavings: 0,
+      topExpensiveFiles: []
+    };
+  }
+  const totalFiles = results.length;
+  const totalTokens = results.reduce((sum, r) => sum + r.tokenCost, 0);
+  const totalContextBudget = results.reduce(
+    (sum, r) => sum + r.contextBudget,
+    0
+  );
+  const avgContextBudget = totalContextBudget / totalFiles;
+  const maxContextBudget = Math.max(...results.map((r) => r.contextBudget));
+  const avgImportDepth = results.reduce((sum, r) => sum + r.importDepth, 0) / totalFiles;
+  const maxImportDepth = Math.max(...results.map((r) => r.importDepth));
+  const deepFiles = results.filter((r) => r.importDepth >= 5).map((r) => ({ file: r.file, depth: r.importDepth })).sort((a, b) => b.depth - a.depth).slice(0, 10);
+  const avgFragmentation = results.reduce((sum, r) => sum + r.fragmentationScore, 0) / totalFiles;
+  const moduleMap = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    for (const domain of result.domains) {
+      if (!moduleMap.has(domain)) {
+        moduleMap.set(domain, []);
+      }
+      moduleMap.get(domain).push(result);
+    }
+  }
+  const fragmentedModules = [];
+  for (const [domain, files] of moduleMap.entries()) {
+    if (files.length < 2) continue;
+    const fragmentationScore = files.reduce((sum, f) => sum + f.fragmentationScore, 0) / files.length;
+    if (fragmentationScore < 0.3) continue;
+    const totalTokens2 = files.reduce((sum, f) => sum + f.tokenCost, 0);
+    const avgCohesion2 = files.reduce((sum, f) => sum + f.cohesionScore, 0) / files.length;
+    const targetFiles = Math.max(1, Math.ceil(files.length / 3));
+    fragmentedModules.push({
+      domain,
+      files: files.map((f) => f.file),
+      totalTokens: totalTokens2,
+      fragmentationScore,
+      avgCohesion: avgCohesion2,
+      suggestedStructure: {
+        targetFiles,
+        consolidationPlan: [
+          `Consolidate ${files.length} ${domain} files into ${targetFiles} cohesive file(s)`,
+          `Current token cost: ${totalTokens2.toLocaleString()}`,
+          `Estimated savings: ${Math.floor(totalTokens2 * 0.3).toLocaleString()} tokens (30%)`
+        ]
+      }
+    });
+  }
+  fragmentedModules.sort((a, b) => b.fragmentationScore - a.fragmentationScore);
+  const avgCohesion = results.reduce((sum, r) => sum + r.cohesionScore, 0) / totalFiles;
+  const lowCohesionFiles = results.filter((r) => r.cohesionScore < 0.6).map((r) => ({ file: r.file, score: r.cohesionScore })).sort((a, b) => a.score - b.score).slice(0, 10);
+  const criticalIssues = results.filter((r) => r.severity === "critical").length;
+  const majorIssues = results.filter((r) => r.severity === "major").length;
+  const minorIssues = results.filter((r) => r.severity === "minor").length;
+  const totalPotentialSavings = results.reduce(
+    (sum, r) => sum + r.potentialSavings,
+    0
+  );
+  const topExpensiveFiles = results.sort((a, b) => b.contextBudget - a.contextBudget).slice(0, 10).map((r) => ({
+    file: r.file,
+    contextBudget: r.contextBudget,
+    severity: r.severity
+  }));
+  return {
+    totalFiles,
+    totalTokens,
+    avgContextBudget,
+    maxContextBudget,
+    avgImportDepth,
+    maxImportDepth,
+    deepFiles,
+    avgFragmentation,
+    fragmentedModules: fragmentedModules.slice(0, 10),
+    avgCohesion,
+    lowCohesionFiles,
+    criticalIssues,
+    majorIssues,
+    minorIssues,
+    totalPotentialSavings,
+    topExpensiveFiles
+  };
+}
+function analyzeIssues(params) {
+  const {
+    file,
+    importDepth,
+    contextBudget,
+    cohesionScore,
+    fragmentationScore,
+    maxDepth,
+    maxContextBudget,
+    minCohesion,
+    maxFragmentation,
+    circularDeps
+  } = params;
+  const issues = [];
+  const recommendations = [];
+  let severity = "info";
+  let potentialSavings = 0;
+  if (circularDeps.length > 0) {
+    severity = "critical";
+    issues.push(
+      `Part of ${circularDeps.length} circular dependency chain(s)`
+    );
+    recommendations.push("Break circular dependencies by extracting interfaces or using dependency injection");
+    potentialSavings += contextBudget * 0.2;
+  }
+  if (importDepth > maxDepth * 1.5) {
+    severity = severity === "critical" ? "critical" : "critical";
+    issues.push(`Import depth ${importDepth} exceeds limit by 50%`);
+    recommendations.push("Flatten dependency tree or use facade pattern");
+    potentialSavings += contextBudget * 0.3;
+  } else if (importDepth > maxDepth) {
+    severity = severity === "critical" ? "critical" : "major";
+    issues.push(`Import depth ${importDepth} exceeds recommended maximum ${maxDepth}`);
+    recommendations.push("Consider reducing dependency depth");
+    potentialSavings += contextBudget * 0.15;
+  }
+  if (contextBudget > maxContextBudget * 1.5) {
+    severity = severity === "critical" ? "critical" : "critical";
+    issues.push(`Context budget ${contextBudget.toLocaleString()} tokens is 50% over limit`);
+    recommendations.push("Split into smaller modules or reduce dependency tree");
+    potentialSavings += contextBudget * 0.4;
+  } else if (contextBudget > maxContextBudget) {
+    severity = severity === "critical" || severity === "major" ? severity : "major";
+    issues.push(`Context budget ${contextBudget.toLocaleString()} exceeds ${maxContextBudget.toLocaleString()}`);
+    recommendations.push("Reduce file size or dependencies");
+    potentialSavings += contextBudget * 0.2;
+  }
+  if (cohesionScore < minCohesion * 0.5) {
+    severity = severity === "critical" ? "critical" : "major";
+    issues.push(`Very low cohesion (${(cohesionScore * 100).toFixed(0)}%) - mixed concerns`);
+    recommendations.push("Split file by domain - separate unrelated functionality");
+    potentialSavings += contextBudget * 0.25;
+  } else if (cohesionScore < minCohesion) {
+    severity = severity === "critical" || severity === "major" ? severity : "minor";
+    issues.push(`Low cohesion (${(cohesionScore * 100).toFixed(0)}%)`);
+    recommendations.push("Consider grouping related exports together");
+    potentialSavings += contextBudget * 0.1;
+  }
+  if (fragmentationScore > maxFragmentation) {
+    severity = severity === "critical" || severity === "major" ? severity : "minor";
+    issues.push(`High fragmentation (${(fragmentationScore * 100).toFixed(0)}%) - scattered implementation`);
+    recommendations.push("Consolidate with related files in same domain");
+    potentialSavings += contextBudget * 0.3;
+  }
+  if (issues.length === 0) {
+    issues.push("No significant issues detected");
+    recommendations.push("File is well-structured for AI context usage");
+  }
+  if (isBuildArtifact(file)) {
+    issues.push("Detected build artifact (bundled/output file)");
+    recommendations.push("Exclude build outputs (e.g., cdk.out, dist, build, .next) from analysis");
+    severity = downgradeSeverity(severity);
+    potentialSavings = 0;
+  }
+  return { severity, issues, recommendations, potentialSavings: Math.floor(potentialSavings) };
+}
+function isBuildArtifact(filePath) {
+  const lower = filePath.toLowerCase();
+  return lower.includes("/node_modules/") || lower.includes("/dist/") || lower.includes("/build/") || lower.includes("/out/") || lower.includes("/output/") || lower.includes("/cdk.out/") || lower.includes("/.next/") || /\/asset\.[^/]+\//.test(lower);
+}
+function downgradeSeverity(s) {
+  switch (s) {
+    case "critical":
+      return "minor";
+    case "major":
+      return "minor";
+    case "minor":
+      return "info";
+    default:
+      return "info";
+  }
+}
+
+export {
+  getSmartDefaults,
+  analyzeContext,
+  generateSummary
+};

package/dist/cli.js

@@ -557,14 +557,37 @@ function analyzeIssues(params) {
     issues.push("No significant issues detected");
     recommendations.push("File is well-structured for AI context usage");
   }
+  if (isBuildArtifact(file)) {
+    issues.push("Detected build artifact (bundled/output file)");
+    recommendations.push("Exclude build outputs (e.g., cdk.out, dist, build, .next) from analysis");
+    severity = downgradeSeverity(severity);
+    potentialSavings = 0;
+  }
   return { severity, issues, recommendations, potentialSavings: Math.floor(potentialSavings) };
 }
+function isBuildArtifact(filePath) {
+  const lower = filePath.toLowerCase();
+  return lower.includes("/node_modules/") || lower.includes("/dist/") || lower.includes("/build/") || lower.includes("/out/") || lower.includes("/output/") || lower.includes("/cdk.out/") || lower.includes("/.next/") || /\/asset\.[^/]+\//.test(lower);
+}
+function downgradeSeverity(s) {
+  switch (s) {
+    case "critical":
+      return "minor";
+    case "major":
+      return "minor";
+    case "minor":
+      return "info";
+    default:
+      return "info";
+  }
+}
 
 // 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_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(
   "--max-context <number>",
@@ -579,7 +602,7 @@ program.name("aiready-context").description("Analyze AI context window cost and
   "-o, --output <format>",
   "Output format: console, json, html",
   "console"
-).option("--output-file <path>", "Output file path (for json/html)").action(async (directory, options) => {
+).option("--output-file <path>", "Output file path (for json/html)").option("--interactive", "Run interactive setup to suggest excludes and focus areas").action(async (directory, options) => {
   console.log(import_chalk.default.blue("\u{1F50D} Analyzing context window costs...\n"));
   const startTime = Date.now();
   try {
@@ -594,7 +617,7 @@ program.name("aiready-context").description("Analyze AI context window cost and
       exclude: void 0,
       maxResults: 10
     };
-    const finalOptions = (0, import_core3.loadMergedConfig)(directory, defaults, {
+    let finalOptions = (0, import_core3.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,
@@ -605,6 +628,9 @@ program.name("aiready-context").description("Analyze AI context window cost and
       exclude: options.exclude?.split(","),
       maxResults: options.maxResults ? parseInt(options.maxResults) : void 0
     });
+    if (options.interactive) {
+      finalOptions = await runInteractiveSetup(directory, finalOptions);
+    }
     const results = await analyzeContext(finalOptions);
     const elapsedTime = (0, import_core3.getElapsedTime)(startTime);
     const summary = generateSummary(results);
@@ -939,3 +965,55 @@ function generateHTMLReport(summary, results) {
 </body>
 </html>`;
 }
+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");
+  let deps = {};
+  if ((0, import_fs.existsSync)(pkgPath)) {
+    try {
+      const pkg = JSON.parse((0, import_fs.readFileSync)(pkgPath, "utf-8"));
+      deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+    } 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 recommendedExcludes = new Set(current.exclude || []);
+  if (hasNextJs && !Array.from(recommendedExcludes).some((p) => p.includes(".next"))) {
+    recommendedExcludes.add("**/.next/**");
+  }
+  if (hasCDK && !Array.from(recommendedExcludes).some((p) => p.includes("cdk.out"))) {
+    recommendedExcludes.add("**/cdk.out/**");
+  }
+  const { applyExcludes } = await (0, import_prompts.default)({
+    type: "toggle",
+    name: "applyExcludes",
+    message: `Detected ${hasNextJs ? "Next.js " : ""}${hasCDK ? "AWS CDK " : ""}frameworks. Apply recommended excludes?`,
+    initial: true,
+    active: "yes",
+    inactive: "no"
+  });
+  let nextOptions = { ...current };
+  if (applyExcludes) {
+    nextOptions.exclude = Array.from(recommendedExcludes);
+  }
+  const { focusArea } = await (0, import_prompts.default)({
+    type: "select",
+    name: "focusArea",
+    message: "Which areas to focus?",
+    choices: [
+      { title: "Frontend (web app)", value: "frontend" },
+      { title: "Backend (API/infra)", value: "backend" },
+      { title: "Both", value: "both" }
+    ],
+    initial: 2
+  });
+  if (focusArea === "frontend") {
+    nextOptions.include = ["**/*.{ts,tsx,js,jsx}"];
+    nextOptions.exclude = Array.from(/* @__PURE__ */ new Set([...nextOptions.exclude || [], "**/cdk.out/**", "**/infra/**", "**/server/**", "**/backend/**"]));
+  } else if (focusArea === "backend") {
+    nextOptions.include = ["**/api/**", "**/server/**", "**/backend/**", "**/infra/**", "**/*.{ts,js,py,java}"];
+  }
+  console.log(import_chalk.default.green("\u2713 Interactive configuration applied."));
+  return nextOptions;
+}

package/dist/cli.mjs

@@ -2,14 +2,15 @@
 import {
   analyzeContext,
   generateSummary
-} from "./chunk-5N5DCJOV.mjs";
+} from "./chunk-HDFXSEFW.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
 import chalk from "chalk";
-import { writeFileSync } from "fs";
+import { writeFileSync, existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { loadMergedConfig, handleJSONOutput, handleCLIError, getElapsedTime } from "@aiready/core";
+import prompts from "prompts";
 var program = new 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(
   "--max-context <number>",
@@ -24,7 +25,7 @@ program.name("aiready-context").description("Analyze AI context window cost and
   "-o, --output <format>",
   "Output format: console, json, html",
   "console"
-).option("--output-file <path>", "Output file path (for json/html)").action(async (directory, options) => {
+).option("--output-file <path>", "Output file path (for json/html)").option("--interactive", "Run interactive setup to suggest excludes and focus areas").action(async (directory, options) => {
   console.log(chalk.blue("\u{1F50D} Analyzing context window costs...\n"));
   const startTime = Date.now();
   try {
@@ -39,7 +40,7 @@ program.name("aiready-context").description("Analyze AI context window cost and
       exclude: void 0,
       maxResults: 10
     };
-    const finalOptions = loadMergedConfig(directory, defaults, {
+    let finalOptions = 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,
@@ -50,6 +51,9 @@ program.name("aiready-context").description("Analyze AI context window cost and
       exclude: options.exclude?.split(","),
       maxResults: options.maxResults ? parseInt(options.maxResults) : void 0
     });
+    if (options.interactive) {
+      finalOptions = await runInteractiveSetup(directory, finalOptions);
+    }
     const results = await analyzeContext(finalOptions);
     const elapsedTime = getElapsedTime(startTime);
     const summary = generateSummary(results);
@@ -384,3 +388,55 @@ function generateHTMLReport(summary, results) {
 </body>
 </html>`;
 }
+async function runInteractiveSetup(directory, current) {
+  console.log(chalk.yellow("\u{1F9ED} Interactive mode: let\u2019s tailor the analysis."));
+  const pkgPath = join(directory, "package.json");
+  let deps = {};
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      deps = { ...pkg.dependencies || {}, ...pkg.devDependencies || {} };
+    } catch {
+    }
+  }
+  const hasNextJs = existsSync(join(directory, ".next")) || !!deps["next"];
+  const hasCDK = existsSync(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/**");
+  }
+  if (hasCDK && !Array.from(recommendedExcludes).some((p) => p.includes("cdk.out"))) {
+    recommendedExcludes.add("**/cdk.out/**");
+  }
+  const { applyExcludes } = await prompts({
+    type: "toggle",
+    name: "applyExcludes",
+    message: `Detected ${hasNextJs ? "Next.js " : ""}${hasCDK ? "AWS CDK " : ""}frameworks. Apply recommended excludes?`,
+    initial: true,
+    active: "yes",
+    inactive: "no"
+  });
+  let nextOptions = { ...current };
+  if (applyExcludes) {
+    nextOptions.exclude = Array.from(recommendedExcludes);
+  }
+  const { focusArea } = await prompts({
+    type: "select",
+    name: "focusArea",
+    message: "Which areas to focus?",
+    choices: [
+      { title: "Frontend (web app)", value: "frontend" },
+      { title: "Backend (API/infra)", value: "backend" },
+      { title: "Both", value: "both" }
+    ],
+    initial: 2
+  });
+  if (focusArea === "frontend") {
+    nextOptions.include = ["**/*.{ts,tsx,js,jsx}"];
+    nextOptions.exclude = Array.from(/* @__PURE__ */ new Set([...nextOptions.exclude || [], "**/cdk.out/**", "**/infra/**", "**/server/**", "**/backend/**"]));
+  } else if (focusArea === "backend") {
+    nextOptions.include = ["**/api/**", "**/server/**", "**/backend/**", "**/infra/**", "**/*.{ts,js,py,java}"];
+  }
+  console.log(chalk.green("\u2713 Interactive configuration applied."));
+  return nextOptions;
+}

package/dist/index.js

@@ -599,8 +599,30 @@ function analyzeIssues(params) {
     issues.push("No significant issues detected");
     recommendations.push("File is well-structured for AI context usage");
   }
+  if (isBuildArtifact(file)) {
+    issues.push("Detected build artifact (bundled/output file)");
+    recommendations.push("Exclude build outputs (e.g., cdk.out, dist, build, .next) from analysis");
+    severity = downgradeSeverity(severity);
+    potentialSavings = 0;
+  }
   return { severity, issues, recommendations, potentialSavings: Math.floor(potentialSavings) };
 }
+function isBuildArtifact(filePath) {
+  const lower = filePath.toLowerCase();
+  return lower.includes("/node_modules/") || lower.includes("/dist/") || lower.includes("/build/") || lower.includes("/out/") || lower.includes("/output/") || lower.includes("/cdk.out/") || lower.includes("/.next/") || /\/asset\.[^/]+\//.test(lower);
+}
+function downgradeSeverity(s) {
+  switch (s) {
+    case "critical":
+      return "minor";
+    case "major":
+      return "minor";
+    case "minor":
+      return "info";
+    default:
+      return "info";
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   analyzeContext,

package/dist/index.mjs

@@ -2,7 +2,7 @@ import {
   analyzeContext,
   generateSummary,
   getSmartDefaults
-} from "./chunk-5N5DCJOV.mjs";
+} from "./chunk-HDFXSEFW.mjs";
 export {
   analyzeContext,
   generateSummary,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/context-analyzer",
-  "version": "0.3.8",
+  "version": "0.4.1",
   "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,10 +49,12 @@
   "dependencies": {
     "commander": "^12.1.0",
     "chalk": "^5.3.0",
-    "@aiready/core": "0.3.7"
+    "prompts": "^2.4.2",
+    "@aiready/core": "0.5.1"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
+    "@types/prompts": "^2.4.9",
     "tsup": "^8.3.5",
     "typescript": "^5.7.3",
     "vitest": "^2.1.9",

package/src/cli.ts

@@ -3,9 +3,10 @@
 import { Command } from 'commander';
 import { analyzeContext, generateSummary } from './index';
 import chalk from 'chalk';
-import { writeFileSync } from 'fs';
+import { writeFileSync, existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { loadMergedConfig, handleJSONOutput, handleCLIError, getElapsedTime } from '@aiready/core';
+import prompts from 'prompts';
 
 const program = new Command();
 
@@ -39,6 +40,7 @@ program
     'console'
   )
   .option('--output-file <path>', 'Output file path (for json/html)')
+  .option('--interactive', 'Run interactive setup to suggest excludes and focus areas')
   .action(async (directory, options) => {
     console.log(chalk.blue('🔍 Analyzing context window costs...\n'));
 
@@ -59,7 +61,7 @@ program
       };
 
       // Load and merge config with CLI options
-      const finalOptions = loadMergedConfig(directory, defaults, {
+      let finalOptions = loadMergedConfig(directory, defaults, {
         maxDepth: options.maxDepth ? parseInt(options.maxDepth) : undefined,
         maxContextBudget: options.maxContext ? parseInt(options.maxContext) : undefined,
         minCohesion: options.minCohesion ? parseFloat(options.minCohesion) : undefined,
@@ -71,6 +73,11 @@ program
         maxResults: options.maxResults ? parseInt(options.maxResults) : undefined,
       }) as any;
 
+      // Optional: interactive setup to refine options for first-time users
+      if (options.interactive) {
+        finalOptions = await runInteractiveSetup(directory, finalOptions);
+      }
+
       const results = await analyzeContext(finalOptions);
 
       const elapsedTime = getElapsedTime(startTime);
@@ -455,3 +462,66 @@ function generateHTMLReport(
 </body>
 </html>`;
 }
+
+/**
+ * Interactive setup: detect common frameworks and suggest excludes & focus areas
+ */
+async function runInteractiveSetup(directory: string, current: any): Promise<any> {
+  console.log(chalk.yellow('🧭 Interactive mode: let’s tailor the analysis.'));
+
+  const pkgPath = join(directory, 'package.json');
+  let deps: Record<string, string> = {};
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    } catch {}
+  }
+
+  const hasNextJs = existsSync(join(directory, '.next')) || !!deps['next'];
+  const hasCDK = existsSync(join(directory, 'cdk.out')) || !!deps['aws-cdk-lib'] || Object.keys(deps).some(d => d.startsWith('@aws-cdk/'));
+
+  const recommendedExcludes = new Set<string>(current.exclude || []);
+  if (hasNextJs && !Array.from(recommendedExcludes).some((p) => p.includes('.next'))) {
+    recommendedExcludes.add('**/.next/**');
+  }
+  if (hasCDK && !Array.from(recommendedExcludes).some((p) => p.includes('cdk.out'))) {
+    recommendedExcludes.add('**/cdk.out/**');
+  }
+
+  const { applyExcludes } = await prompts({
+    type: 'toggle',
+    name: 'applyExcludes',
+    message: `Detected ${hasNextJs ? 'Next.js ' : ''}${hasCDK ? 'AWS CDK ' : ''}frameworks. Apply recommended excludes?`,
+    initial: true,
+    active: 'yes',
+    inactive: 'no',
+  });
+
+  let nextOptions = { ...current };
+  if (applyExcludes) {
+    nextOptions.exclude = Array.from(recommendedExcludes);
+  }
+
+  const { focusArea } = await prompts({
+    type: 'select',
+    name: 'focusArea',
+    message: 'Which areas to focus?',
+    choices: [
+      { title: 'Frontend (web app)', value: 'frontend' },
+      { title: 'Backend (API/infra)', value: 'backend' },
+      { title: 'Both', value: 'both' },
+    ],
+    initial: 2,
+  });
+
+  if (focusArea === 'frontend') {
+    nextOptions.include = ['**/*.{ts,tsx,js,jsx}'];
+    nextOptions.exclude = Array.from(new Set([...(nextOptions.exclude || []), '**/cdk.out/**', '**/infra/**', '**/server/**', '**/backend/**']));
+  } else if (focusArea === 'backend') {
+    nextOptions.include = ['**/api/**', '**/server/**', '**/backend/**', '**/infra/**', '**/*.{ts,js,py,java}'];
+  }
+
+  console.log(chalk.green('✓ Interactive configuration applied.'));
+  return nextOptions;
+}

package/src/index.ts

@@ -453,7 +453,46 @@ function analyzeIssues(params: {
     recommendations.push('File is well-structured for AI context usage');
   }
 
+  // Detect build artifacts and downgrade severity to reduce noise
+  if (isBuildArtifact(file)) {
+    issues.push('Detected build artifact (bundled/output file)');
+    recommendations.push('Exclude build outputs (e.g., cdk.out, dist, build, .next) from analysis');
+    severity = downgradeSeverity(severity);
+    // Build artifacts do not represent actionable savings
+    potentialSavings = 0;
+  }
+
   return { severity, issues, recommendations, potentialSavings: Math.floor(potentialSavings) };
 }
 
 export { getSmartDefaults };
+
+/**
+ * Heuristic: identify common build artifact paths
+ */
+function isBuildArtifact(filePath: string): boolean {
+  const lower = filePath.toLowerCase();
+  return (
+    lower.includes('/node_modules/') ||
+    lower.includes('/dist/') ||
+    lower.includes('/build/') ||
+    lower.includes('/out/') ||
+    lower.includes('/output/') ||
+    lower.includes('/cdk.out/') ||
+    lower.includes('/.next/') ||
+    /\/asset\.[^/]+\//.test(lower) // e.g., cdk.out/asset.*
+  );
+}
+
+function downgradeSeverity(s: ContextAnalysisResult['severity']): ContextAnalysisResult['severity'] {
+  switch (s) {
+    case 'critical':
+      return 'minor';
+    case 'major':
+      return 'minor';
+    case 'minor':
+      return 'info';
+    default:
+      return 'info';
+  }
+}