@skyramp/mcp 0.0.59 → 0.0.60-rc.2

package/build/utils/repoScanner.js

@@ -0,0 +1,378 @@
+import * as fs from "fs";
+import * as path from "path";
+import { nextjsFileToApiPath, parseRouteLine, extractEndpointsFromPythonFile, } from "./routeParsers.js";
+function globRecursive(dir, extensions) {
+    const results = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".next" || entry.name === "dist" || entry.name === "build")
+                continue;
+            results.push(...globRecursive(fullPath, extensions));
+        }
+        else if (extensions.some((ext) => entry.name.endsWith(ext))) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+export function detectApiPrefix(repositoryPath) {
+    const mainCandidates = ["main.py", "app.py", "server.py", "asgi.py", "wsgi.py"];
+    const mainFiles = [];
+    const searchDirs = [repositoryPath];
+    for (const sub of ["backend", "src", "app", "api"]) {
+        const subDir = path.join(repositoryPath, sub);
+        if (fs.existsSync(subDir))
+            searchDirs.push(subDir);
+    }
+    for (const dir of searchDirs) {
+        const files = globRecursive(dir, [".py"]);
+        for (const f of files) {
+            if (mainCandidates.includes(path.basename(f)) && !/test/i.test(f)) {
+                mainFiles.push(f);
+            }
+        }
+    }
+    for (const mainFile of mainFiles) {
+        let fc;
+        try {
+            fc = fs.readFileSync(mainFile, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (!fc.includes("include_router"))
+            continue;
+        const appVarMatch = fc.match(/(\w+)\s*=\s*(?:FastAPI|Flask)\s*\(/);
+        const appVar = appVarMatch ? appVarMatch[1] : "app";
+        const includePattern = new RegExp(appVar + "\\.include_router\\s*\\([^)]*prefix\\s*=\\s*(?:" +
+            '["' + "'" + ']([^"' + "'" + ']+)["' + "'" + ']' +
+            "|(\\w+)" +
+            ")", "g");
+        let match;
+        while ((match = includePattern.exec(fc)) !== null) {
+            if (match[1]) {
+                const prefix = match[1];
+                if (!prefix.includes("{"))
+                    return prefix;
+                continue;
+            }
+            const varName = match[2];
+            if (!varName)
+                continue;
+            const simpleRe = new RegExp(varName + "\\s*=\\s*[\"']([^\"']+)[\"']");
+            const simpleMatch = fc.match(simpleRe);
+            if (simpleMatch && !simpleMatch[1].includes("{"))
+                return simpleMatch[1];
+            const fstringRe = new RegExp(varName + "\\s*=\\s*f[\"']([^\"']+)[\"']");
+            const fstringMatch = fc.match(fstringRe);
+            if (fstringMatch) {
+                let prefix = fstringMatch[1];
+                const envFiles = [".env", "backend/.env", ".env.local", "backend/src/.env"];
+                for (const envFile of envFiles) {
+                    try {
+                        const envContent = fs.readFileSync(path.join(repositoryPath, envFile), "utf-8");
+                        const varRefs = prefix.match(/\{[^}]+\}/g) || [];
+                        for (const vr of varRefs) {
+                            const keyName = vr.replace(/[{}]/g, "").split(".").pop() || "";
+                            if (!keyName)
+                                continue;
+                            const envLine = envContent.match(new RegExp("^" + keyName + "\\s*=\\s*(.+)$", "m"));
+                            if (envLine) {
+                                prefix = prefix.replace(vr, envLine[1].trim());
+                            }
+                        }
+                    }
+                    catch { /* env file not found */ }
+                }
+                prefix = prefix.replace(/\{[^}]*VERSION[^}]*\}/gi, "v1");
+                prefix = prefix.replace(/\{[^}]+\}/g, "");
+                prefix = prefix.replace(/\/\//g, "/").replace(/\/$/, "");
+                if (prefix && prefix !== "/" && !prefix.includes("{"))
+                    return prefix;
+            }
+        }
+    }
+    const jsMainCandidates = ["app.ts", "app.js", "server.ts", "server.js", "index.ts", "index.js"];
+    for (const dir of searchDirs) {
+        const files = globRecursive(dir, [".ts", ".js"]);
+        for (const f of files) {
+            if (!jsMainCandidates.includes(path.basename(f)))
+                continue;
+            let fc;
+            try {
+                fc = fs.readFileSync(f, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const expressMatch = fc.match(/app\.use\s*\(\s*["'](\/[^"']+)["']\s*,/);
+            if (expressMatch && expressMatch[1].length > 1)
+                return expressMatch[1];
+        }
+    }
+    // Go (Gin): r := gin.Default(); api := r.Group("/api/v1")
+    const goMainCandidates = ["main.go", "server.go", "app.go", "router.go", "routes.go"];
+    for (const dir of searchDirs) {
+        const files = globRecursive(dir, [".go"]);
+        for (const f of files) {
+            if (!goMainCandidates.includes(path.basename(f)))
+                continue;
+            let fc;
+            try {
+                fc = fs.readFileSync(f, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const ginGroup = fc.match(/\.Group\s*\(\s*["'](\/[^"']+)["']/);
+            if (ginGroup && ginGroup[1].length > 1)
+                return ginGroup[1];
+        }
+    }
+    // Ruby on Rails: namespace :api do / scope "/api/v1" do
+    for (const dir of searchDirs) {
+        const files = globRecursive(dir, [".rb"]);
+        for (const f of files) {
+            if (!/routes/i.test(path.basename(f)))
+                continue;
+            let fc;
+            try {
+                fc = fs.readFileSync(f, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const scopeMatch = fc.match(/scope\s+["'](\/[^"']+)["']/);
+            if (scopeMatch && scopeMatch[1].length > 1)
+                return scopeMatch[1];
+        }
+    }
+    // PHP Laravel: Route::prefix('/api/v1')->group(...)
+    for (const dir of searchDirs) {
+        const files = globRecursive(dir, [".php"]);
+        for (const f of files) {
+            if (!/route|api/i.test(path.basename(f)))
+                continue;
+            let fc;
+            try {
+                fc = fs.readFileSync(f, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const prefixMatch = fc.match(/Route::prefix\s*\(\s*["'](\/[^"']+)["']/);
+            if (prefixMatch && prefixMatch[1].length > 1)
+                return prefixMatch[1];
+        }
+    }
+    return "";
+}
+export function grepRouterMountingContext(repositoryPath) {
+    const entryCandidates = [
+        "main.py", "app.py", "server.py", "asgi.py", "wsgi.py",
+        "app.ts", "app.js", "server.ts", "server.js", "index.ts", "index.js",
+        "urls.py",
+        "main.go", "server.go", "router.go", "routes.go",
+        "routes.rb", "web.php", "api.php",
+    ];
+    const searchDirs = [repositoryPath];
+    for (const sub of ["backend", "src", "app", "api"]) {
+        const subDir = path.join(repositoryPath, sub);
+        if (fs.existsSync(subDir))
+            searchDirs.push(subDir);
+    }
+    const mountPatterns = [
+        /include_router/i,
+        /register_blueprint/i,
+        /\.use\s*\(\s*["']\//,
+        /urlpatterns/,
+        /path\s*\(.+include\s*\(/,
+        /\.Group\s*\(/,
+        /Route::prefix/,
+        /namespace\s+:api/,
+        /scope\s+["']\//,
+    ];
+    const matches = [];
+    for (const dir of searchDirs) {
+        const files = globRecursive(dir, [".py", ".ts", ".js", ".go", ".rb", ".php", ".rs"]);
+        for (const f of files) {
+            if (!entryCandidates.includes(path.basename(f)))
+                continue;
+            if (/test/i.test(f))
+                continue;
+            let fc;
+            try {
+                fc = fs.readFileSync(f, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const hasMounting = mountPatterns.some((p) => p.test(fc));
+            if (!hasMounting)
+                continue;
+            const relPath = f.startsWith(repositoryPath)
+                ? f.slice(repositoryPath.length + 1)
+                : f;
+            const relevantLines = [];
+            for (const line of fc.split("\n")) {
+                const trimmed = line.trim();
+                if (/include_router|register_blueprint/i.test(trimmed) ||
+                    /\.use\s*\(\s*["']\//.test(trimmed) ||
+                    /path\s*\(.+include\s*\(/.test(trimmed) ||
+                    /^from\s+.+import\s+.*router/i.test(trimmed) ||
+                    /^import\s+.+router/i.test(trimmed) ||
+                    /^const\s+\w+Router\s*=\s*require/i.test(trimmed) ||
+                    /^import\s+\w+Router\s+from/i.test(trimmed) ||
+                    /\.Group\s*\(/.test(trimmed) ||
+                    /Route::prefix/i.test(trimmed) ||
+                    /namespace\s+:/.test(trimmed) ||
+                    /scope\s+["']\//.test(trimmed)) {
+                    relevantLines.push(trimmed);
+                }
+            }
+            if (relevantLines.length > 0) {
+                matches.push(`${relPath}:\n${relevantLines.map((l) => "  " + l).join("\n")}`);
+            }
+        }
+    }
+    return matches.join("\n\n");
+}
+function addEndpointToMap(endpointMap, apiPath, method, sourceFile, repositoryPath) {
+    const relative = sourceFile.startsWith(repositoryPath)
+        ? sourceFile.slice(repositoryPath.length + 1) : sourceFile;
+    const existing = endpointMap.get(apiPath);
+    if (existing)
+        existing.methods.add(method);
+    else
+        endpointMap.set(apiPath, { methods: new Set([method]), sourceFile: relative });
+}
+function scanNextjsFile(file, repositoryPath, endpointMap) {
+    const relative = file.startsWith(repositoryPath)
+        ? file.slice(repositoryPath.length + 1) : file;
+    const apiPath = nextjsFileToApiPath(relative);
+    if (!apiPath)
+        return false;
+    let content;
+    try {
+        content = fs.readFileSync(file, "utf-8");
+    }
+    catch {
+        addEndpointToMap(endpointMap, apiPath, "MULTI", file, repositoryPath);
+        return true;
+    }
+    const detectedMethods = new Set();
+    for (const line of content.split("\n")) {
+        const mc = line.match(/req\.method\s*===?\s*["'](GET|POST|PUT|PATCH|DELETE)["']/i);
+        if (mc)
+            detectedMethods.add(mc[1].toUpperCase());
+        const em = line.match(/export\s+(?:async\s+)?function\s+(GET|POST|PUT|PATCH|DELETE)\s*\(/i);
+        if (em)
+            detectedMethods.add(em[1].toUpperCase());
+    }
+    if (detectedMethods.size > 0) {
+        for (const m of detectedMethods)
+            addEndpointToMap(endpointMap, apiPath, m, file, repositoryPath);
+    }
+    else {
+        addEndpointToMap(endpointMap, apiPath, "MULTI", file, repositoryPath);
+    }
+    return true;
+}
+export function scanAllRepoEndpoints(repositoryPath) {
+    const endpointMap = new Map();
+    const appPrefix = detectApiPrefix(repositoryPath);
+    const sourceFiles = globRecursive(repositoryPath, [".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".kt", ".go", ".rb", ".php", ".rs", ".cs"]);
+    for (const file of sourceFiles) {
+        if (scanNextjsFile(file, repositoryPath, endpointMap))
+            continue;
+        const relative = file.startsWith(repositoryPath)
+            ? file.slice(repositoryPath.length + 1) : file;
+        if (!/route|controller|endpoint|handler|view|urls|api|router/i.test(relative))
+            continue;
+        let content;
+        try {
+            content = fs.readFileSync(file, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        if (file.endsWith(".py")) {
+            const pyEndpoints = extractEndpointsFromPythonFile(content, relative);
+            for (const ep of pyEndpoints) {
+                const fullPath = appPrefix && !ep.path.startsWith(appPrefix) ? appPrefix + ep.path : ep.path;
+                addEndpointToMap(endpointMap, fullPath, ep.method, file, repositoryPath);
+            }
+        }
+        else {
+            for (const line of content.split("\n")) {
+                const ep = parseRouteLine(line, relative);
+                if (ep)
+                    addEndpointToMap(endpointMap, ep.path, ep.method, file, repositoryPath);
+            }
+        }
+    }
+    return Array.from(endpointMap.entries()).map(([apiPath, data]) => ({
+        path: apiPath,
+        methods: Array.from(data.methods),
+        sourceFile: data.sourceFile,
+    }));
+}
+export function scanRelatedEndpoints(repositoryPath, changedFiles) {
+    const appPrefix = detectApiPrefix(repositoryPath);
+    const relatedDirs = new Set();
+    for (const f of changedFiles) {
+        const absDir = path.dirname(path.join(repositoryPath, f));
+        relatedDirs.add(absDir);
+        const parentDir = path.dirname(absDir);
+        if (parentDir !== repositoryPath)
+            relatedDirs.add(parentDir);
+    }
+    const endpointMap = new Map();
+    for (const dir of relatedDirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        const files = globRecursive(dir, [".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".kt", ".go", ".rb", ".php", ".rs", ".cs"]);
+        for (const file of files) {
+            if (scanNextjsFile(file, repositoryPath, endpointMap))
+                continue;
+            const relative = file.startsWith(repositoryPath)
+                ? file.slice(repositoryPath.length + 1) : file;
+            if (!/route|controller|endpoint|handler|view|urls|api|router/i.test(relative))
+                continue;
+            let fileContent;
+            try {
+                fileContent = fs.readFileSync(file, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            if (file.endsWith(".py")) {
+                const pyEndpoints = extractEndpointsFromPythonFile(fileContent, relative);
+                for (const ep of pyEndpoints) {
+                    const fullPath = appPrefix && !ep.path.startsWith(appPrefix) ? appPrefix + ep.path : ep.path;
+                    addEndpointToMap(endpointMap, fullPath, ep.method, file, repositoryPath);
+                }
+            }
+            else {
+                for (const line of fileContent.split("\n")) {
+                    const ep = parseRouteLine(line, relative);
+                    if (ep)
+                        addEndpointToMap(endpointMap, ep.path, ep.method, file, repositoryPath);
+                }
+            }
+        }
+    }
+    return Array.from(endpointMap.entries()).map(([apiPath, data]) => ({
+        path: apiPath,
+        methods: Array.from(data.methods),
+        sourceFile: data.sourceFile,
+    }));
+}

package/build/utils/routeParsers.js

@@ -0,0 +1,213 @@
+export function nextjsFileToApiPath(filePath) {
+    const pagesMatch = filePath.match(/(?:^|\/)pages\/(api\/.+)\.[jt]sx?$/);
+    if (pagesMatch) {
+        let route = "/" + pagesMatch[1];
+        route = route.replace(/\/index$/, "");
+        route = route
+            .replace(/\[\.\.\.(\w+)\]/g, "{$1}")
+            .replace(/\[(\w+)\]/g, "{$1}");
+        return route;
+    }
+    const appMatch = filePath.match(/(?:^|\/)app\/(api\/.+)\/route\.[jt]sx?$/);
+    if (appMatch) {
+        let route = "/" + appMatch[1];
+        route = route
+            .replace(/\[\.\.\.(\w+)\]/g, "{$1}")
+            .replace(/\[(\w+)\]/g, "{$1}");
+        return route;
+    }
+    return null;
+}
+export function parseRouteLine(line, sourceFile) {
+    const stripped = line.replace(/^[+-]\s*/, "").trim();
+    const decoratorMatch = stripped.match(/@(?:\w+)\.(get|post|put|patch|delete|head|options)\s*\(\s*["']([^"'?#]*)/i);
+    if (decoratorMatch) {
+        return {
+            method: decoratorMatch[1].toUpperCase(),
+            path: decoratorMatch[2],
+            sourceFile,
+        };
+    }
+    const flaskMatch = stripped.match(/@\w+\.route\s*\(\s*["']([^"'?#]+)["'][^)]*methods\s*=\s*\[["'](\w+)["']/i);
+    if (flaskMatch) {
+        return {
+            method: flaskMatch[2].toUpperCase(),
+            path: flaskMatch[1],
+            sourceFile,
+        };
+    }
+    const expressMatch = stripped.match(/(?:router|app)\.(get|post|put|patch|delete)\s*\(\s*["']([^"'?#]+)/i);
+    if (expressMatch) {
+        return {
+            method: expressMatch[1].toUpperCase(),
+            path: expressMatch[2],
+            sourceFile,
+        };
+    }
+    const springMatch = stripped.match(/@(Get|Post|Put|Patch|Delete)Mapping\s*(?:\(\s*(?:value\s*=\s*)?["']([^"'?#]+)["'])?/i);
+    if (springMatch && springMatch[2]) {
+        return {
+            method: springMatch[1].toUpperCase(),
+            path: springMatch[2],
+            sourceFile,
+        };
+    }
+    const nestjsMatch = stripped.match(/@(Get|Post|Put|Patch|Delete)\s*\(\s*["']([^"'?#]+)["']/i);
+    if (nestjsMatch) {
+        return {
+            method: nestjsMatch[1].toUpperCase(),
+            path: nestjsMatch[2],
+            sourceFile,
+        };
+    }
+    const nextjsMethodMatch = stripped.match(/req\.method\s*===?\s*["'](GET|POST|PUT|PATCH|DELETE)["']/i);
+    if (nextjsMethodMatch) {
+        const apiPath = nextjsFileToApiPath(sourceFile);
+        if (apiPath) {
+            return {
+                method: nextjsMethodMatch[1].toUpperCase(),
+                path: apiPath,
+                sourceFile,
+            };
+        }
+    }
+    const appRouterExportMatch = stripped.match(/export\s+(?:async\s+)?function\s+(GET|POST|PUT|PATCH|DELETE)\s*\(/i);
+    if (appRouterExportMatch) {
+        const apiPath = nextjsFileToApiPath(sourceFile);
+        if (apiPath) {
+            return {
+                method: appRouterExportMatch[1].toUpperCase(),
+                path: apiPath,
+                sourceFile,
+            };
+        }
+    }
+    // Go (Gin, Echo, Chi): <ident>.GET/POST/...("/path", handler)
+    const ginMatch = stripped.match(/(?:\w+)\.(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*\(\s*["']([^"'?#]+)/i);
+    if (ginMatch && sourceFile.endsWith(".go")) {
+        return { method: ginMatch[1].toUpperCase(), path: ginMatch[2], sourceFile };
+    }
+    // Go stdlib: http.HandleFunc/Handle
+    const goHandleMatch = stripped.match(/(?:HandleFunc|Handle)\s*\(\s*["']([^"'?#]+)/);
+    if (goHandleMatch && sourceFile.endsWith(".go")) {
+        return { method: "MULTI", path: goHandleMatch[1], sourceFile };
+    }
+    // Ruby — Rails
+    const railsMatch = stripped.match(/^(get|post|put|patch|delete)\s+["']([^"'?#]+)/i);
+    if (railsMatch && (sourceFile.endsWith(".rb") || /routes/i.test(sourceFile))) {
+        return { method: railsMatch[1].toUpperCase(), path: railsMatch[2], sourceFile };
+    }
+    // PHP — Laravel
+    const laravelMatch = stripped.match(/Route::(get|post|put|patch|delete|options)\s*\(\s*["']([^"'?#]+)/i);
+    if (laravelMatch) {
+        return { method: laravelMatch[1].toUpperCase(), path: laravelMatch[2], sourceFile };
+    }
+    // Rust — Actix
+    const actixAttrMatch = stripped.match(/#\[(get|post|put|patch|delete)\s*\(\s*["']([^"'?#]+)/i);
+    if (actixAttrMatch) {
+        return { method: actixAttrMatch[1].toUpperCase(), path: actixAttrMatch[2], sourceFile };
+    }
+    // ASP.NET
+    const aspnetMatch = stripped.match(/\[Http(Get|Post|Put|Patch|Delete)\s*(?:\(\s*["']([^"'?#]+)["'])?/i);
+    if (aspnetMatch) {
+        return {
+            method: aspnetMatch[1].toUpperCase(),
+            path: aspnetMatch[2] || "/",
+            sourceFile,
+        };
+    }
+    // Hapi.js
+    const hapiMatch = stripped.match(/method:\s*["'](GET|POST|PUT|PATCH|DELETE)["'][^}]*path:\s*["']([^"'?#]+)/i);
+    if (hapiMatch) {
+        return { method: hapiMatch[1].toUpperCase(), path: hapiMatch[2], sourceFile };
+    }
+    return null;
+}
+export function extractEndpointsFromPythonFile(content, sourceFile) {
+    const endpoints = [];
+    let routerPrefix = "";
+    const fastapiPrefix = content.match(/APIRouter\s*\([^)]*prefix\s*=\s*["']([^"']+)["']/);
+    if (fastapiPrefix) {
+        routerPrefix = fastapiPrefix[1];
+    }
+    else {
+        const flaskPrefix = content.match(/Blueprint\s*\([^)]*url_prefix\s*=\s*["']([^"']+)["']/);
+        if (flaskPrefix)
+            routerPrefix = flaskPrefix[1];
+    }
+    for (const line of content.split("\n")) {
+        const stripped = line.trim();
+        const decoratorMatch = stripped.match(/@(?:\w+)\.(get|post|put|patch|delete|head|options)\s*\(\s*["']([^"'?#]*)["']/i);
+        if (decoratorMatch) {
+            const method = decoratorMatch[1].toUpperCase();
+            const routePath = decoratorMatch[2];
+            const fullPath = routerPrefix + routePath;
+            if (fullPath)
+                endpoints.push({ method, path: fullPath });
+            continue;
+        }
+        const flaskMatch = stripped.match(/@\w+\.route\s*\(\s*["']([^"'?#]*)["'][^)]*methods\s*=\s*\[["'](\w+)["']/i);
+        if (flaskMatch) {
+            const fpath = routerPrefix + flaskMatch[1];
+            if (fpath)
+                endpoints.push({ method: flaskMatch[2].toUpperCase(), path: fpath });
+        }
+    }
+    return endpoints;
+}
+export function parseEndpointsFromDiff(diffData) {
+    const lines = diffData.diffContent.split("\n");
+    const addedRoutes = [];
+    const removedKeys = new Set();
+    let currentFile = "";
+    for (const line of lines) {
+        const fileMatch = line.match(/^diff --git a\/.+ b\/(.+)$/);
+        if (fileMatch) {
+            currentFile = fileMatch[1];
+            continue;
+        }
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            const ep = parseRouteLine(line, currentFile);
+            if (ep)
+                addedRoutes.push(ep);
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            const ep = parseRouteLine(line, currentFile);
+            if (ep)
+                removedKeys.add(`${ep.method} ${ep.path}`);
+        }
+    }
+    const addedRouteKeys = new Set(addedRoutes.map((r) => r.path));
+    for (const file of diffData.changedFiles) {
+        const apiPath = nextjsFileToApiPath(file);
+        if (apiPath && !addedRouteKeys.has(apiPath)) {
+            addedRoutes.push({ method: "MULTI", path: apiPath, sourceFile: file });
+            addedRouteKeys.add(apiPath);
+        }
+    }
+    const newEndpoints = [];
+    const modifiedEndpoints = [];
+    for (const ep of addedRoutes) {
+        if (removedKeys.has(`${ep.method} ${ep.path}`)) {
+            modifiedEndpoints.push(ep);
+        }
+        else {
+            newEndpoints.push(ep);
+        }
+    }
+    const servicePattern = /(?:services?|modules?|apps?)\/([a-z0-9_-]+)/i;
+    const affectedServices = [
+        ...new Set(diffData.changedFiles
+            .map((f) => f.match(servicePattern)?.[1])
+            .filter((s) => !!s)),
+    ];
+    return {
+        currentBranch: diffData.currentBranch,
+        baseBranch: diffData.baseBranch,
+        changedFiles: diffData.changedFiles,
+        diffStat: diffData.diffStat,
+        newEndpoints,
+        modifiedEndpoints,
+        affectedServices,
+    };
+}

package/build/utils/routeParsers.test.js

@@ -0,0 +1,87 @@
+// @ts-ignore
+import { nextjsFileToApiPath, parseRouteLine } from "./routeParsers.js";
+describe("nextjsFileToApiPath", () => {
+    it("converts pages/api route to API path", () => {
+        expect(nextjsFileToApiPath("pages/api/users/index.ts")).toBe("/api/users");
+    });
+    it("converts pages/api nested dynamic route", () => {
+        expect(nextjsFileToApiPath("pages/api/users/[id].ts")).toBe("/api/users/{id}");
+    });
+    it("converts app/api route (App Router)", () => {
+        expect(nextjsFileToApiPath("app/api/products/route.ts")).toBe("/api/products");
+    });
+    it("converts app/api nested dynamic route", () => {
+        expect(nextjsFileToApiPath("app/api/products/[id]/route.ts")).toBe("/api/products/{id}");
+    });
+    it("returns null for non-API paths", () => {
+        expect(nextjsFileToApiPath("src/components/Button.tsx")).toBeNull();
+    });
+});
+describe("parseRouteLine", () => {
+    it("parses FastAPI decorator", () => {
+        const result = parseRouteLine('@app.get("/users")', "main.py");
+        expect(result).toEqual({ method: "GET", path: "/users", sourceFile: "main.py" });
+    });
+    it("parses FastAPI with router prefix", () => {
+        const result = parseRouteLine('@router.post("/items")', "routes.py");
+        expect(result).toEqual({ method: "POST", path: "/items", sourceFile: "routes.py" });
+    });
+    it("parses Flask decorator", () => {
+        const result = parseRouteLine('@app.route("/health", methods=["GET"])', "app.py");
+        expect(result).toEqual({ method: "GET", path: "/health", sourceFile: "app.py" });
+    });
+    it("parses Express route", () => {
+        const result = parseRouteLine('router.get("/api/products", handler)', "routes.ts");
+        expect(result).toEqual({ method: "GET", path: "/api/products", sourceFile: "routes.ts" });
+    });
+    it("parses NestJS decorator", () => {
+        const result = parseRouteLine('@Get("users/:id")', "users.controller.ts");
+        expect(result).toEqual({ method: "GET", path: "users/:id", sourceFile: "users.controller.ts" });
+    });
+    it("parses Spring annotation", () => {
+        const result = parseRouteLine('@GetMapping("/api/v1/orders")', "OrderController.java");
+        expect(result).toEqual({ method: "GET", path: "/api/v1/orders", sourceFile: "OrderController.java" });
+    });
+    it("parses Next.js App Router export", () => {
+        const result = parseRouteLine("export async function GET(request: Request) {", "app/api/items/route.ts");
+        expect(result).not.toBeNull();
+        expect(result.method).toBe("GET");
+    });
+    it("parses Gin route", () => {
+        const result = parseRouteLine('r.GET("/users", getUsers)', "main.go");
+        expect(result).toEqual({ method: "GET", path: "/users", sourceFile: "main.go" });
+    });
+    it("parses Gin group route", () => {
+        const result = parseRouteLine('api.POST("/products", createProduct)', "router.go");
+        expect(result).toEqual({ method: "POST", path: "/products", sourceFile: "router.go" });
+    });
+    it("parses Rails route", () => {
+        const result = parseRouteLine('get "/users", to: "users#index"', "routes.rb");
+        expect(result).toEqual({ method: "GET", path: "/users", sourceFile: "routes.rb" });
+    });
+    it("parses Laravel route", () => {
+        const result = parseRouteLine("Route::get('/api/users', [UserController::class, 'index'])", "api.php");
+        expect(result).toEqual({ method: "GET", path: "/api/users", sourceFile: "api.php" });
+    });
+    it("parses Actix attribute", () => {
+        const result = parseRouteLine('#[get("/health")]', "main.rs");
+        expect(result).toEqual({ method: "GET", path: "/health", sourceFile: "main.rs" });
+    });
+    it("parses ASP.NET HttpGet", () => {
+        const result = parseRouteLine('[HttpGet("users/{id}")]', "UsersController.cs");
+        expect(result).toEqual({ method: "GET", path: "users/{id}", sourceFile: "UsersController.cs" });
+    });
+    it("parses ASP.NET HttpPost without path", () => {
+        const result = parseRouteLine("[HttpPost]", "OrdersController.cs");
+        expect(result).toEqual({ method: "POST", path: "/", sourceFile: "OrdersController.cs" });
+    });
+    it("parses Hapi route", () => {
+        const result = parseRouteLine("{ method: 'GET', path: '/api/users' }", "server.js");
+        expect(result).toEqual({ method: "GET", path: "/api/users", sourceFile: "server.js" });
+    });
+    it("returns null for non-route lines", () => {
+        expect(parseRouteLine("const x = 42;", "app.ts")).toBeNull();
+        expect(parseRouteLine("// comment", "main.py")).toBeNull();
+        expect(parseRouteLine("import express from 'express';", "index.ts")).toBeNull();
+    });
+});