@skyramp/mcp 0.1.2 → 0.1.3

package/build/tools/test-management/analyzeChangesTool.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import * as crypto from "crypto";
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
 import { simpleGit } from "simple-git";
 import { logger } from "../../utils/logger.js";
@@ -12,7 +13,7 @@ import { MAX_RECOMMENDATIONS, MAX_TESTS_TO_GENERATE } from "../../prompts/test-r
 import { TestDiscoveryService } from "../../services/TestDiscoveryService.js";
 import { ScenarioSource, AnalysisScope } from "../../types/RepositoryAnalysis.js";
 import { computeBranchDiff } from "../../utils/branchDiff.js";
-import { parseEndpointsFromDiff, resolveEndpointPaths, extractResourceFromPath, } from "../../utils/routeParsers.js";
+import { parseFileEndpoints, extractResourceFromPath, classifyEndpointsByChangedFiles, } from "../../utils/routeParsers.js";
 import { scanAllRepoEndpoints, scanRelatedEndpoints, grepRouterMountingContext, findCandidateRouteFiles, } from "../../utils/repoScanner.js";
 import { detectProjectMetadata } from "../../utils/projectMetadata.js";
 import { draftScenariosFromEndpoints } from "../../utils/scenarioDrafting.js";
@@ -151,6 +152,53 @@ const NON_APP_PATTERNS = [
 function isNonApplicationFile(filePath) {
     return NON_APP_PATTERNS.some((p) => p.test(filePath));
 }
+const ROUTE_FILE_PATTERN = /route|controller|endpoint|handler|view|urls|api|router/i;
+const SOURCE_EXTS = /\.(ts|tsx|js|jsx|py|java|kt|go|rb|php|rs|cs|ex|exs)$/;
+/**
+ * Recover endpoints from files deleted in this branch by reading their
+ * content from the base branch via `git show`. Only checks files whose
+ * name matches route-file heuristics to keep I/O bounded.
+ */
+async function recoverDeletedFileEndpoints(repositoryPath, baseBranch, deletedFiles) {
+    const candidates = deletedFiles.filter((f) => SOURCE_EXTS.test(f) && ROUTE_FILE_PATTERN.test(f));
+    if (candidates.length === 0)
+        return [];
+    const git = simpleGit(repositoryPath);
+    const results = [];
+    const endpointMap = new Map();
+    for (const file of candidates) {
+        try {
+            const content = await git.show([`${baseBranch}:${file}`]);
+            for (const ep of parseFileEndpoints(content, file)) {
+                const existing = endpointMap.get(ep.path);
+                if (existing) {
+                    existing.methods.add(ep.method);
+                }
+                else {
+                    endpointMap.set(ep.path, {
+                        methods: new Set([ep.method]),
+                        sourceFile: file,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            logger.debug("Failed to recover endpoints from deleted file", {
+                file,
+                baseBranch,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    for (const [apiPath, data] of endpointMap) {
+        results.push({
+            path: apiPath,
+            methods: Array.from(data.methods),
+            sourceFile: data.sourceFile,
+        });
+    }
+    return results;
+}
 export const analyzeChangesInputSchema = {
     repositoryPath: z
         .string()
@@ -267,17 +315,10 @@ to produce a unified state file for the test health workflow.
                     };
                 }
             }
-            await sendProgress(25, 100, "Parsing endpoints from diff...");
-            const parsedDiff = diffData
-                ? parseEndpointsFromDiff(diffData)
-                : undefined;
-            const newEndpoints = parsedDiff
-                ? parsedDiff.newEndpoints
-                : [];
             // ── Step 2: Scan endpoints ──
             let scannedEndpoints = [];
             if (analysisScope !== AnalysisScope.CurrentBranchDiff) {
-                await sendProgress(35, 100, "Scanning all repository endpoints...");
+                await sendProgress(25, 100, "Scanning all repository endpoints...");
                 try {
                     scannedEndpoints = scanAllRepoEndpoints(params.repositoryPath);
                     logger.info("Pre-scanned repo endpoints", {
@@ -291,7 +332,7 @@ to produce a unified state file for the test health workflow.
                 }
             }
             else if (diffData) {
-                await sendProgress(35, 100, "Scanning related endpoints from diff...");
+                await sendProgress(25, 100, "Scanning related endpoints from diff...");
                 try {
                     scannedEndpoints = scanRelatedEndpoints(params.repositoryPath, diffData.changedFiles);
                     logger.info("Scanned related endpoints", {
@@ -303,32 +344,68 @@ to produce a unified state file for the test health workflow.
                         error: err instanceof Error ? err.message : String(err),
                     });
                 }
-                if (scannedEndpoints.length === 0) {
-                    try {
-                        scannedEndpoints = scanAllRepoEndpoints(params.repositoryPath);
-                        logger.info("Fallback: scanned all repo endpoints", {
-                            count: scannedEndpoints.length,
-                        });
-                    }
-                    catch (err) {
-                        logger.warning("Full repo scan fallback also failed", {
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                    }
-                }
+                // No fallback to scanAllRepoEndpoints in PR mode.
+                // If the scanner found 0 related endpoints, the PR likely touches
+                // non-route code (services, models, schemas, client SDK). Flooding
+                // all repo endpoints into the prompt causes the LLM to test
+                // irrelevant neighboring endpoints instead of focusing on the diff.
+            }
+            await sendProgress(40, 100, "Classifying changed endpoints...");
+            // ── Step 2.5: Classify endpoints by changed files ──
+            // Cross-reference changedFiles against scannedEndpoints[].sourceFile to
+            // identify new/modified/removed endpoints — replaces fragile regex parsing
+            // of diff hunks. Scanned endpoints always have full paths and concrete
+            // HTTP methods, eliminating the need for path resolution and MULTI sentinels.
+            let classifiedEndpoints;
+            if (diffData) {
+                // Recover endpoints from deleted files by reading base-branch content
+                const deletedFileEndpoints = diffData.deletedFiles.length > 0
+                    ? await recoverDeletedFileEndpoints(params.repositoryPath, diffData.baseBranch, diffData.deletedFiles)
+                    : [];
+                classifiedEndpoints = classifyEndpointsByChangedFiles(diffData, scannedEndpoints, deletedFileEndpoints);
+                logger.info("Classified endpoints from changed files", {
+                    changed: classifiedEndpoints.changedEndpoints.length,
+                    new: classifiedEndpoints.newEndpoints.length,
+                    removed: classifiedEndpoints.removedEndpoints.length,
+                    unmatched: classifiedEndpoints.unmatchedFiles.length,
+                });
             }
             await sendProgress(50, 100, "Discovering existing tests...");
             // ── Step 3: Discover existing tests ──
-            // In PR mode, extract resource names from the diff endpoints so that
-            // TestDiscoveryService can limit full extraction to relevant files only.
-            const changedResources = parsedDiff
-                ? [
-                    ...parsedDiff.newEndpoints,
-                    ...parsedDiff.modifiedEndpoints,
-                ]
-                    .map(ep => extractResourceFromPath(ep.path))
-                    .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i)
-                : [];
+            // Compute changedResources from classified endpoints for test discovery filtering.
+            // undefined    → full-repo mode (no diff context)
+            // []           → PR mode, no endpoints found → skip external tests
+            // [...names]   → PR mode with resolved resource names → filter external by relevance
+            let changedResources;
+            if (!classifiedEndpoints) {
+                changedResources = undefined;
+            }
+            else {
+                const allClassified = [
+                    ...classifiedEndpoints.changedEndpoints,
+                    ...classifiedEndpoints.newEndpoints,
+                    ...classifiedEndpoints.removedEndpoints,
+                ];
+                if (allClassified.length > 0) {
+                    // Scanned endpoints always have full paths — extractResourceFromPath
+                    // never returns "unknown" for properly resolved paths.
+                    const resolved = allClassified
+                        .map((ep) => extractResourceFromPath(ep.path))
+                        .filter((r, i, arr) => r !== "unknown" && arr.indexOf(r) === i);
+                    changedResources = resolved.length > 0 ? resolved : ["unknown"];
+                }
+                else if (classifiedEndpoints.unmatchedFiles.length > 0) {
+                    // Changed files don't map to any endpoint (e.g. schema, model, or
+                    // migration changes near route files). Use ["unknown"] so external
+                    // tests get name-only entries — enough for the LLM to infer coverage
+                    // from filenames without flooding context with full extraction of
+                    // hundreds of irrelevant test files.
+                    changedResources = ["unknown"];
+                }
+                else {
+                    changedResources = [];
+                }
+            }
             let existingTests = [];
             let discoveredRelevantExternalPaths = [];
             try {
@@ -427,71 +504,30 @@ to produce a unified state file for the test health workflow.
                 : method === "DELETE"
                     ? { statusCode: 204, description: "No Content" }
                     : { statusCode: 200, description: "OK" };
-            const skeletonEndpoints = scannedEndpoints.length > 0
-                ? scannedEndpoints.map((ep) => ({
-                    path: ep.path,
-                    resourceGroup: ep.path.split("/").filter(Boolean).pop() || "unknown",
-                    pathParams: (ep.path.match(/\{(\w+)\}/g) || []).map((p) => ({
-                        name: p.slice(1, -1),
-                        type: "string",
-                        required: true,
-                    })),
-                    methods: ep.methods.map((m) => ({
-                        method: m,
-                        description: "",
-                        queryParams: [],
-                        authRequired: true,
-                        sourceFile: ep.sourceFile,
-                        interactions: [
-                            {
-                                description: `${m} ${ep.path}`,
-                                type: "success",
-                                request: {},
-                                response: skeletonResponse(m),
-                            },
-                        ],
-                    })),
-                }))
-                : parsedDiff
-                    ? (() => {
-                        const grouped = new Map();
-                        for (const ep of [
-                            ...parsedDiff.newEndpoints,
-                            ...parsedDiff.modifiedEndpoints,
-                        ]) {
-                            let entry = grouped.get(ep.path);
-                            if (!entry) {
-                                entry = {
-                                    path: ep.path,
-                                    resourceGroup: ep.path.split("/").filter(Boolean).pop() || "unknown",
-                                    pathParams: (ep.path.match(/\{(\w+)\}/g) || []).map((p) => ({
-                                        name: p.slice(1, -1),
-                                        type: "string",
-                                        required: true,
-                                    })),
-                                    methods: [],
-                                };
-                                grouped.set(ep.path, entry);
-                            }
-                            entry.methods.push({
-                                method: ep.method,
-                                description: "",
-                                queryParams: [],
-                                authRequired: true,
-                                sourceFile: ep.sourceFile,
-                                interactions: [
-                                    {
-                                        description: `${ep.method} ${ep.path}`,
-                                        type: "success",
-                                        request: {},
-                                        response: skeletonResponse(ep.method),
-                                    },
-                                ],
-                            });
-                        }
-                        return Array.from(grouped.values());
-                    })()
-                    : [];
+            const skeletonEndpoints = scannedEndpoints.map((ep) => ({
+                path: ep.path,
+                resourceGroup: ep.path.split("/").filter(Boolean).pop() || "unknown",
+                pathParams: (ep.path.match(/\{(\w+)\}/g) || []).map((p) => ({
+                    name: p.slice(1, -1),
+                    type: "string",
+                    required: true,
+                })),
+                methods: ep.methods.map((m) => ({
+                    method: m,
+                    description: "",
+                    queryParams: [],
+                    authRequired: true,
+                    sourceFile: ep.sourceFile,
+                    interactions: [
+                        {
+                            description: `${m} ${ep.path}`,
+                            type: "success",
+                            request: {},
+                            response: skeletonResponse(m),
+                        },
+                    ],
+                })),
+            }));
             // ── Step 8: Merge trace interactions ──
             if (traceResult && traceResult.entries.length > 0) {
                 for (const entry of traceResult.entries) {
@@ -536,16 +572,18 @@ to produce a unified state file for the test health workflow.
                     }
                 }
             }
-            // ── Step 8.5: Resolve diff-parsed endpoint paths ──
-            // The diff parser extracts route-decorator-relative paths (e.g. "/{order_id}")
-            // because the router prefix is usually outside the diff hunk. Match against
-            // the authoritative scanned endpoints to recover the full API path.
-            if (parsedDiff && skeletonEndpoints.length > 0) {
-                resolveEndpointPaths(parsedDiff.newEndpoints, skeletonEndpoints);
-                resolveEndpointPaths(parsedDiff.modifiedEndpoints, skeletonEndpoints);
-            }
             // ── Step 9: Draft scenarios ──
-            const codeInferredScenarios = draftScenariosFromEndpoints(skeletonEndpoints, parsedDiff?.newEndpoints ?? []);
+            // Only new endpoints are passed as "diff-direct" — draftDiffDirectScenarios
+            // generates success-oriented scenarios (200/201/204) which are wrong for
+            // removed endpoints. Removal coverage (verify-404) is handled by the LLM
+            // from the diffContext.removedEndpoints signal in the recommendation prompt.
+            // Classified endpoints have full paths and concrete methods (no MULTI sentinels).
+            const newEndpointsForDrafting = classifiedEndpoints?.newEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                method: m,
+                path: ep.path,
+                sourceFile: ep.sourceFile,
+            }))) ?? [];
+            const codeInferredScenarios = draftScenariosFromEndpoints(skeletonEndpoints, newEndpointsForDrafting);
             let allDraftedScenarios = codeInferredScenarios;
             if (traceResult && traceResult.userFlows.length > 0) {
                 const traceScenarios = traceResult.userFlows
@@ -642,35 +680,37 @@ to produce a unified state file for the test health workflow.
             const relevantExternalTestPaths = discoveredRelevantExternalPaths.map(p => path.relative(params.repositoryPath, p));
             // Build the full RepositoryAnalysis object — same structure as analyzeRepositoryTool
             // so buildRecommendationPrompt can reason over enriched endpoint + scenario data
-            const diffContext = parsedDiff ? {
-                currentBranch: parsedDiff.currentBranch,
-                baseBranch: parsedDiff.baseBranch,
-                changedFiles: parsedDiff.changedFiles,
-                newEndpoints: (() => {
-                    const grouped = new Map();
-                    for (const ep of parsedDiff.newEndpoints) {
-                        let entry = grouped.get(ep.path);
-                        if (!entry) {
-                            entry = { path: ep.path, methods: [] };
-                            grouped.set(ep.path, entry);
-                        }
-                        entry.methods.push({ method: ep.method, sourceFile: ep.sourceFile, interactionCount: 0 });
-                    }
-                    return Array.from(grouped.values());
-                })(),
-                modifiedEndpoints: (() => {
-                    const grouped = new Map();
-                    for (const ep of parsedDiff.modifiedEndpoints) {
-                        let entry = grouped.get(ep.path);
-                        if (!entry) {
-                            entry = { path: ep.path, methods: [] };
-                            grouped.set(ep.path, entry);
-                        }
-                        entry.methods.push({ method: ep.method, sourceFile: ep.sourceFile, changeType: "modified" });
-                    }
-                    return Array.from(grouped.values());
-                })(),
-                affectedServices: parsedDiff.affectedServices,
+            // Build diffContext from classifiedEndpoints — ScannedEndpoint already
+            // has full paths and concrete methods, so no grouping/MULTI handling needed.
+            const diffContext = classifiedEndpoints ? {
+                currentBranch: classifiedEndpoints.currentBranch,
+                baseBranch: classifiedEndpoints.baseBranch,
+                changedFiles: classifiedEndpoints.changedFiles,
+                newEndpoints: classifiedEndpoints.newEndpoints.map((ep) => ({
+                    path: ep.path,
+                    methods: ep.methods.map((m) => ({
+                        method: m,
+                        sourceFile: ep.sourceFile,
+                        interactionCount: 0,
+                    })),
+                })),
+                modifiedEndpoints: classifiedEndpoints.changedEndpoints.map((ep) => ({
+                    path: ep.path,
+                    methods: ep.methods.map((m) => ({
+                        method: m,
+                        sourceFile: ep.sourceFile,
+                        changeType: "modified",
+                    })),
+                })),
+                removedEndpoints: classifiedEndpoints.removedEndpoints.map((ep) => ({
+                    path: ep.path,
+                    methods: ep.methods.map((m) => ({
+                        method: m,
+                        sourceFile: ep.sourceFile,
+                        changeType: "removed",
+                    })),
+                })),
+                affectedServices: classifiedEndpoints.affectedServices,
                 summary: "",
             } : undefined;
             const fullAnalysis = {
@@ -752,7 +792,7 @@ to produce a unified state file for the test health workflow.
                 : undefined;
             const unifiedState = {
                 existingTests,
-                newEndpoints,
+                newEndpoints: newEndpointsForDrafting,
                 analysisScope,
                 repositoryAnalysis: {
                     skeletonEndpoints,
@@ -764,7 +804,35 @@ to produce a unified state file for the test health workflow.
                     wsSchemaPath,
                     wsAuthMethod,
                     scenarios: allDraftedScenarios,
-                    diff: parsedDiff,
+                    diff: classifiedEndpoints
+                        ? {
+                            currentBranch: classifiedEndpoints.currentBranch,
+                            baseBranch: classifiedEndpoints.baseBranch,
+                            changedFiles: classifiedEndpoints.changedFiles,
+                            newEndpoints: classifiedEndpoints.newEndpoints.map((ep) => ({
+                                path: ep.path,
+                                methods: ep.methods.map((m) => ({
+                                    method: m,
+                                    sourceFile: ep.sourceFile,
+                                })),
+                            })),
+                            modifiedEndpoints: classifiedEndpoints.changedEndpoints.map((ep) => ({
+                                path: ep.path,
+                                methods: ep.methods.map((m) => ({
+                                    method: m,
+                                    sourceFile: ep.sourceFile,
+                                })),
+                            })),
+                            removedEndpoints: classifiedEndpoints.removedEndpoints.map((ep) => ({
+                                path: ep.path,
+                                methods: ep.methods.map((m) => ({
+                                    method: m,
+                                    sourceFile: ep.sourceFile,
+                                })),
+                            })),
+                            affectedServices: classifiedEndpoints.affectedServices,
+                        }
+                        : undefined,
                     sessionId,
                     routerMountContext,
                     candidateRouteFiles,
@@ -780,6 +848,24 @@ to produce a unified state file for the test health workflow.
             catch (error) {
                 logger.warning(`Failed to cleanup old state files: ${error.message}`);
             }
+            // Clean up old diff temp files (>24 hours) from previous invocations
+            try {
+                const tmpDir = os.tmpdir();
+                const entries = await fs.promises.readdir(tmpDir);
+                const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+                for (const entry of entries) {
+                    if (!entry.startsWith("skyramp-diff-") || !entry.endsWith(".diff"))
+                        continue;
+                    const fullPath = path.join(tmpDir, entry);
+                    const stat = await fs.promises.stat(fullPath).catch(() => null);
+                    if (stat && stat.mtimeMs < cutoff) {
+                        await fs.promises.unlink(fullPath).catch(() => { });
+                    }
+                }
+            }
+            catch {
+                // Non-critical — temp cleanup failure should not block analysis
+            }
             const stateManager = new StateManager("analysis", sessionId, undefined, params.stateOutputFile);
             await stateManager.writeData(unifiedState, {
                 repositoryPath: params.repositoryPath,
@@ -842,18 +928,51 @@ to produce a unified state file for the test health workflow.
                     projectType: projectMeta.projectType,
                     primaryFramework: projectMeta.primaryFramework,
                     existingTestCount: existingTests.length,
-                    newEndpointCount: newEndpoints.length,
+                    newEndpointCount: classifiedEndpoints?.newEndpoints.length ?? 0,
                     endpointCount: skeletonEndpoints.reduce((acc, ep) => acc + ep.methods.length, 0),
                 },
                 stateFileSize: stateSize,
                 nextStep: "Call skyramp_analyze_test_health with stateFile to run drift analysis and health scoring",
             }, null, 2);
+            // Build a DiffSummary for buildAnalysisOutputText from classified endpoints.
+            const parsedDiffShim = classifiedEndpoints
+                ? {
+                    currentBranch: classifiedEndpoints.currentBranch,
+                    baseBranch: classifiedEndpoints.baseBranch,
+                    changedFiles: classifiedEndpoints.changedFiles,
+                    diffStat: diffData?.diffStat ?? "",
+                    newEndpoints: classifiedEndpoints.newEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                        method: m,
+                        path: ep.path,
+                        sourceFile: ep.sourceFile,
+                    }))),
+                    modifiedEndpoints: classifiedEndpoints.changedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                        method: m,
+                        path: ep.path,
+                        sourceFile: ep.sourceFile,
+                    }))),
+                    removedEndpoints: classifiedEndpoints.removedEndpoints.flatMap((ep) => ep.methods.map((m) => ({
+                        method: m,
+                        path: ep.path,
+                        sourceFile: ep.sourceFile,
+                    }))),
+                    affectedServices: classifiedEndpoints.affectedServices,
+                }
+                : undefined;
+            // Write the full diff to a temp file so the LLM can read it on demand
+            // rather than embedding potentially large content inline in the prompt.
+            let diffFilePath;
+            if (diffData?.diffContent) {
+                diffFilePath = path.join(os.tmpdir(), `skyramp-diff-${sessionId}.diff`);
+                await fs.promises.writeFile(diffFilePath, diffData.diffContent, { encoding: "utf-8", mode: 0o600 });
+            }
             const outputText = buildAnalysisOutputText({
                 sessionId,
                 stateFile,
                 repositoryPath: params.repositoryPath,
                 analysisScope,
-                parsedDiff,
+                parsedDiff: parsedDiffShim,
+                diffFilePath,
                 diffContent: diffData?.diffContent,
                 candidateRouteFiles,
                 scannedEndpoints,

package/build/tools/test-management/analyzeChangesTool.test.js

@@ -21,7 +21,9 @@ jest.mock("../../utils/branchDiff.js", () => ({
     computeBranchDiff: jest.fn(),
 }));
 jest.mock("../../utils/routeParsers.js", () => ({
-    parseEndpointsFromDiff: jest.fn(),
+    classifyEndpointsByChangedFiles: jest.fn(),
+    extractResourceFromPath: jest.fn(),
+    parseFileEndpoints: jest.fn(),
 }));
 jest.mock("../../utils/repoScanner.js", () => ({
     scanAllRepoEndpoints: jest.fn(),

package/build/tools/test-management/analyzeTestHealthTool.js

@@ -94,6 +94,11 @@ exist only in the LLM's reasoning context and are acted on by \`skyramp_actions\
                         .map((e) => e.methods ? e.methods.map((m) => `${m.method} ${e.path}`).join(", ") : `${e.method} ${e.path}`)
                         .join(", ")}`);
                 }
+                if (diff.removedEndpoints?.length > 0) {
+                    lines.push(`**Removed Endpoints** (${diff.removedEndpoints.length}): ${diff.removedEndpoints
+                        .map((e) => e.methods ? e.methods.map((m) => `${m.method} ${e.path}`).join(", ") : `${e.method} ${e.path}`)
+                        .join(", ")}`);
+                }
                 parsedDiffText = lines.join("\n");
             }
             const scannedEndpoints = stateData.repositoryAnalysis?.skeletonEndpoints || [];

package/build/types/RepositoryAnalysis.js

@@ -128,6 +128,14 @@ export const branchDiffContextSchema = z.object({
             changeType: z.enum(["added", "modified", "removed"]),
         })),
     })),
+    removedEndpoints: z.array(z.object({
+        path: z.string(),
+        methods: z.array(z.object({
+            method: z.string(),
+            sourceFile: z.string(),
+            changeType: z.literal("removed"),
+        })),
+    })).optional(),
     affectedServices: z.array(z.string()),
     summary: z.string().optional(),
 });

package/build/utils/branchDiff.js

@@ -1,10 +1,30 @@
 import { simpleGit } from "simple-git";
 import { logger } from "./logger.js";
-const MAX_DIFF_LENGTH = 50_000;
 /**
  * Try a git diff against the given ref. Returns undefined if the ref doesn't exist
  * or the diff fails, so the caller can try the next candidate.
  */
+/** Parse diff headers to find newly created and deleted files. */
+function parseNewAndDeletedFiles(rawDiff) {
+    const newFiles = [];
+    const deletedFiles = [];
+    const lines = rawDiff.split("\n");
+    let currentFile = "";
+    for (const line of lines) {
+        const fileMatch = line.match(/^diff --git a\/.+ b\/(.+)$/);
+        if (fileMatch) {
+            currentFile = fileMatch[1];
+            continue;
+        }
+        if (line === "--- /dev/null" && currentFile) {
+            newFiles.push(currentFile);
+        }
+        else if (line === "+++ /dev/null" && currentFile) {
+            deletedFiles.push(currentFile);
+        }
+    }
+    return { newFiles, deletedFiles };
+}
 async function tryDiff(git, ref) {
     try {
         const changedFilesRaw = await git.diff([`${ref}...HEAD`, "--name-only"]);
@@ -13,13 +33,9 @@ async function tryDiff(git, ref) {
             .map((f) => f.trim())
             .filter((f) => f.length > 0);
         const diffStat = await git.diff([`${ref}...HEAD`, "--stat"]);
-        let diffContent = await git.diff([`${ref}...HEAD`]);
-        if (diffContent.length > MAX_DIFF_LENGTH) {
-            diffContent =
-                diffContent.substring(0, MAX_DIFF_LENGTH) +
-                    `\n\n... [diff truncated at ${MAX_DIFF_LENGTH} chars, ${changedFiles.length} files total] ...`;
-        }
-        return { changedFiles, diffContent, diffStat };
+        const fullDiff = await git.diff([`${ref}...HEAD`]);
+        const { newFiles, deletedFiles } = parseNewAndDeletedFiles(fullDiff);
+        return { changedFiles, diffContent: fullDiff, diffStat, newFiles, deletedFiles };
     }
     catch (err) {
         logger.debug(`tryDiff against ${ref} failed`, { error: err instanceof Error ? err.message : String(err) });

package/build/utils/repoScanner.js

@@ -1,13 +1,15 @@
 import * as fs from "fs";
 import * as path from "path";
 import { nextjsFileToApiPath, parseFileEndpoints, } from "./routeParsers.js";
+import { logger } from "./logger.js";
 function globRecursive(dir, extensions) {
     const results = [];
     let entries;
     try {
         entries = fs.readdirSync(dir, { withFileTypes: true });
     }
-    catch {
+    catch (err) {
+        logger.debug("globRecursive: skipping directory", { dir, error: err instanceof Error ? err.message : String(err) });
         return results;
     }
     for (const entry of entries) {
@@ -201,7 +203,19 @@ export function findCandidateRouteFiles(repositoryPath) {
             }
         }
     }
-    return [...byName, ...byContent].slice(0, MAX_CANDIDATE_FILES);
+    const combined = [...byName, ...byContent];
+    const contentPassSkipped = byName.length >= MAX_CANDIDATE_FILES;
+    const result = combined.slice(0, MAX_CANDIDATE_FILES);
+    if (combined.length > MAX_CANDIDATE_FILES) {
+        logger.warning("findCandidateRouteFiles: hit MAX_CANDIDATE_FILES cap — some route files may be excluded from LLM analysis", {
+            cap: MAX_CANDIDATE_FILES,
+            byName: byName.length,
+            byContent: byContent.length,
+            contentPassSkipped,
+            totalFound: combined.length,
+        });
+    }
+    return result;
 }
 export function scanAllRepoEndpoints(repositoryPath) {
     const endpointMap = new Map();