genbox 1.0.12 → 1.0.14

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();
+}