apiforge-analyzer 1.3.1 → 1.3.3

package/dist/cjs/index.js

@@ -3,7 +3,7 @@
  * APIForge Analyzer — main entry point (dual ESM/CJS)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectArchitectureType = exports.detectFramework = exports.uploadRoutes = exports.exportToJSON = exports.analyzeNestJS = exports.analyzeReactRouter = exports.analyzeVite = exports.analyzeNextApp = exports.analyzeNextPages = exports.analyzeExpress = void 0;
+exports.detectArchitectureType = exports.detectFramework = exports.uploadRoutes = exports.exportToJSON = exports.analyzeFastify = 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");
@@ -19,6 +19,8 @@ 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 fastify_js_1 = require("./frameworks/fastify.js");
+Object.defineProperty(exports, "analyzeFastify", { enumerable: true, get: function () { return fastify_js_1.analyzeFastify; } });
 const detect_js_1 = require("./detect.js");
 const export_js_1 = require("./export.js");
 const uploader_js_1 = require("./uploader.js");
@@ -117,6 +119,15 @@ async function analyze(app, options) {
         framework = (0, detect_js_1.detectFramework)(app).name;
         console.log(`📦 Detected framework: ${framework}`);
     }
+    // Reject loudly on an unsupported framework instead of falling through to
+    // `return []` — that return value is indistinguishable from "no routes",
+    // "no API key", "debounced", etc. A caller needs to be able to tell them apart.
+    if (!detect_js_1.SUPPORTED_FRAMEWORKS.has(framework)) {
+        const msg = `Framework "${framework}" not supported yet (${[...detect_js_1.SUPPORTED_FRAMEWORKS].join(', ')})`;
+        console.error(`❌ APIForge: ${msg}`);
+        (0, uploader_js_1.writeStatusFile)('error', { error: msg });
+        throw new Error(msg);
+    }
     try {
         switch (framework) {
             case 'nestjs':
@@ -141,6 +152,20 @@ async function analyze(app, options) {
                     }
                 }
                 break;
+            case 'fastify':
+                if (!app) {
+                    const msg = 'Fastify app instance required — pass your app object to analyze()';
+                    console.error(`❌ ${msg}`);
+                    (0, uploader_js_1.writeStatusFile)('error', { error: msg });
+                    return [];
+                }
+                routes = await (0, fastify_js_1.analyzeFastify)(app, {
+                    scopeCatalogPath: options.scopeCatalogPath,
+                    errorCatalogPath: options.errorCatalogPath,
+                    envelopes: options.envelopes,
+                    annotationsPath: options.annotationsPath,
+                });
+                break;
             case 'nextjs-pages':
                 routes = await (0, nextjs_pages_js_1.analyzeNextPages)(options.nextDir || 'pages/api');
                 break;
@@ -153,11 +178,8 @@ async function analyze(app, options) {
             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 [];
+            // No default: unsupported frameworks are rejected above, before this
+            // try block, so a thrown error here isn't silently swallowed into `[]`.
         }
     }
     catch (err) {
@@ -213,6 +235,7 @@ exports.default = {
     analyzeExpress: express_js_1.analyzeExpress,
     analyzeNextPages: nextjs_pages_js_1.analyzeNextPages,
     analyzeNextApp: nextjs_app_js_1.analyzeNextApp,
+    analyzeFastify: fastify_js_1.analyzeFastify,
     analyzeVite: vite_js_1.analyzeVite,
     analyzeReactRouter: react_router_js_1.analyzeReactRouter,
     analyzeNestJS: nestjs_js_1.analyzeNestJS,

package/dist/cjs/package.json

@@ -1 +1 @@
-{"type":"commonjs"}
+{"type":"commonjs"}

package/dist/esm/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { group, intro, outro, text, select, password, confirm, tasks, note, log, isCancel, cancel, spinner, } from '@clack/prompts';
 import { readFileSync, existsSync, writeFileSync, unlinkSync, readdirSync } from 'fs';
-import { join } from 'path';
+import { join, basename } from 'path';
 import { spawn } from 'child_process';
 import axios from 'axios';
 import { detectArchitectureType } from './arch-detect.js';
@@ -22,7 +22,7 @@ const green = (s) => `${gn}${s}${r}`;
 const yellow = (s) => `${yl}${s}${r}`;
 const red = (s) => `${rd}${s}${r}`;
 const white = (s) => `${wh}${s}${r}`;
-const VERSION = '1.3.1';
+const VERSION = '1.3.2';
 // Built-in URLs — users never need to configure these
 const BACKEND_PROD = 'https://apiforgeapi.brainfogagency.com';
 const DASHBOARD_PROD = 'https://apiforge.brainfogagency.com/dashboard';
@@ -219,11 +219,18 @@ async function main() {
     if (serverResult.status === 'error') {
         s.stop(red(`✗ ${serverResult.message}`));
         // Give a targeted hint for common failure modes
-        if (serverResult.message.includes('API key')) {
-            log.warn(yellow('Hint: The CLI wrote your key to .env.local — but your server may not load it.'));
-            log.warn(yellow('      Add this at the top of your entry file before calling analyze():'));
-            log.info(`      ${cyan("require('dotenv').config({ path: '.env.local' })")}`);
-            log.warn(yellow('      Or install dotenv:  npm install dotenv'));
+        if (serverResult.message.includes('API key') || serverResult.message.includes('Invalid API key')) {
+            log.warn(yellow('Hint: Your API key was rejected by the server. Common causes:'));
+            log.warn(yellow(''));
+            log.warn(yellow('  1. Key not yet created — go to your dashboard and generate one:'));
+            log.info(`     ${cyan('https://apiforge.brainfogagency.com/dashboard')}`);
+            log.warn(yellow(''));
+            log.warn(yellow('  2. Key belongs to a different account — make sure you\'re logged in'));
+            log.warn(yellow('     to the same account that owns this project.'));
+            log.warn(yellow(''));
+            log.warn(yellow('  3. Server not loading .env.local — add this at the top of your entry file:'));
+            log.info(`     ${cyan("require('dotenv').config({ path: '.env.local' })")}`);
+            log.warn(yellow('     Or install dotenv:  npm install dotenv'));
         }
         else if (serverResult.message.includes('No routes')) {
             log.warn(yellow('Hint: Make sure all routes are registered before analyze() is called.'));
@@ -233,6 +240,14 @@ async function main() {
             log.warn(yellow('Hint: Your server might be taking too long to start, or the analyzer'));
             log.warn(yellow('      is not being called. Check your server logs for APIForge messages.'));
         }
+        // Show captured server output to help debug the root cause
+        const capturedOutput = serverResult.serverOutput;
+        if (capturedOutput) {
+            log.info('');
+            log.info(dim('─── Server output ───────────────────────────────'));
+            capturedOutput.split('\n').slice(0, 25).forEach((line) => log.info(dim(`  ${line}`)));
+            log.info(dim('─────────────────────────────────────────────────'));
+        }
         await offerCleanup(entryFile, injected);
         outro(red('Analysis failed.'));
         process.exit(1);
@@ -390,6 +405,158 @@ function hasDockerCompose(cwd) {
     return ['docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml']
         .some(f => existsSync(join(cwd, f)));
 }
+/**
+ * Find the gateway among the discovered services (by name or by proxy-middleware
+ * usage) and parse its prefix → service map, e.g. { auth: '/auth', gold_rates: '/gold-rates' }.
+ * Matches the common `'/prefix': process.env.X_SERVICE_URL || ...` gateway route-table
+ * pattern (express-gateway / http-proxy-middleware style). Returns {} if no gateway
+ * or no recognizable mapping is found — callers should treat that as "no rewrite."
+ */
+function detectGatewayPrefixMap(cwd, services) {
+    const prefixMap = {};
+    for (const svc of services) {
+        const svcDir = svc.dir.replace(/^\.\//, '');
+        const relEntry = svc.entryFile ?? findEntryInDir(join(cwd, svcDir));
+        if (!relEntry)
+            continue;
+        let source = '';
+        try {
+            source = readFileSync(join(cwd, svcDir, relEntry), 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        const looksLikeGateway = /gateway/i.test(svc.name) || /createProxyMiddleware|http-proxy-middleware/.test(source);
+        if (!looksLikeGateway)
+            continue;
+        // '/auth': process.env.AUTH_SERVICE_URL || `http://...`
+        const re = /['"](\/[a-zA-Z0-9_-]*)['"]\s*:\s*process\.env\.([A-Z][A-Z0-9_]*)/g;
+        let m;
+        while ((m = re.exec(source))) {
+            const prefix = m[1];
+            const serviceName = m[2].replace(/_SERVICE_URL$|_URL$/, '').toLowerCase();
+            if (!prefixMap[serviceName])
+                prefixMap[serviceName] = prefix; // first (primary) mount wins over aliases
+        }
+        if (Object.keys(prefixMap).length > 0)
+            break;
+    }
+    return prefixMap;
+}
+function withGatewayPrefix(prefix, routePath) {
+    if (routePath === '/')
+        return prefix;
+    return prefix.replace(/\/$/, '') + (routePath.startsWith('/') ? routePath : `/${routePath}`);
+}
+// ─── Postman collection enrichment ─────────────────────────────────────────────
+// Runtime introspection only sees field NAMES (via regex over handler source),
+// never real example values — a Postman collection, when present, already has
+// hand-written example bodies and descriptions. We fold those in as enrichment
+// only: matched by method + path, never adds or removes an endpoint.
+function findFileRecursive(dir, matches, maxDepth, depth = 0) {
+    if (depth > maxDepth)
+        return null;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    for (const e of entries) {
+        if (e.isFile() && matches(e.name))
+            return join(dir, e.name);
+    }
+    for (const e of entries) {
+        if (e.isDirectory() && !['node_modules', '.git', 'dist', 'build', '.next'].includes(e.name)) {
+            const found = findFileRecursive(join(dir, e.name), matches, maxDepth, depth + 1);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function findPostmanCollection(cwd) {
+    const isCollection = (name) => name.endsWith('.postman_collection.json');
+    for (const dir of ['postman', 'docs/postman', '.postman', 'collections']) {
+        const dirPath = join(cwd, dir);
+        if (!existsSync(dirPath))
+            continue;
+        try {
+            const match = readdirSync(dirPath).find(isCollection);
+            if (match)
+                return join(dirPath, match);
+        }
+        catch { }
+    }
+    return findFileRecursive(cwd, isCollection, 3);
+}
+/** "{{baseUrl}}/gold-rates/graph/{{userId}}?interval=x" -> "/gold-rates/graph/:userId" */
+function postmanRawToRoutePath(raw) {
+    let p = raw.trim();
+    p = p.replace(/^\{\{[^}]+\}\}/, '');
+    p = p.split('?')[0];
+    p = p.replace(/\{\{([a-zA-Z0-9_]+)\}\}/g, ':$1');
+    if (!p)
+        p = '/';
+    if (!p.startsWith('/'))
+        p = '/' + p;
+    if (p !== '/' && p.endsWith('/'))
+        p = p.slice(0, -1);
+    return p;
+}
+/** Recursively walk a Postman collection's item tree (folders nest via `item`; requests carry `request`). */
+function walkPostmanItems(items, index) {
+    for (const node of items ?? []) {
+        if (Array.isArray(node.item))
+            walkPostmanItems(node.item, index);
+        if (!node.request)
+            continue;
+        const req = node.request;
+        const method = String(req.method || 'GET').toUpperCase();
+        const rawUrl = typeof req.url === 'string' ? req.url : req.url?.raw;
+        if (!rawUrl)
+            continue;
+        const key = `${method} ${postmanRawToRoutePath(rawUrl)}`;
+        if (index.has(key))
+            continue; // first match wins — collection often repeats the same endpoint in a smoke-test folder
+        const entry = {};
+        if (req.body?.mode === 'raw' && typeof req.body.raw === 'string' && req.body.raw.trim()) {
+            entry.bodyExample = req.body.raw.trim();
+        }
+        if (typeof req.description === 'string' && req.description.trim()) {
+            entry.description = req.description.trim();
+        }
+        if (entry.bodyExample || entry.description)
+            index.set(key, entry);
+    }
+}
+/** Enrich collected routes in-place with Postman example bodies/descriptions, matched by method+path. Never adds or drops routes. */
+function enrichRoutesFromPostman(cwd, routes) {
+    const collectionPath = findPostmanCollection(cwd);
+    if (!collectionPath)
+        return;
+    try {
+        const collection = JSON.parse(readFileSync(collectionPath, 'utf-8'));
+        const index = new Map();
+        walkPostmanItems(collection.item, index);
+        let enriched = 0;
+        for (const route of routes) {
+            const match = index.get(`${route.method} ${route.path}`);
+            if (!match)
+                continue;
+            if (match.bodyExample)
+                route.bodyExample = match.bodyExample;
+            if (match.description && !route.description)
+                route.description = match.description;
+            enriched++;
+        }
+        if (enriched > 0) {
+            log.info(dim(`Enriched ${enriched} routes with examples from ${basename(collectionPath)}`));
+        }
+    }
+    catch { }
+}
 async function microservicesFlow(config, opts) {
     const cwd = process.cwd();
     const allRoutes = [];
@@ -432,6 +599,14 @@ async function microservicesFlow(config, opts) {
         '',
         dim('Each service is started individually and its routes are collected.'),
     ].join('\n'), 'Multi-service analysis');
+    // Routes are collected at each service's own internal paths (e.g. auth's /register),
+    // not the path clients actually call through the gateway (/auth/register) — Express
+    // strips the mount prefix before the service ever sees the request. Rewrite paths
+    // here so the docs match what's actually callable.
+    const gatewayPrefixes = detectGatewayPrefixMap(cwd, config.services);
+    if (Object.keys(gatewayPrefixes).length > 0) {
+        log.info(dim(`Gateway prefixes detected: ${Object.entries(gatewayPrefixes).map(([s, p]) => `${s}→${p}`).join(', ')}`));
+    }
     for (const svc of config.services) {
         const svcSpin = spinner();
         svcSpin.start(`${bold(svc.name)} — starting…`);
@@ -460,13 +635,14 @@ async function microservicesFlow(config, opts) {
             detached: false,
         });
         // Capture output so failures are debuggable without re-running the service by hand.
-        // Bounded to the last ~4000 chars so a chatty/looping service can't blow up memory.
+        // Keep the HEAD, not the tail: Node prints "Error: ..." / "Cannot find module ..."
+        // first, then unwinds the call stack — a long stack trace must not push that
+        // opening line out of the window, so stop growing once capped instead of sliding.
         let output = '';
-        const MAX_OUTPUT = 4000;
+        const MAX_OUTPUT = 6000;
         const capture = (chunk) => {
-            output += chunk.toString();
-            if (output.length > MAX_OUTPUT)
-                output = output.slice(-MAX_OUTPUT);
+            if (output.length < MAX_OUTPUT)
+                output += chunk.toString();
         };
         child.stdout?.on('data', capture);
         child.stderr?.on('data', capture);
@@ -479,7 +655,12 @@ async function microservicesFlow(config, opts) {
         catch { }
         tryUnlink(join(cwd, statusFile));
         if (routes && routes.length > 0) {
-            const annotated = routes.map((r) => ({ ...r, service: svc.name }));
+            const prefix = gatewayPrefixes[svc.name];
+            const annotated = routes.map((r) => ({
+                ...r,
+                service: svc.name,
+                path: prefix ? withGatewayPrefix(prefix, r.path) : r.path,
+            }));
             allRoutes.push(...annotated);
             serviceMeta.push({ name: svc.name, baseUrl: svc.baseUrl });
             svcSpin.stop(green(`✓ ${svc.name} — ${routes.length} routes collected`));
@@ -488,7 +669,7 @@ async function microservicesFlow(config, opts) {
             svcSpin.stop(yellow(`◌ ${svc.name} — no routes collected (timeout or error)`));
             const trimmed = output.trim();
             if (trimmed) {
-                log.error(dim(`   ${bold(svc.name)} output:\n` + trimmed.split('\n').slice(-20).map(l => `   ${l}`).join('\n')));
+                log.error(dim(`   ${bold(svc.name)} output:\n` + trimmed.split('\n').slice(0, 30).map(l => `   ${l}`).join('\n')));
             }
         }
         // Remove injected code
@@ -498,6 +679,7 @@ async function microservicesFlow(config, opts) {
     // Safety: clean up any remaining injections (e.g. if process was interrupted)
     for (const f of injectedFiles)
         removeInjectedCode(f);
+    enrichRoutesFromPostman(cwd, allRoutes);
     if (allRoutes.length === 0) {
         log.error(red('No routes were collected from any service.'));
         outro(red('Analysis failed.'));
@@ -577,11 +759,20 @@ function startAndWaitForAnalysis(command, timeoutMs) {
         const statusPath = join(process.cwd(), STATUS_FILE);
         const child = spawn(command, {
             cwd: process.cwd(),
-            stdio: 'ignore',
+            stdio: ['ignore', 'pipe', 'pipe'],
             shell: true,
             env: { ...process.env },
             detached: false,
         });
+        // Capture server output (head-capped) so we can show it on failure
+        let serverOutput = '';
+        const MAX_OUTPUT = 4000;
+        const captureOutput = (chunk) => {
+            if (serverOutput.length < MAX_OUTPUT)
+                serverOutput += chunk.toString();
+        };
+        child.stdout?.on('data', captureOutput);
+        child.stderr?.on('data', captureOutput);
         let resolved = false;
         function finish(result) {
             if (resolved)
@@ -593,7 +784,7 @@ function startAndWaitForAnalysis(command, timeoutMs) {
                 child.kill('SIGTERM');
             }
             catch { }
-            resolve(result);
+            resolve({ ...result, serverOutput: serverOutput.trim() });
         }
         // Poll for the status file every 500 ms
         const poller = setInterval(() => {
@@ -1018,13 +1209,33 @@ function buildSnippet(projectName, apiKey, baseUrl, backendUrl, appVar, isESM, a
             `    upload: true,`,
             `    runOnce: true,`,
         ].join('\n');
+    // Collection mode: some services only mount routes inside an async bootstrap
+    // gated behind a DB/broker connect (which may hang/fail outside Docker).
+    // Poll briefly for app._router to be populated (Express-shaped apps only)
+    // before giving up and collecting whatever is there — bounded well under
+    // the CLI's 30s per-service timeout so a hung connect still surfaces.
+    const runAnalyze = `APIForge.analyze(${appVar}, {\n${opts}\n  })`;
+    const call = collectionOpts
+        ? [
+            `  let __apiforgeTries = 0`,
+            `  const __apiforgeTryCollect = () => {`,
+            `    const hasRoutes = !${appVar} || !${appVar}._router`,
+            `      ? true`,
+            `      : Array.isArray(${appVar}._router.stack) && ${appVar}._router.stack.length > 0`,
+            `    if (hasRoutes || __apiforgeTries++ >= 26) {`,
+            `      ${runAnalyze}`,
+            `    } else {`,
+            `      setTimeout(__apiforgeTryCollect, 300)`,
+            `    }`,
+            `  }`,
+            `  __apiforgeTryCollect()`,
+        ].join('\n')
+        : `  ${runAnalyze}`;
     if (isESM) {
         return [
             `// APIForge — https://apiforge.brainfogagency.com`,
             `import('apiforge-analyzer').then(({ default: APIForge }) => {`,
-            `  APIForge.analyze(${appVar}, {`,
-            opts,
-            `  })`,
+            call,
             `}).catch(() => {})`,
             '',
         ].join('\n');
@@ -1033,9 +1244,7 @@ function buildSnippet(projectName, apiKey, baseUrl, backendUrl, appVar, isESM, a
         `// APIForge — https://apiforge.brainfogagency.com`,
         `Promise.resolve().then(() => require('apiforge-analyzer')).then(mod => {`,
         `  const APIForge = mod.default || mod`,
-        `  APIForge.analyze(${appVar}, {`,
-        opts,
-        `  })`,
+        call,
         `}).catch(() => {})`,
         '',
     ].join('\n');
@@ -1059,6 +1268,12 @@ function detectAppVariable(content) {
         /(?:const|let|var)\s+(\w+)\s*=\s*(?:fastify|Fastify)\s*\(/,
         /(?:const|let|var)\s+(\w+)\s*=\s*new\s+Koa\s*\(/,
         /(?:const|let|var)\s+(\w+)\s*=\s*(?:Router|createApp|createServer)\s*\(/,
+        // Inline `require('fastify')(...)` / `require('express')(...)` — the app
+        // factory is never bound to a local name, only its return value is. This
+        // is at least as common as the named-import style above (it's the pattern
+        // in Fastify's own project generator output), and the patterns above never
+        // match it because there's no `fastify`/`express` identifier in the source.
+        /(?:const|let|var)\s+(\w+)\s*=\s*require\s*\(\s*['"](?:fastify|express)['"]\s*\)\s*(?:\.default\s*)?\(/,
     ];
     for (const re of patterns) {
         const m = content.match(re);

package/dist/esm/detect.js

@@ -1,5 +1,19 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
+/**
+ * Frameworks analyze() can actually dispatch to. Detection can identify more
+ * frameworks than this (koa, hapi) — those are named so the detector is honest
+ * about what it saw, but `supported: false` tells callers not to expect output.
+ */
+export const SUPPORTED_FRAMEWORKS = new Set([
+    'express',
+    'fastify',
+    'nestjs',
+    'nextjs-pages',
+    'nextjs-app',
+    'vite',
+    'react-router',
+]);
 const cwd = () => process.cwd();
 function fileExists(rel) {
     return existsSync(join(cwd(), rel));
@@ -18,16 +32,19 @@ function tryResolve(mod) {
  * Detect the web framework from the live app instance + filesystem hints.
  * Confidence is used to pick the best match when multiple signals fire.
  */
+function mk(name, confidence) {
+    return { name, confidence, supported: SUPPORTED_FRAMEWORKS.has(name) };
+}
 export function detectFramework(app) {
     // ── Instance-based detection (highest confidence) ─────────────────────────
     if (app && typeof app === 'function') {
         // Express: _router or lazyrouter
         if (app._router || (app.lazyrouter && typeof app.lazyrouter === 'function')) {
-            return { name: 'express', confidence: 1.0 };
+            return mk('express', 1.0);
         }
         // Koa: middleware array
         if (Array.isArray(app.middleware) && typeof app.use === 'function' && app.context) {
-            return { name: 'koa', confidence: 0.95 };
+            return mk('koa', 0.95);
         }
     }
     // Fastify: inject method and route method
@@ -35,7 +52,7 @@ export function detectFramework(app) {
         typeof app === 'object' &&
         typeof app.inject === 'function' &&
         typeof app.route === 'function') {
-        return { name: 'fastify', confidence: 1.0 };
+        return mk('fastify', 1.0);
     }
     // Hapi: server with route + start methods
     if (app &&
@@ -43,43 +60,43 @@ export function detectFramework(app) {
         typeof app.route === 'function' &&
         typeof app.start === 'function' &&
         typeof app.stop === 'function') {
-        return { name: 'hapi', confidence: 0.95 };
+        return mk('hapi', 0.95);
     }
     // NestJS application
     if (app &&
         typeof app === 'object' &&
         typeof app.getHttpServer === 'function' &&
         typeof app.listen === 'function') {
-        return { name: 'nestjs', confidence: 0.95 };
+        return mk('nestjs', 0.95);
     }
     // ── Filesystem detection ──────────────────────────────────────────────────
     // Next.js App Router
     if (fileExists('app') && (fileExists('app/layout.tsx') || fileExists('app/layout.js'))) {
-        return { name: 'nextjs-app', confidence: 0.92 };
+        return mk('nextjs-app', 0.92);
     }
     // Next.js Pages Router
     if (fileExists('pages/api') || fileExists('src/pages/api')) {
-        return { name: 'nextjs-pages', confidence: 0.90 };
+        return mk('nextjs-pages', 0.90);
     }
     if (fileExists('next.config.js') ||
         fileExists('next.config.mjs') ||
         fileExists('next.config.ts')) {
-        return { name: 'nextjs-pages', confidence: 0.75 };
+        return mk('nextjs-pages', 0.75);
     }
     // ── Dependency-based detection (lowest confidence) ────────────────────────
     if (tryResolve('express'))
-        return { name: 'express', confidence: 0.70 };
+        return mk('express', 0.70);
     if (tryResolve('fastify'))
-        return { name: 'fastify', confidence: 0.70 };
+        return mk('fastify', 0.70);
     if (tryResolve('koa'))
-        return { name: 'koa', confidence: 0.70 };
+        return mk('koa', 0.70);
     if (tryResolve('@hapi/hapi') || tryResolve('hapi'))
-        return { name: 'hapi', confidence: 0.70 };
+        return mk('hapi', 0.70);
     if (tryResolve('@nestjs/core'))
-        return { name: 'nestjs', confidence: 0.70 };
+        return mk('nestjs', 0.70);
     if (tryResolve('vite'))
-        return { name: 'vite', confidence: 0.60 };
+        return mk('vite', 0.60);
     if (tryResolve('react-router-dom'))
-        return { name: 'react-router', confidence: 0.55 };
-    return { name: 'unknown', confidence: 0 };
+        return mk('react-router', 0.55);
+    return mk('unknown', 0);
 }