apiforge-analyzer 1.1.0

package/dist/cjs/uploader.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadRoutes = uploadRoutes;
+const axios_1 = __importDefault(require("axios"));
+const export_js_1 = require("./export.js");
+/**
+ * Upload routes to APIForge server
+ */
+async function uploadRoutes(routes, options) {
+    const url = options.apiForgeUrl || process.env.APIFORGE_URL || 'http://localhost:3000';
+    const enrichedRoutes = (0, export_js_1.enrichRoutes)(routes);
+    try {
+        const response = await axios_1.default.post(`${url}/api/upload-routes`, {
+            projectName: options.projectName,
+            routes: enrichedRoutes,
+            baseUrl: options.baseUrl,
+            framework: enrichedRoutes[0]?.framework || 'unknown',
+        }, {
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-Key': options.apiKey,
+            },
+            timeout: 30000,
+        });
+        console.log('✅ Uploaded to APIForge:', response.data);
+    }
+    catch (error) {
+        console.error('❌ Upload failed:', error.message);
+        throw error;
+    }
+}

package/dist/esm/cli.js

@@ -0,0 +1,417 @@
+#!/usr/bin/env node
+import { group, intro, outro, text, select, password, tasks, note, log, isCancel, cancel, } from '@clack/prompts';
+import { readFileSync, existsSync, writeFileSync } from 'fs';
+import { join } from 'path';
+// ─── ANSI helpers ─────────────────────────────────────────────────────────────
+const r = '\x1b[0m';
+const b = '\x1b[1m';
+const d = '\x1b[2m';
+const cy = '\x1b[36m';
+const gn = '\x1b[32m';
+const yl = '\x1b[33m';
+const mg = '\x1b[35m';
+const wh = '\x1b[97m';
+const bold = (s) => `${b}${s}${r}`;
+const dim = (s) => `${d}${s}${r}`;
+const cyan = (s) => `${cy}${s}${r}`;
+const green = (s) => `${gn}${s}${r}`;
+const yellow = (s) => `${yl}${s}${r}`;
+const magenta = (s) => `${mg}${s}${r}`;
+const white = (s) => `${wh}${s}${r}`;
+// ─── Brand header ─────────────────────────────────────────────────────────────
+function printHeader() {
+    const lines = [
+        '',
+        `  ${cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')}`,
+        '',
+        `  ${bold(white('⚡  APIForge'))}   ${dim('v1.1.0')}`,
+        `  ${dim('AI-powered API documentation, auto-generated')}`,
+        '',
+        `  ${dim('Your entire API, documented in under 60 seconds.')}`,
+        '',
+        `  ${cyan('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')}`,
+        '',
+    ];
+    console.log(lines.join('\n'));
+}
+// ─── Shared state across tasks ────────────────────────────────────────────────
+let detectedEntry = '';
+let detectedAppVar = 'app';
+let detectedIsESM = false;
+let detectedFramework = 'unknown';
+let injectionPoint = '';
+let wasAlreadySetup = false;
+let linesAdded = 0;
+// ─── Main ─────────────────────────────────────────────────────────────────────
+async function main() {
+    process.stdout.write('\x1Bc'); // clear screen
+    printHeader();
+    intro(bold(` ${cyan('⚡')} APIForge Setup `));
+    // ── Questions (grouped so cancel is handled once) ──────────────────────────
+    const answers = await group({
+        projectName: () => text({
+            message: 'Name your project',
+            placeholder: 'My Awesome API',
+            validate: (v) => (!v.trim() ? 'Project name cannot be empty' : undefined),
+        }),
+        apiKey: () => password({
+            message: `APIForge API key  ${dim('(get one at apiforge.brainfogagency.com/dashboard)')}`,
+            validate: (v) => {
+                if (!v.trim())
+                    return 'API key is required';
+                if (!v.trim().startsWith('afg_'))
+                    return 'Key must start with afg_';
+            },
+        }),
+        baseUrl: () => text({
+            message: 'Your server base URL',
+            placeholder: 'https://api.myapp.com',
+            initialValue: 'http://localhost:3000',
+            validate: (v) => (!v.trim() ? 'Base URL is required' : undefined),
+        }),
+        method: () => select({
+            message: 'Sync method',
+            options: [
+                {
+                    value: 'runtime',
+                    label: `${bold('Runtime')}  ${dim('→')}  auto-syncs on every server start`,
+                    hint: 'recommended',
+                },
+                {
+                    value: 'json',
+                    label: `${bold('Export JSON')}  ${dim('→')}  write api-export.json, import to dashboard`,
+                },
+            ],
+        }),
+    }, {
+        onCancel: () => {
+            cancel(dim('Setup cancelled. Come back when you\'re ready.'));
+            process.exit(0);
+        },
+    });
+    if (isCancel(answers))
+        process.exit(0);
+    const { projectName, apiKey, baseUrl, method } = answers;
+    log.info(dim('─────────────────────────────────────────────────'));
+    log.info(`${dim('Project:')}  ${bold(projectName)}`);
+    log.info(`${dim('Mode:')}     ${bold(method === 'runtime' ? 'Runtime sync' : 'Export JSON')}`);
+    log.info(`${dim('Base URL:')} ${cyan(baseUrl)}`);
+    log.info(dim('─────────────────────────────────────────────────'));
+    // ── Need to ask for entry file? Do pre-scan first ─────────────────────────
+    const preDetected = detectEntryFile();
+    let entryFile;
+    if (!preDetected) {
+        log.warn('Could not auto-detect your server entry file.');
+        const custom = await text({
+            message: 'Path to your server entry file',
+            placeholder: 'src/index.ts',
+            validate: (v) => {
+                if (!v.trim())
+                    return 'Required';
+                if (!existsSync(join(process.cwd(), v.trim())))
+                    return `Not found: ${v.trim()}`;
+            },
+        });
+        if (isCancel(custom)) {
+            cancel('Setup cancelled.');
+            process.exit(0);
+        }
+        entryFile = custom.trim();
+    }
+    else {
+        entryFile = preDetected;
+    }
+    // ── Multi-step animated tasks ──────────────────────────────────────────────
+    await tasks([
+        {
+            title: `Scanning project`,
+            task: async (msg) => {
+                await sleep(350);
+                detectedEntry = entryFile;
+                msg(`Reading ${detectedEntry}`);
+                await sleep(250);
+                return `${green('✓')} Entry file: ${bold(detectedEntry)}`;
+            },
+        },
+        {
+            title: 'Analysing server file',
+            task: async (msg) => {
+                await sleep(200);
+                const fullPath = join(process.cwd(), detectedEntry);
+                const src = readFileSync(fullPath, 'utf-8');
+                detectedIsESM = detectESM(detectedEntry, src);
+                detectedAppVar = detectAppVariable(src) ?? 'app';
+                detectedFramework = detectFramework(src);
+                msg(`Detected ${detectedFramework}`);
+                await sleep(300);
+                const moduleType = detectedIsESM ? 'ESM' : 'CJS';
+                return [
+                    `${green('✓')} Framework: ${bold(detectedFramework)}`,
+                    `   Module:    ${bold(moduleType)}`,
+                    `   App var:   ${bold(detectedAppVar)}`,
+                ].join('\n');
+            },
+        },
+        {
+            title: 'Patching server file',
+            task: async (msg) => {
+                await sleep(300);
+                msg('Generating snippet…');
+                await sleep(200);
+                const result = injectCode(detectedEntry, projectName, apiKey, baseUrl, method);
+                wasAlreadySetup = result.alreadyInjected;
+                injectionPoint = result.injectionPoint ?? 'end of file';
+                linesAdded = result.linesAdded ?? 0;
+                msg(result.alreadyInjected ? 'Already configured' : `Writing to ${detectedEntry}`);
+                await sleep(300);
+                if (result.alreadyInjected) {
+                    return `${yellow('◌')} Already set up — no changes made`;
+                }
+                return [
+                    `${green('✓')} Patched: ${bold(detectedEntry)}  ${dim(`+${linesAdded} lines`)}`,
+                    `   At:      ${dim(injectionPoint)}`,
+                ].join('\n');
+            },
+        },
+        {
+            title: 'Verifying patch',
+            task: async (msg) => {
+                await sleep(200);
+                if (wasAlreadySetup) {
+                    return `${yellow('◌')} Skipped — file was already configured`;
+                }
+                const src = readFileSync(join(process.cwd(), detectedEntry), 'utf-8');
+                if (!src.includes('apiforge-analyzer')) {
+                    throw new Error('Patch verification failed — please add the snippet manually');
+                }
+                msg('Confirmed apiforge-analyzer in file');
+                await sleep(200);
+                return `${green('✓')} Verified`;
+            },
+        },
+    ]);
+    // ── Summary note ───────────────────────────────────────────────────────────
+    if (wasAlreadySetup) {
+        note([
+            bold('Already good to go!'),
+            '',
+            dim(`APIForge is already configured in ${bold(detectedEntry)}.`),
+            dim('No changes were made.'),
+        ].join('\n'), 'Status');
+    }
+    else {
+        const snippetPreview = getSnippetPreview(method, detectedAppVar);
+        note([
+            `  ${dim('File')}     ${bold(detectedEntry)}  ${dim(`+${linesAdded} lines`)}`,
+            `  ${dim('Mode')}     ${bold(method === 'json' ? 'Export JSON' : 'Runtime sync')}`,
+            `  ${dim('App var')}  ${bold(detectedAppVar)}  ${dim('(auto-detected)')}`,
+            `  ${dim('Format')}   ${bold(detectedIsESM ? 'ESM (import)' : 'CJS (require)')}`,
+            '',
+            dim('Injected snippet:'),
+            '',
+            ...snippetPreview.map(line => `  ${cyan('│')} ${dim(line)}`),
+        ].join('\n'), 'Patch summary');
+    }
+    // ── Next steps + outro ─────────────────────────────────────────────────────
+    if (method === 'json') {
+        note([
+            bold('What to do next:'),
+            '',
+            `  ${dim('1.')} Start your server once:`,
+            `     ${cyan(getStartCommand())}`,
+            '',
+            `  ${dim('2.')} Upload ${bold('api-export.json')} to the dashboard:`,
+            `     ${cyan('https://apiforge.brainfogagency.com/dashboard')}`,
+            '',
+            `  ${dim('3.')} Your AI-enhanced docs appear in seconds.`,
+        ].join('\n'), 'Next steps');
+        outro(`${green('✓')}  All set — run your server to generate the export.`);
+    }
+    else {
+        note([
+            bold('What to do next:'),
+            '',
+            `  ${dim('1.')} Start your server as normal:`,
+            `     ${cyan(getStartCommand())}`,
+            '',
+            `  ${dim('2.')} APIForge detects all routes automatically.`,
+            '',
+            `  ${dim('3.')} View your live docs:`,
+            `     ${cyan('https://apiforge.brainfogagency.com/dashboard')}`,
+        ].join('\n'), 'Next steps');
+        outro(`${green('✓')}  All set — start your server and docs will sync automatically.`);
+    }
+}
+// ─── Entry file detection ─────────────────────────────────────────────────────
+function detectEntryFile() {
+    const cwd = process.cwd();
+    try {
+        const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf-8'));
+        if (pkg.main && existsSync(join(cwd, pkg.main)))
+            return pkg.main;
+        for (const script of ['start', 'dev', 'serve']) {
+            const cmd = pkg.scripts?.[script] ?? '';
+            const m = cmd.match(/(?:node|tsx|ts-node)\s+([^\s&|;]+\.(js|ts|mjs|cjs))/);
+            if (m && existsSync(join(cwd, m[1])))
+                return m[1];
+        }
+    }
+    catch { }
+    const candidates = [
+        'index.ts', 'server.ts', 'app.ts',
+        'index.js', 'server.js', 'app.js',
+        'src/index.ts', 'src/server.ts', 'src/app.ts',
+        'src/index.js', 'src/server.js', 'src/app.js',
+    ];
+    for (const c of candidates)
+        if (existsSync(join(cwd, c)))
+            return c;
+    return null;
+}
+// ─── Framework detection from source ─────────────────────────────────────────
+function detectFramework(src) {
+    if (/require\s*\(\s*['"]express['"]\s*\)|from\s+['"]express['"]/.test(src))
+        return 'Express';
+    if (/require\s*\(\s*['"]fastify['"]\s*\)|from\s+['"]fastify['"]/.test(src))
+        return 'Fastify';
+    if (/require\s*\(\s*['"]koa['"]\s*\)|from\s+['"]koa['"]/.test(src))
+        return 'Koa';
+    if (/require\s*\(\s*['"]hapi['"]\s*\)|from\s+['"]@hapi\/hapi['"]/.test(src))
+        return 'Hapi';
+    if (/from\s+['"]next\/server['"]|NextResponse/.test(src))
+        return 'Next.js';
+    if (/createServer|http\.createServer/.test(src))
+        return 'Node HTTP';
+    return 'Node.js';
+}
+function injectCode(filePath, projectName, apiKey, baseUrl, method) {
+    const fullPath = join(process.cwd(), filePath);
+    const content = readFileSync(fullPath, 'utf-8');
+    if (content.includes('apiforge-analyzer')) {
+        return { message: 'Already configured', alreadyInjected: true };
+    }
+    const isESM = detectESM(filePath, content);
+    const appVar = detectAppVariable(content) ?? 'app';
+    const snippet = getCodeSnippet(projectName, apiKey, baseUrl, method, appVar, isESM);
+    const listenRe = /\b(?:app|server|httpServer|http)\s*\.listen\s*\(/;
+    const listenMatch = listenRe.exec(content);
+    let newContent;
+    let injectionPoint;
+    if (listenMatch?.index !== undefined) {
+        const lineStart = content.lastIndexOf('\n', listenMatch.index - 1) + 1;
+        newContent = content.slice(0, lineStart) + snippet + '\n' + content.slice(lineStart);
+        injectionPoint = `before ${listenMatch[0].trim()}…`;
+    }
+    else {
+        newContent = content.trimEnd() + '\n\n' + snippet;
+        injectionPoint = 'end of file';
+    }
+    writeFileSync(fullPath, newContent, 'utf-8');
+    const linesAdded = snippet.split('\n').length;
+    return {
+        message: `Patched ${filePath}`,
+        alreadyInjected: false,
+        appVar,
+        injectionPoint,
+        linesAdded,
+    };
+}
+function detectESM(filePath, content) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf-8'));
+        if (pkg.type === 'module')
+            return true;
+    }
+    catch { }
+    if (filePath.endsWith('.mjs'))
+        return true;
+    if (filePath.endsWith('.cjs'))
+        return false;
+    return /^(?:import|export)\s+/m.test(content);
+}
+function detectAppVariable(content) {
+    let m = content.match(/(?:const|let|var)\s+(\w+)\s*=\s*express\s*(?:\.default)?\s*\(/);
+    if (m)
+        return m[1];
+    m = content.match(/(?:const|let|var)\s+(\w+)\s*=\s*(?:fastify|Fastify)\s*\(/);
+    if (m)
+        return m[1];
+    m = content.match(/(?:const|let|var)\s+(\w+)\s*=\s*new\s+Koa\s*\(/);
+    if (m)
+        return m[1];
+    return null;
+}
+// ─── Snippet builder ──────────────────────────────────────────────────────────
+function getCodeSnippet(projectName, apiKey, baseUrl, method, appVar, isESM) {
+    const isJson = method === 'json';
+    const opts = isJson
+        ? [
+            `    apiKey: '${apiKey}',`,
+            `    projectName: '${projectName}',`,
+            `    baseUrl: '${baseUrl}',`,
+            `    saveJson: true,`,
+            `    jsonPath: './api-export.json',`,
+            `    upload: false,`,
+        ].join('\n')
+        : [
+            `    apiKey: '${apiKey}',`,
+            `    projectName: '${projectName}',`,
+            `    baseUrl: '${baseUrl}',`,
+            `    apiForgeUrl: 'https://apiforge.brainfogagency.com',`,
+            `    upload: true,`,
+        ].join('\n');
+    if (isESM) {
+        return [
+            `// APIForge — https://apiforge.brainfogagency.com`,
+            `import('apiforge-analyzer').then(({ default: APIForge }) => {`,
+            `  APIForge.analyze(${appVar}, {`,
+            opts,
+            `  })`,
+            `}).catch(() => {})`,
+            '',
+        ].join('\n');
+    }
+    return [
+        `// APIForge — https://apiforge.brainfogagency.com`,
+        `Promise.resolve().then(() => require('apiforge-analyzer')).then(mod => {`,
+        `  const APIForge = mod.default || mod`,
+        `  APIForge.analyze(${appVar}, {`,
+        opts,
+        `  })`,
+        `}).catch(() => {})`,
+        '',
+    ].join('\n');
+}
+/** First 4 lines of the injected snippet for the summary preview. */
+function getSnippetPreview(method, appVar) {
+    const isJson = method === 'json';
+    return [
+        `// APIForge — https://apiforge.brainfogagency.com`,
+        `import('apiforge-analyzer').then(({ default: APIForge }) => {`,
+        `  APIForge.analyze(${appVar}, {`,
+        `    ${isJson ? 'saveJson: true, upload: false,' : 'upload: true,'}`,
+        `  …`,
+    ];
+}
+/** Best-guess start command from package.json scripts. */
+function getStartCommand() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(process.cwd(), 'package.json'), 'utf-8'));
+        if (pkg.scripts?.start)
+            return 'npm start';
+        if (pkg.scripts?.dev)
+            return 'npm run dev';
+        if (pkg.scripts?.serve)
+            return 'npm run serve';
+    }
+    catch { }
+    return 'node ' + (detectedEntry || 'index.js');
+}
+// ─── Util ─────────────────────────────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/esm/detect.js

@@ -0,0 +1,65 @@
+/**
+ * Framework detection utilities
+ */
+/**
+ * Detect which framework is being used
+ */
+export function detectFramework(app) {
+    // Express detection
+    if (app && typeof app === 'function') {
+        if (app._router || (app.lazyrouter && typeof app.lazyrouter === 'function')) {
+            return { name: 'express', confidence: 1.0 };
+        }
+    }
+    // Next.js detection
+    try {
+        const fs = require('fs');
+        const path = require('path');
+        // Check for Next.js Pages Router
+        if (fs.existsSync(path.join(process.cwd(), 'pages'))) {
+            const hasApiFolder = fs.existsSync(path.join(process.cwd(), 'pages', 'api'));
+            if (hasApiFolder) {
+                return { name: 'nextjs-pages', confidence: 0.9 };
+            }
+        }
+        // Check for Next.js App Router
+        if (fs.existsSync(path.join(process.cwd(), 'app'))) {
+            return { name: 'nextjs-app', confidence: 0.9 };
+        }
+        // Check for next.config
+        if (fs.existsSync(path.join(process.cwd(), 'next.config.js')) ||
+            fs.existsSync(path.join(process.cwd(), 'next.config.mjs'))) {
+            return { name: 'nextjs-pages', confidence: 0.7 };
+        }
+    }
+    catch (e) {
+        // Ignore fs errors
+    }
+    // Vite detection
+    try {
+        require.resolve('vite');
+        return { name: 'vite', confidence: 0.8 };
+    }
+    catch (e) {
+        // Vite not installed
+    }
+    // React Router detection
+    try {
+        require.resolve('react-router-dom');
+        return { name: 'react-router', confidence: 0.7 };
+    }
+    catch (e) {
+        // React Router not installed
+    }
+    // Node HTTP detection
+    try {
+        const http = require('http');
+        if (http) {
+            return { name: 'node-http', confidence: 0.5 };
+        }
+    }
+    catch (e) {
+        // HTTP module not available
+    }
+    return { name: 'unknown', confidence: 0 };
+}