codemap-ai 3.0.0 → 3.1.1

package/dist/cli.js

@@ -2,12 +2,13 @@
 
 import {
   FlowStorage
-} from "./chunk-XNA2HNUR.js";
+} from "./chunk-LXZ73T7X.js";
 
 // src/cli-flow.ts
 import { Command } from "commander";
-import { resolve as resolve2, join } from "path";
-import { existsSync, mkdirSync } from "fs";
+import { resolve as resolve3, join as join3 } from "path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir } from "os";
 import chalk from "chalk";
 import ora from "ora";
 
@@ -1277,19 +1278,238 @@ var DEFAULT_CONFIG = {
   languages: ["typescript", "javascript", "python"]
 };
 
+// src/commands/impact.ts
+import { resolve as resolve2, join as join2 } from "path";
+
+// src/utils/git.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+function isGitRepository(path) {
+  return existsSync(join(path, ".git"));
+}
+function getGitChangedFiles(rootPath) {
+  try {
+    const output = execSync("git diff HEAD --name-status", {
+      cwd: rootPath,
+      encoding: "utf-8"
+    }).trim();
+    if (!output) {
+      return [];
+    }
+    const files = [];
+    for (const line of output.split("\n")) {
+      const [status, path] = line.split("	");
+      if (path) {
+        files.push({
+          path,
+          status: status === "A" ? "added" : status === "D" ? "deleted" : "modified"
+        });
+      }
+    }
+    return files;
+  } catch (error) {
+    return [];
+  }
+}
+function parseGitDiffForFunctions(rootPath, files) {
+  const changedFunctions = [];
+  for (const file of files) {
+    if (file.status === "deleted") {
+      continue;
+    }
+    try {
+      const diff = execSync(`git diff HEAD -- "${file.path}"`, {
+        cwd: rootPath,
+        encoding: "utf-8"
+      });
+      const lines = diff.split("\n");
+      let currentFunction = null;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith("@@")) {
+          const contextMatch = line.match(/@@.*@@\s*(.*)/);
+          if (contextMatch) {
+            const context = contextMatch[1];
+            const pythonMatch = context.match(/(?:async\s+)?def\s+(\w+)/);
+            if (pythonMatch) {
+              currentFunction = pythonMatch[1];
+            }
+            const jsMatch = context.match(/(?:function|const|class)\s+(\w+)/);
+            if (jsMatch) {
+              currentFunction = jsMatch[1];
+            }
+            const lineMatch = line.match(/\+(\d+)/);
+            const lineNumber = lineMatch ? parseInt(lineMatch[1]) : 0;
+            if (currentFunction) {
+              changedFunctions.push({
+                file: file.path,
+                functionName: currentFunction,
+                lineNumber,
+                changeType: file.status === "added" ? "added" : "modified"
+              });
+            }
+          }
+        }
+      }
+    } catch (error) {
+      continue;
+    }
+  }
+  return changedFunctions;
+}
+function getGitStatus(rootPath) {
+  try {
+    const statusOutput = execSync("git status --porcelain", {
+      cwd: rootPath,
+      encoding: "utf-8"
+    }).trim();
+    const lines = statusOutput.split("\n").filter((l) => l.trim());
+    const staged = lines.filter((l) => l[0] !== " " && l[0] !== "?").length;
+    const modified = lines.length;
+    return {
+      hasChanges: modified > 0,
+      modifiedFiles: modified,
+      stagedFiles: staged
+    };
+  } catch (error) {
+    return {
+      hasChanges: false,
+      modifiedFiles: 0,
+      stagedFiles: 0
+    };
+  }
+}
+
+// src/commands/impact.ts
+async function analyzeImpact(options = {}) {
+  const rootPath = resolve2(options.path || ".");
+  const dbPath = join2(rootPath, ".codemap", "graph.db");
+  const storage = new FlowStorage(dbPath);
+  try {
+    if (isGitRepository(rootPath)) {
+      return await analyzeImpactWithGit(storage, rootPath, options);
+    } else {
+      return await analyzeImpactWithHash(storage, rootPath, options);
+    }
+  } finally {
+    storage.close();
+  }
+}
+async function analyzeImpactWithGit(storage, rootPath, options) {
+  const gitStatus = getGitStatus(rootPath);
+  if (!gitStatus.hasChanges) {
+    return {
+      changedFiles: [],
+      changedFunctions: [],
+      directCallers: /* @__PURE__ */ new Map(),
+      affectedEndpoints: [],
+      riskLevel: "LOW",
+      totalImpact: 0
+    };
+  }
+  const changedFiles = getGitChangedFiles(rootPath);
+  const changedFilePaths = changedFiles.map((f) => f.path);
+  const changedFunctions = parseGitDiffForFunctions(rootPath, changedFiles);
+  const builder = new FlowBuilder(storage, {
+    rootPath,
+    include: changedFilePaths.map((f) => f),
+    exclude: [],
+    forceReindex: true
+  });
+  await builder.build();
+  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);
+    for (const node of nodes) {
+      const callers = storage.getResolvedCallersWithLocation(node.id);
+      if (callers.length > 0) {
+        directCallers.set(func.functionName, callers);
+      }
+      const endpoints = storage.getHttpEndpointsByHandler(node.id);
+      for (const endpoint of endpoints) {
+        affectedEndpoints.push(`${endpoint.method} ${endpoint.path}`);
+      }
+    }
+  }
+  const totalCallers = Array.from(directCallers.values()).reduce((sum, callers) => sum + callers.length, 0);
+  let riskLevel = "LOW";
+  if (totalCallers > 20 || affectedEndpoints.length > 5) {
+    riskLevel = "HIGH";
+  } else if (totalCallers > 10 || affectedEndpoints.length > 2) {
+    riskLevel = "MEDIUM";
+  }
+  return {
+    changedFiles: changedFilePaths,
+    changedFunctions,
+    directCallers,
+    affectedEndpoints,
+    riskLevel,
+    totalImpact: totalCallers
+  };
+}
+async function analyzeImpactWithHash(storage, rootPath, options) {
+  const oldHashes = storage.getAllFileHashes();
+  const builder = new FlowBuilder(storage, {
+    rootPath,
+    include: DEFAULT_CONFIG.include,
+    exclude: DEFAULT_CONFIG.exclude,
+    forceReindex: false
+    // Use hash comparison
+  });
+  const result = await builder.build();
+  const changedFiles = [];
+  const newHashes = storage.getAllFileHashes();
+  for (const [filePath, newHash] of Object.entries(newHashes)) {
+    const oldHash = oldHashes[filePath];
+    if (!oldHash || oldHash !== newHash) {
+      changedFiles.push(filePath);
+    }
+  }
+  return {
+    changedFiles,
+    changedFunctions: [],
+    directCallers: /* @__PURE__ */ new Map(),
+    affectedEndpoints: [],
+    riskLevel: changedFiles.length > 10 ? "HIGH" : changedFiles.length > 5 ? "MEDIUM" : "LOW",
+    totalImpact: result.indexed
+  };
+}
+
 // src/cli-flow.ts
 var program = new Command();
-program.name("codemap").description("CodeMap Flow - Call graph analyzer for understanding code impact").version("3.0.0");
+function configureMCPServer(projectPath) {
+  try {
+    const claudeConfigPath = join3(homedir(), ".claude", "config.json");
+    if (!existsSync2(claudeConfigPath)) {
+      return false;
+    }
+    const config = JSON.parse(readFileSync2(claudeConfigPath, "utf-8"));
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+    config.mcpServers.codemap = {
+      command: "npx",
+      args: ["codemap-ai", "mcp-server", "--path", projectPath]
+    };
+    writeFileSync(claudeConfigPath, JSON.stringify(config, null, 2));
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+program.name("codemap").description("CodeMap Flow - Call graph analyzer for understanding code impact").version("3.1.1");
 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 = resolve2(path);
-  const outputDir = join(rootPath, ".codemap");
+  const rootPath = resolve3(path);
+  const outputDir = join3(rootPath, ".codemap");
   console.log(chalk.blue.bold("\n  CodeMap Call Graph Indexer\n"));
   console.log(chalk.gray(`  Project: ${rootPath}
 `));
-  if (!existsSync(outputDir)) {
+  if (!existsSync2(outputDir)) {
     mkdirSync(outputDir, { recursive: true });
   }
-  const dbPath = join(outputDir, "graph.db");
+  const dbPath = join3(outputDir, "graph.db");
   const storage = new FlowStorage(dbPath);
   const builder = new FlowBuilder(storage, {
     rootPath,
@@ -1358,10 +1578,150 @@ program.command("index").description("Build call graph for your codebase").argum
     storage.close();
   }
 });
+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");
+  console.log(chalk.blue.bold("\n  CodeMap Initialization\n"));
+  console.log(chalk.gray(`  Project: ${rootPath}
+`));
+  if (existsSync2(join3(outputDir, "graph.db")) && !options.force) {
+    console.log(chalk.yellow("  Already initialized. Use 'codemap reindex' to rebuild.\n"));
+    return;
+  }
+  if (!existsSync2(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  const dbPath = join3(outputDir, "graph.db");
+  const storage = new FlowStorage(dbPath);
+  const builder = new FlowBuilder(storage, {
+    rootPath,
+    include: options.include || DEFAULT_CONFIG.include,
+    exclude: options.exclude || DEFAULT_CONFIG.exclude,
+    forceReindex: true
+  });
+  const spinner = ora("Indexing codebase...").start();
+  builder.setProgressCallback((progress) => {
+    switch (progress.phase) {
+      case "discovering":
+        spinner.text = "Discovering files...";
+        break;
+      case "parsing":
+        spinner.text = `Parsing (${progress.current}/${progress.total}): ${progress.currentFile}`;
+        break;
+      case "resolving":
+        spinner.text = "Resolving cross-file calls...";
+        break;
+      case "complete":
+        spinner.succeed(chalk.green("Indexing complete!"));
+        break;
+    }
+  });
+  try {
+    const result = await builder.build();
+    console.log(chalk.blue("\n  Results:\n"));
+    console.log(`  ${chalk.bold("Indexed:")}    ${result.indexed} files`);
+    console.log(`  ${chalk.bold("Resolved:")}   ${result.resolved} function calls`);
+    const stats = storage.getStats();
+    if (stats.httpEndpoints > 0) {
+      console.log(chalk.cyan(`
+  ${chalk.bold("Framework Detection:")}`));
+      console.log(`  ${chalk.bold("HTTP Endpoints:")} ${stats.httpEndpoints} routes`);
+    }
+    const resolveRate = result.resolved + result.unresolved > 0 ? Math.round(result.resolved / (result.resolved + result.unresolved) * 100) : 0;
+    console.log(chalk.gray(`
+  Call resolution: ${resolveRate}%`));
+    console.log(chalk.gray(`  Database: ${dbPath}
+`));
+    if (!options.skipMcp) {
+      const mcpConfigured = configureMCPServer(rootPath);
+      if (mcpConfigured) {
+        console.log(chalk.green("  \u2713 MCP server configured in Claude Code\n"));
+      } else {
+        console.log(chalk.yellow("  \u26A0 Could not auto-configure MCP (Claude Code not found)"));
+        console.log(chalk.gray("    Run manually: claude mcp add codemap -- npx codemap-ai mcp-server\n"));
+      }
+    }
+    console.log(chalk.cyan("  Ready!"));
+    console.log(chalk.gray("    Ask Claude: 'What would break if I change authenticate_user?'\n"));
+  } catch (error) {
+    spinner.fail(chalk.red("Initialization failed"));
+    console.error(error);
+    process.exit(1);
+  } finally {
+    storage.close();
+  }
+});
+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");
+  console.log(chalk.blue.bold("\n  CodeMap Impact Analysis\n"));
+  if (!existsSync2(dbPath)) {
+    console.log(chalk.red("  Error: Not initialized. Run 'codemap init' first.\n"));
+    process.exit(1);
+  }
+  const spinner = ora("Detecting changes...").start();
+  try {
+    const result = await analyzeImpact({ path: rootPath, verbose: options.verbose });
+    if (result.changedFiles.length === 0) {
+      spinner.succeed(chalk.green("No changes detected"));
+      console.log(chalk.gray("  All files are up to date.\n"));
+      return;
+    }
+    spinner.succeed(chalk.green(`Detected ${result.changedFiles.length} modified files`));
+    console.log(chalk.blue("\n  Modified Files:\n"));
+    for (const file of result.changedFiles.slice(0, 10)) {
+      console.log(chalk.gray(`    \u2022 ${file}`));
+    }
+    if (result.changedFiles.length > 10) {
+      console.log(chalk.gray(`    ... and ${result.changedFiles.length - 10} more`));
+    }
+    if (result.changedFunctions.length > 0) {
+      console.log(chalk.blue("\n  Changed Functions:\n"));
+      for (const func of result.changedFunctions) {
+        console.log(chalk.gray(`    \u2022 ${func.functionName} (${func.file}:${func.lineNumber})`));
+      }
+    }
+    if (result.directCallers.size > 0) {
+      console.log(chalk.blue("\n  Impact Analysis:\n"));
+      for (const [funcName, callers] of result.directCallers.entries()) {
+        console.log(chalk.yellow(`    ${funcName}:`));
+        console.log(chalk.gray(`      ${callers.length} direct callers`));
+        if (options.verbose) {
+          for (const caller of callers.slice(0, 5)) {
+            console.log(chalk.gray(`        \u2022 ${caller.name} (${caller.file}:${caller.line})`));
+          }
+          if (callers.length > 5) {
+            console.log(chalk.gray(`        ... and ${callers.length - 5} more`));
+          }
+        }
+      }
+    }
+    if (result.affectedEndpoints.length > 0) {
+      console.log(chalk.blue("\n  Affected HTTP Endpoints:\n"));
+      for (const endpoint of result.affectedEndpoints) {
+        console.log(chalk.gray(`    \u2022 ${endpoint}`));
+      }
+    }
+    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`);
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk.red("Impact analysis failed"));
+    console.error(error);
+    process.exit(1);
+  }
+});
+program.command("reindex").description("Force full re-index of codebase").argument("[path]", "Path to the project root", ".").option("--include <patterns...>", "Glob patterns to include").option("--exclude <patterns...>", "Glob patterns to exclude").action(async (path, options) => {
+  const indexCommand = program.commands.find((cmd) => cmd.name() === "index");
+  if (indexCommand) {
+    await indexCommand.parseAsync([path, "--force", ...options.include ? ["--include", ...options.include] : [], ...options.exclude ? ["--exclude", ...options.exclude] : []], { from: "user" });
+  }
+});
 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 = resolve2(options.path);
-  process.env.CODEMAP_DB_PATH = join(resolve2(options.path), ".codemap", "graph.db");
-  await import("./flow-server-QO7IWYLE.js");
+  process.env.CODEMAP_PROJECT_ROOT = resolve3(options.path);
+  process.env.CODEMAP_DB_PATH = join3(resolve3(options.path), ".codemap", "graph.db");
+  await import("./flow-server-B2SVQKDG.js");
 });
 program.parse();
 //# sourceMappingURL=cli.js.map