sibi-flux 2026.1.5__tar.gz → 2026.1.6__tar.gz

{sibi_flux-2026.1.5 → sibi_flux-2026.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sibi-flux
-Version: 2026.1.5
+Version: 2026.1.6
 Summary: Sibi Toolkit: A collection of tools for Data Analysis/Engineering.
 Author: Luis Valverde
 Author-email: Luis Valverde <lvalverdeb@gmail.com>
@@ -52,30 +52,10 @@ Description-Content-Type: text/markdown
 
 **SibiFlux** is a production-grade resilient data engineering ecosystem designed to bridge the gap between local development, distributed computing, and agentic AI workflows. It provides a unified engine for hybrid data loading (batch + streaming), self-healing distributed operations, and native interfaces for AI agents via the Model Context Protocol (MCP).
 
-```mermaid
-graph TD
-    subgraph G1["Agentic Interface (MCP)"]
-        Agent["AI Agent / Claude"] <--> Router["MCP Router"]
-        Router <--> Resources["SibiFlux Resources"]
-    end
-
-    subgraph G2["Solutions Layer (Business Logic)"]
-        Logistics["Logistics Solutions"]
-        Enrichment["Enrichment Pipelines"]
-        Cubes["DataCubes"]
-    end
-
-    subgraph G3["SibiFlux Core Engine"]
-        DfHelper["DfHelper (Unified Loader)"]
-        Cluster["Resilient Dask Cluster"]
-        Managed["ManagedResource Lifecycle"]
-    end
-
-    Resources --> Cubes
-    Logistics --> DfHelper
-    Cubes --> DfHelper
-    DfHelper --> Cluster
-```
+
+
+## Documentation
+Full documentation is available in [src/docs/index.md](src/docs/index.md).
 
 ## Core Architecture
 

{sibi_flux-2026.1.5 → sibi_flux-2026.1.6}/README.md

@@ -2,30 +2,10 @@
 
 **SibiFlux** is a production-grade resilient data engineering ecosystem designed to bridge the gap between local development, distributed computing, and agentic AI workflows. It provides a unified engine for hybrid data loading (batch + streaming), self-healing distributed operations, and native interfaces for AI agents via the Model Context Protocol (MCP).
 
-```mermaid
-graph TD
-    subgraph G1["Agentic Interface (MCP)"]
-        Agent["AI Agent / Claude"] <--> Router["MCP Router"]
-        Router <--> Resources["SibiFlux Resources"]
-    end
-
-    subgraph G2["Solutions Layer (Business Logic)"]
-        Logistics["Logistics Solutions"]
-        Enrichment["Enrichment Pipelines"]
-        Cubes["DataCubes"]
-    end
-
-    subgraph G3["SibiFlux Core Engine"]
-        DfHelper["DfHelper (Unified Loader)"]
-        Cluster["Resilient Dask Cluster"]
-        Managed["ManagedResource Lifecycle"]
-    end
-
-    Resources --> Cubes
-    Logistics --> DfHelper
-    Cubes --> DfHelper
-    DfHelper --> Cluster
-```
+
+
+## Documentation
+Full documentation is available in [src/docs/index.md](src/docs/index.md).
 
 ## Core Architecture
 

{sibi_flux-2026.1.5 → sibi_flux-2026.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sibi-flux"
-version = "2026.1.5"
+version = "2026.1.6"
 description = "Sibi Toolkit: A collection of tools for Data Analysis/Engineering."
 readme = "README.md"
 authors = [
@@ -127,6 +127,21 @@ dc-scan = "python solutions/generators/datacubes/gen_dc.py scan"
 dc-match = "python solutions/generators/datacubes/gen_dc.py match"
 dc-map = "python solutions/generators/datacubes/gen_dc.py map"
 
+# --- Internal Snapshot Tasks ---
+_test_snapshots_core = "python tests/solutions/gendatacubes/test_snapshots.py"
+_test_snapshots_cli = "python tests/solutions/gendatacubes/test_cli_snapshot.py"
+_test_snapshots_env = "python tests/solutions/init/test_env_generator_snapshots.py"
+_test_snapshots_rules = "python tests/solutions/init/test_rule_engine_snapshots.py"
+
+[tool.poe.tasks.test-snapshots]
+help = "Run all regression snapshot tests"
+sequence = ["_test_snapshots_core", "_test_snapshots_cli", "_test_snapshots_env", "_test_snapshots_rules"]
+
+[tool.poe.tasks.update-snapshots]
+help = "Update all regression snapshots (Golden Masters)"
+sequence = ["_test_snapshots_core", "_test_snapshots_cli", "_test_snapshots_env", "_test_snapshots_rules"]
+env = { UPDATE_SNAPSHOTS = "1" }
+
 [tool.poe.tasks.release]
 sequence = ["build","publish"]
 envfile = ".env"  # Loads the token for the whole sequence

{sibi_flux-2026.1.5 → sibi_flux-2026.1.6}/src/sibi_flux/cli.py

@@ -34,6 +34,42 @@ def init(
     initialize_project(project_name, lib, app)
 
 
+@app.command()
+def create_app(
+    name: str = typer.Argument(..., help="Name of the application to create"),
+):
+    """
+    Create a new application within an existing Sibi Flux project.
+    
+    Generates standard directory structure in `<project_root>/<name>`.
+    """
+    from sibi_flux.init.app import init_app
+    init_app(name)
+
+
+@app.command()
+def create_cubes(
+    app_name: str = typer.Argument(..., help="Name of the application"),
+):
+    """
+    Generate app-specific Datacube extensions from `<app_name>/datacubes/datacubes.yaml`.
+    """
+    from sibi_flux.init.cube_extender import create_cubes
+    create_cubes(app_name)
+
+
+@app.command()
+def propose_cubes(
+    db_domain: str = typer.Argument(..., help="Database domain to filter by (e.g., 'ibis_dev')"),
+    app_name: str = typer.Argument(..., help="Name of the target application"),
+):
+    """
+    Scan global registry for datacubes in <db_domain> and add them to <app_name>/datacubes/datacubes.yaml.
+    """
+    from sibi_flux.init.cube_proposer import propose_cubes
+    propose_cubes(db_domain, app_name)
+
+
 @app.command()
 def env(
     project_path: Path = typer.Argument(Path("."), help="Project root directory"),

{sibi_flux-2026.1.5 → sibi_flux-2026.1.6}/src/sibi_flux/datacube/cli.py

@@ -258,6 +258,42 @@ def sync(
 
     # Start with empty/default registry
     config_data = _load_and_resolve_config(config_path)
+
+    # Load existing Global Registry to preserve manual edits (e.g. custom_name)
+    # We must flatten the grouped structure (by config object) into a single tables dict
+    params = context.params or {}
+    reg_rel_path = params.get("paths", {}).get("repositories", {}).get(
+        "global_datacube_registry_file"
+    ) or params.get("global_datacube_registry_file")
+
+    if reg_rel_path:
+        reg_file = Path(reg_rel_path)
+        if not reg_file.is_absolute():
+            try:
+                # Heuristic: config_path is in generators/datacubes/, project root is 3 levels up
+                prj_root = config_path.parent.parent.parent
+                reg_file = prj_root / reg_rel_path
+            except Exception:
+                reg_file = Path.cwd() / reg_rel_path
+        
+        if reg_file.exists():
+            try:
+                with open(reg_file, "r") as rf:
+                    existing_reg_data = yaml.safe_load(rf) or {}
+                
+                flat_tables = {}
+                for grp, tbls in existing_reg_data.items():
+                    if isinstance(tbls, dict):
+                        for t, t_meta in tbls.items():
+                            # Inject the config object (group key) so DatacubeRegistry knows the connection
+                            t_meta["connection_obj"] = grp
+                            flat_tables[t] = t_meta
+                
+                config_data["tables"] = flat_tables
+                console.print(f"[dim]Loaded {len(flat_tables)} existing registry entries for merge preservation.[/dim]")
+            except Exception as e:
+                console.print(f"[yellow]Warning: Could not load existing registry: {e}[/yellow]")
+
     registry = DatacubeRegistry(config_data, params=context.params)
 
     # --- Aggregation Phase ---
@@ -378,9 +414,16 @@ def sync(
             imp = [db_imp] if db_imp else registry.global_imports
             return resolve_db_url(conf_name, imp)
 
-        _run_field_map_generation(
+        generated_maps = _run_field_map_generation(
             context, config_path, databases, get_url_safe, force=force
         )
+
+        if generated_maps:
+            for table_name, mod_path in generated_maps.items():
+                if table_name in registry.tables:
+                    # console.print(f"[green]DEBUG: Updating {table_name} with field_map {mod_path}[/green]")
+                    registry.tables[table_name]["field_map"] = mod_path
+
         # Ensure new modules are picked up
         importlib.invalidate_caches()
 
@@ -533,11 +576,18 @@ def sync(
             if conf_obj not in generated_registry:
                 generated_registry[conf_obj] = {}
 
-            generated_registry[conf_obj][t_name] = {
+            # Preserve custom_name from existing registry if present
+            existing_meta = registry.get_table_details(t_name)
+            custom_name = existing_meta.get("custom_name")
+
+            entry_data = {
                 "class_name": cls_n,
                 "path": str(rel_path),
+                "custom_name": custom_name,
             }
 
+            generated_registry[conf_obj][t_name] = entry_data
+
     console.print(summary_table)
 
     # --- Write Datacube Registry ---
@@ -1904,6 +1954,9 @@ def whitelist(
             # Merge: update rule defaults only if not set in existing
             merged = rule_meta.copy()
             merged.update(existing_meta)  # Existing overwrites rule
+            
+            # Legacy Cleanup: We moved custom_name to Registry
+            merged.pop("custom_name", None)
 
             # Restore calculated paths (Enforce Relative)
             if "datacube_path" in rule_meta:
@@ -2099,6 +2152,8 @@ def _run_field_map_generation(
                 "[yellow]Warning: Could not determine global field_maps_dir for clean build.[/yellow]"
             )
 
+    generated_maps = {}
+    
     for db in target_dbs:
         # console.print(f"DEBUG: Processing DB entry: {db} (Type: {type(db)})")
         if isinstance(db, str):
@@ -2223,10 +2278,6 @@ def _run_field_map_generation(
             if not found:
                 rules = []
 
-        # console.print(f"DEBUG: Loaded {len(rules)} rules from {rules_path} for {conn_obj}")
-
-        # console.print(f"DEBUG: Loaded {len(rules)} rules from {rules_path}")
-
         # Support List or Dict Format
         scoped_data = registry_data.get(conn_obj, {})
         if isinstance(scoped_data, list):
@@ -2448,6 +2499,21 @@ def _run_field_map_generation(
                     with open(target_file, "w") as f:
                         f.write("\n".join(lines))
 
+                    # Calculate Import Path
+                    try:
+                        # Ensure we get relative path to project root (which should be sys.path root)
+                        if "project_root" not in locals():
+                            project_root = Path.cwd()
+                        
+                        rel_py_path = target_file.relative_to(project_root)
+                        module_path = str(rel_py_path.with_suffix("")).replace("/", ".")
+                        generated_maps[table_name] = f"{module_path}.field_map"
+                    except ValueError:
+                        # Fallback if outside project root?
+                        pass
+                    except Exception as e:
+                        pass
+
                 except Exception as e:
                     console.print(f"[red]Error processing {table_name}: {e}[/red]")
                     continue
@@ -2464,6 +2530,8 @@ def _run_field_map_generation(
     except Exception as e:
         console.print(f"[red]Failed to save Global Field Repository: {e}[/red]")
 
+    return generated_maps
+
 
 if __name__ == "__main__":
     app()

{sibi_flux-2026.1.5 → sibi_flux-2026.1.6}/src/sibi_flux/datacube/generator.py

@@ -531,6 +531,15 @@ class DatacubeRegistry:
             or self.config.get("class_suffix")
             or self.params.get("class_suffix", "Dc")
         )
+        self._enforce_custom_names()
+
+    def _enforce_custom_names(self) -> None:
+        """
+        Ensures that if custom_name is set, it overrides class_name explicitly.
+        """
+        for table, meta in self.tables.items():
+            if meta.get("custom_name"):
+                meta["class_name"] = meta["custom_name"]
 
     def get_table_details(self, table_name: str) -> dict[str, Any]:
         return self.tables.get(table_name, {})
@@ -573,7 +582,10 @@ class DatacubeRegistry:
                     elif k not in existing:
                         existing[k] = v
 
-                if "class_name" not in existing:
+                # Override class_name if custom_name is set
+                if existing.get("custom_name"):
+                    existing["class_name"] = existing["custom_name"]
+                elif "class_name" not in existing:
                     existing["class_name"] = new_details.get("class_name")
 
                 self.tables[table] = existing

{sibi_flux-2026.1.5 → sibi_flux-2026.1.6}/src/sibi_flux/datacube/orchestrator.py

@@ -554,8 +554,23 @@ class DiscoveryOrchestrator:
                 "[yellow]Prune active: Registry replaced with discovery results.[/]"
             )
         else:
-            # Merge: Update existing keys, add new ones.
-            current_data["tables"].update(new_entries)
+            # Smart Merge: Preserve 'custom_name' and 'class_name' from existing entries
+            # if they are not explicitly overridden by the new entry.
+            for table, new_meta in new_entries.items():
+                if table in current_data["tables"]:
+                    existing = current_data["tables"][table]
+                    
+                    # 1. Preserve custom_name if new entry doesn't specify one
+                    if not new_meta.get("custom_name") and existing.get("custom_name"):
+                        new_meta["custom_name"] = existing["custom_name"]
+                        
+                        # 2. Also preserve class_name (since it's driven by custom_name)
+                        # We only preserve class_name if custom_name was preserved 
+                        # AND new entry didn't explicitly change class_name logic (unlikely unless configured)
+                        if existing.get("class_name"):
+                            new_meta["class_name"] = existing["class_name"]
+
+                current_data["tables"][table] = new_meta
 
         # Sort tables for readability
         current_data["tables"] = dict(sorted(current_data["tables"].items()))

sibi_flux-2026.1.6/src/sibi_flux/init/app.py

@@ -0,0 +1,111 @@
+
+from pathlib import Path
+import os
+from rich.console import Console
+import typer
+import yaml
+
+console = Console()
+
+def init_app(name: str) -> None:
+    """
+    Initialize a new application within the current project root.
+    
+    Args:
+        name: The name of the application to create (e.g., 'inventory', 'pricing').
+    """
+    
+    # 1. Validation: Ensure we are in a Sibi Flux project root (check for pyproject.toml as heuristic)
+    cwd = Path(os.getcwd())
+    if not (cwd / "pyproject.toml").exists():
+         console.print("[yellow]Warning: pyproject.toml not found. Are you in a project root?[/yellow]")
+    
+    app_dir = cwd / name
+    
+    if app_dir.exists():
+        console.print(f"[red]Error: Application directory '{name}' already exists.[/red]")
+        raise typer.Exit(code=1)
+        
+    console.print(f"[bold blue]Initializing new application: {name}[/bold blue]")
+    
+    # 2. Create Directory Structure
+    structure = [
+        "api",
+        "datacubes",
+        "readers",
+        "aggregators",
+    ]
+    
+    app_dir.mkdir()
+    (app_dir / "__init__.py").touch()
+    
+    for folder in structure:
+        path = app_dir / folder
+        path.mkdir()
+        (path / "__init__.py").touch()
+        
+    # 2.1 Create datacubes extension registry template
+    datacubes_yaml = app_dir / "datacubes" / "datacubes.yaml"
+    template_yaml = """
+cubes:
+  # Define your app-specific datacube extensions here
+  # - source: dataobjects.gencubes.ibis_dev.products.products_cubes.ProductsDc
+  #   name: LogisticsProductsDc
+  #   module: products  # -> logistics/datacubes/products.py
+"""
+    datacubes_yaml.write_text(template_yaml.strip())
+        
+    # 3. Create Basic Router Template
+    router_template = f"""
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/")
+async def root():
+    return {{"message": "Hello from {name}!"}}
+"""
+    (app_dir / "api" / "main.py").write_text(router_template.strip())
+    
+    # 4. Register in conf/apps.yaml
+    conf_dir = cwd / "conf"
+    if not conf_dir.exists():
+        conf_dir.mkdir()
+    
+    apps_yaml_path = conf_dir / "apps.yaml"
+    
+    apps_data = {"apps": []}
+    if apps_yaml_path.exists():
+        try:
+            with open(apps_yaml_path, "r") as f:
+                loaded = yaml.safe_load(f)
+                if loaded and isinstance(loaded, dict) and "apps" in loaded:
+                    apps_data = loaded
+                elif loaded is None:
+                     pass # empty file
+                else:
+                    console.print(f"[yellow]Warning: conf/apps.yaml has unexpected structure. Initializing with empty list.[/yellow]")
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not read existing apps.yaml: {e}[/yellow]")
+    
+    if name not in apps_data["apps"]:
+        apps_data["apps"].append(name)
+        with open(apps_yaml_path, "w") as f:
+            yaml.dump(apps_data, f, default_flow_style=False)
+        console.print(f"[green]Registered '{name}' in conf/apps.yaml[/green]")
+    else:
+         console.print(f"[yellow]App '{name}' already registered in conf/apps.yaml[/yellow]")
+
+    # 5. Success Message & Instructions
+    console.print(f"[bold green]Successfully created application '{name}'![/bold green]")
+    console.print(f"Location: {name}/")
+    console.print("\n[yellow]Next Steps:[/yellow]")
+    console.print(f"1. Register your new router in [bold]main.py[/bold] (or wherever your app is defined):")
+    
+    code_snippet = f"""
+    from {name}.api.main import router as {name}_router
+    
+    app.include_router({name}_router, prefix="/{name}", tags=["{name}"])
+    """
+    console.print(code_snippet)
+    

sibi_flux-2026.1.6/src/sibi_flux/init/cube_extender.py

@@ -0,0 +1,149 @@
+
+import yaml
+from pathlib import Path
+import os
+from typing import List, Dict, Any
+from rich.console import Console
+import typer
+import importlib.util
+import sys
+
+console = Console()
+
+def create_cubes(app_name: str) -> None:
+    """
+    Generate app-specific Datacube extensions based on local configuration.
+    
+    Args:
+        app_name: The name of the application (must exist in project root).
+    """
+    cwd = Path(os.getcwd())
+    
+    # 1. Validate App Directory
+    app_dir = cwd / app_name
+    if not app_dir.exists() or not app_dir.is_dir():
+        console.print(f"[red]Error: Application directory '{app_name}' not found.[/red]")
+        raise typer.Exit(code=1)
+        
+    datacubes_dir = app_dir / "datacubes"
+    if not datacubes_dir.exists():
+        console.print(f"[yellow]Creating 'datacubes' directory for {app_name}...[/yellow]")
+        datacubes_dir.mkdir(parents=True, exist_ok=True)
+        (datacubes_dir / "__init__.py").touch()
+        
+    # 2. Load Registry (datacubes.yaml)
+    registry_path = datacubes_dir / "datacubes.yaml"
+    if not registry_path.exists():
+        console.print(f"[red]Error: Registry file not found at {registry_path}[/red]")
+        console.print("Please define your extensions in this file first.")
+        # Create a template if missing?
+        template = """
+cubes:
+  # - source: dataobjects.gencubes.ibis_dev.products.products_cubes.ProductsDc
+  #   name: LogisticsProductsDc
+  #   module: products
+"""
+        registry_path.write_text(template.strip())
+        console.print(f"[green]Created template at {registry_path}. Edit it and run again.[/green]")
+        raise typer.Exit(code=1)
+        
+    try:
+        with open(registry_path, "r") as f:
+            config = yaml.safe_load(f)
+    except Exception as e:
+        console.print(f"[red]Error parsing {registry_path}: {e}[/red]")
+        raise typer.Exit(code=1)
+        
+    if not config or "cubes" not in config or not isinstance(config["cubes"], list):
+        console.print(f"[yellow]Warning: No 'cubes' list found in {registry_path}.[/yellow]")
+        return
+
+    # 3. Group by Module
+    from collections import defaultdict
+    cubes_by_module = defaultdict(list)
+    for entry in config["cubes"]:
+        mod = entry.get("module")
+        if mod:
+            cubes_by_module[mod].append(entry)
+
+    console.print(f"[bold blue]Processing {len(config['cubes'])} datacube extensions across {len(cubes_by_module)} modules...[/bold blue]")
+    
+    for module_name, entries in cubes_by_module.items():
+        process_module_group(module_name, entries, datacubes_dir, app_name)
+
+
+def process_module_group(module_name: str, entries: List[Dict[str, Any]], datacubes_dir: Path, app_name: str) -> None:
+    target_file = datacubes_dir / f"{module_name}.py"
+    
+    # Read existing content if file exists
+    existing_content = ""
+    if target_file.exists():
+        existing_content = target_file.read_text()
+    
+    new_imports = set()
+    new_classes = []
+    
+    for entry in entries:
+        source_path = entry.get("source")
+        class_name = entry.get("name")
+        
+        if not all([source_path, class_name]):
+            console.print(f"[red]Skipping invalid entry in {module_name}: {entry}[/red]")
+            continue
+
+        # Check for idempotency: does class definition already exist?
+        if f"class {class_name}" in existing_content:
+            console.print(f"[dim]Skipping {class_name} (already exists in {module_name}.py)[/dim]")
+            continue
+            
+        # Parse Source
+        try:
+            source_module_str, source_class = source_path.rsplit(".", 1)
+        except ValueError:
+            console.print(f"[red]Invalid source format '{source_path}' for {class_name}[/red]")
+            continue
+            
+        # Prepare Import
+        import_stmt = f"from {source_module_str} import {source_class}"
+        
+        # Check if import exists in file or is already queued
+        if import_stmt not in existing_content:
+            new_imports.add(import_stmt)
+            
+        # Prepare Class
+        class_code = f"""
+class {class_name}({source_class}):
+    \"\"\"
+    App-specific extension of {source_class} for '{app_name}'.
+    
+    Source: {source_path}
+    \"\"\"
+    pass
+"""
+        new_classes.append(class_code.strip())
+        console.print(f"[green]Queued generation for {class_name}[/green]")
+
+    if new_classes:
+        mode = "a" if target_file.exists() else "w"
+        
+        content_parts = []
+        
+        # Add imports first
+        if new_imports:
+            sorted_imports = sorted(list(new_imports))
+            content_parts.extend(sorted_imports)
+            content_parts.append("") # Spacer
+            
+        # Add classes
+        content_parts.extend(new_classes)
+        
+        with open(target_file, mode) as f:
+            if mode == "a" and existing_content.strip():
+                f.write("\n\n") # Ensure separation from previous content
+            
+            f.write("\n\n".join(content_parts))
+            f.write("\n")
+            
+        console.print(f"[green]Updated {target_file.name} with {len(new_classes)} new classes.[/green]")
+    else:
+        console.print(f"[dim]No changes needed for {target_file.name}[/dim]")

sibi_flux-2026.1.6/src/sibi_flux/init/cube_proposer.py

@@ -0,0 +1,134 @@
+
+import yaml
+from pathlib import Path
+import os
+from typing import List, Dict, Any
+from rich.console import Console
+import typer
+import sys
+
+console = Console()
+
+def propose_cubes(db_domain: str, app_name: str) -> None:
+    """
+    Scans the global datacube registry for cubes matching 'db_domain'
+    and adds them to the app's datacubes.yaml.
+    
+    Args:
+        db_domain: The database domain / folder name to filter by (e.g., 'ibis_dev', 'istmo360n').
+        app_name: The name of the target application.
+    """
+    cwd = Path(os.getcwd())
+    
+    # 1. Validate App Directory
+    app_dir = cwd / app_name
+    if not app_dir.exists() or not app_dir.is_dir():
+        console.print(f"[red]Error: Application directory '{app_name}' not found.[/red]")
+        raise typer.Exit(code=1)
+        
+    datacubes_dir = app_dir / "datacubes"
+    datacubes_dir.mkdir(parents=True, exist_ok=True) # Ensure exists
+    
+    registry_path = datacubes_dir / "datacubes.yaml"
+    
+    # 2. Locate Global Registry
+    # Heuristic: dataobjects/globals/datacube_registry.yaml
+    global_reg_path = cwd / "dataobjects/globals/datacube_registry.yaml"
+    
+    if not global_reg_path.exists():
+         console.print(f"[red]Error: Global registry not found at {global_reg_path}[/red]")
+         console.print("Run 'uv run sibi-flux dc sync' first to generate the registry.")
+         raise typer.Exit(code=1)
+         
+    try:
+        with open(global_reg_path, "r") as f:
+            global_data = yaml.safe_load(f)
+    except Exception as e:
+        console.print(f"[red]Error parsing global registry: {e}[/red]")
+        raise typer.Exit(code=1)
+        
+    if not global_data:
+        console.print("[yellow]Global registry is empty.[/yellow]")
+        return
+
+    # 3. Find Matches
+    matches = []
+    
+    # Registry Structure: {conf_obj: {table_name: {class_name: ..., path: ...}}}
+    for conf_obj, tables in global_data.items():
+        for table_name, meta in tables.items():
+            path_str = meta.get("path", "")
+            class_name = meta.get("class_name")
+            
+            # Check if domain matches path logic
+            # e.g. path="dataobjects/gencubes/istmo360n/..." and db_domain="istmo360n"
+            if db_domain in path_str.split("/"):
+                # Clean source path for python import
+                # "dataobjects/gencubes/..." -> "dataobjects.gencubes...."
+                # remove extension .py
+                module_path = path_str.replace("/", ".").rstrip(".py")
+                source_path = f"{module_path}.{class_name}"
+                
+                # Determine target module name (the last part of the path directory?)
+                # e.g. .../biometric/biometric_cubes.py -> "biometric"
+                try:
+                    # heuristic: parent dir name or filename base?
+                    # path: dataobjects/gencubes/istmo360n/biometric/biometric_cubes.py
+                    # logical group: biometric
+                    
+                    p = Path(path_str)
+                    module_group = p.parent.name # biometric
+                    if module_group == db_domain:
+                         # fallback if nested directly under domain
+                         module_group = p.stem.replace("_cubes", "")
+                         
+                except Exception:
+                    module_group = "common"
+                
+                matches.append({
+                    "source": source_path,
+                    "name": f"{app_name.capitalize()}{class_name}", # Default naming: App + Class
+                    "module": module_group,
+                    "original_class": class_name
+                })
+    
+    if not matches:
+        console.print(f"[yellow]No datacubes found for domain '{db_domain}' in registry.[/yellow]")
+        return
+        
+    console.print(f"[green]Found {len(matches)} matching datacubes.[/green]")
+    
+    # 4. Update App Registry
+    
+    # Load existing
+    current_config = {"cubes": []}
+    if registry_path.exists():
+        try:
+            with open(registry_path, "r") as f:
+                loaded = yaml.safe_load(f)
+                if loaded and "cubes" in loaded:
+                    current_config = loaded
+        except Exception:
+            pass
+            
+    # Deduplicate
+    existing_sources = {c.get("source") for c in current_config["cubes"]}
+    added_count = 0
+    
+    for m in matches:
+        if m["source"] not in existing_sources:
+            entry = {
+                "source": m["source"],
+                "name": m["name"],
+                "module": m["module"]
+            }
+            current_config["cubes"].append(entry)
+            existing_sources.add(m["source"])
+            added_count += 1
+            
+    # Save
+    with open(registry_path, "w") as f:
+        yaml.dump(current_config, f, sort_keys=False)
+        
+    console.print(f"[bold green]Added {added_count} new entries to {registry_path}[/bold green]")
+    console.print(f"Next: Run [blue]uv run sibi-flux create-cubes {app_name}[/blue] to generate code.")