@lzehrung/codegraph 2.1.0

package/dist/impact/report-suggestions.js

@@ -0,0 +1,886 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { SymbolKind } from "../indexer/types.js";
+import { findReferences } from "../indexer/navigation.js";
+import { fileIdentityKey, resolveFilePathFromRoot, toProjectDisplayPath } from "../util/paths.js";
+import { mapLimit } from "../util/concurrency.js";
+import { maskJsLikeCommentsAndStrings } from "../util/comments.js";
+import { listCandidateTestFiles } from "./context.js";
+import { collectHunkLineText, collectRemovedLines } from "./hunks.js";
+import { normalizeImpactFilePath } from "./path.js";
+import { collectImpactSuggestions } from "./suggestions.js";
+import { compileTestPatterns, createIndexTestFileMatcher } from "./testPatterns.js";
+const CONFIG_FILE_RE = /(^|\/)(?:tsconfig(?:\.[^./]+)?\.json|jsconfig\.json|vite\.config\.[cm]?[jt]s|webpack\.config\.[cm]?[jt]s|rollup\.config\.[cm]?[jt]s|esbuild\.config\.[cm]?[jt]s|babel\.config\.[cm]?[jt]s|\.eslintrc(?:\.[^./]+)?|prettier\.config\.[cm]?[jt]s|package\.json|pnpm-workspace\.ya?ml|lerna\.json|turbo\.json|nx\.json|\.env(?:\.[^/]*)?)$/i;
+const UNTESTED_CHANGE_REFERENCE_SCAN_LIMIT = 500;
+function matchesConfigSemantics(filePath) {
+    return CONFIG_FILE_RE.test(filePath);
+}
+function collectAddedLines(change) {
+    return collectHunkLineText(change).added;
+}
+function collectRemovedLinesText(change) {
+    return collectHunkLineText(change).removed;
+}
+function collectRemovedAndAddedLines(change) {
+    return collectHunkLineText(change).changed;
+}
+function collectTsconfigPathAliases(change) {
+    const aliases = new Set();
+    const keyRe = /"([^"\n]+)"\s*:\s*/;
+    for (const line of collectRemovedAndAddedLines(change)) {
+        const match = keyRe.exec(line);
+        const key = match?.[1]?.trim();
+        if (!key)
+            continue;
+        if (key.startsWith("@") || key.includes("/*") || key.includes("/")) {
+            aliases.add(key);
+        }
+    }
+    return [...aliases];
+}
+function aliasMatchesImport(alias, rawSpecifier) {
+    if (alias.endsWith("/*")) {
+        const prefix = alias.slice(0, -1);
+        return rawSpecifier.startsWith(prefix);
+    }
+    return rawSpecifier === alias;
+}
+function collectTsconfigBlastRadius(index, aliases) {
+    if (!aliases.length) {
+        return { aliases: [], importers: [] };
+    }
+    const aliasSet = new Set(aliases);
+    const importers = new Set();
+    for (const edge of index.graph.edges) {
+        const raw = edge.raw?.trim();
+        if (!raw || edge.to.type !== "file")
+            continue;
+        for (const alias of aliasSet) {
+            if (!aliasMatchesImport(alias, raw))
+                continue;
+            importers.add(edge.from);
+            break;
+        }
+    }
+    return {
+        aliases: [...aliasSet],
+        importers: [...importers],
+    };
+}
+function collectWorkspaceManifestPaths(index) {
+    const out = new Set();
+    for (const node of index.graph.nodes) {
+        if (!node.endsWith("/package.json"))
+            continue;
+        out.add(node);
+    }
+    return [...out];
+}
+function classifyConfigImpact(index, projectRoot, change) {
+    const lowerPath = change.path.toLowerCase();
+    const addedLines = collectAddedLines(change).join("\n").toLowerCase();
+    const removedLines = collectRemovedLinesText(change).join("\n").toLowerCase();
+    const lineSignals = `${addedLines}\n${removedLines}`;
+    if (lowerPath.endsWith("package.json")) {
+        if (lineSignals.includes('"scripts"')) {
+            return {
+                details: "package.json scripts changed; CI/build workflows may be affected across packages.",
+                confidence: "medium",
+            };
+        }
+        if (lineSignals.includes('"dependencies"') || lineSignals.includes('"devdependencies"')) {
+            return {
+                details: "package.json dependency graph changed; dependency resolution can affect multiple workspaces.",
+                confidence: "high",
+            };
+        }
+    }
+    const isTsconfig = lowerPath.endsWith("tsconfig.json") || lowerPath.endsWith("jsconfig.json");
+    if (isTsconfig) {
+        const aliases = collectTsconfigPathAliases(change);
+        const blastRadius = collectTsconfigBlastRadius(index, aliases);
+        if (blastRadius.aliases.length) {
+            const relImporters = blastRadius.importers.slice(0, 5).map((file) => toProjectDisplayPath(projectRoot, file));
+            const importerSummary = blastRadius.importers.length
+                ? `Likely impacted importer files: ${relImporters.join(", ")}${blastRadius.importers.length > relImporters.length ? ", ..." : ""}.`
+                : "No existing imports currently match these aliases.";
+            return {
+                details: `TypeScript/JavaScript path aliases changed (${blastRadius.aliases.join(", ")}). ${importerSummary}`,
+                confidence: "high",
+            };
+        }
+        return {
+            details: "TypeScript/JavaScript compiler config changed; type-checking and module resolution can shift project-wide.",
+            confidence: "high",
+        };
+    }
+    const isBuildToolConfig = lowerPath.includes("vite.config") ||
+        lowerPath.includes("webpack.config") ||
+        lowerPath.includes("rollup.config") ||
+        lowerPath.includes("esbuild.config");
+    if (isBuildToolConfig) {
+        const signalParts = [];
+        if (lineSignals.includes("alias"))
+            signalParts.push("module alias resolution");
+        if (lineSignals.includes("input") || lineSignals.includes("entry")) {
+            signalParts.push("entrypoint selection");
+        }
+        if (lineSignals.includes("output") || lineSignals.includes("outdir")) {
+            signalParts.push("bundle output targets");
+        }
+        if (lineSignals.includes("plugin"))
+            signalParts.push("plugin execution order");
+        if (lineSignals.includes("define"))
+            signalParts.push("compile-time constants");
+        const detailsSuffix = signalParts.length ? ` Detected changes touch ${signalParts.join(", ")}.` : "";
+        return {
+            details: `Build tool configuration changed (${path.basename(change.path)}); bundling and runtime artifact behavior may change.${detailsSuffix}`,
+            confidence: "high",
+        };
+    }
+    if (lowerPath.endsWith("turbo.json") || lowerPath.endsWith("nx.json")) {
+        const workspaceManifests = collectWorkspaceManifestPaths(index);
+        const affectsTasks = lineSignals.includes("pipeline") ||
+            lineSignals.includes("tasks") ||
+            lineSignals.includes("dependson") ||
+            lineSignals.includes("cache") ||
+            lineSignals.includes("outputs");
+        const scopeSummary = workspaceManifests.length
+            ? `${workspaceManifests.length} workspace package manifest(s) discovered.`
+            : "Workspace package manifests were not discovered.";
+        return {
+            details: affectsTasks
+                ? `Monorepo task orchestration config changed (${path.basename(change.path)}); task dependency graph, caching, or outputs may shift across packages. ${scopeSummary}`
+                : `Monorepo config changed (${path.basename(change.path)}); cross-package task behavior may shift. ${scopeSummary}`,
+            confidence: "high",
+        };
+    }
+    if (lowerPath.includes(".env")) {
+        return {
+            details: "Environment configuration changed; runtime behavior may differ across services and deploy environments.",
+            confidence: "medium",
+        };
+    }
+    return {
+        details: "Configuration change detected; impact can be broad and may require full-project validation.",
+        confidence: "high",
+    };
+}
+function collectConfigAndBreakingSuggestions(index, projectRoot, fileChanges, changedSymbols, opts) {
+    const suggestions = [];
+    const breakingByKey = new Map();
+    const removedLinesByFile = new Map();
+    const confidenceScore = {
+        low: 1,
+        medium: 2,
+        high: 3,
+    };
+    const upsertBreakingSuggestion = (entry) => {
+        const key = `${entry.kind}::${entry.file}::${entry.symbol ?? ""}`;
+        const existing = breakingByKey.get(key);
+        if (!existing) {
+            breakingByKey.set(key, entry);
+            return;
+        }
+        const existingScore = confidenceScore[existing.confidence];
+        const incomingScore = confidenceScore[entry.confidence];
+        if (incomingScore > existingScore) {
+            breakingByKey.set(key, entry);
+        }
+    };
+    for (const fileChange of fileChanges) {
+        const normalized = normalizeImpactFilePath(projectRoot, fileChange.path);
+        removedLinesByFile.set(normalized, collectRemovedLines(fileChange));
+        if (!opts.configImpactRules || !matchesConfigSemantics(fileChange.path))
+            continue;
+        const configSemantics = classifyConfigImpact(index, projectRoot, fileChange);
+        suggestions.push({
+            file: normalized,
+            kind: "configImpact",
+            details: configSemantics.details,
+            confidence: configSemantics.confidence,
+        });
+    }
+    if (opts.detectBreakingChanges) {
+        for (const fileChange of fileChanges) {
+            const normalized = normalizeImpactFilePath(projectRoot, fileChange.path);
+            const signatureChanges = detectExportSignatureChanges(fileChange);
+            for (const change of signatureChanges) {
+                upsertBreakingSuggestion({
+                    file: normalized,
+                    kind: "breakingChange",
+                    symbol: change.name,
+                    details: change.details,
+                    confidence: change.confidence,
+                });
+            }
+        }
+        for (const symbol of changedSymbols) {
+            if (!symbol.exported)
+                continue;
+            const removedLines = removedLinesByFile.get(symbol.file);
+            if (!removedLines || removedLines.size === 0)
+                continue;
+            const symbolStart = symbol.range.start.line;
+            const symbolEnd = symbol.range.end.line;
+            let overlapsRemoval = false;
+            for (const line of removedLines) {
+                if (line < symbolStart || line > symbolEnd)
+                    continue;
+                overlapsRemoval = true;
+                break;
+            }
+            if (!overlapsRemoval)
+                continue;
+            upsertBreakingSuggestion({
+                file: symbol.file,
+                range: symbol.range,
+                kind: "breakingChange",
+                symbol: symbol.name,
+                details: "Exported symbol overlaps removed lines; verify call sites for potential breaking changes.",
+                confidence: "medium",
+            });
+        }
+        for (const fileChange of fileChanges) {
+            const normalized = normalizeImpactFilePath(projectRoot, fileChange.path);
+            const removedLines = removedLinesByFile.get(normalized);
+            if (!removedLines || removedLines.size === 0)
+                continue;
+            const mod = index.byFile.get(fileIdentityKey(normalized));
+            const hasExports = !!mod?.exports.length;
+            const alreadyHasForFile = Array.from(breakingByKey.values()).some((entry) => fileIdentityKey(entry.file) === fileIdentityKey(normalized));
+            if (!hasExports || alreadyHasForFile)
+                continue;
+            upsertBreakingSuggestion({
+                file: normalized,
+                kind: "breakingChange",
+                details: "Removed lines in a module with exports may indicate breaking API changes.",
+                confidence: "low",
+            });
+        }
+    }
+    suggestions.push(...breakingByKey.values());
+    return suggestions;
+}
+async function collectUntestedChangeSuggestions(index, changedSymbols, projectRoot, fanInByFileInput, options) {
+    const suggestions = [];
+    const testPatterns = compileTestPatterns(options?.testPatterns);
+    const isIndexTestFile = createIndexTestFileMatcher(index, testPatterns, projectRoot);
+    const testFiles = new Set();
+    for (const module of index.byFile.values()) {
+        const file = module.file;
+        if (isIndexTestFile(file)) {
+            testFiles.add(fileIdentityKey(file));
+        }
+    }
+    const fanInByFile = fanInByFileInput ?? new Map();
+    if (!fanInByFileInput) {
+        for (const edge of index.graph.edges) {
+            if (edge.to.type !== "file")
+                continue;
+            const key = fileIdentityKey(edge.to.path);
+            const current = fanInByFile.get(key) ?? 0;
+            fanInByFile.set(key, current + 1);
+        }
+    }
+    const candidateTestsByFile = new Map();
+    const changedSymbolIdsByFile = new Map();
+    for (const symbol of changedSymbols) {
+        const existing = changedSymbolIdsByFile.get(symbol.file);
+        if (existing) {
+            existing.push(symbol.id);
+        }
+        else {
+            changedSymbolIdsByFile.set(symbol.file, [symbol.id]);
+        }
+    }
+    for (const [file, symbolIds] of changedSymbolIdsByFile) {
+        candidateTestsByFile.set(file, listCandidateTestFiles(index, [file], symbolIds, {
+            ...(options?.testPatterns ? { testPatterns: options.testPatterns } : {}),
+            maxCandidates: 3,
+            projectRoot,
+        }).filter((entry) => entry.file !== file));
+    }
+    const coverageOptions = {};
+    if (options?.lcovPaths)
+        coverageOptions.lcovPaths = options.lcovPaths;
+    if (options?.coveragePaths)
+        coverageOptions.coveragePaths = options.coveragePaths;
+    const coverageByFile = await loadCoverageByFile(projectRoot, coverageOptions);
+    const inferTestCommand = (candidateNames) => {
+        const template = options?.testCommandTemplate?.trim();
+        if (template) {
+            if (template.includes("{files}")) {
+                const fileArg = candidateNames.length ? candidateNames.join(" ") : "";
+                return template.replace("{files}", fileArg).trim();
+            }
+            return template;
+        }
+        const graphNodeKeys = new Set(Array.from(index.graph.nodes, fileIdentityKey));
+        const hasPnpm = graphNodeKeys.has(fileIdentityKey(path.resolve(projectRoot, "pnpm-lock.yaml").replace(/\\/g, "/")));
+        const hasYarn = graphNodeKeys.has(fileIdentityKey(path.resolve(projectRoot, "yarn.lock").replace(/\\/g, "/")));
+        const hasPackage = graphNodeKeys.has(fileIdentityKey(path.resolve(projectRoot, "package.json").replace(/\\/g, "/")));
+        let runner = "npm run";
+        if (hasPnpm) {
+            runner = "pnpm";
+        }
+        else if (hasYarn) {
+            runner = "yarn";
+        }
+        else if (hasPackage) {
+            runner = "npm run";
+        }
+        if (!candidateNames.length) {
+            return runner === "npm run" ? "npm run test" : `${runner} test`;
+        }
+        const target = candidateNames[0];
+        if (runner === "pnpm")
+            return `pnpm test ${target}`;
+        if (runner === "yarn")
+            return `yarn test ${target}`;
+        return `npm run test -- ${target}`;
+    };
+    const confidenceFromSignals = (signals) => {
+        let score = 2;
+        if (signals.hasCoverageData && signals.coveredLines === 0 && signals.totalLines > 0) {
+            score += 2;
+        }
+        if (!signals.hasCoverageData)
+            score += 1;
+        if (signals.exported)
+            score += 1;
+        if (signals.fanIn >= 3)
+            score += 1;
+        if (signals.kind === SymbolKind.Function)
+            score += 1;
+        if (signals.coveredLines > 0)
+            score -= 1;
+        if (score >= 5)
+            return "high";
+        if (score <= 2)
+            return "low";
+        return "medium";
+    };
+    const suggestionEntries = await mapLimit(changedSymbols, 8, async (symbol) => {
+        const refs = await findReferences(index, {
+            def: {
+                file: symbol.file,
+                localName: symbol.name,
+                kind: symbol.kind,
+                range: symbol.range,
+            },
+        }, {
+            maxReferences: UNTESTED_CHANGE_REFERENCE_SCAN_LIMIT,
+        });
+        if (refs.status !== "ok")
+            return undefined;
+        const hasTestRef = refs.references.some((entry) => testFiles.has(fileIdentityKey(entry.file)));
+        if (hasTestRef)
+            return undefined;
+        const coverage = coverageByFile.get(symbol.file);
+        const coveredLines = countCoveredLinesForRange(coverage, symbol.range);
+        const totalLines = countTotalLinesForRange(coverage, symbol.range);
+        const hasCoverageData = totalLines > 0;
+        const candidateNames = (candidateTestsByFile.get(symbol.file) ?? [])
+            .filter((entry) => entry.confidence !== "low")
+            .slice(0, 2)
+            .map((entry) => path.basename(entry.file));
+        const coverageSummary = hasCoverageData
+            ? `Coverage currently exercises ${coveredLines}/${totalLines} changed line(s).`
+            : "No LCOV or Istanbul coverage data matched this symbol range.";
+        const fanIn = fanInByFile.get(fileIdentityKey(symbol.file)) ?? 0;
+        const confidence = confidenceFromSignals({
+            hasCoverageData,
+            coveredLines,
+            totalLines,
+            exported: symbol.exported,
+            fanIn,
+            kind: symbol.kind,
+        });
+        const suggestedCommand = inferTestCommand(candidateNames);
+        const details = candidateNames.length
+            ? `Changed symbol has no discovered references in test files. ${coverageSummary} Candidate tests: ${candidateNames.join(", ")}. Fan-in for this file is ${fanIn}. Suggested command: ${suggestedCommand}`
+            : `Changed symbol has no discovered references in test files. ${coverageSummary} Fan-in for this file is ${fanIn}. Suggested command: ${suggestedCommand}`;
+        return {
+            file: symbol.file,
+            range: symbol.range,
+            kind: "untestedChange",
+            symbol: symbol.name,
+            details,
+            confidence,
+        };
+    });
+    for (const suggestion of suggestionEntries) {
+        if (suggestion)
+            suggestions.push(suggestion);
+    }
+    return suggestions;
+}
+function countParams(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return 0;
+    let count = 0;
+    let sawNonWhitespaceSinceLastComma = false;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    let typeAngleDepth = 0;
+    let stringQuote = null;
+    let escaped = false;
+    let inTypeAnnotation = false;
+    for (let i = 0; i < trimmed.length; i += 1) {
+        const ch = trimmed[i];
+        if (!ch)
+            continue;
+        if (stringQuote) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (ch === stringQuote) {
+                stringQuote = null;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            stringQuote = ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === "(") {
+            parenDepth += 1;
+            continue;
+        }
+        if (ch === ")") {
+            if (parenDepth > 0)
+                parenDepth -= 1;
+            continue;
+        }
+        if (ch === "[") {
+            bracketDepth += 1;
+            continue;
+        }
+        if (ch === "]") {
+            if (bracketDepth > 0)
+                bracketDepth -= 1;
+            continue;
+        }
+        if (ch === "{") {
+            braceDepth += 1;
+            continue;
+        }
+        if (ch === "}") {
+            if (braceDepth > 0)
+                braceDepth -= 1;
+            continue;
+        }
+        const atTopLevel = parenDepth === 0 && bracketDepth === 0 && braceDepth === 0 && typeAngleDepth === 0;
+        if (ch === ":") {
+            if (atTopLevel)
+                inTypeAnnotation = true;
+            continue;
+        }
+        if (ch === "=") {
+            if (atTopLevel)
+                inTypeAnnotation = false;
+            continue;
+        }
+        if (ch === "<") {
+            if (inTypeAnnotation)
+                typeAngleDepth += 1;
+            continue;
+        }
+        if (ch === ">") {
+            if (inTypeAnnotation && typeAngleDepth > 0)
+                typeAngleDepth -= 1;
+            continue;
+        }
+        if (ch === ",") {
+            if (atTopLevel && sawNonWhitespaceSinceLastComma) {
+                count += 1;
+                sawNonWhitespaceSinceLastComma = false;
+            }
+            inTypeAnnotation = false;
+            continue;
+        }
+        if (atTopLevel && !/\s/.test(ch)) {
+            sawNonWhitespaceSinceLastComma = true;
+        }
+    }
+    if (sawNonWhitespaceSinceLastComma)
+        count += 1;
+    return count;
+}
+function countNewlines(text) {
+    let count = 0;
+    for (let index = 0; index < text.length; index += 1) {
+        if (text.charCodeAt(index) === 10)
+            count += 1;
+    }
+    return count;
+}
+function readBalancedParenContent(text, openParenIndex) {
+    let depth = 0;
+    let quote = null;
+    let escaping = false;
+    for (let index = openParenIndex; index < text.length; index += 1) {
+        const ch = text[index];
+        if (quote) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escaping = true;
+                continue;
+            }
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === "`") {
+            quote = ch;
+            continue;
+        }
+        if (ch === "(") {
+            depth += 1;
+            continue;
+        }
+        if (ch === ")") {
+            depth -= 1;
+            if (!depth) {
+                return { content: text.slice(openParenIndex + 1, index), endIndex: index };
+            }
+        }
+    }
+    return null;
+}
+function functionSuffixStartsAfterParams(text, closeParenIndex) {
+    return /^\s*(?::|[{;])/.test(text.slice(closeParenIndex + 1));
+}
+function arrowSuffixStartsAfterParams(text, closeParenIndex) {
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let braceDepth = 0;
+    let angleDepth = 0;
+    let sawReturnTypeAnnotation = false;
+    for (let index = closeParenIndex + 1; index < text.length; index += 1) {
+        const ch = text[index];
+        if (!ch)
+            continue;
+        const atTopLevel = !parenDepth && !bracketDepth && !braceDepth && !angleDepth;
+        if (atTopLevel && ch === "=" && text[index + 1] === ">")
+            return true;
+        if (atTopLevel && (ch === ";" || ch === "\n" || ch === "\r"))
+            return false;
+        if (atTopLevel && ch === ":") {
+            sawReturnTypeAnnotation = true;
+            continue;
+        }
+        if (atTopLevel && !sawReturnTypeAnnotation && !/\s/.test(ch))
+            return false;
+        if (ch === "(") {
+            parenDepth += 1;
+            continue;
+        }
+        if (ch === ")") {
+            if (parenDepth)
+                parenDepth -= 1;
+            continue;
+        }
+        if (ch === "[") {
+            bracketDepth += 1;
+            continue;
+        }
+        if (ch === "]") {
+            if (bracketDepth)
+                bracketDepth -= 1;
+            continue;
+        }
+        if (ch === "{") {
+            braceDepth += 1;
+            continue;
+        }
+        if (ch === "}") {
+            if (braceDepth)
+                braceDepth -= 1;
+            continue;
+        }
+        if (ch === "<") {
+            angleDepth += 1;
+            continue;
+        }
+        if (ch === ">") {
+            if (angleDepth)
+                angleDepth -= 1;
+        }
+    }
+    return false;
+}
+function collectExportSignaturesFromText(text, hunkIndex, startLine) {
+    const output = [];
+    const pushMatch = (match, name, rawParams) => {
+        output.push({
+            name,
+            paramCount: countParams(rawParams),
+            hunkIndex,
+            line: startLine + countNewlines(text.slice(0, match.index)),
+        });
+    };
+    const scanText = maskJsLikeCommentsAndStrings(text);
+    const functionRe = /^\s*export\s+(?:default\s+)?(?:async\s+)?function\s*(?:\*\s*)?(?:([A-Za-z_$][\w$]*))?(?:\s*<[^>]+>)?\s*\(/gm;
+    for (let match; (match = functionRe.exec(scanText));) {
+        const params = readBalancedParenContent(scanText, functionRe.lastIndex - 1);
+        if (params && functionSuffixStartsAfterParams(scanText, params.endIndex)) {
+            pushMatch(match, match[1] ?? "default", params.content);
+            functionRe.lastIndex = params.endIndex + 1;
+        }
+    }
+    const arrowRe = /^\s*export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:<[^>]+>\s*)?\(/gm;
+    for (let match; (match = arrowRe.exec(scanText));) {
+        const name = match[1];
+        const params = readBalancedParenContent(scanText, arrowRe.lastIndex - 1);
+        if (name && params && arrowSuffixStartsAfterParams(scanText, params.endIndex)) {
+            pushMatch(match, name, params.content);
+            arrowRe.lastIndex = params.endIndex + 1;
+        }
+    }
+    const singleParamArrowRe = /^\s*export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?([A-Za-z_$][\w$]*)\s*=>/gm;
+    for (let match; (match = singleParamArrowRe.exec(scanText));) {
+        const name = match[1];
+        if (!name)
+            continue;
+        output.push({
+            name,
+            paramCount: 1,
+            hunkIndex,
+            line: startLine + countNewlines(text.slice(0, match.index)),
+        });
+    }
+    return output;
+}
+function detectExportSignatureChanges(change) {
+    const removed = [];
+    const added = [];
+    for (let hunkIndex = 0; hunkIndex < change.hunks.length; hunkIndex += 1) {
+        const hunk = change.hunks[hunkIndex];
+        const oldSideLines = [];
+        const newSideLines = [];
+        for (const rawLine of hunk.lines) {
+            if (rawLine.startsWith(" ")) {
+                const line = rawLine.slice(1);
+                oldSideLines.push(line);
+                newSideLines.push(line);
+                continue;
+            }
+            if (rawLine.startsWith("-")) {
+                oldSideLines.push(rawLine.slice(1));
+                continue;
+            }
+            if (rawLine.startsWith("+")) {
+                newSideLines.push(rawLine.slice(1));
+            }
+        }
+        removed.push(...collectExportSignaturesFromText(oldSideLines.join("\n"), hunkIndex, hunk.oldStart));
+        added.push(...collectExportSignaturesFromText(newSideLines.join("\n"), hunkIndex, hunk.newStart));
+    }
+    const addedByName = new Map();
+    const addedByHunk = new Map();
+    for (const entry of added) {
+        const byName = addedByName.get(entry.name);
+        if (byName)
+            byName.push(entry);
+        else
+            addedByName.set(entry.name, [entry]);
+        const byHunk = addedByHunk.get(entry.hunkIndex);
+        if (byHunk)
+            byHunk.push(entry);
+        else
+            addedByHunk.set(entry.hunkIndex, [entry]);
+    }
+    const bestAddedMatchForRemoved = (removedSig) => {
+        const sameName = addedByName.get(removedSig.name);
+        if (!sameName?.length)
+            return undefined;
+        let best = sameName[0];
+        let bestDistance = Number.POSITIVE_INFINITY;
+        for (const candidate of sameName) {
+            const hunkPenalty = candidate.hunkIndex === removedSig.hunkIndex ? 0 : 100_000;
+            const distance = hunkPenalty + Math.abs(candidate.line - removedSig.line);
+            if (distance < bestDistance) {
+                best = candidate;
+                bestDistance = distance;
+            }
+        }
+        return best;
+    };
+    const output = [];
+    for (const removedSig of removed) {
+        const matched = bestAddedMatchForRemoved(removedSig);
+        if (matched && matched.paramCount !== removedSig.paramCount) {
+            output.push({
+                name: removedSig.name,
+                details: `Exported function signature changed from ${removedSig.paramCount} parameter(s) to ${matched.paramCount}. This is likely a breaking API change.`,
+                confidence: "high",
+            });
+            continue;
+        }
+        if (!matched && added.length) {
+            const candidates = addedByHunk.get(removedSig.hunkIndex) ?? [];
+            const candidate = candidates.find((entry) => Math.abs(entry.line - removedSig.line) <= 3);
+            const renameDetails = candidate
+                ? `Exported symbol ${removedSig.name} appears to be removed or renamed (for example ${candidate.name}). Verify backward compatibility for downstream imports.`
+                : `Exported symbol ${removedSig.name} appears to be removed or renamed. Verify backward compatibility for downstream imports.`;
+            output.push({
+                name: removedSig.name,
+                details: renameDetails,
+                confidence: "medium",
+            });
+        }
+    }
+    return output;
+}
+async function loadCoverageByFile(projectRoot, options) {
+    const coverage = new Map();
+    const allPaths = [...(options?.lcovPaths ?? []), ...(options?.coveragePaths ?? [])];
+    if (!allPaths.length)
+        return coverage;
+    const ensureFileCoverage = (filePath) => {
+        const existing = coverage.get(filePath);
+        if (existing)
+            return existing;
+        const next = {
+            allLines: new Set(),
+            coveredLines: new Set(),
+        };
+        coverage.set(filePath, next);
+        return next;
+    };
+    const parseLcovText = (text) => {
+        let currentFile = null;
+        for (const rawLine of text.split(/\r?\n/)) {
+            if (rawLine.startsWith("SF:")) {
+                const filePath = rawLine.slice(3).trim();
+                currentFile = filePath ? normalizeImpactFilePath(projectRoot, filePath) : null;
+                continue;
+            }
+            if (!currentFile || !rawLine.startsWith("DA:"))
+                continue;
+            const parts = rawLine.slice(3).split(",");
+            const lineNo = Number(parts[0]);
+            const hits = Number(parts[1]);
+            if (!Number.isInteger(lineNo) || lineNo <= 0)
+                continue;
+            const fileCoverage = ensureFileCoverage(currentFile);
+            fileCoverage.allLines.add(lineNo);
+            if (Number.isFinite(hits) && hits > 0) {
+                fileCoverage.coveredLines.add(lineNo);
+            }
+        }
+    };
+    const parseIstanbulJson = (text) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        if (!parsed || typeof parsed !== "object")
+            return;
+        const entries = Object.entries(parsed);
+        for (const [fileKey, value] of entries) {
+            if (!value || typeof value !== "object")
+                continue;
+            const statementMap = value.statementMap;
+            const statements = value.s;
+            if (!statementMap || !statements)
+                continue;
+            if (typeof statementMap !== "object" || typeof statements !== "object") {
+                continue;
+            }
+            const normalizedFile = normalizeImpactFilePath(projectRoot, fileKey);
+            const fileCoverage = ensureFileCoverage(normalizedFile);
+            const mapEntries = Object.entries(statementMap);
+            for (const [statementId, rangeValue] of mapEntries) {
+                if (!rangeValue || typeof rangeValue !== "object")
+                    continue;
+                const start = rangeValue.start;
+                const end = rangeValue.end;
+                const startLineRaw = start?.line;
+                const endLineRaw = end?.line;
+                if (!Number.isInteger(startLineRaw) || !Number.isInteger(endLineRaw)) {
+                    continue;
+                }
+                const startLine = Number(startLineRaw);
+                const endLine = Number(endLineRaw);
+                const hitsRaw = statements[statementId];
+                const hits = typeof hitsRaw === "number" ? hitsRaw : 0;
+                for (let line = startLine; line <= endLine; line += 1) {
+                    fileCoverage.allLines.add(line);
+                    if (hits > 0)
+                        fileCoverage.coveredLines.add(line);
+                }
+            }
+        }
+    };
+    for (const coveragePath of allPaths) {
+        const abs = resolveFilePathFromRoot(projectRoot, coveragePath);
+        let text = "";
+        try {
+            text = await fs.readFile(abs, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const isJson = abs.toLowerCase().endsWith(".json");
+        if (isJson)
+            parseIstanbulJson(text);
+        else
+            parseLcovText(text);
+    }
+    return coverage;
+}
+function countLinesForRange(coverage, range, linesForCoverage) {
+    if (!coverage)
+        return 0;
+    let count = 0;
+    const lines = linesForCoverage(coverage);
+    for (let line = range.start.line; line <= range.end.line; line += 1) {
+        if (lines.has(line))
+            count += 1;
+    }
+    return count;
+}
+function countCoveredLinesForRange(coverage, range) {
+    return countLinesForRange(coverage, range, (entry) => entry.coveredLines);
+}
+function countTotalLinesForRange(coverage, range) {
+    return countLinesForRange(coverage, range, (entry) => entry.allLines);
+}
+export async function collectImpactReportSuggestions(projectRoot, index, options, normalizedChanges, changedSymbols) {
+    const suggestions = options.verifyReferences
+        ? await collectImpactSuggestions(index, projectRoot, normalizedChanges, options)
+        : [];
+    const configAndBreaking = options.configImpactRules || options.detectBreakingChanges
+        ? collectConfigAndBreakingSuggestions(index, projectRoot, normalizedChanges, changedSymbols, {
+            configImpactRules: !!options.configImpactRules,
+            detectBreakingChanges: !!options.detectBreakingChanges,
+        })
+        : [];
+    const coverageSuggestions = options.testCoverageSuggestions
+        ? await collectUntestedChangeSuggestions(index, changedSymbols, projectRoot, undefined, {
+            ...(options.lcovPaths ? { lcovPaths: options.lcovPaths } : {}),
+            ...(options.coveragePaths ? { coveragePaths: options.coveragePaths } : {}),
+            ...(options.testCommandTemplate ? { testCommandTemplate: options.testCommandTemplate } : {}),
+            ...(options.testPatterns ? { testPatterns: options.testPatterns } : {}),
+        })
+        : [];
+    return [...suggestions, ...configAndBreaking, ...coverageSuggestions];
+}
+//# sourceMappingURL=report-suggestions.js.map