codemap-ai 3.4.0 → 3.5.0

package/dist/cli.js

@@ -2,18 +2,18 @@
 
 import {
   FlowStorage
-} from "./chunk-LXZ73T7X.js";
+} from "./chunk-BRVRY5KT.js";
 
 // src/cli-flow.ts
 import { Command } from "commander";
 import { resolve as resolve3, join as join4 } from "path";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync5, writeFileSync } from "fs";
 import { homedir } from "os";
 import chalk from "chalk";
 import ora from "ora";
 
 // src/flow/builder.ts
-import { readFileSync, statSync } from "fs";
+import { readFileSync as readFileSync2, statSync } from "fs";
 import { createHash } from "crypto";
 import { glob } from "glob";
 import { resolve, relative, extname } from "path";
@@ -483,10 +483,13 @@ var TypeScriptParser = class extends BaseParser {
   language = "typescript";
   extensions = [".ts", ".tsx"];
   parser;
+  treeSitterParser;
+  // Expose for Phase 3
   constructor() {
     super();
     this.parser = new Parser();
     this.parser.setLanguage(TypeScript.typescript);
+    this.treeSitterParser = this.parser;
   }
   parse(filePath, content) {
     const analysis = this.createEmptyAnalysis(filePath);
@@ -774,6 +777,7 @@ var JavaScriptParser = class extends TypeScriptParser {
     super();
     this.parser = new Parser();
     this.parser.setLanguage(JavaScript);
+    this.treeSitterParser = this.parser;
   }
   parse(filePath, content) {
     const sourceCode = typeof content === "string" ? content : String(content);
@@ -798,10 +802,13 @@ var PythonParser = class extends BaseParser {
   language = "python";
   extensions = [".py"];
   parser;
+  treeSitterParser;
+  // Expose for Phase 3
   constructor() {
     super();
     this.parser = new Parser2();
     this.parser.setLanguage(Python);
+    this.treeSitterParser = this.parser;
   }
   parse(filePath, content) {
     const analysis = this.createEmptyAnalysis(filePath);
@@ -1362,6 +1369,614 @@ function registerAllParsers() {
 }
 registerAllParsers();
 
+// src/flow/phase3-analyzer.ts
+import { readFileSync } from "fs";
+
+// src/analysis/property-tracker.ts
+function extractPropertyAccesses(functionNode, scopeId, scopeName, filePath) {
+  const accesses = [];
+  const isJS = /\.(js|ts|jsx|tsx)$/.test(filePath);
+  const isPython = /\.py$/.test(filePath);
+  if (isJS) {
+    extractJavaScriptPropertyAccesses(functionNode, scopeId, scopeName, accesses);
+  } else if (isPython) {
+    extractPythonPropertyAccesses(functionNode, scopeId, scopeName, accesses);
+  }
+  return accesses;
+}
+function extractJavaScriptPropertyAccesses(node, scopeId, scopeName, accesses) {
+  traverseNode(node, (current) => {
+    if (current.type === "member_expression") {
+      const access = parseJavaScriptMemberExpression(current, scopeId);
+      if (access) {
+        accesses.push(access);
+      }
+    }
+    if (current.type === "optional_chain") {
+      const memberExpr = current.children.find((c) => c.type === "member_expression");
+      if (memberExpr) {
+        const access = parseJavaScriptMemberExpression(memberExpr, scopeId);
+        if (access) {
+          access.accessType = "optional";
+          accesses.push(access);
+        }
+      }
+    }
+    if (current.type === "subscript_expression") {
+      const access = parseJavaScriptSubscript(current, scopeId);
+      if (access) {
+        accesses.push(access);
+      }
+    }
+  });
+}
+function parseJavaScriptMemberExpression(node, scopeId) {
+  const propertyPath = [];
+  let objectName = "";
+  let currentNode = node;
+  while (currentNode && currentNode.type === "member_expression") {
+    const propertyNode = currentNode.childForFieldName("property");
+    if (propertyNode) {
+      propertyPath.unshift(propertyNode.text);
+    }
+    const objectNode = currentNode.childForFieldName("object");
+    if (!objectNode) break;
+    if (objectNode.type === "identifier") {
+      objectName = objectNode.text;
+      break;
+    } else if (objectNode.type === "member_expression") {
+      currentNode = objectNode;
+    } else {
+      return null;
+    }
+  }
+  if (!objectName || isCommonJavaScriptObject(objectName)) {
+    return null;
+  }
+  if (propertyPath.length === 0) {
+    return null;
+  }
+  return {
+    objectName,
+    propertyPath,
+    fullPath: `${objectName}.${propertyPath.join(".")}`,
+    line: node.startPosition.row + 1,
+    scopeId,
+    accessType: "dot"
+  };
+}
+function parseJavaScriptSubscript(node, scopeId) {
+  const objectNode = node.childForFieldName("object");
+  const indexNode = node.childForFieldName("index");
+  if (!objectNode || !indexNode) return null;
+  if (indexNode.type !== "string") return null;
+  const objectName = objectNode.text;
+  const propertyName = indexNode.text.replace(/['"]/g, "");
+  if (isCommonJavaScriptObject(objectName)) {
+    return null;
+  }
+  return {
+    objectName,
+    propertyPath: [propertyName],
+    fullPath: `${objectName}.${propertyName}`,
+    line: node.startPosition.row + 1,
+    scopeId,
+    accessType: "bracket"
+  };
+}
+function extractPythonPropertyAccesses(node, scopeId, scopeName, accesses) {
+  traverseNode(node, (current) => {
+    if (current.type === "attribute") {
+      const access = parsePythonAttribute(current, scopeId);
+      if (access) {
+        accesses.push(access);
+      }
+    }
+    if (current.type === "subscript") {
+      const access = parsePythonSubscript(current, scopeId);
+      if (access) {
+        accesses.push(access);
+      }
+    }
+  });
+}
+function parsePythonAttribute(node, scopeId) {
+  const propertyPath = [];
+  let objectName = "";
+  let currentNode = node;
+  while (currentNode && currentNode.type === "attribute") {
+    const attrNode = currentNode.childForFieldName("attribute");
+    if (attrNode) {
+      propertyPath.unshift(attrNode.text);
+    }
+    const objectNode = currentNode.childForFieldName("object");
+    if (!objectNode) break;
+    if (objectNode.type === "identifier") {
+      objectName = objectNode.text;
+      break;
+    } else if (objectNode.type === "attribute") {
+      currentNode = objectNode;
+    } else {
+      return null;
+    }
+  }
+  if (!objectName || isCommonPythonObject(objectName)) {
+    return null;
+  }
+  if (propertyPath.length === 0) {
+    return null;
+  }
+  return {
+    objectName,
+    propertyPath,
+    fullPath: `${objectName}.${propertyPath.join(".")}`,
+    line: node.startPosition.row + 1,
+    scopeId,
+    accessType: "dot"
+  };
+}
+function parsePythonSubscript(node, scopeId) {
+  const valueNode = node.childForFieldName("value");
+  const subscriptChildren = node.children.filter(
+    (c) => c.type === "string" || c.type === "identifier"
+  );
+  if (!valueNode || subscriptChildren.length === 0) return null;
+  const keyNode = subscriptChildren.find((c) => c.type === "string");
+  if (!keyNode) return null;
+  const objectName = valueNode.text;
+  const stringContent = keyNode.children.find((c) => c.type === "string_content");
+  const propertyName = stringContent ? stringContent.text : keyNode.text.replace(/['"]/g, "");
+  if (isCommonPythonObject(objectName)) {
+    return null;
+  }
+  return {
+    objectName,
+    propertyPath: [propertyName],
+    fullPath: `${objectName}.${propertyName}`,
+    line: node.startPosition.row + 1,
+    scopeId,
+    accessType: "bracket"
+  };
+}
+function traverseNode(node, visitor) {
+  visitor(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      traverseNode(child, visitor);
+    }
+  }
+}
+function isCommonJavaScriptObject(name) {
+  const commonObjects = /* @__PURE__ */ new Set([
+    // Global objects
+    "console",
+    "window",
+    "document",
+    "process",
+    "global",
+    // Common libraries
+    "Math",
+    "JSON",
+    "Date",
+    "Array",
+    "Object",
+    "String",
+    "Number",
+    // Keywords
+    "this",
+    "super",
+    // Common module patterns
+    "exports",
+    "module",
+    "require"
+  ]);
+  return commonObjects.has(name);
+}
+function isCommonPythonObject(name) {
+  const commonObjects = /* @__PURE__ */ new Set([
+    // Keywords
+    "self",
+    "cls",
+    // Built-in types
+    "str",
+    "int",
+    "float",
+    "dict",
+    "list",
+    "tuple",
+    "set",
+    // Common modules
+    "os",
+    "sys",
+    "json",
+    "math",
+    "datetime"
+  ]);
+  return commonObjects.has(name);
+}
+
+// src/analysis/return-analyzer.ts
+function analyzeReturnStatements(functionNode, functionId, functionName, filePath) {
+  const returns = [];
+  const isJS = /\.(js|ts|jsx|tsx)$/.test(filePath);
+  const isPython = /\.py$/.test(filePath);
+  if (isJS) {
+    extractJavaScriptReturns(functionNode, functionId, functionName, returns);
+  } else if (isPython) {
+    extractPythonReturns(functionNode, functionId, functionName, returns);
+  }
+  return returns;
+}
+function extractJavaScriptReturns(node, functionId, functionName, returns) {
+  traverseNode2(node, (current) => {
+    if (current.type === "return_statement") {
+      const returnNode = current.children.find(
+        (c) => c.type !== "return" && c.type !== ";"
+      );
+      if (returnNode) {
+        const returnInfo = parseJavaScriptReturnValue(
+          returnNode,
+          functionId,
+          functionName
+        );
+        if (returnInfo) {
+          returns.push(returnInfo);
+        }
+      }
+    }
+  });
+}
+function parseJavaScriptReturnValue(returnNode, functionId, functionName) {
+  const line = returnNode.startPosition.row + 1;
+  const returnExpression = returnNode.text;
+  let returnType = null;
+  let objectShape = null;
+  if (returnNode.type === "object") {
+    objectShape = extractJavaScriptObjectShape(returnNode);
+    returnType = "object";
+  } else if (returnNode.type === "array") {
+    returnType = "array";
+    objectShape = {
+      properties: [],
+      propertyTypes: /* @__PURE__ */ new Map(),
+      nestedShapes: /* @__PURE__ */ new Map(),
+      isArray: true,
+      isDictionary: false,
+      isOptional: false
+    };
+  } else if (returnNode.type === "new_expression") {
+    const constructorNode = returnNode.childForFieldName("constructor");
+    if (constructorNode) {
+      returnType = constructorNode.text;
+    }
+  } else if (returnNode.type === "identifier") {
+    returnType = `@var:${returnNode.text}`;
+  } else if (returnNode.type === "call_expression") {
+    const funcNode = returnNode.childForFieldName("function");
+    if (funcNode) {
+      returnType = `@call:${funcNode.text}`;
+    }
+  }
+  return {
+    functionId,
+    functionName,
+    returnType,
+    objectShape,
+    line,
+    returnExpression
+  };
+}
+function extractJavaScriptObjectShape(objectNode) {
+  const properties = [];
+  const propertyTypes = /* @__PURE__ */ new Map();
+  const nestedShapes = /* @__PURE__ */ new Map();
+  for (const child of objectNode.children) {
+    if (child.type === "pair") {
+      const keyNode = child.childForFieldName("key");
+      const valueNode = child.childForFieldName("value");
+      if (keyNode) {
+        const propertyName = keyNode.text.replace(/['"]/g, "");
+        properties.push(propertyName);
+        if (valueNode) {
+          const propertyType = inferJavaScriptType(valueNode);
+          propertyTypes.set(propertyName, propertyType);
+          if (valueNode.type === "object") {
+            const nestedShape = extractJavaScriptObjectShape(valueNode);
+            nestedShapes.set(propertyName, nestedShape);
+          }
+        }
+      }
+    }
+  }
+  return {
+    properties,
+    propertyTypes,
+    nestedShapes,
+    isArray: false,
+    isDictionary: false,
+    isOptional: false
+  };
+}
+function inferJavaScriptType(valueNode) {
+  switch (valueNode.type) {
+    case "number":
+      return "number";
+    case "string":
+    case "template_string":
+      return "string";
+    case "true":
+    case "false":
+      return "boolean";
+    case "null":
+      return "null";
+    case "undefined":
+      return "undefined";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    case "arrow_function":
+    case "function_expression":
+      return "function";
+    case "identifier":
+      return `@var:${valueNode.text}`;
+    case "call_expression":
+      return "@call";
+    default:
+      return "unknown";
+  }
+}
+function extractPythonReturns(node, functionId, functionName, returns) {
+  traverseNode2(node, (current) => {
+    if (current.type === "return_statement") {
+      const returnNode = current.children.find((c) => c.type !== "return");
+      if (returnNode) {
+        const returnInfo = parsePythonReturnValue(
+          returnNode,
+          functionId,
+          functionName
+        );
+        if (returnInfo) {
+          returns.push(returnInfo);
+        }
+      }
+    }
+  });
+}
+function parsePythonReturnValue(returnNode, functionId, functionName) {
+  const line = returnNode.startPosition.row + 1;
+  const returnExpression = returnNode.text;
+  let returnType = null;
+  let objectShape = null;
+  if (returnNode.type === "dictionary") {
+    objectShape = extractPythonDictionaryShape(returnNode);
+    returnType = "dict";
+  } else if (returnNode.type === "list") {
+    returnType = "list";
+    objectShape = {
+      properties: [],
+      propertyTypes: /* @__PURE__ */ new Map(),
+      nestedShapes: /* @__PURE__ */ new Map(),
+      isArray: true,
+      isDictionary: false,
+      isOptional: false
+    };
+  } else if (returnNode.type === "call") {
+    const funcNode = returnNode.childForFieldName("function");
+    if (funcNode) {
+      const funcName = funcNode.text;
+      if (funcName[0] === funcName[0].toUpperCase()) {
+        returnType = funcName;
+      } else {
+        returnType = `@call:${funcName}`;
+      }
+    }
+  } else if (returnNode.type === "identifier") {
+    returnType = `@var:${returnNode.text}`;
+  } else if (returnNode.type === "list_comprehension") {
+    returnType = "list";
+    objectShape = {
+      properties: [],
+      propertyTypes: /* @__PURE__ */ new Map(),
+      nestedShapes: /* @__PURE__ */ new Map(),
+      isArray: true,
+      isDictionary: false,
+      isOptional: false
+    };
+  }
+  return {
+    functionId,
+    functionName,
+    returnType,
+    objectShape,
+    line,
+    returnExpression
+  };
+}
+function extractPythonDictionaryShape(dictNode) {
+  const properties = [];
+  const propertyTypes = /* @__PURE__ */ new Map();
+  const nestedShapes = /* @__PURE__ */ new Map();
+  for (const child of dictNode.children) {
+    if (child.type === "pair") {
+      const keyNode = child.children.find((c) => c.type === "string");
+      const valueNode = child.children.find(
+        (c) => c.type !== "string" && c.type !== ":"
+      );
+      if (keyNode) {
+        const stringContent = keyNode.children.find(
+          (c) => c.type === "string_content"
+        );
+        const propertyName = stringContent ? stringContent.text : keyNode.text.replace(/['"]/g, "");
+        properties.push(propertyName);
+        if (valueNode) {
+          const propertyType = inferPythonType(valueNode);
+          propertyTypes.set(propertyName, propertyType);
+          if (valueNode.type === "dictionary") {
+            const nestedShape = extractPythonDictionaryShape(valueNode);
+            nestedShapes.set(propertyName, nestedShape);
+          }
+        }
+      }
+    }
+  }
+  return {
+    properties,
+    propertyTypes,
+    nestedShapes,
+    isArray: false,
+    isDictionary: true,
+    isOptional: false
+  };
+}
+function inferPythonType(valueNode) {
+  switch (valueNode.type) {
+    case "integer":
+    case "float":
+      return "number";
+    case "string":
+      return "string";
+    case "true":
+    case "false":
+      return "boolean";
+    case "none":
+      return "None";
+    case "list":
+      return "list";
+    case "dictionary":
+      return "dict";
+    case "lambda":
+      return "function";
+    case "identifier":
+      return `@var:${valueNode.text}`;
+    case "call":
+      return "@call";
+    default:
+      return "unknown";
+  }
+}
+function traverseNode2(node, visitor) {
+  visitor(node);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      traverseNode2(child, visitor);
+    }
+  }
+}
+
+// src/flow/storage-queries-phase3.ts
+import { randomUUID } from "crypto";
+function storePropertyAccesses(db, accesses) {
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO property_accesses
+    (id, scope_node_id, object_name, property_path, full_path, access_type, file_path, line)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insert = db.transaction((accesses2) => {
+    for (const access of accesses2) {
+      stmt.run(
+        randomUUID(),
+        access.scopeId,
+        access.objectName,
+        JSON.stringify(access.propertyPath),
+        access.fullPath,
+        access.accessType,
+        access.filePath || "",
+        access.line
+      );
+    }
+  });
+  insert(accesses);
+}
+function storeReturnInfo(db, returns) {
+  const stmt = db.prepare(`
+    INSERT OR REPLACE INTO return_shapes
+    (id, function_id, return_type, object_shape, line, return_expression)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+  const insert = db.transaction((returns2) => {
+    for (const ret of returns2) {
+      stmt.run(
+        randomUUID(),
+        ret.functionId,
+        ret.returnType,
+        ret.objectShape ? JSON.stringify(serializeObjectShape(ret.objectShape)) : null,
+        ret.line,
+        ret.returnExpression
+      );
+    }
+  });
+  insert(returns);
+}
+function serializeObjectShape(shape) {
+  return {
+    properties: shape.properties,
+    propertyTypes: Array.from(shape.propertyTypes.entries()),
+    nestedShapes: Array.from(shape.nestedShapes.entries()).map(([key, nested]) => [
+      key,
+      serializeObjectShape(nested)
+    ]),
+    isArray: shape.isArray,
+    isDictionary: shape.isDictionary,
+    isOptional: shape.isOptional
+  };
+}
+
+// src/flow/phase3-analyzer.ts
+function analyzeFileForPhase3(filePath, functionNodes, db) {
+  try {
+    const language = getLanguageFromPath(filePath);
+    if (!language) return;
+    const parserInstance = parserRegistry.getByLanguage(language);
+    if (!parserInstance || !parserInstance.treeSitterParser) return;
+    const content = readFileSync(filePath, "utf-8");
+    const tree = parserInstance.treeSitterParser.parse(content);
+    const rootNode = tree.rootNode;
+    for (const func of functionNodes) {
+      const funcNode = findNodeAtLine(rootNode, func.startLine, func.endLine);
+      if (!funcNode) continue;
+      const accesses = extractPropertyAccesses(funcNode, func.id, func.name, filePath);
+      if (accesses.length > 0) {
+        const accessesWithFile = accesses.map((a) => ({ ...a, filePath }));
+        storePropertyAccesses(db, accessesWithFile);
+      }
+      const returns = analyzeReturnStatements(funcNode, func.id, func.name, filePath);
+      if (returns.length > 0) {
+        storeReturnInfo(db, returns);
+      }
+    }
+  } catch (error) {
+  }
+}
+function getLanguageFromPath(filePath) {
+  if (filePath.endsWith(".py")) return "python";
+  if (filePath.endsWith(".js") || filePath.endsWith(".jsx")) return "javascript";
+  if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) return "typescript";
+  return null;
+}
+function findNodeAtLine(node, startLine, endLine) {
+  const nodeStart = node.startPosition.row + 1;
+  const nodeEnd = node.endPosition.row + 1;
+  if (nodeStart === startLine && nodeEnd === endLine) {
+    return node;
+  }
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) {
+      const result = findNodeAtLine(child, startLine, endLine);
+      if (result) return result;
+    }
+  }
+  if (nodeStart <= startLine && nodeEnd >= endLine) {
+    if (node.type === "function_definition" || node.type === "function_declaration" || node.type === "method_definition" || node.type === "arrow_function" || node.type === "function_expression") {
+      return node;
+    }
+  }
+  return null;
+}
+
 // src/flow/builder.ts
 var FlowBuilder = class {
   storage;
@@ -1389,7 +2004,7 @@ var FlowBuilder = class {
     const filesToIndex = [];
     let skipped = 0;
     for (const filePath of allFiles) {
-      const content = readFileSync(filePath, "utf-8");
+      const content = readFileSync2(filePath, "utf-8");
       const hash = this.hashContent(content);
       if (!this.config.forceReindex) {
         const existingHash = this.storage.getFileHash(filePath);
@@ -1473,7 +2088,7 @@ var FlowBuilder = class {
   }
   async parseAndStore(filePath, hash, rootPath) {
     const language = this.getLanguage(filePath);
-    const content = readFileSync(filePath, "utf-8");
+    const content = readFileSync2(filePath, "utf-8");
     const parser = parserRegistry.getByLanguage(language);
     if (!parser) {
       throw new Error(`No parser found for language: ${language}`);
@@ -1510,6 +2125,15 @@ var FlowBuilder = class {
         );
       }
     }
+    const functionNodes = analysis.nodes.filter((n) => n.type === "function" || n.type === "method").map((n) => ({
+      id: n.id,
+      name: n.name,
+      startLine: n.startLine,
+      endLine: n.endLine
+    }));
+    if (functionNodes.length > 0) {
+      analyzeFileForPhase3(filePath, functionNodes, this.storage.db);
+    }
     if (analysis.databaseOperations) {
       for (const dbOp of analysis.databaseOperations) {
         this.storage.insertDatabaseOperation({
@@ -1789,7 +2413,7 @@ function getGitStatus(rootPath) {
 }
 
 // src/analysis/imports.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 function isJavaScriptBuiltin(identifier) {
   const builtins = /* @__PURE__ */ new Set([
     "Object",
@@ -1872,7 +2496,7 @@ function isPythonBuiltin(identifier) {
   return builtins.has(identifier);
 }
 function analyzeJavaScriptImports(filePath) {
-  const content = readFileSync2(filePath, "utf-8");
+  const content = readFileSync3(filePath, "utf-8");
   const lines = content.split("\n");
   const imports = /* @__PURE__ */ new Map();
   for (let i = 0; i < lines.length; i++) {
@@ -1967,7 +2591,7 @@ function analyzeJavaScriptImports(filePath) {
   return { missing, unused };
 }
 function analyzePythonImports(filePath) {
-  const content = readFileSync2(filePath, "utf-8");
+  const content = readFileSync3(filePath, "utf-8");
   const lines = content.split("\n");
   const imports = /* @__PURE__ */ new Map();
   for (let i = 0; i < lines.length; i++) {
@@ -2066,14 +2690,14 @@ function analyzeImports(filePath) {
 }
 
 // src/analysis/docker.ts
-import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync4, 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 content = readFileSync4(dockerfilePath, "utf-8");
   const lines = content.split("\n");
   let inHealthCheck = false;
   for (const line of lines) {
@@ -2151,7 +2775,7 @@ function parseDockerCompose(projectRoot) {
   let composeData = null;
   for (const file of composeFiles) {
     if (existsSync2(file)) {
-      const content = readFileSync3(file, "utf-8");
+      const content = readFileSync4(file, "utf-8");
       composeData = parseYaml(content);
       break;
     }
@@ -2923,7 +3547,7 @@ function configureMCPServer(projectPath) {
     if (!existsSync3(claudeConfigPath)) {
       return false;
     }
-    const config = JSON.parse(readFileSync4(claudeConfigPath, "utf-8"));
+    const config = JSON.parse(readFileSync5(claudeConfigPath, "utf-8"));
     if (!config.mcpServers) {
       config.mcpServers = {};
     }
@@ -2937,7 +3561,7 @@ function configureMCPServer(projectPath) {
     return false;
   }
 }
-program.name("codemap").description("CodeMap Flow - Call graph analyzer for understanding code impact").version("3.2.0");
+program.name("codemap").description("CodeMap Flow - Call graph analyzer for understanding code impact").version("3.5.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 = join4(rootPath, ".codemap");
@@ -3236,7 +3860,7 @@ 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 = join4(resolve3(options.path), ".codemap", "graph.db");
-  await import("./flow-server-4XSR5P4N.js");
+  await import("./flow-server-FMPWJSLK.js");
 });
 program.parse();
 //# sourceMappingURL=cli.js.map