zero-doc 1.0.4 → 1.0.6

package/dist/ai-analyzer.js

@@ -34,23 +34,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AIAnalyzer = void 0;
-const generative_ai_1 = require("@google/generative-ai");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const glob_1 = require("glob");
 class AIAnalyzer {
     constructor(options) {
-        this.genAI = new generative_ai_1.GoogleGenerativeAI(options.apiKey);
-        this.model = this.genAI.getGenerativeModel({ model: 'gemini-3-flash-preview' });
+        this.apiUrl = options.apiUrl;
         this.projectRoot = options.projectRoot;
         this.filePatterns = options.filePatterns;
     }
     async analyzeProject() {
-        // Find all relevant files
         const files = await this.findProjectFiles();
-        // Read and analyze files
         const fileContents = [];
-        for (const file of files.slice(0, 50)) { // Limit to 50 files for now
+        for (const file of files.slice(0, 50)) {
             try {
                 const content = fs.readFileSync(file, 'utf-8');
                 fileContents.push({ path: path.relative(this.projectRoot, file), content });
@@ -58,40 +54,34 @@ class AIAnalyzer {
             catch (error) {
             }
         }
-        // Analyze with AI
+        if (fileContents.length === 0) {
+            throw new Error('No files found to analyze. Check your file patterns and project structure.');
+        }
         let endpoints = await this.analyzeWithAI(fileContents);
-        // Filter duplicates and root routes
         endpoints = this.filterAndCleanEndpoints(endpoints);
-        // Detect base URL from common prefix
         const baseUrl = this.detectBaseUrl(endpoints);
-        // Detect programming language
         const language = this.detectLanguage(files);
-        // Calculate stats
-        const stats = this.calculateStats(endpoints);
+        const framework = this.detectFramework(files, endpoints);
         const inventory = {
             version: '1.0.0',
             generatedAt: new Date().toISOString(),
-            baseUrl: baseUrl || 'https://api.example.com',
+            baseUrl: baseUrl,
             project: {
-                name: this.extractProjectName(),
-                version: this.extractProjectVersion(),
-                description: this.extractProjectDescription(),
-                framework: this.detectFramework(endpoints, language),
+                name: '',
+                version: '',
+                description: '',
+                framework: framework,
                 language: language,
             },
-            endpoints,
-            stats,
+            endpoints: endpoints,
+            stats: {
+                totalEndpoints: endpoints.length,
+                byMethod: endpoints.reduce((acc, ep) => {
+                    acc[ep.method] = (acc[ep.method] || 0) + 1;
+                    return acc;
+                }, {}),
+            },
         };
-        // Validate inventory structure
-        if (!inventory.endpoints || !Array.isArray(inventory.endpoints)) {
-            inventory.endpoints = [];
-        }
-        if (!inventory.stats) {
-            inventory.stats = {
-                totalEndpoints: inventory.endpoints.length,
-                byMethod: {},
-            };
-        }
         return inventory;
     }
     async findProjectFiles() {
@@ -101,43 +91,51 @@ class AIAnalyzer {
                 const files = await (0, glob_1.glob)(pattern, {
                     cwd: this.projectRoot,
                     absolute: true,
-                    ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.git/**'],
+                    ignore: [
+                        '**/node_modules/**',
+                        '**/dist/**',
+                        '**/build/**',
+                        '**/.git/**',
+                        '**/coverage/**',
+                        '**/*.test.*',
+                        '**/*.spec.*',
+                    ],
                 });
                 allFiles.push(...files);
             }
             catch (error) {
-                // Silently ignore pattern errors
             }
         }
-        const uniqueFiles = [...new Set(allFiles)];
+        const uniqueFiles = [...new Set(allFiles)].sort();
         if (uniqueFiles.length === 0) {
-            // Try alternative patterns
             const alternativePatterns = [
                 '**/*.ts',
                 '**/*.js',
-                '**/*.tsx',
-                '**/*.jsx',
-                'src/**/*.ts',
-                'src/**/*.js',
-                'app/**/*.ts',
-                'app/**/*.js',
-                'lib/**/*.ts',
-                'lib/**/*.js',
+                '**/*.py',
+                '**/*.java',
+                '**/*.go',
+                '**/*.rs',
+                '**/*.php',
+                '**/*.rb',
             ];
-            for (const altPattern of alternativePatterns) {
+            for (const pattern of alternativePatterns) {
                 try {
-                    const files = await (0, glob_1.glob)(altPattern, {
+                    const files = await (0, glob_1.glob)(pattern, {
                         cwd: this.projectRoot,
                         absolute: true,
-                        ignore: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.git/**'],
+                        ignore: [
+                            '**/node_modules/**',
+                            '**/dist/**',
+                            '**/build/**',
+                            '**/.git/**',
+                        ],
                     });
                     if (files.length > 0) {
                         uniqueFiles.push(...files);
-                        break; // Use first pattern that finds files
+                        break;
                     }
                 }
                 catch (error) {
-                    // Continue
                 }
             }
         }
@@ -145,64 +143,210 @@ class AIAnalyzer {
     }
     async analyzeWithAI(files) {
         const prompt = this.buildAnalysisPrompt(files);
+        if (!this.apiUrl) {
+            throw new Error('Proxy API URL not configured');
+        }
+        const url = this.apiUrl.trim();
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            throw new Error(`Invalid API URL: "${url}". URL must start with http:// or https://`);
+        }
         try {
-            const result = await this.model.generateContent(prompt);
-            const response = await result.response;
-            const text = response.text();
-            // Parse JSON from response
-            const jsonMatch = text.match(/\{[\s\S]*\}/);
-            if (!jsonMatch) {
-                throw new Error('Failed to parse JSON from AI response');
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ prompt }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'No error details');
+                throw new Error(`Proxy API error (${response.status}): ${response.statusText}. ${errorText}`);
             }
-            const aiResult = JSON.parse(jsonMatch[0]);
-            if (!aiResult.endpoints || !Array.isArray(aiResult.endpoints)) {
-                throw new Error('Invalid response format from AI');
+            const responseText = await response.text();
+            let endpoints = [];
+            try {
+                const parsed = JSON.parse(responseText);
+                if (parsed.endpoints && Array.isArray(parsed.endpoints)) {
+                    endpoints = parsed.endpoints;
+                }
+                else if (Array.isArray(parsed)) {
+                    endpoints = parsed;
+                }
+                else if (parsed.data && Array.isArray(parsed.data)) {
+                    endpoints = parsed.data;
+                }
+                else if (parsed.response && typeof parsed.response === 'string') {
+                    try {
+                        const innerParsed = JSON.parse(parsed.response);
+                        if (Array.isArray(innerParsed)) {
+                            endpoints = innerParsed;
+                        }
+                        else if (innerParsed.endpoints && Array.isArray(innerParsed.endpoints)) {
+                            endpoints = innerParsed.endpoints;
+                        }
+                    }
+                    catch {
+                        const jsonMatch = parsed.response.match(/\{[\s\S]*"endpoints"[\s\S]*\}/);
+                        if (jsonMatch) {
+                            const extracted = JSON.parse(jsonMatch[0]);
+                            if (extracted.endpoints && Array.isArray(extracted.endpoints)) {
+                                endpoints = extracted.endpoints;
+                            }
+                        }
+                    }
+                }
+                if (endpoints.length === 0) {
+                    throw new Error(`Invalid response format. Expected { endpoints: [...] } or array of endpoints. Received: ${JSON.stringify(parsed).substring(0, 200)}`);
+                }
             }
-            // Validate and map endpoints
-            const mappedEndpoints = aiResult.endpoints.map((ep, index) => {
-                // Ensure method is uppercase
-                const method = (ep.method || 'GET').toUpperCase();
-                if (!['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].includes(method)) {
+            catch (parseError) {
+                const codeBlockMatch = responseText.match(/```(?:json)?\s*(\{[\s\S]*\})\s*```/);
+                if (codeBlockMatch) {
+                    try {
+                        const extracted = JSON.parse(codeBlockMatch[1]);
+                        if (extracted.endpoints && Array.isArray(extracted.endpoints)) {
+                            endpoints = extracted.endpoints;
+                        }
+                        else if (Array.isArray(extracted)) {
+                            endpoints = extracted;
+                        }
+                    }
+                    catch {
+                    }
                 }
-                return {
-                    id: `ep-${index}`,
-                    method: (['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].includes(method) ? method : 'GET'),
-                    path: ep.path || '/',
-                    group: ep.group || 'Other',
-                    file: ep.file || 'unknown',
-                    line: ep.line || 0,
-                    handler: {
-                        name: ep.handler?.name,
-                        isAsync: ep.handler?.isAsync || false,
-                        parameters: ep.handler?.parameters || [],
-                    },
-                    parameters: Array.isArray(ep.parameters) ? ep.parameters : [],
-                    requestBody: ep.requestBody || undefined,
-                    responses: Array.isArray(ep.responses) ? ep.responses : [],
-                    authentication: ep.authentication || undefined,
-                    headers: Array.isArray(ep.headers) ? ep.headers : [],
-                    metadata: {
-                        title: ep.metadata?.title || ep.title || `${method} ${ep.path || '/'}`,
-                        description: ep.metadata?.description || ep.description || '',
-                        aiGenerated: true,
-                    },
-                };
-            });
-            // Log first endpoint for debugging
-            // Logs removed for clean progress bar output
-            return mappedEndpoints;
+                if (endpoints.length === 0) {
+                    throw new Error(`Failed to parse API response. Expected JSON with endpoints array. Response preview: ${responseText.substring(0, 300)}`);
+                }
+            }
+            return this.mapEndpoints(endpoints);
         }
         catch (error) {
-            throw error;
+            if (error instanceof TypeError && error.message.includes('fetch failed')) {
+                throw new Error(`Failed to connect to API at ${this.apiUrl}. Check if the server is running and the URL is correct.`);
+            }
+            throw new Error(`AI analysis failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
+    mapEndpoints(endpoints) {
+        return endpoints.map((ep, index) => {
+            const method = (ep.method || 'GET').toUpperCase();
+            return {
+                id: `ep-${index}`,
+                method: method,
+                path: ep.path || '/',
+                group: ep.group || 'Default',
+                file: ep.file || '',
+                line: ep.line || 0,
+                handler: ep.handler || {
+                    name: 'anonymous',
+                    isAsync: false,
+                    parameters: [],
+                },
+                parameters: ep.parameters || [],
+                requestBody: ep.requestBody || { required: false, fields: [] },
+                responses: ep.responses || [],
+                authentication: ep.authentication || { required: false, type: 'none' },
+                headers: ep.headers || [],
+                metadata: ep.metadata || { title: '', description: '' },
+            };
+        });
+    }
+    filterAndCleanEndpoints(endpoints) {
+        const seen = new Map();
+        for (const endpoint of endpoints) {
+            const key = `${endpoint.method}:${endpoint.path}`;
+            if (endpoint.path === '/' && endpoint.group === 'Root') {
+                continue;
+            }
+            if (!seen.has(key)) {
+                seen.set(key, endpoint);
+            }
+        }
+        return Array.from(seen.values());
+    }
+    detectBaseUrl(endpoints) {
+        if (endpoints.length === 0)
+            return 'https://api.example.com';
+        const paths = endpoints.map(e => e.path).filter(p => p && p !== '/');
+        if (paths.length === 0)
+            return 'https://api.example.com';
+        const firstPath = paths[0];
+        let commonPrefix = '';
+        for (let i = 0; i < firstPath.length; i++) {
+            const char = firstPath[i];
+            if (paths.every(p => p[i] === char)) {
+                commonPrefix += char;
+            }
+            else {
+                break;
+            }
+        }
+        const lastSlash = commonPrefix.lastIndexOf('/');
+        if (lastSlash > 0) {
+            return `https://api.example.com${commonPrefix.substring(0, lastSlash + 1)}`;
+        }
+        return 'https://api.example.com';
+    }
+    detectLanguage(files) {
+        const extensions = new Map();
+        for (const file of files) {
+            const ext = path.extname(file).toLowerCase();
+            const langMap = {
+                '.ts': 'TypeScript',
+                '.js': 'JavaScript',
+                '.py': 'Python',
+                '.java': 'Java',
+                '.go': 'Go',
+                '.rs': 'Rust',
+                '.php': 'PHP',
+                '.rb': 'Ruby',
+            };
+            if (langMap[ext]) {
+                extensions.set(langMap[ext], (extensions.get(langMap[ext]) || 0) + 1);
+            }
+        }
+        if (extensions.size === 0)
+            return 'Unknown';
+        const sorted = Array.from(extensions.entries()).sort((a, b) => b[1] - a[1]);
+        return sorted[0][0];
+    }
+    detectFramework(files, endpoints) {
+        const fileNames = files.map(f => path.basename(f).toLowerCase());
+        const allFiles = files.join(' ');
+        if (fileNames.some(f => f.includes('express')) || allFiles.includes('express')) {
+            return 'express';
+        }
+        if (fileNames.some(f => f.includes('fastify')) || allFiles.includes('fastify')) {
+            return 'fastify';
+        }
+        if (fileNames.some(f => f.includes('koa')) || allFiles.includes('koa')) {
+            return 'koa';
+        }
+        if (fileNames.some(f => f.includes('django')) || allFiles.includes('django')) {
+            return 'django';
+        }
+        if (fileNames.some(f => f.includes('flask')) || allFiles.includes('flask')) {
+            return 'flask';
+        }
+        if (fileNames.some(f => f.includes('spring')) || allFiles.includes('spring')) {
+            return 'spring';
+        }
+        return 'unknown';
+    }
     buildAnalysisPrompt(files) {
+        if (files.length === 0) {
+            throw new Error('No project files found to analyze');
+        }
         const filesContext = files.map(f => `// File: ${f.path}\n${f.content}`).join('\n\n---\n\n');
-        return `You are an expert API documentation analyzer. Your task is to analyze ANY programming language codebase and extract ALL API endpoints with COMPLETE information.
+        return `You are an expert API documentation analyzer. Your task is to analyze the provided codebase files and extract ALL API endpoints with COMPLETE information.
 
-PROJECT FILES:
+IMPORTANT: Below are the ACTUAL SOURCE CODE FILES from the user's project. Analyze these files to find all API endpoints, routes, handlers, parameters, request bodies, responses, and authentication requirements.
+
+PROJECT FILES TO ANALYZE (${files.length} file${files.length > 1 ? 's' : ''}):
 ${filesContext}
 
+---
+
 CRITICAL INSTRUCTIONS:
 1. Analyze the ENTIRE codebase structure to understand how routes are organized
 2. Follow ALL route prefixes and middleware chains (router.use, app.use, etc.)
@@ -219,21 +363,21 @@ For EACH endpoint found, you MUST extract:
 2. FULL PATH: Complete path including all prefixes
    - Follow router.use('/prefix', router) chains
    - Combine prefixes correctly
-   - Example: router.use('/api/instagram', instagramRoutes) + router.get('/auth', ...) = /api/instagram/auth
+   - Example: router.use('/api/users', userRoutes) + router.get('/auth', ...) = /api/users/auth
 
-3. GROUP NAME: Based on the RESOURCE, not controller
-   - /api/instagram/auth → "Auth" (NOT "Instagram")
-   - /api/instagram/auth/callback → "Auth" (same group as /auth)
-   - /api/instagram/posts/:userId → "Posts" (NOT "Instagram")
-   - Group related endpoints together (auth + auth/callback)
-   - DO NOT create a "Root" group unless absolutely necessary
-   - Skip root routes (path: "/") that are just status/health checks
+3. GROUP NAME: Based on the RESOURCE, not controller/service name
+   - /api/users/auth → "Auth" (NOT "Users")
+   - /api/users/auth/callback → "Auth" (same group as /auth)
+   - /api/users/posts/:userId → "Posts" (NOT "Users")
+   - Group related endpoints together (auth + auth/callback belong in same group)
 
 4. PARAMETERS: Extract ALL parameters from:
    - Path parameters: /users/:id → {name: "id", in: "path"}
    - Query parameters: req.query.page → {name: "page", in: "query"}
    - Body parameters: req.body.email, const {email, password} = req.body → {name: "email", in: "body"}
    - Header parameters: req.headers.authorization → {name: "Authorization", in: "header"}
+   - IMPORTANT: HTTP headers are case-insensitive (X-API-Key, x-api-key, X-Api-Key are all the same)
+   - DO NOT duplicate headers if you see different casings - use only ONE entry with the most common casing
 
 5. REQUEST BODY: Complete structure if POST/PUT/PATCH
    - Extract all fields from req.body or request.body
@@ -254,10 +398,16 @@ For EACH endpoint found, you MUST extract:
 8. HEADERS: Extract required headers
    - From req.headers.fieldName or request.headers.fieldName
    - Include Authorization if authentication is required
+   - CRITICAL: HTTP headers are case-insensitive - X-API-Key, x-api-key, X-Api-Key are THE SAME header
+   - If you see the same header with different casings, include it ONLY ONCE (use the most common casing)
+   - DO NOT create duplicate header entries for the same header with different casings
 
 9. HANDLER INFO: Function name, async status, parameters
 
-Return a JSON object with this EXACT structure:
+OUTPUT FORMAT - YOU MUST RETURN EXACTLY THIS STRUCTURE:
+
+Return a JSON object with this EXACT structure. DO NOT wrap it in markdown code blocks, DO NOT add explanations, DO NOT add any text before or after. Return ONLY the raw JSON:
+
 {
   "endpoints": [
     {
@@ -315,7 +465,7 @@ Return a JSON object with this EXACT structure:
       ],
       "authentication": {
         "required": true,
-        "type": "bearer|basic|api-key|custom",
+        "type": "bearer|basic|api-key|custom|none",
         "description": "Authentication description"
       },
       "headers": [
@@ -335,168 +485,29 @@ Return a JSON object with this EXACT structure:
   ]
 }
 
-CRITICAL:
-- Return ONLY valid JSON, no markdown, no code blocks, no explanations
-- Extract EVERYTHING from the code - be thorough
-- Group by resource name, not controller name
-- Include ALL responses found in the code
-- Schema should be direct object, not wrapped in {type: "object", properties: {...}}
-- DO NOT create duplicate endpoints
-- DO NOT include root routes (path: "/") unless absolutely necessary`;
-    }
-    filterAndCleanEndpoints(endpoints) {
-        // Remove duplicates based on method + path
-        const seen = new Set();
-        const filtered = [];
-        for (const endpoint of endpoints) {
-            const key = `${endpoint.method}:${endpoint.path}`;
-            // Skip duplicates
-            if (seen.has(key)) {
-                continue;
-            }
-            // Skip root routes unless they have meaningful content
-            if (endpoint.path === '/' && (!endpoint.metadata?.title || endpoint.metadata.title === 'API Root' || endpoint.metadata.title === 'GET /')) {
-                // Only skip if it's a simple root route without meaningful content
-                if (!endpoint.parameters.length && (!endpoint.responses || endpoint.responses.length === 0)) {
-                    continue;
-                }
-            }
-            seen.add(key);
-            filtered.push(endpoint);
-        }
-        return filtered;
-    }
-    detectBaseUrl(endpoints) {
-        if (endpoints.length === 0)
-            return undefined;
-        // Find common prefix in all paths (excluding root)
-        const paths = endpoints.map(ep => ep.path).filter(p => p !== '/' && p.length > 1);
-        if (paths.length === 0)
-            return undefined;
-        // Find longest common prefix
-        let commonPrefix = paths[0];
-        for (let i = 1; i < paths.length; i++) {
-            const path = paths[i];
-            let j = 0;
-            while (j < commonPrefix.length && j < path.length && commonPrefix[j] === path[j]) {
-                j++;
-            }
-            commonPrefix = commonPrefix.substring(0, j);
-        }
-        // Extract base URL (e.g., /api/instagram from /api/instagram/auth)
-        if (commonPrefix && commonPrefix.length > 1) {
-            // Find complete segments
-            const segments = commonPrefix.split('/').filter(s => s);
-            if (segments.length >= 2) {
-                // Take first 2 segments as base (e.g., /api/instagram)
-                const basePath = '/' + segments.slice(0, 2).join('/');
-                // Remove base path from endpoint paths
-                endpoints.forEach(ep => {
-                    if (ep.path.startsWith(basePath)) {
-                        ep.path = ep.path.substring(basePath.length) || '/';
-                    }
-                });
-                return `https://api.example.com${basePath}`;
-            }
-            else if (segments.length === 1) {
-                const basePath = '/' + segments[0];
-                // Remove base path from endpoint paths
-                endpoints.forEach(ep => {
-                    if (ep.path.startsWith(basePath)) {
-                        ep.path = ep.path.substring(basePath.length) || '/';
-                    }
-                });
-                return `https://api.example.com${basePath}`;
-            }
-        }
-        return undefined;
-    }
-    detectLanguage(files) {
-        const extensions = new Map();
-        for (const file of files) {
-            const ext = path.extname(file).toLowerCase();
-            if (ext) {
-                extensions.set(ext, (extensions.get(ext) || 0) + 1);
-            }
-        }
-        // Find most common extension
-        let maxCount = 0;
-        let mostCommon = 'unknown';
-        for (const [ext, count] of extensions.entries()) {
-            if (count > maxCount) {
-                maxCount = count;
-                mostCommon = ext;
-            }
-        }
-        const languageMap = {
-            '.ts': 'TypeScript',
-            '.js': 'JavaScript',
-            '.tsx': 'TypeScript React',
-            '.jsx': 'JavaScript React',
-            '.py': 'Python',
-            '.java': 'Java',
-            '.go': 'Go',
-            '.rs': 'Rust',
-            '.php': 'PHP',
-            '.rb': 'Ruby',
-        };
-        return languageMap[mostCommon] || 'unknown';
-    }
-    detectFramework(endpoints, language) {
-        // Simple detection based on common patterns
-        if (language.includes('TypeScript') || language.includes('JavaScript')) {
-            return 'express'; // Default for Node.js
-        }
-        return 'unknown';
-    }
-    calculateStats(endpoints) {
-        const byMethod = {};
-        endpoints.forEach(endpoint => {
-            byMethod[endpoint.method] = (byMethod[endpoint.method] || 0) + 1;
-        });
-        return {
-            totalEndpoints: endpoints.length,
-            byMethod,
-        };
-    }
-    extractProjectName() {
-        try {
-            const packageJsonPath = path.join(this.projectRoot, 'package.json');
-            if (fs.existsSync(packageJsonPath)) {
-                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                return packageJson.name;
-            }
-        }
-        catch (error) {
-            // Ignore
-        }
-        return undefined;
-    }
-    extractProjectVersion() {
-        try {
-            const packageJsonPath = path.join(this.projectRoot, 'package.json');
-            if (fs.existsSync(packageJsonPath)) {
-                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                return packageJson.version;
-            }
-        }
-        catch (error) {
-            // Ignore
-        }
-        return undefined;
-    }
-    extractProjectDescription() {
-        try {
-            const packageJsonPath = path.join(this.projectRoot, 'package.json');
-            if (fs.existsSync(packageJsonPath)) {
-                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                return packageJson.description;
-            }
-        }
-        catch (error) {
-            // Ignore
-        }
-        return undefined;
+CRITICAL OUTPUT REQUIREMENTS:
+1. Return ONLY the raw JSON object, starting with { and ending with }
+2. DO NOT wrap in markdown code blocks (no triple backticks)
+3. DO NOT add any text before or after the JSON
+4. DO NOT add explanations, comments, or any other text
+5. The root object MUST have an "endpoints" key containing an array
+6. If no endpoints are found, return: { "endpoints": [] }
+7. The JSON MUST be valid and parseable
+8. Extract EVERYTHING from the code - be thorough
+9. Group by resource name, not controller name
+10. Include ALL responses found in the code
+11. Schema should be direct object, not wrapped in {type: "object", properties: {...}}
+
+EXAMPLE OF CORRECT OUTPUT:
+{"endpoints":[{"method":"GET","path":"/api/users","group":"Users","file":"src/routes/users.ts","line":10,"handler":{"name":"getUsers","isAsync":true,"parameters":["req","res"]},"parameters":[],"requestBody":{"required":false,"fields":[]},"responses":[{"statusCode":200,"type":"application/json","description":"List of users","schema":{"users":{"type":"array"}}}],"authentication":{"required":false,"type":"none"},"headers":[],"metadata":{"title":"Get Users","description":"Retrieve all users"}}]}
+
+DO NOT return this format (WRONG):
+Markdown code blocks with triple backticks
+DO NOT return this format (WRONG):
+Text explanations before or after the JSON
+
+Return ONLY this format (CORRECT):
+{ "endpoints": [...] }`;
     }
 }
 exports.AIAnalyzer = AIAnalyzer;

package/dist/cli.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import 'dotenv/config';
+export {};