genbox 1.0.11 → 1.0.13

package/dist/strict-mode.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * Strict Mode Enforcement
+ *
+ * In strict mode (default for v4):
+ * - All app types must be explicit (no inference from names)
+ * - 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 = {
+    enabled: true,
+    allow_detect: true,
+    warnings_as_errors: false,
+};
+// ============================================
+// Strict Mode Validation
+// ============================================
+/**
+ * Validate a configuration against strict mode rules
+ */
+function validateStrictMode(config, strictConfig = {}) {
+    const settings = { ...exports.DEFAULT_STRICT_CONFIG, ...strictConfig };
+    const violations = [];
+    let explicitValues = 0;
+    let detectMarkers = 0;
+    let inferredValues = 0;
+    // Check each app
+    for (const [appName, appConfig] of Object.entries(config.apps || {})) {
+        const appPath = `apps.${appName}`;
+        // Check app type
+        if (!appConfig.type) {
+            violations.push({
+                path: `${appPath}.type`,
+                type: 'missing_type',
+                message: `App "${appName}" has no type specified`,
+                suggestion: `Add explicit "type: frontend | backend | worker | gateway"`,
+                severity: settings.enabled ? 'error' : 'warning',
+            });
+            inferredValues++;
+        }
+        else if ((0, schema_v3_1.isDetectMarker)(appConfig.type)) {
+            if (!settings.allow_detect) {
+                violations.push({
+                    path: `${appPath}.type`,
+                    type: 'implicit_value',
+                    message: `$detect markers are not allowed in strict mode`,
+                    suggestion: `Replace $detect with explicit type value`,
+                    severity: 'error',
+                });
+            }
+            detectMarkers++;
+        }
+        else {
+            explicitValues++;
+            // Check for naming-based inference (when type matches name pattern)
+            if (isTypeInferredFromName(appName, appConfig.type)) {
+                violations.push({
+                    path: `${appPath}.type`,
+                    type: 'naming_inference',
+                    message: `App type "${appConfig.type}" appears to match naming convention`,
+                    suggestion: `This is fine, but ensure the type is intentional, not just matching the name`,
+                    severity: 'warning',
+                });
+            }
+        }
+        // Check port for backend apps
+        if (appConfig.type === 'backend' || appConfig.type === 'gateway') {
+            if (!appConfig.port) {
+                violations.push({
+                    path: `${appPath}.port`,
+                    type: 'missing_port',
+                    message: `Backend app "${appName}" has no port specified`,
+                    suggestion: `Add explicit "port: <number>" or "port: $detect"`,
+                    severity: settings.enabled ? 'error' : 'warning',
+                });
+                inferredValues++;
+            }
+            else if ((0, schema_v3_1.isDetectMarker)(appConfig.port)) {
+                if (!settings.allow_detect) {
+                    violations.push({
+                        path: `${appPath}.port`,
+                        type: 'implicit_value',
+                        message: `$detect markers are not allowed in strict mode`,
+                        suggestion: `Replace $detect with explicit port number`,
+                        severity: 'error',
+                    });
+                }
+                detectMarkers++;
+            }
+            else {
+                explicitValues++;
+            }
+        }
+        // Check connections (v4 style)
+        const v4App = appConfig;
+        if (v4App.connects_to) {
+            for (const [connName, connConfig] of Object.entries(v4App.connects_to)) {
+                if (!connConfig || typeof connConfig !== 'object') {
+                    violations.push({
+                        path: `${appPath}.connects_to.${connName}`,
+                        type: 'undeclared_connection',
+                        message: `Invalid connection configuration for "${connName}"`,
+                        suggestion: `Specify connection mode: { mode: local | staging | production }`,
+                        severity: 'error',
+                    });
+                }
+                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)) {
+            if (!infraConfig.type || !infraConfig.image || !infraConfig.port) {
+                violations.push({
+                    path: `provides.${infraName}`,
+                    type: 'implicit_value',
+                    message: `Infrastructure "${infraName}" missing required fields`,
+                    suggestion: `Specify type, image, and port explicitly`,
+                    severity: 'error',
+                });
+            }
+            else {
+                explicitValues += 3; // type, image, port
+            }
+        }
+    }
+    // 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,
+        violations,
+        summary: {
+            errors,
+            warnings,
+            explicit_values: explicitValues,
+            detect_markers: detectMarkers,
+            inferred_values: inferredValues,
+        },
+    };
+}
+/**
+ * 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;
+}
+// ============================================
+// 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;
+}
+/**
+ * Check if strict mode is enabled
+ */
+function isStrictModeEnabled(config) {
+    return getStrictModeSettings(config).enabled;
+}
+/**
+ * Format strict mode violations for display
+ */
+function formatStrictViolations(result) {
+    const lines = [];
+    if (result.valid) {
+        lines.push('✓ Strict mode validation passed');
+    }
+    else {
+        lines.push('✗ Strict mode validation failed');
+    }
+    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}`);
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Generate fixes for strict mode violations
+ */
+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`,
+                });
+            }
+        }
+    }
+    return fixes;
+}

package/package.json

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