zero-doc 1.0.0

package/dist/ai-enricher.d.ts

@@ -0,0 +1,15 @@
+import { RouteEndpoint } from './types';
+export interface AIEnrichmentOptions {
+    apiKey: string;
+    model?: string;
+    batchSize?: number;
+}
+export declare class AIEnricher {
+    private openai;
+    private model;
+    constructor(options: AIEnrichmentOptions);
+    enrichEndpoint(endpoint: RouteEndpoint): Promise<RouteEndpoint>;
+    enrichEndpoints(endpoints: RouteEndpoint[]): Promise<RouteEndpoint[]>;
+    private buildPrompt;
+    private applyEnrichment;
+}

package/dist/ai-enricher.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIEnricher = void 0;
+const openai_1 = __importDefault(require("openai"));
+class AIEnricher {
+    constructor(options) {
+        this.openai = new openai_1.default({
+            apiKey: options.apiKey,
+        });
+        this.model = options.model || 'gpt-4o-mini';
+    }
+    async enrichEndpoint(endpoint) {
+        const prompt = this.buildPrompt(endpoint);
+        try {
+            const response = await this.openai.chat.completions.create({
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are an API documentation expert. Analyze the endpoint and provide structured information in JSON format.',
+                    },
+                    {
+                        role: 'user',
+                        content: prompt,
+                    },
+                ],
+                response_format: { type: 'json_object' },
+                temperature: 0.3,
+            });
+            const result = JSON.parse(response.choices[0].message.content || '{}');
+            return this.applyEnrichment(endpoint, result);
+        }
+        catch (error) {
+            console.error(`Failed to enrich ${endpoint.method} ${endpoint.path}:`, error);
+            return endpoint;
+        }
+    }
+    async enrichEndpoints(endpoints) {
+        console.log(`🤖 Enriching ${endpoints.length} endpoints with AI...\n`);
+        const enriched = [];
+        for (const endpoint of endpoints) {
+            console.log(`   Processing: ${endpoint.method} ${endpoint.path}`);
+            const result = await this.enrichEndpoint(endpoint);
+            enriched.push(result);
+        }
+        console.log('\n✨ AI enrichment complete!\n');
+        return enriched;
+    }
+    buildPrompt(endpoint) {
+        return `Analyze this API endpoint and provide enrichment data:
+
+METHOD: ${endpoint.method}
+PATH: ${endpoint.path}
+ASYNC: ${endpoint.handler.isAsync}
+PARAMETERS: ${JSON.stringify(endpoint.parameters, null, 2)}
+
+Provide a JSON response with:
+{
+  "title": "A friendly title (e.g., 'Create New User')",
+  "description": "Technical description explaining what this endpoint does",
+  "parameters": [
+    {
+      "name": "parameter name",
+      "inferredType": "string|number|boolean|object|array",
+      "description": "what this parameter is for"
+    }
+  ]
+}
+
+Rules:
+- Title should be action-oriented and concise (2-4 words)
+- Description should explain the business logic
+- Infer types based on parameter names (e.g., 'email' is string, 'page' is number, 'isActive' is boolean)
+- Provide practical descriptions for each parameter`;
+    }
+    applyEnrichment(endpoint, aiResult) {
+        const enriched = { ...endpoint };
+        enriched.metadata = {
+            ...enriched.metadata,
+            title: aiResult.title || endpoint.metadata?.title,
+            description: aiResult.description || endpoint.metadata?.description,
+            aiGenerated: true,
+        };
+        if (aiResult.parameters && Array.isArray(aiResult.parameters)) {
+            enriched.parameters = enriched.parameters.map((param) => {
+                const aiParam = aiResult.parameters.find((p) => p.name === param.name);
+                if (aiParam) {
+                    return {
+                        ...param,
+                        inferredType: aiParam.inferredType || param.inferredType,
+                        description: aiParam.description || param.description,
+                    };
+                }
+                return param;
+            });
+        }
+        return enriched;
+    }
+}
+exports.AIEnricher = AIEnricher;

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,312 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv/config");
+const commander_1 = require("commander");
+const generator_1 = require("./generator");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const tmp = __importStar(require("tmp"));
+const fse = __importStar(require("fs-extra"));
+commander_1.program
+    .name('zero-doc')
+    .description('Zero-Config API Documentation Generator')
+    .version('1.0.0');
+// Init command
+commander_1.program
+    .command('init')
+    .description('Initialize zero-doc in your project')
+    .action(() => {
+    const config = {
+        input: 'src/**/*.ts',
+        output: 'api-inventory.json',
+        tsconfig: 'tsconfig.json',
+        ai: {
+            enabled: false,
+            provider: 'gemini',
+            model: 'gemini-2.5-flash'
+        }
+    };
+    const configPath = path.join(process.cwd(), 'zero-doc.config.json');
+    if (fs.existsSync(configPath)) {
+        console.log('⚠️  zero-doc.config.json already exists');
+        return;
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log('✅ Created zero-doc.config.json');
+    console.log('💡 Edit the config file and run: zero-doc generate');
+});
+// Generate command
+commander_1.program
+    .command('generate')
+    .description('Generate API inventory from project')
+    .option('-i, --input <pattern>', 'Source files glob pattern')
+    .option('-o, --output <path>', 'Output file path')
+    .option('-c, --tsconfig <path>', 'Path to tsconfig.json')
+    .option('-n, --name <name>', 'Project name')
+    .option('--ai', 'Enable AI enrichment')
+    .option('--ai-provider <provider>', 'AI provider: openai or gemini', 'gemini')
+    .option('--ai-model <model>', 'AI model: gemini-2.5-flash (fast) or gemini-2.5-pro (smart)', 'gemini-2.5-flash')
+    .action(async (options) => {
+    console.log('🔍 Analyzing code...\n');
+    // Load config if exists
+    const configPath = path.join(process.cwd(), 'zero-doc.config.json');
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    try {
+        let aiApiKey;
+        const aiEnabled = options.ai !== undefined ? options.ai : config.ai?.enabled;
+        if (aiEnabled) {
+            const provider = options.aiProvider || config.ai?.provider || 'gemini';
+            if (provider === 'gemini') {
+                aiApiKey = process.env.GEMINI_API_KEY;
+                if (!aiApiKey) {
+                    console.error('❌ Error: --ai with gemini requires GEMINI_API_KEY environment variable');
+                    process.exit(1);
+                }
+            }
+            else {
+                aiApiKey = process.env.OPENAI_API_KEY;
+                if (!aiApiKey) {
+                    console.error('❌ Error: --ai with openai requires OPENAI_API_KEY environment variable');
+                    process.exit(1);
+                }
+            }
+        }
+        const generator = new generator_1.APIInventoryGenerator({
+            tsConfigPath: options.tsconfig || config.tsconfig,
+            projectName: options.name || config.name,
+            aiEnrichment: aiEnabled ? {
+                enabled: true,
+                apiKey: aiApiKey,
+                model: options.aiModel || config.ai?.model || 'gemini-2.5-flash',
+                provider: options.aiProvider || config.ai?.provider || 'gemini',
+            } : undefined,
+        });
+        const inputPattern = options.input || config.input || 'src/**/*.ts';
+        generator.addSourceFiles(inputPattern);
+        const inventory = await generator.generate();
+        const outputPath = options.output || config.output || 'api-inventory.json';
+        await generator.saveToFile(outputPath);
+        console.log('✅ Analysis complete!\n');
+        console.log(`📊 Statistics:`);
+        console.log(`   Total endpoints: ${inventory.stats.totalEndpoints}`);
+        console.log(`   Framework: ${inventory.project.framework}`);
+        if (aiEnabled) {
+            console.log(`   AI Provider: ${options.aiProvider || config.ai?.provider || 'gemini'}`);
+            console.log(`   AI Model: ${options.aiModel || config.ai?.model || 'gemini-2.5-flash'}`);
+        }
+        console.log('');
+        Object.entries(inventory.stats.byMethod).forEach(([method, count]) => {
+            console.log(`   ${method}: ${count}`);
+        });
+        console.log(`\n💾 File generated: ${outputPath}`);
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// Preview command
+commander_1.program
+    .command('preview')
+    .description('Generate docs and start local preview server')
+    .option('-i, --input <pattern>', 'Source files glob pattern')
+    .option('-c, --tsconfig <path>', 'Path to tsconfig.json')
+    .option('-n, --name <name>', 'Project name')
+    .option('--ai', 'Enable AI enrichment')
+    .option('--ai-provider <provider>', 'AI provider: openai or gemini', 'gemini')
+    .option('--ai-model <model>', 'AI model', 'gemini-2.5-flash')
+    .action(async (options) => {
+    console.log('🚀 Starting preview...\n');
+    // Load config if exists
+    const configPath = path.join(process.cwd(), 'zero-doc.config.json');
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    try {
+        // Step 1: Generate API inventory
+        console.log('🔍 Analyzing code...\n');
+        let aiApiKey;
+        const aiEnabled = options.ai !== undefined ? options.ai : config.ai?.enabled;
+        if (aiEnabled) {
+            const provider = options.aiProvider || config.ai?.provider || 'gemini';
+            if (provider === 'gemini') {
+                aiApiKey = process.env.GEMINI_API_KEY;
+                if (!aiApiKey) {
+                    console.error('❌ Error: --ai with gemini requires GEMINI_API_KEY environment variable');
+                    process.exit(1);
+                }
+            }
+            else {
+                aiApiKey = process.env.OPENAI_API_KEY;
+                if (!aiApiKey) {
+                    console.error('❌ Error: --ai with openai requires OPENAI_API_KEY environment variable');
+                    process.exit(1);
+                }
+            }
+        }
+        const generator = new generator_1.APIInventoryGenerator({
+            tsConfigPath: options.tsconfig || config.tsconfig,
+            projectName: options.name || config.name,
+            aiEnrichment: aiEnabled ? {
+                enabled: true,
+                apiKey: aiApiKey,
+                model: options.aiModel || config.ai?.model || 'gemini-2.5-flash',
+                provider: options.aiProvider || config.ai?.provider || 'gemini',
+            } : undefined,
+        });
+        const inputPattern = options.input || config.input || 'src/**/*.ts';
+        generator.addSourceFiles(inputPattern);
+        const inventory = await generator.generate();
+        console.log('✅ Analysis complete!\n');
+        console.log(`📊 Found ${inventory.stats.totalEndpoints} endpoints\n`);
+        // Step 2: Create temporary directory
+        const tmpDir = tmp.dirSync({
+            prefix: 'zero-doc-',
+            unsafeCleanup: true
+        });
+        const tempViewerPath = path.join(tmpDir.name, 'viewer');
+        console.log('📦 Setting up temporary viewer...\n');
+        // Step 3: Find viewer source (works in monorepo or when installed)
+        let viewerSourcePath;
+        // Try installed package path first (when installed globally)
+        const installedViewerPath = path.join(__dirname, '../viewer');
+        if (fs.existsSync(installedViewerPath)) {
+            viewerSourcePath = installedViewerPath;
+        }
+        else {
+            // Try monorepo path (development)
+            const monorepoViewerPath = path.join(__dirname, '../../apps/viewer');
+            if (fs.existsSync(monorepoViewerPath)) {
+                viewerSourcePath = monorepoViewerPath;
+            }
+            else {
+                console.error('❌ Error: Viewer app not found');
+                console.log('💡 Make sure you are in the monorepo or have installed zero-doc globally');
+                process.exit(1);
+            }
+        }
+        // Step 4: Copy viewer files to temp directory
+        await fse.copy(viewerSourcePath, tempViewerPath, {
+            filter: (src) => {
+                // Skip node_modules, dist, and other build artifacts
+                const relativePath = path.relative(viewerSourcePath, src);
+                return !relativePath.includes('node_modules') &&
+                    !relativePath.includes('dist') &&
+                    !relativePath.startsWith('.git');
+            }
+        });
+        // Step 5: Copy generated JSON to temp viewer public folder
+        const tempPublicPath = path.join(tempViewerPath, 'public');
+        if (!fs.existsSync(tempPublicPath)) {
+            fs.mkdirSync(tempPublicPath, { recursive: true });
+        }
+        const jsonContent = JSON.stringify(inventory, null, 2);
+        fs.writeFileSync(path.join(tempPublicPath, 'api-inventory.json'), jsonContent, 'utf-8');
+        // Step 6: Install dependencies in temp directory
+        console.log('📥 Installing dependencies...\n');
+        const installProcess = (0, child_process_1.spawn)('npm', ['install'], {
+            cwd: tempViewerPath,
+            stdio: 'inherit',
+            shell: true
+        });
+        await new Promise((resolve, reject) => {
+            installProcess.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`npm install failed with code ${code}`));
+                }
+            });
+            installProcess.on('error', reject);
+        });
+        // Step 7: Start Vite dev server
+        console.log('\n🚀 Starting preview server...\n');
+        console.log('📖 Documentation available at: http://localhost:5173\n');
+        console.log('💡 Press Ctrl+C to stop and clean up\n');
+        const vite = (0, child_process_1.spawn)('npm', ['run', 'dev'], {
+            cwd: tempViewerPath,
+            stdio: 'inherit',
+            shell: true
+        });
+        // Cleanup on exit
+        const cleanup = () => {
+            console.log('\n\n🧹 Cleaning up temporary files...');
+            tmpDir.removeCallback();
+            process.exit(0);
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        vite.on('error', (error) => {
+            console.error('❌ Error starting preview server:', error);
+            cleanup();
+        });
+        vite.on('close', (code) => {
+            cleanup();
+        });
+    }
+    catch (error) {
+        console.error('❌ Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// Deploy command (placeholder)
+commander_1.program
+    .command('deploy')
+    .description('Deploy documentation to zero-doc cloud')
+    .option('--token <token>', 'API token for authentication')
+    .action(async (options) => {
+    const inventoryPath = path.join(process.cwd(), 'api-inventory.json');
+    if (!fs.existsSync(inventoryPath)) {
+        console.error('❌ Error: api-inventory.json not found');
+        console.log('💡 Run: zero-doc generate first');
+        process.exit(1);
+    }
+    console.log('🚀 Deploying documentation...\n');
+    console.log('⚠️  Deploy feature coming soon!');
+    console.log('💡 For now, you can serve the viewer locally with: zero-doc preview');
+    // TODO: Implement actual deployment
+    // - Upload JSON to backend
+    // - Get unique URL
+    // - Return docs.zerodoc.com/user/project
+});
+commander_1.program.parse();

package/dist/gemini-enricher.d.ts

@@ -0,0 +1,14 @@
+import { RouteEndpoint } from './types';
+export interface GeminiEnricherOptions {
+    apiKey: string;
+    model?: string;
+}
+export declare class GeminiEnricher {
+    private genAI;
+    private model;
+    constructor(options: GeminiEnricherOptions);
+    enrichEndpoint(endpoint: RouteEndpoint): Promise<RouteEndpoint>;
+    enrichEndpoints(endpoints: RouteEndpoint[]): Promise<RouteEndpoint[]>;
+    private buildPrompt;
+    private applyEnrichment;
+}

package/dist/gemini-enricher.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiEnricher = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+class GeminiEnricher {
+    constructor(options) {
+        this.genAI = new generative_ai_1.GoogleGenerativeAI(options.apiKey);
+        // Use Gemini 2.5 Flash by default (fast and free tier friendly)
+        // Available models: gemini-2.5-flash, gemini-2.5-pro, gemini-2.0-flash
+        const modelName = options.model || 'gemini-2.5-flash';
+        this.model = this.genAI.getGenerativeModel({ model: modelName });
+    }
+    async enrichEndpoint(endpoint) {
+        const prompt = this.buildPrompt(endpoint);
+        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) {
+                console.error(`Failed to parse JSON from Gemini response for ${endpoint.method} ${endpoint.path}`);
+                return endpoint;
+            }
+            const aiResult = JSON.parse(jsonMatch[0]);
+            return this.applyEnrichment(endpoint, aiResult);
+        }
+        catch (error) {
+            console.error(`Failed to enrich ${endpoint.method} ${endpoint.path}:`, error);
+            return endpoint;
+        }
+    }
+    async enrichEndpoints(endpoints) {
+        console.log(`🤖 Enriching ${endpoints.length} endpoints with Gemini AI...\n`);
+        const enriched = [];
+        for (const endpoint of endpoints) {
+            console.log(`   Processing: ${endpoint.method} ${endpoint.path}`);
+            const result = await this.enrichEndpoint(endpoint);
+            enriched.push(result);
+        }
+        console.log('\n✨ AI enrichment complete!\n');
+        return enriched;
+    }
+    buildPrompt(endpoint) {
+        return `Analyze this API endpoint and provide enrichment data.
+
+METHOD: ${endpoint.method}
+PATH: ${endpoint.path}
+ASYNC: ${endpoint.handler.isAsync}
+PARAMETERS: ${JSON.stringify(endpoint.parameters, null, 2)}
+
+Provide a JSON response with this EXACT structure:
+{
+  "title": "A friendly title (e.g., 'Create New User')",
+  "description": "Technical description explaining what this endpoint does",
+  "parameters": [
+    {
+      "name": "parameter name",
+      "inferredType": "string|number|boolean|object|array",
+      "description": "what this parameter is for"
+    }
+  ]
+}
+
+Rules:
+- Title should be action-oriented and concise (2-4 words)
+- Description should explain the business logic
+- Infer types based on parameter names (e.g., 'email' is string, 'page' is number, 'isActive' is boolean)
+- Provide practical descriptions for each parameter
+- Return ONLY valid JSON, no markdown, no extra text`;
+    }
+    applyEnrichment(endpoint, aiResult) {
+        const enriched = { ...endpoint };
+        enriched.metadata = {
+            ...enriched.metadata,
+            title: aiResult.title || endpoint.metadata?.title,
+            description: aiResult.description || endpoint.metadata?.description,
+            aiGenerated: true,
+        };
+        if (aiResult.parameters && Array.isArray(aiResult.parameters)) {
+            enriched.parameters = enriched.parameters.map((param) => {
+                const aiParam = aiResult.parameters.find((p) => p.name === param.name);
+                if (aiParam) {
+                    return {
+                        ...param,
+                        inferredType: aiParam.inferredType || param.inferredType,
+                        description: aiParam.description || param.description,
+                    };
+                }
+                return param;
+            });
+        }
+        return enriched;
+    }
+}
+exports.GeminiEnricher = GeminiEnricher;

package/dist/generator.d.ts

@@ -0,0 +1,22 @@
+import { APIInventory } from './types';
+export interface GeneratorOptions {
+    tsConfigPath?: string;
+    projectName?: string;
+    aiEnrichment?: {
+        enabled: boolean;
+        apiKey: string;
+        model?: string;
+        provider?: 'openai' | 'gemini';
+    };
+}
+export declare class APIInventoryGenerator {
+    private parser;
+    private projectName?;
+    private aiEnricher?;
+    constructor(options: GeneratorOptions | string, projectName?: string);
+    addSourceFiles(pattern: string): void;
+    generate(): Promise<APIInventory>;
+    private detectFramework;
+    private calculateStats;
+    saveToFile(outputPath: string): Promise<void>;
+}

package/dist/generator.js

@@ -0,0 +1,113 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIInventoryGenerator = void 0;
+const parser_1 = require("./parser");
+const ai_enricher_1 = require("./ai-enricher");
+const gemini_enricher_1 = require("./gemini-enricher");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class APIInventoryGenerator {
+    constructor(options, projectName) {
+        if (typeof options === 'string') {
+            this.parser = new parser_1.RouteParser(options);
+            this.projectName = projectName;
+        }
+        else {
+            this.parser = new parser_1.RouteParser(options.tsConfigPath);
+            this.projectName = options.projectName;
+            if (options.aiEnrichment?.enabled && options.aiEnrichment.apiKey) {
+                const provider = options.aiEnrichment.provider || 'gemini';
+                if (provider === 'gemini') {
+                    this.aiEnricher = new gemini_enricher_1.GeminiEnricher({
+                        apiKey: options.aiEnrichment.apiKey,
+                        model: options.aiEnrichment.model,
+                    });
+                }
+                else {
+                    this.aiEnricher = new ai_enricher_1.AIEnricher({
+                        apiKey: options.aiEnrichment.apiKey,
+                        model: options.aiEnrichment.model,
+                    });
+                }
+            }
+        }
+    }
+    addSourceFiles(pattern) {
+        this.parser.addSourceFiles(pattern);
+    }
+    async generate() {
+        let endpoints = this.parser.parse();
+        if (this.aiEnricher) {
+            endpoints = await this.aiEnricher.enrichEndpoints(endpoints);
+        }
+        const stats = this.calculateStats(endpoints);
+        return {
+            version: '1.0.0',
+            generatedAt: new Date().toISOString(),
+            project: {
+                name: this.projectName,
+                framework: this.detectFramework(endpoints),
+            },
+            endpoints,
+            stats,
+        };
+    }
+    detectFramework(endpoints) {
+        // Simple logic: can be improved by analyzing imports
+        return 'express'; // TODO: auto-detect
+    }
+    calculateStats(endpoints) {
+        const byMethod = {};
+        endpoints.forEach(endpoint => {
+            byMethod[endpoint.method] = (byMethod[endpoint.method] || 0) + 1;
+        });
+        return {
+            totalEndpoints: endpoints.length,
+            byMethod,
+        };
+    }
+    async saveToFile(outputPath) {
+        const inventory = await this.generate();
+        const json = JSON.stringify(inventory, null, 2);
+        // Ensure directory exists
+        const dir = path.dirname(outputPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(outputPath, json, 'utf-8');
+    }
+}
+exports.APIInventoryGenerator = APIInventoryGenerator;