@skyramp/mcp 0.3.8 → 0.4.0-rc.1

package/build/utils/pathAffinityClassification.js

@@ -1,180 +0,0 @@
-/**
- * Path-affinity classification fallback — SKYR-3857.
- *
- * `classifyEndpointsByChangedFiles` (routeParsers.ts) matches changed files to
- * scanned endpoints by exact `sourceFile` equality. That match structurally fails
- * for an entire repository whenever the endpoint catalog carries no usable
- * `sourceFile` linkage for its route files — either because the framework isn't
- * (yet) handled by `parseFileEndpoints` (the repo scan contributes nothing for
- * those files), or because the catalog is predominantly spec-derived
- * (`filterEndpointsBySpec` merges in OpenAPI-only entries with `sourceFile: ""`).
- * In both cases every changed route file lands in `unmatchedFiles`, `changed`/
- * `new` counts stay at 0 for every PR touching that repo, and downstream
- * `hasApiChanges` derivation misclassifies genuinely mixed PRs as UI-only (see
- * testbot run 26968884237, koljahe/infisical PR #16 — Fastify backend, 1,972
- * spec-merged catalog entries, all with `sourceFile: ""`).
- *
- * This module recovers those files by matching on PATH instead of `sourceFile`:
- * for each unmatched, route-like changed file, it derives a resource token from
- * the file's own name and looks for catalog endpoints whose path implies the
- * same resource — narrowed by a version/prefix conjunction (see
- * `deriveVersionSegments`) so a file under `routes/v4/` cannot match a `/v1/`
- * or `/v2/` sibling endpoint just because the resource name lines up.
- *
- * Deliberately conservative: only fired for files `classifyEndpointsByChangedFiles`
- * already found nothing for (never overrides a real sourceFile match), and a file
- * with no surviving affinity match is left exactly as unmatched as it is today.
- * Every entry point here is fail-safe — a per-file error is logged and that file
- * is skipped, never thrown to the caller.
- *
- * KNOWN LIMITATION (conscious first-cut scope): matching is resource-token +
- * version/prefix only. It does not corroborate against literal relative-URL
- * string evidence in the changed file's content (route files quote their own
- * URL suffixes, e.g. `"/:secretName"`) — the token+version conjunction already
- * narrows precisely enough for the motivating case, and content-based
- * corroboration adds real complexity (multi-language quoting, template-literal
- * interpolation) for a marginal precision gain. Left as a follow-up if
- * real-world false positives surface.
- *
- * SKYR-3857 consolidation: both halves of the token matching are shared with
- * `importerHop.ts` rather than reimplemented here — `deriveResourceTokensForFile`
- * for the file side (which also gives this fallback symbol-based affinity: a
- * declared class/interface/schema name on an added diff line can anchor a match
- * for route files whose filename alone is too generic, e.g.
- * `routes/v4/index-router.ts`) and `endpointResourceTokens` for the endpoint
- * side. The version vocabulary comes from `isVersionLikeSegment` in
- * `routeParsers.ts`, next to the `SKIP_PATH_SEGMENTS` set it extends.
- */
-import { logger } from "./logger.js";
-import { isRouteLikeFile, isVersionLikeSegment } from "./routeParsers.js";
-import { isFrontendFile, isTestFile } from "../prompts/test-recommendation/scopeAssessment.js";
-import { deriveResourceTokensForFile, endpointResourceTokens, sliceAddedLinesByFile } from "./importerHop.js";
-/** Default cap on endpoints classified per unmatched file — keeps a broad/wrong
- * resource-token match from flooding the change set. */
-const DEFAULT_MAX_ENDPOINTS_PER_FILE = 15;
-/** 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 function deriveVersionSegments(file) {
-    const normalized = file.replace(/\\/g, "/");
-    const segments = normalized.split("/").filter(Boolean);
-    // Exclude the basename — the resource token is derived from it separately,
-    // and a hyphenated basename (e.g. "secret-v4-router.ts") isn't a directory.
-    const dirSegments = segments.slice(0, -1);
-    return new Set(dirSegments.filter(isVersionLikeSegment).map((s) => s.toLowerCase()));
-}
-/** Segments of an endpoint path, lowercased, for the version-conjunction check. */
-function endpointPathSegments(endpointPath) {
-    return new Set(endpointPath.split("/").filter(Boolean).map((s) => s.toLowerCase()));
-}
-/**
- * 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 function classifyUnmatchedFilesByPathAffinity(unmatchedFiles, scannedEndpoints, alreadyClassifiedEndpoints = [], maxEndpointsPerFile = DEFAULT_MAX_ENDPOINTS_PER_FILE, diffContent, removedEndpoints = []) {
-    const endpoints = [];
-    const mappedFiles = [];
-    const eligibleFiles = unmatchedFiles.filter((file) => !isFrontendFile(file) && !isTestFile(file) && isRouteLikeFile(file));
-    if (eligibleFiles.length === 0)
-        return { endpoints, mappedFiles };
-    const alreadyKeys = new Set(alreadyClassifiedEndpoints.map((ep) => `${ep.sourceFile}::${ep.path}`));
-    const addedKeys = new Set();
-    const addedLinesByFile = diffContent ? sliceAddedLinesByFile(diffContent) : undefined;
-    const removedMethodKeys = new Set();
-    const removedMultiPaths = new Set();
-    for (const ep of removedEndpoints) {
-        for (const method of ep.methods) {
-            if (method === "MULTI")
-                removedMultiPaths.add(ep.path);
-            else
-                removedMethodKeys.add(`${method}::${ep.path}`);
-        }
-    }
-    const isRemoved = (ep) => removedMultiPaths.has(ep.path) ||
-        (ep.methods.length > 0 && ep.methods.every((m) => removedMethodKeys.has(`${m}::${ep.path}`)));
-    // Endpoint-side tokens/segments depend only on the endpoint's own path —
-    // derive them once up front rather than per (file, endpoint) pair (the
-    // motivating spec-merged catalogs run to thousands of entries).
-    const endpointIndex = scannedEndpoints
-        .filter((ep) => !isRemoved(ep))
-        .map((ep) => ({
-        ep,
-        tokens: endpointResourceTokens(ep.path),
-        segments: endpointPathSegments(ep.path),
-    }));
-    for (const file of eligibleFiles) {
-        try {
-            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 requiredVersionSegments = deriveVersionSegments(file);
-            const candidates = endpointIndex.filter(({ tokens, segments }) => {
-                if (!resourceTokens.some((token) => tokens.has(token)))
-                    return false;
-                if (requiredVersionSegments.size === 0)
-                    return true;
-                return [...requiredVersionSegments].every((seg) => segments.has(seg));
-            });
-            if (candidates.length === 0)
-                continue;
-            const capped = candidates.slice(0, maxEndpointsPerFile);
-            for (const { ep } of capped) {
-                const key = `${ep.sourceFile}::${ep.path}`;
-                if (alreadyKeys.has(key) || addedKeys.has(key))
-                    continue;
-                addedKeys.add(key);
-                endpoints.push(ep);
-            }
-            mappedFiles.push(file);
-            logger.info("Path-affinity fallback classified endpoints for sourceFile-less file", {
-                file,
-                resourceTokens,
-                versionSegments: [...requiredVersionSegments],
-                matched: capped.length,
-                truncated: candidates.length > capped.length,
-            });
-        }
-        catch (err) {
-            logger.warning("Path-affinity classification failed for file — skipping", {
-                file,
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    return { endpoints, mappedFiles };
-}

package/build/utils/pythonMountPrefixes.d.ts

@@ -1,25 +0,0 @@
-/** Repo-relative POSIX path of a Python source file. */
-export type RelFile = string;
-/** A router variable name as written in source (e.g. "router"). */
-export type RouterVar = string;
-/** The ancestor mount prefix a router inherits from its include_router chain (e.g. "/api"). */
-export type MountPrefix = string;
-/**
- * `sourceFile → (routerVar → ancestor mount prefix)`, produced by
- * `resolvePythonMountPrefixes`. Only routers that inherit a non-empty ancestor
- * prefix appear; everything else is absent (single-file parsing is unchanged).
- */
-export type MountPrefixesByFile = Map<RelFile, Map<RouterVar, MountPrefix>>;
-/**
- * Join a prefix and a child path segment with exactly one slash, tolerating
- * leading/trailing slashes on either side. Empty child → the prefix unchanged;
- * empty prefix → the child made absolute.
- */
-export declare function joinRoutePrefix(prefix: string, child: string): string;
-/**
- * Build `sourceFile → (routerVar → ancestorMountPrefix)` for every FastAPI
- * router reachable through an `include_router` chain. Only non-empty ancestor
- * prefixes are returned, so files whose routers sit at the root are absent and
- * fall back to unchanged single-file parsing.
- */
-export declare function resolvePythonMountPrefixes(repositoryPath: string): MountPrefixesByFile;

package/build/utils/pythonMountPrefixes.js

@@ -1,347 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { walkSourceFiles } from "./fileWalk.js";
-import { logger } from "./logger.js";
-/**
- * Cross-file FastAPI mount-prefix resolution.
- *
- * FastAPI composes a route's full URL from prefixes applied at three levels:
- *   1. the router's own `APIRouter(prefix=…)` (captured per-file by
- *      `parseFileEndpoints`), and
- *   2. every `include_router(child, prefix=…)` / `app.include_router(child, …)`
- *      mount point the router passes through — which routinely live in *other*
- *      files (an `app.py` / `routes/__init__.py` aggregator).
- *
- * The single-file route parser can only see (1), so a leaf route declared as
- * `@router.get("")` on a `router = APIRouter(prefix="/recipes")` that an
- * aggregator mounts under `APIRouter(prefix="/api")` was emitted as `/recipes`
- * instead of `/api/recipes` — generated tests then hit the un-prefixed URL and
- * 405. (Seen on Mealie's endpoint catalog.)
- *
- * This module does a repo-level pre-pass: it parses every Python file for router
- * declarations, `include_router` mount edges, and the intra-repo imports that
- * connect them, then walks the mount graph to compute, for each router, the
- * **ancestor** prefix it inherits from its mount chain (NOT including the
- * router's own prefix, which `parseFileEndpoints` still applies). The result is
- * keyed by `sourceFile → routerVarName → ancestorPrefix`.
- *
- * Best-effort by design (mirrors the rest of the extractor): an import that
- * can't be resolved simply leaves that router as a graph root with an empty
- * ancestor prefix — i.e. it falls back to today's single-file behavior rather
- * than emitting a wrong path.
- */
-/** Skip these directory names when walking for Python sources. */
-const SKIP_DIRS = new Set([
-    "node_modules", ".git", "dist", "build", "out",
-    "venv", ".venv", "env", ".env", "__pycache__", ".tox",
-    "site-packages", ".mypy_cache", ".pytest_cache", "coverage",
-]);
-/** Cap on Python files parsed — a backstop against pathological repos. */
-const MAX_PY_FILES = 5000;
-/** Guard against cycles / runaway mount chains. */
-const MAX_MOUNT_DEPTH = 32;
-function nodeId(relFile, varName) {
-    return `${relFile}\n${varName}`;
-}
-/**
- * Join a prefix and a child path segment with exactly one slash, tolerating
- * leading/trailing slashes on either side. Empty child → the prefix unchanged;
- * empty prefix → the child made absolute.
- */
-export function joinRoutePrefix(prefix, child) {
-    const left = prefix.replace(/\/+$/, "");
-    const right = child.replace(/^\/+/, "");
-    if (!right)
-        return left;
-    if (!left)
-        return "/" + right;
-    return `${left}/${right}`;
-}
-function normalizeRel(p) {
-    return p.replace(/\\/g, "/");
-}
-/** Recursively collect `.py` files, returning repo-relative (posix) paths. */
-function collectPyFiles(repositoryPath) {
-    const abs = walkSourceFiles(repositoryPath, {
-        extensions: [".py"],
-        skipDirs: SKIP_DIRS,
-        limit: MAX_PY_FILES,
-    });
-    if (abs.length >= MAX_PY_FILES) {
-        logger.warning("resolvePythonMountPrefixes: hit MAX_PY_FILES cap — some Python files were not scanned, so cross-file mount prefixes may be under-resolved on this repo", { cap: MAX_PY_FILES });
-    }
-    return abs.map((full) => normalizeRel(full.startsWith(repositoryPath) ? full.slice(repositoryPath.length + 1) : full));
-}
-/**
- * Merge physical lines into logical lines, joining any line whose parentheses
- * are left open (multi-line `APIRouter(`, `include_router(`, and
- * `from x import ( … )`). String contents are not specially handled — a stray
- * paren inside a string literal is a rare edge that only degrades to a missed
- * prefix (fail-safe).
- */
-function toLogicalLines(content) {
-    const logical = [];
-    let buf = "";
-    let depth = 0;
-    for (const raw of content.split("\n")) {
-        const line = raw.replace(/#.*$/, ""); // drop trailing comments
-        buf = buf ? `${buf} ${line.trim()}` : line;
-        for (const ch of line) {
-            if (ch === "(" || ch === "[" || ch === "{")
-                depth++;
-            else if (ch === ")" || ch === "]" || ch === "}")
-                depth = Math.max(0, depth - 1);
-        }
-        if (depth === 0) {
-            logical.push(buf);
-            buf = "";
-        }
-    }
-    if (buf)
-        logical.push(buf);
-    return logical;
-}
-/**
- * Resolve an intra-repo Python module reference to a source file in `fileSet`.
- * `dots` is the leading-dot count (0 = absolute), `modulePath` the dotted
- * remainder (e.g. `mealie.routes` or `recipe`). Returns the repo-relative file
- * path or null when it can't be resolved to a known file.
- */
-function resolveModuleFile(fromRel, dots, modulePath, fileSet) {
-    const segments = modulePath ? modulePath.split(".").filter(Boolean) : [];
-    const candidates = [];
-    if (dots > 0) {
-        // Relative import: walk up `dots` directories from the current file's dir.
-        let base = path.posix.dirname(fromRel);
-        for (let i = 1; i < dots; i++)
-            base = path.posix.dirname(base);
-        const joined = [base === "." ? "" : base, ...segments].filter(Boolean).join("/");
-        candidates.push(`${joined}.py`, `${joined}/__init__.py`);
-    }
-    else {
-        // Absolute import: resolve from repo root, but also suffix-match so `src/`
-        // (or other package-root) layouts resolve too.
-        const joined = segments.join("/");
-        candidates.push(`${joined}.py`, `${joined}/__init__.py`);
-    }
-    for (const c of candidates) {
-        if (fileSet.has(c))
-            return c;
-    }
-    // Suffix fallback for absolute imports under a package root (e.g. src/).
-    if (dots === 0) {
-        const joined = segments.join("/");
-        const suffixes = [`/${joined}.py`, `/${joined}/__init__.py`];
-        for (const f of fileSet) {
-            if (suffixes.some((s) => f.endsWith(s)))
-                return f;
-        }
-    }
-    return null;
-}
-const ROUTER_DECL_RE = /^(\w+)\s*=\s*\w*APIRouter\s*\(/;
-const PREFIX_KW_RE = /(?:^|[,(\s])prefix\s*=\s*["']([^"']*)["']/;
-const CONST_RE = /^(\w+)\s*=\s*["']([^"']*)["']\s*$/;
-const IMPORT_FROM_RE = /^from\s+(\.*)([\w.]*)\s+import\s+(.+)$/;
-const IMPORT_RE = /^import\s+([\w.]+)(?:\s+as\s+(\w+))?/;
-const INCLUDE_ROUTER_RE = /(\w+)\.include_router\s*\(\s*([\w.]+)\s*(?:,(.*))?\)/;
-function parseImportedNames(blob) {
-    return blob
-        .replace(/[()]/g, "")
-        .split(",")
-        .map((s) => s.trim())
-        .filter(Boolean)
-        .map((tok) => {
-        const m = tok.match(/^(\w+)(?:\s+as\s+(\w+))?$/);
-        if (!m)
-            return null;
-        return { name: m[1], alias: m[2] ?? m[1] };
-    })
-        .filter((x) => x !== null);
-}
-function collectFileFacts(relFile, content, fileSet) {
-    const facts = {
-        ownPrefixes: new Map(),
-        stringConsts: new Map(),
-        moduleAlias: new Map(),
-        symbolAlias: new Map(),
-        mounts: [],
-    };
-    for (const line of toLogicalLines(content)) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        // Router declaration + its own prefix.
-        const decl = trimmed.match(ROUTER_DECL_RE);
-        if (decl) {
-            const pm = trimmed.match(PREFIX_KW_RE);
-            facts.ownPrefixes.set(decl[1], pm ? pm[1] : "");
-            // fall through: a declaration line has no include_router / import.
-        }
-        // Module-level string const (for prefix=CONST resolution).
-        const cm = trimmed.match(CONST_RE);
-        if (cm)
-            facts.stringConsts.set(cm[1], cm[2]);
-        // `from <module> import <names>`
-        const fromM = trimmed.match(IMPORT_FROM_RE);
-        if (fromM) {
-            const dots = fromM[1].length;
-            const modulePath = fromM[2];
-            const names = parseImportedNames(fromM[3]);
-            if (modulePath) {
-                // Symbols imported FROM a specific module (e.g. `from .x import router`).
-                const modFile = resolveModuleFile(relFile, dots, modulePath, fileSet);
-                if (modFile) {
-                    for (const { name, alias } of names) {
-                        facts.symbolAlias.set(alias, { file: modFile, varName: name });
-                    }
-                }
-            }
-            else if (dots > 0) {
-                // `from . import a, b` — each name is a submodule.
-                for (const { name, alias } of names) {
-                    const modFile = resolveModuleFile(relFile, dots, name, fileSet);
-                    if (modFile)
-                        facts.moduleAlias.set(alias, modFile);
-                }
-            }
-            continue;
-        }
-        // `import a.b.c as d`
-        const impM = trimmed.match(IMPORT_RE);
-        if (impM) {
-            const modFile = resolveModuleFile(relFile, 0, impM[1], fileSet);
-            if (modFile) {
-                const alias = impM[2] ?? impM[1].split(".")[0];
-                facts.moduleAlias.set(alias, modFile);
-            }
-            continue;
-        }
-        // include_router mount edges (a line may contain several).
-        let m;
-        const re = new RegExp(INCLUDE_ROUTER_RE, "g");
-        while ((m = re.exec(trimmed)) !== null) {
-            const prefixExpr = extractMountPrefixExpr(m[3] ?? "");
-            facts.mounts.push({ parentVar: m[1], arg: m[2], prefixExpr });
-        }
-    }
-    return facts;
-}
-/** Pull the `prefix=` argument (literal or bare identifier) out of the call tail. */
-function extractMountPrefixExpr(argsTail) {
-    const lit = argsTail.match(/prefix\s*=\s*["']([^"']*)["']/);
-    if (lit)
-        return JSON.stringify(lit[1]); // quote to mark it a literal
-    const ident = argsTail.match(/prefix\s*=\s*(\w+)/);
-    if (ident)
-        return ident[1]; // bare identifier — resolve against stringConsts
-    return null;
-}
-/** Resolve an `include_router` first-argument expression to a router NodeId. */
-function resolveMountArg(arg, relFile, facts) {
-    const parts = arg.split(".");
-    if (parts.length === 1) {
-        // Bare name: an imported symbol, else a router declared in this file.
-        const sym = facts.symbolAlias.get(parts[0]);
-        if (sym)
-            return nodeId(sym.file, sym.varName);
-        return nodeId(relFile, parts[0]);
-    }
-    // `mod.router` — module alias + attribute.
-    const modFile = facts.moduleAlias.get(parts[0]);
-    if (modFile)
-        return nodeId(modFile, parts[parts.length - 1]);
-    return null;
-}
-/**
- * Build `sourceFile → (routerVar → ancestorMountPrefix)` for every FastAPI
- * router reachable through an `include_router` chain. Only non-empty ancestor
- * prefixes are returned, so files whose routers sit at the root are absent and
- * fall back to unchanged single-file parsing.
- */
-export function resolvePythonMountPrefixes(repositoryPath) {
-    const pyFiles = collectPyFiles(repositoryPath);
-    const result = new Map();
-    if (pyFiles.length === 0)
-        return result;
-    const fileSet = new Set(pyFiles);
-    const factsByFile = new Map();
-    const ownPrefixByNode = new Map();
-    const edges = [];
-    for (const rel of pyFiles) {
-        let content;
-        try {
-            content = fs.readFileSync(path.join(repositoryPath, rel), "utf-8");
-        }
-        catch {
-            continue;
-        }
-        // Cheap gate: only parse files that actually wire routers together or
-        // declare one — avoids tokenizing the whole repo's Python.
-        if (!/include_router|APIRouter/.test(content))
-            continue;
-        const facts = collectFileFacts(rel, content, fileSet);
-        factsByFile.set(rel, facts);
-        for (const [varName, prefix] of facts.ownPrefixes) {
-            ownPrefixByNode.set(nodeId(rel, varName), prefix);
-        }
-    }
-    // Second pass: resolve mount edges now that every file's facts (imports,
-    // consts, router vars) are known.
-    for (const [rel, facts] of factsByFile) {
-        for (const mount of facts.mounts) {
-            const child = resolveMountArg(mount.arg, rel, facts);
-            if (!child)
-                continue;
-            let mountPrefix = "";
-            if (mount.prefixExpr !== null) {
-                if (mount.prefixExpr.startsWith('"')) {
-                    mountPrefix = JSON.parse(mount.prefixExpr);
-                }
-                else {
-                    mountPrefix = facts.stringConsts.get(mount.prefixExpr) ?? "";
-                }
-            }
-            edges.push({ parent: nodeId(rel, mount.parentVar), child, mountPrefix });
-        }
-    }
-    // First incoming edge wins (a router mounted in two places is rare; pick one
-    // deterministically rather than guessing a "primary" mount).
-    const incoming = new Map();
-    for (const e of edges) {
-        if (!incoming.has(e.child))
-            incoming.set(e.child, e);
-    }
-    const memo = new Map();
-    function ancestorPrefix(node, depth) {
-        if (depth > MAX_MOUNT_DEPTH)
-            return "";
-        const cached = memo.get(node);
-        if (cached !== undefined)
-            return cached;
-        memo.set(node, ""); // cycle guard: treat as root until resolved
-        const inc = incoming.get(node);
-        if (!inc)
-            return ""; // root — no inherited prefix
-        const parentAncestor = ancestorPrefix(inc.parent, depth + 1);
-        const parentOwn = ownPrefixByNode.get(inc.parent) ?? "";
-        const full = joinRoutePrefix(joinRoutePrefix(parentAncestor, parentOwn), inc.mountPrefix);
-        memo.set(node, full);
-        return full;
-    }
-    for (const node of ownPrefixByNode.keys()) {
-        const prefix = ancestorPrefix(node, 0);
-        if (!prefix)
-            continue; // root router — leave to single-file parsing
-        const sep = node.indexOf("\n");
-        const relFile = node.slice(0, sep);
-        const varName = node.slice(sep + 1);
-        let perFile = result.get(relFile);
-        if (!perFile) {
-            perFile = new Map();
-            result.set(relFile, perFile);
-        }
-        perFile.set(varName, prefix);
-    }
-    return result;
-}

package/build/utils/repoScanner.d.ts

@@ -1,34 +0,0 @@
-export interface ScannedEndpoint {
-    path: string;
-    methods: string[];
-    sourceFile: string;
-    /**
-     * 1-based line number of the route's declaration in `sourceFile`, when known.
-     * Used by hunk-aware diff scoping to attribute a changed line to the single
-     * route that owns it (rather than flagging every route in a touched file).
-     * Optional — absence disables scoping and falls back to file-level matching.
-     */
-    line?: number;
-}
-/**
- * Returns the relative paths of entry-point files that define the routing
- * hierarchy for this repository. The LLM reads these files in Step 1.5 to
- * trace router/module nesting and build an authoritative path resolution table.
- *
- * Intentionally returns only file paths — no extracted lines. Static regex
- * extraction is fragile and framework-specific; the LLM reads the files directly
- * and understands any framework's routing syntax.
- */
-export declare function grepRouterMountingContext(repositoryPath: string): string[];
-/**
- * Return relative paths of all source files that are likely to define API
- * routes. Two-pass strategy:
- *   1. Fast: filename matches ROUTE_FILE_PATTERN (no file I/O needed).
- *   2. Content: files not matched by name are read and checked for both a
- *      URL-path literal AND an HTTP method registration. This covers any
- *      framework the filename filter misses — Axum, Ktor, .NET, Hono, etc.
- * Result is capped at MAX_CANDIDATE_FILES to keep the LLM prompt bounded.
- */
-export declare function findCandidateRouteFiles(repositoryPath: string): string[];
-export declare function scanAllRepoEndpoints(repositoryPath: string): ScannedEndpoint[];
-export declare function scanRelatedEndpoints(repositoryPath: string, changedFiles: string[]): ScannedEndpoint[];