@tdk-landscape/tdk-cli-core 1.3.15 → 1.3.22

package/discovery/manifest/loading.star

@@ -0,0 +1,386 @@
+# =============================================================================
+# 📋 TILT SDK - MANIFEST LOADING (CEO Review: rename-service-manifest)
+# =============================================================================
+# Path: .tilt/topologies/tilt/discovery/manifest/loading.star
+# Purpose: Load, synthesize, and apply defaults to manifests
+# 
+# Manifest loading with synthesis-by-default
+# Priority: service.json → synthesize from path
+# =============================================================================
+
+load('../../engine/topologies/tilt/manifest/constants.star',
+     'MANIFEST_DEFAULTS',
+     'DEFAULT_SYNCS',
+     'MANIFEST_FILENAME',
+     'BASE_PORT_FRONTEND',
+     'BASE_PORT_BACKEND',
+     'HEALTH_CHECK_PATH')
+load('../../engine/topologies/tilt/common/utils.star', 'Utils')
+load('../../engine/topologies/platform/docker/constants.star', 'PlatformDockerConstants')
+
+def _check_prisma_folder(resource_path):
+    """
+    Check if prisma/ directory exists in resource path (silent).
+    Used to auto-detect has_migrator when not in features.
+    """
+    check_cmd = "test -d '{path}/prisma' && echo 'yes' || echo 'no'".format(path=resource_path)
+    result = str(local(check_cmd, quiet=True, echo_off=True)).strip()
+    return result == 'yes'
+
+
+def check_prisma_folder(resource_path):
+    return _check_prisma_folder(resource_path)
+
+
+def get_default_syncs_for_type(app_type, features=None):
+    """
+    Returns default sync paths based on app type and features.
+    """
+    if features == None:
+        features = []
+
+    syncs = list(DEFAULT_SYNCS.get(app_type, ['src', 'package.json']))
+
+    # Add prisma to syncs if using prisma feature
+    if app_type == 'backend' and 'prisma' in features and 'prisma' not in syncs:
+        syncs.append('prisma')
+
+    return syncs
+
+
+def _extract_stack_from_path(resource_path, app_name):
+    """
+    Extract stack from resource path or app name.
+    
+    Convention: services/product/{stack}/{resource-name}
+    Fallback: First segment of app_name before hyphen
+    
+    Special handling: profile -> identity
+    """
+    parts = resource_path.rstrip('/').split('/')
+    if len(parts) >= 4 and parts[-4] == 'services' and parts[-3] == 'product':
+        stack = parts[-2]
+        # Normalize profile to identity
+        if stack == 'profile':
+            return 'identity'
+        return stack
+    else:
+        return app_name.split('-')[0] if '-' in app_name else app_name
+
+
+def load_manifest(resource_path, persist_to_disk=False):
+    """
+    Load manifest with synthesis-by-default.
+    
+    Priority order:
+      1. service.json (manifest file)
+      2. Synthesize from directory structure (synthesis-by-default for standard resources)
+    
+    Args:
+        resource_path: Path to resource directory
+        persist_to_disk: If True, sync _internalDeps back to the physical manifest file
+        
+    Returns:
+        Validated manifest dict with all defaults applied
+    """
+    manifest = None
+    manifest_source = None
+    manifest_path = None
+    
+    # Prepend project root to relative paths for correct resolution
+    project_root = os.environ.get('TDK_PROJECT_ROOT', '')
+    if project_root and not resource_path.startswith('/'):
+        base_path = project_root + '/' + resource_path
+    else:
+        base_path = resource_path
+    
+    # Try to load manifest file
+    manifest_full_path = base_path + '/' + MANIFEST_FILENAME
+    content = read_file(manifest_full_path, default='')
+    
+    if content and str(content).strip():
+        manifest = decode_json(content)
+        manifest_source = 'service.json'
+        manifest_path = manifest_full_path
+    else:
+        # Synthesize from directory structure if no manifest found
+        manifest = synthesize_manifest_from_path(resource_path)
+        manifest_source = 'synthesized'
+        manifest_path = resource_path  # Virtual path
+    
+    # Validate JSON parsed correctly
+    if manifest == None and manifest_source != 'synthesized':
+        fail("""
+❌ ═══════════════════════════════════════════════════════════════════
+❌  INVALID JSON IN MANIFEST FILE
+❌ ═══════════════════════════════════════════════════════════════════
+   📁 File: {path}
+   Source: {source}
+   
+   Common issues:
+   • Missing closing quote: "appName": "my-app
+   • Trailing comma: "port": 4000,}}
+   • Missing comma between properties
+   • Single quotes instead of double quotes
+   
+   Fix the JSON syntax and run 'tilt up' again.
+❌ ═══════════════════════════════════════════════════════════════════
+""".format(path=manifest_path, source=manifest_source))
+    
+    # Track manifest source for debugging
+    manifest['_manifestSource'] = manifest_source
+    manifest['_manifestPath'] = manifest_path
+    
+    # Apply defaults and compute derived values
+    validated = apply_manifest_defaults(manifest, resource_path)
+
+    return validated
+
+
+def synthesize_manifest_from_path(resource_path):
+    return _synthesize_manifest_from_path(resource_path)
+
+
+def apply_manifest_defaults(manifest, resource_path):
+    return _apply_manifest_defaults(manifest, resource_path)
+
+
+def _synthesize_manifest_from_path(resource_path):
+    """
+    Create a manifest based on directory naming conventions.
+    Used when manifest.json doesn't exist (backward compatibility).
+    
+    Convention: services/product/{stack}/{stack}-{component}-{type}
+    Example: services/product/{stack}/{app-name}-{type}
+             -> appName: {app-name}-{type}
+             -> appType: {type}
+             -> stack: {stack}
+    """
+    parts = resource_path.rstrip('/').split('/')
+    dir_name = parts[-1] if parts else 'unknown-service'
+    
+    # Determine appType from directory name suffix
+    app_type = 'backend'
+    if dir_name.endswith('-frontend'):
+        app_type = 'frontend'
+    elif dir_name.endswith('-backend'):
+        app_type = 'backend'
+    elif dir_name.endswith('-migrator'):
+        app_type = 'migrator'
+    elif dir_name.endswith('-sdk'):
+        app_type = 'sdk'
+    elif dir_name.endswith('-infra') or dir_name.endswith('-ui'):
+        app_type = 'library'
+    elif 'lib-' in dir_name or 'platform-' in dir_name:
+        app_type = 'library'
+    
+    return {
+        'appName': dir_name,
+        'appType': app_type,
+        '_synthesized': True,
+    }
+
+
+def _apply_manifest_defaults(manifest, resource_path):
+    """
+    🎯 SMART DEFAULTS: Expand slim manifest to full config.
+    
+    CEO Review updates (rename-service-manifest):
+    - Port is constant per appType (3000 frontend, 4000 backend) — Traefik handles routing
+    - Custom dockerfile support via manifest["dockerfile"] field
+    - Developer manually provides features (no auto-detection per requirement)
+    
+    Convention over Configuration:
+    - features: ["nats", "prisma"] -> usePrisma=True, useNats=True
+    - domain: "order" -> databaseName="TDK_order"
+    - domain: "order" -> traefik.host="order.backend.{project}.local"
+    - domain: "order" -> nats.queueGroup="order_backend_svc"
+    """
+    result = dict(manifest)
+    
+    # Normalize resource_path to be relative (strip leading / if present)
+    # Docker build context requires relative paths
+    if resource_path.startswith('/'):
+        resource_path = resource_path[1:]
+    
+    # Track overrides for logging (task 4.8: override detection)
+    overrides = []
+    app_name = result.get('appName', '')
+    
+    # Apply simple defaults
+    for key, default_value in MANIFEST_DEFAULTS.items():
+        if key not in result or result[key] == None:
+            result[key] = default_value
+    
+    # 🎯 CEO REVIEW: Traefik-native port strategy
+    # Port is constant per appType, not dynamically assigned
+    # Traefik routes by hostname (e.g., booking.backend.{project}.local), not port
+    app_type = result.get('appType', 'backend')
+    
+    # Set constant port per appType, but preserve explicit service.json ports.
+    computed_port = None
+    if app_type == 'frontend':
+        computed_port = BASE_PORT_FRONTEND
+    elif app_type == 'backend':
+        computed_port = BASE_PORT_BACKEND
+    elif app_type == 'migrator':
+        computed_port = 7000  # Migrator uses different range
+    
+    if computed_port != None and ('port' not in manifest or manifest.get('port') == None):
+        result['port'] = computed_port
+    
+    # 🎯 CEO REVIEW: Custom dockerfile support
+    # Validate custom dockerfile exists if specified
+    if 'dockerfile' in result:
+        custom_dockerfile = result['dockerfile']
+        dockerfile_path = resource_path + '/' + custom_dockerfile
+        # BUG FIX: Run check from project root since Tilt may run from .tdk/.tdk-out/
+        project_root = os.environ.get('TDK_PROJECT_ROOT', '')
+        if project_root:
+            dockerfile_exists = local("cd '{root}' && test -f '{path}' && echo 'yes' || echo 'no'".format(root=project_root, path=dockerfile_path), quiet=True, echo_off=True)
+        else:
+            dockerfile_exists = local("test -f '{path}' && echo 'yes' || echo 'no'".format(path=dockerfile_path), quiet=True, echo_off=True)
+        if str(dockerfile_exists).strip() != 'yes':
+            fail("""
+❌ ═══════════════════════════════════════════════════════════════════
+❌  CUSTOM DOCKERFILE NOT FOUND
+❌ ═══════════════════════════════════════════════════════════════════
+   📁 Resource: {resource}
+   🐳 Dockerfile: {dockerfile}
+   
+   Manifest specifies custom Dockerfile but it doesn't exist.
+   Either:
+    • Create {dockerfile} in resource directory
+   • Remove "dockerfile" field to use auto-generated Dockerfile
+❌ ═══════════════════════════════════════════════════════════════════
+""".format(resource=resource_path.split('/')[-1], dockerfile=custom_dockerfile))
+    
+    # 🎯 FEATURE FLAGS -> BOOLEAN CONFIG
+    # NOTE: Developer manually provides features per CEO Review requirement
+    # No auto-detection from file existence (e.g., prisma/schema.prisma)
+    features = result.get('features', [])
+    result['usePrisma'] = 'prisma' in features
+    result['useNats'] = 'nats' in features
+    result['useTraefik'] = 'traefik' in features or app_type in ['backend', 'sdk']
+
+    # Extract stack from path if not set
+    if 'stack' not in result:
+        result['stack'] = _extract_stack_from_path(resource_path, app_name)
+    
+    stack = result['stack']
+    
+    # 🎯 SMART DATABASE NAME with override detection
+    computed_db_name = PlatformDockerConstants.get_db_name(stack)
+    if 'databaseName' not in result:
+        result['databaseName'] = computed_db_name
+    elif result['databaseName'] != computed_db_name:
+        overrides.append("databaseName: {} (auto: {})".format(result['databaseName'], computed_db_name))
+    
+    # 🎯 SMART TRAEFIK CONFIG (Convention over Configuration)
+    # Apply to backends and SDKs that need Traefik routing
+    if result['useTraefik'] and app_type in ['backend', 'sdk']:
+        existing_traefik = result.get('traefik', {})
+        # Use apiPath from root level if available, otherwise use default pattern
+        root_api_path = result.get('apiPath')
+        default_path_prefix = root_api_path if root_api_path else '/api/' + stack
+        
+        computed_traefik = {
+            'host': stack + '.backend.' + PlatformDockerConstants.PROJECT_NAME + '.local',
+            'pathPrefix': default_path_prefix,
+            'healthCheck': HEALTH_CHECK_PATH,
+        }
+        
+        # Check for overrides
+        if existing_traefik.get('host') and existing_traefik.get('host') != computed_traefik['host']:
+            overrides.append("traefik.host: {} (auto: {})".format(existing_traefik['host'], computed_traefik['host']))
+        if existing_traefik.get('pathPrefix') and existing_traefik.get('pathPrefix') != computed_traefik['pathPrefix']:
+            overrides.append("traefik.pathPrefix: {} (auto: {})".format(existing_traefik['pathPrefix'], computed_traefik['pathPrefix']))
+        
+        result['traefik'] = {
+            'host': existing_traefik.get('host', computed_traefik['host']),
+            'pathPrefix': existing_traefik.get('pathPrefix', computed_traefik['pathPrefix']),
+            'healthCheck': existing_traefik.get('healthCheck', computed_traefik['healthCheck']),
+        }
+    
+    # 🎯 SMART NATS CONFIG
+    if result['useNats']:
+        existing_nats = result.get('nats', {})
+        result['nats'] = {
+            'queueGroup': existing_nats.get('queueGroup', stack + '_' + app_type + '_svc'),
+            'subjects': existing_nats.get('subjects', [stack + '.>']),
+        }
+    
+    # Compute backend name for frontends with override detection
+    if app_type == 'frontend':
+        computed_backend = app_name.replace('-frontend', '-backend')
+        if 'backendName' not in result:
+            result['backendName'] = computed_backend
+        elif result['backendName'] != computed_backend:
+            overrides.append("backendName: {} (auto: {})".format(result['backendName'], computed_backend))
+        
+        # 🎯 SMART BASEPATH for frontends (convention: /{stack}s)
+        computed_base_path = '/' + stack + 's'
+        if 'basePath' not in result:
+            result['basePath'] = computed_base_path
+        elif result['basePath'] != computed_base_path:
+            overrides.append("basePath: {} (auto: {})".format(result['basePath'], computed_base_path))
+    
+    # 🎯 Always set _servicePath for all manifest types
+    result['_servicePath'] = resource_path
+    
+    # 🎯 CENTRALIZED: Use Utils.get_internal_deps() for dependency extraction
+    internal_deps = Utils.get_internal_deps(resource_path)
+    result['_internalDeps'] = sorted(internal_deps)
+    
+    # 🎯 CENTRALIZED: Use Utils.build_deps_mapping() for path resolution
+    result['_internalDepsMapping'] = Utils.build_deps_mapping(resource_path, internal_deps)
+    
+    # 🎯 Log overrides if any were detected and verbose mode is enabled
+    if overrides and os.environ.get('TILT_LOG_LEVEL') == 'verbose':
+        print("📝 Override(s) detected for {}: {}".format(app_name, ', '.join(overrides)))
+    
+    return result
+
+
+def load_related_manifest(frontend_manifest, backend_suffix='-backend'):
+    """
+    Load the related backend manifest for a frontend resource.
+    
+    CEO Review update: Supports dual-filename and synthesis-by-default.
+    
+    Args:
+        frontend_manifest: The loaded frontend manifest
+        backend_suffix: Suffix to replace '-frontend' with
+        
+    Returns:
+        Backend manifest dictionary, or None if not found
+    """
+    if frontend_manifest.get('appType') != 'frontend':
+        return None
+    
+    resource_path = frontend_manifest.get('_servicePath', '')
+    backend_path = resource_path.replace('-frontend', backend_suffix)
+    
+    # Use load_manifest which handles dual-filename and synthesis
+    return load_manifest(backend_path)
+
+
+def get_manifest_filename(resource_path):
+    """
+    Determine which manifest filename is being used for a resource.
+    
+    CEO Review addition: Utility for filename detection.
+    
+    Args:
+        resource_path: Path to resource directory
+        
+    Returns:
+        Filename string or None if neither exists (synthesis will be used)
+    """
+    # Check for manifest file (service.json)
+    manifest_path = resource_path + '/' + MANIFEST_FILENAME
+    if local("test -f '{path}' && echo 'yes' || echo 'no'".format(path=manifest_path), quiet=True, echo_off=True) == 'yes':
+        return MANIFEST_FILENAME
+    
+    # Manifest not found - synthesis will be used
+    return None

package/discovery/manifest/normalize.star

@@ -0,0 +1,281 @@
+# =============================================================================
+# 📋 TILT SDK - MANIFEST NORMALIZATION & DISCOVERY
+# =============================================================================
+# Path: .tilt/topologies/tilt/discovery/manifest/normalize.star
+# Purpose: Normalize manifests and provide helper accessors
+# =============================================================================
+
+load('./constants.star', 'MANIFEST_DEFAULTS', 'MANIFEST_FILENAME')
+load('./loading.star', 'apply_manifest_defaults', 'check_prisma_folder', 'get_default_syncs_for_type')
+load('./validation.star', 'validate_manifest')
+load('../../engine/topologies/tilt/common/utils.star', 'Utils')
+load('../../engine/topologies/platform/docker/constants.star', 'PlatformDockerConstants')
+load('../../specs/specs/TILT_TECH_STACK.star', 'RUNTIME', 'MESSAGING')
+
+
+def _load_and_normalize(manifest_path, warn_only=True):
+    """
+    🎯 MAIN ENTRY POINT: Load manifest and normalize to full resource config.
+    
+    This function is the bridge between the discovery system (resource_registry.star)
+    and the manifest loading system. It:
+    
+    1. Reads the JSON file
+    2. Validates the structure
+    3. Normalizes with smart defaults
+    4. Computes labels, syncs, has_migrator
+    5. Returns a resource-ready configuration
+    
+    Args:
+        manifest_path: Full path to manifest file
+        warn_only: If True, return None on error instead of failing
+        
+    Returns:
+        Normalized manifest dict or None on error (if warn_only=True)
+    """
+    # Prepend project root to relative paths for correct resolution
+    project_root = os.environ.get('TDK_PROJECT_ROOT', '')
+    if project_root and not manifest_path.startswith('/'):
+        full_path = project_root + '/' + manifest_path
+    else:
+        full_path = manifest_path
+    
+    # Read manifest file
+    content = read_file(full_path, default='')
+    
+    if not content or not str(content).strip():
+        if warn_only:
+            print("   ⚠️  Empty or missing manifest: " + manifest_path)
+            return None
+        fail("Empty or missing manifest: " + manifest_path)
+    
+    # Parse JSON
+    manifest = decode_json(content)
+    if manifest == None:
+        if warn_only:
+            print("   ⚠️  Invalid JSON in manifest: " + manifest_path)
+            return None
+        fail("Invalid JSON in manifest: " + manifest_path)
+    
+    # Validate
+    issues = validate_manifest(manifest)
+    if issues:
+        if warn_only:
+            for issue in issues:
+                print("   ⚠️  " + manifest_path + ": " + issue)
+            return None
+        fail("Manifest validation failed:\n" + "\n".join(issues))
+    
+    # Extract service path from manifest path
+    resource_path = manifest_path.rsplit('/', 1)[0]
+    
+    # BUG FIX: Normalize various path patterns to project-relative paths
+    # Pattern 1: Worktrees - .worktrees/task1-dry/services/platform/...
+    # Pattern 2: TDK output - .tdk/.tdk-out/../.. or .tdk/.tdk-out/../../path
+    
+    if resource_path.startswith('.worktrees/'):
+        # Extract the part after the worktree name
+        parts = resource_path.split('/')
+        if len(parts) >= 3:
+            resource_path = '/'.join(parts[2:])
+    elif '.worktrees/' in resource_path:
+        worktree_idx = resource_path.find('.worktrees/')
+        after_worktree = resource_path[worktree_idx:]
+        parts = after_worktree.split('/')
+        if len(parts) >= 3:
+            resource_path = '/'.join(parts[2:])
+    elif '.tdk/.tdk-out/../..' in resource_path:
+        # Handle TDK output paths like: /path/to/.tdk/.tdk-out/../.. or .tdk/.tdk-out/../../services/...
+        tdk_idx = resource_path.find('.tdk/.tdk-out/../..')
+        if tdk_idx != -1:
+            after_tdk = resource_path[tdk_idx + len('.tdk/.tdk-out/../..'):]
+            if after_tdk.startswith('/'):
+                after_tdk = after_tdk[1:]
+            resource_path = after_tdk
+    elif resource_path.endswith('.tdk/.tdk-out/../..'):
+        # Handle bare TDK output path that ends with just the resolution pattern
+        resource_path = ''
+    
+    # Apply smart defaults
+    normalized = apply_manifest_defaults(manifest, resource_path)
+    
+    # Compute additional fields for registry compatibility
+    app_name = normalized.get('appName', '')
+    app_type = normalized.get('appType', 'backend')
+    stack = normalized.get('stack', '')
+    features = normalized.get('features', [])
+    
+    # 🎯 AUTO-COMPUTE labels from stack
+    normalized['labels'] = ['app.' + stack]
+    
+    # 🎯 AUTO-DETECT has_migrator
+    has_migrator = 'prisma' in features
+    if not has_migrator:
+        has_migrator = check_prisma_folder(resource_path)
+    normalized['has_migrator'] = has_migrator
+    
+    # 🎯 AUTO-COMPUTE syncs if not specified
+    if normalized.get('syncs') == None:
+        normalized['syncs'] = get_default_syncs_for_type(app_type, features)
+    
+    # 🎯 COMPUTE dockerfile path
+    dockerfile = normalized.get('dockerfile', 'Dockerfile')
+    normalized['dockerfile_path'] = app_name + '/' + dockerfile
+    
+    # 🎯 MARK as frontend if applicable
+    if app_type == 'frontend':
+        normalized['frontend'] = True
+    
+    # 🎯 EXTRACT dependencies for registry
+    normalized['serviceDependencies'] = normalized.get('dependsOn', [])
+
+    return normalized
+
+
+def _discover_manifests_in_path(root_path):
+    """
+    Discover all manifest files under a root path.
+    
+    Args:
+        root_path: Directory to search (e.g., 'services/product')
+        
+    Returns:
+        List of manifest file paths
+    """
+    find_cmd = "find {root} -name '{filename}' -type f 2>/dev/null | sort".format(
+        root=root_path,
+        filename=MANIFEST_FILENAME
+    )
+    result = str(local(find_cmd, quiet=True, echo_off=True))
+    
+    manifests = []
+    if result:
+        for line in result.strip().split('\n'):
+            if line and line.strip():
+                manifests.append(line.strip())
+    
+    return manifests
+
+
+def _load_all_manifests(root_path, warn_only=True):
+    """
+    Load and normalize all manifests under a root path.
+    
+    Args:
+        root_path: Directory to search (e.g., 'services/product')
+        warn_only: If True, skip invalid manifests with warnings
+        
+    Returns:
+        List of normalized manifest dicts
+    """
+    manifest_paths = _discover_manifests_in_path(root_path)
+    manifests = []
+    
+    for path in manifest_paths:
+        normalized = _load_and_normalize(path, warn_only=warn_only)
+        if normalized:
+            manifests.append(normalized)
+    
+    return manifests
+
+
+def _get_port(manifest):
+    """Get the resource port from manifest."""
+    return manifest.get('port', MANIFEST_DEFAULTS['port'])
+
+
+def _get_database_url(manifest, host='localhost', port=5432):
+    """
+    Generate DATABASE_URL from manifest.
+    
+    Args:
+        manifest: Manifest dictionary
+        host: Database host (default: localhost)
+        port: Database port (default: 5432)
+        
+    Returns:
+        PostgreSQL connection string
+    """
+    db_name = manifest.get('databaseName', PlatformDockerConstants.get_db_name(manifest.get('stack', 'app')))
+    return PlatformDockerConstants.get_tilt_database_url_template().format(
+        host=host,
+        port=port,
+        db=db_name,
+    )
+
+
+def _print_summary(manifests):
+    """
+    Print formatted summary of loaded manifests.
+    
+    Args:
+        manifests: List of manifest dictionaries
+    """
+    print("")
+    print("📋 ═══════════════════════════════════════════════════════════════")
+    print("📋  LOADED MANIFESTS")
+    print("📋 ═══════════════════════════════════════════════════════════════")
+    
+    for m in manifests:
+        status = "✅" if not m.get('_synthesized') else "⚡"
+        app_name = m.get('appName', 'unknown')
+        app_type = m.get('appType', 'unknown')
+        port = m.get('port', 0)
+        stack = m.get('stack', 'unknown')
+        
+        print("   {status} {name} | {type} | Port: {port} | Stack: {stack}".format(
+            status=status,
+            name=app_name,
+            type=app_type,
+            port=port,
+            stack=stack,
+        ))
+    
+    print("📋 ═══════════════════════════════════════════════════════════════")
+    print("")
+
+
+def _generate_manifest_template(app_name, stack, app_type='backend', port=4000):
+    """
+    🎯 TEMPLATE GENERATOR: Returns a string with a standard manifest.
+    """
+    template = {
+        "$schema": "https://" + PlatformDockerConstants.EMAIL_DOMAIN + "/schemas/manifest-schema.json",
+        "appName": app_name,
+        "appType": app_type,
+        "stack": stack,
+        "port": port,
+        "replicas": 1,
+        "features": [MESSAGING, "infisical"],
+        "dependsOn": [],
+        "runtime": RUNTIME
+    }
+    return Utils.encode_json(template)
+
+
+def load_and_normalize(manifest_path, warn_only=True):
+    return _load_and_normalize(manifest_path, warn_only=warn_only)
+
+
+def discover_manifests_in_path(root_path):
+    return _discover_manifests_in_path(root_path)
+
+
+def load_all_manifests(root_path, warn_only=True):
+    return _load_all_manifests(root_path, warn_only=warn_only)
+
+
+def get_port(manifest):
+    return _get_port(manifest)
+
+
+def get_database_url(manifest, host='localhost', port=5432):
+    return _get_database_url(manifest, host=host, port=port)
+
+
+def print_summary(manifests):
+    return _print_summary(manifests)
+
+
+def generate_manifest_template(app_name, stack, app_type='backend', port=4000):
+    return _generate_manifest_template(app_name, stack, app_type=app_type, port=port)