genbox 1.0.47 → 1.0.48

package/dist/strict-mode.js

@@ -7,22 +7,16 @@
  * - All ports must be explicit or use $detect markers
  * - All connections must be declared in connects_to
  * - No implicit defaults are applied
- *
- * This ensures reproducible, predictable behavior across
- * different environments and team members.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_STRICT_CONFIG = void 0;
 exports.validateStrictMode = validateStrictMode;
 exports.getStrictModeSettings = getStrictModeSettings;
 exports.isStrictModeEnabled = isStrictModeEnabled;
 exports.formatStrictViolations = formatStrictViolations;
-exports.generateStrictFixes = generateStrictFixes;
-const schema_v3_1 = require("./schema-v3");
-// ============================================
-// Default Strict Mode Settings
-// ============================================
-exports.DEFAULT_STRICT_CONFIG = {
+exports.enforceStrictMode = enforceStrictMode;
+const schema_v4_1 = require("./schema-v4");
+// Default strict mode settings
+const DEFAULT_STRICT_CONFIG = {
     enabled: true,
     allow_detect: true,
     warnings_as_errors: false,
@@ -34,7 +28,7 @@ exports.DEFAULT_STRICT_CONFIG = {
  * Validate a configuration against strict mode rules
  */
 function validateStrictMode(config, strictConfig = {}) {
-    const settings = { ...exports.DEFAULT_STRICT_CONFIG, ...strictConfig };
+    const settings = { ...DEFAULT_STRICT_CONFIG, ...strictConfig };
     const violations = [];
     let explicitValues = 0;
     let detectMarkers = 0;
@@ -53,7 +47,7 @@ function validateStrictMode(config, strictConfig = {}) {
             });
             inferredValues++;
         }
-        else if ((0, schema_v3_1.isDetectMarker)(appConfig.type)) {
+        else if ((0, schema_v4_1.isDetectMarker)(appConfig.type)) {
             if (!settings.allow_detect) {
                 violations.push({
                     path: `${appPath}.type`,
@@ -67,7 +61,7 @@ function validateStrictMode(config, strictConfig = {}) {
         }
         else {
             explicitValues++;
-            // Check for naming-based inference (when type matches name pattern)
+            // Check for naming-based inference
             if (isTypeInferredFromName(appName, appConfig.type)) {
                 violations.push({
                     path: `${appPath}.type`,
@@ -90,7 +84,7 @@ function validateStrictMode(config, strictConfig = {}) {
                 });
                 inferredValues++;
             }
-            else if ((0, schema_v3_1.isDetectMarker)(appConfig.port)) {
+            else if ((0, schema_v4_1.isDetectMarker)(appConfig.port)) {
                 if (!settings.allow_detect) {
                     violations.push({
                         path: `${appPath}.port`,
@@ -106,10 +100,9 @@ function validateStrictMode(config, strictConfig = {}) {
                 explicitValues++;
             }
         }
-        // Check connections (v4 style)
-        const v4App = appConfig;
-        if (v4App.connects_to) {
-            for (const [connName, connConfig] of Object.entries(v4App.connects_to)) {
+        // Check connections
+        if (appConfig.connects_to) {
+            for (const [connName, connConfig] of Object.entries(appConfig.connects_to)) {
                 if (!connConfig || typeof connConfig !== 'object') {
                     violations.push({
                         path: `${appPath}.connects_to.${connName}`,
@@ -122,24 +115,10 @@ function validateStrictMode(config, strictConfig = {}) {
                 explicitValues++;
             }
         }
-        // Check for legacy requires (v3 style)
-        const v3App = appConfig;
-        if (v3App.requires) {
-            for (const [depName, requirement] of Object.entries(v3App.requires)) {
-                violations.push({
-                    path: `${appPath}.requires.${depName}`,
-                    type: 'undeclared_connection',
-                    message: `Legacy "requires" syntax used`,
-                    suggestion: `Use "connects_to: { ${depName}: { mode: local } }" instead`,
-                    severity: settings.enabled ? 'error' : 'warning',
-                });
-            }
-        }
     }
-    // Check provides/infrastructure
-    const v4Config = config;
-    if (v4Config.provides) {
-        for (const [infraName, infraConfig] of Object.entries(v4Config.provides)) {
+    // Check provides
+    if (config.provides) {
+        for (const [infraName, infraConfig] of Object.entries(config.provides)) {
             if (!infraConfig.type || !infraConfig.image || !infraConfig.port) {
                 violations.push({
                     path: `provides.${infraName}`,
@@ -150,17 +129,15 @@ function validateStrictMode(config, strictConfig = {}) {
                 });
             }
             else {
-                explicitValues += 3; // type, image, port
+                explicitValues += 3;
             }
         }
     }
     // Calculate summary
     const errors = violations.filter(v => v.severity === 'error').length;
     const warnings = violations.filter(v => v.severity === 'warning').length;
-    // In strict mode with warnings_as_errors, warnings become errors
-    const finalErrors = settings.warnings_as_errors ? errors + warnings : errors;
     return {
-        valid: finalErrors === 0,
+        valid: settings.warnings_as_errors ? violations.length === 0 : errors === 0,
         violations,
         summary: {
             errors,
@@ -175,114 +152,68 @@ function validateStrictMode(config, strictConfig = {}) {
  * Check if a type appears to be inferred from the app name
  */
 function isTypeInferredFromName(appName, type) {
-    const nameLower = appName.toLowerCase();
-    if (type === 'frontend') {
-        return /web|frontend|ui|client|app/.test(nameLower);
-    }
-    if (type === 'backend') {
-        return /api|backend|server|service/.test(nameLower);
-    }
-    if (type === 'worker') {
-        return /worker|queue|job|processor/.test(nameLower);
-    }
-    if (type === 'gateway') {
-        return /gateway|proxy|router/.test(nameLower);
-    }
-    return false;
+    const name = appName.toLowerCase();
+    const patterns = {
+        frontend: ['web', 'ui', 'client', 'app', 'dashboard', 'admin'],
+        backend: ['api', 'server', 'service', 'backend'],
+        worker: ['worker', 'job', 'queue', 'processor'],
+        gateway: ['gateway', 'proxy', 'router'],
+    };
+    const typePatterns = patterns[type];
+    if (!typePatterns)
+        return false;
+    return typePatterns.some(pattern => name.includes(pattern));
 }
-// ============================================
-// Strict Mode Helpers
-// ============================================
 /**
  * Get strict mode settings from config
  */
 function getStrictModeSettings(config) {
-    const v4Config = config;
-    if (v4Config.version === 4 && v4Config.strict) {
-        return { ...exports.DEFAULT_STRICT_CONFIG, ...v4Config.strict };
-    }
-    // v3 configs default to lenient mode
-    if (config.version !== 4) {
-        return {
-            enabled: false,
-            allow_detect: true,
-            warnings_as_errors: false,
-        };
-    }
-    return exports.DEFAULT_STRICT_CONFIG;
+    return {
+        ...DEFAULT_STRICT_CONFIG,
+        ...config.strict,
+    };
 }
 /**
  * Check if strict mode is enabled
  */
 function isStrictModeEnabled(config) {
-    return getStrictModeSettings(config).enabled;
+    return config.strict?.enabled ?? true;
 }
 /**
- * Format strict mode violations for display
+ * Format violations for display
  */
 function formatStrictViolations(result) {
-    const lines = [];
-    if (result.valid) {
-        lines.push('✓ Strict mode validation passed');
+    if (result.violations.length === 0) {
+        return '✓ No strict mode violations';
     }
-    else {
-        lines.push('✗ Strict mode validation failed');
+    const lines = [];
+    const errors = result.violations.filter(v => v.severity === 'error');
+    const warnings = result.violations.filter(v => v.severity === 'warning');
+    if (errors.length > 0) {
+        lines.push(`\n❌ ${errors.length} error(s):\n`);
+        for (const v of errors) {
+            lines.push(`  • ${v.path}: ${v.message}`);
+            lines.push(`    → ${v.suggestion}`);
+        }
     }
-    lines.push('');
-    lines.push(`Summary:`);
-    lines.push(`  Explicit values: ${result.summary.explicit_values}`);
-    lines.push(`  $detect markers: ${result.summary.detect_markers}`);
-    lines.push(`  Inferred values: ${result.summary.inferred_values}`);
-    lines.push(`  Errors: ${result.summary.errors}`);
-    lines.push(`  Warnings: ${result.summary.warnings}`);
-    if (result.violations.length > 0) {
-        lines.push('');
-        lines.push('Violations:');
-        for (const violation of result.violations) {
-            const icon = violation.severity === 'error' ? '✗' : '⚠';
-            lines.push(`  ${icon} ${violation.path}`);
-            lines.push(`    ${violation.message}`);
-            lines.push(`    → ${violation.suggestion}`);
+    if (warnings.length > 0) {
+        lines.push(`\n⚠️  ${warnings.length} warning(s):\n`);
+        for (const v of warnings) {
+            lines.push(`  • ${v.path}: ${v.message}`);
+            lines.push(`    → ${v.suggestion}`);
         }
     }
     return lines.join('\n');
 }
 /**
- * Generate fixes for strict mode violations
+ * Check a config and throw if invalid in strict mode
  */
-function generateStrictFixes(config, result) {
-    const fixes = [];
-    for (const violation of result.violations) {
-        if (violation.type === 'missing_type') {
-            // Add $detect marker for missing types
-            fixes.push({
-                path: violation.path,
-                action: 'add',
-                value: '$detect',
-                description: `Add $detect marker to auto-detect type`,
-            });
-        }
-        if (violation.type === 'missing_port') {
-            fixes.push({
-                path: violation.path,
-                action: 'add',
-                value: '$detect',
-                description: `Add $detect marker to auto-detect port`,
-            });
-        }
-        if (violation.type === 'undeclared_connection' && violation.path.includes('requires')) {
-            // Convert requires to connects_to
-            const match = violation.path.match(/apps\.(\w+)\.requires\.(\w+)/);
-            if (match) {
-                const [, appName, depName] = match;
-                fixes.push({
-                    path: `apps.${appName}.connects_to.${depName}`,
-                    action: 'add',
-                    value: { mode: 'local', required: true },
-                    description: `Convert requires.${depName} to connects_to`,
-                });
-            }
-        }
+function enforceStrictMode(config, options = {}) {
+    const settings = getStrictModeSettings(config);
+    if (!settings.enabled)
+        return;
+    const result = validateStrictMode(config, settings);
+    if (!result.valid || (options.throwOnWarnings && result.summary.warnings > 0)) {
+        throw new Error(`Strict mode validation failed:\n${formatStrictViolations(result)}`);
     }
-    return fixes;
 }

package/package.json

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

package/dist/migration.js

@@ -1,335 +0,0 @@
-"use strict";
-/**
- * Configuration Migration Utilities
- *
- * Handles migration from v3 to v4 schema:
- * - Converts `requires` to `connects_to`
- * - Converts `infrastructure` to `provides`
- * - Adds explicit types where inferred
- * - Shows deprecation warnings
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkDeprecations = checkDeprecations;
-exports.migrateV3ToV4 = migrateV3ToV4;
-exports.needsMigration = needsMigration;
-exports.getMigrationSummary = getMigrationSummary;
-const schema_v4_1 = require("./schema-v4");
-/**
- * Check a v3 config for deprecated patterns
- */
-function checkDeprecations(config) {
-    const warnings = [];
-    // Check version (v3 version is '3.0' string, v4 is number 4)
-    if (config.version !== 4) {
-        warnings.push({
-            path: 'version',
-            message: `Config version ${config.version} is deprecated`,
-            suggestion: 'Run "genbox migrate" to upgrade to version 4',
-            severity: 'warning',
-            autoMigrate: true,
-        });
-    }
-    // Check for requires in apps
-    for (const [appName, appConfig] of Object.entries(config.apps || {})) {
-        if (appConfig.requires) {
-            warnings.push({
-                path: `apps.${appName}.requires`,
-                message: '"requires" is deprecated in v4',
-                suggestion: 'Use "connects_to" with explicit connection modes',
-                severity: 'warning',
-                autoMigrate: true,
-            });
-        }
-    }
-    // Check for infrastructure (should be provides)
-    if (config.infrastructure) {
-        warnings.push({
-            path: 'infrastructure',
-            message: '"infrastructure" is renamed to "provides" in v4',
-            suggestion: 'Rename to "provides" for clarity',
-            severity: 'warning',
-            autoMigrate: true,
-        });
-    }
-    // Check for profile connect_to
-    for (const [profileName, profile] of Object.entries(config.profiles || {})) {
-        if (profile.connect_to && typeof profile.connect_to === 'string') {
-            warnings.push({
-                path: `profiles.${profileName}.connect_to`,
-                message: 'Single string "connect_to" is deprecated in v4',
-                suggestion: 'Use "default_connection" or per-app "connections" overrides',
-                severity: 'warning',
-                autoMigrate: true,
-            });
-        }
-    }
-    // Check for implicit app types (inferred from names)
-    for (const [appName, appConfig] of Object.entries(config.apps || {})) {
-        if (!appConfig.type) {
-            warnings.push({
-                path: `apps.${appName}.type`,
-                message: `App "${appName}" has no explicit type`,
-                suggestion: 'Add explicit "type: frontend|backend|worker|gateway"',
-                severity: 'warning',
-                autoMigrate: false,
-            });
-        }
-    }
-    return warnings;
-}
-/**
- * Migrate a v3 config to v4
- */
-function migrateV3ToV4(v3Config) {
-    const changes = [];
-    const warnings = [];
-    // Start with base v4 structure
-    const v4Config = {
-        version: 4,
-        project: {
-            name: v3Config.project.name,
-            description: v3Config.project.description,
-            structure: v3Config.project.structure,
-        },
-        apps: {},
-    };
-    changes.push({
-        type: 'modify',
-        path: 'version',
-        description: 'Upgraded version from 3 to 4',
-        before: v3Config.version,
-        after: 4,
-    });
-    // Migrate infrastructure to provides
-    if (v3Config.infrastructure) {
-        v4Config.provides = {};
-        for (const [name, infra] of Object.entries(v3Config.infrastructure)) {
-            v4Config.provides[name] = migrateInfrastructure(name, infra);
-        }
-        changes.push({
-            type: 'rename',
-            path: 'infrastructure',
-            description: 'Renamed "infrastructure" to "provides"',
-        });
-    }
-    // Migrate apps
-    for (const [appName, appConfig] of Object.entries(v3Config.apps || {})) {
-        const migratedApp = migrateApp(appName, appConfig, v3Config, changes, warnings);
-        v4Config.apps[appName] = migratedApp;
-    }
-    // Migrate profiles
-    if (v3Config.profiles) {
-        v4Config.profiles = {};
-        for (const [profileName, profile] of Object.entries(v3Config.profiles)) {
-            v4Config.profiles[profileName] = migrateProfile(profileName, profile, changes);
-        }
-    }
-    // Copy over other sections
-    if (v3Config.environments) {
-        v4Config.environments = {};
-        for (const [envName, envConfig] of Object.entries(v3Config.environments)) {
-            v4Config.environments[envName] = {
-                description: envConfig.description,
-                urls: extractUrls(envConfig),
-                env: {},
-            };
-        }
-    }
-    if (v3Config.repos) {
-        v4Config.repos = {};
-        for (const [repoName, repoConfig] of Object.entries(v3Config.repos)) {
-            v4Config.repos[repoName] = {
-                url: repoConfig.url,
-                path: repoConfig.path,
-                branch: repoConfig.branch,
-                auth: repoConfig.auth,
-            };
-        }
-    }
-    if (v3Config.defaults) {
-        v4Config.defaults = {
-            size: v3Config.defaults.size,
-            database: v3Config.defaults.database,
-            branch: v3Config.defaults.branch,
-        };
-    }
-    if (v3Config.hooks) {
-        v4Config.hooks = v3Config.hooks;
-    }
-    if (v3Config.scripts) {
-        v4Config.scripts = v3Config.scripts.map(script => ({
-            name: script.name,
-            path: script.path,
-            stage: script.stage,
-            run_as: script.runAs,
-            depends_on: script.dependsOn,
-        }));
-    }
-    // Add strict mode (default for v4)
-    v4Config.strict = {
-        enabled: true,
-        allow_detect: true,
-        warnings_as_errors: false,
-    };
-    changes.push({
-        type: 'add',
-        path: 'strict',
-        description: 'Added strict mode configuration (default for v4)',
-        after: v4Config.strict,
-    });
-    return { config: v4Config, changes, warnings };
-}
-function migrateInfrastructure(name, infra) {
-    return {
-        type: infra.type,
-        image: infra.image,
-        port: infra.port,
-        data_dir: infra.data_dir,
-        description: `Migrated from infrastructure.${name}`,
-    };
-}
-function migrateApp(appName, appConfig, v3Config, changes, warnings) {
-    const v4App = {
-        path: appConfig.path,
-        type: appConfig.type || '$detect',
-    };
-    // Migrate framework
-    if (appConfig.framework) {
-        v4App.framework = appConfig.framework;
-    }
-    // Migrate port
-    if (appConfig.port) {
-        v4App.port = appConfig.port;
-    }
-    // Migrate requires to connects_to
-    if (appConfig.requires) {
-        v4App.connects_to = {};
-        for (const [depName, requirement] of Object.entries(appConfig.requires)) {
-            v4App.connects_to[depName] = {
-                mode: 'local', // Default to local
-                required: requirement === 'required',
-                description: `Migrated from requires.${depName}`,
-            };
-        }
-        changes.push({
-            type: 'rename',
-            path: `apps.${appName}.requires`,
-            description: `Converted "requires" to "connects_to" for app "${appName}"`,
-            before: appConfig.requires,
-            after: v4App.connects_to,
-        });
-    }
-    // Also handle dependencies if present
-    if (appConfig.dependencies) {
-        if (!v4App.connects_to)
-            v4App.connects_to = {};
-        for (const [depName, depConfig] of Object.entries(appConfig.dependencies)) {
-            if (!v4App.connects_to[depName]) {
-                v4App.connects_to[depName] = {
-                    mode: depConfig.mode,
-                    required: true,
-                };
-            }
-        }
-    }
-    // Migrate commands
-    if (appConfig.commands) {
-        v4App.commands = appConfig.commands;
-    }
-    // Copy other fields
-    if (appConfig.repo)
-        v4App.repo = appConfig.repo;
-    if (appConfig.description)
-        v4App.description = appConfig.description;
-    if (appConfig.env)
-        v4App.env = appConfig.env;
-    if (appConfig.compose_file) {
-        v4App.runner = 'docker';
-        v4App.docker = { file: appConfig.compose_file };
-    }
-    // Warn about missing explicit type
-    if (!appConfig.type) {
-        warnings.push(`App "${appName}" has no explicit type. Using $detect marker. ` +
-            `Run "genbox scan" then "genbox resolve" to determine the type.`);
-    }
-    return v4App;
-}
-function migrateProfile(profileName, profile, changes) {
-    const v4Profile = {
-        description: profile.description,
-        extends: profile.extends,
-        size: profile.size,
-        apps: profile.apps,
-        database: profile.database,
-        env: profile.env,
-        branch: profile.branch,
-    };
-    // Convert connect_to to default_connection
-    if (profile.connect_to && typeof profile.connect_to === 'string') {
-        v4Profile.default_connection = profile.connect_to;
-        changes.push({
-            type: 'rename',
-            path: `profiles.${profileName}.connect_to`,
-            description: `Converted string "connect_to" to "default_connection" in profile "${profileName}"`,
-            before: profile.connect_to,
-            after: v4Profile.default_connection,
-        });
-    }
-    return v4Profile;
-}
-function extractUrls(envConfig) {
-    const urls = {};
-    if (envConfig.api?.url) {
-        urls['api'] = envConfig.api.url;
-    }
-    if (envConfig.api?.gateway) {
-        urls['gateway'] = envConfig.api.gateway;
-    }
-    if (envConfig.mongodb?.url) {
-        urls['mongodb'] = envConfig.mongodb.url;
-    }
-    if (envConfig.redis?.url) {
-        urls['redis'] = envConfig.redis.url;
-    }
-    if (envConfig.rabbitmq?.url) {
-        urls['rabbitmq'] = envConfig.rabbitmq.url;
-    }
-    return urls;
-}
-// ============================================
-// Migration Detection
-// ============================================
-/**
- * Check if a config needs migration
- */
-function needsMigration(config) {
-    const version = (0, schema_v4_1.getConfigVersion)(config);
-    return version === 3 || version === 'unknown';
-}
-/**
- * Get migration summary
- */
-function getMigrationSummary(v3Config) {
-    const deprecations = checkDeprecations(v3Config);
-    const estimatedChanges = [];
-    if (v3Config.infrastructure) {
-        estimatedChanges.push('Rename "infrastructure" to "provides"');
-    }
-    for (const appName of Object.keys(v3Config.apps || {})) {
-        const app = v3Config.apps[appName];
-        if (app.requires) {
-            estimatedChanges.push(`Convert "${appName}.requires" to "connects_to"`);
-        }
-    }
-    for (const profileName of Object.keys(v3Config.profiles || {})) {
-        const profile = v3Config.profiles[profileName];
-        if (profile.connect_to && typeof profile.connect_to === 'string') {
-            estimatedChanges.push(`Convert "${profileName}.connect_to" to "default_connection"`);
-        }
-    }
-    return {
-        fieldsToMigrate: estimatedChanges.length,
-        deprecatedPatterns: deprecations.length,
-        estimatedChanges,
-    };
-}

package/dist/schema-v3.js

@@ -1,48 +0,0 @@
-"use strict";
-/**
- * Genbox Configuration Schema v3
- *
- * Supports:
- * - Multi-level configs (workspace/project/user)
- * - Flexible app selection (profiles, CLI, interactive)
- * - External environment connections
- * - Database modes (none/local/copy/remote)
- * - Dependency resolution
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DETECTABLE_APP_FIELDS = exports.DETECT_MARKER = void 0;
-exports.isDetectMarker = isDetectMarker;
-// ============================================
-// $detect Marker Support
-// ============================================
-/**
- * Special marker indicating a value should be auto-detected.
- * Used in genbox.yaml to opt-in to detection for specific fields.
- *
- * Example:
- *   apps:
- *     web:
- *       path: ./web
- *       type: $detect        # Auto-detect from dependencies
- *       port: $detect        # Auto-detect from scripts
- *       framework: $detect   # Auto-detect from dependencies
- */
-exports.DETECT_MARKER = '$detect';
-/**
- * List of fields that support $detect markers in AppConfig
- */
-exports.DETECTABLE_APP_FIELDS = [
-    'type',
-    'framework',
-    'port',
-    'commands.install',
-    'commands.dev',
-    'commands.build',
-    'commands.start',
-];
-/**
- * Check if a value is a $detect marker
- */
-function isDetectMarker(value) {
-    return value === exports.DETECT_MARKER;
-}