@skyramp/mcp 0.3.0-rc.1 → 0.3.0

package/build/utils/importerHop.js

@@ -216,6 +216,26 @@ export function deriveResourceToken(file) {
  * `[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();
@@ -230,9 +250,7 @@ export function deriveResourceTokensForFile(file, diffHunk) {
         addToken(filenameToken);
     }
     if (diffHunk) {
-        const addedLines = diffHunk.split("\n").filter((line) => line.startsWith("+"));
-        const symbols = extractDeclaredSymbolsFromAddedLines(addedLines);
-        for (const symbol of symbols) {
+        for (const symbol of extractChangedSymbols(diffHunk)) {
             for (const token of tokensFromSymbol(symbol))
                 addToken(token);
         }
@@ -459,6 +477,33 @@ export function sliceAddedLinesByFile(diffContent) {
     }
     return sections;
 }
+/**
+ * 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

package/build/utils/importerHop.test.js

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import { mapUnmatchedFilesToImporterEndpoints, deriveResourceToken, deriveResourceTokensForFile, endpointResourceTokens, extractFieldNamesFromAddedLines, computeAddedFieldsByFile, buildHopResponseShapeInputs, } from "./importerHop.js";
+import { mapUnmatchedFilesToImporterEndpoints, deriveResourceToken, deriveResourceTokensForFile, endpointResourceTokens, extractFieldNamesFromAddedLines, computeAddedFieldsByFile, extractChangedSymbols, sliceDiffByFile, buildHopResponseShapeInputs, } from "./importerHop.js";
 /** Creates a plain (non-git) tmp dir with the given files — mapUnmatchedFilesToImporterEndpoints
  * reads files directly off disk, no git grep involved. */
 function makeFixtureDir(files) {
@@ -397,3 +397,73 @@ describe("computeAddedFieldsByFile", () => {
         expect(computeAddedFieldsByFile("some diff", [])).toEqual({});
     });
 });
+describe("extractChangedSymbols", () => {
+    it("extracts a class declared on an added line (python)", () => {
+        expect(extractChangedSymbols("+class DeploymentCreate(ActionBaseModel):")).toEqual([
+            "DeploymentCreate",
+        ]);
+    });
+    it("extracts TS interface/type/enum/zod-schema declared on added lines", () => {
+        expect(extractChangedSymbols("+export interface UserDto {")).toEqual(["UserDto"]);
+        expect(extractChangedSymbols("+type FlowRunFilter = {")).toEqual(["FlowRunFilter"]);
+        expect(extractChangedSymbols("+export enum WorkPoolType {")).toEqual(["WorkPoolType"]);
+        expect(extractChangedSymbols("+export const UserSchema = z.object({")).toEqual(["UserSchema"]);
+    });
+    it("extracts the enclosing type from the @@ hunk header when only a field changed (SKYR-3924)", () => {
+        // A field-only edit yields no declaration on the added line — the class name
+        // survives only in the hunk-context header, which is exactly the schema/DTO case.
+        const hunk = [
+            "@@ -10,6 +10,7 @@ class DeploymentCreate(ActionBaseModel):",
+            "     name: str",
+            "+    work_pool_name: str = Field(default=...)",
+            "     flow_id: UUID",
+        ].join("\n");
+        expect(extractChangedSymbols(hunk)).toEqual(["DeploymentCreate"]);
+    });
+    it("dedups a symbol that appears in both an added declaration and the hunk header", () => {
+        const hunk = [
+            "@@ -1,3 +1,4 @@ class DeploymentCreate(ActionBaseModel):",
+            "+class DeploymentCreate(ActionBaseModel):",
+        ].join("\n");
+        expect(extractChangedSymbols(hunk)).toEqual(["DeploymentCreate"]);
+    });
+    it("returns an empty array when no type-level declaration is present", () => {
+        const hunk = ["@@ -1,2 +1,3 @@ def create_deployment():", "+    work_pool_name = None"].join("\n");
+        expect(extractChangedSymbols(hunk)).toEqual([]);
+    });
+});
+describe("sliceDiffByFile", () => {
+    const multiFileDiff = [
+        "diff --git a/src/schemas/actions.py b/src/schemas/actions.py",
+        "--- a/src/schemas/actions.py",
+        "+++ b/src/schemas/actions.py",
+        "@@ -10,6 +10,7 @@ class DeploymentCreate(ActionBaseModel):",
+        "     name: str",
+        "+    work_pool_name: str = Field(default=...)",
+        "diff --git a/src/schemas/core.py b/src/schemas/core.py",
+        "--- a/src/schemas/core.py",
+        "+++ b/src/schemas/core.py",
+        "@@ -1,2 +1,3 @@",
+        "+class WorkPool(ORMBaseModel):",
+    ].join("\n");
+    it("keys sections by the b/ path and isolates each file's lines", () => {
+        const sections = sliceDiffByFile(multiFileDiff);
+        expect([...sections.keys()]).toEqual(["src/schemas/actions.py", "src/schemas/core.py"]);
+        expect(sections.get("src/schemas/actions.py")).toContain("work_pool_name");
+        expect(sections.get("src/schemas/actions.py")).not.toContain("WorkPool");
+    });
+    it("preserves @@ hunk headers within each file section", () => {
+        const sections = sliceDiffByFile(multiFileDiff);
+        expect(sections.get("src/schemas/actions.py")).toContain("@@ -10,6 +10,7 @@ class DeploymentCreate(ActionBaseModel):");
+    });
+    it("keeps a symbol declared in one file out of another file's derived symbols", () => {
+        // The mixing bug: symbols from core.py must not leak into actions.py's slice.
+        const sections = sliceDiffByFile(multiFileDiff);
+        expect(extractChangedSymbols(sections.get("src/schemas/actions.py"))).toEqual([
+            "DeploymentCreate",
+        ]);
+        expect(extractChangedSymbols(sections.get("src/schemas/core.py"))).toEqual(["WorkPool"]);
+        // Whereas the full multi-file diff mixes both.
+        expect(extractChangedSymbols(multiFileDiff).sort()).toEqual(["DeploymentCreate", "WorkPool"]);
+    });
+});

package/build/utils/pythonMountPrefixes.d.ts

@@ -0,0 +1,25 @@
+/** 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

@@ -0,0 +1,347 @@
+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/pythonMountPrefixes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/utils/pythonMountPrefixes.test.js

@@ -0,0 +1,113 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { joinRoutePrefix, resolvePythonMountPrefixes } from "./pythonMountPrefixes.js";
+describe("joinRoutePrefix", () => {
+    it("composes with exactly one slash regardless of surrounding slashes", () => {
+        expect(joinRoutePrefix("/api", "/recipes")).toBe("/api/recipes");
+        expect(joinRoutePrefix("/api/", "recipes")).toBe("/api/recipes");
+        expect(joinRoutePrefix("/api", "recipes/")).toBe("/api/recipes/");
+    });
+    it("returns the prefix unchanged for an empty child", () => {
+        expect(joinRoutePrefix("/api", "")).toBe("/api");
+    });
+    it("makes the child absolute for an empty prefix", () => {
+        expect(joinRoutePrefix("", "/recipes")).toBe("/recipes");
+        expect(joinRoutePrefix("", "recipes")).toBe("/recipes");
+    });
+});
+describe("resolvePythonMountPrefixes", () => {
+    const tempRepos = [];
+    afterEach(() => {
+        for (const repo of tempRepos.splice(0)) {
+            fs.rmSync(repo, { recursive: true, force: true });
+        }
+    });
+    function makeRepo(files) {
+        const repo = fs.mkdtempSync(path.join(os.tmpdir(), "py-mount-"));
+        tempRepos.push(repo);
+        for (const [rel, content] of Object.entries(files)) {
+            const full = path.join(repo, rel);
+            fs.mkdirSync(path.dirname(full), { recursive: true });
+            fs.writeFileSync(full, content);
+        }
+        return repo;
+    }
+    it("resolves a relative-import mount chain to the ancestor prefix", () => {
+        const repo = makeRepo({
+            "app/__init__.py": `
+from fastapi import APIRouter
+from . import users
+
+router = APIRouter(prefix="/api")
+router.include_router(users.router)
+`,
+            "app/users.py": `
+from fastapi import APIRouter
+router = APIRouter(prefix="/users")
+@router.get("")
+def list_users(): pass
+`,
+        });
+        const result = resolvePythonMountPrefixes(repo);
+        // users.router inherits "/api" (aggregator own prefix); its own "/users" is
+        // applied later by parseFileEndpoints, so it is NOT part of the ancestor.
+        expect(result.get("app/users.py")?.get("router")).toBe("/api");
+        // The root aggregator has no ancestor prefix, so it's omitted entirely.
+        expect(result.get("app/__init__.py")).toBeUndefined();
+    });
+    it("resolves a mount prefix given as a module-level string constant", () => {
+        const repo = makeRepo({
+            "svc/__init__.py": `
+from fastapi import APIRouter
+from . import billing
+
+BILLING = "/billing"
+router = APIRouter()
+router.include_router(billing.router, prefix=BILLING)
+`,
+            "svc/billing.py": `
+from fastapi import APIRouter
+router = APIRouter()
+@router.get("/invoices")
+def invoices(): pass
+`,
+        });
+        const result = resolvePythonMountPrefixes(repo);
+        expect(result.get("svc/billing.py")?.get("router")).toBe("/billing");
+    });
+    it("fails safe (no ancestor prefix) when the mounted module can't be resolved", () => {
+        const repo = makeRepo({
+            "app/main.py": `
+from fastapi import FastAPI
+from some_external_pkg import router as ext_router
+
+app = FastAPI()
+app.include_router(ext_router, prefix="/api")
+`,
+        });
+        // The external module isn't in the repo, so the edge is dropped and nothing
+        // is returned — the scanner then behaves exactly as it does today.
+        const result = resolvePythonMountPrefixes(repo);
+        expect(result.size).toBe(0);
+    });
+    it("does not loop forever on a mutually-recursive mount cycle", () => {
+        const repo = makeRepo({
+            "a.py": `
+from fastapi import APIRouter
+from b import router as b_router
+router = APIRouter(prefix="/a")
+router.include_router(b_router)
+`,
+            "b.py": `
+from fastapi import APIRouter
+from a import router as a_router
+router = APIRouter(prefix="/b")
+router.include_router(a_router)
+`,
+        });
+        // Should terminate; the exact prefixes are unimportant, only that it returns.
+        const result = resolvePythonMountPrefixes(repo);
+        expect(result).toBeInstanceOf(Map);
+    });
+});