apiforge-analyzer 1.1.0 → 1.3.0

package/dist/cjs/index.js

@@ -1,10 +1,12 @@
 "use strict";
 /**
- * Main analyzer entry point with dual module support
+ * APIForge Analyzer — main entry point (dual ESM/CJS)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectFramework = exports.uploadRoutes = exports.exportToJSON = exports.analyzeReactRouter = exports.analyzeVite = exports.analyzeNextApp = exports.analyzeNextPages = exports.analyzeExpress = void 0;
+exports.detectArchitectureType = exports.detectFramework = exports.uploadRoutes = exports.exportToJSON = exports.analyzeNestJS = exports.analyzeReactRouter = exports.analyzeVite = exports.analyzeNextApp = exports.analyzeNextPages = exports.analyzeExpress = void 0;
 exports.analyze = analyze;
+const fs_1 = require("fs");
+const path_1 = require("path");
 const express_js_1 = require("./frameworks/express.js");
 Object.defineProperty(exports, "analyzeExpress", { enumerable: true, get: function () { return express_js_1.analyzeExpress; } });
 const nextjs_pages_js_1 = require("./frameworks/nextjs-pages.js");
@@ -15,92 +17,185 @@ const vite_js_1 = require("./frameworks/vite.js");
 Object.defineProperty(exports, "analyzeVite", { enumerable: true, get: function () { return vite_js_1.analyzeVite; } });
 const react_router_js_1 = require("./frameworks/react-router.js");
 Object.defineProperty(exports, "analyzeReactRouter", { enumerable: true, get: function () { return react_router_js_1.analyzeReactRouter; } });
+const nestjs_js_1 = require("./frameworks/nestjs.js");
+Object.defineProperty(exports, "analyzeNestJS", { enumerable: true, get: function () { return nestjs_js_1.analyzeNestJS; } });
 const detect_js_1 = require("./detect.js");
 const export_js_1 = require("./export.js");
 const uploader_js_1 = require("./uploader.js");
-// Global state for debouncing
-const analysisState = new Map();
-const DEBOUNCE_TIME = 5000;
+const arch_detect_js_1 = require("./arch-detect.js");
+const express_js_2 = require("./modules/express.js");
+const nestjs_js_2 = require("./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 = (0, fs_1.readFileSync)((0, path_1.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 = (0, fs_1.readFileSync)((0, path_1.join)(process.cwd(), DEBOUNCE_FILE), 'utf-8');
+        return JSON.parse(raw).timestamp ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function stampLastRun() {
+    try {
+        (0, fs_1.writeFileSync)((0, path_1.join)(process.cwd(), DEBOUNCE_FILE), JSON.stringify({ timestamp: Date.now() }), 'utf-8');
+    }
+    catch { }
+}
+// ─── Main analyze ─────────────────────────────────────────────────────────────
 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}`);
+        (0, uploader_js_1.writeStatusFile)('error', { error: msg });
+        return [];
+    }
     let routes = [];
     let framework = options.framework;
-    // Auto-detect framework if not specified
     if (!framework) {
-        const detected = (0, detect_js_1.detectFramework)(app);
-        framework = detected.name;
+        framework = (0, detect_js_1.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 (0, nestjs_js_1.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}`);
+                    (0, uploader_js_1.writeStatusFile)('error', { error: msg });
+                    return [];
+                }
+                routes = await (0, express_js_1.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 = (0, nestjs_js_2.detectNestModules)(dir).length > 0
+                        ? (0, nestjs_js_2.detectNestModules)(dir)
+                        : (0, express_js_2.detectExpressModules)(dir);
+                    if (modules.length > 0) {
+                        routes = (0, express_js_2.annotateRoutesWithModules)(routes, modules);
+                    }
+                }
+                break;
+            case 'nextjs-pages':
+                routes = await (0, nextjs_pages_js_1.analyzeNextPages)(options.nextDir || 'pages/api');
+                break;
+            case 'nextjs-app':
+                routes = await (0, nextjs_app_js_1.analyzeNextApp)(options.nextDir || 'app');
+                break;
+            case 'vite':
+                routes = await (0, vite_js_1.analyzeVite)(options.nextDir || 'vite.config.js');
+                break;
+            case 'react-router':
+                routes = await (0, react_router_js_1.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}`);
+                (0, uploader_js_1.writeStatusFile)('error', { error: msg });
                 return [];
-            }
-            routes = await (0, express_js_1.analyzeExpress)(app);
-            break;
-        case 'nextjs-pages':
-            routes = await (0, nextjs_pages_js_1.analyzeNextPages)(options.nextDir || 'pages/api');
-            break;
-        case 'nextjs-app':
-            routes = await (0, nextjs_app_js_1.analyzeNextApp)(options.nextDir || 'app');
-            break;
-        case 'vite':
-            routes = await (0, vite_js_1.analyzeVite)(options.nextDir || 'vite.config.js');
-            break;
-        case 'react-router':
-            routes = await (0, react_router_js_1.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}`);
+        (0, uploader_js_1.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}`);
+        (0, uploader_js_1.writeStatusFile)('error', { error: msg });
+        return [];
+    }
+    console.log(`✅ Found ${routes.length} routes`);
     if (options.saveJson) {
-        const filePath = options.jsonPath || 'api-export.json';
-        await (0, export_js_1.exportToJSON)(routes, options.projectName, filePath, options.baseUrl);
+        await (0, export_js_1.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 {
+            (0, fs_1.writeFileSync)((0, path_1.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 (0, uploader_js_1.uploadRoutes)(routes, {
             projectName: options.projectName,
             apiKey: options.apiKey,
             baseUrl: options.baseUrl,
             apiForgeUrl: options.apiForgeUrl,
+            architectureType: options.architectureType,
         });
     }
     return routes;
@@ -111,7 +206,8 @@ var uploader_js_2 = require("./uploader.js");
 Object.defineProperty(exports, "uploadRoutes", { enumerable: true, get: function () { return uploader_js_2.uploadRoutes; } });
 var detect_js_2 = require("./detect.js");
 Object.defineProperty(exports, "detectFramework", { enumerable: true, get: function () { return detect_js_2.detectFramework; } });
-// Default export for CommonJS
+var arch_detect_js_2 = require("./arch-detect.js");
+Object.defineProperty(exports, "detectArchitectureType", { enumerable: true, get: function () { return arch_detect_js_2.detectArchitectureType; } });
 exports.default = {
     analyze,
     analyzeExpress: express_js_1.analyzeExpress,
@@ -119,7 +215,9 @@ exports.default = {
     analyzeNextApp: nextjs_app_js_1.analyzeNextApp,
     analyzeVite: vite_js_1.analyzeVite,
     analyzeReactRouter: react_router_js_1.analyzeReactRouter,
+    analyzeNestJS: nestjs_js_1.analyzeNestJS,
     exportToJSON: export_js_1.exportToJSON,
     uploadRoutes: uploader_js_1.uploadRoutes,
-    detectFramework: detect_js_1.detectFramework
+    detectFramework: detect_js_1.detectFramework,
+    detectArchitectureType: arch_detect_js_1.detectArchitectureType,
 };

package/dist/cjs/modules/express.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectExpressModules = detectExpressModules;
+exports.resolveModuleForPath = resolveModuleForPath;
+exports.annotateRoutesWithModules = annotateRoutesWithModules;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Detect Express feature-module structure by scanning standard directory patterns.
+ * Works for: src/modules/, src/features/, src/domains/ conventions.
+ */
+function detectExpressModules(rootDir) {
+    const modules = [];
+    const srcDir = (0, path_1.join)(rootDir, 'src');
+    for (const parentDir of ['modules', 'features', 'domains']) {
+        const dir = (0, fs_1.existsSync)(srcDir)
+            ? (0, path_1.join)(srcDir, parentDir)
+            : (0, path_1.join)(rootDir, parentDir);
+        if (!(0, fs_1.existsSync)(dir))
+            continue;
+        const subdirs = (0, fs_1.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.
+ */
+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.
+ */
+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/cjs/modules/nestjs.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectNestModules = detectNestModules;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Detect NestJS modules by scanning for *.module.ts files and extracting
+ * their declared controllers with the @Module() decorator.
+ */
+function detectNestModules(rootDir) {
+    const srcDir = (0, path_1.join)(rootDir, 'src');
+    const searchDir = (0, fs_1.existsSync)(srcDir) ? srcDir : rootDir;
+    const moduleFiles = findModuleFiles(searchDir);
+    if (moduleFiles.length === 0)
+        return [];
+    const modules = [];
+    for (const filePath of moduleFiles) {
+        const name = (0, path_1.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 = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (['node_modules', 'dist', '.next'].includes(entry.name))
+                continue;
+            if (entry.isDirectory()) {
+                results.push(...findModuleFiles((0, path_1.join)(dir, entry.name), depth + 1));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.module.ts')) {
+                results.push((0, path_1.join)(dir, entry.name));
+            }
+        }
+    }
+    catch { }
+    return results;
+}
+function inferPrefixFromModuleName(name) {
+    // user-profile → /user-profile, users → /users
+    return `/${name}`;
+}

package/dist/cjs/uploader.js

@@ -3,32 +3,72 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeStatusFile = writeStatusFile;
+exports.removeStatusFile = removeStatusFile;
 exports.uploadRoutes = uploadRoutes;
 const axios_1 = __importDefault(require("axios"));
+const fs_1 = require("fs");
+const path_1 = require("path");
 const export_js_1 = require("./export.js");
+/** Status file written to the project root so the CLI can detect completion. */
+const STATUS_FILE = '.apiforge-status.json';
+function writeStatusFile(status, data) {
+    try {
+        (0, fs_1.writeFileSync)((0, path_1.join)(process.cwd(), STATUS_FILE), JSON.stringify({ status, timestamp: Date.now(), ...data }), 'utf-8');
+    }
+    catch { }
+}
+function removeStatusFile() {
+    try {
+        const p = (0, path_1.join)(process.cwd(), STATUS_FILE);
+        if ((0, fs_1.existsSync)(p))
+            (0, fs_1.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.
  */
 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 = (0, export_js_1.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_1.default.post(`${url}/api/upload-routes`, {
-            projectName: options.projectName,
-            routes: enrichedRoutes,
-            baseUrl: options.baseUrl,
-            framework: enrichedRoutes[0]?.framework || 'unknown',
-        }, {
+        const response = await axios_1.default.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/esm/arch-detect.js

@@ -0,0 +1,130 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+export function detectArchitectureType(rootDir) {
+    let microScore = 0;
+    let modularScore = 0;
+    const evidence = [];
+    const servicePaths = [];
+    const moduleNames = [];
+    // ── Microservices signals ────────────────────────────────────────────────────
+    // Definitive: config file lists services[]
+    const configPaths = [join(rootDir, 'apiforge.config.ts'), join(rootDir, '.apiforge.json')];
+    for (const configPath of configPaths) {
+        if (existsSync(configPath)) {
+            try {
+                const raw = readFileSync(configPath, 'utf-8');
+                if (raw.includes('"services"') || raw.includes("'services'") || raw.includes('services:')) {
+                    microScore += 50;
+                    evidence.push(`Config file with services[]: ${basename(configPath)}`);
+                }
+            }
+            catch { }
+        }
+    }
+    // docker-compose.yml with multiple node service entries
+    const composePath = join(rootDir, 'docker-compose.yml');
+    if (existsSync(composePath)) {
+        try {
+            const compose = readFileSync(composePath, 'utf-8');
+            const serviceMatches = compose.match(/^\s{2}\w[\w-]+:/gm) || [];
+            if (serviceMatches.length >= 3) {
+                microScore += 35;
+                evidence.push(`docker-compose.yml with ${serviceMatches.length} services`);
+            }
+        }
+        catch { }
+    }
+    // Multiple sibling package.json at depth 1
+    const siblingPackages = findSiblingPackages(rootDir);
+    if (siblingPackages.length >= 2) {
+        microScore += 40;
+        siblingPackages.forEach(p => servicePaths.push(p));
+        evidence.push(`${siblingPackages.length} sibling package.json files (${siblingPackages.join(', ')})`);
+    }
+    // ── Modular Monolithic signals ────────────────────────────────────────────────
+    // NestJS module files anywhere in src/
+    const srcDir = join(rootDir, 'src');
+    if (existsSync(srcDir)) {
+        const nestModules = findFilesRecursive(srcDir, '.module.ts');
+        if (nestModules.length > 0) {
+            modularScore += 40;
+            nestModules.forEach(f => {
+                const name = basename(f).replace('.module.ts', '');
+                if (!moduleNames.includes(name))
+                    moduleNames.push(name);
+            });
+            evidence.push(`NestJS @Module files: ${nestModules.map(f => basename(f)).join(', ')}`);
+        }
+        // src/modules/, src/features/, or src/domains/
+        for (const dir of ['modules', 'features', 'domains']) {
+            if (existsSync(join(srcDir, dir))) {
+                modularScore += 35;
+                evidence.push(`Feature-based directory: src/${dir}/`);
+                const subdirs = readdirSync(join(srcDir, dir), { withFileTypes: true })
+                    .filter(d => d.isDirectory())
+                    .map(d => d.name);
+                subdirs.forEach(name => { if (!moduleNames.includes(name))
+                    moduleNames.push(name); });
+                break;
+            }
+        }
+    }
+    // nest-cli.json at root
+    if (existsSync(join(rootDir, 'nest-cli.json'))) {
+        modularScore += 20;
+        evidence.push('nest-cli.json found');
+    }
+    // Classify
+    let type = 'monolithic';
+    let confidence = 0.6;
+    if (microScore >= 40) {
+        type = 'microservices';
+        confidence = Math.min(0.5 + microScore / 100, 0.98);
+    }
+    else if (modularScore >= 35) {
+        type = 'modular-monolithic';
+        confidence = Math.min(0.5 + modularScore / 100, 0.95);
+    }
+    if (evidence.length === 0) {
+        evidence.push('Single package.json, flat route structure');
+    }
+    return { type, confidence, evidence, moduleNames, servicePaths };
+}
+function findSiblingPackages(rootDir) {
+    const results = [];
+    try {
+        const entries = readdirSync(rootDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (['node_modules', '.git', 'dist', '.next', 'build'].includes(entry.name))
+                continue;
+            const pkgPath = join(rootDir, entry.name, 'package.json');
+            if (existsSync(pkgPath)) {
+                results.push(`./${entry.name}`);
+            }
+        }
+    }
+    catch { }
+    return results;
+}
+function findFilesRecursive(dir, suffix, maxDepth = 6, depth = 0) {
+    if (depth > maxDepth)
+        return [];
+    const results = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === 'dist')
+                continue;
+            if (entry.isDirectory()) {
+                results.push(...findFilesRecursive(join(dir, entry.name), suffix, maxDepth, depth + 1));
+            }
+            else if (entry.isFile() && entry.name.endsWith(suffix)) {
+                results.push(join(dir, entry.name));
+            }
+        }
+    }
+    catch { }
+    return results;
+}