genbox 1.0.2 → 1.0.4

package/dist/scanner/config-generator.js

@@ -0,0 +1,620 @@
+"use strict";
+/**
+ * Configuration Generator
+ *
+ * Generates genbox.yaml configuration from scan results
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigGenerator = void 0;
+class ConfigGenerator {
+    /**
+     * Generate configuration from scan results
+     */
+    generate(scan) {
+        const config = {
+            version: '2.0',
+            project: {
+                name: scan.projectName,
+                structure: scan.structure.type,
+            },
+            services: this.generateServices(scan),
+            system: {
+                size: this.inferServerSize(scan),
+                runtimes: scan.runtimes.map(r => ({
+                    language: r.language,
+                    version: r.version || 'latest',
+                    packageManager: r.packageManager,
+                })),
+            },
+            repos: this.generateRepos(scan),
+        };
+        // Add workspace config for monorepos
+        if (scan.structure.type.startsWith('monorepo')) {
+            config.workspace = this.generateWorkspaceConfig(scan);
+        }
+        // Add infrastructure from docker-compose
+        if (scan.compose) {
+            config.infrastructure = this.generateInfrastructure(scan);
+        }
+        // Generate hooks
+        config.hooks = this.generateHooks(scan);
+        // Generate scripts
+        if (scan.scripts.length > 0) {
+            config.scripts = this.generateScripts(scan);
+        }
+        // Generate networking config
+        config.networking = this.generateNetworking(scan, config.services);
+        const warnings = this.collectWarnings(scan);
+        return {
+            config,
+            envTemplate: this.generateEnvTemplate(scan),
+            warnings,
+            scripts: this.generateSetupScripts(scan, config),
+        };
+    }
+    generateServices(scan) {
+        const services = {};
+        // For hybrid structure, prioritize discovered apps over docker-compose
+        if (scan.structure.type === 'hybrid' && scan.apps.length > 0) {
+            for (const app of scan.apps) {
+                if (app.type === 'library')
+                    continue;
+                const framework = scan.frameworks.find(f => f.name === app.framework);
+                const port = app.port || framework?.defaultPort || this.getDefaultPort(app.type, app.framework);
+                const serviceConfig = {
+                    type: app.type,
+                    framework: app.framework,
+                    path: app.path,
+                    port,
+                    start: {
+                        command: framework?.startCommand || 'npm run dev',
+                        dev: framework?.devCommand || 'npm run dev',
+                    },
+                };
+                if (framework?.buildCommand) {
+                    serviceConfig.build = {
+                        command: framework.buildCommand,
+                        output: framework?.outputDir,
+                    };
+                }
+                services[app.name] = serviceConfig;
+            }
+        }
+        // From docker-compose applications (microservices structure)
+        else if (scan.compose && scan.structure.type === 'microservices') {
+            for (const app of scan.compose.applications) {
+                const serviceName = this.normalizeServiceName(app.name);
+                const port = app.ports[0]?.host || 3000;
+                // Try to find matching framework
+                const framework = scan.frameworks.find(f => app.build?.context && app.build.context.includes(f.name));
+                services[serviceName] = {
+                    type: this.inferServiceType(app.name),
+                    framework: framework?.name,
+                    port,
+                    healthcheck: app.healthcheck?.test ? this.extractHealthPath(app.healthcheck.test) : undefined,
+                    dependsOn: app.dependsOn.map(d => this.normalizeServiceName(d)),
+                    env: Object.keys(app.environment).filter(k => !k.startsWith('_')),
+                };
+            }
+        }
+        // From discovered apps (monorepo)
+        else if (scan.apps.length > 0) {
+            for (const app of scan.apps) {
+                if (app.type === 'library')
+                    continue;
+                const framework = scan.frameworks.find(f => f.name === app.framework);
+                const port = app.port || framework?.defaultPort || 3000;
+                const serviceConfig = {
+                    type: app.type,
+                    framework: app.framework,
+                    path: app.path !== scan.root ? app.path : undefined,
+                    port,
+                    start: {
+                        command: framework?.startCommand || 'npm start',
+                        dev: framework?.devCommand,
+                    },
+                };
+                if (framework?.buildCommand) {
+                    serviceConfig.build = {
+                        command: this.wrapForMonorepo(framework.buildCommand, app.name, scan),
+                        output: framework?.outputDir,
+                    };
+                }
+                services[app.name] = serviceConfig;
+            }
+        }
+        // Single app fallback
+        if (Object.keys(services).length === 0 && scan.frameworks.length > 0) {
+            const framework = scan.frameworks[0];
+            const serviceConfig = {
+                type: framework.type === 'fullstack' ? 'frontend' : framework.type,
+                framework: framework.name,
+                port: framework.defaultPort || 3000,
+                start: {
+                    command: framework.startCommand || 'npm start',
+                    dev: framework.devCommand,
+                },
+            };
+            if (framework.buildCommand) {
+                serviceConfig.build = {
+                    command: framework.buildCommand,
+                    output: framework.outputDir,
+                };
+            }
+            services[scan.projectName] = serviceConfig;
+        }
+        return services;
+    }
+    getDefaultPort(type, framework) {
+        // Framework-specific defaults
+        if (framework === 'nextjs')
+            return 3000;
+        if (framework === 'react' || framework === 'react-admin')
+            return 5173;
+        if (framework === 'nestjs')
+            return 3050;
+        if (framework === 'express')
+            return 3000;
+        // Type-based defaults
+        if (type === 'frontend')
+            return 3000;
+        if (type === 'backend' || type === 'api')
+            return 3050;
+        return 3000;
+    }
+    generateWorkspaceConfig(scan) {
+        const typeMap = {
+            'monorepo-npm': 'npm',
+            'monorepo-pnpm': 'pnpm',
+            'monorepo-yarn': 'yarn',
+            'monorepo-nx': 'nx',
+            'monorepo-turborepo': 'turborepo',
+            'monorepo-lerna': 'lerna',
+        };
+        return {
+            type: typeMap[scan.structure.type] || 'npm',
+            root: `/home/dev/${scan.projectName}`,
+            apps: scan.apps
+                .filter(a => a.type !== 'library')
+                .map(a => ({
+                name: a.name,
+                path: a.path,
+                framework: a.framework,
+            })),
+        };
+    }
+    generateInfrastructure(scan) {
+        if (!scan.compose)
+            return undefined;
+        const infrastructure = {};
+        // Databases
+        if (scan.compose.databases.length > 0) {
+            infrastructure.databases = scan.compose.databases.map(db => {
+                const type = this.inferDatabaseType(db.image || db.name);
+                return {
+                    type,
+                    container: db.name,
+                    name: scan.projectName,
+                    port: db.ports[0]?.container || this.getDefaultDatabasePort(type),
+                };
+            });
+        }
+        // Caches
+        if (scan.compose.caches.length > 0) {
+            infrastructure.caches = scan.compose.caches.map(cache => ({
+                type: this.inferCacheType(cache.image || cache.name),
+                container: cache.name,
+                port: cache.ports[0]?.container || 6379,
+            }));
+        }
+        // Queues
+        if (scan.compose.queues.length > 0) {
+            infrastructure.queues = scan.compose.queues.map(queue => {
+                const type = this.inferQueueType(queue.image || queue.name);
+                return {
+                    type,
+                    container: queue.name,
+                    port: queue.ports[0]?.container || this.getDefaultQueuePort(type),
+                    managementPort: this.getManagementPort(type, queue),
+                };
+            });
+        }
+        return Object.keys(infrastructure).length > 0 ? infrastructure : undefined;
+    }
+    generateRepos(scan) {
+        if (!scan.git)
+            return {};
+        // Extract repo name from URL
+        let repoName = scan.projectName;
+        const match = scan.git.remote.match(/[:/]([^/]+\/)?([^/.]+)(\.git)?$/);
+        if (match) {
+            repoName = match[2];
+        }
+        return {
+            [repoName]: {
+                url: scan.git.remote,
+                path: `/home/dev/${repoName}`,
+                branch: scan.git.branch !== 'main' && scan.git.branch !== 'master'
+                    ? scan.git.branch
+                    : undefined,
+                auth: scan.git.type === 'https' ? 'token' : 'ssh',
+            },
+        };
+    }
+    generateHooks(scan) {
+        const hooks = {
+            postCheckout: [],
+            postStart: [],
+        };
+        // Install dependencies based on package managers
+        for (const runtime of scan.runtimes) {
+            const installCmd = this.getInstallCommand(runtime.language, runtime.packageManager);
+            if (installCmd) {
+                hooks.postCheckout.push({
+                    command: installCmd,
+                    workdir: `/home/dev/${scan.projectName}`,
+                });
+            }
+        }
+        // Add docker compose up if docker is present
+        if (scan.compose) {
+            hooks.postStart.push({
+                command: 'docker compose up -d',
+                workdir: `/home/dev/${scan.projectName}`,
+            });
+        }
+        // Clean up empty arrays
+        if (hooks.postCheckout.length === 0)
+            delete hooks.postCheckout;
+        if (hooks.postStart.length === 0)
+            delete hooks.postStart;
+        return Object.keys(hooks).length > 0 ? hooks : {};
+    }
+    generateScripts(scan) {
+        return scan.scripts.map(script => ({
+            name: script.name,
+            path: script.path,
+            stage: script.stage,
+        }));
+    }
+    generateNetworking(scan, services) {
+        const expose = [];
+        // Expose all application services
+        for (const [name, config] of Object.entries(services)) {
+            // Frontend services get root subdomain
+            if (config.type === 'frontend') {
+                expose.push({
+                    service: name,
+                    port: config.port,
+                    subdomain: '',
+                });
+            }
+            else if (config.type === 'gateway') {
+                expose.push({
+                    service: name,
+                    port: config.port,
+                    subdomain: 'api',
+                });
+            }
+            else if (config.type === 'backend' || config.type === 'api') {
+                expose.push({
+                    service: name,
+                    port: config.port,
+                    subdomain: name.replace(/-?(api|service|backend)$/i, '') || 'api',
+                });
+            }
+        }
+        // Sort: frontends first, then by name
+        expose.sort((a, b) => {
+            if (a.subdomain === '' && b.subdomain !== '')
+                return -1;
+            if (a.subdomain !== '' && b.subdomain === '')
+                return 1;
+            return a.service.localeCompare(b.service);
+        });
+        return expose.length > 0 ? { expose } : undefined;
+    }
+    generateEnvTemplate(scan) {
+        const sections = [];
+        const warnings = [];
+        // Group variables by service
+        const serviceGroups = new Map();
+        for (const variable of [...scan.envAnalysis.required, ...scan.envAnalysis.optional]) {
+            if (variable.usedBy.length === 0 || variable.usedBy.length > 1) {
+                const global = serviceGroups.get('_global') || [];
+                global.push(variable);
+                serviceGroups.set('_global', global);
+            }
+            else {
+                const service = variable.usedBy[0];
+                const group = serviceGroups.get(service) || [];
+                group.push(variable);
+                serviceGroups.set(service, group);
+            }
+        }
+        // Global section
+        const globalVars = serviceGroups.get('_global') || [];
+        if (globalVars.length > 0) {
+            sections.push({
+                name: 'GLOBAL',
+                description: 'Shared configuration',
+                variables: globalVars.map(v => ({
+                    name: v.name,
+                    value: v.value || this.generateDefaultValue(v),
+                    comment: v.description,
+                    required: this.isRequired(v),
+                    sensitive: false,
+                })),
+            });
+        }
+        // Service sections
+        for (const [service, vars] of serviceGroups) {
+            if (service === '_global')
+                continue;
+            sections.push({
+                name: service.toUpperCase(),
+                description: `Configuration for ${service}`,
+                variables: vars.map(v => ({
+                    name: v.name,
+                    value: v.value || this.generateDefaultValue(v),
+                    comment: v.description,
+                    required: this.isRequired(v),
+                    sensitive: false,
+                })),
+            });
+        }
+        // Secrets section
+        if (scan.envAnalysis.secrets.length > 0) {
+            sections.push({
+                name: 'SECRETS',
+                description: 'Sensitive values - DO NOT COMMIT',
+                variables: scan.envAnalysis.secrets.map(v => ({
+                    name: v.name,
+                    value: v.value || 'your-secret-here',
+                    comment: 'SENSITIVE - Replace with actual value',
+                    required: true,
+                    sensitive: true,
+                })),
+            });
+            warnings.push('Secrets detected - ensure .env.genbox is in .gitignore');
+        }
+        return { sections, warnings };
+    }
+    generateSetupScripts(scan, config) {
+        const scripts = [];
+        // Generate setup script
+        const setupContent = this.generateSetupScript(scan, config);
+        scripts.push({
+            path: 'scripts/setup-genbox.sh',
+            content: setupContent,
+        });
+        return scripts;
+    }
+    generateSetupScript(scan, config) {
+        const lines = [
+            '#!/bin/bash',
+            '# Generated by genbox init',
+            'set -e',
+            '',
+            `cd /home/dev/${scan.projectName} || exit 1`,
+            '',
+            'echo "Setting up development environment..."',
+            '',
+        ];
+        // Install dependencies
+        for (const runtime of scan.runtimes) {
+            const installCmd = this.getInstallCommand(runtime.language, runtime.packageManager);
+            if (installCmd) {
+                lines.push(`echo "Installing ${runtime.language} dependencies..."`);
+                lines.push(installCmd);
+                lines.push('');
+            }
+        }
+        // Start docker services
+        if (scan.compose) {
+            lines.push('echo "Starting Docker services..."');
+            // Check for different compose file variants
+            lines.push('if [ -f "docker-compose.secure.yml" ]; then');
+            lines.push('  docker compose -f docker-compose.secure.yml up -d');
+            lines.push('elif [ -f "docker-compose.yml" ]; then');
+            lines.push('  docker compose up -d');
+            lines.push('elif [ -f "compose.yml" ]; then');
+            lines.push('  docker compose up -d');
+            lines.push('fi');
+            lines.push('');
+        }
+        lines.push('echo "Setup complete!"');
+        return lines.join('\n');
+    }
+    inferServerSize(scan) {
+        // Count total services
+        let serviceCount = scan.apps.filter(a => a.type !== 'library').length;
+        if (scan.compose) {
+            serviceCount += scan.compose.applications.length;
+            serviceCount += scan.compose.databases.length;
+            serviceCount += scan.compose.caches.length;
+            serviceCount += scan.compose.queues.length;
+        }
+        // Check for heavy services
+        const hasHeavyService = scan.compose?.infrastructure.some(s => /elasticsearch|kafka|spark|hadoop/i.test(s.image || ''));
+        if (hasHeavyService || serviceCount > 10)
+            return 'xl';
+        if (serviceCount > 5)
+            return 'large';
+        if (serviceCount > 2)
+            return 'medium';
+        return 'small';
+    }
+    normalizeServiceName(name) {
+        return name
+            .replace(/[-_]service$/i, '')
+            .replace(/[-_]app$/i, '')
+            .toLowerCase()
+            .replace(/[^a-z0-9-]/g, '-');
+    }
+    inferServiceType(name) {
+        const lowerName = name.toLowerCase();
+        if (/gateway|proxy|ingress/.test(lowerName))
+            return 'gateway';
+        if (/frontend|web|ui|client/.test(lowerName))
+            return 'frontend';
+        if (/worker|queue|consumer|job/.test(lowerName))
+            return 'worker';
+        if (/api/.test(lowerName))
+            return 'api';
+        return 'backend';
+    }
+    extractHealthPath(healthcheck) {
+        // Extract path from curl commands like "curl -f http://localhost:3000/health"
+        const match = healthcheck.match(/https?:\/\/[^/]+(\S+)/);
+        return match ? match[1] : undefined;
+    }
+    wrapForMonorepo(command, appName, scan) {
+        const pm = scan.runtimes[0]?.packageManager;
+        switch (pm) {
+            case 'pnpm':
+                return `pnpm --filter ${appName} run ${command.split(' ')[0]}`;
+            case 'yarn':
+                return `yarn workspace ${appName} ${command}`;
+            case 'npm':
+                return `npm run ${command} --workspace=${appName}`;
+            default:
+                return command;
+        }
+    }
+    getInstallCommand(language, packageManager) {
+        const commands = {
+            node: {
+                pnpm: 'pnpm install --frozen-lockfile',
+                yarn: 'yarn install --frozen-lockfile',
+                npm: 'npm ci',
+                bun: 'bun install --frozen-lockfile',
+            },
+            python: {
+                poetry: 'poetry install',
+                pipenv: 'pipenv install',
+                pip: 'pip install -r requirements.txt',
+                uv: 'uv sync',
+            },
+            go: {
+                go: 'go mod download',
+            },
+            ruby: {
+                bundler: 'bundle install',
+            },
+            rust: {
+                cargo: 'cargo fetch',
+            },
+        };
+        const langCommands = commands[language];
+        if (!langCommands)
+            return null;
+        return langCommands[packageManager || Object.keys(langCommands)[0]] || null;
+    }
+    inferDatabaseType(imageOrName) {
+        const lower = imageOrName.toLowerCase();
+        if (/mongo/i.test(lower))
+            return 'mongodb';
+        if (/postgres/i.test(lower))
+            return 'postgres';
+        if (/mysql|mariadb/i.test(lower))
+            return 'mysql';
+        return 'redis';
+    }
+    inferCacheType(imageOrName) {
+        if (/memcache/i.test(imageOrName))
+            return 'memcached';
+        return 'redis';
+    }
+    inferQueueType(imageOrName) {
+        const lower = imageOrName.toLowerCase();
+        if (/kafka/i.test(lower))
+            return 'kafka';
+        if (/redis/i.test(lower))
+            return 'redis';
+        return 'rabbitmq';
+    }
+    getDefaultDatabasePort(type) {
+        const ports = {
+            mongodb: 27017,
+            postgres: 5432,
+            mysql: 3306,
+            redis: 6379,
+        };
+        return ports[type] || 3000;
+    }
+    getDefaultQueuePort(type) {
+        const ports = {
+            rabbitmq: 5672,
+            kafka: 9092,
+            redis: 6379,
+        };
+        return ports[type] || 5672;
+    }
+    getManagementPort(type, service) {
+        if (type === 'rabbitmq') {
+            // Look for management port (15672)
+            const mgmtPort = service.ports.find(p => p.container === 15672);
+            return mgmtPort?.host || 15672;
+        }
+        return undefined;
+    }
+    generateDefaultValue(variable) {
+        if (variable.name.includes('MONGO'))
+            return 'mongodb://localhost:27017/myapp';
+        if (variable.name.includes('POSTGRES'))
+            return 'postgresql://localhost:5432/myapp';
+        if (variable.name.includes('REDIS'))
+            return 'redis://localhost:6379';
+        if (variable.name.includes('RABBIT'))
+            return 'amqp://localhost:5672';
+        if (variable.name.includes('PORT'))
+            return '3000';
+        if (variable.type === 'boolean')
+            return 'false';
+        if (variable.type === 'number')
+            return '0';
+        return '';
+    }
+    isRequired(variable) {
+        const requiredPatterns = [
+            /^DATABASE/i,
+            /^MONGO/i,
+            /^POSTGRES/i,
+            /^REDIS/i,
+            /^JWT_SECRET$/i,
+            /^NODE_ENV$/i,
+        ];
+        return requiredPatterns.some(p => p.test(variable.name));
+    }
+    collectWarnings(scan) {
+        const warnings = [];
+        // Check for missing versions
+        for (const runtime of scan.runtimes) {
+            if (!runtime.version) {
+                warnings.push(`No version detected for ${runtime.language} - using 'latest'`);
+            }
+        }
+        // Check for port conflicts
+        if (scan.compose) {
+            const portUsage = new Map();
+            for (const [port, service] of scan.compose.portMap) {
+                const existing = portUsage.get(port) || [];
+                existing.push(service);
+                portUsage.set(port, existing);
+            }
+            for (const [port, services] of portUsage) {
+                if (services.length > 1) {
+                    warnings.push(`Port ${port} used by multiple services: ${services.join(', ')}`);
+                }
+            }
+        }
+        // Check for missing env variables
+        const missingSecrets = scan.envAnalysis.secrets.filter(s => !s.value);
+        if (missingSecrets.length > 0) {
+            warnings.push(`${missingSecrets.length} secret(s) need values: ${missingSecrets.map(s => s.name).join(', ')}`);
+        }
+        return warnings;
+    }
+}
+exports.ConfigGenerator = ConfigGenerator;