@flisk-sh/flisk 0.0.0-stage → 1.3.189

package/engine/topologies/tilt/manifest/errors.star

@@ -0,0 +1,268 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# =============================================================================
+# 📋 MANIFEST MODULE - ERROR HANDLING
+# =============================================================================
+# Path: .tilt/topologies/tilt/manifest/errors.star
+# Purpose: Standardized error types and handling for manifest system
+# Status: Phase 1 of manifest system refactoring
+# =============================================================================
+
+# Error severity levels
+SEVERITY = {
+    'CRITICAL': 'critical',  # Must fix, system won't function
+    'ERROR': 'error',        # Should fix, may cause issues
+    'WARNING': 'warning',    # Should consider, non-blocking
+    'INFO': 'info',          # Informational only
+    'DEPRECATION': 'deprecation',  # Feature will be removed
+}
+
+# Error categories
+CATEGORY = {
+    'SCHEMA': 'schema',           # Schema violations
+    'VALIDATION': 'validation',     # Value validation failures
+    'IO': 'io',                   # File I/O errors
+    'PARSE': 'parse',             # JSON parsing errors
+    'DEPENDENCY': 'dependency',   # Service dependency issues
+    'CONFIG': 'config',           # Configuration errors
+    'RUNTIME': 'runtime',         # Runtime errors
+    'NETWORK': 'network',         # Network/remote fetch errors
+}
+
+# Common error messages
+ERROR_MESSAGES = {
+    'MISSING_REQUIRED_FIELD': 'Missing required field: {field}',
+    'INVALID_FIELD_TYPE': 'Field {field} has invalid type: expected {expected}, got {actual}',
+    'INVALID_FIELD_VALUE': 'Field {field} has invalid value: {value}',
+    'FIELD_OUT_OF_RANGE': 'Field {field} value {value} is outside valid range [{min}, {max}]',
+    'INVALID_PATTERN': 'Field {field} value does not match required pattern: {pattern}',
+    'INVALID_ENUM': 'Field {field} value {value} is not in allowed values: {allowed}',
+    'FILE_NOT_FOUND': 'Manifest file not found: {path}',
+    'FILE_EMPTY': 'Manifest file is empty: {path}',
+    'INVALID_JSON': 'Invalid JSON in manifest file: {path} - {error}',
+    'DEPENDENCY_NOT_FOUND': 'Dependency {dependency} not found for service {service}',
+    'CIRCULAR_DEPENDENCY': 'Circular dependency detected: {path}',
+    'PORT_CONFLICT': 'Port {port} is already used by service {existing_service}',
+    'DUPLICATE_RESOURCE_NAME': 'Duplicate service name: {name}',
+    'INVALID_APP_TYPE': 'Invalid app type {appType} for service {service}',
+    'MISSING_BACKEND': 'Frontend {service} is missing backendName field',
+    'MISSING_DATABASE': 'Service {service} has prisma feature but no databaseName',
+}
+
+def new_error(message, category, severity, context=None):
+    """
+    Create a standardized error struct.
+    
+    Args:
+        message: Human-readable error message
+        category: Error category (from CATEGORY)
+        severity: Error severity (from SEVERITY)
+        context: Optional dict with:
+            - field: Field name if field-specific
+            - path: File path
+            - value: Invalid value
+            - expected: Expected value/type
+            - suggestion: Suggested fix
+    
+    Returns:
+        Error struct
+    """
+    return struct(
+        message=message,
+        category=category,
+        severity=severity,
+        context=context or {},
+        timestamp=None,  # Tilt doesn't have time functions, set externally if needed
+    )
+
+def format_error(error):
+    """
+    Format error for display.
+    
+    Args:
+        error: Error struct
+    
+    Returns:
+        Formatted string
+    """
+    base = "[{severity}] {category}: {message}".format(
+        severity=error.severity.upper(),
+        category=error.category.upper(),
+        message=error.message,
+    )
+    
+    if error.context:
+        if 'field' in error.context:
+            base += " (field: {field})".format(field=error.context['field'])
+        if 'path' in error.context:
+            base += " @ {path}".format(path=error.context['path'])
+        if 'suggestion' in error.context:
+            base += "\n  💡 Suggestion: {suggestion}".format(
+                suggestion=error.context['suggestion']
+            )
+    
+    return base
+
+def group_errors(errors):
+    """
+    Group errors by category and severity.
+    
+    Args:
+        errors: List of error structs
+    
+    Returns:
+        Dict with errors grouped by category and severity
+    """
+    grouped = {}
+    
+    for error in errors:
+        cat = error.category
+        sev = error.severity
+        
+        if cat not in grouped:
+            grouped[cat] = {}
+        
+        if sev not in grouped[cat]:
+            grouped[cat][sev] = []
+        
+        grouped[cat][sev].append(error)
+    
+    return grouped
+
+def has_critical_errors(errors):
+    """
+    Check if any critical errors exist.
+    
+    Args:
+        errors: List of error structs
+    
+    Returns:
+        True if any critical errors exist
+    """
+    for error in errors:
+        if error.severity == SEVERITY['CRITICAL']:
+            return True
+    return False
+
+def has_errors(errors, min_severity='ERROR'):
+    """
+    Check if any errors of specified severity or higher exist.
+    
+    Args:
+        errors: List of error structs
+        min_severity: Minimum severity to check (ERROR, WARNING, etc.)
+    
+    Returns:
+        True if any matching errors exist
+    """
+    severity_order = ['INFO', 'DEPRECATION', 'WARNING', 'ERROR', 'CRITICAL']
+    min_idx = severity_order.index(min_severity)
+    
+    for error in errors:
+        error_idx = severity_order.index(error.severity)
+        if error_idx >= min_idx:
+            return True
+    
+    return False
+
+def filter_errors(errors, category=None, severity=None):
+    """
+    Filter errors by category and/or severity.
+    
+    Args:
+        errors: List of error structs
+        category: Optional category to filter by
+        severity: Optional severity to filter by
+    
+    Returns:
+        Filtered list of errors
+    """
+    filtered = []
+    
+    for error in errors:
+        if category and error.category != category:
+            continue
+        if severity and error.severity != severity:
+            continue
+        filtered.append(error)
+    
+    return filtered
+
+def get_error_summary(errors):
+    """
+    Get a summary of errors by category and severity.
+    
+    Args:
+        errors: List of error structs
+    
+    Returns:
+        Summary dict with counts
+    """
+    summary = {
+        'total': len(errors),
+        'by_severity': {
+            'CRITICAL': 0,
+            'ERROR': 0,
+            'WARNING': 0,
+            'INFO': 0,
+            'DEPRECATION': 0,
+        },
+        'by_category': {},
+    }
+    
+    for error in errors:
+        summary['by_severity'][error.severity] += 1
+        
+        cat = error.category
+        if cat not in summary['by_category']:
+            summary['by_category'][cat] = 0
+        summary['by_category'][cat] += 1
+    
+    return summary
+
+def create_field_error(field_name, field_value, error_type, **kwargs):
+    """
+    Convenience function to create field-specific errors.
+    
+    Args:
+        field_name: Name of the field with error
+        field_value: The invalid value
+        error_type: Type of error (key in ERROR_MESSAGES)
+        **kwargs: Additional context for error message formatting
+    
+    Returns:
+        Error struct
+    """
+    message_template = ERROR_MESSAGES.get(error_type, 'Unknown error for field {field}')
+    
+    context = {
+        'field': field_name,
+        'value': field_value,
+    }
+    context.update(kwargs)
+    
+    message = message_template.format(**context)
+    
+    return new_error(
+        message=message,
+        category=CATEGORY['VALIDATION'],
+        severity=SEVERITY['ERROR'],
+        context=context,
+    )
+
+# Export all error handling functions and constants
+ManifestErrors = struct(
+    SEVERITY=SEVERITY,
+    CATEGORY=CATEGORY,
+    ERROR_MESSAGES=ERROR_MESSAGES,
+    new=new_error,
+    format=format_error,
+    group=group_errors,
+    has_critical=has_critical_errors,
+    has_errors=has_errors,
+    filter=filter_errors,
+    get_summary=get_error_summary,
+    create_field_error=create_field_error,
+)
+
+VALIDATION = {}

package/engine/topologies/tilt/manifest/integration.star

@@ -0,0 +1,348 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# =============================================================================
+# 📋 MANIFEST MODULE - DISCOVERY INTEGRATION (Phase 5 Complete)
+# =============================================================================
+# Path: .tilt/topologies/tilt/manifest/integration.star
+# Purpose: Integration layer between new manifest module and discovery system
+# Status: Phase 5 COMPLETE - Fully integrated, backward compatibility removed
+# 
+# This module provides the bridge between the new manifest system and the
+# discovery infrastructure. Phase 5 complete - using new system exclusively.
+# =============================================================================
+
+load("./__init__.star", "Manifest")
+load("./loader.star", "ManifestLoader")
+load("./parser.star", "ManifestParser")
+load("./validator.star", "ManifestValidator")
+load("../resources/shared-platform-postgres.star", "SHARED_POSTGRES_DEPENDENCY_NAMES")
+
+# Phase 5: Migration complete - always use new system
+def load_and_validate_manifest(manifest_path, all_manifests=None):
+    """
+    Load and validate a manifest using the new manifest system.
+    
+    This is the main integration point for discovery.star to use
+    the new manifest module. Phase 5: Always uses new system.
+    
+    Args:
+        manifest_path: Path to manifest JSON file
+        all_manifests: Optional list of all manifests for cross-validation
+    
+    Returns:
+        struct(
+            manifest=None,      # Normalized manifest dict
+            error=None,         # Error message or None
+            warnings=[],        # List of warnings
+            validation=None,    # Validation result struct
+            metadata={},        # Loading metadata
+        )
+    """
+    
+    if load_result.error:
+        return struct(
+            manifest=None,
+            error=load_result.error,
+            warnings=load_result.warnings,
+            validation=None,
+            metadata=load_result.metadata,
+        )
+    
+    raw_manifest = load_result.manifest
+    resource_path = ManifestParser.extract_resource_path(manifest_path)
+    
+    # Step 2: Parse and normalize
+    parse_result = ManifestParser.get_normalized(raw_manifest, resource_path)
+    
+    if parse_result.error:
+        return struct(
+            manifest=None,
+            error=parse_result.error,
+            warnings=parse_result.warnings + load_result.warnings,
+            validation=None,
+            metadata=load_result.metadata,
+        )
+    
+    normalized_manifest = parse_result.manifest
+    all_warnings = parse_result.warnings + load_result.warnings
+    
+    # Step 3: Validate
+    context = {'resource_path': resource_path}
+    if all_manifests:
+        context['all_manifests'] = all_manifests
+    
+    validation_result = ManifestValidator.validate(normalized_manifest, context, level='all')
+    
+    # Add validation warnings to list
+    for warning in validation_result.warnings:
+        all_warnings.append(Manifest.format_error(warning))
+    
+    return struct(
+        manifest=normalized_manifest,
+        error=None,
+        warnings=all_warnings,
+        validation=validation_result,
+        metadata=load_result.metadata,
+    )
+
+def load_all_manifests(services_root, filters=None, validate=False):
+    """
+    Load all manifests with optional validation.
+    
+    Integration wrapper for Manifest.load_all() with additional
+    processing for discovery system compatibility.
+    
+    Args:
+        services_root: Root directory to search
+        filters: Optional filters (appType, stack, features)
+        validate: Whether to validate each manifest
+    
+    Returns:
+        struct(
+            manifests=[],       # List of normalized manifests
+            errors=[],          # List of errors
+            warnings=[],        # List of warnings
+            stats={},           # Loading statistics
+            by_name={},         # Dict mapping appName to manifest
+            by_port={},         # Dict mapping port to manifest
+        )
+    """
+    # Use the new loader
+    load_result = ManifestLoader.load_all(services_root, filters)
+    
+    manifests = []
+    errors = []
+    warnings = []
+    by_name = {}
+    by_port = {}
+    
+    # Normalize each manifest
+    for raw_manifest in load_result.manifests:
+        resource_path = raw_manifest.get('_resource_path', '')
+        
+        # Normalize
+        parse_result = ManifestParser.get_normalized(raw_manifest, resource_path)
+        
+        if parse_result.error:
+            errors.append(parse_result.error)
+            continue
+        
+        normalized = parse_result.manifest
+        manifests.append(normalized)
+        
+        # Build lookup maps
+        app_name = normalized.get('appName')
+        if app_name:
+            by_name[app_name] = normalized
+        
+        port = normalized.get('port')
+        if port:
+            by_port[port] = normalized
+        
+        # Collect warnings
+        warnings.extend(parse_result.warnings)
+    
+    # Add loading errors
+    for error in load_result.errors:
+        errors.append(ManifestErrors.format(error))
+    
+    # Validate if requested
+    if validate:
+        for manifest in manifests:
+            context = {
+                'all_manifests': manifests,
+                'resource_path': manifest.get('_resource_path', ''),
+            }
+            
+            validation = ManifestValidator.validate(manifest, context, level='cross_service')
+            
+            if not validation.valid:
+                for error in validation.errors:
+                    errors.append(Manifest.format_error(error))
+    
+    return struct(
+        manifests=manifests,
+        errors=errors,
+        warnings=warnings,
+        stats=load_result.stats,
+        by_name=by_name,
+        by_port=by_port,
+    )
+
+def convert_to_resource_format(manifest):
+    """
+    Convert normalized manifest to discovery resource format.
+    
+    This ensures compatibility with the existing discovery system
+    by converting the new manifest format to the expected resource format.
+    
+    Args:
+        manifest: Normalized manifest dict
+    
+    Returns:
+        Resource dict in discovery format
+    """
+    app_name = manifest.get('appName', 'unknown')
+    app_type = manifest.get('appType', 'backend')
+    stack = manifest.get('stack', 'unknown')
+    port = manifest.get('port', 4000)
+    syncs = manifest.get('syncs', [])
+    dockerfile = manifest.get('dockerfile', '.autogenerated/Dockerfile.app.autogenerated')
+    resource_path = manifest.get('_resource_path', '')
+
+    resource = {
+        'name': app_name,
+        'dockerfile': app_name + '/' + dockerfile,
+        'syncs': syncs,
+        'port': port,
+        'stack': stack,
+        '_manifest': manifest.get('_manifest', manifest),  # Original manifest
+        '_resource_path': resource_path,
+        '_normalized': True,
+    }
+    
+    # Add frontend-specific fields
+    if app_type == 'frontend':
+        resource['frontend'] = True
+        resource['backendName'] = manifest.get('backendName', app_name.replace('-frontend', '-backend'))
+    
+    # Add optional fields
+    if manifest.get('target_path'):
+        resource['target_path'] = manifest['target_path']
+    if manifest.get('prisma_client_path'):
+        resource['prisma_client_path'] = manifest['prisma_client_path']
+    if manifest.get('registry_host'):
+        resource['registry_host'] = manifest['registry_host']
+    if manifest.get('start_command'):
+        resource['start_command'] = manifest['start_command']
+    
+    return resource
+
+def get_validation_summary(manifests):
+    """
+    Generate validation summary for all manifests.
+    
+    Args:
+        manifests: List of manifest dicts
+    
+    Returns:
+        Dict with summary statistics
+    """
+    summary = {
+        'total': len(manifests),
+        'valid': 0,
+        'invalid': 0,
+        'errors': 0,
+        'warnings': 0,
+        'by_severity': {
+            'CRITICAL': 0,
+            'ERROR': 0,
+            'WARNING': 0,
+        },
+    }
+    
+    for manifest in manifests:
+        context = {'all_manifests': manifests}
+        result = ManifestValidator.validate(manifest, context, level='all')
+        
+        if result.valid:
+            summary['valid'] += 1
+        else:
+            summary['invalid'] += 1
+        
+        summary['errors'] += len([e for e in result.errors 
+                                  if e.severity in ['ERROR', 'CRITICAL']])
+        summary['warnings'] += len(result.warnings)
+        
+        for error in result.errors:
+            if error.severity in summary['by_severity']:
+                summary['by_severity'][error.severity] += 1
+    
+    return summary
+
+def check_port_conflicts(manifests):
+    """
+    Check for port conflicts across all manifests.
+    
+    Args:
+        manifests: List of manifest dicts
+    
+    Returns:
+        List of conflict error structs
+    """
+    conflicts = []
+    ports = {}
+    
+    for manifest in manifests:
+        port = manifest.get('port')
+        app_name = manifest.get('appName', 'unknown')
+        
+        if port:
+            if port in ports:
+                conflicts.append(ManifestErrors.new(
+                    message="Port {} conflict: {} and {}".format(port, ports[port], app_name),
+                    category=ManifestErrors.CATEGORY['VALIDATION'],
+                    severity=ManifestErrors.SEVERITY['ERROR'],
+                    context={'port': port, 'services': [ports[port], app_name]},
+                ))
+            else:
+                ports[port] = app_name
+    
+    return conflicts
+
+def check_dependencies_valid(manifests):
+    """
+    Check if all dependencies reference valid services.
+
+    Shared platform Postgres names (`postgres`, `database-management`) are not
+    app services; they resolve to the Tilt resource `postgres` and are not
+    reported as missing.
+
+    Args:
+        manifests: List of manifest dicts
+
+    Returns:
+        List of dependency error structs
+    """
+    errors = []
+    app_names = {m.get('appName'): m for m in manifests if m.get('appName')}
+
+    for manifest in manifests:
+        app_name = manifest.get('appName', 'unknown')
+        internal_deps = manifest.get('dependsOn', [])
+
+        for dep in internal_deps:
+            if dep in SHARED_POSTGRES_DEPENDENCY_NAMES:
+                continue
+            if dep not in app_names:
+                errors.append(ManifestErrors.new(
+                    message="Service '{}' depends on non-existent service '{}'".format(app_name, dep),
+                    category=ManifestErrors.CATEGORY['DEPENDENCY'],
+                    severity=ManifestErrors.SEVERITY['ERROR'],
+                    context={'service': app_name, 'dependency': dep},
+                ))
+        
+        # Check frontend backend references
+        if manifest.get('appType') == 'frontend':
+            backend_name = manifest.get('backendName', '')
+            if backend_name and backend_name not in app_names:
+                errors.append(ManifestErrors.new(
+                    message="Frontend '{}' references non-existent backend '{}'".format(app_name, backend_name),
+                    category=ManifestErrors.CATEGORY['DEPENDENCY'],
+                    severity=ManifestErrors.SEVERITY['ERROR'],
+                    context={'frontend': app_name, 'backend': backend_name},
+                ))
+    
+    return errors
+
+# Export integration functions
+ManifestIntegration = struct(
+    load_and_validate=load_and_validate_manifest,
+    load_all=load_all_manifests,
+    convert_to_resource=convert_to_resource_format,
+    get_validation_summary=get_validation_summary,
+    check_port_conflicts=check_port_conflicts,
+    check_dependencies_valid=check_dependencies_valid,
+)
+
+VALIDATION = {}

package/engine/topologies/tilt/manifest/json_to_yaml.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+"""Convert JSON manifest to Tilt-compatible YAML resource"""
+import sys
+import json
+import yaml
+import uuid
+
+if len(sys.argv) < 2:
+    print("Usage: json_to_yaml.py <json_file>", file=sys.stderr)
+    sys.exit(1)
+
+json_file = sys.argv[1]
+try:
+    with open(json_file, 'r') as f:
+        data = json.load(f)
+    
+    # The YAML is a generated, committed mirror used only for Tilt resource tracking. A secret that someone put in service.json must
+    # not be copied into it (the JWT secret belongs in the project .env; `flisk doctor` warns about it).
+    data = {key: value for key, value in data.items() if key not in ("jwtSecret",)}
+
+    # Deterministic: the mirror is regenerated on every run, so a wall-clock time or random uid would change the file each time.
+    # The uid is derived from the content, and the timestamp is a fixed epoch (nothing reads it).
+    now = "1970-01-01T00:00:00Z"
+    uid = str(uuid.uuid5(uuid.NAMESPACE_URL, json.dumps(data, sort_keys=True)))
+    
+    # Match exact Tilt get uiresources format
+    tilt_resource = {
+        "apiVersion": "tilt.dev/v1alpha1",
+        "kind": "UIResource",
+        "metadata": {
+            "annotations": {
+                "tilt.dev/resource": data.get("appName", "unknown")
+            },
+            "creationTimestamp": now,
+            "name": data.get("appName", "unknown"),
+            "resourceVersion": "1",
+            "uid": uid
+        },
+        "spec": data,
+        "status": {
+            "conditions": [
+                {
+                    "lastTransitionTime": now,
+                    "status": "True",
+                    "type": "UpToDate"
+                }
+            ],
+            "runtimeStatus": "pending",
+            "updateStatus": "ok"
+        }
+    }
+    
+    print(yaml.dump(tilt_resource, 
+                   default_flow_style=False, 
+                   sort_keys=False,
+                   allow_unicode=True))
+except Exception as e:
+    print(f"Error: {e}", file=sys.stderr)
+    sys.exit(1)