@skyramp/mcp 0.3.8 → 0.4.0-rc.1

package/build/utils/importerHop.js

@@ -1,489 +0,0 @@
-/**
- * Importer-hop endpoint classification — SKYR-3855 (backend half).
- *
- * `classifyEndpointsByChangedFiles` (routeParsers.ts) matches changed files to
- * scanned endpoints by exact `sourceFile` equality. A changed DTO/service/model
- * file — a non-route backend file that a route handler *imports* rather than
- * declares routes in — matches no endpoint and lands in `unmatchedFiles`. That
- * silently drops the change from `diffContext.modifiedEndpoints`, which makes
- * every drafted scenario classify as `novelty: existing` and the ranked plan
- * never mentions the actual change (see testbot run 27468308525 — immich PR
- * adding a derived `initials` field to `user.dto.ts`).
- *
- * This module "hops" one import edge: for each unmatched backend file, it
- * finds already-scanned endpoints whose source file textually imports the
- * changed file (via the same path-reference signature used by
- * `frontendIntegration.ts`), then narrows to endpoints that plausibly belong
- * to the same REST resource as the changed file (the "resource-affinity"
- * filter) — critical containment so a widely-imported DTO (e.g. immich's
- * `user.dto.ts`, imported by nearly every controller) doesn't flag the whole
- * endpoint catalog. If no candidate survives the affinity filter, the file is
- * left unmapped — conservative by design, matching the pre-existing
- * "unmatched" behavior rather than guessing.
- *
- * Every entry point here is fail-safe: any error for a given file is logged
- * and that file is simply skipped, never thrown to the caller.
- *
- * KNOWN LIMITATIONS (conscious first-cut scope — both no-op conservatively,
- * leaving classification exactly as it was pre-hop):
- * 1. Import edge is TS/JS path-quoted imports only. Python/Go/Java dotted or
- *    package imports produce zero signature hits (e.g. FastAPI's
- *    `schemas.actions.DeploymentCreate`). Language-aware signatures tracked
- *    in SKYR-3921's lane. Symbol-based affinity (see point 2) widens which
- *    candidates PASS the filter once an edge fires — it does not create new
- *    import-edge candidates, so this limitation stands on its own for
- *    Python/Go/Java until SKYR-3921/3929 lands.
- * 2. MITIGATED: affinity used to be FILENAME-only, so generic multi-DTO
- *    modules defeated it even when the edge fired: `schemas/actions.py`
- *    holding `DeploymentCreate` derived token "action", never matching
- *    `/deployments`. `deriveResourceTokensForFile` now additionally derives
- *    tokens from the changed SYMBOL names in the diff hunk
- *    (`class DeploymentCreate` -> "deployment"), and the affinity filter
- *    passes if an endpoint matches ANY derived token. Shared with the
- *    maintenance path — SKYR-3924 consumes `deriveResourceTokensForFile`
- *    directly for its own "changed DTO -> affected resource" signal, so the
- *    derivation lives here once rather than being duplicated.
- *
- * SKYR-3857 consolidation: pathAffinityClassification.ts's fallback used to
- * carry its own, basename-only `deriveFileResourceToken` derivation. It now
- * consumes `deriveResourceTokensForFile` directly (gaining symbol-based
- * affinity for route files for free), so this is the ONLY filename/symbol to
- * resource-token derivation in the codebase. `deriveResourceToken` here
- * additionally strips the route-ish filename suffixes ("-router"/"-routes"/
- * ".controller"/etc.) that module used to handle on its own, and
- * `GENERIC_RESOURCE_TOKENS` absorbed its generic-token vocabulary.
- */
-import * as fs from "fs";
-import * as path from "path";
-import { logger } from "./logger.js";
-import { extractResourceFromPath, isParamSegment, isVersionLikeSegment, SKIP_PATH_SEGMENTS } from "./routeParsers.js";
-import { sliceAddedLinesByFile } from "./branchDiff.js";
-import { buildPathSignatures, importsIndexModule, isIndexModule } from "./pathSignatures.js";
-import { singularize } from "./pluralization.js";
-import { isFrontendFile, isTestFile } from "../prompts/test-recommendation/scopeAssessment.js";
-const MAX_FILE_SIZE_BYTES = 512 * 1024;
-// Mirrors the small `SOURCE_EXTS` copies already living in routeParsers.ts and
-// analyzeChangesTool.ts — kept local rather than shared so each domain stays
-// independently tunable (same precedent as frontendIntegration.ts's own
-// FRONTEND_SOURCE_EXT_PATTERN, which is deliberately not shared either).
-const SOURCE_EXTS = /\.(ts|tsx|js|jsx|py|java|kt|go|rb|php|rs|cs|ex|exs)$/;
-// Common backend "framework layer" suffixes stripped before deriving a resource
-// token from a source file name — e.g. "user.dto.ts" -> "user",
-// "order.service.ts" -> "order", "UsersRepository.ts" handled via extension only.
-const FRAMEWORK_SUFFIX_RE = /\.(dto|service|controller|repository|entity|module|schema|model|resolver|gateway|guard|middleware|interceptor|mapper|serializer)$/i;
-// Route-ish suffix forms, merged in from pathAffinityClassification.ts's former
-// `ROUTE_FILE_SUFFIX_RE` during the SKYR-3857 derivation consolidation — e.g.
-// "secret-router.ts" -> "secret", "orders-routes.js" -> "order". Hyphen, dot,
-// or underscore delimited, since route-file naming conventions vary by
-// framework (Fastify favors hyphens, Nest/Angular favor dots). Applied after
-// FRAMEWORK_SUFFIX_RE in `deriveResourceToken` below; both regexes are
-// end-anchored, so together they only ever strip within the final path
-// segment — directory names are never touched.
-const ROUTE_SUFFIX_RE = /[-_.](?:router|routes?|controllers?|handlers?|endpoints?|resource|resources|api)$/i;
-// Resource tokens too generic to safely anchor the affinity filter — matching on
-// these would defeat its purpose (e.g. a shared base.service.ts imported everywhere).
-const GENERIC_RESOURCE_TOKENS = new Set([
-    "base", "common", "shared", "abstract", "index", "types", "utils", "helpers",
-    "constants", "config", "settings", "app", "main", "server", "core",
-    // Merged from pathAffinityClassification.ts's former GENERIC_RESOURCE_TOKENS
-    // (SKYR-3857 derivation consolidation) — route-file vocabulary that is
-    // structural, not resource-identifying, e.g. a bare "router.ts" or "api.ts".
-    "route", "router", "routes", "controller", "controllers", "handler",
-    "handlers", "endpoint", "endpoints", "api", "service", "gateway",
-    "resolver", "middleware", "resource", "resources",
-]);
-// Sibling to GENERIC_RESOURCE_TOKENS, for words split out of a declared SYMBOL
-// name rather than a filename — DTO/action/framework vocabulary that appears
-// inside class/type names constantly (e.g. "DeploymentCreate", "UserRequest")
-// but never identifies the resource itself. Checked in addition to
-// GENERIC_RESOURCE_TOKENS (a word generic enough to reject as a filename token
-// is equally generic as a symbol-word token).
-const GENERIC_SYMBOL_TOKENS = new Set([
-    "create", "update", "delete", "request", "response", "dto", "schema",
-    "input", "output", "type", "base", "params", "options", "config", "error",
-]);
-// Caps the token list `deriveResourceTokensForFile` returns so a single huge
-// schema/module file (many declared symbols) can't blow up the affinity
-// filter into matching nearly everything.
-const MAX_RESOURCE_TOKENS = 8;
-// Declared-symbol forms recognized on an ADDED diff line (leading "+"), in
-// the languages importer-hop already targets. Best-effort regex, not a
-// parser — mirrors the precedent set by TS_FIELD_RE/PY_FIELD_RE below. Method
-// and function declarations never match any of these (no "class"/"interface"/
-// "type"/"enum" keyword), so `getUsers(): User[] {` is correctly ignored.
-const TS_SYMBOL_DECL_RES = [
-    /^\+\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([A-Za-z_]\w*)/,
-    /^\+\s*(?:export\s+)?interface\s+([A-Za-z_]\w*)/,
-    /^\+\s*(?:export\s+)?type\s+([A-Za-z_]\w*)\s*=/,
-    /^\+\s*(?:export\s+)?(?:const\s+)?enum\s+([A-Za-z_]\w*)/,
-    // "schema-ish" export const — e.g. a zod DTO: `export const UserSchema = z.object({...})`.
-    /^\+\s*export\s+const\s+([A-Za-z_]\w*)\s*=\s*z\./,
-];
-const PY_SYMBOL_DECL_RE = /^\+\s*class\s+([A-Za-z_]\w*)/;
-/**
- * Extracts declared class/interface/type/enum/schema symbol names from an
- * array of raw added diff lines (each still prefixed with the unified-diff
- * `+` marker). Sibling to `extractFieldNamesFromAddedLines` — same
- * best-effort, non-parser contract — but looks for type-level declarations
- * instead of field/property assignments.
- */
-function extractDeclaredSymbolsFromAddedLines(lines) {
-    const symbols = new Set();
-    for (const line of lines) {
-        if (line.startsWith("++"))
-            continue; // "+++ b/file" diff header line
-        let name;
-        for (const re of TS_SYMBOL_DECL_RES) {
-            const match = re.exec(line);
-            if (match) {
-                name = match[1];
-                break;
-            }
-        }
-        if (!name)
-            name = PY_SYMBOL_DECL_RE.exec(line)?.[1];
-        if (name)
-            symbols.add(name);
-    }
-    return [...symbols];
-}
-/** Splits a CamelCase/PascalCase/snake_case symbol name into lowercase words —
- * "DeploymentCreate" -> ["Deployment", "Create"], "secret_version" -> ["secret", "version"],
- * "HTTPServer" -> ["HTTP", "Server"] (acronym-aware boundary). */
-function splitSymbolIntoWords(symbol) {
-    const withBoundaries = symbol
-        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
-        .replace(/_/g, " ");
-    return withBoundaries.split(/\s+/).filter(Boolean);
-}
-/** Splits a declared symbol into filtered, singularized resource-token
- * candidates — drops generic/framework words and tokens too short (<=2
- * chars) to safely anchor affinity. */
-function tokensFromSymbol(symbol) {
-    return splitSymbolIntoWords(symbol)
-        .map((word) => singularize(word.toLowerCase()))
-        .filter((token) => token.length > 2 &&
-        !GENERIC_SYMBOL_TOKENS.has(token) &&
-        !GENERIC_RESOURCE_TOKENS.has(token));
-}
-/**
- * Derives a singular, lowercase "resource token" from a backend source file
- * path — e.g. "src/dtos/user.dto.ts" -> "user",
- * "modules/orders/order.service.ts" -> "order". Strips the file extension and
- * a trailing framework-layer suffix, then reuses `extractResourceFromPath`'s
- * "last meaningful path segment" rule by treating the remaining slash-joined
- * path as if it were a URL path.
- */
-export function deriveResourceToken(file) {
-    const normalized = file.replace(/\\/g, "/");
-    const ext = path.extname(normalized);
-    const withoutExt = ext ? normalized.slice(0, -ext.length) : normalized;
-    const withoutSuffix = withoutExt.replace(FRAMEWORK_SUFFIX_RE, "").replace(ROUTE_SUFFIX_RE, "");
-    return singularize(extractResourceFromPath(withoutSuffix).toLowerCase());
-}
-/**
- * Derives ALL plausible resource-affinity tokens for a changed file: the
- * filename-derived token from `deriveResourceToken` (when it isn't generic),
- * plus tokens split out of any class/interface/type/enum/schema symbols
- * declared on the file's ADDED diff lines (when `diffHunk` is supplied).
- *
- * This is the sharper anchor requested on PR #588: a generic multi-DTO
- * module (`schemas/actions.py` holding `class DeploymentCreate`, `class
- * FlowCreate`, ...) has no single filename->resource mapping, but the
- * declared symbol name IS the resource — `DeploymentCreate` -> "deployment".
- * Same problem exists for TS (`types/common.ts` holding many interfaces).
- *
- * `diffHunk` is expected to be the file's own added-line slice (e.g. one
- * entry's lines from `sliceAddedLinesByFile`, joined with "\n") — this
- * function does not re-slice a full multi-file diff itself, to avoid
- * duplicating that walking logic in two places.
- *
- * Deduped; capped at `MAX_RESOURCE_TOKENS` so a huge schema file with many
- * declared symbols can't explode the affinity filter into a near-match-all.
- * With no `diffHunk` (or no symbols found), the result is exactly
- * `[deriveResourceToken(file)]` (or `[]` if that's generic/unknown) —
- * identical to today's filename-only behavior.
- */
-/**
- * Declared symbol names changed in a unified diff — from added-line declarations
- * AND from the hunk-header enclosing type (so a field-only edit to an existing class,
- * e.g. `DeploymentCreate.work_pool_name` → required, still yields `DeploymentCreate`).
- * Returns raw names, used both for resource-token derivation (via `tokensFromSymbol`)
- * and for content-grep matching against test bodies (SKYR-3924).
- */
-export function extractChangedSymbols(diffHunk) {
-    const lines = diffHunk.split("\n");
-    const symbols = new Set(extractDeclaredSymbolsFromAddedLines(lines.filter((line) => line.startsWith("+"))));
-    const HUNK_CTX_DECL = /^@@.*@@.*\b(?:class|struct|interface|type|enum)\s+([A-Za-z_]\w*)/;
-    for (const line of lines) {
-        if (!line.startsWith("@@"))
-            continue;
-        const m = HUNK_CTX_DECL.exec(line);
-        if (m)
-            symbols.add(m[1]);
-    }
-    return [...symbols];
-}
-export function deriveResourceTokensForFile(file, diffHunk) {
-    const tokens = [];
-    const seen = new Set();
-    const addToken = (token) => {
-        if (!token || seen.has(token))
-            return;
-        seen.add(token);
-        tokens.push(token);
-    };
-    const filenameToken = deriveResourceToken(file);
-    if (filenameToken && filenameToken !== "unknown" && !GENERIC_RESOURCE_TOKENS.has(filenameToken)) {
-        addToken(filenameToken);
-    }
-    if (diffHunk) {
-        for (const symbol of extractChangedSymbols(diffHunk)) {
-            for (const token of tokensFromSymbol(symbol))
-                addToken(token);
-        }
-    }
-    return tokens.slice(0, MAX_RESOURCE_TOKENS);
-}
-/**
- * All singular resource tokens implied by an endpoint path, used for affinity
- * matching against a `deriveResourceToken` result. Shared by the importer-hop
- * and path-affinity fallbacks (SKYR-3857) — the ONLY endpoint-path to
- * resource-token derivation in the codebase, mirroring how
- * `deriveResourceTokensForFile` is the only file-side one:
- *   - the primary (first non-skip, non-param, non-version) path segment —
- *     catches literal action-style segments like "/users/me", which
- *     `extractResourceFromPath`'s "last segment" rule would otherwise resolve
- *     to "me" instead of "users". Version-like segments are excluded via
- *     `isVersionLikeSegment` — `SKIP_PATH_SEGMENTS` covers "api"/"public" but
- *     only v1-v3, so without it any endpoint versioned beyond v3 would derive
- *     a nonsense token ("v4") as its resource.
- *   - `extractResourceFromPath`'s own result, split on "_" for the sub-resource
- *     composite form ("orders_items" -> "order", "item"). That function only
- *     recognizes OpenAPI-style "{param}" segments (its dedup-key callers see
- *     normalized paths), so ":id"/"[id]"-style params can flow through as its
- *     result — filtered here rather than widening a function whose other
- *     callers don't need it.
- */
-export function endpointResourceTokens(endpointPath) {
-    const tokens = new Set();
-    const segments = endpointPath.split("/").filter(Boolean);
-    const primary = segments.find((s) => !isParamSegment(s) && !SKIP_PATH_SEGMENTS.has(s.toLowerCase()) && !isVersionLikeSegment(s));
-    if (primary)
-        tokens.add(singularize(primary.toLowerCase()));
-    const composite = extractResourceFromPath(endpointPath).toLowerCase();
-    for (const part of composite.split("_")) {
-        if (part && !isParamSegment(part))
-            tokens.add(singularize(part));
-    }
-    return tokens;
-}
-/**
- * Maps unmatched changed files (from `classifyEndpointsByChangedFiles`) to
- * endpoints that import them, when the import target and the endpoint share
- * the same REST resource.
- *
- * `alreadyClassifiedEndpoints` (typically `changedEndpoints` + `newEndpoints`
- * from the same classification pass) is used purely for dedup — an endpoint
- * already classified directly is not duplicated into the returned `endpoints`
- * list, though the mapping is still established (harmless to skip re-adding
- * something already present).
- *
- * `diffContent`, when supplied, is the full unified diff — used to derive
- * per-file added-line hunks for `deriveResourceTokensForFile`'s symbol-based
- * affinity anchors (see module doc, limitation 2). Without it, affinity falls
- * back to the filename-only token, identical to pre-symbol-affinity behavior.
- */
-export function mapUnmatchedFilesToImporterEndpoints(repositoryPath, unmatchedFiles, scannedEndpoints, alreadyClassifiedEndpoints = [], diffContent) {
-    const endpoints = [];
-    const byFile = {};
-    const alreadyKeys = new Set(alreadyClassifiedEndpoints.map((ep) => `${ep.sourceFile}::${ep.path}`));
-    const addedKeys = new Set();
-    const addedLinesByFile = diffContent ? sliceAddedLinesByFile(diffContent) : undefined;
-    // Cache file contents across unmatched files — multiple changed files may be
-    // imported by the same controller/service, and controllers can be large.
-    const contentCache = new Map();
-    const readCached = (sourceFile) => {
-        if (contentCache.has(sourceFile))
-            return contentCache.get(sourceFile);
-        let content = null;
-        try {
-            const abs = path.isAbsolute(sourceFile) ? sourceFile : path.join(repositoryPath, sourceFile);
-            const stat = fs.statSync(abs);
-            if (stat.size <= MAX_FILE_SIZE_BYTES) {
-                content = fs.readFileSync(abs, "utf-8");
-            }
-        }
-        catch {
-            content = null; // unreadable / too large — tolerate, treat as no content to match against
-        }
-        contentCache.set(sourceFile, content);
-        return content;
-    };
-    for (const file of unmatchedFiles) {
-        try {
-            if (isFrontendFile(file) || isTestFile(file) || !SOURCE_EXTS.test(file))
-                continue;
-            const fileAddedLines = addedLinesByFile?.get(file);
-            const diffHunk = fileAddedLines && fileAddedLines.length > 0 ? fileAddedLines.join("\n") : undefined;
-            const resourceTokens = deriveResourceTokensForFile(file, diffHunk);
-            if (resourceTokens.length === 0)
-                continue;
-            const signatures = buildPathSignatures(file);
-            // For an index module the directory stem is a plain string match, so also
-            // require the specifier to resolve to this module's directory.
-            const indexModule = isIndexModule(file);
-            const rawCandidates = scannedEndpoints.filter((ep) => {
-                const content = readCached(ep.sourceFile);
-                if (content === null || !signatures.some((sig) => content.includes(sig)))
-                    return false;
-                return !indexModule || importsIndexModule(ep.sourceFile, content, file);
-            });
-            if (rawCandidates.length === 0)
-                continue;
-            // Critical containment: only keep candidates whose own resource affinity
-            // matches ANY of this file's resource tokens (filename OR symbol-derived
-            // — see deriveResourceTokensForFile). If nothing survives, flag NOTHING
-            // for this file — conservative, preserves today's "unmatched" behavior
-            // rather than guessing.
-            const affineCandidates = rawCandidates.filter((ep) => {
-                const epTokens = endpointResourceTokens(ep.path);
-                return resourceTokens.some((token) => epTokens.has(token));
-            });
-            if (affineCandidates.length === 0)
-                continue;
-            const mappedPaths = [];
-            for (const ep of affineCandidates) {
-                const key = `${ep.sourceFile}::${ep.path}`;
-                mappedPaths.push(ep.path);
-                if (alreadyKeys.has(key) || addedKeys.has(key))
-                    continue;
-                addedKeys.add(key);
-                endpoints.push(ep);
-            }
-            if (mappedPaths.length > 0) {
-                byFile[file] = [...new Set(mappedPaths)];
-            }
-        }
-        catch (err) {
-            logger.warning("Importer-hop classification failed for file — skipping", {
-                file,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    return { endpoints, byFile };
-}
-/**
- * Builds the inputs `draftResponseShapeScenarios` needs from an
- * {@link ImporterHopResult}, keyed off `byFile` rather than `endpoints`.
- *
- * `hopResult.endpoints` is deduped against endpoints already present in
- * `changedEndpoints`/`newEndpoints` (see `mapUnmatchedFilesToImporterEndpoints`),
- * so it can be empty — or missing entries — even when `byFile` holds valid
- * path mappings (e.g. a controller and the DTO it imports both changed in the
- * same PR: the controller's endpoint is already classified directly, so the
- * hop drops it from `endpoints`, but `byFile` still records the mapping).
- * Response-shape drafting wants every hop-mapped endpoint regardless of
- * whether it was newly added to the change set, so this re-derives the
- * endpoint list from `scannedEndpoints` filtered to the paths `byFile` maps
- * to, instead of relying on the deduped `endpoints` array.
- */
-export function buildHopResponseShapeInputs(hopResult, scannedEndpoints, diffContent) {
-    const mappedPaths = new Set(Object.values(hopResult.byFile).flat());
-    if (mappedPaths.size === 0)
-        return { endpoints: [], addedFieldsByFile: {} };
-    return {
-        endpoints: scannedEndpoints.filter((ep) => mappedPaths.has(ep.path)),
-        addedFieldsByFile: diffContent
-            ? computeAddedFieldsByFile(diffContent, Object.keys(hopResult.byFile))
-            : {},
-    };
-}
-// ── Added-field extraction from diff hunks ──────────────────────────────────
-const TS_FIELD_RE = /^\+\s*(?:public |readonly |private )?([A-Za-z_]\w*)\??!?\s*[:=]/;
-const PY_FIELD_RE = /^\+\s*([a-z_]\w*)\s*:\s*\w+/;
-// Words that can precede a bare colon/equals in real code without being a
-// field/property declaration (control-flow keywords, declarations, labels).
-const NON_FIELD_KEYWORDS = new Set([
-    "if", "for", "while", "return", "const", "let", "var",
-    "import", "export", "function", "class", "case", "default",
-    "else", "switch", "do", "try", "catch", "finally",
-]);
-/**
- * Extracts likely property/field names from an array of raw added diff lines
- * (each still prefixed with the unified-diff `+` marker). Best-effort regex,
- * not a parser — intended to give a scenario a field name to name-drop, not
- * to be exhaustive.
- */
-export function extractFieldNamesFromAddedLines(lines) {
-    const fields = new Set();
-    for (const line of lines) {
-        // A genuine content line never starts with a second "+" — that's the
-        // "+++ b/file" diff header line.
-        if (line.startsWith("++"))
-            continue;
-        const match = TS_FIELD_RE.exec(line) ?? PY_FIELD_RE.exec(line);
-        if (!match)
-            continue;
-        const name = match[1];
-        if (NON_FIELD_KEYWORDS.has(name.toLowerCase()))
-            continue;
-        fields.add(name);
-    }
-    return [...fields];
-}
-// `sliceAddedLinesByFile` now lives in `branchDiff.ts` (imported above) — moved
-// there so modules this one already imports can reuse it without an import
-// cycle. Re-exported here so existing importers of it from this module
-// (pathAffinityClassification.ts) don't need to change their import path.
-export { sliceAddedLinesByFile };
-/**
- * Splits a unified diff into per-file raw sections — every line after a file's
- * `diff --git` header up to the next one — keyed by the `b/` (post-change) path.
- * Unlike `sliceAddedLinesByFile` (added lines only), this preserves the `@@`
- * hunk headers, so `extractChangedSymbols`' enclosing-type extraction (which
- * reads `@@ ... class Foo`) still works when a single file's section is passed
- * to `deriveResourceTokensForFile`. Use this for per-file token derivation that
- * must not mix symbols across files in a multi-file diff (SKYR-3924).
- */
-export function sliceDiffByFile(diffContent) {
-    const sections = new Map();
-    let currentFile = null;
-    for (const line of diffContent.split("\n")) {
-        const headerMatch = /^diff --git a\/.+ b\/(.+)$/.exec(line);
-        if (headerMatch) {
-            currentFile = headerMatch[1];
-            sections.set(currentFile, []);
-            continue;
-        }
-        if (currentFile)
-            sections.get(currentFile).push(line);
-    }
-    const joined = new Map();
-    for (const [file, lines] of sections)
-        joined.set(file, lines.join("\n"));
-    return joined;
-}
-/**
- * Computes added-field names per file for the given files, from a full
- * unified diff. Files with no added-line matches are omitted from the result
- * (an empty field list is a valid, expected outcome — the caller still drafts
- * a scenario, just without field hints).
- */
-export function computeAddedFieldsByFile(diffContent, files) {
-    const result = {};
-    if (!diffContent || files.length === 0)
-        return result;
-    const sections = sliceAddedLinesByFile(diffContent);
-    for (const file of files) {
-        const addedLines = sections.get(file);
-        if (!addedLines || addedLines.length === 0)
-            continue;
-        const names = extractFieldNamesFromAddedLines(addedLines);
-        if (names.length > 0)
-            result[file] = names;
-    }
-    return result;
-}

package/build/utils/pathAffinityClassification.d.ts

@@ -1,49 +0,0 @@
-import type { ScannedEndpoint } from "./repoScanner.js";
-/** Version/prefix directory segments ("v4", "api", ...) present in a changed
- * file's own path — required, as a conjunction, in any matching endpoint path.
- * Prevents a `routes/v4/secret-router.ts` change from matching a `/api/v1/*`
- * sibling endpoint on resource-token alone. */
-export declare function deriveVersionSegments(file: string): Set<string>;
-export interface PathAffinityFallbackResult {
-    /** Endpoints newly classified via path affinity, deduped against `alreadyClassifiedEndpoints`. */
-    endpoints: ScannedEndpoint[];
-    /** Unmatched files that mapped to at least one endpoint (for unmatched-state cleanup). */
-    mappedFiles: string[];
-}
-/**
- * Maps changed files that `classifyEndpointsByChangedFiles` could not match by
- * `sourceFile` (its `unmatchedFiles`) to catalog endpoints that plausibly belong
- * to the same REST resource, purely from the file's own path and the endpoint's
- * own path — no `sourceFile` needed on either side. Intended to run against the
- * *final* endpoint catalog (after any OpenAPI spec merge), since a catalog with
- * no source-scan coverage for a file is, by definition, only useful for this
- * fallback once spec-derived entries are present to match against.
- *
- * `alreadyClassifiedEndpoints` (typically `changedEndpoints` + `newEndpoints`
- * from the same classification pass) is used only for dedup — never duplicates
- * an endpoint already classified directly.
- *
- * `diffContent`, when supplied, is the full unified diff — sliced per-file
- * (via `sliceAddedLinesByFile`, shared with `mapUnmatchedFilesToImporterEndpoints`)
- * and passed to `deriveResourceTokensForFile` so a route file whose filename
- * alone is too generic to anchor a match (e.g. `routes/v4/index-router.ts`)
- * can still match via a symbol declared on its added diff lines. Without it,
- * matching falls back to the filename-only token, identical to pre-symbol-
- * affinity behavior.
- *
- * `removedEndpoints` (the classifier's removal result, recovered from the base
- * tree) is excluded from the candidate set BY PATH+METHOD, not via the
- * sourceFile-keyed dedup: removal is classified at Step 2.5 against the
- * pre-spec-merge catalog, but this fallback matches the post-spec-merge
- * catalog — where a stale checked-in OpenAPI spec can still list a deleted
- * endpoint as a `sourceFile: ""` entry. Without this guard, a sibling
- * unmatched file sharing the resource token would resurrect the removed
- * endpoint as "modified", contradicting the removal classification. A `MULTI`
- * removed method covers every method on that path; a candidate survives if
- * any of its methods is not removed.
- *
- * Matched endpoints are always attributed as MODIFIED (never new/removed) —
- * path affinity says an endpoint is *related* to the change, not that the
- * relationship is an addition or removal.
- */
-export declare function classifyUnmatchedFilesByPathAffinity(unmatchedFiles: string[], scannedEndpoints: ScannedEndpoint[], alreadyClassifiedEndpoints?: ScannedEndpoint[], maxEndpointsPerFile?: number, diffContent?: string, removedEndpoints?: ScannedEndpoint[]): PathAffinityFallbackResult;