grepmax 0.23.0 → 0.24.0

package/dist/lib/analysis/surprising-connections.js

@@ -0,0 +1,600 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SURPRISE_COLUMNS = exports.MAX_SURPRISE_ROWS = exports.DEFAULT_SURPRISE_OPTIONS = void 0;
+exports.normalizeSurpriseOptions = normalizeSurpriseOptions;
+exports.isTestPath = isTestPath;
+exports.isEvalPath = isEvalPath;
+exports.relPath = relPath;
+exports.lineLabel = lineLabel;
+exports.directoryBucket = directoryBucket;
+exports.findingBucketLabel = findingBucketLabel;
+exports.findingExamples = findingExamples;
+exports.formatPenaltySummary = formatPenaltySummary;
+exports.skeletonHint = skeletonHint;
+exports.scorePair = scorePair;
+exports.quantile = quantile;
+exports.stats = stats;
+exports.buildFindings = buildFindings;
+exports.analyzeSurprisingConnections = analyzeSurprisingConnections;
+const path = __importStar(require("node:path"));
+const callsites_1 = require("../graph/callsites");
+const arrow_1 = require("../utils/arrow");
+const scope_filter_1 = require("../utils/scope-filter");
+exports.DEFAULT_SURPRISE_OPTIONS = {
+    sample: 160,
+    neighbors: 20,
+    dirDepth: 3,
+    minSimilarity: 0,
+    maxRows: 50000,
+    includeTests: false,
+    includeEval: false,
+};
+exports.MAX_SURPRISE_ROWS = 100000;
+exports.SURPRISE_COLUMNS = [
+    "id",
+    "path",
+    "start_line",
+    "end_line",
+    "defined_symbols",
+    "referenced_symbols",
+    "type_referenced_symbols",
+    "role",
+    "content",
+    "vector",
+];
+const CODE_EXTENSIONS = new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".cs",
+    ".rb",
+    ".kt",
+    ".swift",
+    ".scala",
+    ".php",
+    ".c",
+    ".cc",
+    ".cpp",
+    ".h",
+    ".hpp",
+]);
+const TEST_DIR_RE = /(^|\/)(__tests__|tests?|specs?|benchmark)(\/|$)/i;
+const TEST_FILE_RE = /\.(test|spec)\.[cm]?[jt]sx?$/i;
+const NATIVE_TEST_DIR_RE = /(^|\/)\w+Tests?(\/|$)/;
+const NATIVE_TEST_FILE_RE = /Tests?\.(swift|kt|java)$/;
+function normalizeSurpriseOptions(opts = {}) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    return Object.assign(Object.assign(Object.assign({}, exports.DEFAULT_SURPRISE_OPTIONS), opts), { sample: Math.max(1, Math.floor((_a = opts.sample) !== null && _a !== void 0 ? _a : exports.DEFAULT_SURPRISE_OPTIONS.sample)), neighbors: Math.max(1, Math.floor((_b = opts.neighbors) !== null && _b !== void 0 ? _b : exports.DEFAULT_SURPRISE_OPTIONS.neighbors)), dirDepth: Math.max(1, Math.floor((_c = opts.dirDepth) !== null && _c !== void 0 ? _c : exports.DEFAULT_SURPRISE_OPTIONS.dirDepth)), minSimilarity: Math.max(0, (_d = opts.minSimilarity) !== null && _d !== void 0 ? _d : exports.DEFAULT_SURPRISE_OPTIONS.minSimilarity), maxRows: Math.max(1, Math.min(exports.MAX_SURPRISE_ROWS, Math.floor((_e = opts.maxRows) !== null && _e !== void 0 ? _e : exports.DEFAULT_SURPRISE_OPTIONS.maxRows))), includeTests: (_f = opts.includeTests) !== null && _f !== void 0 ? _f : exports.DEFAULT_SURPRISE_OPTIONS.includeTests, includeEval: (_g = opts.includeEval) !== null && _g !== void 0 ? _g : exports.DEFAULT_SURPRISE_OPTIONS.includeEval });
+}
+function isTestPath(filePath) {
+    return (TEST_DIR_RE.test(filePath) ||
+        TEST_FILE_RE.test(filePath) ||
+        NATIVE_TEST_DIR_RE.test(filePath) ||
+        NATIVE_TEST_FILE_RE.test(filePath));
+}
+function isEvalPath(filePath) {
+    return (/(^|\/)src\/eval[^/]*\.ts$/i.test(filePath) ||
+        /(^|\/)(benchmarks?|experiments|scripts)(\/|$)/i.test(filePath));
+}
+function relPath(absPath, prefix) {
+    return absPath.startsWith(prefix) ? absPath.slice(prefix.length) : absPath;
+}
+function lineLabel(row) {
+    const sym = row.definedSymbols[0] ? ` ${row.definedSymbols[0]}` : "";
+    return `${row.relPath}:${row.startLine + 1}${sym}`;
+}
+function directoryBucket(rel, depth) {
+    const dir = path.dirname(rel);
+    if (dir === ".")
+        return ".";
+    return dir.split(path.sep).slice(0, depth).join(path.sep) || ".";
+}
+function findingBucketLabel(finding, dirDepth) {
+    return `${directoryBucket(finding.fileA, dirDepth)}<->${directoryBucket(finding.fileB, dirDepth)}`;
+}
+function findingExamples(finding, limit = 2) {
+    var _a;
+    const examples = ((_a = finding.examples) === null || _a === void 0 ? void 0 : _a.length)
+        ? finding.examples
+        : [finding.representative];
+    return examples.slice(0, limit);
+}
+function formatPenaltySummary(parts) {
+    const entries = [
+        ["tiny", parts.tinyHelperPenalty],
+        ["type", parts.typeConstantPenalty],
+        ["wrapper", parts.wrapperPenalty],
+        ["generic", parts.genericSymbolPenalty],
+    ].filter(([, value]) => Number(value) > 0);
+    return entries.length === 0
+        ? "none"
+        : entries.map(([name, value]) => `${name}:${value}`).join(",");
+}
+function skeletonHint(finding) {
+    return `gmax skeleton ${JSON.stringify(finding.fileA)} | gmax skeleton ${JSON.stringify(finding.fileB)}`;
+}
+function isCodePath(filePath) {
+    return CODE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+function vectorLength(vector) {
+    if (!vector)
+        return 0;
+    if (Array.isArray(vector))
+        return vector.length;
+    if (ArrayBuffer.isView(vector)) {
+        const view = vector;
+        return typeof view.length === "number" ? view.length : view.byteLength;
+    }
+    if (typeof vector.length === "number") {
+        return Number(vector.length) || 0;
+    }
+    return 0;
+}
+function stableHash(s) {
+    let h = 2166136261;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return h >>> 0;
+}
+function rowKey(row) {
+    return row.id || `${row.path}:${row.startLine}`;
+}
+function pairKey(a, b) {
+    return [rowKey(a), rowKey(b)].sort().join("\0");
+}
+function filePairKey(a, b) {
+    return [a.path, b.path].sort().join("\0");
+}
+function primarySymbol(row) {
+    var _a;
+    return (_a = row.definedSymbols.find((symbol) => !(0, callsites_1.isBuiltinCallee)(symbol))) !== null && _a !== void 0 ? _a : "";
+}
+function symbolTokens(symbol) {
+    const spaced = symbol
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_-]+/g, " ")
+        .toLowerCase();
+    return new Set(spaced.split(/[^a-z0-9]+/).filter((token) => token.length > 1));
+}
+function exactSharedSymbols(a, b) {
+    const left = new Set(a.definedSymbols.filter((s) => !(0, callsites_1.isBuiltinCallee)(s)));
+    return b.definedSymbols.filter((s) => left.has(s) && !(0, callsites_1.isBuiltinCallee)(s));
+}
+function symbolShapeSimilarity(a, b) {
+    const left = symbolTokens(primarySymbol(a));
+    const right = symbolTokens(primarySymbol(b));
+    if (left.size === 0 || right.size === 0)
+        return 0;
+    let overlap = 0;
+    for (const token of left)
+        if (right.has(token))
+            overlap++;
+    const union = new Set([...left, ...right]).size;
+    return union === 0 ? 0 : overlap / union;
+}
+function lineCount(row) {
+    return Math.max(1, row.endLine - row.startLine + 1);
+}
+function isTinyHelper(row) {
+    return row.content.trim().length < 220 || lineCount(row) <= 8;
+}
+function isTypeLike(row) {
+    return /^(export\s+)?(type|interface)\s+/m.test(row.content.trim());
+}
+function isConstantLike(row) {
+    if (row.definedSymbols.length === 0)
+        return false;
+    return row.definedSymbols.every((symbol) => /^[A-Z][A-Z0-9_]{2,}$/.test(symbol) || /_RE$/.test(symbol));
+}
+const GENERIC_SYMBOLS = new Set([
+    "constructor",
+    "context",
+    "data",
+    "default",
+    "fmt",
+    "get",
+    "height",
+    "kind",
+    "main",
+    "new",
+    "options",
+    "rel",
+    "relpath",
+    "resolve",
+    "root",
+    "run",
+    "set",
+    "style",
+    "styles",
+    "toarray",
+    "tostringarray",
+    "type",
+    "types",
+    "value",
+    "values",
+    "width",
+]);
+function isGenericSymbol(symbol) {
+    const normalized = symbol.replace(/[^a-z0-9]/gi, "").toLowerCase();
+    return normalized.length <= 1 || GENERIC_SYMBOLS.has(normalized);
+}
+function isImplementationLike(row) {
+    if (isTypeLike(row) || isConstantLike(row))
+        return false;
+    return row.content.trim().length >= 300 && lineCount(row) >= 8;
+}
+function isCommandLibraryPair(a, b) {
+    return ((a.relPath.startsWith("src/commands/") &&
+        b.relPath.startsWith("src/lib/")) ||
+        (b.relPath.startsWith("src/commands/") && a.relPath.startsWith("src/lib/")));
+}
+function addReason(reasons, condition, reason) {
+    if (condition)
+        reasons.add(reason);
+}
+function scorePair(pair, pairCount) {
+    const sharedSymbols = exactSharedSymbols(pair.source, pair.target);
+    const sourcePrimary = primarySymbol(pair.source);
+    const targetPrimary = primarySymbol(pair.target);
+    const primaryMatch = sourcePrimary !== "" && sourcePrimary === targetPrimary;
+    const genericExactSymbol = (primaryMatch && isGenericSymbol(sourcePrimary)) ||
+        sharedSymbols.some((symbol) => isGenericSymbol(symbol));
+    const symbolShape = symbolShapeSimilarity(pair.source, pair.target);
+    const bothImplementation = isImplementationLike(pair.source) && isImplementationLike(pair.target);
+    const anyImplementation = isImplementationLike(pair.source) || isImplementationLike(pair.target);
+    const strongSymbol = !genericExactSymbol &&
+        (primaryMatch || sharedSymbols.length > 0 || symbolShape >= 0.5);
+    const sourceTiny = isTinyHelper(pair.source);
+    const targetTiny = isTinyHelper(pair.target);
+    const sourceTypeConstant = isTypeLike(pair.source) || isConstantLike(pair.source);
+    const targetTypeConstant = isTypeLike(pair.target) || isConstantLike(pair.target);
+    const commandWrapper = isCommandLibraryPair(pair.source, pair.target);
+    const reasons = new Set();
+    addReason(reasons, primaryMatch || sharedSymbols.length > 0, "same-symbol");
+    addReason(reasons, !primaryMatch && symbolShape >= 0.5, "similar-symbol");
+    addReason(reasons, bothImplementation, "implementation");
+    addReason(reasons, pairCount > 1, "multi-pair");
+    addReason(reasons, sourceTiny || targetTiny, "tiny-helper");
+    addReason(reasons, sourceTypeConstant || targetTypeConstant, "type-constant");
+    addReason(reasons, commandWrapper, "command-wrapper");
+    addReason(reasons, genericExactSymbol, "generic-symbol");
+    const sameSymbolBoost = genericExactSymbol
+        ? 0
+        : primaryMatch
+            ? 0.08
+            : sharedSymbols.length > 0
+                ? 0.05
+                : 0;
+    const symbolShapeBoost = !primaryMatch && sharedSymbols.length === 0 && symbolShape >= 0.5
+        ? Math.min(0.05, symbolShape * 0.08)
+        : 0;
+    const implementationBoost = bothImplementation
+        ? 0.04
+        : anyImplementation
+            ? 0.015
+            : 0;
+    const supportBoost = Math.min(0.06, Math.log2(pairCount + 1) * 0.018);
+    const tinyHelperBase = (sourceTiny ? 0.06 : 0) + (targetTiny ? 0.06 : 0);
+    const tinyHelperPenalty = strongSymbol
+        ? Math.min(0.04, tinyHelperBase / 2)
+        : Math.min(0.12, tinyHelperBase);
+    const typeConstantPenalty = Math.min(0.18, (sourceTypeConstant ? 0.09 : 0) + (targetTypeConstant ? 0.09 : 0));
+    const wrapperPenalty = commandWrapper ? 0.12 : 0;
+    const genericSymbolPenalty = genericExactSymbol ? 0.08 : 0;
+    const score = pair.similarity +
+        sameSymbolBoost +
+        symbolShapeBoost +
+        implementationBoost +
+        supportBoost -
+        tinyHelperPenalty -
+        typeConstantPenalty -
+        wrapperPenalty -
+        genericSymbolPenalty;
+    return {
+        base: Number(pair.similarity.toFixed(3)),
+        sameSymbolBoost: Number(sameSymbolBoost.toFixed(3)),
+        symbolShapeBoost: Number(symbolShapeBoost.toFixed(3)),
+        implementationBoost: Number(implementationBoost.toFixed(3)),
+        supportBoost: Number(supportBoost.toFixed(3)),
+        tinyHelperPenalty: Number(tinyHelperPenalty.toFixed(3)),
+        typeConstantPenalty: Number(typeConstantPenalty.toFixed(3)),
+        wrapperPenalty: Number(wrapperPenalty.toFixed(3)),
+        genericSymbolPenalty: Number(genericSymbolPenalty.toFixed(3)),
+        score: Number(score.toFixed(3)),
+        reasons: [...reasons].sort(),
+    };
+}
+function toChunkRow(raw, prefix) {
+    const absPath = String(raw.path || "");
+    return {
+        id: String(raw.id || ""),
+        path: absPath,
+        relPath: relPath(absPath, prefix),
+        startLine: Number(raw.start_line || 0),
+        endLine: Number(raw.end_line || 0),
+        role: String(raw.role || ""),
+        content: String(raw.content || ""),
+        vector: raw.vector,
+        definedSymbols: (0, arrow_1.toArr)(raw.defined_symbols),
+        referencedSymbols: (0, arrow_1.toArr)(raw.referenced_symbols),
+        typeReferencedSymbols: (0, arrow_1.toArr)(raw.type_referenced_symbols),
+    };
+}
+function similarityFromDistance(distance) {
+    return 1 / (1 + Math.max(0, distance));
+}
+function quantile(sortedAsc, q) {
+    if (sortedAsc.length === 0)
+        return 0;
+    const pos = (sortedAsc.length - 1) * q;
+    const base = Math.floor(pos);
+    const rest = pos - base;
+    const next = sortedAsc[base + 1];
+    return next !== undefined
+        ? sortedAsc[base] + rest * (next - sortedAsc[base])
+        : sortedAsc[base];
+}
+function stats(values) {
+    var _a, _b;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mean = sorted.length === 0 ? 0 : sorted.reduce((a, b) => a + b, 0) / sorted.length;
+    return {
+        min: Number(((_a = sorted[0]) !== null && _a !== void 0 ? _a : 0).toFixed(3)),
+        p50: Number(quantile(sorted, 0.5).toFixed(3)),
+        p90: Number(quantile(sorted, 0.9).toFixed(3)),
+        max: Number(((_b = sorted[sorted.length - 1]) !== null && _b !== void 0 ? _b : 0).toFixed(3)),
+        mean: Number(mean.toFixed(3)),
+    };
+}
+function buildFileEdges(rows) {
+    const defFiles = new Map();
+    for (const row of rows) {
+        for (const symbol of row.definedSymbols) {
+            if (!defFiles.has(symbol))
+                defFiles.set(symbol, new Set());
+            defFiles.get(symbol).add(row.path);
+        }
+    }
+    const edges = new Set();
+    for (const row of rows) {
+        const refs = new Set([
+            ...row.referencedSymbols,
+            ...row.typeReferencedSymbols,
+        ]);
+        for (const symbol of refs) {
+            if ((0, callsites_1.isBuiltinCallee)(symbol))
+                continue;
+            const files = defFiles.get(symbol);
+            if (!files || files.size !== 1)
+                continue;
+            const [targetFile] = files;
+            if (!targetFile || targetFile === row.path)
+                continue;
+            edges.add(`${row.path}\0${targetFile}`);
+        }
+    }
+    return edges;
+}
+function hasDirectFileEdge(edges, a, b) {
+    return edges.has(`${a.path}\0${b.path}`) || edges.has(`${b.path}\0${a.path}`);
+}
+function filterableCodeRow(row, opts) {
+    if (!row.path || !isCodePath(row.path))
+        return false;
+    if (!opts.includeTests && isTestPath(row.relPath))
+        return false;
+    if (!opts.includeEval && isEvalPath(row.relPath))
+        return false;
+    if (vectorLength(row.vector) === 0)
+        return false;
+    if (row.content.trim().length < 80)
+        return false;
+    return row.definedSymbols.length > 0;
+}
+function buildFindings(pairs) {
+    var _a;
+    const groups = new Map();
+    for (const pair of pairs) {
+        const key = filePairKey(pair.source, pair.target);
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(pair);
+    }
+    const findings = [];
+    for (const group of groups.values()) {
+        const scoredPairs = group.map((pair) => (Object.assign(Object.assign({}, pair), { scoreParts: scorePair(pair, group.length) })));
+        scoredPairs.sort((a, b) => b.scoreParts.score - a.scoreParts.score ||
+            b.similarity - a.similarity ||
+            a.distance - b.distance);
+        const representative = scoredPairs[0];
+        const files = [representative.source, representative.target].sort((a, b) => a.path.localeCompare(b.path));
+        const similaritiesAsc = group
+            .map((pair) => pair.similarity)
+            .sort((a, b) => a - b);
+        findings.push({
+            fileA: files[0].relPath,
+            fileB: files[1].relPath,
+            pairCount: group.length,
+            maxSimilarity: Number(((_a = similaritiesAsc[similaritiesAsc.length - 1]) !== null && _a !== void 0 ? _a : 0).toFixed(3)),
+            medianSimilarity: Number(quantile(similaritiesAsc, 0.5).toFixed(3)),
+            representative,
+            examples: scoredPairs.slice(0, 3),
+            score: representative.scoreParts.score,
+            reasons: representative.scoreParts.reasons,
+            topSimilarities: [...similaritiesAsc]
+                .reverse()
+                .slice(0, 5)
+                .map((value) => Number(value.toFixed(3))),
+        });
+    }
+    return findings.sort((a, b) => b.score - a.score ||
+        b.maxSimilarity - a.maxSimilarity ||
+        b.pairCount - a.pairCount ||
+        `${a.fileA}\0${a.fileB}`.localeCompare(`${b.fileA}\0${b.fileB}`));
+}
+function analyzeSurprisingConnections(table_1, projectRoot_1) {
+    return __awaiter(this, arguments, void 0, function* (table, projectRoot, partialOptions = {}) {
+        var _a;
+        const opts = normalizeSurpriseOptions(partialOptions);
+        const prefix = projectRoot.endsWith("/") ? projectRoot : `${projectRoot}/`;
+        const scope = (0, scope_filter_1.resolveScope)({
+            projectRoot,
+            in: opts.in,
+            exclude: opts.exclude,
+        });
+        const where = (0, scope_filter_1.buildScopeWhere)(scope);
+        const rawRows = (yield table
+            .query()
+            .select(exports.SURPRISE_COLUMNS)
+            .where(where)
+            .limit(opts.maxRows)
+            .toArray());
+        const rows = rawRows.map((row) => toChunkRow(row, prefix));
+        const codeRows = rows.filter((row) => filterableCodeRow(row, opts));
+        const fileEdges = buildFileEdges(rows);
+        const anchors = [...codeRows]
+            .sort((a, b) => stableHash(rowKey(a)) - stableHash(rowKey(b)))
+            .slice(0, opts.sample);
+        const filters = {
+            rawNeighbors: 0,
+            sameChunk: 0,
+            sameFile: 0,
+            nonCode: 0,
+            weakCode: 0,
+            tests: 0,
+            evalHarness: 0,
+            sameDirBucket: 0,
+            graphEdge: 0,
+            belowThreshold: 0,
+        };
+        const pairs = new Map();
+        for (const source of anchors) {
+            const neighbors = (yield table
+                .vectorSearch(source.vector)
+                .select([...exports.SURPRISE_COLUMNS, "_distance"])
+                .where(where)
+                .limit(opts.neighbors + 8)
+                .toArray());
+            for (const rawTarget of neighbors) {
+                filters.rawNeighbors++;
+                const target = toChunkRow(rawTarget, prefix);
+                if (rowKey(source) === rowKey(target)) {
+                    filters.sameChunk++;
+                    continue;
+                }
+                if (source.path === target.path) {
+                    filters.sameFile++;
+                    continue;
+                }
+                if (!isCodePath(target.path) || vectorLength(target.vector) === 0) {
+                    filters.nonCode++;
+                    continue;
+                }
+                if (target.content.trim().length < 80 ||
+                    target.definedSymbols.length === 0) {
+                    filters.weakCode++;
+                    continue;
+                }
+                if (!opts.includeTests && isTestPath(target.relPath)) {
+                    filters.tests++;
+                    continue;
+                }
+                if (!opts.includeEval && isEvalPath(target.relPath)) {
+                    filters.evalHarness++;
+                    continue;
+                }
+                if (directoryBucket(source.relPath, opts.dirDepth) ===
+                    directoryBucket(target.relPath, opts.dirDepth)) {
+                    filters.sameDirBucket++;
+                    continue;
+                }
+                if (hasDirectFileEdge(fileEdges, source, target)) {
+                    filters.graphEdge++;
+                    continue;
+                }
+                const distance = Number((_a = rawTarget._distance) !== null && _a !== void 0 ? _a : 0);
+                const similarity = similarityFromDistance(distance);
+                if (similarity < opts.minSimilarity) {
+                    filters.belowThreshold++;
+                    continue;
+                }
+                const key = pairKey(source, target);
+                const existing = pairs.get(key);
+                if (!existing || similarity > existing.similarity) {
+                    pairs.set(key, { similarity, distance, source, target });
+                }
+            }
+        }
+        const acceptedPairs = [...pairs.values()].sort((a, b) => a.distance - b.distance || b.similarity - a.similarity);
+        const findings = buildFindings(acceptedPairs);
+        return {
+            summary: {
+                projectRoot,
+                rows: rows.length,
+                codeRows: codeRows.length,
+                sampledAnchors: anchors.length,
+                graphFileEdges: fileEdges.size,
+                options: opts,
+                filters,
+                acceptedPairs: acceptedPairs.length,
+                acceptedFilePairs: findings.length,
+                similarity: stats(acceptedPairs.map((pair) => pair.similarity)),
+                distance: stats(acceptedPairs.map((pair) => pair.distance)),
+                actionabilityScore: stats(findings.map((finding) => finding.score)),
+            },
+            pairs: acceptedPairs,
+            findings,
+        };
+    });
+}