codemap-ai 3.1.0 → 3.2.0

package/dist/cli.js

@@ -2,12 +2,12 @@
 
 import {
   FlowStorage
-} from "./chunk-Q4IB4JZ6.js";
+} from "./chunk-LXZ73T7X.js";
 
 // src/cli-flow.ts
 import { Command } from "commander";
-import { resolve as resolve3, join as join3 } from "path";
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { resolve as resolve3, join as join4 } from "path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
 import { homedir } from "os";
 import chalk from "chalk";
 import ora from "ora";
@@ -1279,7 +1279,7 @@ var DEFAULT_CONFIG = {
 };
 
 // src/commands/impact.ts
-import { resolve as resolve2, join as join2 } from "path";
+import { resolve as resolve2, join as join3, relative as relative2 } from "path";
 
 // src/utils/git.ts
 import { execSync } from "child_process";
@@ -1381,10 +1381,279 @@ function getGitStatus(rootPath) {
   }
 }
 
+// src/analysis/imports.ts
+import { readFileSync as readFileSync2 } from "fs";
+function analyzeJavaScriptImports(filePath) {
+  const content = readFileSync2(filePath, "utf-8");
+  const lines = content.split("\n");
+  const imports = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const defaultMatch = line.match(/import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/);
+    if (defaultMatch) {
+      imports.set(defaultMatch[1], i + 1);
+    }
+    const namedMatch = line.match(/import\s+\{([^}]+)\}\s+from\s+['"]([^'"]+)['"]/);
+    if (namedMatch) {
+      const names = namedMatch[1].split(",").map((n) => n.trim().split(" as ")[0].trim());
+      names.forEach((name) => imports.set(name, i + 1));
+    }
+  }
+  const usedIdentifiers = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim().startsWith("import ") || line.trim().startsWith("//") || line.trim().startsWith("*")) {
+      continue;
+    }
+    for (const [identifier] of imports) {
+      const regex = new RegExp(`\\b${identifier}\\b`, "g");
+      if (regex.test(line)) {
+        if (!usedIdentifiers.has(identifier)) {
+          usedIdentifiers.set(identifier, []);
+        }
+        usedIdentifiers.get(identifier).push(i + 1);
+      }
+    }
+  }
+  const unused = [];
+  for (const [identifier, line] of imports) {
+    const usage = usedIdentifiers.get(identifier);
+    if (!usage || usage.length === 0) {
+      unused.push({ identifier, line, type: "unused" });
+    }
+  }
+  const missing = [];
+  const commonLibraries = ["express", "cors", "winston", "Redis", "MongoClient", "mongoose", "axios"];
+  for (const lib of commonLibraries) {
+    if (!imports.has(lib)) {
+      const usageLines = [];
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.includes(lib) && !line.trim().startsWith("//")) {
+          usageLines.push(i + 1);
+        }
+      }
+      if (usageLines.length > 0) {
+        missing.push({
+          identifier: lib,
+          line: usageLines[0],
+          type: "missing",
+          usedAt: usageLines
+        });
+      }
+    }
+  }
+  return { missing, unused };
+}
+function analyzePythonImports(filePath) {
+  const content = readFileSync2(filePath, "utf-8");
+  const lines = content.split("\n");
+  const imports = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const importMatch = line.match(/^import\s+(\w+)/);
+    if (importMatch) {
+      imports.set(importMatch[1], i + 1);
+    }
+    const fromMatch = line.match(/^from\s+[\w.]+\s+import\s+(.+)/);
+    if (fromMatch) {
+      const names = fromMatch[1].split(",").map((n) => n.trim().split(" as ")[0].trim());
+      names.forEach((name) => imports.set(name, i + 1));
+    }
+  }
+  const usedIdentifiers = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim().startsWith("import ") || line.trim().startsWith("from ") || line.trim().startsWith("#")) {
+      continue;
+    }
+    for (const [identifier] of imports) {
+      const regex = new RegExp(`\\b${identifier}\\b`, "g");
+      if (regex.test(line)) {
+        if (!usedIdentifiers.has(identifier)) {
+          usedIdentifiers.set(identifier, []);
+        }
+        usedIdentifiers.get(identifier).push(i + 1);
+      }
+    }
+  }
+  const unused = [];
+  for (const [identifier, line] of imports) {
+    const usage = usedIdentifiers.get(identifier);
+    if (!usage || usage.length === 0) {
+      unused.push({ identifier, line, type: "unused" });
+    }
+  }
+  return { missing: [], unused };
+}
+function analyzeImports(filePath) {
+  if (filePath.endsWith(".py")) {
+    return analyzePythonImports(filePath);
+  } else if (filePath.match(/\.(js|jsx|ts|tsx)$/)) {
+    return analyzeJavaScriptImports(filePath);
+  }
+  return { missing: [], unused: [] };
+}
+
+// src/analysis/docker.ts
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+import { load as parseYaml } from "js-yaml";
+import { join as join2 } from "path";
+function parseDockerfile(dockerfilePath) {
+  if (!existsSync2(dockerfilePath)) {
+    return null;
+  }
+  const content = readFileSync3(dockerfilePath, "utf-8");
+  const lines = content.split("\n");
+  let inHealthCheck = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (line.includes("HEALTHCHECK")) {
+      inHealthCheck = true;
+      continue;
+    }
+    if (inHealthCheck && !line.startsWith(" ") && !line.startsWith("	")) {
+      inHealthCheck = false;
+    }
+    if (inHealthCheck) {
+      continue;
+    }
+    if (trimmed.startsWith("CMD")) {
+      const match = trimmed.match(/CMD\s+\[([^\]]+)\]/);
+      if (match) {
+        const parts = match[1].split(",").map((p) => p.trim().replace(/"/g, ""));
+        const commandStr = parts.join(" ");
+        return extractEntryPointFromCommand(commandStr);
+      }
+      const shellMatch = trimmed.match(/CMD\s+(.+)/);
+      if (shellMatch) {
+        return extractEntryPointFromCommand(shellMatch[1]);
+      }
+    }
+    if (trimmed.startsWith("ENTRYPOINT")) {
+      const match = trimmed.match(/ENTRYPOINT\s+\[([^\]]+)\]/);
+      if (match) {
+        const parts = match[1].split(",").map((p) => p.trim().replace(/"/g, ""));
+        const commandStr = parts.join(" ");
+        return extractEntryPointFromCommand(commandStr);
+      }
+    }
+  }
+  return null;
+}
+function extractEntryPointFromCommand(command) {
+  const commandStr = Array.isArray(command) ? command.join(" ") : command;
+  const patterns = [
+    /node\s+([^\s]+\.js)/,
+    /python\s+-m\s+([\w.]+)/,
+    /python\s+([^\s]+\.py)/,
+    /uvicorn\s+([\w:]+)/,
+    /npm\s+start/
+  ];
+  for (const pattern of patterns) {
+    const match = commandStr.match(pattern);
+    if (match) {
+      const entryFile = match[1];
+      if (entryFile.endsWith(".js") || entryFile.endsWith(".py")) {
+        return entryFile;
+      } else if (entryFile.includes(":")) {
+        const file = entryFile.split(":")[0];
+        return `${file}.py`;
+      } else {
+        const file = entryFile.replace(/\./g, "/");
+        return `${file}.py`;
+      }
+    }
+  }
+  return null;
+}
+function parseDockerCompose(projectRoot) {
+  const graph = {
+    services: /* @__PURE__ */ new Map(),
+    entryPoints: /* @__PURE__ */ new Map()
+  };
+  const composeFiles = [
+    join2(projectRoot, "docker-compose.yaml"),
+    join2(projectRoot, "docker-compose.yml"),
+    join2(projectRoot, "compose.yaml"),
+    join2(projectRoot, "compose.yml")
+  ];
+  let composeData = null;
+  for (const file of composeFiles) {
+    if (existsSync2(file)) {
+      const content = readFileSync3(file, "utf-8");
+      composeData = parseYaml(content);
+      break;
+    }
+  }
+  if (!composeData || !composeData.services) {
+    return graph;
+  }
+  for (const [serviceName, serviceConfig] of Object.entries(composeData.services)) {
+    const config = serviceConfig;
+    const service = {
+      name: serviceName,
+      dependsOn: [],
+      volumes: [],
+      entryPoint: config.entrypoint,
+      command: config.command
+    };
+    if (config.depends_on) {
+      if (Array.isArray(config.depends_on)) {
+        service.dependsOn = config.depends_on;
+      } else if (typeof config.depends_on === "object") {
+        service.dependsOn = Object.keys(config.depends_on);
+      }
+    }
+    if (config.volumes && Array.isArray(config.volumes)) {
+      service.volumes = config.volumes.filter((v) => typeof v === "string").map((v) => v.split(":")[0]);
+    }
+    if (config.command) {
+      const entryFile = extractEntryPointFromCommand(config.command);
+      if (entryFile) {
+        graph.entryPoints.set(serviceName, entryFile);
+      }
+    }
+    if (!graph.entryPoints.has(serviceName) && config.build) {
+      const buildContext = typeof config.build === "string" ? config.build : config.build.context;
+      if (buildContext) {
+        const dockerfilePath = join2(projectRoot, buildContext, "Dockerfile");
+        const entryFile = parseDockerfile(dockerfilePath);
+        if (entryFile) {
+          graph.entryPoints.set(serviceName, entryFile);
+        }
+      }
+    }
+    graph.services.set(serviceName, service);
+  }
+  return graph;
+}
+function findDependentServices(graph, serviceName) {
+  const dependents = [];
+  for (const [name, service] of graph.services) {
+    if (service.dependsOn.includes(serviceName)) {
+      dependents.push(name);
+    }
+  }
+  return dependents;
+}
+function calculateServiceBlastRadius(graph, serviceName) {
+  const affected = /* @__PURE__ */ new Set();
+  const queue = [serviceName];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (affected.has(current)) continue;
+    affected.add(current);
+    const dependents = findDependentServices(graph, current);
+    queue.push(...dependents);
+  }
+  return Array.from(affected);
+}
+
 // src/commands/impact.ts
 async function analyzeImpact(options = {}) {
   const rootPath = resolve2(options.path || ".");
-  const dbPath = join2(rootPath, ".codemap", "graph.db");
+  const dbPath = join3(rootPath, ".codemap", "graph.db");
   const storage = new FlowStorage(dbPath);
   try {
     if (isGitRepository(rootPath)) {
@@ -1404,6 +1673,7 @@ async function analyzeImpactWithGit(storage, rootPath, options) {
       changedFunctions: [],
       directCallers: /* @__PURE__ */ new Map(),
       affectedEndpoints: [],
+      importIssues: /* @__PURE__ */ new Map(),
       riskLevel: "LOW",
       totalImpact: 0
     };
@@ -1421,7 +1691,7 @@ async function analyzeImpactWithGit(storage, rootPath, options) {
   const directCallers = /* @__PURE__ */ new Map();
   const affectedEndpoints = [];
   for (const func of changedFunctions) {
-    const nodes = storage.getNodesByFile(join2(rootPath, func.file)).filter((n) => n.name === func.functionName);
+    const nodes = storage.getNodesByFile(join3(rootPath, func.file)).filter((n) => n.name === func.functionName);
     for (const node of nodes) {
       const callers = storage.getResolvedCallersWithLocation(node.id);
       if (callers.length > 0) {
@@ -1433,11 +1703,44 @@ async function analyzeImpactWithGit(storage, rootPath, options) {
       }
     }
   }
+  const importIssues = /* @__PURE__ */ new Map();
+  for (const filePath of changedFilePaths) {
+    const fullPath = join3(rootPath, filePath);
+    const analysis = analyzeImports(fullPath);
+    if (analysis.missing.length > 0 || analysis.unused.length > 0) {
+      importIssues.set(relative2(rootPath, fullPath), analysis);
+    }
+  }
+  const dockerGraph = parseDockerCompose(rootPath);
+  let dockerImpact;
+  const entryPointFiles = [];
+  const affectedServices = /* @__PURE__ */ new Set();
+  for (const [serviceName, entryPoint] of dockerGraph.entryPoints) {
+    for (const changedFile of changedFilePaths) {
+      if (changedFile.includes(entryPoint) || entryPoint.includes(changedFile)) {
+        entryPointFiles.push(entryPoint);
+        const blastRadius = calculateServiceBlastRadius(dockerGraph, serviceName);
+        blastRadius.forEach((s) => affectedServices.add(s));
+      }
+    }
+  }
+  if (affectedServices.size > 0) {
+    dockerImpact = {
+      affectedServices: Array.from(affectedServices),
+      entryPointFiles
+    };
+  }
   const totalCallers = Array.from(directCallers.values()).reduce((sum, callers) => sum + callers.length, 0);
+  const hasCriticalImportIssues = Array.from(importIssues.values()).some((i) => i.missing.length > 0);
+  const hasDockerImpact = dockerImpact && dockerImpact.affectedServices.length > 0;
   let riskLevel = "LOW";
-  if (totalCallers > 20 || affectedEndpoints.length > 5) {
+  if (hasCriticalImportIssues && hasDockerImpact) {
+    riskLevel = "CRITICAL";
+  } else if (hasCriticalImportIssues || hasDockerImpact && dockerImpact.affectedServices.length > 2) {
+    riskLevel = "HIGH";
+  } else if (totalCallers > 20 || affectedEndpoints.length > 5) {
     riskLevel = "HIGH";
-  } else if (totalCallers > 10 || affectedEndpoints.length > 2) {
+  } else if (totalCallers > 10 || affectedEndpoints.length > 2 || hasDockerImpact) {
     riskLevel = "MEDIUM";
   }
   return {
@@ -1445,8 +1748,10 @@ async function analyzeImpactWithGit(storage, rootPath, options) {
     changedFunctions,
     directCallers,
     affectedEndpoints,
+    importIssues,
+    dockerImpact,
     riskLevel,
-    totalImpact: totalCallers
+    totalImpact: totalCallers + (dockerImpact?.affectedServices.length || 0)
   };
 }
 async function analyzeImpactWithHash(storage, rootPath, options) {
@@ -1467,12 +1772,21 @@ async function analyzeImpactWithHash(storage, rootPath, options) {
       changedFiles.push(filePath);
     }
   }
+  const importIssues = /* @__PURE__ */ new Map();
+  for (const filePath of changedFiles) {
+    const analysis = analyzeImports(filePath);
+    if (analysis.missing.length > 0 || analysis.unused.length > 0) {
+      importIssues.set(relative2(rootPath, filePath), analysis);
+    }
+  }
+  const hasCriticalImportIssues = Array.from(importIssues.values()).some((i) => i.missing.length > 0);
   return {
     changedFiles,
     changedFunctions: [],
     directCallers: /* @__PURE__ */ new Map(),
     affectedEndpoints: [],
-    riskLevel: changedFiles.length > 10 ? "HIGH" : changedFiles.length > 5 ? "MEDIUM" : "LOW",
+    importIssues,
+    riskLevel: hasCriticalImportIssues ? "CRITICAL" : changedFiles.length > 10 ? "HIGH" : changedFiles.length > 5 ? "MEDIUM" : "LOW",
     totalImpact: result.indexed
   };
 }
@@ -1481,11 +1795,11 @@ async function analyzeImpactWithHash(storage, rootPath, options) {
 var program = new Command();
 function configureMCPServer(projectPath) {
   try {
-    const claudeConfigPath = join3(homedir(), ".claude", "config.json");
-    if (!existsSync2(claudeConfigPath)) {
+    const claudeConfigPath = join4(homedir(), ".claude", "config.json");
+    if (!existsSync3(claudeConfigPath)) {
       return false;
     }
-    const config = JSON.parse(readFileSync2(claudeConfigPath, "utf-8"));
+    const config = JSON.parse(readFileSync4(claudeConfigPath, "utf-8"));
     if (!config.mcpServers) {
       config.mcpServers = {};
     }
@@ -1499,17 +1813,17 @@ function configureMCPServer(projectPath) {
     return false;
   }
 }
-program.name("codemap").description("CodeMap Flow - Call graph analyzer for understanding code impact").version("3.1.0");
+program.name("codemap").description("CodeMap Flow - Call graph analyzer for understanding code impact").version("3.2.0");
 program.command("index").description("Build call graph for your codebase").argument("[path]", "Path to the project root", ".").option("-f, --force", "Force reindex all files (ignore cache)").option("--include <patterns...>", "Glob patterns to include").option("--exclude <patterns...>", "Glob patterns to exclude").action(async (path, options) => {
   const rootPath = resolve3(path);
-  const outputDir = join3(rootPath, ".codemap");
+  const outputDir = join4(rootPath, ".codemap");
   console.log(chalk.blue.bold("\n  CodeMap Call Graph Indexer\n"));
   console.log(chalk.gray(`  Project: ${rootPath}
 `));
-  if (!existsSync2(outputDir)) {
+  if (!existsSync3(outputDir)) {
     mkdirSync(outputDir, { recursive: true });
   }
-  const dbPath = join3(outputDir, "graph.db");
+  const dbPath = join4(outputDir, "graph.db");
   const storage = new FlowStorage(dbPath);
   const builder = new FlowBuilder(storage, {
     rootPath,
@@ -1580,18 +1894,18 @@ program.command("index").description("Build call graph for your codebase").argum
 });
 program.command("init").description("Initialize CodeMap (index + setup MCP)").argument("[path]", "Path to the project root", ".").option("--include <patterns...>", "Glob patterns to include").option("--exclude <patterns...>", "Glob patterns to exclude").option("--skip-mcp", "Skip MCP server configuration").action(async (path, options) => {
   const rootPath = resolve3(path);
-  const outputDir = join3(rootPath, ".codemap");
+  const outputDir = join4(rootPath, ".codemap");
   console.log(chalk.blue.bold("\n  CodeMap Initialization\n"));
   console.log(chalk.gray(`  Project: ${rootPath}
 `));
-  if (existsSync2(join3(outputDir, "graph.db")) && !options.force) {
+  if (existsSync3(join4(outputDir, "graph.db")) && !options.force) {
     console.log(chalk.yellow("  Already initialized. Use 'codemap reindex' to rebuild.\n"));
     return;
   }
-  if (!existsSync2(outputDir)) {
+  if (!existsSync3(outputDir)) {
     mkdirSync(outputDir, { recursive: true });
   }
-  const dbPath = join3(outputDir, "graph.db");
+  const dbPath = join4(outputDir, "graph.db");
   const storage = new FlowStorage(dbPath);
   const builder = new FlowBuilder(storage, {
     rootPath,
@@ -1653,9 +1967,9 @@ program.command("init").description("Initialize CodeMap (index + setup MCP)").ar
 });
 program.command("impact").description("Analyze impact of code changes").argument("[path]", "Path to the project root", ".").option("-v, --verbose", "Show detailed output").action(async (path, options) => {
   const rootPath = resolve3(path);
-  const dbPath = join3(rootPath, ".codemap", "graph.db");
+  const dbPath = join4(rootPath, ".codemap", "graph.db");
   console.log(chalk.blue.bold("\n  CodeMap Impact Analysis\n"));
-  if (!existsSync2(dbPath)) {
+  if (!existsSync3(dbPath)) {
     console.log(chalk.red("  Error: Not initialized. Run 'codemap init' first.\n"));
     process.exit(1);
   }
@@ -1702,9 +2016,50 @@ program.command("impact").description("Analyze impact of code changes").argument
         console.log(chalk.gray(`    \u2022 ${endpoint}`));
       }
     }
+    if (result.importIssues.size > 0) {
+      console.log(chalk.blue("\n  \u{1F50D} Import Analysis:\n"));
+      for (const [file, issues] of result.importIssues.entries()) {
+        if (issues.missing.length > 0) {
+          console.log(chalk.red(`    \u274C CRITICAL: ${file} - Missing imports still in use:`));
+          for (const missing of issues.missing.slice(0, 5)) {
+            const usageInfo = missing.usedAt ? ` (used at lines: ${missing.usedAt.slice(0, 3).join(", ")}${missing.usedAt.length > 3 ? "..." : ""})` : "";
+            console.log(chalk.gray(`       \u2022 ${missing.identifier}${usageInfo}`));
+          }
+          if (issues.missing.length > 5) {
+            console.log(chalk.gray(`       ... and ${issues.missing.length - 5} more`));
+          }
+        }
+        if (issues.unused.length > 0 && options.verbose) {
+          console.log(chalk.yellow(`    \u26A0\uFE0F  ${file} - Unused imports:`));
+          for (const unused of issues.unused.slice(0, 3)) {
+            console.log(chalk.gray(`       \u2022 ${unused.identifier} (line ${unused.line})`));
+          }
+        }
+      }
+    }
+    if (result.dockerImpact) {
+      console.log(chalk.blue("\n  \u{1F4E6} Docker Service Impact:\n"));
+      console.log(chalk.red(`    \u26A0\uFE0F  Entry point file(s) modified - service(s) will not start:`));
+      for (const file of result.dockerImpact.entryPointFiles) {
+        console.log(chalk.gray(`       \u2022 ${file}`));
+      }
+      console.log(chalk.red(`
+    \u{1F4A5} Affected Services (${result.dockerImpact.affectedServices.length}):`));
+      for (const service of result.dockerImpact.affectedServices) {
+        console.log(chalk.gray(`       \u2022 ${service}`));
+      }
+      console.log(chalk.yellow(`
+    \u2192 If entry point crashes, these services WILL FAIL`));
+    }
     console.log(chalk.blue("\n  Risk Assessment:\n"));
-    const riskColor = result.riskLevel === "HIGH" ? chalk.red : result.riskLevel === "MEDIUM" ? chalk.yellow : chalk.green;
-    console.log(`    ${riskColor(result.riskLevel)} - ${result.totalImpact} functions affected`);
+    const riskColor = result.riskLevel === "CRITICAL" ? chalk.red.bold : result.riskLevel === "HIGH" ? chalk.red : result.riskLevel === "MEDIUM" ? chalk.yellow : chalk.green;
+    console.log(`    ${riskColor(result.riskLevel)} - ${result.totalImpact} components affected`);
+    if (result.riskLevel === "CRITICAL") {
+      console.log(chalk.red.bold("\n    \u26A0\uFE0F  DO NOT DEPLOY - System-wide failure risk"));
+      console.log(chalk.gray("       Fix critical issues before proceeding"));
+    } else if (result.riskLevel === "HIGH") {
+      console.log(chalk.yellow("\n    \u26A0\uFE0F  High risk - Extensive testing required"));
+    }
     console.log();
   } catch (error) {
     spinner.fail(chalk.red("Impact analysis failed"));
@@ -1720,8 +2075,8 @@ program.command("reindex").description("Force full re-index of codebase").argume
 });
 program.command("mcp-server").description("Start MCP server for Claude Code integration").option("-p, --path <path>", "Project root path", ".").action(async (options) => {
   process.env.CODEMAP_PROJECT_ROOT = resolve3(options.path);
-  process.env.CODEMAP_DB_PATH = join3(resolve3(options.path), ".codemap", "graph.db");
-  await import("./flow-server-4LJZBCB4.js");
+  process.env.CODEMAP_DB_PATH = join4(resolve3(options.path), ".codemap", "graph.db");
+  await import("./flow-server-UQEOUP2C.js");
 });
 program.parse();
 //# sourceMappingURL=cli.js.map