flock-core 0.3.41__py3-none-any.whl → 0.4.0b1__py3-none-any.whl

flock/__init__.py

@@ -31,6 +31,37 @@ def main():
     from flock.core.util.cli_helper import init_console
 
     console = Console()
+
+    # Show a welcome message on first run with the new tool serialization format
+    import os
+
+    feature_flag_file = os.path.expanduser("~/.flock/tool_serialization_notice")
+    if not os.path.exists(feature_flag_file):
+        # Create the directory if it doesn't exist
+        os.makedirs(os.path.dirname(feature_flag_file), exist_ok=True)
+
+        # Show the notice about the new tool serialization
+        console.print(
+            Panel(
+                "[bold green]Flock 0.4.0b 'Magpie'- Flock CLI Management Console BETA[/]\n\n"
+                "Flock now offers a tool for managing your flock:\n"
+                "- Serialization and deserialization of Flock instances\n"
+                "- Execution of Flock instances\n"
+                "- Managing components, types, and agents via the registry management\n"
+                "- Starting a web server to interact with your flock\n"
+                "plannes featues: deployment on docker, kubernetes, and more!"
+            ),
+            justify="center",
+        )
+        console.line()
+
+        # Create the flag file to prevent showing this notice again
+        with open(feature_flag_file, "w") as f:
+            f.write("Tool serialization notice shown")
+
+        input("Press Enter to continue to the main menu...")
+        console.clear()
+
     while True:
         init_console()
 

flock/cli/create_flock.py

@@ -13,10 +13,12 @@ from rich.panel import Panel
 from flock.cli.loaded_flock_cli import start_loaded_flock_cli
 from flock.core.flock import Flock
 from flock.core.flock_factory import FlockFactory
+from flock.core.logging.logging import get_logger
 from flock.core.util.cli_helper import init_console
 
 # Create console instance
 console = Console()
+logger = get_logger("cli.create_flock")
 
 
 def create_flock():
@@ -212,9 +214,62 @@ def _save_flock_to_yaml(flock):
     save_path = Path(file_path)
     save_path.parent.mkdir(parents=True, exist_ok=True)
 
+    # Ask about path_type
+    path_type_choice = questionary.select(
+        "How should file paths be formatted?",
+        choices=[
+            "absolute (full paths, best for local use)",
+            "relative (relative paths, better for sharing)",
+        ],
+        default="absolute (full paths, best for local use)",
+    ).ask()
+
+    # Extract just the first word
+    path_type = path_type_choice.split()[0]
+
+    console.print(
+        f"[bold]Path type selected: [green]{path_type}[/green][/bold]"
+    )
+
     try:
-        # Save the Flock to YAML
-        flock.to_yaml_file(file_path)
-        console.print(f"\n[green]✓[/] Flock saved to {file_path}")
+        # Check if the flock has tools to provide a helpful message
+        has_tools = False
+        for agent in flock.agents.values():
+            if agent.tools and len(agent.tools) > 0:
+                has_tools = True
+                break
+
+        # Save the Flock to YAML with proper tool serialization
+        logger.info(f"Saving Flock to {file_path}")
+        flock.to_yaml_file(file_path, path_type=path_type)
+        console.print(
+            f"\n[green]✓[/] Flock saved to {file_path} with {path_type} paths"
+        )
+
+        # Provide helpful information about tool serialization
+        if has_tools:
+            console.print("\n[bold blue]Tools Information:[/]")
+            console.print(
+                "This Flock contains tools that have been serialized as callable references."
+            )
+            console.print(
+                "When loading this Flock on another system, ensure that:"
+            )
+            console.print(
+                "  - The tools/functions are registered in the Flock registry"
+            )
+            console.print(
+                "  - The containing modules are available in the Python path"
+            )
     except Exception as e:
+        logger.error(f"Error saving Flock: {e}", exc_info=True)
         console.print(f"\n[bold red]Error saving Flock:[/] {e!s}")
+
+        # Provide guidance on potential issues with tool serialization
+        if "callable" in str(e).lower() or "registry" in str(e).lower():
+            console.print(
+                "\n[yellow]This error might be related to tool serialization.[/]"
+            )
+            console.print(
+                "[yellow]Check if all tools are properly registered in the Flock registry.[/]"
+            )

flock/cli/load_flock.py

@@ -8,6 +8,9 @@ from rich.markdown import Markdown
 
 from flock.cli.loaded_flock_cli import start_loaded_flock_cli
 from flock.core.flock import Flock
+from flock.core.logging.logging import get_logger
+
+logger = get_logger("cli.load_flock")
 
 
 def filter(file_path) -> bool:
@@ -40,7 +43,42 @@ def load_flock():
         console.print(f"Selected file: {selected_file}", style="bold green")
 
         try:
-            flock = Flock.load_from_file(result)
+            # Try loading with detailed error handling
+            try:
+                logger.info(f"Attempting to load Flock from: {result}")
+                flock = Flock.load_from_file(result)
+            except ImportError as e:
+                # Handle missing module path errors
+                if "No module named" in str(e):
+                    console.print(
+                        f"[yellow]Warning: Module import failed: {e}[/]"
+                    )
+                    console.print(
+                        "[yellow]Trying file path fallback mechanism...[/]"
+                    )
+                    # Re-try loading with fallback
+                    flock = Flock.load_from_file(result)
+                else:
+                    raise  # Re-raise if it's not a missing module error
+            except KeyError as e:
+                # This could be caused by missing tool references
+                if "__callable_ref__" in str(e):
+                    console.print(
+                        f"[yellow]Warning: Tool reference error: {e}[/]"
+                    )
+                    console.print(
+                        "[yellow]This may be due to missing tool registrations. Attempting to scan for tools...[/]"
+                    )
+                    # Scan for tools and retry
+                    from flock.cli.registry_management import (
+                        auto_registration_scanner,
+                    )
+
+                    auto_registration_scanner()
+                    # Try loading again
+                    flock = Flock.load_from_file(result)
+                else:
+                    raise  # Re-raise if it's not a tool reference error
 
             console.line()
             console.print(
@@ -55,4 +93,100 @@ def load_flock():
 
         except Exception as e:
             console.print(f"Error loading Flock: {e!s}", style="bold red")
+            logger.error(f"Failed to load Flock: {e}", exc_info=True)
+
+            # Add more detailed error information for specific errors
+            if "No module named" in str(e):
+                console.print(
+                    "\n[yellow]This error might be due to missing module paths.[/]"
+                )
+                console.print(
+                    "[yellow]Component references may need to be updated with file paths.[/]"
+                )
+
+                # Show the option to scan the directory for components
+                fix_paths = questionary.confirm(
+                    "Would you like to scan directories for components to fix missing imports?",
+                    default=True,
+                ).ask()
+
+                if fix_paths:
+                    from flock.cli.registry_management import (
+                        auto_registration_scanner,
+                    )
+
+                    auto_registration_scanner()
+
+                    # Try loading again
+                    console.print(
+                        "\n[yellow]Attempting to load Flock again...[/]"
+                    )
+                    try:
+                        flock = Flock.load_from_file(result)
+                        console.line()
+                        console.print(
+                            Markdown(
+                                "# Flock loaded successfully after component scan"
+                            ),
+                            style="bold green",
+                        )
+                        console.line()
+
+                        start_loaded_flock_cli(
+                            flock, server_name=f"Flock - {selected_file.name}"
+                        )
+                        return
+                    except Exception as e2:
+                        console.print(
+                            f"Error loading Flock after scan: {e2!s}",
+                            style="bold red",
+                        )
+
+            # Handle tool reference issues
+            elif "__callable_ref__" in str(e) or "callable" in str(e).lower():
+                console.print(
+                    "\n[yellow]This error might be due to missing tool registrations.[/]"
+                )
+
+                # Show the option to scan the directory for tools
+                fix_tools = questionary.confirm(
+                    "Would you like to scan directories for tools to fix missing references?",
+                    default=True,
+                ).ask()
+
+                if fix_tools:
+                    from flock.cli.registry_management import (
+                        auto_registration_scanner,
+                    )
+
+                    console.print(
+                        "\n[yellow]Scanning for tools and callables...[/]"
+                    )
+                    auto_registration_scanner()
+
+                    # Try loading again
+                    console.print(
+                        "\n[yellow]Attempting to load Flock again...[/]"
+                    )
+                    try:
+                        flock = Flock.load_from_file(result)
+                        console.line()
+                        console.print(
+                            Markdown(
+                                "# Flock loaded successfully after tool scan"
+                            ),
+                            style="bold green",
+                        )
+                        console.line()
+
+                        start_loaded_flock_cli(
+                            flock, server_name=f"Flock - {selected_file.name}"
+                        )
+                        return
+                    except Exception as e2:
+                        console.print(
+                            f"Error loading Flock after tool scan: {e2!s}",
+                            style="bold red",
+                        )
+
             input("\nPress Enter to continue...")