@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/engine/topologies/tilt/resources/libs_paths.star

@@ -0,0 +1,81 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# =============================================================================
+# 📚 TILT SDK - LIBRARY PATHS & DEP MAPPINGS
+# =============================================================================
+
+load('../../../topologies/tilt/common/utils.star', 'Utils')
+
+
+def get_lib_path_from_package_name(ctx, package_name):
+    """
+    Converts @flisk/platform-logger -> shared-platform-engineering/platform-logger
+
+    Returns:
+        Tuple of (path, label, tilt_resource_name) or (None, None, None) if not a library
+    """
+    lib_info = Utils.resolve_lib_path(package_name)
+    lib_path = lib_info[0]
+    lib_type = lib_info[1]
+
+    if not lib_path:
+        return (None, None, None)
+
+    lib_name = package_name[len(Utils.INTERNAL_SCOPE):]
+    tilt_resource = 'lib-' + lib_name
+
+    label_map = {
+        'platform': 'lib.platform',
+        'product': 'lib.product',
+        'ddd': 'lib.ddd',
+    }
+    label = label_map.get(lib_type, 'lib.platform')
+
+    return (lib_path, label, tilt_resource)
+
+
+def read_package_json_deps(ctx, package_json_path):
+    """Reads a package.json and returns all internal dependencies."""
+    resource_path = package_json_path.rsplit('/package.json', 1)[0]
+    return Utils.get_internal_deps(resource_path)
+
+
+def get_resource_paths_for_focus(ctx, focus_enabled_all):
+    """Returns list of service paths based on focus mode targets."""
+    if focus_enabled_all == None:
+        return []
+
+    resource_path_map = ctx.get('resource_path_map', {})
+    resource_paths = []
+
+    for resource in focus_enabled_all:
+        if resource in resource_path_map:
+            path = resource_path_map[resource]
+            if path not in resource_paths:
+                resource_paths.append(path)
+
+    return resource_paths
+
+
+def get_internal_deps_mapping(ctx, resource_path):
+    """Returns a mapping of package_name -> source_path for internal dependencies."""
+    pkg_path = resource_path + '/package.json'
+    internal_deps = read_package_json_deps(ctx, pkg_path)
+
+    mapping = {}
+    for dep_name in internal_deps:
+        lib_info = get_lib_path_from_package_name(ctx, dep_name)
+        lib_path = lib_info[0]
+
+        if lib_path != None:
+            mapping[dep_name] = lib_path
+
+    return mapping
+
+
+LibsPaths = struct(
+    get_path = get_lib_path_from_package_name,
+    read_package_json_deps = read_package_json_deps,
+    get_resource_paths = get_resource_paths_for_focus,
+    get_deps_mapping = get_internal_deps_mapping,
+)

package/engine/topologies/tilt/resources/libs_resource_definition.star

@@ -0,0 +1,153 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# =============================================================================
+# 📦 TILT SDK - LIBRARY RESOURCE DEFINITION
+# =============================================================================
+
+load("../../platform/docker/constants.star", "PlatformDockerConstants")
+
+
+def _library_needs_vite(path):
+    """Check if a library needs a Vite config."""
+    pkg_content = read_file(path + '/package.json', default='')
+    if not pkg_content:
+        return False
+
+    pkg = decode_json(pkg_content)
+    if not pkg:
+        return False
+
+    deps = {}
+    for dep_type in ['dependencies', 'devDependencies', 'peerDependencies']:
+        deps.update(pkg.get(dep_type, {}))
+
+    needs_vite = 'vitest' in deps or 'vite-plugin-dts' in deps or 'vite' in deps
+    if needs_vite:
+        print("   🔍 Library at " + path + " needs Vite")
+    return needs_vite
+
+
+def _library_has_react(path):
+    """Check if a library has React components."""
+    pkg_content = read_file(path + '/package.json', default='')
+    if not pkg_content:
+        return False
+
+    pkg = decode_json(pkg_content)
+    if not pkg:
+        return False
+
+    deps = {}
+    for dep_type in ['dependencies', 'devDependencies', 'peerDependencies']:
+        deps.update(pkg.get(dep_type, {}))
+
+    return 'react' in deps or '@vitejs/plugin-react' in deps
+
+
+def _library_has_dts(path):
+    """Check if a library has vite-plugin-dts in dependencies."""
+    pkg_content = read_file(path + '/package.json', default='')
+    if not pkg_content:
+        return False
+
+    pkg = decode_json(pkg_content)
+    if not pkg:
+        return False
+
+    deps = {}
+    for dep_type in ['dependencies', 'devDependencies', 'peerDependencies']:
+        deps.update(pkg.get(dep_type, {}))
+
+    return 'vite-plugin-dts' in deps
+
+
+def library_is_frontend(path):
+    """Check if library is marked as frontend in manifest or has React."""
+    # Check library manifest (libraries use their own naming convention)
+    lib_name = path.split('/')[-1]
+    manifest_content = read_file(path + '/' + lib_name + '.manifest.json', default='')
+    
+    return _library_has_react(path)
+
+
+def define_library_resource(ctx, name, path, labels, internal_deps=None, consumer_paths=None, write_fn=None, generate_vite_fn=None):
+    """Defines a Tilt local_resource for a library with proper dependency management.
+
+    Args:
+        ctx: Tilt context with global_config, verdaccio_url, etc.
+        name: Library name
+        path: Path to library directory
+        labels: Labels for Tilt UI organization
+        internal_deps: Optional list of internal dependencies
+        consumer_paths: Optional list of consumer resource paths
+        write_fn: Optional write function for file generation
+        generate_vite_fn: Optional Vite config generator function
+
+    Returns:
+        str: Name of created Tilt resource
+    """
+    global_config = ctx.get('global_config', {})
+    registry = (
+        ctx.get('verdaccio_url_docker')
+        or global_config.get('verdaccio_url_docker')
+        or ctx.get('verdaccio_url_local')
+        or global_config.get('verdaccio_url_local')
+        or PlatformDockerConstants.VERDACCIO_URL_DOCKER
+    )
+    internal_scope = ctx.get('internal_scope', '@flisk/')
+    pkg_name = internal_scope + name
+
+    if write_fn and generate_vite_fn:
+        lib_manifest = {
+            'appName': name,
+            'appType': 'library',
+            '_servicePath': path,
+            'needsVite': True,
+            'hasReact': _library_has_react(path),
+            'hasDts': _library_has_dts(path),
+        }
+
+        if _library_needs_vite(path):
+            print("   📚 Generating vite.config.ts for library: " + name)
+            generate_vite_fn(lib_manifest, None, write_fn)
+
+    consumer_paths_str = ''
+    if consumer_paths:
+        consumer_paths_str = ','.join(consumer_paths)
+
+    publish_cmd = './engine/scripts/build-and-publish-lib.sh "' + path + '" "' + registry + '" "' + pkg_name + '" "' + consumer_paths_str + '"'
+
+    # Sanitize name to remove invalid characters for Tilt resource names
+    # e.g., "introvertic/ui" -> "introvertic-ui"
+    resource_name = 'lib-' + name.replace('/', '-')
+    auto_init_libs = os.environ.get('TILT_AUTO_INIT_LIBS', 'false').lower() == 'true'
+
+    deps = [PlatformDockerConstants.VERDACCIO_RESOURCE_NAME]
+    if internal_deps:
+        for dep in internal_deps:
+            if dep not in deps:
+                deps.append(dep)
+
+    input_deps = [
+        path + '/src',
+        path + '/package.json',
+        path + '/tsconfig.json',
+    ]
+
+    local_resource(
+        resource_name,
+        cmd=publish_cmd,
+        deps=input_deps,
+        labels=labels + ['lib'],
+        resource_deps=deps,
+        allow_parallel=True,
+        auto_init=auto_init_libs,
+    )
+
+    return resource_name
+
+
+LibsResourceDefinition = struct(
+    define_resource = define_library_resource,
+    is_frontend = library_is_frontend,
+)

package/engine/topologies/tilt/resources/libs_setup.star

@@ -0,0 +1,166 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# =============================================================================
+# 🚀 TILT SDK - LIBRARY SETUP ORCHESTRATOR
+# =============================================================================
+
+load('./libs_paths.star', 'LibsPaths')
+load('./libs_discovery.star', 'LibsDiscovery')
+load('./libs_resource_definition.star', 'LibsResourceDefinition')
+load('../../platform/docker/constants.star', 'PlatformDockerConstants')
+
+_get_lib_path_from_package_name = LibsPaths.get_path
+_read_package_json_deps = LibsPaths.read_package_json_deps
+_get_resource_paths_for_focus = LibsPaths.get_resource_paths
+_discover_resource_libraries = LibsDiscovery.discover_resource_libs
+_define_library_resource = LibsResourceDefinition.define_resource
+
+
+def setup_libraries(ctx, should_enable_fn, ddd_libs, platform_libs, product_libs, config_generators, focus_enabled_all=None):
+    """
+    Sets up library resources with dynamic dependency scanning.
+
+    Returns:
+        Dict mapping package_name -> tilt_resource_name
+    """
+    library_map = {}
+    internal_scope = ctx.get('internal_scope', '@flisk/')
+    library_roots = ctx.get('library_roots', {})
+    print("📚 setup_libraries called for " + str(len(platform_libs) + len(product_libs) + len(ddd_libs)) + " potential libraries")
+
+    generate_tsconfig = config_generators.get('tsconfig')
+    generate_npmrc = config_generators.get('npmrc')
+    generate_bunfig = config_generators.get('bunfig')
+    generate_vite = config_generators.get('vite')
+    write_fn = config_generators.get('write_fn')
+
+    if not should_enable_fn(PlatformDockerConstants.VERDACCIO_RESOURCE_NAME):
+        return library_map
+
+    if focus_enabled_all != None:
+        print("📚 Focus mode: Scanning service dependencies...")
+
+        resource_paths = _get_resource_paths_for_focus(ctx, focus_enabled_all)
+
+        if len(resource_paths) == 0:
+            print("   ⚠️  No service paths found for focus targets")
+            return library_map
+
+        print("   🔍 Scanning " + str(len(resource_paths)) + " services")
+
+        needed_libs = _discover_resource_libraries(ctx, resource_paths)
+
+        if len(needed_libs) == 0:
+            print("   ℹ️  No internal library dependencies found")
+            return library_map
+
+        platform_count = 0
+        product_count = 0
+        ddd_count = 0
+
+        for pkg_name, lib_info in needed_libs.items():
+            lib_name = lib_info['name']
+            lib_path = lib_info['path']
+            lib_label = lib_info['label']
+            tilt_resource = lib_info['tilt_resource']
+            internal_deps = lib_info.get('internal_deps', [])
+
+            lib_res_deps = []
+            lib_ts_deps = {}
+            for dep_pkg in internal_deps:
+                dep_info = _get_lib_path_from_package_name(ctx, dep_pkg)
+                if dep_info[2]:
+                    lib_res_deps.append(dep_info[2])
+                    lib_ts_deps[dep_pkg] = dep_info[0]
+
+            consumer_paths = []
+            for resource_path in resource_paths:
+                resource_internal_deps = _read_package_json_deps(ctx, resource_path + '/package.json')
+                if pkg_name in resource_internal_deps:
+                    consumer_paths.append(resource_path)
+
+            if generate_npmrc:
+                generate_npmrc(lib_path)
+            if generate_bunfig:
+                generate_bunfig(lib_path)
+            if generate_tsconfig:
+                generate_tsconfig(lib_path, lib_ts_deps)
+
+            _define_library_resource(
+                ctx,
+                lib_name,
+                lib_path,
+                [lib_label],
+                internal_deps=lib_res_deps,
+                consumer_paths=consumer_paths,
+                write_fn=write_fn,
+                generate_vite_fn=generate_vite,
+            )
+            library_map[pkg_name] = tilt_resource
+
+            if lib_label == 'lib.platform':
+                platform_count = platform_count + 1
+            elif lib_label == 'lib.product':
+                product_count = product_count + 1
+            elif lib_label == 'lib.ddd':
+                ddd_count = ddd_count + 1
+
+        print("   ✅ Discovered " + str(len(needed_libs)) + " libraries (platform: " + str(platform_count) + ", product: " + str(product_count) + ", ddd: " + str(ddd_count) + ")")
+
+    else:
+        all_libs_info = {}
+
+        for lib in ddd_libs:
+            pkg_name = internal_scope + lib['name']
+            lib_path = lib['path']
+            all_libs_info[pkg_name] = {'name': lib['name'], 'path': lib_path, 'label': 'lib.ddd'}
+
+        for lib_name in platform_libs:
+            pkg_name = internal_scope + lib_name
+            lib_path = library_roots.get('platform', 'shared-platform-engineering') + '/' + lib_name
+            all_libs_info[pkg_name] = {'name': lib_name, 'path': lib_path, 'label': 'lib.platform'}
+
+        for lib_name in product_libs:
+            pkg_name = internal_scope + lib_name
+            lib_path = library_roots.get('product', 'shared-product-engineering') + '/' + lib_name
+            all_libs_info[pkg_name] = {'name': lib_name, 'path': lib_path, 'label': 'lib.product'}
+
+        for pkg_name, lib_info in all_libs_info.items():
+            lib_name = lib_info['name']
+            lib_path = lib_info['path']
+            lib_label = lib_info['label']
+
+            internal_deps = _read_package_json_deps(ctx, lib_path + '/package.json')
+
+            lib_res_deps = []
+            lib_ts_deps = {}
+            for dep_pkg in internal_deps:
+                dep_info = _get_lib_path_from_package_name(ctx, dep_pkg)
+                if dep_info[2]:
+                    lib_res_deps.append(dep_info[2])
+                    lib_ts_deps[dep_pkg] = dep_info[0]
+
+            if generate_npmrc:
+                generate_npmrc(lib_path)
+            if generate_bunfig:
+                generate_bunfig(lib_path)
+            if generate_tsconfig:
+                generate_tsconfig(lib_path, lib_ts_deps)
+
+            _define_library_resource(
+                ctx,
+                lib_name,
+                lib_path,
+                [lib_label],
+                internal_deps=lib_res_deps,
+                write_fn=write_fn,
+                generate_vite_fn=generate_vite,
+            )
+            library_map[pkg_name] = 'lib-' + lib_name
+
+    return library_map
+
+
+LibsSetup = struct(
+    setup_all = setup_libraries,
+)

package/engine/topologies/tilt/resources/libs_tsconfig.star

@@ -0,0 +1,39 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# =============================================================================
+# 🎯 TILT SDK - LIBRARY TSCONFIG FACTORY
+# =============================================================================
+
+load('./libs_resource_definition.star', 'LibsResourceDefinition')
+
+_library_is_frontend = LibsResourceDefinition.is_frontend
+
+
+def make_smart_tsconfig_generator(tsconfig_provider, write_fn):
+    """
+    Factory function that creates a smart tsconfig generator.
+    Detects if a library is frontend (manifest or has React) and uses appropriate tsconfig.
+
+    Args:
+        tsconfig_provider: Provider with library_frontend and library_backend methods
+        write_fn: Write function for file output
+
+    Returns:
+        function: Config generator function taking (path, deps)
+    """
+    def generate_tsconfig(path, deps=None):
+        is_frontend = _library_is_frontend(path)
+
+        if is_frontend:
+            tsconfig_provider.library_frontend(path, write_fn, internal_deps=deps, is_docker=True)
+            tsconfig_provider.library_frontend(path, write_fn, internal_deps=deps, is_docker=False)
+        else:
+            tsconfig_provider.library_backend(path, write_fn, internal_deps=deps, is_docker=True)
+            tsconfig_provider.library_backend(path, write_fn, internal_deps=deps, is_docker=False)
+
+    return generate_tsconfig
+
+
+LibsTSConfig = struct(
+    make_smart_tsconfig = make_smart_tsconfig_generator,
+)

package/engine/topologies/tilt/resources/orchestrator/apply.star

@@ -0,0 +1,79 @@
+# Copyright (c) 2026 Flisk Landscape contributors
+# SPDX-License-Identifier: MIT
+# =============================================================================
+# 🎯 TILT SDK - ORCHESTRATOR APPLY
+# =============================================================================
+# Purpose: thin coordinator for service apply lifecycle.
+# =============================================================================
+
+load("../../common/utils_debug.star", "debug_log")
+load('../databases.star', 'Database')
+load('./apply_runtime_flags.star', 'RuntimeFlags')
+load('./apply_resource_validation.star', 'ResourceValidation')
+load('./apply_manifest_orchestration.star', 'ManifestOrchestration')
+load('./apply_compose_resource_registration.star', 'ComposeResourceRegistration', 'resource_needs_database')
+load('./apply_migrator_orchestration.star', 'MigratorOrchestration')
+
+
+def apply_app_service(resource_config, ctx):
+    """
+    Load and configure an application service by delegating each responsibility
+    to a focused orchestration module.
+    """
+    resource_name = resource_config.get('appName', resource_config.get('name', 'UNKNOWN'))
+    resource_path = resource_config.get('path', 'NO_PATH')
+    should_enable = ctx['should_enable']
+
+    # resource_config here is a STACK-level grouping from discovery_orchestrator.star
+    # (its own 'name'/'appName' is the stack, e.g. "auth") - the actual
+    # individual services live nested in resource_config['resources'], each
+    # with its own 'name' (e.g. "auth-api-backend"). flisk stack/flisk project -
+    # the CLI's own standard scaffolding - populates spec.master's
+    # PRE_ALPHA_RESOURCES etc. keyed by individual SERVICE name, not stack
+    # name. Checking should_enable() only at the stack level silently drops
+    # every service whose stack name isn't itself individually enabled, even
+    # when the service is - which is the common case for any project using
+    # the CLI's normal `flisk resource` + `flisk stack` workflow. Fall back to
+    # checking each nested service name before giving up on this group.
+    stack_enabled = should_enable(resource_name)
+    service_enabled = False
+    if not stack_enabled:
+        for nested in resource_config.get('resources', []):
+            nested_name = nested.get('name', '')
+            if nested_name and should_enable(nested_name):
+                debug_log("APPLY: stack '{}' not individually enabled, but nested service '{}' is - proceeding".format(resource_name, nested_name))
+                service_enabled = True
+                break
+
+    if not stack_enabled and not service_enabled:
+        return
+
+    runtime_flags = RuntimeFlags.resolve()
+    ctx['auto_init_config_gen'] = runtime_flags['auto_init_config_gen']
+
+    ResourceValidation.validate(resource_config)
+
+    # Provision the database when a resource receives DATABASE_URL (backend or bring-your-own), not for frontends only.
+    has_backend = False
+    for resource in resource_config.get('resources', []):
+        if resource_needs_database(resource.get('_manifest', {})):
+            has_backend = True
+            break
+    
+    if should_enable('database-management') and has_backend:
+        Database.provision(resource_name)
+
+    manifest_state = ManifestOrchestration.prepare(resource_config, ctx)
+    compose_state = ComposeResourceRegistration.register(
+        resource_config,
+        ctx,
+        runtime_flags,
+        manifest_state,
+    )
+
+    MigratorOrchestration.register(
+        resource_config,
+        ctx,
+        runtime_flags,
+        compose_state['compose_project_name'],
+    )