apiforge-analyzer 1.1.0 → 1.3.0

package/dist/esm/index.js

@@ -1,107 +1,201 @@
 /**
- * Main analyzer entry point with dual module support
+ * APIForge Analyzer — main entry point (dual ESM/CJS)
  */
+import { writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
 import { analyzeExpress } from './frameworks/express.js';
 import { analyzeNextPages } from './frameworks/nextjs-pages.js';
 import { analyzeNextApp } from './frameworks/nextjs-app.js';
 import { analyzeVite } from './frameworks/vite.js';
 import { analyzeReactRouter } from './frameworks/react-router.js';
+import { analyzeNestJS } from './frameworks/nestjs.js';
 import { detectFramework } from './detect.js';
 import { exportToJSON } from './export.js';
-import { uploadRoutes } from './uploader.js';
-// Global state for debouncing
-const analysisState = new Map();
-const DEBOUNCE_TIME = 5000;
+import { uploadRoutes, writeStatusFile } from './uploader.js';
+import { detectArchitectureType } from './arch-detect.js';
+import { detectExpressModules, annotateRoutesWithModules } from './modules/express.js';
+import { detectNestModules } from './modules/nestjs.js';
+// ─── Env file loader — no dotenv dependency ───────────────────────────────────
 /**
- * Main analyze function with auto-detection
+ * Read a single variable from a .env-style file.
+ * Plain Node/Express doesn't auto-load .env.local, so we do it ourselves.
+ * The package never requires dotenv or any other dep for this.
  */
+function readEnvFile(varName) {
+    const candidates = [
+        '.env.local',
+        '.env.development.local',
+        '.env.development',
+        '.env',
+    ];
+    for (const file of candidates) {
+        try {
+            const content = readFileSync(join(process.cwd(), file), 'utf-8');
+            for (const line of content.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed.startsWith('#') || !trimmed.includes('='))
+                    continue;
+                const eqIdx = trimmed.indexOf('=');
+                const key = trimmed.slice(0, eqIdx).trim();
+                if (key !== varName)
+                    continue;
+                return trimmed.slice(eqIdx + 1).trim().replace(/^['"]|['"]$/g, '');
+            }
+        }
+        catch { }
+    }
+    return undefined;
+}
+// ─── File-based debounce (survives nodemon restarts) ──────────────────────────
+const DEBOUNCE_FILE = '.apiforge-last-run.json';
+const DEBOUNCE_MS = 30000; // 30 s
+function readLastRunMs() {
+    try {
+        const raw = readFileSync(join(process.cwd(), DEBOUNCE_FILE), 'utf-8');
+        return JSON.parse(raw).timestamp ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function stampLastRun() {
+    try {
+        writeFileSync(join(process.cwd(), DEBOUNCE_FILE), JSON.stringify({ timestamp: Date.now() }), 'utf-8');
+    }
+    catch { }
+}
+// ─── Main analyze ─────────────────────────────────────────────────────────────
 export async function analyze(app, options) {
-    // Skip in production
+    // Never run in production
     if (options.skipInProduction !== false && process.env.NODE_ENV === 'production') {
-        console.log('⏭️  Skipping analysis in production');
         return [];
     }
-    // Debounce check
-    if (options.runOnce !== false) {
-        const cached = analysisState.get(options.projectName);
-        const now = Date.now();
-        if (cached && (now - cached.timestamp) < DEBOUNCE_TIME) {
-            console.log(`⚡ Analysis skipped - already ran ${Math.round((now - cached.timestamp) / 1000)}s ago`);
-            return cached.routes;
+    // File-based debounce — survives nodemon restarts.
+    // Skipped in collection mode (statusFile set) because the CLI controls each service start
+    // and the shared .apiforge-last-run.json would cause services 2+ to be skipped.
+    if (options.runOnce !== false && !options.statusFile) {
+        const elapsed = Date.now() - readLastRunMs();
+        if (elapsed < DEBOUNCE_MS) {
+            console.log(`⚡ APIForge: skipped (last run ${Math.round(elapsed / 1000)}s ago)`);
+            return [];
         }
+        stampLastRun();
     }
-    console.log(`🔍 Analyzing ${options.projectName}...`);
-    // CRITICAL: Prevent restart loops - force saveJson=false when uploading
+    // ── Resolve API key ─────────────────────────────────────────────────────────
+    // Priority: explicit option → process.env → .env.local/.env file
+    // This means the package works even if the user's server doesn't load dotenv.
+    if (!options.apiKey) {
+        options.apiKey =
+            process.env.APIFORGE_API_KEY ||
+                readEnvFile('APIFORGE_API_KEY');
+    }
+    console.log(`🔍 APIForge: analyzing ${options.projectName}…`);
+    // Writing saveJson files into the watched dir triggers nodemon restart loops
     if (options.upload !== false && options.apiKey) {
         options.saveJson = false;
     }
+    // ── Early failure: upload desired but no API key anywhere ──────────────────
+    if (options.upload !== false && !options.apiKey) {
+        const msg = 'APIFORGE_API_KEY not found in options, process.env, or .env.local';
+        console.error(`❌ APIForge: ${msg}`);
+        writeStatusFile('error', { error: msg });
+        return [];
+    }
     let routes = [];
     let framework = options.framework;
-    // Auto-detect framework if not specified
     if (!framework) {
-        const detected = detectFramework(app);
-        framework = detected.name;
+        framework = detectFramework(app).name;
         console.log(`📦 Detected framework: ${framework}`);
     }
-    // Analyze based on framework
-    switch (framework) {
-        case 'express':
-            if (!app) {
-                console.error('❌ Express app instance required');
+    try {
+        switch (framework) {
+            case 'nestjs':
+                routes = await analyzeNestJS(app, options.nextDir || process.cwd());
+                break;
+            case 'express':
+                if (!app) {
+                    const msg = 'Express app instance required — pass your app object to analyze()';
+                    console.error(`❌ ${msg}`);
+                    writeStatusFile('error', { error: msg });
+                    return [];
+                }
+                routes = await analyzeExpress(app);
+                // For modular-monolithic: annotate each route with its module name
+                if (options.architectureType === 'modular-monolithic') {
+                    const dir = options.nextDir || process.cwd();
+                    const modules = detectNestModules(dir).length > 0
+                        ? detectNestModules(dir)
+                        : detectExpressModules(dir);
+                    if (modules.length > 0) {
+                        routes = annotateRoutesWithModules(routes, modules);
+                    }
+                }
+                break;
+            case 'nextjs-pages':
+                routes = await analyzeNextPages(options.nextDir || 'pages/api');
+                break;
+            case 'nextjs-app':
+                routes = await analyzeNextApp(options.nextDir || 'app');
+                break;
+            case 'vite':
+                routes = await analyzeVite(options.nextDir || 'vite.config.js');
+                break;
+            case 'react-router':
+                routes = await analyzeReactRouter(options.nextDir || 'src/routes.tsx');
+                break;
+            default:
+                const msg = `Framework "${framework}" not supported yet (express, nextjs-pages, nextjs-app, vite, react-router)`;
+                console.warn(`⚠️  APIForge: ${msg}`);
+                writeStatusFile('error', { error: msg });
                 return [];
-            }
-            routes = await analyzeExpress(app);
-            break;
-        case 'nextjs-pages':
-            routes = await analyzeNextPages(options.nextDir || 'pages/api');
-            break;
-        case 'nextjs-app':
-            routes = await analyzeNextApp(options.nextDir || 'app');
-            break;
-        case 'vite':
-            routes = await analyzeVite(options.nextDir || 'vite.config.js');
-            break;
-        case 'react-router':
-            routes = await analyzeReactRouter(options.nextDir || 'src/routes.tsx');
-            break;
-        case 'node-http':
-        case 'unknown':
-        default:
-            console.warn(`⚠️  Framework "${framework}" not supported yet`);
-            console.log('💡 Supported: express, nextjs-pages, nextjs-app, vite, react-router');
-            console.log('💡 Tip: Specify framework manually: { framework: "express" }');
-            return [];
+        }
     }
-    console.log(`✅ Found ${routes.length} routes`);
-    // Cache results
-    if (options.runOnce !== false) {
-        analysisState.set(options.projectName, {
-            timestamp: Date.now(),
-            routes
-        });
+    catch (err) {
+        const msg = err.message || 'Unknown error during route extraction';
+        console.error(`❌ APIForge analysis error: ${msg}`);
+        writeStatusFile('error', { error: msg });
+        return [];
     }
-    // Save JSON (only if not uploading)
+    if (routes.length === 0) {
+        const msg = 'No routes found — ensure routes are registered before analyze() is called';
+        console.warn(`⚠️  APIForge: ${msg}`);
+        writeStatusFile('error', { error: msg });
+        return [];
+    }
+    console.log(`✅ Found ${routes.length} routes`);
     if (options.saveJson) {
-        const filePath = options.jsonPath || 'api-export.json';
-        await exportToJSON(routes, options.projectName, filePath, options.baseUrl);
+        await exportToJSON(routes, options.projectName, options.jsonPath || 'api-export.json', options.baseUrl);
+    }
+    // Stamp service name on routes if running in microservices mode
+    if (options.service) {
+        routes = routes.map(r => ({ ...r, service: options.service }));
+    }
+    // Multi-service collection mode: write routes to a per-service file for the CLI to aggregate.
+    // The CLI spawns each service individually, collects via this file, then uploads once.
+    if (options.statusFile) {
+        try {
+            writeFileSync(join(process.cwd(), options.statusFile), JSON.stringify({ status: 'collected', service: options.service, routes, routeCount: routes.length }), 'utf-8');
+        }
+        catch { }
+        return routes;
     }
-    // Upload to APIForge
     if (options.upload !== false && options.apiKey) {
         await uploadRoutes(routes, {
             projectName: options.projectName,
             apiKey: options.apiKey,
             baseUrl: options.baseUrl,
             apiForgeUrl: options.apiForgeUrl,
+            architectureType: options.architectureType,
         });
     }
     return routes;
 }
-// Re-export framework-specific analyzers
-export { analyzeExpress, analyzeNextPages, analyzeNextApp, analyzeVite, analyzeReactRouter };
+// Re-exports for library consumers
+export { analyzeExpress, analyzeNextPages, analyzeNextApp, analyzeVite, analyzeReactRouter, analyzeNestJS };
 export { exportToJSON } from './export.js';
 export { uploadRoutes } from './uploader.js';
 export { detectFramework } from './detect.js';
-// Default export for CommonJS
+export { detectArchitectureType } from './arch-detect.js';
 export default {
     analyze,
     analyzeExpress,
@@ -109,7 +203,9 @@ export default {
     analyzeNextApp,
     analyzeVite,
     analyzeReactRouter,
+    analyzeNestJS,
     exportToJSON,
     uploadRoutes,
-    detectFramework
+    detectFramework,
+    detectArchitectureType,
 };

package/dist/esm/modules/express.js

@@ -0,0 +1,60 @@
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+/**
+ * Detect Express feature-module structure by scanning standard directory patterns.
+ * Works for: src/modules/, src/features/, src/domains/ conventions.
+ */
+export function detectExpressModules(rootDir) {
+    const modules = [];
+    const srcDir = join(rootDir, 'src');
+    for (const parentDir of ['modules', 'features', 'domains']) {
+        const dir = existsSync(srcDir)
+            ? join(srcDir, parentDir)
+            : join(rootDir, parentDir);
+        if (!existsSync(dir))
+            continue;
+        const subdirs = readdirSync(dir, { withFileTypes: true })
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name);
+        for (const name of subdirs) {
+            const routePrefix = `/${name}`;
+            modules.push({ name, routePrefix });
+        }
+        if (modules.length > 0)
+            break;
+    }
+    return modules;
+}
+/**
+ * Given a route path, return the module name it belongs to.
+ * Falls back to the tag (first meaningful path segment) when no module matches.
+ */
+export function resolveModuleForPath(routePath, modules) {
+    if (modules.length === 0)
+        return undefined;
+    // Strip /api/v1/ etc. prefixes before matching
+    const normalized = routePath.replace(/^\/(api\/)?(v\d+\/)?/, '/');
+    for (const mod of modules) {
+        if (normalized.startsWith(mod.routePrefix + '/') || normalized === mod.routePrefix) {
+            return mod.name;
+        }
+    }
+    // Fallback: first non-param, non-version segment
+    const segment = normalized.split('/').filter(s => s && !s.startsWith(':'))[0];
+    return segment || undefined;
+}
+/**
+ * Annotate a list of routes with their module names using path-prefix matching.
+ */
+export function annotateRoutesWithModules(routes, modules) {
+    return routes.map(route => ({
+        ...route,
+        module: resolveModuleForPath(route.path, modules) || inferModuleFromPath(route.path),
+    }));
+}
+function inferModuleFromPath(routePath) {
+    const skip = new Set(['api', 'v1', 'v2', 'v3']);
+    return (routePath
+        .split('/')
+        .filter(s => s && !s.startsWith(':') && !skip.has(s))[0] || 'general');
+}

package/dist/esm/modules/nestjs.js

@@ -0,0 +1,47 @@
+import { existsSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+/**
+ * Detect NestJS modules by scanning for *.module.ts files and extracting
+ * their declared controllers with the @Module() decorator.
+ */
+export function detectNestModules(rootDir) {
+    const srcDir = join(rootDir, 'src');
+    const searchDir = existsSync(srcDir) ? srcDir : rootDir;
+    const moduleFiles = findModuleFiles(searchDir);
+    if (moduleFiles.length === 0)
+        return [];
+    const modules = [];
+    for (const filePath of moduleFiles) {
+        const name = basename(filePath).replace('.module.ts', '');
+        // Skip the root AppModule — it's the container, not a domain module
+        if (name === 'app')
+            continue;
+        const routePrefix = inferPrefixFromModuleName(name);
+        modules.push({ name, routePrefix });
+    }
+    return modules;
+}
+function findModuleFiles(dir, depth = 0) {
+    if (depth > 8)
+        return [];
+    const results = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (['node_modules', 'dist', '.next'].includes(entry.name))
+                continue;
+            if (entry.isDirectory()) {
+                results.push(...findModuleFiles(join(dir, entry.name), depth + 1));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.module.ts')) {
+                results.push(join(dir, entry.name));
+            }
+        }
+    }
+    catch { }
+    return results;
+}
+function inferPrefixFromModuleName(name) {
+    // user-profile → /user-profile, users → /users
+    return `/${name}`;
+}

package/dist/esm/uploader.js

@@ -1,28 +1,66 @@
 import axios from 'axios';
+import { writeFileSync, unlinkSync, existsSync } from 'fs';
+import { join } from 'path';
 import { enrichRoutes } from './export.js';
+/** Status file written to the project root so the CLI can detect completion. */
+const STATUS_FILE = '.apiforge-status.json';
+export function writeStatusFile(status, data) {
+    try {
+        writeFileSync(join(process.cwd(), STATUS_FILE), JSON.stringify({ status, timestamp: Date.now(), ...data }), 'utf-8');
+    }
+    catch { }
+}
+export function removeStatusFile() {
+    try {
+        const p = join(process.cwd(), STATUS_FILE);
+        if (existsSync(p))
+            unlinkSync(p);
+    }
+    catch { }
+}
 /**
- * Upload routes to APIForge server
+ * Submit routes to the APIForge backend for user review.
+ * Returns the pendingImportId so the CLI can poll for approval.
  */
 export async function uploadRoutes(routes, options) {
-    const url = options.apiForgeUrl || process.env.APIFORGE_URL || 'http://localhost:3000';
+    // Production URL is the built-in default — no config needed.
+    // Override only for local testing via option or env var.
+    const backendUrl = (options.apiForgeUrl ||
+        process.env.APIFORGE_URL ||
+        'https://apiforgeapi.brainfogagency.com').replace(/\/$/, '');
     const enrichedRoutes = enrichRoutes(routes);
+    const payload = {
+        projectName: options.projectName,
+        routes: enrichedRoutes,
+        baseUrl: options.baseUrl,
+        framework: enrichedRoutes[0]?.framework || 'unknown',
+        architectureType: options.architectureType || 'monolithic',
+        services: options.services || [],
+    };
     try {
-        const response = await axios.post(`${url}/api/upload-routes`, {
-            projectName: options.projectName,
-            routes: enrichedRoutes,
-            baseUrl: options.baseUrl,
-            framework: enrichedRoutes[0]?.framework || 'unknown',
-        }, {
+        const response = await axios.post(`${backendUrl}/api/cli/submit`, payload, {
             headers: {
                 'Content-Type': 'application/json',
                 'X-API-Key': options.apiKey,
+                'User-Agent': 'apiforge-analyzer/1.3.0',
             },
             timeout: 30000,
         });
-        console.log('✅ Uploaded to APIForge:', response.data);
+        const data = response.data?.data;
+        console.log(`✅ APIForge: ${data?.message || 'Routes submitted for review'}`);
+        writeStatusFile('submitted', {
+            pendingImportId: data.pendingImportId,
+            routeCount: data.routeCount,
+        });
+        return data;
     }
     catch (error) {
-        console.error('❌ Upload failed:', error.message);
-        throw error;
+        const msg = error.response?.data?.message ||
+            error.response?.data?.error ||
+            error.message ||
+            'Unknown error';
+        console.error(`❌ APIForge upload failed: ${msg}`);
+        writeStatusFile('error', { error: msg });
+        return null;
     }
 }

package/dist/types/arch-detect.d.ts

@@ -0,0 +1,9 @@
+export type ArchitectureType = 'monolithic' | 'modular-monolithic' | 'microservices';
+export interface ArchDetectResult {
+    type: ArchitectureType;
+    confidence: number;
+    evidence: string[];
+    moduleNames: string[];
+    servicePaths: string[];
+}
+export declare function detectArchitectureType(rootDir: string): ArchDetectResult;

package/dist/types/detect.d.ts

@@ -1,13 +1,11 @@
-/**
- * Framework detection utilities
- */
-export type Framework = 'express' | 'nextjs-pages' | 'nextjs-app' | 'vite' | 'react-router' | 'node-http' | 'unknown';
+export type Framework = 'express' | 'fastify' | 'koa' | 'hapi' | 'nestjs' | 'nextjs-pages' | 'nextjs-app' | 'vite' | 'react-router' | 'node-http' | 'unknown';
 export interface FrameworkInfo {
     name: Framework;
     version?: string;
     confidence: number;
 }
 /**
- * Detect which framework is being used
+ * Detect the web framework from the live app instance + filesystem hints.
+ * Confidence is used to pick the best match when multiple signals fire.
  */
 export declare function detectFramework(app?: any): FrameworkInfo;

package/dist/types/export.d.ts

@@ -28,6 +28,8 @@ export interface Route {
     linkedPaths: string[];
     hasAuth: boolean;
     framework: string;
+    module?: string;
+    service?: string;
     sourceContext?: Record<string, any>;
 }
 /**

package/dist/types/frameworks/express.d.ts

@@ -1,5 +1,5 @@
 /**
- * Express analyzer — accurate route + payload extraction
+ * Express route analyzer — deep extraction of routes, parameters, and auth patterns
  */
 export interface Route {
     id?: number;
@@ -8,6 +8,7 @@ export interface Route {
     tag: string;
     operationId: string;
     summary: string;
+    description?: string;
     middleware: string[];
     authRequired: boolean;
     pathParams: string[];
@@ -18,6 +19,5 @@ export interface Route {
     framework: string;
     responseStatuses?: number[];
     headerParams?: string[];
-    description?: string;
 }
 export declare function analyzeExpress(app: any): Route[];

package/dist/types/frameworks/nestjs.d.ts

@@ -0,0 +1,10 @@
+import type { Route } from '../export.js';
+/**
+ * Analyze a NestJS application by extracting the underlying Express (or Fastify)
+ * HTTP adapter and reusing the existing Express route-walker.
+ *
+ * NestJS wraps an inner Express app under app.getHttpServer()._events.request.
+ * When that's available we get full runtime accuracy. Otherwise we warn and
+ * fall back to an empty array so the CLI can report the limitation.
+ */
+export declare function analyzeNestJS(app: any, rootDir?: string): Promise<Route[]>;

package/dist/types/index.d.ts

@@ -1,14 +1,17 @@
 /**
- * Main analyzer entry point with dual module support
+ * APIForge Analyzer — main entry point (dual ESM/CJS)
  */
 import { analyzeExpress } from './frameworks/express.js';
 import { analyzeNextPages } from './frameworks/nextjs-pages.js';
 import { analyzeNextApp } from './frameworks/nextjs-app.js';
 import { analyzeVite } from './frameworks/vite.js';
 import { analyzeReactRouter } from './frameworks/react-router.js';
+import { analyzeNestJS } from './frameworks/nestjs.js';
 import { detectFramework } from './detect.js';
 import { exportToJSON } from './export.js';
 import { uploadRoutes } from './uploader.js';
+import { detectArchitectureType } from './arch-detect.js';
+import type { ArchitectureType } from './arch-detect.js';
 export interface AnalyzerOptions {
     projectName: string;
     baseUrl?: string;
@@ -21,15 +24,17 @@ export interface AnalyzerOptions {
     nextDir?: string;
     skipInProduction?: boolean;
     runOnce?: boolean;
+    architectureType?: ArchitectureType;
+    service?: string;
+    /** CLI multi-service mode: write routes to this file and exit without uploading */
+    statusFile?: string;
 }
-/**
- * Main analyze function with auto-detection
- */
 export declare function analyze(app: any, options: AnalyzerOptions): Promise<any[]>;
-export { analyzeExpress, analyzeNextPages, analyzeNextApp, analyzeVite, analyzeReactRouter };
+export { analyzeExpress, analyzeNextPages, analyzeNextApp, analyzeVite, analyzeReactRouter, analyzeNestJS };
 export { exportToJSON } from './export.js';
 export { uploadRoutes } from './uploader.js';
 export { detectFramework } from './detect.js';
+export { detectArchitectureType } from './arch-detect.js';
 declare const _default: {
     analyze: typeof analyze;
     analyzeExpress: typeof analyzeExpress;
@@ -37,8 +42,10 @@ declare const _default: {
     analyzeNextApp: typeof analyzeNextApp;
     analyzeVite: typeof analyzeVite;
     analyzeReactRouter: typeof analyzeReactRouter;
+    analyzeNestJS: typeof analyzeNestJS;
     exportToJSON: typeof exportToJSON;
     uploadRoutes: typeof uploadRoutes;
     detectFramework: typeof detectFramework;
+    detectArchitectureType: typeof detectArchitectureType;
 };
 export default _default;

package/dist/types/modules/express.d.ts

@@ -0,0 +1,22 @@
+export interface ModuleInfo {
+    name: string;
+    routePrefix: string;
+}
+/**
+ * Detect Express feature-module structure by scanning standard directory patterns.
+ * Works for: src/modules/, src/features/, src/domains/ conventions.
+ */
+export declare function detectExpressModules(rootDir: string): ModuleInfo[];
+/**
+ * Given a route path, return the module name it belongs to.
+ * Falls back to the tag (first meaningful path segment) when no module matches.
+ */
+export declare function resolveModuleForPath(routePath: string, modules: ModuleInfo[]): string | undefined;
+/**
+ * Annotate a list of routes with their module names using path-prefix matching.
+ */
+export declare function annotateRoutesWithModules<T extends {
+    path: string;
+}>(routes: T[], modules: ModuleInfo[]): (T & {
+    module: string;
+})[];

package/dist/types/modules/nestjs.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleInfo } from './express.js';
+/**
+ * Detect NestJS modules by scanning for *.module.ts files and extracting
+ * their declared controllers with the @Module() decorator.
+ */
+export declare function detectNestModules(rootDir: string): ModuleInfo[];

package/dist/types/uploader.d.ts

@@ -1,11 +1,26 @@
 import { Route } from './export.js';
+import type { ArchitectureType } from './arch-detect.js';
+export interface ServiceMeta {
+    name: string;
+    baseUrl?: string;
+}
 export interface UploadOptions {
     projectName: string;
     baseUrl?: string;
     apiForgeUrl?: string;
     apiKey: string;
+    architectureType?: ArchitectureType;
+    services?: ServiceMeta[];
+}
+export interface UploadResult {
+    pendingImportId: string;
+    routeCount: number;
+    message: string;
 }
+export declare function writeStatusFile(status: 'submitted' | 'error', data: Record<string, any>): void;
+export declare function removeStatusFile(): void;
 /**
- * Upload routes to APIForge server
+ * Submit routes to the APIForge backend for user review.
+ * Returns the pendingImportId so the CLI can poll for approval.
  */
-export declare function uploadRoutes(routes: Route[], options: UploadOptions): Promise<void>;
+export declare function uploadRoutes(routes: Route[], options: UploadOptions): Promise<UploadResult | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apiforge-analyzer",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Universal API documentation generator for Express, Next.js, Vite, React Router, and Node.js",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -26,7 +26,8 @@
     "build:esm": "tsc -p tsconfig.esm.json",
     "build:cjs": "tsc -p tsconfig.cjs.json && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
     "build:types": "tsc -p tsconfig.types.json",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "node ../test-apps/run-all.cjs"
   },
   "keywords": [
     "api",