Function buildCodeGraph

src/services/code-graph.ts:644–802

(
  projectPath: string,
  extraExtensions?: Set<string>,
  progress?: GraphBuildProgress,
)

 * `symbolsByFile` / `outgoingCallsByFile` and persisted by `doRebuildGraph`.
 */
export async function buildCodeGraph(
  projectPath: string,
  extraExtensions?: Set<string>,
  progress?: GraphBuildProgress,
): Promise<CodeGraph & {
  symbolsByFile: Map<string, SymbolNode[]>;
  outgoingCallsByFile: Map<string, SymbolEdge[]>;
}> {
  ensureDynamicLanguages();

  const resolvedPath = path.resolve(projectPath);
  const aliases = await loadPathAliases(resolvedPath);
  const files = await getGraphableFiles(resolvedPath, extraExtensions);
  const fileSet = new Set(files);

  if (progress) {
    progress.filesTotal = files.length;
    progress.phase = "analyzing imports";
  }

  logger.info("Building code graph", { projectPath: resolvedPath, fileCount: files.length });

  const nodesMap = new Map<string, CodeGraphNode>();
  const edges: CodeGraphEdge[] = [];
  const symbolsByFile = new Map<string, SymbolNode[]>();
  const outgoingCallsByFile = new Map<string, SymbolEdge[]>();

  // Build a suffix lookup map for JVM multi-module projects (Java/Kotlin/Scala).
  // This resolves FQNs like com.example.Foo when the class lives under a nested
  // src/main/java/ tree (e.g. module-a/sub/src/main/java/com/example/Foo.java).
  // Cost: O(n) once here, O(1) per import lookup (negligible vs. full AST parse).
  const hasJvm = files.some((f) => {
    const e = path.extname(f).toLowerCase();
    return e === ".java" || e === ".kt" || e === ".kts" || e === ".scala";
  });
  const jvmSuffixMap = hasJvm ? buildJvmSuffixMap(fileSet) : undefined;

  // Build a namespace lookup map for C# projects. Each `namespace X.Y.Z` block
  // (or file-scoped `namespace X.Y.Z;`) is recorded so `using X.Y.Z;` directives
  // can be resolved to the file(s) that contribute to that namespace. Without
  // this, every C# import resolved to null and the file graph was empty.
  const hasCs = files.some((f) => path.extname(f).toLowerCase() === ".cs");
  const csNamespaceMap = hasCs ? buildCsNamespaceMap(fileSet, resolvedPath) : undefined;

  // Build Go module-resolution info from go.mod (issue #45). Without this,
  // every Go import resolved to null and Go projects produced an empty
  // file graph. The info is null when go.mod is missing or unparseable;
  // the resolver treats null as "no Go resolution available" and behaves
  // exactly as it did before this PR for those cases.
  const hasGo = files.some((f) => f.endsWith(".go"));
  const goModuleInfo = hasGo ? buildGoModuleInfo(fileSet, resolvedPath) : undefined;

  for (const relPath of files) {
    const ext = path.extname(relPath).toLowerCase();
    const lang = getAstGrepLang(ext);

    // Files with no AST grammar (extra extensions) are included as leaf nodes
    // so they can be targets of import edges from other files, but we skip