apiforge-analyzer 1.3.0 → 1.3.1

package/dist/cjs/arch-detect.js

@@ -44,6 +44,27 @@ function detectArchitectureType(rootDir) {
         siblingPackages.forEach(p => servicePaths.push(p));
         evidence.push(`${siblingPackages.length} sibling package.json files (${siblingPackages.join(', ')})`);
     }
+    // services/, apps/, or microservices/ dir containing 2+ independently-built
+    // subdirs (own Dockerfile and/or package.json) — the common Docker-Compose
+    // microservices layout, where each service lives one level deeper than the
+    // sibling-package check above looks.
+    for (const parentDir of ['services', 'apps', 'microservices']) {
+        const parentPath = (0, path_1.join)(rootDir, parentDir);
+        if (!(0, fs_1.existsSync)(parentPath))
+            continue;
+        try {
+            const subdirs = (0, fs_1.readdirSync)(parentPath, { withFileTypes: true }).filter(d => d.isDirectory());
+            const ownedServices = subdirs.filter(d => (0, fs_1.existsSync)((0, path_1.join)(parentPath, d.name, 'Dockerfile')) ||
+                (0, fs_1.existsSync)((0, path_1.join)(parentPath, d.name, 'package.json')));
+            if (ownedServices.length >= 2) {
+                microScore += 45;
+                ownedServices.forEach(d => servicePaths.push(`./${parentDir}/${d.name}`));
+                evidence.push(`${parentDir}/ has ${ownedServices.length} independently-built services: ${ownedServices.map(d => d.name).join(', ')}`);
+                break;
+            }
+        }
+        catch { }
+    }
     // ── Modular Monolithic signals ────────────────────────────────────────────────
     // NestJS module files anywhere in src/
     const srcDir = (0, path_1.join)(rootDir, 'src');

package/dist/cjs/cli.js

@@ -27,7 +27,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.0';
+const VERSION = '1.3.1';
 // Built-in URLs — users never need to configure these
 const BACKEND_PROD = 'https://apiforgeapi.brainfogagency.com';
 const DASHBOARD_PROD = 'https://apiforge.brainfogagency.com/dashboard';
@@ -391,6 +391,10 @@ function waitForServiceStatusFile(statusFile, timeoutMs) {
         }, timeoutMs);
     });
 }
+function hasDockerCompose(cwd) {
+    return ['docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml']
+        .some(f => (0, fs_1.existsSync)((0, path_1.join)(cwd, f)));
+}
 async function microservicesFlow(config, opts) {
     const cwd = process.cwd();
     const allRoutes = [];
@@ -403,6 +407,29 @@ async function microservicesFlow(config, opts) {
     tryUnlink((0, path_1.join)(cwd, STATUS_FILE));
     tryUnlink((0, path_1.join)(cwd, LOCK_FILE));
     persistApiKeyToEnv(opts.apiKey);
+    if (hasDockerCompose(cwd)) {
+        (0, prompts_1.note)([
+            `${yellow('Docker Compose detected — APIForge will NOT start, build, or touch Docker.')}`,
+            '',
+            dim('Each service below is run directly with node/tsx on this machine, just'),
+            dim('long enough to capture its routes, then reverted. Your containers (if'),
+            dim('running) are left completely alone — no ports, network, or images are used.'),
+            '',
+            bold('For this to work:'),
+            `  ${dim('·')} ${bold('npm install')} ${dim('has been run at the project root (deps must resolve outside Docker)')}`,
+            `  ${dim('·')} a readable ${bold('.env')} ${dim('at the project root (same values Docker passes via env_file)')}`,
+            '',
+            dim("Routes are captured before RabbitMQ/Redis/DB connections resolve, so those don't need to be reachable."),
+        ].join('\n'), 'Docker Compose project');
+        const proceed = await (0, prompts_1.confirm)({
+            message: 'Run services locally to collect routes?',
+            initialValue: true,
+        });
+        if ((0, prompts_1.isCancel)(proceed) || !proceed) {
+            (0, prompts_1.cancel)(dim('Cancelled. Run `npm install` at the project root, then re-run apiforge.'));
+            process.exit(0);
+        }
+    }
     (0, prompts_1.note)([
         bold(`Analyzing ${config.services.length} service${config.services.length > 1 ? 's' : ''}…`),
         '',
@@ -432,11 +459,22 @@ async function microservicesFlow(config, opts) {
         const startCmd = svc.startCommand ?? serviceNodeCommand(fullEntry);
         const child = (0, child_process_1.spawn)(startCmd, {
             cwd,
-            stdio: 'ignore',
+            stdio: ['ignore', 'pipe', 'pipe'],
             shell: true,
             env: { ...process.env },
             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.
+        let output = '';
+        const MAX_OUTPUT = 4000;
+        const capture = (chunk) => {
+            output += chunk.toString();
+            if (output.length > MAX_OUTPUT)
+                output = output.slice(-MAX_OUTPUT);
+        };
+        child.stdout?.on('data', capture);
+        child.stderr?.on('data', capture);
         // Wait up to 30 s for the status file to appear
         const routes = await waitForServiceStatusFile(statusFile, 30000);
         // Kill service process
@@ -453,6 +491,10 @@ async function microservicesFlow(config, opts) {
         }
         else {
             svcSpin.stop(yellow(`◌ ${svc.name} — no routes collected (timeout or error)`));
+            const trimmed = output.trim();
+            if (trimmed) {
+                prompts_1.log.error(dim(`   ${bold(svc.name)} output:\n` + trimmed.split('\n').slice(-20).map(l => `   ${l}`).join('\n')));
+            }
         }
         // Remove injected code
         removeInjectedCode(fullEntry);
@@ -896,8 +938,15 @@ function injectCode(filePath, projectName, apiKey, baseUrl, backendUrl, architec
     const isESM = detectESM(filePath, content);
     const appVar = detectAppVariable(content) ?? 'app';
     const snippet = buildSnippet(projectName, apiKey, baseUrl, backendUrl, appVar, isESM, architectureType, collectionOpts);
+    // Collection mode (microservices): append at end of file instead of before
+    // .listen(). Route mounting (app.use(...)) happens synchronously at module
+    // load; .listen() is often gated behind an async bootstrap (DB/broker
+    // connect) that can hang or fail outside its container/network. Appending
+    // at the end runs right after the synchronous portion of the module —
+    // independent of whether that bootstrap ever finishes — so route capture
+    // doesn't require RabbitMQ/Redis/DB to be reachable.
     const listenRe = /\b(?:app|server|httpServer|http)\s*\.listen\s*\(/;
-    const listenMatch = listenRe.exec(content);
+    const listenMatch = collectionOpts ? undefined : listenRe.exec(content);
     let newContent;
     let injectionPoint;
     if (listenMatch?.index !== undefined) {

package/dist/esm/arch-detect.js

@@ -41,6 +41,27 @@ export function detectArchitectureType(rootDir) {
         siblingPackages.forEach(p => servicePaths.push(p));
         evidence.push(`${siblingPackages.length} sibling package.json files (${siblingPackages.join(', ')})`);
     }
+    // services/, apps/, or microservices/ dir containing 2+ independently-built
+    // subdirs (own Dockerfile and/or package.json) — the common Docker-Compose
+    // microservices layout, where each service lives one level deeper than the
+    // sibling-package check above looks.
+    for (const parentDir of ['services', 'apps', 'microservices']) {
+        const parentPath = join(rootDir, parentDir);
+        if (!existsSync(parentPath))
+            continue;
+        try {
+            const subdirs = readdirSync(parentPath, { withFileTypes: true }).filter(d => d.isDirectory());
+            const ownedServices = subdirs.filter(d => existsSync(join(parentPath, d.name, 'Dockerfile')) ||
+                existsSync(join(parentPath, d.name, 'package.json')));
+            if (ownedServices.length >= 2) {
+                microScore += 45;
+                ownedServices.forEach(d => servicePaths.push(`./${parentDir}/${d.name}`));
+                evidence.push(`${parentDir}/ has ${ownedServices.length} independently-built services: ${ownedServices.map(d => d.name).join(', ')}`);
+                break;
+            }
+        }
+        catch { }
+    }
     // ── Modular Monolithic signals ────────────────────────────────────────────────
     // NestJS module files anywhere in src/
     const srcDir = join(rootDir, 'src');

package/dist/esm/cli.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.0';
+const VERSION = '1.3.1';
 // Built-in URLs — users never need to configure these
 const BACKEND_PROD = 'https://apiforgeapi.brainfogagency.com';
 const DASHBOARD_PROD = 'https://apiforge.brainfogagency.com/dashboard';
@@ -386,6 +386,10 @@ function waitForServiceStatusFile(statusFile, timeoutMs) {
         }, timeoutMs);
     });
 }
+function hasDockerCompose(cwd) {
+    return ['docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml']
+        .some(f => existsSync(join(cwd, f)));
+}
 async function microservicesFlow(config, opts) {
     const cwd = process.cwd();
     const allRoutes = [];
@@ -398,6 +402,29 @@ async function microservicesFlow(config, opts) {
     tryUnlink(join(cwd, STATUS_FILE));
     tryUnlink(join(cwd, LOCK_FILE));
     persistApiKeyToEnv(opts.apiKey);
+    if (hasDockerCompose(cwd)) {
+        note([
+            `${yellow('Docker Compose detected — APIForge will NOT start, build, or touch Docker.')}`,
+            '',
+            dim('Each service below is run directly with node/tsx on this machine, just'),
+            dim('long enough to capture its routes, then reverted. Your containers (if'),
+            dim('running) are left completely alone — no ports, network, or images are used.'),
+            '',
+            bold('For this to work:'),
+            `  ${dim('·')} ${bold('npm install')} ${dim('has been run at the project root (deps must resolve outside Docker)')}`,
+            `  ${dim('·')} a readable ${bold('.env')} ${dim('at the project root (same values Docker passes via env_file)')}`,
+            '',
+            dim("Routes are captured before RabbitMQ/Redis/DB connections resolve, so those don't need to be reachable."),
+        ].join('\n'), 'Docker Compose project');
+        const proceed = await confirm({
+            message: 'Run services locally to collect routes?',
+            initialValue: true,
+        });
+        if (isCancel(proceed) || !proceed) {
+            cancel(dim('Cancelled. Run `npm install` at the project root, then re-run apiforge.'));
+            process.exit(0);
+        }
+    }
     note([
         bold(`Analyzing ${config.services.length} service${config.services.length > 1 ? 's' : ''}…`),
         '',
@@ -427,11 +454,22 @@ async function microservicesFlow(config, opts) {
         const startCmd = svc.startCommand ?? serviceNodeCommand(fullEntry);
         const child = spawn(startCmd, {
             cwd,
-            stdio: 'ignore',
+            stdio: ['ignore', 'pipe', 'pipe'],
             shell: true,
             env: { ...process.env },
             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.
+        let output = '';
+        const MAX_OUTPUT = 4000;
+        const capture = (chunk) => {
+            output += chunk.toString();
+            if (output.length > MAX_OUTPUT)
+                output = output.slice(-MAX_OUTPUT);
+        };
+        child.stdout?.on('data', capture);
+        child.stderr?.on('data', capture);
         // Wait up to 30 s for the status file to appear
         const routes = await waitForServiceStatusFile(statusFile, 30000);
         // Kill service process
@@ -448,6 +486,10 @@ async function microservicesFlow(config, opts) {
         }
         else {
             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')));
+            }
         }
         // Remove injected code
         removeInjectedCode(fullEntry);
@@ -891,8 +933,15 @@ function injectCode(filePath, projectName, apiKey, baseUrl, backendUrl, architec
     const isESM = detectESM(filePath, content);
     const appVar = detectAppVariable(content) ?? 'app';
     const snippet = buildSnippet(projectName, apiKey, baseUrl, backendUrl, appVar, isESM, architectureType, collectionOpts);
+    // Collection mode (microservices): append at end of file instead of before
+    // .listen(). Route mounting (app.use(...)) happens synchronously at module
+    // load; .listen() is often gated behind an async bootstrap (DB/broker
+    // connect) that can hang or fail outside its container/network. Appending
+    // at the end runs right after the synchronous portion of the module —
+    // independent of whether that bootstrap ever finishes — so route capture
+    // doesn't require RabbitMQ/Redis/DB to be reachable.
     const listenRe = /\b(?:app|server|httpServer|http)\s*\.listen\s*\(/;
-    const listenMatch = listenRe.exec(content);
+    const listenMatch = collectionOpts ? undefined : listenRe.exec(content);
     let newContent;
     let injectionPoint;
     if (listenMatch?.index !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apiforge-analyzer",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Universal API documentation generator for Express, Next.js, Vite, React Router, and Node.js",
   "type": "module",
   "main": "./dist/cjs/index.js",