@ank1015/llm 0.0.1 → 0.0.3

package/vendor/web/standalone/node_modules/next/dist/server/mcp/tools/get-routes.js

@@ -0,0 +1,136 @@
+/**
+ * MCP tool for getting all routes that become entry points in a Next.js application.
+ *
+ * This tool discovers routes by scanning the filesystem directly. It finds all route
+ * files in the app/ and pages/ directories and converts them to route paths.
+ *
+ * Returns routes grouped by router type:
+ * - appRouter: App Router pages and route handlers
+ * - pagesRouter: Pages Router pages and API routes
+ *
+ * Dynamic route segments appear as [id], [slug], or [...slug] patterns. This tool
+ * does NOT expand getStaticParams - it only shows the route patterns as defined in
+ * the filesystem.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerGetRoutesTool", {
+    enumerable: true,
+    get: function() {
+        return registerGetRoutesTool;
+    }
+});
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+const _routediscovery = require("../../../build/route-discovery");
+const _zod = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/zod"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function registerGetRoutesTool(server, options) {
+    server.registerTool('get_routes', {
+        description: 'Get all routes that will become entry points in the Next.js application by scanning the filesystem. Returns routes grouped by router type (appRouter, pagesRouter). Dynamic segments appear as [param] or [...slug] patterns. API routes are included in their respective routers (e.g., /api/* routes from pages/ are in pagesRouter). Optional parameter: routerType ("app" | "pages") - filter by specific router type, omit to get all routes.',
+        inputSchema: {
+            routerType: _zod.default.union([
+                _zod.default.literal('app'),
+                _zod.default.literal('pages')
+            ]).optional()
+        }
+    }, async (request)=>{
+        // Track telemetry
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_routes');
+        try {
+            const routerType = request.routerType === 'app' || request.routerType === 'pages' ? request.routerType : undefined;
+            const { projectPath, nextConfig, pagesDir, appDir } = options;
+            // Check if we have any directories to scan
+            if (!pagesDir && !appDir) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'No pages or app directory found in the project.'
+                            })
+                        }
+                    ]
+                };
+            }
+            const isSrcDir = pagesDir && pagesDir.includes('/src/') || appDir && appDir.includes('/src/');
+            const commonOpts = {
+                pageExtensions: nextConfig.pageExtensions,
+                isDev: true,
+                baseDir: projectPath,
+                isSrcDir: !!isSrcDir
+            };
+            // Discover app and pages routes independently so a failure in one
+            // router doesn't prevent the other from returning results.
+            let appRoutes = [];
+            let pageRoutes = [];
+            const wantApp = routerType !== 'pages' && appDir;
+            const wantPages = routerType !== 'app' && pagesDir;
+            const [appResult, pagesResult] = await Promise.all([
+                wantApp ? (0, _routediscovery.discoverRoutes)({
+                    ...commonOpts,
+                    appDir
+                }).catch(()=>null) : null,
+                wantPages ? (0, _routediscovery.discoverRoutes)({
+                    ...commonOpts,
+                    pagesDir
+                }).catch(()=>null) : null
+            ]);
+            if (appResult) {
+                appRoutes = [
+                    ...appResult.appRoutes,
+                    ...appResult.appRouteHandlers
+                ].map((r)=>r.route).sort();
+            }
+            if (pagesResult) {
+                pageRoutes = [
+                    ...pagesResult.pageRoutes,
+                    ...pagesResult.pageApiRoutes
+                ].map((r)=>r.route).sort();
+            }
+            if (appRoutes.length === 0 && pageRoutes.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                appRouter: [],
+                                pagesRouter: []
+                            })
+                        }
+                    ]
+                };
+            }
+            // Format the output with grouped routes
+            const output = {
+                appRouter: appRoutes.length > 0 ? appRoutes : undefined,
+                pagesRouter: pageRoutes.length > 0 ? pageRoutes : undefined
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(output, null, 2)
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error)
+                        })
+                    }
+                ]
+            };
+        }
+    });
+}
+
+//# sourceMappingURL=get-routes.js.map

package/vendor/web/standalone/node_modules/next/dist/server/mcp/tools/get-server-action-by-id.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "registerGetActionByIdTool", {
+    enumerable: true,
+    get: function() {
+        return registerGetActionByIdTool;
+    }
+});
+const _zod = require("next/dist/compiled/zod");
+const _fs = require("fs");
+const _path = require("path");
+const _mcptelemetrytracker = require("../mcp-telemetry-tracker");
+const INLINE_ACTION_PREFIX = '$$RSC_SERVER_ACTION_';
+function registerGetActionByIdTool(server, distDir) {
+    server.registerTool('get_server_action_by_id', {
+        description: 'Locates a Server Action by its ID in the server-reference-manifest.json. Returns the filename and export name for the action.',
+        inputSchema: {
+            actionId: _zod.z.string()
+        }
+    }, async (request)=>{
+        // Track telemetry
+        _mcptelemetrytracker.mcpTelemetryTracker.recordToolCall('mcp/get_server_action_by_id');
+        try {
+            const { actionId } = request;
+            if (!actionId) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'actionId parameter is required'
+                            })
+                        }
+                    ]
+                };
+            }
+            const manifestPath = (0, _path.join)(distDir, 'server', 'server-reference-manifest.json');
+            let manifestContent;
+            try {
+                manifestContent = await _fs.promises.readFile(manifestPath, 'utf-8');
+            } catch (error) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `Could not read server-reference-manifest.json at ${manifestPath}.`
+                            })
+                        }
+                    ]
+                };
+            }
+            const manifest = JSON.parse(manifestContent);
+            // Search in node entries
+            if (manifest.node && manifest.node[actionId]) {
+                const entry = manifest.node[actionId];
+                const isInlineAction = entry.exportedName.startsWith(INLINE_ACTION_PREFIX);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                actionId,
+                                runtime: 'node',
+                                filename: entry.filename,
+                                functionName: isInlineAction ? 'inline server action' : entry.exportedName,
+                                layer: entry.layer,
+                                workers: entry.workers
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            // Search in edge entries
+            if (manifest.edge && manifest.edge[actionId]) {
+                const entry = manifest.edge[actionId];
+                const isInlineAction = entry.exportedName.startsWith(INLINE_ACTION_PREFIX);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                actionId,
+                                runtime: 'edge',
+                                filename: entry.filename,
+                                functionName: isInlineAction ? 'inline server action' : entry.exportedName,
+                                layer: entry.layer,
+                                workers: entry.workers
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Action ID "${actionId}" not found in server-reference-manifest.json`
+                        })
+                    }
+                ]
+            };
+        } catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : String(error)
+                        })
+                    }
+                ]
+            };
+        }
+    });
+}
+
+//# sourceMappingURL=get-server-action-by-id.js.map

package/vendor/web/standalone/node_modules/next/dist/server/mcp/tools/next-instance-error-state.js

@@ -0,0 +1,31 @@
+/**
+ * Global error state for Next.js instance-level errors that are not associated
+ * with a specific browser session or route. This state is exposed through the MCP server's `get_errors`
+ * tool as well. This covers the errors that are global to the Next.js instance, such as errors in next.config.js.
+ *
+ *
+ * ## Usage
+ *
+ * This state is directly manipulated by various parts of the Next.js dev server:
+ *
+ * // Reset the error state
+ * NextInstanceErrorState.[errorType] = []
+ *
+ * // Capture an error for a specific error type
+ * NextInstanceErrorState.[errorType].push(err)
+ *
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NextInstanceErrorState", {
+    enumerable: true,
+    get: function() {
+        return NextInstanceErrorState;
+    }
+});
+const NextInstanceErrorState = {
+    nextConfig: []
+};
+
+//# sourceMappingURL=next-instance-error-state.js.map

package/vendor/web/standalone/node_modules/next/dist/server/mcp/tools/utils/browser-communication.js

@@ -0,0 +1,90 @@
+/**
+ * Shared utilities for MCP tools that communicate with the browser.
+ * This module provides a common infrastructure for request-response
+ * communication between MCP endpoints and browser sessions via HMR.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    DEFAULT_BROWSER_REQUEST_TIMEOUT_MS: null,
+    createBrowserRequest: null,
+    handleBrowserPageResponse: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    DEFAULT_BROWSER_REQUEST_TIMEOUT_MS: function() {
+        return DEFAULT_BROWSER_REQUEST_TIMEOUT_MS;
+    },
+    createBrowserRequest: function() {
+        return createBrowserRequest;
+    },
+    handleBrowserPageResponse: function() {
+        return handleBrowserPageResponse;
+    }
+});
+const _nanoid = require("next/dist/compiled/nanoid");
+const DEFAULT_BROWSER_REQUEST_TIMEOUT_MS = 5000;
+const pendingRequests = new Map();
+function createBrowserRequest(messageType, sendHmrMessage, getActiveConnectionCount, timeoutMs) {
+    const connectionCount = getActiveConnectionCount();
+    if (connectionCount === 0) {
+        return Promise.resolve([]);
+    }
+    const requestId = `mcp-${messageType}-${(0, _nanoid.nanoid)()}`;
+    const responsePromise = new Promise((resolve, reject)=>{
+        const timeout = setTimeout(()=>{
+            const pending = pendingRequests.get(requestId);
+            if (pending && pending.responses.length > 0) {
+                resolve(pending.responses);
+            } else {
+                reject(Object.defineProperty(new Error(`Timeout waiting for response from frontend. The browser may not be responding to HMR messages.`), "__NEXT_ERROR_CODE", {
+                    value: "E825",
+                    enumerable: false,
+                    configurable: true
+                }));
+            }
+            pendingRequests.delete(requestId);
+        }, timeoutMs);
+        pendingRequests.set(requestId, {
+            responses: [],
+            expectedCount: connectionCount,
+            resolve: resolve,
+            reject,
+            timeout
+        });
+    });
+    sendHmrMessage({
+        type: messageType,
+        requestId
+    });
+    return responsePromise;
+}
+function handleBrowserPageResponse(requestId, data, url) {
+    if (!url) {
+        throw Object.defineProperty(new Error('URL is required in MCP browser response. This is a bug in Next.js.'), "__NEXT_ERROR_CODE", {
+            value: "E824",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const pending = pendingRequests.get(requestId);
+    if (pending) {
+        pending.responses.push({
+            url,
+            data
+        });
+        if (pending.responses.length >= pending.expectedCount) {
+            clearTimeout(pending.timeout);
+            pending.resolve(pending.responses);
+            pendingRequests.delete(requestId);
+        }
+    }
+}
+
+//# sourceMappingURL=browser-communication.js.map

package/vendor/web/standalone/node_modules/next/dist/server/mcp/tools/utils/format-errors.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    formatErrors: null,
+    setStackFrameResolver: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    formatErrors: function() {
+        return formatErrors;
+    },
+    setStackFrameResolver: function() {
+        return setStackFrameResolver;
+    }
+});
+const _errorsource = require("../../../../shared/lib/error-source");
+// Dependency injection for stack frame resolver
+let stackFrameResolver;
+function setStackFrameResolver(fn) {
+    stackFrameResolver = fn;
+}
+async function resolveStackFrames(request) {
+    if (!stackFrameResolver) {
+        throw Object.defineProperty(new Error('Stack frame resolver not initialized. This is a bug in Next.js.'), "__NEXT_ERROR_CODE", {
+            value: "E822",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    return stackFrameResolver(request);
+}
+const formatStackFrameToObject = (frame)=>{
+    return {
+        file: frame.file || '<unknown>',
+        methodName: frame.methodName || '<anonymous>',
+        line: frame.line1,
+        column: frame.column1
+    };
+};
+const resolveErrorFrames = async (frames, context)=>{
+    try {
+        const resolvedFrames = await resolveStackFrames({
+            frames: frames.map((frame)=>({
+                    file: frame.file || null,
+                    methodName: frame.methodName || '<anonymous>',
+                    arguments: [],
+                    line1: frame.line1 || null,
+                    column1: frame.column1 || null
+                })),
+            isServer: context.isServer,
+            isEdgeServer: context.isEdgeServer,
+            isAppDirectory: context.isAppDirectory
+        });
+        return resolvedFrames.filter((resolvedFrame)=>{
+            var _resolvedFrame_value_originalStackFrame;
+            return !(resolvedFrame.status === 'fulfilled' && ((_resolvedFrame_value_originalStackFrame = resolvedFrame.value.originalStackFrame) == null ? void 0 : _resolvedFrame_value_originalStackFrame.ignored));
+        }).map((resolvedFrame, j)=>resolvedFrame.status === 'fulfilled' && resolvedFrame.value.originalStackFrame ? formatStackFrameToObject(resolvedFrame.value.originalStackFrame) : formatStackFrameToObject(frames[j]));
+    } catch  {
+        return frames.map(formatStackFrameToObject);
+    }
+};
+async function formatRuntimeErrorsToObjects(errors, isAppDirectory) {
+    const formattedErrors = [];
+    for (const error of errors){
+        var _error_error, _error_error1, _error_frames;
+        const errorName = ((_error_error = error.error) == null ? void 0 : _error_error.name) || 'Error';
+        const errorMsg = ((_error_error1 = error.error) == null ? void 0 : _error_error1.message) || 'Unknown error';
+        let stack = [];
+        if ((_error_frames = error.frames) == null ? void 0 : _error_frames.length) {
+            const errorSource = (0, _errorsource.getErrorSource)(error.error);
+            stack = await resolveErrorFrames(error.frames, {
+                isServer: errorSource === 'server',
+                isEdgeServer: errorSource === 'edge-server',
+                isAppDirectory
+            });
+        }
+        formattedErrors.push({
+            type: error.type,
+            errorName,
+            message: errorMsg,
+            stack
+        });
+    }
+    return formattedErrors;
+}
+async function formatErrors(errorsByUrl, nextInstanceErrors = {
+    nextConfig: []
+}) {
+    const output = {
+        configErrors: [],
+        sessionErrors: []
+    };
+    // Format Next.js instance errors first (e.g., next.config.js errors)
+    for (const error of nextInstanceErrors.nextConfig){
+        if (error instanceof Error) {
+            output.configErrors.push({
+                name: error.name,
+                message: error.message,
+                stack: error.stack || null
+            });
+        } else {
+            output.configErrors.push({
+                name: 'Error',
+                message: String(error),
+                stack: null
+            });
+        }
+    }
+    // Format browser session errors
+    for (const [url, overlayState] of errorsByUrl){
+        const totalErrorCount = overlayState.errors.length + (overlayState.buildError ? 1 : 0);
+        if (totalErrorCount === 0) continue;
+        let displayUrl = url;
+        try {
+            const urlObj = new URL(url);
+            displayUrl = urlObj.pathname + urlObj.search + urlObj.hash;
+        } catch  {
+        // If URL parsing fails, use the original URL
+        }
+        const runtimeErrors = await formatRuntimeErrorsToObjects(overlayState.errors, overlayState.routerType === 'app');
+        output.sessionErrors.push({
+            url: displayUrl,
+            buildError: overlayState.buildError || null,
+            runtimeErrors
+        });
+    }
+    return output;
+}
+
+//# sourceMappingURL=format-errors.js.map