genbox 1.0.4 → 1.0.6

package/dist/commands/init.js

@@ -51,6 +51,79 @@ const config_generator_1 = require("../scanner/config-generator");
 const scan_1 = require("../scan");
 const CONFIG_FILENAME = 'genbox.yaml';
 const ENV_FILENAME = '.env.genbox';
+/**
+ * Detect git repositories in app directories (for multi-repo workspaces)
+ */
+function detectAppGitRepos(apps, rootDir) {
+    const { execSync } = require('child_process');
+    const repos = [];
+    for (const app of apps) {
+        const appDir = path_1.default.join(rootDir, app.path);
+        const gitDir = path_1.default.join(appDir, '.git');
+        if (!fs_1.default.existsSync(gitDir))
+            continue;
+        try {
+            const remote = execSync('git remote get-url origin', {
+                cwd: appDir,
+                stdio: 'pipe',
+                encoding: 'utf8',
+            }).trim();
+            if (!remote)
+                continue;
+            const isSSH = remote.startsWith('git@') || remote.startsWith('ssh://');
+            let provider = 'other';
+            if (remote.includes('github.com'))
+                provider = 'github';
+            else if (remote.includes('gitlab.com'))
+                provider = 'gitlab';
+            else if (remote.includes('bitbucket.org'))
+                provider = 'bitbucket';
+            let branch = 'main';
+            try {
+                branch = execSync('git rev-parse --abbrev-ref HEAD', {
+                    cwd: appDir,
+                    stdio: 'pipe',
+                    encoding: 'utf8',
+                }).trim();
+            }
+            catch { }
+            repos.push({
+                appName: app.name,
+                appPath: app.path,
+                remote,
+                type: isSSH ? 'ssh' : 'https',
+                provider,
+                branch,
+            });
+        }
+        catch {
+            // No git remote in this directory
+        }
+    }
+    return repos;
+}
+/**
+ * Find .env files in app directories
+ */
+function findAppEnvFiles(apps, rootDir) {
+    const envFiles = [];
+    const envPatterns = ['.env', '.env.local', '.env.development'];
+    for (const app of apps) {
+        const appDir = path_1.default.join(rootDir, app.path);
+        for (const pattern of envPatterns) {
+            const envPath = path_1.default.join(appDir, pattern);
+            if (fs_1.default.existsSync(envPath)) {
+                envFiles.push({
+                    appName: app.name,
+                    envFile: pattern,
+                    fullPath: envPath,
+                });
+                break; // Only take the first match per app
+            }
+        }
+    }
+    return envFiles;
+}
 exports.initCommand = new commander_1.Command('init')
     .description('Initialize a new Genbox configuration')
     .option('--v2', 'Use legacy v2 format (single-app only)')
@@ -80,24 +153,15 @@ exports.initCommand = new commander_1.Command('init')
         }
         console.log(chalk_1.default.blue('Initializing Genbox...'));
         console.log('');
-        // Get directory exclusions
+        // Get initial exclusions from CLI options only
         let exclude = [];
         if (options.exclude) {
             exclude = options.exclude.split(',').map((d) => d.trim()).filter(Boolean);
         }
-        else if (!nonInteractive) {
-            const excludeDirs = await prompts.input({
-                message: 'Directories to exclude (comma-separated, or empty to skip):',
-                default: '',
-            });
-            exclude = excludeDirs
-                ? excludeDirs.split(',').map((d) => d.trim()).filter(Boolean)
-                : [];
-        }
-        // Scan project (skip scripts initially - we'll ask about them later)
+        // Scan project first (skip scripts initially)
         const spinner = (0, ora_1.default)('Scanning project...').start();
         const scanner = new scanner_1.ProjectScanner();
-        const scan = await scanner.scan(process.cwd(), { exclude, skipScripts: true });
+        let scan = await scanner.scan(process.cwd(), { exclude, skipScripts: true });
         spinner.succeed('Project scanned');
         // Display scan results
         console.log('');
@@ -114,7 +178,27 @@ exports.initCommand = new commander_1.Command('init')
             const frameworkStr = scan.frameworks.map(f => f.name).join(', ');
             console.log(`  ${chalk_1.default.dim('Frameworks:')} ${frameworkStr}`);
         }
-        if (scan.apps.length > 0) {
+        // For multi-repo: show apps and let user select which to include
+        const isMultiRepoStructure = scan.structure.type === 'hybrid';
+        let selectedApps = scan.apps;
+        if (isMultiRepoStructure && scan.apps.length > 0 && !nonInteractive) {
+            console.log('');
+            console.log(chalk_1.default.blue('=== Apps Detected ==='));
+            const appChoices = scan.apps.map(app => ({
+                name: `${app.name} (${app.type}${app.framework ? `, ${app.framework}` : ''})`,
+                value: app.name,
+                checked: app.type !== 'library', // Default select non-libraries
+            }));
+            const selectedAppNames = await prompts.checkbox({
+                message: 'Select apps to include:',
+                choices: appChoices,
+            });
+            // Filter scan.apps to only selected ones
+            selectedApps = scan.apps.filter(a => selectedAppNames.includes(a.name));
+            // Update scan with filtered apps
+            scan = { ...scan, apps: selectedApps };
+        }
+        else if (scan.apps.length > 0) {
             console.log(`  ${chalk_1.default.dim('Apps:')}       ${scan.apps.length} discovered`);
             for (const app of scan.apps.slice(0, 5)) {
                 console.log(`               - ${app.name} (${app.type}${app.framework ? `, ${app.framework}` : ''})`);
@@ -187,10 +271,52 @@ exports.initCommand = new commander_1.Command('init')
             v3Config.defaults = {};
         }
         v3Config.defaults.size = serverSize;
-        // Git repository setup
-        if (scan.git) {
+        // Git repository setup - different handling for multi-repo vs single-repo
+        const isMultiRepo = isMultiRepoStructure;
+        if (isMultiRepo) {
+            // Multi-repo workspace: detect git repos in app directories
+            const appGitRepos = detectAppGitRepos(scan.apps, process.cwd());
+            if (appGitRepos.length > 0 && !nonInteractive) {
+                console.log('');
+                console.log(chalk_1.default.blue('=== Git Repositories ==='));
+                console.log(chalk_1.default.dim(`Found ${appGitRepos.length} git repositories in app directories`));
+                const repoChoices = appGitRepos.map(repo => ({
+                    name: `${repo.appName} - ${repo.remote}`,
+                    value: repo.appName,
+                    checked: true, // Default to include all
+                }));
+                const selectedRepos = await prompts.checkbox({
+                    message: 'Select repositories to include:',
+                    choices: repoChoices,
+                });
+                if (selectedRepos.length > 0) {
+                    v3Config.repos = {};
+                    for (const repoName of selectedRepos) {
+                        const repo = appGitRepos.find(r => r.appName === repoName);
+                        v3Config.repos[repo.appName] = {
+                            url: repo.remote,
+                            path: `/home/dev/${projectName}/${repo.appPath}`,
+                            branch: repo.branch !== 'main' && repo.branch !== 'master' ? repo.branch : undefined,
+                            auth: repo.type === 'ssh' ? 'ssh' : 'token',
+                        };
+                    }
+                }
+            }
+            else if (appGitRepos.length > 0) {
+                // Non-interactive: include all repos
+                v3Config.repos = {};
+                for (const repo of appGitRepos) {
+                    v3Config.repos[repo.appName] = {
+                        url: repo.remote,
+                        path: `/home/dev/${projectName}/${repo.appPath}`,
+                        auth: repo.type === 'ssh' ? 'ssh' : 'token',
+                    };
+                }
+            }
+        }
+        else if (scan.git) {
+            // Single repo or monorepo with root git
             if (nonInteractive) {
-                // Use detected git config with defaults
                 const repoName = path_1.default.basename(scan.git.remote, '.git').replace(/.*[:/]/, '');
                 v3Config.repos = {
                     [repoName]: {
@@ -210,7 +336,8 @@ exports.initCommand = new commander_1.Command('init')
                 }
             }
         }
-        else if (!nonInteractive) {
+        else if (!nonInteractive && !isMultiRepo) {
+            // Only ask to add repo for non-multi-repo projects
             const addRepo = await prompts.confirm({
                 message: 'No git remote detected. Add a repository?',
                 default: false,
@@ -239,66 +366,55 @@ exports.initCommand = new commander_1.Command('init')
         }
         // Environment configuration (skip in non-interactive mode)
         if (!nonInteractive) {
-            const envConfig = await setupEnvironments(scan, v3Config);
+            const envConfig = await setupEnvironments(scan, v3Config, isMultiRepo);
             if (envConfig) {
                 v3Config.environments = envConfig;
             }
         }
-        // Script selection (skip in non-interactive mode)
+        // Script selection - always show multi-select UI (skip in non-interactive mode)
         if (!nonInteractive) {
-            const includeScripts = await prompts.confirm({
-                message: 'Include setup scripts in configuration?',
-                default: false,
-            });
-            if (includeScripts) {
-                // Scan for scripts now
-                const scriptsSpinner = (0, ora_1.default)('Scanning for scripts...').start();
-                const fullScan = await scanner.scan(process.cwd(), { exclude, skipScripts: false });
-                scriptsSpinner.stop();
-                if (fullScan.scripts.length > 0) {
-                    console.log(chalk_1.default.dim(`\nFound ${fullScan.scripts.length} scripts:`));
-                    // Group scripts by directory
-                    const scriptsByDir = new Map();
-                    for (const script of fullScan.scripts) {
-                        const dir = script.path.includes('/') ? script.path.split('/')[0] : '(root)';
-                        const existing = scriptsByDir.get(dir) || [];
-                        existing.push(script);
-                        scriptsByDir.set(dir, existing);
-                    }
-                    // Show grouped scripts
-                    for (const [dir, scripts] of scriptsByDir) {
-                        console.log(chalk_1.default.dim(`  ${dir}/`));
-                        for (const s of scripts.slice(0, 5)) {
-                            console.log(chalk_1.default.dim(`    - ${s.name}`));
-                        }
-                        if (scripts.length > 5) {
-                            console.log(chalk_1.default.dim(`    ... and ${scripts.length - 5} more`));
-                        }
-                    }
-                    // Let user select scripts
-                    const scriptChoices = fullScan.scripts.map(s => ({
-                        name: `${s.path} (${s.stage})`,
-                        value: s.path,
-                        checked: s.path.startsWith('scripts/'), // Default select scripts/ directory
-                    }));
-                    const selectedScripts = await prompts.checkbox({
-                        message: 'Select scripts to include:',
-                        choices: scriptChoices,
-                    });
-                    if (selectedScripts.length > 0) {
-                        v3Config.scripts = fullScan.scripts
-                            .filter(s => selectedScripts.includes(s.path))
-                            .map(s => ({
-                            name: s.name,
-                            path: s.path,
-                            stage: s.stage,
-                        }));
-                    }
+            // Scan for scripts
+            const scriptsSpinner = (0, ora_1.default)('Scanning for scripts...').start();
+            const fullScan = await scanner.scan(process.cwd(), { exclude, skipScripts: false });
+            scriptsSpinner.stop();
+            if (fullScan.scripts.length > 0) {
+                console.log('');
+                console.log(chalk_1.default.blue('=== Setup Scripts ==='));
+                // Group scripts by directory for display
+                const scriptsByDir = new Map();
+                for (const script of fullScan.scripts) {
+                    const dir = script.path.includes('/') ? script.path.split('/')[0] : '(root)';
+                    const existing = scriptsByDir.get(dir) || [];
+                    existing.push(script);
+                    scriptsByDir.set(dir, existing);
                 }
-                else {
-                    console.log(chalk_1.default.dim('No scripts found.'));
+                // Show grouped scripts
+                for (const [dir, scripts] of scriptsByDir) {
+                    console.log(chalk_1.default.dim(`  ${dir}/ (${scripts.length} scripts)`));
+                }
+                // Let user select scripts with multi-select
+                const scriptChoices = fullScan.scripts.map(s => ({
+                    name: `${s.path} (${s.stage})`,
+                    value: s.path,
+                    checked: s.path.startsWith('scripts/'), // Default select scripts/ directory
+                }));
+                const selectedScripts = await prompts.checkbox({
+                    message: 'Select scripts to include (space to toggle, enter to confirm):',
+                    choices: scriptChoices,
+                });
+                if (selectedScripts.length > 0) {
+                    v3Config.scripts = fullScan.scripts
+                        .filter(s => selectedScripts.includes(s.path))
+                        .map(s => ({
+                        name: s.name,
+                        path: s.path,
+                        stage: s.stage,
+                    }));
                 }
             }
+            else {
+                console.log(chalk_1.default.dim('No scripts found.'));
+            }
         }
         // Save configuration
         const yamlContent = yaml.dump(v3Config, {
@@ -309,7 +425,7 @@ exports.initCommand = new commander_1.Command('init')
         fs_1.default.writeFileSync(configPath, yamlContent);
         console.log(chalk_1.default.green(`\n✔ Configuration saved to ${CONFIG_FILENAME}`));
         // Generate .env.genbox
-        await setupEnvFile(projectName, v3Config, nonInteractive);
+        await setupEnvFile(projectName, v3Config, nonInteractive, scan, isMultiRepo);
         // Show warnings
         if (generated.warnings.length > 0) {
             console.log('');
@@ -480,7 +596,7 @@ async function setupGitAuth(gitInfo, projectName) {
 /**
  * Setup staging/production environments
  */
-async function setupEnvironments(scan, config) {
+async function setupEnvironments(scan, config, isMultiRepo = false) {
     const setupEnvs = await prompts.confirm({
         message: 'Configure staging/production environments?',
         default: true,
@@ -493,37 +609,108 @@ async function setupEnvironments(scan, config) {
     console.log(chalk_1.default.dim('These URLs will be used when connecting to external services.'));
     console.log(chalk_1.default.dim('Actual secrets go in .env.genbox'));
     console.log('');
-    const stagingApiUrl = await prompts.input({
-        message: 'Staging API URL (leave empty to skip):',
-        default: '',
-    });
     const environments = {};
-    if (stagingApiUrl) {
-        environments.staging = {
-            description: 'Staging environment',
-            api: { gateway: stagingApiUrl },
-            mongodb: { url: '${STAGING_MONGODB_URL}' },
-            redis: { url: '${STAGING_REDIS_URL}' },
-        };
+    if (isMultiRepo) {
+        // For multi-repo: configure API URLs per backend app
+        const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
+        if (backendApps.length > 0) {
+            console.log(chalk_1.default.dim('Configure staging API URLs for each backend service:'));
+            const stagingApi = {};
+            for (const app of backendApps) {
+                const url = await prompts.input({
+                    message: `  ${app.name} staging URL (leave empty to skip):`,
+                    default: '',
+                });
+                if (url) {
+                    stagingApi[app.name] = url;
+                }
+            }
+            if (Object.keys(stagingApi).length > 0) {
+                environments.staging = {
+                    description: 'Staging environment',
+                    api: stagingApi,
+                    mongodb: { url: '${STAGING_MONGODB_URL}' },
+                    redis: { url: '${STAGING_REDIS_URL}' },
+                };
+            }
+        }
+        else {
+            // No backend apps, just ask for a single URL
+            const stagingApiUrl = await prompts.input({
+                message: 'Staging API URL (leave empty to skip):',
+                default: '',
+            });
+            if (stagingApiUrl) {
+                environments.staging = {
+                    description: 'Staging environment',
+                    api: { gateway: stagingApiUrl },
+                    mongodb: { url: '${STAGING_MONGODB_URL}' },
+                    redis: { url: '${STAGING_REDIS_URL}' },
+                };
+            }
+        }
+    }
+    else {
+        // Single repo: simple single URL
+        const stagingApiUrl = await prompts.input({
+            message: 'Staging API URL (leave empty to skip):',
+            default: '',
+        });
+        if (stagingApiUrl) {
+            environments.staging = {
+                description: 'Staging environment',
+                api: { gateway: stagingApiUrl },
+                mongodb: { url: '${STAGING_MONGODB_URL}' },
+                redis: { url: '${STAGING_REDIS_URL}' },
+            };
+        }
     }
     const setupProd = await prompts.confirm({
         message: 'Also configure production environment?',
         default: false,
     });
     if (setupProd) {
-        const prodApiUrl = await prompts.input({
-            message: 'Production API URL:',
-            default: '',
-        });
-        if (prodApiUrl) {
-            environments.production = {
-                description: 'Production (use with caution)',
-                api: { gateway: prodApiUrl },
-                mongodb: {
-                    url: '${PROD_MONGODB_URL}',
-                    read_only: true,
-                },
-            };
+        if (isMultiRepo) {
+            const backendApps = scan.apps.filter(a => a.type === 'backend' || a.type === 'api');
+            if (backendApps.length > 0) {
+                console.log(chalk_1.default.dim('Configure production API URLs for each backend service:'));
+                const prodApi = {};
+                for (const app of backendApps) {
+                    const url = await prompts.input({
+                        message: `  ${app.name} production URL:`,
+                        default: '',
+                    });
+                    if (url) {
+                        prodApi[app.name] = url;
+                    }
+                }
+                if (Object.keys(prodApi).length > 0) {
+                    environments.production = {
+                        description: 'Production (use with caution)',
+                        api: prodApi,
+                        mongodb: {
+                            url: '${PROD_MONGODB_URL}',
+                            read_only: true,
+                        },
+                    };
+                }
+            }
+        }
+        else {
+            const prodApiUrl = await prompts.input({
+                message: 'Production API URL:',
+                default: '',
+            });
+            if (prodApiUrl) {
+                environments.production = {
+                    description: 'Production (use with caution)',
+                    api: { gateway: prodApiUrl },
+                    mongodb: {
+                        url: '${PROD_MONGODB_URL}',
+                        read_only: true,
+                    },
+                };
+            }
         }
     }
     return Object.keys(environments).length > 0 ? environments : undefined;
@@ -531,31 +718,89 @@ async function setupEnvironments(scan, config) {
 /**
  * Setup .env.genbox file
  */
-async function setupEnvFile(projectName, config, nonInteractive = false) {
+async function setupEnvFile(projectName, config, nonInteractive = false, scan, isMultiRepo = false) {
     const envPath = path_1.default.join(process.cwd(), ENV_FILENAME);
     if (fs_1.default.existsSync(envPath)) {
         console.log(chalk_1.default.dim(`  ${ENV_FILENAME} already exists, skipping...`));
         return;
     }
-    // Check for existing .env
-    const existingEnvFiles = ['.env.local', '.env', '.env.development'];
-    let existingEnvPath;
-    for (const envFile of existingEnvFiles) {
-        const fullPath = path_1.default.join(process.cwd(), envFile);
-        if (fs_1.default.existsSync(fullPath)) {
-            existingEnvPath = fullPath;
-            break;
+    // For multi-repo: find env files in app directories
+    if (isMultiRepo && scan) {
+        const appEnvFiles = findAppEnvFiles(scan.apps, process.cwd());
+        if (appEnvFiles.length > 0 && !nonInteractive) {
+            console.log('');
+            console.log(chalk_1.default.blue('=== Environment Files ==='));
+            console.log(chalk_1.default.dim(`Found .env files in ${appEnvFiles.length} app directories`));
+            const envChoices = appEnvFiles.map(env => ({
+                name: `${env.appName}/${env.envFile}`,
+                value: env.fullPath,
+                checked: true,
+            }));
+            const selectedEnvFiles = await prompts.checkbox({
+                message: 'Select .env files to merge into .env.genbox:',
+                choices: envChoices,
+            });
+            if (selectedEnvFiles.length > 0) {
+                let mergedContent = `# Genbox Environment Variables
+# Merged from: ${selectedEnvFiles.map(f => path_1.default.relative(process.cwd(), f)).join(', ')}
+# DO NOT COMMIT THIS FILE
+#
+# Add staging/production URLs:
+# STAGING_MONGODB_URL=mongodb+srv://...
+# STAGING_REDIS_URL=redis://...
+# PROD_MONGODB_URL=mongodb+srv://...
+#
+# Git authentication:
+# GIT_TOKEN=ghp_xxxxxxxxxxxx
+
+`;
+                for (const envFilePath of selectedEnvFiles) {
+                    const appInfo = appEnvFiles.find(e => e.fullPath === envFilePath);
+                    const content = fs_1.default.readFileSync(envFilePath, 'utf8');
+                    mergedContent += `\n# === ${appInfo?.appName || path_1.default.dirname(envFilePath)} ===\n`;
+                    mergedContent += content;
+                    mergedContent += '\n';
+                }
+                fs_1.default.writeFileSync(envPath, mergedContent);
+                console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} from ${selectedEnvFiles.length} app env files`));
+            }
+        }
+        else if (appEnvFiles.length > 0 && nonInteractive) {
+            // Non-interactive: merge all env files
+            let mergedContent = `# Genbox Environment Variables
+# Merged from app directories
+# DO NOT COMMIT THIS FILE
+
+`;
+            for (const envFile of appEnvFiles) {
+                const content = fs_1.default.readFileSync(envFile.fullPath, 'utf8');
+                mergedContent += `\n# === ${envFile.appName} ===\n`;
+                mergedContent += content;
+                mergedContent += '\n';
+            }
+            fs_1.default.writeFileSync(envPath, mergedContent);
+            console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} from ${appEnvFiles.length} app env files`));
         }
     }
-    if (existingEnvPath) {
-        // In non-interactive mode, default to copying existing env
-        const copyExisting = nonInteractive ? true : await prompts.confirm({
-            message: `Found ${path_1.default.basename(existingEnvPath)}. Copy to ${ENV_FILENAME}?`,
-            default: true,
-        });
-        if (copyExisting) {
-            const content = fs_1.default.readFileSync(existingEnvPath, 'utf8');
-            const header = `# Genbox Environment Variables
+    // If no env file created yet, check for root .env
+    if (!fs_1.default.existsSync(envPath)) {
+        const existingEnvFiles = ['.env.local', '.env', '.env.development'];
+        let existingEnvPath;
+        for (const envFile of existingEnvFiles) {
+            const fullPath = path_1.default.join(process.cwd(), envFile);
+            if (fs_1.default.existsSync(fullPath)) {
+                existingEnvPath = fullPath;
+                break;
+            }
+        }
+        if (existingEnvPath) {
+            const copyExisting = nonInteractive ? true : await prompts.confirm({
+                message: `Found ${path_1.default.basename(existingEnvPath)}. Copy to ${ENV_FILENAME}?`,
+                default: true,
+            });
+            if (copyExisting) {
+                const content = fs_1.default.readFileSync(existingEnvPath, 'utf8');
+                const header = `# Genbox Environment Variables
 # Generated from ${path_1.default.basename(existingEnvPath)}
 # DO NOT COMMIT THIS FILE
 #
@@ -568,20 +813,20 @@ async function setupEnvFile(projectName, config, nonInteractive = false) {
 # GIT_TOKEN=ghp_xxxxxxxxxxxx
 
 `;
-            fs_1.default.writeFileSync(envPath, header + content);
-            console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} from ${path_1.default.basename(existingEnvPath)}`));
+                fs_1.default.writeFileSync(envPath, header + content);
+                console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} from ${path_1.default.basename(existingEnvPath)}`));
+            }
         }
-    }
-    else {
-        // In non-interactive mode, default to creating template
-        const createEnv = nonInteractive ? true : await prompts.confirm({
-            message: `Create ${ENV_FILENAME} template?`,
-            default: true,
-        });
-        if (createEnv) {
-            const template = generateEnvTemplate(projectName, config);
-            fs_1.default.writeFileSync(envPath, template);
-            console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} template`));
+        else {
+            const createEnv = nonInteractive ? true : await prompts.confirm({
+                message: `Create ${ENV_FILENAME} template?`,
+                default: true,
+            });
+            if (createEnv) {
+                const template = generateEnvTemplate(projectName, config);
+                fs_1.default.writeFileSync(envPath, template);
+                console.log(chalk_1.default.green(`✔ Created ${ENV_FILENAME} template`));
+            }
         }
     }
     // Add to .gitignore

package/package.json

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