genbox 1.0.91 → 1.0.92

package/dist/commands/init.js

@@ -151,9 +151,25 @@ function convertScanToDetected(scan, root) {
         })),
         apps: {},
     };
-    // Convert apps
+    // Collect docker app build contexts first (docker takes precedence over package.json)
+    const dockerBuildContexts = new Set();
+    if (scan.compose?.applications) {
+        for (const dockerApp of scan.compose.applications) {
+            if (dockerApp.build?.context) {
+                // Normalize the path for comparison
+                const ctx = dockerApp.build.context.replace(/^\.?\/?/, '').replace(/\/$/, '');
+                dockerBuildContexts.add(ctx);
+            }
+        }
+    }
+    // Convert apps from package.json (skip if docker app builds from same directory)
     const isMultiRepo = scan.structure.type === 'hybrid';
     for (const app of scan.apps) {
+        // Skip if there's a docker app building from this directory
+        const normalizedPath = app.path.replace(/^\.?\/?/, '').replace(/\/$/, '');
+        if (dockerBuildContexts.has(normalizedPath)) {
+            continue; // Docker app takes precedence
+        }
         const mappedType = mapAppType(app.type);
         let appGit = undefined;
         if (isMultiRepo) {
@@ -179,7 +195,7 @@ function convertScanToDetected(scan, root) {
             git: appGit,
         };
     }
-    // Convert infrastructure
+    // Convert infrastructure (keep all, no deduplication - user selects by source file)
     if (scan.compose) {
         detected.infrastructure = [];
         for (const db of scan.compose.databases || []) {
@@ -188,7 +204,7 @@ function convertScanToDetected(scan, root) {
                 type: 'database',
                 image: db.image || 'unknown',
                 port: db.ports?.[0]?.host || 0,
-                source: 'docker-compose.yml',
+                source: db.sourceFile || 'docker-compose.yml',
             });
         }
         for (const cache of scan.compose.caches || []) {
@@ -197,7 +213,7 @@ function convertScanToDetected(scan, root) {
                 type: 'cache',
                 image: cache.image || 'unknown',
                 port: cache.ports?.[0]?.host || 0,
-                source: 'docker-compose.yml',
+                source: cache.sourceFile || 'docker-compose.yml',
             });
         }
         for (const queue of scan.compose.queues || []) {
@@ -206,21 +222,53 @@ function convertScanToDetected(scan, root) {
                 type: 'queue',
                 image: queue.image || 'unknown',
                 port: queue.ports?.[0]?.host || 0,
-                source: 'docker-compose.yml',
+                source: queue.sourceFile || 'docker-compose.yml',
+            });
+        }
+        // Add other infrastructure (vector DBs, search engines, etc.)
+        for (const infra of scan.compose.infrastructure || []) {
+            detected.infrastructure.push({
+                name: infra.name,
+                type: 'other',
+                image: infra.image || 'unknown',
+                port: infra.ports?.[0]?.host || 0,
+                source: infra.sourceFile || 'docker-compose.yml',
             });
         }
         // Add Docker application services as apps with runner: 'docker'
         if (scan.compose.applications && scan.compose.applications.length > 0) {
+            // Collect infrastructure service keys (name@source) to exclude from apps
+            // Only exclude if same name AND same source file
+            const infraKeys = new Set([
+                ...(scan.compose.databases || []).map(d => `${d.name}@${d.sourceFile || ''}`),
+                ...(scan.compose.caches || []).map(c => `${c.name}@${c.sourceFile || ''}`),
+                ...(scan.compose.queues || []).map(q => `${q.name}@${q.sourceFile || ''}`),
+                ...(scan.compose.infrastructure || []).map(i => `${i.name}@${i.sourceFile || ''}`),
+            ]);
             for (const dockerApp of scan.compose.applications) {
-                if (detected.apps[dockerApp.name])
-                    continue;
+                const infraCheckKey = `${dockerApp.name}@${dockerApp.sourceFile || ''}`;
+                if (infraKeys.has(infraCheckKey))
+                    continue; // Skip infrastructure services from same file
                 const { type: mappedType, reason: typeReason } = inferDockerAppType(dockerApp.name, dockerApp.build?.context, root);
-                detected.apps[dockerApp.name] = {
+                // Use unique key if app name already exists (from different source)
+                let detectedAppKey = dockerApp.name;
+                if (detected.apps[detectedAppKey]) {
+                    // Check if it's from a different source - if so, use source in key
+                    const existingSource = detected.apps[detectedAppKey].source;
+                    const newSource = dockerApp.sourceFile || 'docker-compose';
+                    if (existingSource !== newSource) {
+                        detectedAppKey = `${dockerApp.name}@${newSource}`;
+                    }
+                    else {
+                        continue; // Same source, skip duplicate
+                    }
+                }
+                detected.apps[detectedAppKey] = {
                     path: dockerApp.build?.context || '.',
                     type: mappedType,
                     type_reason: typeReason,
                     runner: 'docker',
-                    runner_reason: 'defined in docker-compose.yml',
+                    runner_reason: `defined in ${dockerApp.sourceFile || 'docker-compose.yml'}`,
                     docker: {
                         service: dockerApp.name,
                         build_context: dockerApp.build?.context,
@@ -228,7 +276,8 @@ function convertScanToDetected(scan, root) {
                         image: dockerApp.image,
                     },
                     port: dockerApp.ports?.[0]?.host,
-                    port_source: 'docker-compose.yml ports',
+                    port_source: `${dockerApp.sourceFile || 'docker-compose.yml'} ports`,
+                    source: dockerApp.sourceFile || 'docker-compose',
                 };
             }
         }
@@ -293,74 +342,216 @@ function saveDetectedConfig(rootDir, detected) {
 // App Configuration
 // =============================================================================
 /**
- * Interactive app selection
+ * Get app source group for grouping purposes
+ */
+function getAppSourceGroup(name, app) {
+    // Docker apps - group by docker-compose source file
+    if (app.runner === 'docker' && app.source) {
+        return app.source;
+    }
+    // Use app path for grouping
+    if (app.path && app.path !== '.') {
+        return app.path;
+    }
+    return 'root';
+}
+/**
+ * Interactive app selection (grouped by source)
  */
 async function selectApps(detected) {
     const appEntries = Object.entries(detected.apps);
     if (appEntries.length === 0)
         return detected;
+    // Group apps by source
+    const appsBySource = new Map();
+    for (const [name, app] of appEntries) {
+        const source = getAppSourceGroup(name, app);
+        if (!appsBySource.has(source)) {
+            appsBySource.set(source, []);
+        }
+        appsBySource.get(source).push([name, app]);
+    }
     console.log('');
     console.log(chalk_1.default.blue('=== Detected Apps ==='));
     console.log('');
-    for (const [name, app] of appEntries) {
-        const parts = [
-            chalk_1.default.cyan(name),
-            app.type ? `(${app.type})` : '',
-            app.framework ? `[${app.framework}]` : '',
-            app.port ? `port:${app.port}` : '',
-            app.runner ? chalk_1.default.dim(`runner:${app.runner}`) : '',
-        ].filter(Boolean);
-        console.log(`  ${parts.join(' ')}`);
-        if (app.git) {
-            console.log(chalk_1.default.dim(`    └─ ${app.git.remote}`));
+    // Display grouped by source
+    for (const [source, apps] of appsBySource) {
+        console.log(chalk_1.default.dim(`  ${source}:`));
+        for (const [name, app] of apps) {
+            const parts = [
+                chalk_1.default.cyan(name),
+                app.type ? `(${app.type})` : '',
+                app.framework ? `[${app.framework}]` : '',
+                app.port ? `port:${app.port}` : '',
+                app.runner ? chalk_1.default.dim(`runner:${app.runner}`) : '',
+            ].filter(Boolean);
+            console.log(`    ${parts.join(' ')}`);
         }
     }
     console.log('');
-    const appChoices = appEntries.map(([name, app]) => ({
-        name: `${name} (${app.type || 'unknown'}${app.framework ? `, ${app.framework}` : ''})`,
-        value: name,
-        checked: app.type !== 'library',
-    }));
-    const selectedApps = await prompts.checkbox({
-        message: 'Select apps to include:',
-        choices: appChoices,
+    // If only one source group, select individual apps
+    if (appsBySource.size === 1) {
+        const appChoices = appEntries.map(([name, app]) => ({
+            name: `${name} (${app.type || 'unknown'}${app.framework ? `, ${app.framework}` : ''})`,
+            value: name,
+            checked: app.type !== 'library',
+        }));
+        const selectedApps = await prompts.checkbox({
+            message: 'Select apps to include:',
+            choices: appChoices,
+        });
+        const filteredApps = {};
+        for (const appName of selectedApps) {
+            filteredApps[appName] = detected.apps[appName];
+        }
+        return { ...detected, apps: filteredApps };
+    }
+    // Multiple source groups - let user select by group first
+    const sourceChoices = Array.from(appsBySource.entries()).map(([source, apps]) => {
+        const hasLibraryOnly = apps.every(([, a]) => a.type === 'library');
+        const appNames = apps.map(([n]) => n).join(', ');
+        return {
+            name: `${source} (${appNames})`,
+            value: source,
+            checked: !hasLibraryOnly, // Uncheck if all are libraries
+        };
     });
+    const selectedSources = await prompts.checkbox({
+        message: 'Select app groups to include:',
+        choices: sourceChoices,
+    });
+    // Collect all apps from selected sources (excluding libraries by default)
     const filteredApps = {};
-    for (const appName of selectedApps) {
-        filteredApps[appName] = detected.apps[appName];
+    for (const source of selectedSources) {
+        const apps = appsBySource.get(source);
+        if (apps) {
+            for (const [name, app] of apps) {
+                // Include non-libraries by default from selected groups
+                if (app.type !== 'library') {
+                    filteredApps[name] = app;
+                }
+            }
+        }
+    }
+    // If user selected groups, ask if they want to fine-tune individual apps
+    if (selectedSources.length > 0 && Object.keys(filteredApps).length > 0) {
+        const fineTune = await prompts.confirm({
+            message: `${Object.keys(filteredApps).length} apps selected. Fine-tune individual apps?`,
+            default: false,
+        });
+        if (fineTune) {
+            // Show all apps from selected groups for fine-tuning
+            const allAppsInGroups = [];
+            for (const source of selectedSources) {
+                const apps = appsBySource.get(source);
+                if (apps)
+                    allAppsInGroups.push(...apps);
+            }
+            const appChoices = allAppsInGroups.map(([name, app]) => ({
+                name: `${name} (${app.type || 'unknown'}${app.framework ? `, ${app.framework}` : ''})`,
+                value: name,
+                checked: app.type !== 'library',
+            }));
+            const selectedApps = await prompts.checkbox({
+                message: 'Select individual apps:',
+                choices: appChoices,
+            });
+            const finalApps = {};
+            for (const appName of selectedApps) {
+                finalApps[appName] = detected.apps[appName];
+            }
+            return { ...detected, apps: finalApps };
+        }
     }
     return { ...detected, apps: filteredApps };
 }
 /**
- * Interactive infrastructure selection
+ * Interactive infrastructure selection (grouped by source file)
  */
 async function selectInfrastructure(detected) {
     if (!detected.infrastructure || detected.infrastructure.length === 0) {
         return detected;
     }
+    // Group infrastructure by source file
+    const infraBySource = new Map();
+    for (const infra of detected.infrastructure) {
+        const source = infra.source || 'unknown';
+        if (!infraBySource.has(source)) {
+            infraBySource.set(source, []);
+        }
+        infraBySource.get(source).push(infra);
+    }
     console.log('');
     console.log(chalk_1.default.blue('=== Detected Infrastructure ==='));
     console.log('');
-    for (const infra of detected.infrastructure) {
-        const parts = [
-            chalk_1.default.cyan(infra.name),
-            `(${infra.type})`,
-            infra.image ? `[${infra.image}]` : '',
-            infra.port ? `port:${infra.port}` : '',
-        ].filter(Boolean);
-        console.log(`  ${parts.join(' ')}`);
+    // Display grouped by source
+    for (const [source, infraList] of infraBySource) {
+        console.log(chalk_1.default.dim(`  ${source}:`));
+        for (const infra of infraList) {
+            const parts = [
+                chalk_1.default.cyan(infra.name),
+                `(${infra.type})`,
+                infra.image && infra.image !== 'unknown' ? `[${infra.image}]` : '',
+                infra.port ? `port:${infra.port}` : '',
+            ].filter(Boolean);
+            console.log(`    ${parts.join(' ')}`);
+        }
     }
     console.log('');
-    const infraChoices = detected.infrastructure.map(infra => ({
-        name: `${infra.name} (${infra.type}${infra.image ? `, ${infra.image}` : ''})`,
-        value: infra.name,
-        checked: true, // Infrastructure is typically required, so default to selected
-    }));
-    const selectedInfra = await prompts.checkbox({
-        message: 'Select infrastructure to include:',
-        choices: infraChoices,
+    // If only one source file, select individual services
+    if (infraBySource.size === 1) {
+        const infraChoices = detected.infrastructure.map(infra => ({
+            name: `${infra.name} (${infra.type}${infra.image && infra.image !== 'unknown' ? `, ${infra.image}` : ''})`,
+            value: infra.name,
+            checked: true,
+        }));
+        const selectedInfra = await prompts.checkbox({
+            message: 'Select infrastructure to include:',
+            choices: infraChoices,
+        });
+        const filteredInfra = detected.infrastructure.filter(infra => selectedInfra.includes(infra.name));
+        return { ...detected, infrastructure: filteredInfra.length > 0 ? filteredInfra : undefined };
+    }
+    // Multiple source files - let user select by file first
+    const sourceChoices = Array.from(infraBySource.entries()).map(([source, infraList]) => {
+        const serviceNames = infraList.map(i => i.name).join(', ');
+        return {
+            name: `${source} (${serviceNames})`,
+            value: source,
+            checked: true,
+        };
     });
-    const filteredInfra = detected.infrastructure.filter(infra => selectedInfra.includes(infra.name));
+    const selectedSources = await prompts.checkbox({
+        message: 'Select infrastructure sources to include:',
+        choices: sourceChoices,
+    });
+    // Collect all infrastructure from selected sources
+    let filteredInfra = [];
+    for (const source of selectedSources) {
+        const infraList = infraBySource.get(source);
+        if (infraList) {
+            filteredInfra.push(...infraList);
+        }
+    }
+    // If user selected sources, ask if they want to fine-tune individual services
+    if (selectedSources.length > 0 && filteredInfra.length > 0) {
+        const fineTune = await prompts.confirm({
+            message: `${filteredInfra.length} infrastructure services selected. Fine-tune individual services?`,
+            default: false,
+        });
+        if (fineTune) {
+            const infraChoices = filteredInfra.map(infra => ({
+                name: `${infra.name} (${infra.type}${infra.image && infra.image !== 'unknown' ? `, ${infra.image}` : ''}) - ${infra.source}`,
+                value: `${infra.name}@${infra.source}`, // Unique key
+                checked: true,
+            }));
+            const selectedInfraKeys = await prompts.checkbox({
+                message: 'Select individual infrastructure services:',
+                choices: infraChoices,
+            });
+            filteredInfra = filteredInfra.filter(infra => selectedInfraKeys.includes(`${infra.name}@${infra.source}`));
+        }
+    }
     return { ...detected, infrastructure: filteredInfra.length > 0 ? filteredInfra : undefined };
 }
 /**

package/dist/scanner/compose-parser.js

@@ -93,6 +93,18 @@ const INFRA_PATTERNS = [
     /^zipkin/i,
     /^vault/i,
     /^consul/i,
+    // Vector databases
+    /^qdrant/i,
+    /^weaviate/i,
+    /^semitechnologies\/weaviate/i,
+    /^pinecone/i,
+    /^milvus/i,
+    /^chroma/i,
+    // Logging
+    /^loki/i,
+    /^promtail/i,
+    /^fluentd/i,
+    /^logstash/i,
 ];
 class ComposeParser {
     /**
@@ -107,9 +119,13 @@ class ComposeParser {
         for (const file of composeFiles) {
             try {
                 const content = yaml.load(fs.readFileSync(file, 'utf8'));
+                // Get relative path for cleaner display
+                const relativeFile = path.relative(root, file);
+                // Get compose file's directory for resolving relative build contexts
+                const composeDir = path.dirname(file);
                 if (content && content.services) {
                     for (const [name, config] of Object.entries(content.services)) {
-                        const service = this.normalizeService(name, config, root);
+                        const service = this.normalizeService(name, config, root, composeDir, relativeFile);
                         allServices.push(service);
                     }
                 }
@@ -177,11 +193,11 @@ class ComposeParser {
         findRecursively(root);
         return files;
     }
-    normalizeService(name, config, root) {
+    normalizeService(name, config, root, composeDir, sourceFile) {
         return {
             name,
             image: config.image,
-            build: this.normalizeBuild(config.build, root),
+            build: this.normalizeBuild(config.build, root, composeDir),
             ports: this.normalizePorts(config.ports),
             environment: this.normalizeEnvironment(config.environment),
             envFile: this.normalizeEnvFile(config.env_file),
@@ -190,20 +206,25 @@ class ComposeParser {
             healthcheck: this.normalizeHealthcheck(config.healthcheck),
             command: this.normalizeCommand(config.command),
             labels: this.normalizeLabels(config.labels),
+            sourceFile,
         };
     }
-    normalizeBuild(build, root) {
+    normalizeBuild(build, root, composeDir) {
         if (!build)
             return undefined;
         if (typeof build === 'string') {
+            // Resolve relative to compose file directory, then make relative to root
+            const absoluteContext = path.resolve(composeDir, build);
             return {
-                context: path.resolve(root, build),
+                context: path.relative(root, absoluteContext),
             };
         }
         if (typeof build === 'object') {
             const b = build;
+            // Resolve relative to compose file directory, then make relative to root
+            const absoluteContext = path.resolve(composeDir, b.context || '.');
             return {
-                context: path.resolve(root, b.context || '.'),
+                context: path.relative(root, absoluteContext),
                 dockerfile: b.dockerfile,
                 target: b.target,
             };

package/dist/scanner/env-analyzer.js

@@ -323,8 +323,8 @@ class EnvAnalyzer {
                 return type;
             }
         }
-        // Check value format
-        if (value) {
+        // Check value format (ensure value is a string)
+        if (value && typeof value === 'string') {
             if (/^(true|false)$/i.test(value))
                 return 'boolean';
             if (/^\d+$/.test(value))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genbox",
-  "version": "1.0.91",
+  "version": "1.0.92",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {