flock-core 0.3.30__py3-none-any.whl → 0.3.31__py3-none-any.whl

flock/__init__.py

@@ -1,10 +1,11 @@
 """Flock package initialization."""
 
+from rich.panel import Panel
+
 from flock.cli.constants import CLI_EXIT, CLI_NOTES, CLI_THEME_BUILDER
 from flock.cli.load_release_notes import load_release_notes
-from flock.core.logging.formatters.theme_builder import theme_builder
 from flock.cli.settings import settings_editor
-from rich.panel import Panel
+from flock.core.logging.formatters.theme_builder import theme_builder
 
 
 def main():
@@ -19,7 +20,6 @@ def main():
         CLI_LOAD_EXAMPLE,
         CLI_LOAD_FLOCK,
         CLI_SETTINGS,
-        CLI_START_ADVANCED_MODE,
         CLI_START_WEB_SERVER,
     )
     from flock.cli.load_flock import load_flock
@@ -29,8 +29,10 @@ def main():
     while True:
         init_console()
 
-        #console.print("Flock Management Console\n", style="bold green")
-        console.print(Panel("[bold green]Flock Management Console[/]"), justify="center")
+        # console.print("Flock Management Console\n", style="bold green")
+        console.print(
+            Panel("[bold green]Flock Management Console[/]"), justify="center"
+        )
         console.line()
 
         result = questionary.select(
@@ -38,7 +40,7 @@ def main():
             choices=[
                 questionary.Separator(line=" "),
                 # CLI_CREATE_AGENT,
-                # CLI_CREATE_FLOCK,
+                CLI_CREATE_FLOCK,
                 # CLI_LOAD_AGENT,
                 CLI_LOAD_FLOCK,
                 # CLI_LOAD_EXAMPLE,
@@ -46,7 +48,6 @@ def main():
                 CLI_THEME_BUILDER,
                 CLI_SETTINGS,
                 questionary.Separator(),
-                CLI_START_ADVANCED_MODE,
                 CLI_START_WEB_SERVER,
                 questionary.Separator(),
                 CLI_NOTES,
@@ -56,13 +57,24 @@ def main():
 
         if result == CLI_LOAD_FLOCK:
             load_flock()
-        if result == CLI_THEME_BUILDER:
+        elif result == CLI_CREATE_FLOCK:
+            # This will be implemented in a separate create_flock.py
+            from flock.cli.create_flock import create_flock
+
+            create_flock()
+        elif result == CLI_THEME_BUILDER:
             theme_builder()
-        if result == CLI_SETTINGS:
+        elif result == CLI_SETTINGS:
             settings_editor()
-        if result == CLI_NOTES:
+        elif result == CLI_START_WEB_SERVER:
+            # Simple web server without a loaded Flock - could create a new one
+            console.print(
+                "[yellow]Web server without loaded Flock not yet implemented.[/]"
+            )
+            input("\nPress Enter to continue...")
+        elif result == CLI_NOTES:
             load_release_notes()
-        if result == CLI_EXIT:
+        elif result == CLI_EXIT:
             break
         input("\nPress Enter to continue...\n\n")
 

flock/cli/constants.py

@@ -1,15 +1,14 @@
 """Constants for the CLI module."""
 
 CLI_CREATE_AGENT = "Create an agent"
-CLI_CREATE_FLOCK = "Create a flock"
+CLI_CREATE_FLOCK = "Create a new Flock"
 CLI_LOAD_AGENT = "Load an agent"
 CLI_LOAD_FLOCK = "Load a *.flock file"
 CLI_THEME_BUILDER = "Theme builder"
 CLI_LOAD_EXAMPLE = "Load a example"
 CLI_SETTINGS = "Settings"
 CLI_NOTES = "'Hummingbird' release notes"
-CLI_START_ADVANCED_MODE = "Start advanced mode (coming soon)"
-CLI_START_WEB_SERVER = "Start web server (coming soon)"
+CLI_START_WEB_SERVER = "Start web server"
 CLI_EXIT = "Exit"
 CLI_CHOICES = [
     CLI_CREATE_AGENT,
@@ -18,7 +17,6 @@ CLI_CHOICES = [
     CLI_LOAD_FLOCK,
     CLI_LOAD_EXAMPLE,
     CLI_SETTINGS,
-    CLI_START_ADVANCED_MODE,
     CLI_START_WEB_SERVER,
     CLI_EXIT,
 ]

flock/cli/create_flock.py

@@ -1 +1,220 @@
-# TODO
+"""Create a new Flock through a guided wizard.
+
+This module provides a wizard-like interface for creating new Flock instances,
+with options for basic configuration and initial agent creation.
+"""
+
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+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.util.cli_helper import init_console
+
+# Create console instance
+console = Console()
+
+
+def create_flock():
+    """Create a new Flock through a guided wizard."""
+    init_console()
+    console.print(Panel("[bold green]Create New Flock[/]"), justify="center")
+    console.line()
+
+    # Step 1: Basic Flock Configuration
+    console.print("[bold]Step 1: Basic Flock Configuration[/]")
+    console.line()
+
+    # Get description
+    description = questionary.text(
+        "Enter a description for this Flock (optional):",
+        default="",
+    ).ask()
+
+    # Default model selection
+    default_models = [
+        "openai/gpt-4o",
+        "openai/gpt-3.5-turbo",
+        "anthropic/claude-3-opus-20240229",
+        "anthropic/claude-3-sonnet-20240229",
+        "gemini/gemini-1.5-pro",
+        "Other (specify)",
+    ]
+
+    model_choice = questionary.select(
+        "Select a default model:",
+        choices=default_models,
+    ).ask()
+
+    if model_choice == "Other (specify)":
+        model = questionary.text(
+            "Enter the model identifier:",
+            default="openai/gpt-4o",
+        ).ask()
+    else:
+        model = model_choice
+
+    # Execution options
+    enable_temporal = questionary.confirm(
+        "Enable Temporal for distributed execution?",
+        default=False,
+    ).ask()
+
+    # Logging configuration
+    enable_logging = questionary.confirm(
+        "Enable logging?",
+        default=True,
+    ).ask()
+
+    # Create the Flock instance
+    flock = Flock(
+        model=model,
+        description=description,
+        enable_temporal=enable_temporal,
+        enable_logging=enable_logging,
+    )
+
+    console.print("\n[green]✓[/] Flock created successfully!")
+    console.line()
+
+    # Step 2: Create Initial Agent (optional)
+    create_agent = questionary.confirm(
+        "Would you like to create an initial agent?",
+        default=True,
+    ).ask()
+
+    if create_agent:
+        _create_initial_agent(flock)
+
+    # Step 3: Save Options
+    console.print("\n[bold]Step 3: Save Options[/]")
+    console.line()
+
+    save_choice = questionary.select(
+        "What would you like to do with this Flock?",
+        choices=[
+            "Save to YAML file",
+            "Continue in CLI without saving",
+            "Execute immediately",
+            "Cancel and discard",
+        ],
+    ).ask()
+
+    if save_choice == "Save to YAML file":
+        _save_flock_to_yaml(flock)
+
+        # Ask if user wants to continue working with this Flock
+        continue_with_flock = questionary.confirm(
+            "Would you like to continue working with this Flock in the CLI?",
+            default=True,
+        ).ask()
+
+        if continue_with_flock:
+            start_loaded_flock_cli(flock, server_name="New Flock")
+
+    elif save_choice == "Continue in CLI without saving":
+        start_loaded_flock_cli(flock, server_name="New Flock")
+
+    elif save_choice == "Execute immediately":
+        from flock.cli.execute_flock import execute_flock
+
+        try:
+            execute_flock(flock)
+        except ImportError:
+            console.print(
+                "[yellow]Execute functionality not yet implemented.[/]"
+            )
+            input("\nPress Enter to continue...")
+            start_loaded_flock_cli(flock, server_name="New Flock")
+
+
+def _create_initial_agent(flock):
+    """Create an initial agent for the Flock.
+
+    Args:
+        flock: The Flock instance to add the agent to
+    """
+    console.print("\n[bold]Step 2: Create Initial Agent[/]")
+    console.line()
+
+    # Get agent name
+    name = questionary.text(
+        "Enter a name for the agent:",
+        default="my_agent",
+    ).ask()
+
+    # Get agent description
+    description = questionary.text(
+        "Enter a description for the agent (optional):",
+        default="",
+    ).ask()
+
+    # Get input specification
+    input_spec = questionary.text(
+        "Enter input specification (e.g., 'query: str | The search query'):",
+        default="query",
+    ).ask()
+
+    # Get output specification
+    output_spec = questionary.text(
+        "Enter output specification (e.g., 'result: str | The generated result'):",
+        default="result",
+    ).ask()
+
+    # Additional options
+    use_cache = questionary.confirm(
+        "Enable caching for this agent?",
+        default=True,
+    ).ask()
+
+    enable_rich_tables = questionary.confirm(
+        "Enable rich table output for this agent?",
+        default=True,
+    ).ask()
+
+    # Create the agent
+    agent = FlockFactory.create_default_agent(
+        name=name,
+        description=description,
+        input=input_spec,
+        output=output_spec,
+        use_cache=use_cache,
+        enable_rich_tables=enable_rich_tables,
+    )
+
+    # Add the agent to the Flock
+    flock.add_agent(agent)
+    console.print(f"\n[green]✓[/] Agent '{name}' created and added to Flock!")
+
+
+def _save_flock_to_yaml(flock):
+    """Save the Flock to a YAML file.
+
+    Args:
+        flock: The Flock instance to save
+    """
+    # Get file path
+    default_name = "my_flock.flock.yaml"
+    file_path = questionary.text(
+        "Enter file path to save Flock:",
+        default=default_name,
+    ).ask()
+
+    # Ensure the file has the correct extension
+    if not file_path.endswith((".yaml", ".yml")):
+        file_path += ".yaml"
+
+    # Create directory if it doesn't exist
+    save_path = Path(file_path)
+    save_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # Save the Flock to YAML
+        flock.to_yaml_file(file_path)
+        console.print(f"\n[green]✓[/] Flock saved to {file_path}")
+    except Exception as e:
+        console.print(f"\n[bold red]Error saving Flock:[/] {e!s}")

flock/cli/execute_flock.py

@@ -0,0 +1,200 @@
+"""Execute a Flock instance with a selected agent.
+
+This module provides functionality to execute a Flock instance with
+a selected agent and input configuration.
+"""
+
+import json
+
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+
+from flock.core.flock import Flock
+from flock.core.util.cli_helper import init_console
+
+# Create console instance
+console = Console()
+
+
+def execute_flock(flock: Flock):
+    """Execute a Flock instance.
+
+    Args:
+        flock: The Flock instance to execute
+    """
+    if not flock:
+        console.print("[bold red]Error: No Flock instance provided.[/]")
+        return
+
+    agent_names = list(flock._agents.keys())
+
+    if not agent_names:
+        console.print("[yellow]No agents in this Flock to execute.[/]")
+        return
+
+    init_console()
+    console.print(Panel("[bold green]Execute Flock[/]"), justify="center")
+
+    # Step 1: Select start agent
+    console.print("\n[bold]Step 1: Select Start Agent[/]")
+
+    start_agent_name = questionary.select(
+        "Select an agent to start with:",
+        choices=agent_names,
+    ).ask()
+
+    if not start_agent_name:
+        return
+
+    start_agent = flock._agents[start_agent_name]
+
+    # Step 2: Configure input
+    console.print("\n[bold]Step 2: Configure Input[/]")
+
+    # Parse input schema
+    input_fields = _parse_input_schema(start_agent.input)
+
+    # If we couldn't parse any fields, ask for generic input
+    if not input_fields:
+        raw_input = questionary.text(
+            "Enter input (JSON format):",
+            default="{}",
+        ).ask()
+
+        try:
+            input_data = json.loads(raw_input)
+        except json.JSONDecodeError:
+            console.print("[bold red]Error: Invalid JSON input.[/]")
+            return
+    else:
+        # Otherwise, ask for each field
+        input_data = {}
+
+        for field, info in input_fields.items():
+            field_type = info.get("type", "str")
+            description = info.get("description", "")
+            prompt = f"Enter value for '{field}'"
+
+            if description:
+                prompt += f" ({description})"
+
+            prompt += ":"
+
+            value = questionary.text(prompt).ask()
+
+            # Convert value to appropriate type
+            if field_type == "int":
+                try:
+                    value = int(value)
+                except ValueError:
+                    console.print(
+                        f"[yellow]Warning: Could not convert value to int, using as string.[/]"
+                    )
+
+            input_data[field] = value
+
+    # Step 3: Run Options
+    console.print("\n[bold]Step 3: Run Options[/]")
+
+    # Logging options
+    enable_logging = questionary.confirm(
+        "Enable detailed logging?",
+        default=False,
+    ).ask()
+
+    # Preview input
+    console.print("\n[bold]Input Preview:[/]")
+    console.print(json.dumps(input_data, indent=2))
+
+    # Confirm execution
+    confirm = questionary.confirm(
+        "Execute Flock with this configuration?",
+        default=True,
+    ).ask()
+
+    if not confirm:
+        return
+
+    # Execute the Flock
+    console.print("\n[bold]Executing Flock...[/]")
+
+    try:
+        # Handle logging settings
+        if enable_logging:
+            # Enable logging through the logging configuration method
+            flock._configure_logging(True)
+
+        # Run the Flock
+        result = flock.run(
+            start_agent=start_agent_name,
+            input=input_data,
+        )
+
+        # Display result
+        console.print("\n[bold green]Execution Complete![/]")
+
+        if result and enable_logging:
+            console.print("\n[bold]Result:[/]")
+            if isinstance(result, dict):
+                # Display as formatted JSON
+                console.print(json.dumps(result, indent=2))
+            else:
+                # Display as plain text
+                console.print(str(result))
+
+    except Exception as e:
+        console.print(f"\n[bold red]Error during execution:[/] {e!s}")
+
+
+def _parse_input_schema(input_schema: str) -> dict[str, dict[str, str]]:
+    """Parse the input schema string into a field dictionary.
+
+    Args:
+        input_schema: The input schema string (e.g., "query: str | The search query")
+
+    Returns:
+        A dictionary mapping field names to field info (type, description)
+    """
+    if not input_schema:
+        return {}
+
+    fields = {}
+
+    try:
+        # Split by comma for multiple fields
+        for field_def in input_schema.split(","):
+            field_def = field_def.strip()
+
+            # Check for type hint with colon
+            if ":" in field_def:
+                field_name, rest = field_def.split(":", 1)
+                field_name = field_name.strip()
+                rest = rest.strip()
+
+                # Check for description with pipe
+                if "|" in rest:
+                    field_type, description = rest.split("|", 1)
+                    fields[field_name] = {
+                        "type": field_type.strip(),
+                        "description": description.strip(),
+                    }
+                else:
+                    fields[field_name] = {"type": rest.strip()}
+            else:
+                # Just a field name without type hint
+                if "|" in field_def:
+                    field_name, description = field_def.split("|", 1)
+                    fields[field_name.strip()] = {
+                        "description": description.strip()
+                    }
+                else:
+                    fields[field_def.strip()] = {}
+
+    except Exception as e:
+        console.print(
+            f"[yellow]Warning: Could not parse input schema: {e!s}[/]"
+        )
+        return {}
+
+    return fields

flock/cli/load_flock.py

@@ -6,6 +6,7 @@ import questionary
 from rich.console import Console
 from rich.markdown import Markdown
 
+from flock.cli.loaded_flock_cli import start_loaded_flock_cli
 from flock.core.flock import Flock
 
 
@@ -14,25 +15,44 @@ def filter(file_path) -> bool:
     path = Path(file_path)
     if path.is_dir():
         return True
-    return path.is_file() and path.suffix == ".flock"
+    return path.is_file() and (
+        path.suffix == ".flock"
+        or path.suffix == ".yaml"
+        or path.suffix == ".yml"
+    )
 
 
 def load_flock():
     """Load a Flock from a file."""
     console = Console()
 
-    console.print("\nPlease select a *.flock file\n", style="bold green")
+    console.print(
+        "\nPlease select a *.flock, *.yaml, or *.yml file\n", style="bold green"
+    )
 
     result = questionary.path("", file_filter=filter).ask()
 
+    if not result:
+        return
+
     selected_file = Path(result)
     if selected_file.is_file():
         console.print(f"Selected file: {selected_file}", style="bold green")
 
-        flock = Flock.load_from_file(result)
+        try:
+            flock = Flock.load_from_file(result)
+
+            console.line()
+            console.print(
+                Markdown("# Flock loaded successfully"), style="bold green"
+            )
+            console.line()
 
-        console.line()
-        console.print(Markdown("# Flock loaded...."), style="bold orange")
-        console.line()
+            # Instead of just running the Flock, start our enhanced CLI
+            start_loaded_flock_cli(
+                flock, server_name=f"Flock - {selected_file.name}"
+            )
 
-        flock.run()
+        except Exception as e:
+            console.print(f"Error loading Flock: {e!s}", style="bold red")
+            input("\nPress Enter to continue...")