@skyramp/mcp 0.2.9 → 0.2.10-rc.1

package/build/utils/repoScanner.test.js

@@ -42,14 +42,14 @@ async def bulk_delete_deployments(): pass
         const endpoints = scanAllRepoEndpoints(repo);
         const relatedEndpoints = scanRelatedEndpoints(repo, ["src/prefect/server/api/flows.py"]);
         expect(endpoints).toEqual(expect.arrayContaining([
-            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" },
-            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" },
-            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/deployments.py" },
-            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/deployments.py" },
+            expect.objectContaining({ path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" }),
+            expect.objectContaining({ path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" }),
+            expect.objectContaining({ path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/deployments.py" }),
+            expect.objectContaining({ path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/deployments.py" }),
         ]));
         expect(relatedEndpoints).toEqual(expect.arrayContaining([
-            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" },
-            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" },
+            expect.objectContaining({ path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" }),
+            expect.objectContaining({ path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" }),
         ]));
         const classified = classifyEndpointsByChangedFiles({
             currentBranch: "feature/admin-key",
@@ -61,11 +61,11 @@ async def bulk_delete_deployments(): pass
             deletedFiles: [],
         }, endpoints);
         expect(classified.changedEndpoints).toEqual(expect.arrayContaining([
-            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" },
-            { path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" },
+            expect.objectContaining({ path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/flows.py" }),
+            expect.objectContaining({ path: "/bulk_delete", methods: ["POST"], sourceFile: "src/prefect/server/api/flows.py" }),
         ]));
         expect(classified.changedEndpoints).not.toEqual(expect.arrayContaining([
-            { path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/deployments.py" },
+            expect.objectContaining({ path: "/{id:uuid}", methods: ["DELETE"], sourceFile: "src/prefect/server/api/deployments.py" }),
         ]));
     });
     it("does not suppress removed router-relative endpoints with same-path siblings", () => {

package/build/utils/routeParsers.d.ts

@@ -4,6 +4,8 @@ export interface ParsedDiffEndpoint {
     method: string;
     path: string;
     sourceFile: string;
+    /** 1-based line where the route declaration starts, when parsed from full file content. */
+    line?: number;
 }
 export declare function nextjsFileToApiPath(filePath: string): string | null;
 export declare const UI_FILE_EXTENSIONS: readonly ["tsx", "jsx", "vue", "svelte", "html", "xml"];
@@ -36,6 +38,36 @@ export declare const SKIP_PATH_SEGMENTS: Set<string>;
  * parent prevents "/orders/{id}/items" and "/products/{id}/items" from colliding on "items".
  */
 export declare function extractResourceFromPath(endpointPath: string): string;
+/**
+ * Files that may contain endpoints removed in this branch: every changed file
+ * except newly-created ones. Both whole-file deletions AND line-edits that drop a
+ * route from a surviving file belong here — newly-created files cannot contain a
+ * route that existed in the base branch.
+ */
+export declare function selectRemovalCandidateFiles(diffData: BranchDiffData): string[];
+/**
+ * Recover endpoints as they existed in the base branch, for the given candidate
+ * files. `fetchBaseContent` returns a file's base-branch content (e.g. via
+ * `git show base:<file>`); files that throw are skipped. Returns every endpoint
+ * found in the base versions — callers pass the result to
+ * `classifyEndpointsByChangedFiles`, whose moved/still-present filter drops any
+ * endpoint that survives in the current catalog, leaving only genuine removals.
+ */
+export declare function recoverRemovedEndpointsFromBase(candidateFiles: string[], fetchBaseContent: (file: string) => Promise<string>): Promise<ScannedEndpoint[]>;
+/**
+ * Parse a unified diff into the set of new-side (post-change) line numbers that
+ * were touched, keyed by normalized file path.
+ *
+ * Context and added (`+`) lines advance the new-side cursor; added lines are
+ * recorded. Removed (`-`) lines don't advance the cursor but record the current
+ * new-side position, so deletion-only hunks still map to a location (otherwise a
+ * pure deletion would scope to nothing and fall back to whole-file matching).
+ * Feeds hunk-aware scoping in `classifyEndpointsByChangedFiles` so a
+ * change can be attributed to the specific route whose declaration owns those
+ * lines — instead of flagging every route in a touched file (the failure mode
+ * on centralized-routing SUTs that register the whole API in one hub file).
+ */
+export declare function parseChangedLinesByFile(diffContent: string): Map<string, Set<number>>;
 export interface ClassifiedEndpoints {
     /** Endpoints in scanned catalog whose sourceFile is in changedFiles (not new/deleted). */
     changedEndpoints: ScannedEndpoint[];

package/build/utils/routeParsers.js

@@ -1,3 +1,4 @@
+import { logger } from "./logger.js";
 export function nextjsFileToApiPath(filePath) {
     const pagesMatch = filePath.match(/(?:^|\/)pages\/(api\/.+)\.[jt]sx?$/);
     if (pagesMatch) {
@@ -192,7 +193,10 @@ export function parseFileEndpoints(content, sourceFile) {
     let pendingRouterVar = ""; // variable name being accumulated in a multi-line declaration
     let pendingPythonDecorator = null;
     let pendingExpressMethod = ""; // HTTP method from a multi-line Express route (e.g. "POST" from `router.post(\n`)
+    let pendingExpressLine = 0; // line where the multi-line Express route started
+    let lineNo = 0; // 1-based; incremented for every line (including skipped) to keep numbering accurate
     for (const line of content.split("\n")) {
+        lineNo++;
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*"))
             continue;
@@ -272,6 +276,7 @@ export function parseFileEndpoints(content, sourceFile) {
                     method: pendingPythonDecorator.method,
                     path,
                     sourceFile,
+                    line: pendingPythonDecorator.startLine,
                 });
                 pendingPythonDecorator = null;
                 continue;
@@ -302,6 +307,7 @@ export function parseFileEndpoints(content, sourceFile) {
                         method: pendingExpressMethod,
                         path: pathMatch[1],
                         sourceFile,
+                        line: pendingExpressLine,
                     });
                 }
                 pendingExpressMethod = "";
@@ -340,6 +346,7 @@ export function parseFileEndpoints(content, sourceFile) {
                 pendingPythonDecorator = {
                     routerVar: pythonDecoratorMultiLine[1],
                     method: pythonDecoratorMultiLine[2].toUpperCase(),
+                    startLine: lineNo,
                 };
                 continue;
             }
@@ -348,6 +355,7 @@ export function parseFileEndpoints(content, sourceFile) {
             const expressMultiLine = trimmed.match(/(?:router|app)\.(get|post|put|patch|delete)\s*\(\s*$/i);
             if (expressMultiLine && !UI_COMPONENT_EXT.test(sourceFile)) {
                 pendingExpressMethod = expressMultiLine[1].toUpperCase();
+                pendingExpressLine = lineNo;
             }
             continue;
         }
@@ -376,9 +384,16 @@ export function parseFileEndpoints(content, sourceFile) {
                 }
             }
         }
+        ep.line = lineNo;
         results.push(ep);
     }
-    return results;
+    // Normalize to a leading-slash path here (single responsibility) so callers
+    // don't each re-normalize. Empty paths (e.g. NestJS no-path decorators) are
+    // left as-is.
+    return results.map((ep) => ({
+        ...ep,
+        path: ep.path && !ep.path.startsWith("/") ? `/${ep.path}` : ep.path,
+    }));
 }
 export const SKIP_PATH_SEGMENTS = new Set(["api", "v1", "v2", "v3", "public"]);
 /**
@@ -433,9 +448,194 @@ function endpointSourceResource(ep) {
 function endpointMovedKey(path, resource, method) {
     return method ? `${path}::${resource}::${method}` : `${path}::${resource}`;
 }
+// Route-file heuristics: keep base-branch I/O bounded to files that plausibly
+// declare endpoints. Mirrors the previous deleted-file recovery filter.
+const ROUTE_FILE_PATTERN = /route|controller|endpoint|handler|view|urls|api|router|service|gateway|resolver|\bserver\b/i;
+const ROUTE_FILE_BASENAME_PATTERN = /\bapp\b|\bmain\b/i;
+const SOURCE_EXTS = /\.(ts|tsx|js|jsx|py|java|kt|go|rb|php|rs|cs|ex|exs)$/;
+function isRouteLikeFile(filePath) {
+    const base = normalizeSourcePath(filePath).split("/").pop() ?? "";
+    return SOURCE_EXTS.test(filePath) &&
+        (ROUTE_FILE_PATTERN.test(filePath) || ROUTE_FILE_BASENAME_PATTERN.test(base));
+}
+/**
+ * Files that may contain endpoints removed in this branch: every changed file
+ * except newly-created ones. Both whole-file deletions AND line-edits that drop a
+ * route from a surviving file belong here — newly-created files cannot contain a
+ * route that existed in the base branch.
+ */
+export function selectRemovalCandidateFiles(diffData) {
+    const newFileSet = new Set(diffData.newFiles.map(normalizeSourcePath));
+    return diffData.changedFiles.filter((f) => !newFileSet.has(normalizeSourcePath(f)));
+}
+/**
+ * Recover endpoints as they existed in the base branch, for the given candidate
+ * files. `fetchBaseContent` returns a file's base-branch content (e.g. via
+ * `git show base:<file>`); files that throw are skipped. Returns every endpoint
+ * found in the base versions — callers pass the result to
+ * `classifyEndpointsByChangedFiles`, whose moved/still-present filter drops any
+ * endpoint that survives in the current catalog, leaving only genuine removals.
+ */
+export async function recoverRemovedEndpointsFromBase(candidateFiles, fetchBaseContent) {
+    const routeFiles = candidateFiles.filter(isRouteLikeFile);
+    const endpointMap = new Map();
+    for (const file of routeFiles) {
+        let content;
+        try {
+            content = await fetchBaseContent(file);
+        }
+        catch (err) {
+            // Expected for files that don't exist in the base tree: a path renamed in
+            // this branch (the new name isn't in base), or a sparse/shallow checkout
+            // where `git show base:<file>` can't resolve. We skip (best-effort
+            // recovery — a single unreadable file shouldn't abort removal detection)
+            // but warn so it's visible if recovery silently under-reports.
+            logger.warning("Failed to fetch base-branch content for removal recovery", {
+                file,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            continue;
+        }
+        for (const ep of parseFileEndpoints(content, file)) {
+            // parseFileEndpoints already normalizes paths to a leading slash.
+            const key = `${file}::${ep.path}`;
+            const existing = endpointMap.get(key);
+            if (existing) {
+                existing.methods.add(ep.method);
+            }
+            else {
+                endpointMap.set(key, {
+                    path: ep.path,
+                    methods: new Set([ep.method]),
+                    sourceFile: file,
+                });
+            }
+        }
+    }
+    return [...endpointMap.values()].map((d) => ({
+        path: d.path,
+        methods: [...d.methods],
+        sourceFile: d.sourceFile,
+    }));
+}
+/** Strip git's `a/` / `b/` diff-path prefix and normalize separators. */
+function normalizeDiffPath(spec) {
+    let p = spec.replace(/\\/g, "/");
+    if (p.startsWith("a/") || p.startsWith("b/"))
+        p = p.slice(2);
+    return p;
+}
+/**
+ * Parse a unified diff into the set of new-side (post-change) line numbers that
+ * were touched, keyed by normalized file path.
+ *
+ * Context and added (`+`) lines advance the new-side cursor; added lines are
+ * recorded. Removed (`-`) lines don't advance the cursor but record the current
+ * new-side position, so deletion-only hunks still map to a location (otherwise a
+ * pure deletion would scope to nothing and fall back to whole-file matching).
+ * Feeds hunk-aware scoping in `classifyEndpointsByChangedFiles` so a
+ * change can be attributed to the specific route whose declaration owns those
+ * lines — instead of flagging every route in a touched file (the failure mode
+ * on centralized-routing SUTs that register the whole API in one hub file).
+ */
+export function parseChangedLinesByFile(diffContent) {
+    const result = new Map();
+    if (!diffContent)
+        return result;
+    let currentFile = null;
+    let newCursor = 0;
+    // Walk the diff line-by-line without materializing a full array of every line
+    // (`split("\n")`), which would transiently double the memory of an already
+    // in-memory (and potentially large) diff. Only one line is held at a time.
+    const len = diffContent.length;
+    let pos = 0;
+    while (pos <= len) {
+        let nl = diffContent.indexOf("\n", pos);
+        if (nl === -1)
+            nl = len;
+        const raw = diffContent.slice(pos, nl);
+        pos = nl + 1;
+        // New-file header: "+++ b/path" (checked before the generic "+" branch).
+        if (raw.startsWith("+++ ")) {
+            const spec = raw.slice(4).trim().split("\t")[0];
+            currentFile = spec === "/dev/null" ? null : normalizeDiffPath(spec);
+            continue;
+        }
+        if (raw.startsWith("--- ") || raw.startsWith("diff --git") || raw.startsWith("index ")) {
+            continue;
+        }
+        const hunk = raw.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+        if (hunk) {
+            newCursor = parseInt(hunk[1], 10);
+            continue;
+        }
+        if (currentFile === null)
+            continue;
+        if (raw.startsWith("+")) {
+            const set = result.get(currentFile) ?? new Set();
+            set.add(newCursor);
+            result.set(currentFile, set);
+            newCursor++;
+        }
+        else if (raw.startsWith("-")) {
+            // Removed line — present only on the old side, so the new-side cursor does
+            // not advance. Record the current new-side position so deletion-only hunks
+            // (removing a route line or handler code) still scope to the owning route
+            // instead of falling back to whole-file matching.
+            const set = result.get(currentFile) ?? new Set();
+            set.add(newCursor);
+            result.set(currentFile, set);
+        }
+        else if (raw.startsWith("\\")) {
+            // "" — not a real line.
+        }
+        else {
+            // Context line (leading space, or a blank final line).
+            newCursor++;
+        }
+    }
+    return result;
+}
+/**
+ * Scope a file's endpoints to the ones actually touched by the diff, using an
+ * ownership-range model: sorted by declaration line, each endpoint owns
+ * [line_i, line_{i+1}) (the last owns to EOF). An endpoint is "changed" iff a
+ * changed line falls in its range — so a route-line edit maps to that one route
+ * and a handler-body edit maps to its enclosing route.
+ *
+ * Falls back to the full set (file-level behavior) whenever scoping isn't safe:
+ * no changed lines for the file, fewer than two endpoints, any endpoint missing
+ * line info, or no changed line mapping to any route (e.g. an import edit above
+ * the first route). Fallback keeps behavior identical to pre-scoping when
+ * `diffContent` is empty.
+ */
+function scopeEndpointsToHunks(eps, changedLines) {
+    if (!changedLines || changedLines.size === 0)
+        return eps;
+    if (eps.length <= 1)
+        return eps;
+    if (!eps.every((e) => typeof e.line === "number"))
+        return eps;
+    const sorted = [...eps].sort((a, b) => a.line - b.line);
+    const matched = new Set();
+    for (let i = 0; i < sorted.length; i++) {
+        const start = sorted[i].line;
+        const end = i + 1 < sorted.length ? sorted[i + 1].line : Infinity;
+        for (const ln of changedLines) {
+            if (ln >= start && ln < end) {
+                matched.add(sorted[i]);
+                break;
+            }
+        }
+    }
+    if (matched.size === 0)
+        return eps;
+    return eps.filter((e) => matched.has(e));
+}
 export function classifyEndpointsByChangedFiles(diffData, scannedEndpoints, deletedFileEndpoints) {
     const newFileSet = new Set(diffData.newFiles.map(normalizeSourcePath));
     const deletedFileSet = new Set(diffData.deletedFiles.map(normalizeSourcePath));
+    const changedLinesByFile = parseChangedLinesByFile(diffData.diffContent);
     const bySourceFile = new Map();
     for (const ep of scannedEndpoints) {
         const sourceKey = normalizeSourcePath(ep.sourceFile);
@@ -461,7 +661,10 @@ export function classifyEndpointsByChangedFiles(diffData, scannedEndpoints, dele
             newEndpoints.push(...eps);
         }
         else {
-            changedEndpoints.push(...eps);
+            // Scope to the routes the diff actually touched — critical on hub files
+            // that register the whole API, where file-level matching would flag every
+            // route as changed. Falls back to `eps` when scoping isn't safe.
+            changedEndpoints.push(...scopeEndpointsToHunks(eps, changedLinesByFile.get(fileKey)));
         }
     }
     // Removed endpoints: from deleted files, recovered from the base branch.