genbox 1.0.12 → 1.0.13

package/dist/commands/resolve.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Resolve Command
+ *
+ * Computes the final configuration by:
+ * 1. Loading genbox.yaml
+ * 2. Applying profile settings
+ * 3. Resolving $detect markers from detected.yaml
+ * 4. Computing environment variables
+ * 5. Outputting to .genbox/resolved.yaml
+ *
+ * This provides transparency into what will actually be created.
+ *
+ * Usage:
+ *   genbox resolve                  # Resolve with defaults
+ *   genbox resolve --profile quick  # Resolve with specific profile
+ *   genbox resolve --stdout         # Output to stdout
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const config_loader_1 = require("../config-loader");
+const profile_resolver_1 = require("../profile-resolver");
+const detected_config_1 = require("../detected-config");
+exports.resolveCommand = new commander_1.Command('resolve')
+    .description('Compute final configuration from genbox.yaml and detected values')
+    .option('-p, --profile <profile>', 'Profile to use')
+    .option('-a, --apps <apps>', 'Comma-separated apps to include')
+    .option('--stdout', 'Output to stdout instead of file')
+    .option('--json', 'Output as JSON')
+    .option('-y, --yes', 'Skip interactive prompts')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    console.log(chalk_1.default.cyan('\n🔄 Resolving configuration...\n'));
+    try {
+        // Load configuration
+        const configLoader = new config_loader_1.ConfigLoader();
+        const loadResult = await configLoader.load(cwd);
+        if (!loadResult.found || !loadResult.config) {
+            console.log(chalk_1.default.red('No genbox.yaml found. Run "genbox init" first.'));
+            process.exit(1);
+        }
+        let config = loadResult.config;
+        // Load detected config if available
+        const detectedPath = path.join(loadResult.root, '.genbox', 'detected.yaml');
+        let detectedConfig = null;
+        let appliedDetections = [];
+        if (fs.existsSync(detectedPath)) {
+            try {
+                const content = fs.readFileSync(detectedPath, 'utf8');
+                detectedConfig = yaml.load(content);
+                console.log(chalk_1.default.dim(`Loaded detected.yaml from ${detectedPath}`));
+                // Apply $detect markers
+                const result = (0, detected_config_1.applyDetectedValues)(config, detectedConfig);
+                config = result.config;
+                appliedDetections = result.applied;
+                if (appliedDetections.length > 0) {
+                    console.log(chalk_1.default.dim(`Applied ${appliedDetections.length} $detect markers`));
+                }
+            }
+            catch (err) {
+                console.log(chalk_1.default.yellow(`Warning: Could not parse detected.yaml: ${err}`));
+            }
+        }
+        // Show resolution steps
+        console.log(chalk_1.default.bold('Resolution steps:'));
+        console.log(`  1. ${chalk_1.default.green('✓')} Loaded genbox.yaml`);
+        if (options.profile) {
+            const profile = configLoader.getProfile(config, options.profile);
+            if (profile) {
+                console.log(`  2. ${chalk_1.default.green('✓')} Applied profile '${options.profile}'`);
+            }
+            else {
+                console.log(`  2. ${chalk_1.default.yellow('⚠')} Profile '${options.profile}' not found`);
+            }
+        }
+        if (appliedDetections.length > 0) {
+            console.log(`  3. ${chalk_1.default.green('✓')} Resolved $detect markers:`);
+            for (const path of appliedDetections.slice(0, 5)) {
+                console.log(chalk_1.default.dim(`       → ${path}`));
+            }
+            if (appliedDetections.length > 5) {
+                console.log(chalk_1.default.dim(`       ... and ${appliedDetections.length - 5} more`));
+            }
+        }
+        // Resolve using ProfileResolver
+        const profileResolver = new profile_resolver_1.ProfileResolver(configLoader);
+        const resolved = await profileResolver.resolve(config, {
+            name: 'resolved',
+            profile: options.profile,
+            apps: options.apps?.split(',').map(s => s.trim()),
+            yes: options.yes ?? true, // Default to non-interactive for resolve
+        });
+        // Add metadata
+        const resolvedWithMeta = {
+            _meta: {
+                resolved_at: new Date().toISOString(),
+                profile: options.profile || null,
+                detect_markers_applied: appliedDetections,
+            },
+            ...resolved,
+        };
+        // Output
+        if (options.stdout) {
+            const output = options.json
+                ? JSON.stringify(resolvedWithMeta, null, 2)
+                : yaml.dump(resolvedWithMeta, { lineWidth: 120, noRefs: true });
+            console.log('\n' + output);
+        }
+        else {
+            await writeResolvedConfig(resolvedWithMeta, loadResult.root, options.json);
+            showResolvedSummary(resolved, appliedDetections);
+        }
+        // Show warnings
+        if (resolved.warnings.length > 0) {
+            console.log(chalk_1.default.yellow('\n⚠️  Warnings:'));
+            for (const warning of resolved.warnings) {
+                console.log(chalk_1.default.yellow(`  • ${warning}`));
+            }
+        }
+        console.log(chalk_1.default.bold('\n📝 Next steps:\n'));
+        console.log('  1. Review the resolved configuration in .genbox/resolved.yaml');
+        console.log('  2. Run ' + chalk_1.default.cyan('genbox validate') + ' to check for errors');
+        console.log('  3. Run ' + chalk_1.default.cyan('genbox create <name>') + ' to provision');
+        console.log();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Resolution failed:'), error);
+        process.exit(1);
+    }
+});
+async function writeResolvedConfig(resolved, root, asJson) {
+    const genboxDir = path.join(root, '.genbox');
+    // Create .genbox directory if it doesn't exist
+    if (!fs.existsSync(genboxDir)) {
+        fs.mkdirSync(genboxDir, { recursive: true });
+    }
+    // Write resolved config
+    const filename = asJson ? 'resolved.json' : 'resolved.yaml';
+    const filePath = path.join(genboxDir, filename);
+    const content = asJson
+        ? JSON.stringify(resolved, null, 2)
+        : yaml.dump(resolved, { lineWidth: 120, noRefs: true });
+    fs.writeFileSync(filePath, content);
+    console.log(chalk_1.default.green(`\n✓ Resolved configuration written to: ${filePath}`));
+}
+function showResolvedSummary(resolved, appliedDetections) {
+    console.log(chalk_1.default.bold('\n📋 Resolved Configuration:\n'));
+    // Basic info
+    console.log(`  Name: ${chalk_1.default.cyan(resolved.name)}`);
+    console.log(`  Size: ${chalk_1.default.cyan(resolved.size)}`);
+    console.log(`  Project: ${resolved.project.name} (${resolved.project.structure})`);
+    // Apps
+    if (resolved.apps.length > 0) {
+        console.log(`\n  Apps (${resolved.apps.length}):`);
+        for (const app of resolved.apps) {
+            const deps = Object.entries(app.dependencies)
+                .map(([name, config]) => `${name}:${config.mode}`)
+                .join(', ');
+            console.log(`    ${chalk_1.default.cyan(app.name)}: ${app.type}${app.framework ? ` [${app.framework}]` : ''}`);
+            if (deps) {
+                console.log(chalk_1.default.dim(`      Dependencies: ${deps}`));
+            }
+        }
+    }
+    // Infrastructure
+    if (resolved.infrastructure.length > 0) {
+        console.log(`\n  Infrastructure (${resolved.infrastructure.length}):`);
+        for (const infra of resolved.infrastructure) {
+            console.log(`    ${chalk_1.default.cyan(infra.name)}: ${infra.type} (${infra.mode})`);
+        }
+    }
+    // Database
+    console.log(`\n  Database: ${chalk_1.default.cyan(resolved.database.mode)}`);
+    if (resolved.database.source) {
+        console.log(chalk_1.default.dim(`    Source: ${resolved.database.source}`));
+    }
+    // Repos
+    if (resolved.repos.length > 0) {
+        console.log(`\n  Repositories (${resolved.repos.length}):`);
+        for (const repo of resolved.repos) {
+            console.log(`    ${chalk_1.default.cyan(repo.name)}: ${repo.url}`);
+        }
+    }
+    // Environment variables
+    const envCount = Object.keys(resolved.env).length;
+    if (envCount > 0) {
+        console.log(`\n  Environment variables: ${envCount}`);
+        for (const [key, value] of Object.entries(resolved.env).slice(0, 5)) {
+            const displayValue = key.includes('SECRET') || key.includes('PASSWORD')
+                ? '***'
+                : value.length > 50 ? value.slice(0, 47) + '...' : value;
+            console.log(chalk_1.default.dim(`    ${key}=${displayValue}`));
+        }
+        if (envCount > 5) {
+            console.log(chalk_1.default.dim(`    ... and ${envCount - 5} more`));
+        }
+    }
+    // Detection info
+    if (appliedDetections.length > 0) {
+        console.log(chalk_1.default.yellow(`\n  ⚡ ${appliedDetections.length} values from $detect markers`));
+    }
+}

package/dist/commands/scan.js

@@ -0,0 +1,354 @@
+"use strict";
+/**
+ * Scan Command
+ *
+ * Analyzes the project structure and outputs detected configuration
+ * to .genbox/detected.yaml (or stdout with --stdout flag)
+ *
+ * This separates detection from configuration - users can review
+ * what was detected before using it.
+ *
+ * Usage:
+ *   genbox scan              # Output to .genbox/detected.yaml
+ *   genbox scan --stdout     # Output to stdout
+ *   genbox scan --json       # Output as JSON
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const scanner_1 = require("../scanner");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { version } = require('../../package.json');
+exports.scanCommand = new commander_1.Command('scan')
+    .description('Analyze project structure and output detected configuration')
+    .option('--stdout', 'Output to stdout instead of .genbox/detected.yaml')
+    .option('--json', 'Output as JSON instead of YAML')
+    .option('--no-infra', 'Skip infrastructure detection (docker-compose)')
+    .option('--no-scripts', 'Skip script detection')
+    .option('-e, --exclude <patterns>', 'Comma-separated patterns to exclude', '')
+    .action(async (options) => {
+    const cwd = process.cwd();
+    console.log(chalk_1.default.cyan('\n🔍 Scanning project...\n'));
+    try {
+        // Run the scanner
+        const scanner = new scanner_1.ProjectScanner();
+        const exclude = options.exclude ? options.exclude.split(',').map(s => s.trim()) : [];
+        const scan = await scanner.scan(cwd, {
+            exclude,
+            skipScripts: !options.scripts,
+        });
+        // Convert scan result to DetectedConfig format
+        const detected = convertScanToDetected(scan, cwd);
+        // Output
+        if (options.stdout) {
+            outputToStdout(detected, options.json);
+        }
+        else {
+            await outputToFile(detected, cwd, options.json);
+            showSummary(detected);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('Scan failed:'), error);
+        process.exit(1);
+    }
+});
+/**
+ * Convert ProjectScan to DetectedConfig
+ */
+function convertScanToDetected(scan, root) {
+    const detected = {
+        _meta: {
+            generated_at: new Date().toISOString(),
+            genbox_version: version,
+            scanned_root: root,
+        },
+        structure: {
+            type: mapStructureType(scan.structure.type),
+            confidence: scan.structure.confidence || 'medium',
+            indicators: scan.structure.indicators || [],
+        },
+        runtimes: scan.runtimes.map(r => ({
+            language: r.language,
+            version: r.version,
+            version_source: r.versionSource,
+            package_manager: r.packageManager,
+            lockfile: r.lockfile,
+        })),
+        apps: {},
+    };
+    // Convert apps
+    for (const app of scan.apps) {
+        // Map scanner AppType to DetectedApp type
+        const mappedType = mapAppType(app.type);
+        detected.apps[app.name] = {
+            path: app.path,
+            type: mappedType,
+            type_reason: inferTypeReason(app),
+            port: app.port,
+            port_source: app.port ? inferPortSource(app) : undefined,
+            framework: app.framework, // Framework is a string type
+            framework_source: app.framework ? inferFrameworkSource(app) : undefined,
+            commands: app.scripts ? {
+                dev: app.scripts.dev,
+                build: app.scripts.build,
+                start: app.scripts.start,
+            } : undefined,
+            dependencies: app.dependencies,
+        };
+    }
+    // Convert infrastructure
+    if (scan.compose) {
+        detected.infrastructure = [];
+        for (const db of scan.compose.databases || []) {
+            detected.infrastructure.push({
+                name: db.name,
+                type: 'database',
+                image: db.image || 'unknown',
+                port: db.ports?.[0]?.host || 0,
+                source: 'docker-compose.yml',
+            });
+        }
+        for (const cache of scan.compose.caches || []) {
+            detected.infrastructure.push({
+                name: cache.name,
+                type: 'cache',
+                image: cache.image || 'unknown',
+                port: cache.ports?.[0]?.host || 0,
+                source: 'docker-compose.yml',
+            });
+        }
+        for (const queue of scan.compose.queues || []) {
+            detected.infrastructure.push({
+                name: queue.name,
+                type: 'queue',
+                image: queue.image || 'unknown',
+                port: queue.ports?.[0]?.host || 0,
+                source: 'docker-compose.yml',
+            });
+        }
+    }
+    // Git info
+    if (scan.git) {
+        detected.git = {
+            remote: scan.git.remote,
+            type: scan.git.type,
+            provider: scan.git.provider,
+            branch: scan.git.branch,
+        };
+    }
+    // Scripts
+    if (scan.scripts && scan.scripts.length > 0) {
+        detected.scripts = scan.scripts.map(s => ({
+            name: s.name,
+            path: s.path,
+            stage: s.stage,
+            stage_reason: inferStageReason(s),
+            executable: s.isExecutable,
+        }));
+    }
+    return detected;
+}
+function mapStructureType(type) {
+    if (type.startsWith('monorepo'))
+        return 'monorepo';
+    if (type === 'hybrid')
+        return 'workspace';
+    if (type === 'microservices')
+        return 'microservices';
+    return 'single-app';
+}
+function mapAppType(type) {
+    // Map scanner's AppType to DetectedApp type
+    switch (type) {
+        case 'frontend':
+            return 'frontend';
+        case 'backend':
+        case 'api': // Scanner has 'api', map to 'backend'
+            return 'backend';
+        case 'worker':
+            return 'worker';
+        case 'gateway':
+            return 'gateway';
+        case 'library':
+            return 'library';
+        default:
+            return undefined; // Unknown type
+    }
+}
+function inferTypeReason(app) {
+    if (!app.type)
+        return 'unknown';
+    const name = (app.name || app.path || '').toLowerCase();
+    if (name.includes('web') || name.includes('frontend') || name.includes('ui') || name.includes('client')) {
+        return `naming convention ('${app.name}' contains frontend keyword)`;
+    }
+    if (name.includes('api') || name.includes('backend') || name.includes('server') || name.includes('gateway')) {
+        return `naming convention ('${app.name}' contains backend keyword)`;
+    }
+    if (name.includes('worker') || name.includes('queue') || name.includes('job')) {
+        return `naming convention ('${app.name}' contains worker keyword)`;
+    }
+    return 'dependency analysis';
+}
+function inferPortSource(app) {
+    if (app.scripts?.dev?.includes('--port')) {
+        return 'package.json scripts.dev (--port flag)';
+    }
+    if (app.scripts?.dev?.includes('PORT=')) {
+        return 'package.json scripts.dev (PORT= env)';
+    }
+    if (app.scripts?.start?.includes('--port')) {
+        return 'package.json scripts.start (--port flag)';
+    }
+    return 'framework default';
+}
+function inferFrameworkSource(app) {
+    const framework = app.framework;
+    if (!framework)
+        return 'unknown';
+    // Config file based detection
+    const configFrameworks = ['nextjs', 'nuxt', 'nestjs', 'astro', 'gatsby'];
+    if (configFrameworks.includes(framework)) {
+        return `config file (${framework}.config.* or similar)`;
+    }
+    return 'package.json dependencies';
+}
+function inferStageReason(script) {
+    const name = script.name.toLowerCase();
+    if (name.includes('setup') || name.includes('init') || name.includes('install')) {
+        return `filename contains '${name.match(/setup|init|install/)?.[0]}'`;
+    }
+    if (name.includes('build') || name.includes('compile')) {
+        return `filename contains '${name.match(/build|compile/)?.[0]}'`;
+    }
+    if (name.includes('start') || name.includes('run') || name.includes('serve')) {
+        return `filename contains '${name.match(/start|run|serve/)?.[0]}'`;
+    }
+    if (name.includes('deploy') || name.includes('release')) {
+        return `filename contains '${name.match(/deploy|release/)?.[0]}'`;
+    }
+    return 'default assignment';
+}
+function outputToStdout(detected, asJson) {
+    if (asJson) {
+        console.log(JSON.stringify(detected, null, 2));
+    }
+    else {
+        console.log(yaml.dump(detected, { lineWidth: 120, noRefs: true }));
+    }
+}
+async function outputToFile(detected, root, asJson) {
+    const genboxDir = path.join(root, '.genbox');
+    // Create .genbox directory if it doesn't exist
+    if (!fs.existsSync(genboxDir)) {
+        fs.mkdirSync(genboxDir, { recursive: true });
+    }
+    // Add .genbox to .gitignore if not already there
+    const gitignorePath = path.join(root, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+        const gitignore = fs.readFileSync(gitignorePath, 'utf8');
+        if (!gitignore.includes('.genbox')) {
+            fs.appendFileSync(gitignorePath, '\n# Genbox generated files\n.genbox/\n');
+            console.log(chalk_1.default.dim('Added .genbox/ to .gitignore'));
+        }
+    }
+    // Write detected config
+    const filename = asJson ? 'detected.json' : 'detected.yaml';
+    const filePath = path.join(genboxDir, filename);
+    const content = asJson
+        ? JSON.stringify(detected, null, 2)
+        : yaml.dump(detected, { lineWidth: 120, noRefs: true });
+    fs.writeFileSync(filePath, content);
+    console.log(chalk_1.default.green(`\n✓ Detected configuration written to: ${filePath}`));
+}
+function showSummary(detected) {
+    console.log(chalk_1.default.bold('\n📊 Detection Summary:\n'));
+    // Structure
+    console.log(`  Structure: ${chalk_1.default.cyan(detected.structure.type)} (${detected.structure.confidence} confidence)`);
+    if (detected.structure.indicators.length > 0) {
+        console.log(chalk_1.default.dim(`    Indicators: ${detected.structure.indicators.join(', ')}`));
+    }
+    // Runtimes
+    if (detected.runtimes.length > 0) {
+        console.log(`\n  Runtimes:`);
+        for (const runtime of detected.runtimes) {
+            console.log(`    ${chalk_1.default.cyan(runtime.language)}${runtime.version ? ` ${runtime.version}` : ''}`);
+            if (runtime.package_manager) {
+                console.log(chalk_1.default.dim(`      Package manager: ${runtime.package_manager}`));
+            }
+        }
+    }
+    // Apps
+    const appNames = Object.keys(detected.apps);
+    if (appNames.length > 0) {
+        console.log(`\n  Apps (${appNames.length}):`);
+        for (const name of appNames) {
+            const app = detected.apps[name];
+            const parts = [
+                chalk_1.default.cyan(name),
+                app.type ? `(${app.type})` : '',
+                app.framework ? `[${app.framework}]` : '',
+                app.port ? `port:${app.port}` : '',
+            ].filter(Boolean);
+            console.log(`    ${parts.join(' ')}`);
+        }
+    }
+    // Infrastructure
+    if (detected.infrastructure && detected.infrastructure.length > 0) {
+        console.log(`\n  Infrastructure (${detected.infrastructure.length}):`);
+        for (const infra of detected.infrastructure) {
+            console.log(`    ${chalk_1.default.cyan(infra.name)}: ${infra.type} (${infra.image})`);
+        }
+    }
+    // Git
+    if (detected.git?.remote) {
+        console.log(`\n  Git: ${detected.git.provider || 'git'} (${detected.git.type})`);
+        console.log(chalk_1.default.dim(`    Branch: ${detected.git.branch || 'unknown'}`));
+    }
+    console.log(chalk_1.default.bold('\n📝 Next steps:\n'));
+    console.log('  1. Review the detected configuration in .genbox/detected.yaml');
+    console.log('  2. Run ' + chalk_1.default.cyan('genbox init --from-scan') + ' to create genbox.yaml');
+    console.log('  3. Or manually create genbox.yaml using detected values');
+    console.log();
+}