apiforge-analyzer 1.1.0

package/dist/esm/export.js

@@ -0,0 +1,283 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Export routes to JSON file
+ */
+export async function exportToJSON(routes, projectName, filePath, baseUrl) {
+    const enrichedRoutes = enrichRoutes(routes);
+    const exportData = {
+        projectName,
+        timestamp: new Date().toISOString(),
+        schemaVersion: 'apiforge.route-export.v2',
+        framework: enrichedRoutes[0]?.framework || 'unknown',
+        baseUrl,
+        routes: enrichedRoutes,
+        metadata: {
+            totalRoutes: enrichedRoutes.length,
+            tags: Array.from(new Set(enrichedRoutes.map(r => r.tag))),
+            extractedAt: new Date().toISOString(),
+            routeIds: enrichedRoutes.map(r => ({ id: r.id, routeKey: r.routeKey, method: r.method, path: r.path })),
+        },
+    };
+    const fullPath = path.join(process.cwd(), filePath);
+    try {
+        fs.writeFileSync(fullPath, JSON.stringify(exportData, null, 2), 'utf-8');
+        console.log(`💾 Saved API export to: ${fullPath}`);
+    }
+    catch (error) {
+        console.error('Failed to save JSON:', error.message);
+        throw error;
+    }
+}
+export function enrichRoutes(routes) {
+    const withIds = routes.map((route, index) => enrichRoute(route, index + 1));
+    return withIds.map(route => ({
+        ...route,
+        linkedPaths: route.linkedPaths?.length ? route.linkedPaths : inferLinkedPaths(route, withIds),
+    }));
+}
+export function enrichRoute(route, index) {
+    const id = route.id || index;
+    const routeKey = route.routeKey || `api-${String(id).padStart(3, '0')}`;
+    const pathParams = unique([...(route.pathParams || []), ...extractPathParams(route.path)]);
+    const queryParams = unique(route.queryParams || []);
+    const requestBodyFields = unique(route.requestBodyFields || []);
+    const headerParams = unique(route.headerParams || []);
+    const tag = route.tag || inferTag(route.path);
+    const parameters = buildParameters(route.parameters, pathParams, queryParams, headerParams);
+    const requestBody = route.requestBody || buildRequestBody(route.method, requestBodyFields);
+    const responses = route.responses || buildResponses(route.method, route.path, tag, route.responseStatuses);
+    const authRequired = Boolean(route.authRequired || route.hasAuth || detectAuth(route.middleware || []));
+    return {
+        ...route,
+        id,
+        routeKey,
+        tag,
+        tags: route.tags?.length ? route.tags : [tag],
+        summary: route.summary || generateSummary(route.method, route.path),
+        description: route.description || generateDescription(route.method, route.path, tag),
+        authRequired,
+        hasAuth: authRequired,
+        pathParams,
+        queryParams,
+        requestBodyFields,
+        headerParams,
+        parameters,
+        requestBody,
+        responses,
+        sourceContext: {
+            framework: route.framework,
+            routeKey,
+            detectedFrom: route.framework,
+            confidence: confidenceFor(route, parameters, requestBody, responses),
+            middleware: route.middleware || [],
+            authRequired,
+            pathParams,
+            queryParams,
+            requestBodyFields,
+            headerParams,
+            responseStatuses: route.responseStatuses || [],
+            notes: buildNotes(route, requestBodyFields, queryParams, headerParams),
+        },
+    };
+}
+function buildParameters(existing, pathParams, queryParams, headerParams = []) {
+    const params = new Map();
+    (existing || []).forEach(param => params.set(`${param.in}:${param.name}`, param));
+    pathParams.forEach(name => params.set(`path:${name}`, {
+        name,
+        in: 'path',
+        required: true,
+        type: 'string',
+        schema: { type: 'string' },
+        description: `Required path parameter: ${name}.`,
+    }));
+    queryParams.forEach(name => {
+        const key = `query:${name}`;
+        if (!params.has(key))
+            params.set(key, {
+                name,
+                in: 'query',
+                required: false,
+                type: 'string',
+                schema: { type: 'string' },
+                description: `Optional query parameter: ${name}.`,
+            });
+    });
+    headerParams.forEach(name => {
+        const key = `header:${name}`;
+        if (!params.has(key))
+            params.set(key, {
+                name,
+                in: 'header',
+                required: name.toLowerCase() === 'authorization',
+                type: 'string',
+                schema: { type: 'string' },
+                description: `Request header: ${name}.`,
+            });
+    });
+    return Array.from(params.values());
+}
+function buildRequestBody(method, fields) {
+    if (!['POST', 'PUT', 'PATCH'].includes(method.toUpperCase()) || !fields.length)
+        return undefined;
+    const properties = {};
+    fields.forEach(field => {
+        properties[field] = {
+            type: inferFieldType(field),
+            description: `Detected request body field: ${field}.`,
+            example: exampleForField(field),
+        };
+    });
+    return {
+        required: true,
+        content: {
+            'application/json': {
+                schema: {
+                    type: 'object',
+                    required: fields,
+                    properties,
+                },
+            },
+        },
+    };
+}
+function buildResponses(method, path, tag, detectedStatuses) {
+    // Prefer statuses seen in the source; fall back to method-based inference
+    const m = method.toUpperCase();
+    const inferredPrimary = m === 'POST' ? 201 : m === 'DELETE' ? 204 : 200;
+    const primaryStatus = detectedStatuses?.find(s => s >= 200 && s < 300) ?? inferredPrimary;
+    const status = String(primaryStatus);
+    const successBody = status === '204' ? undefined : {
+        'application/json': {
+            schema: {
+                type: 'object',
+                properties: {
+                    success: { type: 'boolean', example: true },
+                    endpoint: { type: 'string', example: `${m} ${path}` },
+                    resource: { type: 'string', example: tag.toLowerCase() },
+                },
+            },
+        },
+    };
+    const base = {
+        [status]: {
+            description: status === '204' ? 'Deleted successfully' : 'Successful response',
+            content: successBody,
+        },
+    };
+    (detectedStatuses || []).forEach(s => {
+        if (s >= 200 && s < 300)
+            return; // already covered
+        base[String(s)] = { description: statusDescription(s) };
+    });
+    // Always include standard errors if not already present
+    if (!base['400'])
+        base['400'] = { description: 'Invalid request input' };
+    if (!base['401'])
+        base['401'] = { description: 'Authentication required or invalid credentials' };
+    if (!base['500'])
+        base['500'] = { description: 'Unexpected server error' };
+    return base;
+}
+function statusDescription(code) {
+    const map = {
+        400: 'Invalid request input',
+        401: 'Authentication required or invalid credentials',
+        403: 'Forbidden — insufficient permissions',
+        404: 'Resource not found',
+        409: 'Conflict — resource already exists',
+        422: 'Unprocessable entity',
+        429: 'Too many requests — rate limit exceeded',
+        500: 'Unexpected server error',
+        503: 'Service unavailable',
+    };
+    return map[code] || `HTTP ${code}`;
+}
+function inferLinkedPaths(route, routes) {
+    return routes
+        .filter(other => other.id !== route.id)
+        .filter(other => other.tag === route.tag || shareResource(route.path, other.path))
+        .slice(0, 5)
+        .map(other => `${other.method.toUpperCase()} ${other.path}`);
+}
+function extractPathParams(routePath) {
+    return unique([...(routePath.matchAll(/:(\w+)/g))].map(match => match[1]));
+}
+function detectAuth(middleware) {
+    const authNames = ['authenticateToken', 'authenticate', 'verifyToken', 'requireAuth', 'auth', 'protect', 'isAuth', 'checkAuth', 'jwtAuth', 'bearerAuth'];
+    return middleware.some(name => authNames.some(authName => name.toLowerCase().includes(authName.toLowerCase())));
+}
+function inferTag(routePath) {
+    const skip = new Set(['api', 'v1', 'v2', 'v3']);
+    return routePath.split('/').filter(Boolean).find(part => !skip.has(part) && !part.startsWith(':')) || 'general';
+}
+function generateSummary(method, routePath) {
+    const resource = routePath.split('/').filter(Boolean).filter(part => !part.startsWith(':')).pop() || 'resource';
+    const action = {
+        GET: `Get ${resource}`,
+        POST: `Create ${resource}`,
+        PUT: `Replace ${resource}`,
+        PATCH: `Update ${resource}`,
+        DELETE: `Delete ${resource}`,
+    };
+    return action[method.toUpperCase()] || `${method.toUpperCase()} ${routePath}`;
+}
+function generateDescription(method, routePath, tag) {
+    return `${method.toUpperCase()} ${routePath} in the ${tag} API group. Generated from runtime route metadata, middleware names, path parameters, query reads, and request body reads.`;
+}
+function shareResource(a, b) {
+    const clean = (value) => value.split('/').filter(Boolean).filter(part => !part.startsWith(':') && !['api', 'v1', 'v2', 'v3'].includes(part));
+    return clean(a).some(part => clean(b).includes(part));
+}
+function confidenceFor(route, parameters, requestBody, responses) {
+    let score = 0.55;
+    if (parameters.length)
+        score += 0.15;
+    if (requestBody)
+        score += 0.15;
+    if (responses)
+        score += 0.1;
+    if (route.middleware?.length)
+        score += 0.05;
+    return Math.min(score, 0.95);
+}
+function buildNotes(route, bodyFields, queryParams, headerParams = []) {
+    const notes = [];
+    if (bodyFields.length)
+        notes.push(`Detected request body fields: ${bodyFields.join(', ')}.`);
+    if (queryParams.length)
+        notes.push(`Detected query parameters: ${queryParams.join(', ')}.`);
+    if (headerParams.length)
+        notes.push(`Detected request headers: ${headerParams.join(', ')}.`);
+    if (route.responseStatuses?.length)
+        notes.push(`Detected response status codes: ${route.responseStatuses.join(', ')}.`);
+    if (route.middleware?.length)
+        notes.push(`Middleware chain: ${route.middleware.join(', ')}.`);
+    return notes;
+}
+function inferFieldType(name) {
+    if (/^(is|has|can|should)[A-Z_]/.test(name) || /active|enabled|verified/i.test(name))
+        return 'boolean';
+    if (/count|total|amount|price|limit|offset|page|age|qty|quantity/i.test(name))
+        return 'number';
+    return 'string';
+}
+function exampleForField(name) {
+    if (/email/i.test(name))
+        return 'user@example.com';
+    if (/password/i.test(name))
+        return 'SecurePass123!';
+    if (/name/i.test(name))
+        return 'Jane Developer';
+    if (/id$/i.test(name))
+        return 'id_123';
+    if (/count|total|amount|price|limit|offset|page|age|qty|quantity/i.test(name))
+        return 10;
+    if (/active|enabled|verified/i.test(name))
+        return true;
+    return `example_${name}`;
+}
+function unique(items) {
+    return Array.from(new Set(items.filter(Boolean)));
+}

package/dist/esm/frameworks/express.js

@@ -0,0 +1,242 @@
+/**
+ * Express analyzer — accurate route + payload extraction
+ */
+// ─── Path normalisation ───────────────────────────────────────────────────────
+function normalizePath(raw) {
+    return raw
+        .replace(/\\\//g, '/')
+        .replace(/\(\?[^)]*\)/g, '')
+        .replace(/\([^)]*\)/g, '')
+        .replace(/\\\w/g, '')
+        .replace(/[\^\$\?\\]/g, '')
+        .replace(/\/+/g, '/')
+        .replace(/\/$/, '')
+        || '/';
+}
+function tagFromPath(path) {
+    const skip = new Set(['api', 'v1', 'v2', 'v3', 'v4']);
+    const meaningful = path
+        .split('/')
+        .filter(Boolean)
+        .find(s => !skip.has(s) && !s.startsWith(':'));
+    return meaningful || 'general';
+}
+function generateSummary(method, path) {
+    const parts = path.split('/').filter(s => s && !s.startsWith(':'));
+    const action = parts[parts.length - 1] || '';
+    const resource = parts[parts.length - 2] || '';
+    const map = {
+        GET: action ? `Get ${action}` : `List ${resource}`,
+        POST: action ? `Create ${action}` : `Create ${resource}`,
+        PUT: action ? `Update ${action}` : `Update ${resource}`,
+        PATCH: action ? `Patch ${action}` : `Patch ${resource}`,
+        DELETE: action ? `Delete ${action}` : `Delete ${resource}`,
+    };
+    const base = map[method] || `${method} ${path}`;
+    return (base.charAt(0).toUpperCase() + base.slice(1)).replace(/[-_]/g, ' ');
+}
+// ─── Main analyser ────────────────────────────────────────────────────────────
+export function analyzeExpress(app) {
+    const routes = [];
+    const seen = new Set();
+    if (typeof app.lazyrouter === 'function')
+        app.lazyrouter();
+    const stack = app._router?.stack ??
+        app.router?.stack ??
+        app.layerStack ??
+        app.stack ??
+        null;
+    if (!stack?.length) {
+        console.warn('⚠️  No routes found — ensure routes are registered before analyze()');
+        return routes;
+    }
+    for (const layer of stack) {
+        if (layer.route) {
+            const r = buildRoute(layer.route, '');
+            if (r && !seen.has(r.method + r.path)) {
+                routes.push(r);
+                seen.add(r.method + r.path);
+            }
+        }
+        else if (layer.handle?.stack) {
+            let base = '';
+            if (layer.regexp?.source)
+                base = normalizePath(layer.regexp.source);
+            else if (layer.path)
+                base = normalizePath(layer.path);
+            else if (typeof layer.route === 'string')
+                base = normalizePath(layer.route);
+            for (const sub of layer.handle.stack) {
+                if (sub.route) {
+                    const r = buildRoute(sub.route, base);
+                    if (r && !seen.has(r.method + r.path)) {
+                        routes.push(r);
+                        seen.add(r.method + r.path);
+                    }
+                }
+            }
+        }
+    }
+    return routes;
+}
+// ─── Route builder ────────────────────────────────────────────────────────────
+function buildRoute(route, basePath) {
+    if (!route.path)
+        return null;
+    const methods = Object.keys(route.methods || {})
+        .filter(m => route.methods[m])
+        .map(m => m.toUpperCase());
+    if (!methods.length)
+        return null;
+    const cleanBase = normalizePath(basePath);
+    const cleanRoute = normalizePath(route.path);
+    let fullPath = (cleanBase === '/' ? '' : cleanBase) + cleanRoute;
+    if (!fullPath.startsWith('/'))
+        fullPath = '/' + fullPath;
+    if (fullPath !== '/' && fullPath.endsWith('/'))
+        fullPath = fullPath.slice(0, -1);
+    const stack = route.stack || [];
+    // ── Middleware names ───────────────────────────────────────────────────────
+    const middleware = stack
+        .map((l) => l.name)
+        .filter((n) => n && n !== '<anonymous>' && n !== 'bound dispatch' && n !== 'bound ');
+    // ── Join all handler source text ───────────────────────────────────────────
+    const src = stack.map((l) => l.handle?.toString() ?? '').join('\n');
+    // ── Path params (from route pattern) ──────────────────────────────────────
+    const pathParams = unique([...fullPath.matchAll(/:(\w+)/g)].map(m => m[1]));
+    // ── Query params ───────────────────────────────────────────────────────────
+    const queryParams = unique([
+        // req.query.foo
+        ...matchAll(src, /req\.query\.([a-zA-Z0-9_$]+)/g),
+        // { foo, bar } = req.query  /  { foo: renamed } = req.query
+        ...destructured(src, /(?:const|let|var)\s+\{([^}]+)\}\s*=\s*req\.query/g),
+        // req.query['foo']
+        ...matchAll(src, /req\.query\[['"]([a-zA-Z0-9_$]+)['"]\]/g),
+    ]);
+    // ── Request body fields ────────────────────────────────────────────────────
+    const requestBodyFields = unique([
+        // req.body.foo
+        ...matchAll(src, /req\.body\.([a-zA-Z0-9_$]+)/g),
+        // { foo, bar: alias, baz = default } = req.body
+        ...destructured(src, /(?:const|let|var)\s+\{([^}]+)\}\s*=\s*req\.body/g),
+        // req.body['foo']
+        ...matchAll(src, /req\.body\[['"]([a-zA-Z0-9_$]+)['"]\]/g),
+        // body.foo (when `const body = req.body`)
+        ...bodyAliasFields(src),
+        // Zod: z.object({ field: z.string() }).parse(req.body)
+        ...zodFields(src),
+        // Joi: Joi.object({ field: Joi.string() }).validate(req.body)
+        ...joiFields(src),
+    ]);
+    // ── Header params ──────────────────────────────────────────────────────────
+    const headerParams = unique([
+        ...matchAll(src, /req\.headers\[['"]([a-zA-Z0-9_$-]+)['"]\]/g),
+        ...matchAll(src, /req\.get\s*\(\s*['"]([a-zA-Z0-9_$-]+)['"]\s*\)/g),
+        // req.headers.authorization, req.headers['x-api-key'], etc.
+        ...matchAll(src, /req\.headers\.([a-zA-Z0-9_$]+)/g),
+    ]);
+    // ── Response status codes from `res.status(nnn)` ──────────────────────────
+    const responseStatuses = unique([...src.matchAll(/res\.status\s*\(\s*(\d{3})\s*\)/g)].map(m => parseInt(m[1], 10)));
+    // ── Auth detection ─────────────────────────────────────────────────────────
+    const AUTH_NAMES = new Set([
+        'authenticateToken', 'authenticate', 'verifyToken', 'requireAuth', 'auth',
+        'protect', 'isAuth', 'checkAuth', 'jwtAuth', 'bearerAuth', 'isAuthenticated',
+        'requireLogin', 'ensureAuth', 'verifyJWT', 'checkToken', 'authMiddleware',
+        'passport.authenticate', 'jwt', 'bearer',
+    ]);
+    const hasAuth = middleware.some(m => AUTH_NAMES.has(m) || [...AUTH_NAMES].some(a => m.toLowerCase().includes(a.toLowerCase()))) ||
+        /req\.user|req\.auth|verifyToken|jwt\.verify|passport\.authenticate/.test(src);
+    const method = methods[0];
+    const tag = tagFromPath(fullPath);
+    const summary = generateSummary(method, fullPath);
+    const operationId = `${method.toLowerCase()}_${fullPath
+        .replace(/[^a-zA-Z0-9]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '')}`;
+    return {
+        method,
+        path: fullPath,
+        tag,
+        operationId,
+        summary,
+        middleware,
+        authRequired: hasAuth,
+        pathParams,
+        queryParams,
+        requestBodyFields,
+        linkedPaths: [],
+        hasAuth,
+        framework: 'express',
+        responseStatuses: responseStatuses.length ? responseStatuses : undefined,
+        headerParams: headerParams.length ? headerParams : undefined,
+    };
+}
+// ─── Extraction helpers ───────────────────────────────────────────────────────
+/** Run a global regex and return capture group 1 for every match. */
+function matchAll(src, re) {
+    return [...src.matchAll(re)].map(m => m[1]).filter(Boolean);
+}
+/**
+ * Extract field names from all destructuring patterns like:
+ *   const { a, b: alias, c = default, d: alias2 = default } = req.body
+ * Runs ALL occurrences of the given regex, not just the first.
+ */
+function destructured(src, re) {
+    const results = [];
+    for (const match of src.matchAll(re)) {
+        match[1]
+            .split(',')
+            .map(s => s.trim())
+            // handle "alias: original" — we want the local binding (left side)
+            .map(s => s.split(':')[0].trim())
+            // strip default value
+            .map(s => s.split('=')[0].trim())
+            .filter(Boolean)
+            .forEach(f => results.push(f));
+    }
+    return results;
+}
+/**
+ * When a developer writes `const body = req.body` and then accesses `body.foo`.
+ */
+function bodyAliasFields(src) {
+    const aliasMatch = src.match(/(?:const|let|var)\s+(\w+)\s*=\s*req\.body\b/);
+    if (!aliasMatch)
+        return [];
+    const alias = aliasMatch[1];
+    if (alias === 'body')
+        return matchAll(src, /body\.([a-zA-Z0-9_$]+)/g);
+    const re = new RegExp(`\\b${alias}\\.([a-zA-Z0-9_$]+)`, 'g');
+    return matchAll(src, re);
+}
+/** Extract field names from Zod object schemas. */
+function zodFields(src) {
+    const results = [];
+    // z.object({ field: z.xxx(), ... }).parse(req.body) or .safeParse
+    const zodRe = /z\.object\s*\(\s*\{([^}]+)\}/g;
+    for (const match of src.matchAll(zodRe)) {
+        match[1]
+            .split(',')
+            .map(s => s.trim().split(':')[0].trim())
+            .filter(s => /^[a-zA-Z_$]/.test(s))
+            .forEach(f => results.push(f));
+    }
+    return results;
+}
+/** Extract field names from Joi object schemas. */
+function joiFields(src) {
+    const results = [];
+    // Joi.object({ field: Joi.xxx() }) or yup.object().shape({ field: ... })
+    const joiRe = /(?:Joi|yup)\.object\s*\(?\s*(?:\.shape\s*\()?\s*\{([^}]+)\}/g;
+    for (const match of src.matchAll(joiRe)) {
+        match[1]
+            .split(',')
+            .map(s => s.trim().split(':')[0].trim())
+            .filter(s => /^[a-zA-Z_$]/.test(s))
+            .forEach(f => results.push(f));
+    }
+    return results;
+}
+function unique(items) {
+    return Array.from(new Set(items.filter(Boolean)));
+}

package/dist/esm/frameworks/nextjs-app.js

@@ -0,0 +1,145 @@
+/**
+ * Next.js App Router analyzer
+ * Analyzes route handlers in app directory
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { exportToJSON } from '../export.js';
+import { uploadRoutes } from '../uploader.js';
+/**
+ * Analyze Next.js App Router routes
+ */
+export async function analyzeNextApp(options = 'app') {
+    // Support both string path and options object
+    const appDir = typeof options === 'string' ? options : (options.appDir || 'app');
+    const opts = typeof options === 'string' ? { projectName: '' } : options;
+    const routes = [];
+    try {
+        const baseDir = path.join(process.cwd(), appDir);
+        if (!fs.existsSync(baseDir)) {
+            console.warn('app directory not found');
+            return routes;
+        }
+        // Recursively scan for route.ts/route.js files
+        const scanDir = (dir, basePath = '') => {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // Handle dynamic routes like [id]
+                    const dirName = entry.name.startsWith('[') && entry.name.endsWith(']')
+                        ? `:${entry.name.slice(1, -1)}`
+                        : entry.name;
+                    // Skip non-route directories
+                    if (['_components', '_lib', '_utils'].includes(entry.name)) {
+                        continue;
+                    }
+                    scanDir(fullPath, `${basePath}/${dirName}`);
+                }
+                else if (entry.isFile() && /route\.(ts|js)$/.test(entry.name)) {
+                    // Found a route file
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const methods = detectAppRouterMethods(content);
+                    methods.forEach(method => {
+                        const pathString = basePath || '/';
+                        const operationId = `${method.toLowerCase()}_${pathString.replace(/[^a-zA-Z0-9]/g, '_').replace(/_+/g, '_').replace(/^_|_$/g, '')}`;
+                        const tags = pathString.startsWith('/api') ? ['api'] : ['app'];
+                        const middleware = detectMiddleware(content);
+                        const authRequired = middleware.includes('auth');
+                        const pathParams = extractParameters(pathString).map(p => p.name);
+                        // Basic static extraction
+                        const queryParams = [];
+                        const queryHits = [...content.matchAll(/searchParams\.get\(['"]([^'"]+)['"]\)/g)];
+                        queryHits.forEach(m => queryParams.push(m[1]));
+                        const requestBodyFields = [];
+                        const bodyDestruct = content.match(/const\s+\{([^}]+)\}\s*=\s*await\s+req\.json\(\)/);
+                        if (bodyDestruct) {
+                            bodyDestruct[1].split(',').map(s => s.trim().split(':')[0]).filter(Boolean).forEach(m => requestBodyFields.push(m));
+                        }
+                        routes.push({
+                            method,
+                            path: pathString,
+                            tag: tags[0] || 'General',
+                            operationId,
+                            summary: `${method} ${pathString}`,
+                            middleware,
+                            authRequired,
+                            pathParams: Array.from(new Set(pathParams)),
+                            queryParams: Array.from(new Set(queryParams)),
+                            requestBodyFields: Array.from(new Set(requestBodyFields)),
+                            linkedPaths: [],
+                            hasAuth: authRequired,
+                            framework: 'nextjs-app'
+                        });
+                    });
+                }
+            }
+        };
+        scanDir(baseDir);
+        console.log(`✅ Found ${routes.length} routes`);
+        // Export to JSON if requested
+        if (opts.saveJson && opts.projectName) {
+            const filePath = opts.jsonPath || 'api-export.json';
+            await exportToJSON(routes, opts.projectName, filePath, opts.baseUrl);
+        }
+        // Upload to APIForge if requested
+        if (opts.upload && opts.apiKey && opts.projectName) {
+            await uploadRoutes(routes, {
+                projectName: opts.projectName,
+                apiKey: opts.apiKey,
+                baseUrl: opts.baseUrl,
+                apiForgeUrl: opts.apiForgeUrl
+            });
+        }
+    }
+    catch (error) {
+        console.error('Error analyzing Next.js App routes:', error.message);
+    }
+    return routes;
+}
+/**
+ * Detect exported HTTP method handlers
+ */
+function detectAppRouterMethods(content) {
+    const methods = [];
+    const httpMethods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
+    httpMethods.forEach(method => {
+        // Check for export async function METHOD or export function METHOD
+        const regex = new RegExp(`export\\s+(async\\s+)?function\\s+${method}\\s*\\(`, 'g');
+        if (regex.test(content)) {
+            methods.push(method);
+        }
+    });
+    return methods;
+}
+/**
+ * Detect middleware usage
+ */
+function detectMiddleware(content) {
+    const middleware = [];
+    if (content.includes('auth') || content.includes('authenticate')) {
+        middleware.push('auth');
+    }
+    if (content.includes('cors')) {
+        middleware.push('cors');
+    }
+    return middleware;
+}
+/**
+ * Extract parameters from route path
+ */
+function extractParameters(routePath) {
+    const params = [];
+    const paramMatches = routePath.match(/:(\w+)/g) || [];
+    paramMatches.forEach(param => {
+        const name = param.slice(1);
+        params.push({
+            name,
+            in: 'path',
+            required: true,
+            type: 'string',
+            description: `Path parameter: ${name}`
+        });
+    });
+    return params;
+}