@skyramp/mcp 0.0.61 → 0.0.62

package/build/utils/repoScanner.js

@@ -0,0 +1,425 @@
+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];
+        }
+    }
+    // Java (Spring Boot): @RequestMapping prefix on controllers or config classes
+    for (const dir of searchDirs) {
+        const files = globRecursive(dir, [".java"]);
+        for (const f of files) {
+            if (!/controller|config|application/i.test(path.basename(f)))
+                continue;
+            let fc;
+            try {
+                fc = fs.readFileSync(f, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const requestMapping = fc.match(/@RequestMapping\s*\(\s*(?:value\s*=\s*)?["']([^"']+)["']/);
+            if (requestMapping && requestMapping[1].length > 1)
+                return requestMapping[1];
+        }
+    }
+    // Java: check application.properties/yml for context-path (including Maven src/main/resources)
+    const propSearchDirs = [...searchDirs];
+    for (const sub of ["src/main/resources", "config"]) {
+        const subDir = path.join(repositoryPath, sub);
+        if (fs.existsSync(subDir))
+            propSearchDirs.push(subDir);
+    }
+    for (const dir of propSearchDirs) {
+        for (const propFile of ["application.properties", "application.yml", "application.yaml"]) {
+            const full = path.join(dir, propFile);
+            if (!fs.existsSync(full))
+                continue;
+            let fc;
+            try {
+                fc = fs.readFileSync(full, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            // Flat format: server.servlet.context-path=/api/v1
+            const flatMatch = fc.match(/server\.servlet\.context-path\s*[=:]\s*(\S+)/);
+            if (flatMatch && flatMatch[1].length > 1)
+                return flatMatch[1];
+            // YAML nested format: context-path: /api/v1 (indented under server.servlet)
+            const yamlMatch = fc.match(/context-path\s*:\s*(\S+)/);
+            if (yamlMatch && yamlMatch[1].startsWith("/") && yamlMatch[1].length > 1)
+                return yamlMatch[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,
+    };
+}