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

flock/cli/yaml_editor.py

@@ -0,0 +1,283 @@
+"""YAML Editor for Flock CLI.
+
+This module provides functionality to view, edit, and validate YAML configurations
+for Flock and FlockAgent instances.
+"""
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+import questionary
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+
+from flock.core.flock import Flock
+from flock.core.flock_agent import FlockAgent
+from flock.core.util.cli_helper import init_console
+
+# Create console instance
+console = Console()
+
+
+def yaml_editor(flock_or_agent: Flock | FlockAgent | None = None):
+    """YAML Editor main entry point.
+
+    Args:
+        flock_or_agent: Optional Flock or FlockAgent instance to edit
+    """
+    init_console()
+    console.print(Panel("[bold green]YAML Editor[/]"), justify="center")
+
+    if flock_or_agent is None:
+        # If no object provided, provide options to load from file
+        _yaml_file_browser()
+        return
+
+    while True:
+        init_console()
+        console.print(Panel("[bold green]YAML Editor[/]"), justify="center")
+
+        # Determine object type
+        if isinstance(flock_or_agent, Flock):
+            obj_type = "Flock"
+            console.print(
+                f"Editing [bold cyan]Flock[/] with {len(flock_or_agent._agents)} agents"
+            )
+        elif isinstance(flock_or_agent, FlockAgent):
+            obj_type = "FlockAgent"
+            console.print(
+                f"Editing [bold cyan]FlockAgent[/]: {flock_or_agent.name}"
+            )
+        else:
+            console.print("[bold red]Error: Unknown object type[/]")
+            input("\nPress Enter to continue...")
+            return
+
+        console.line()
+
+        choice = questionary.select(
+            "What would you like to do?",
+            choices=[
+                questionary.Separator(line=" "),
+                "View Current YAML",
+                "Edit YAML Directly",
+                "Abstract Editor (Visual)",
+                "Validate YAML",
+                "Save to File",
+                questionary.Separator(),
+                "Back to Main Menu",
+            ],
+        ).ask()
+
+        if choice == "View Current YAML":
+            _view_yaml(flock_or_agent)
+        elif choice == "Edit YAML Directly":
+            flock_or_agent = _edit_yaml_directly(flock_or_agent)
+        elif choice == "Abstract Editor (Visual)":
+            flock_or_agent = _abstract_editor(flock_or_agent)
+        elif choice == "Validate YAML":
+            _validate_yaml(flock_or_agent)
+        elif choice == "Save to File":
+            _save_to_file(flock_or_agent)
+        elif choice == "Back to Main Menu":
+            break
+
+        if choice != "Back to Main Menu":
+            input("\nPress Enter to continue...")
+
+
+def _yaml_file_browser():
+    """Browser for YAML files to load."""
+    console.print("\n[bold]YAML File Browser[/]")
+    console.line()
+
+    current_dir = os.getcwd()
+    console.print(f"Current directory: [cyan]{current_dir}[/]")
+
+    # List .yaml/.yml files in current directory
+    yaml_files = list(Path(current_dir).glob("*.yaml")) + list(
+        Path(current_dir).glob("*.yml")
+    )
+
+    if not yaml_files:
+        console.print("[yellow]No YAML files found in current directory.[/]")
+        input("\nPress Enter to continue...")
+        return
+
+    # Display files
+    table = Table(title="YAML Files")
+    table.add_column("Filename", style="cyan")
+    table.add_column("Size", style="green")
+    table.add_column("Last Modified", style="yellow")
+
+    for file in yaml_files:
+        table.add_row(
+            file.name, f"{file.stat().st_size} bytes", f"{file.stat().st_mtime}"
+        )
+
+    console.print(table)
+
+    # TODO: Add file selection and loading
+
+
+def _view_yaml(obj: Flock | FlockAgent):
+    """View the YAML representation of an object.
+
+    Args:
+        obj: The object to view as YAML
+    """
+    yaml_str = obj.to_yaml()
+
+    # Display with syntax highlighting
+    syntax = Syntax(
+        yaml_str,
+        "yaml",
+        theme="monokai",
+        line_numbers=True,
+        code_width=100,
+        word_wrap=True,
+    )
+
+    init_console()
+    console.print(Panel("[bold green]YAML View[/]"), justify="center")
+    console.print(syntax)
+
+
+def _edit_yaml_directly(obj: Flock | FlockAgent) -> Flock | FlockAgent:
+    """Edit the YAML representation directly using an external editor.
+
+    Args:
+        obj: The object to edit
+
+    Returns:
+        The updated object
+    """
+    # Convert to YAML
+    yaml_str = obj.to_yaml()
+
+    # Create a temporary file
+    with tempfile.NamedTemporaryFile(
+        suffix=".yaml", mode="w+", delete=False
+    ) as tmp:
+        tmp.write(yaml_str)
+        tmp_path = tmp.name
+
+    try:
+        # Determine which editor to use
+        editor = os.environ.get(
+            "EDITOR", "notepad" if os.name == "nt" else "nano"
+        )
+
+        # Open the editor
+        console.print(
+            f"\nOpening {editor} to edit YAML. Save and exit when done."
+        )
+        subprocess.call([editor, tmp_path])
+
+        # Read updated YAML
+        with open(tmp_path) as f:
+            updated_yaml = f.read()
+
+        # Parse back to object
+        try:
+            if isinstance(obj, Flock):
+                updated_obj = Flock.from_yaml(updated_yaml)
+                console.print("\n[green]✓[/] YAML parsed successfully!")
+                return updated_obj
+            elif isinstance(obj, FlockAgent):
+                updated_obj = FlockAgent.from_yaml(updated_yaml)
+                console.print("\n[green]✓[/] YAML parsed successfully!")
+                return updated_obj
+        except Exception as e:
+            console.print(f"\n[bold red]Error parsing YAML:[/] {e!s}")
+            console.print("\nKeeping original object.")
+            return obj
+
+    finally:
+        # Clean up the temporary file
+        try:
+            os.unlink(tmp_path)
+        except:
+            pass
+
+
+def _abstract_editor(obj: Flock | FlockAgent) -> Flock | FlockAgent:
+    """Edit object using an abstract form-based editor.
+
+    Args:
+        obj: The object to edit
+
+    Returns:
+        The updated object
+    """
+    console.print("\n[yellow]Abstract visual editor not yet implemented.[/]")
+    console.print("Will provide a form-based editor for each field.")
+
+    # For now, just return the original object
+    return obj
+
+
+def _validate_yaml(obj: Flock | FlockAgent):
+    """Validate the YAML representation of an object.
+
+    Args:
+        obj: The object to validate
+    """
+    try:
+        yaml_str = obj.to_yaml()
+
+        # Attempt to parse with PyYAML
+        yaml.safe_load(yaml_str)
+
+        # Attempt to deserialize back to object
+        if isinstance(obj, Flock):
+            Flock.from_yaml(yaml_str)
+        elif isinstance(obj, FlockAgent):
+            FlockAgent.from_yaml(yaml_str)
+
+        console.print("\n[green]✓[/] YAML validation successful!")
+    except Exception as e:
+        console.print(f"\n[bold red]YAML validation failed:[/] {e!s}")
+
+
+def _save_to_file(obj: Flock | FlockAgent):
+    """Save object to a YAML file.
+
+    Args:
+        obj: The object to save
+    """
+    # Determine default filename based on object type
+    if isinstance(obj, Flock):
+        default_name = "my_flock.flock.yaml"
+    elif isinstance(obj, FlockAgent):
+        default_name = f"{obj.name}.agent.yaml"
+    else:
+        default_name = "unknown.yaml"
+
+    # Get file path
+    file_path = questionary.text(
+        "Enter file path to save YAML:",
+        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 to file
+        with open(file_path, "w") as f:
+            f.write(obj.to_yaml())
+
+        console.print(f"\n[green]✓[/] Saved to {file_path}")
+    except Exception as e:
+        console.print(f"\n[bold red]Error saving file:[/] {e!s}")

flock/core/__init__.py

@@ -2,18 +2,18 @@
 
 from flock.core.flock import Flock
 from flock.core.flock_agent import FlockAgent
-from flock.core.flock_api import FlockAPI
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
 from flock.core.flock_factory import FlockFactory
 from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.core.flock_registry import FlockRegistry
 
 __all__ = [
     "Flock",
-    "FlockAPI",
     "FlockAgent",
     "FlockEvaluator",
     "FlockEvaluatorConfig",
     "FlockFactory",
     "FlockModule",
     "FlockModuleConfig",
+    "FlockRegistry",
 ]

flock/core/api/__init__.py

@@ -0,0 +1,11 @@
+# src/flock/core/api/__init__.py
+"""Flock API Server components."""
+
+from .main import FlockAPI
+from .models import FlockAPIRequest, FlockAPIResponse
+
+__all__ = [
+    "FlockAPI",
+    "FlockAPIRequest",
+    "FlockAPIResponse",
+]

flock/core/api/endpoints.py

@@ -0,0 +1,222 @@
+# src/flock/core/api/endpoints.py
+"""FastAPI endpoints for the Flock API."""
+
+import html  # For escaping
+import uuid
+from typing import TYPE_CHECKING  # Added Any for type hinting clarity
+
+from fastapi import (
+    APIRouter,
+    BackgroundTasks,
+    HTTPException,
+    Request as FastAPIRequest,
+)
+
+# Import HTMLResponse for the UI form endpoint
+from fastapi.responses import HTMLResponse
+
+from flock.core.logging.logging import get_logger
+
+# Import models and UI utils
+from .models import FlockAPIRequest, FlockAPIResponse
+
+# Import UI utils - assuming they are now in ui/utils.py
+
+# Use TYPE_CHECKING to avoid circular imports for type hints
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
+
+    from .main import FlockAPI
+    from .run_store import RunStore
+
+logger = get_logger("api.endpoints")
+
+
+# Factory function to create the router with dependencies
+def create_api_router(flock_api: "FlockAPI") -> APIRouter:
+    """Creates the APIRouter and defines endpoints, injecting dependencies."""
+    router = APIRouter()
+    # Get dependencies from the main FlockAPI instance passed in
+    run_store: RunStore = flock_api.run_store
+    flock_instance: Flock = flock_api.flock
+
+    # --- API Endpoints ---
+    @router.post("/run/flock", response_model=FlockAPIResponse, tags=["API"])
+    async def run_flock_json(
+        request: FlockAPIRequest, background_tasks: BackgroundTasks
+    ):
+        """Run a flock workflow starting with the specified agent (expects JSON)."""
+        run_id = None
+        try:
+            run_id = str(uuid.uuid4())
+            run_store.create_run(run_id)  # Use RunStore
+            response = run_store.get_run(
+                run_id
+            )  # Get initial response from store
+
+            processed_inputs = request.inputs if request.inputs else {}
+            logger.info(
+                f"API request: run flock '{request.agent_name}' (run_id: {run_id})",
+                inputs=processed_inputs,
+            )
+
+            if request.async_run:
+                logger.debug(
+                    f"Running flock '{request.agent_name}' asynchronously (run_id: {run_id})"
+                )
+                # Call the helper method on the passed FlockAPI instance
+                background_tasks.add_task(
+                    flock_api._run_flock,
+                    run_id,
+                    request.agent_name,
+                    processed_inputs,
+                )
+                run_store.update_run_status(run_id, "running")
+                response.status = "running"  # Update local response copy too
+            else:
+                logger.debug(
+                    f"Running flock '{request.agent_name}' synchronously (run_id: {run_id})"
+                )
+                # Call the helper method on the passed FlockAPI instance
+                await flock_api._run_flock(
+                    run_id, request.agent_name, processed_inputs
+                )
+                response = run_store.get_run(
+                    run_id
+                )  # Fetch updated status/result
+
+            return response
+        except ValueError as ve:
+            logger.error(f"Value error starting run: {ve}")
+            if run_id:
+                run_store.update_run_status(run_id, "failed", str(ve))
+            raise HTTPException(status_code=400, detail=str(ve))
+        except Exception as e:
+            error_msg = f"Internal server error: {type(e).__name__}"
+            logger.error(f"Error starting run: {e!s}", exc_info=True)
+            if run_id:
+                run_store.update_run_status(run_id, "failed", error_msg)
+            raise HTTPException(status_code=500, detail=error_msg)
+
+    @router.get("/run/{run_id}", response_model=FlockAPIResponse, tags=["API"])
+    async def get_run_status(run_id: str):
+        """Get the status of a specific run."""
+        logger.debug(f"API request: get status for run_id: {run_id}")
+        run_data = run_store.get_run(run_id)
+        if not run_data:
+            logger.warning(f"Run ID not found: {run_id}")
+            raise HTTPException(status_code=404, detail="Run not found")
+        return run_data
+
+    @router.get("/agents", tags=["API"])
+    async def list_agents():
+        """List all available agents."""
+        logger.debug("API request: list agents")
+        # Access flock instance via factory closure
+        agents_list = [
+            {"name": agent.name, "description": agent.description or agent.name}
+            for agent in flock_instance.agents.values()
+        ]
+        return {"agents": agents_list}
+
+    # --- UI Form Endpoint ---
+    @router.post("/ui/run-agent-form", response_class=HTMLResponse, tags=["UI"])
+    async def run_flock_form(fastapi_req: FastAPIRequest):
+        """Endpoint to handle form submissions from the UI."""
+        run_id = None
+        try:
+            form_data = await fastapi_req.form()
+            agent_name = form_data.get("agent_name")
+            if not agent_name:
+                logger.warning("UI form submission missing agent_name")
+                return HTMLResponse(
+                    '<div id="result-content" class="error-message">Error: Agent name not provided.</div>',
+                    status_code=400,
+                )
+
+            logger.info(f"UI Form submission for agent: {agent_name}")
+            form_inputs = {}
+            # Access flock instance via factory closure
+            agent_def = flock_instance.agents.get(agent_name)
+            # Use helper from flock_api instance for parsing
+            defined_input_fields = (
+                flock_api._parse_input_spec(agent_def.input or "")
+                if agent_def
+                else []
+            )
+
+            for key, value in form_data.items():
+                if key.startswith("inputs."):
+                    form_inputs[key[len("inputs.") :]] = value
+            for field in defined_input_fields:  # Handle checkboxes
+                if (
+                    field["html_type"] == "checkbox"
+                    and field["name"] not in form_inputs
+                ):
+                    form_inputs[field["name"]] = False
+                elif (
+                    field["html_type"] == "checkbox"
+                    and field["name"] in form_inputs
+                ):
+                    form_inputs[field["name"]] = True
+
+            logger.debug(f"Parsed form inputs for UI run: {form_inputs}")
+            run_id = str(uuid.uuid4())
+            run_store.create_run(run_id)  # Use RunStore
+            logger.debug(
+                f"Running flock '{agent_name}' synchronously from UI (run_id: {run_id})"
+            )
+
+            # Call helper method on flock_api instance
+            await flock_api._run_flock(run_id, agent_name, form_inputs)
+
+            final_status = run_store.get_run(run_id)
+            if final_status and final_status.status == "completed":
+                # Use helper from flock_api instance for formatting
+                formatted_html = flock_api._format_result_to_html(
+                    final_status.result
+                )
+                logger.info(f"UI run completed successfully (run_id: {run_id})")
+                return HTMLResponse(
+                    f"<div id='result-content'>{formatted_html}</div>"
+                )  # Wrap in target div
+            elif final_status and final_status.status == "failed":
+                logger.error(
+                    f"UI run failed (run_id: {run_id}): {final_status.error}"
+                )
+                error_msg = html.escape(final_status.error or "Unknown error")
+                return HTMLResponse(
+                    f"<div id='result-content' class='error-message'>Run Failed: {error_msg}</div>",
+                    status_code=500,
+                )
+            else:
+                status_str = (
+                    final_status.status if final_status else "Not Found"
+                )
+                logger.warning(
+                    f"UI run {run_id} ended in unexpected state: {status_str}"
+                )
+                return HTMLResponse(
+                    f"<div id='result-content' class='error-message'>Run ended unexpectedly. Status: {status_str}</div>",
+                    status_code=500,
+                )
+
+        except ValueError as ve:
+            logger.error(f"Value error processing UI form run: {ve}")
+            if run_id:
+                run_store.update_run_status(run_id, "failed", str(ve))
+            return HTMLResponse(
+                f"<div id='result-content' class='error-message'>Error: {html.escape(str(ve))}</div>",
+                status_code=400,
+            )
+        except Exception as e:
+            error_msg = f"Internal server error: {type(e).__name__}"
+            logger.error(f"Error processing UI form run: {e!s}", exc_info=True)
+            if run_id:
+                run_store.update_run_status(run_id, "failed", error_msg)
+            return HTMLResponse(
+                f"<div id='result-content' class='error-message'>{html.escape(error_msg)}</div>",
+                status_code=500,
+            )
+
+    return router