Function computeImpactCandidates

src/tools/search-codebase.ts:426–484

(resultPaths: string[])

  // Impact breadth estimate from the import graph (used for risk assessment).
  // 2-hop: direct importers (hop 1) + importers of importers (hop 2).
  function computeImpactCandidates(resultPaths: string[]): ImpactCandidate[] {
    const allImports = getImportsGraph();
    if (!allImports) return [];

    const importDetails = getImportDetailsGraph();

    const reverseImportsLocal = new Map<string, string[]>();
    for (const [file, deps] of Object.entries<string[]>(allImports)) {
      for (const dep of deps) {
        if (!reverseImportsLocal.has(dep)) reverseImportsLocal.set(dep, []);
        reverseImportsLocal.get(dep)!.push(file);
      }
    }

    const targets = resultPaths.map((rp) => normalizeGraphPath(rp));

    const candidates = new Map<string, ImpactCandidate>();

    const addCandidate = (file: string, hop: 1 | 2, line?: number): void => {
      const existing = candidates.get(file);
      if (existing) {
        if (existing.hop <= hop) return;
      }
      candidates.set(file, { file, hop, ...(line ? { line } : {}) });
    };

    const collectImporters = (
      target: string
    ): Array<{ importer: string; detail: ImportEdgeDetail | null }> => {
      const matches: Array<{ importer: string; detail: ImportEdgeDetail | null }> = [];
      for (const [dep, importers] of reverseImportsLocal) {
        if (!pathsMatch(dep, target)) continue;
        for (const importer of importers) {
          matches.push({ importer, detail: findImportDetail(importDetails, importer, dep) });
        }
      }
      return matches;
    };

    // Hop 1
    const hop1Files: string[] = [];
    for (const target of targets) {
      for (const { importer, detail } of collectImporters(target)) {
        addCandidate(importer, 1, detail?.line);
      }
    }
    for (const candidate of candidates.values()) {
      if (candidate.hop === 1) hop1Files.push(candidate.file);
    }

    // Hop 2
    for (const mid of hop1Files) {
      for (const { importer, detail } of collectImporters(mid)) {
        addCandidate(importer, 2, detail?.line);
      }
    }

    return Array.from(candidates.values()).slice(0, 20);