flock-core 0.4.0b33__py3-none-any.whl → 0.4.0b35__py3-none-any.whl

flock/webapp/app/api/agent_management.py

@@ -0,0 +1,270 @@
+from pathlib import Path
+
+from fastapi import APIRouter, Form, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+from flock.webapp.app.services.flock_service import (
+    add_agent_to_current_flock_service,
+    get_current_flock_instance,
+    get_registered_items_service,
+    remove_agent_from_current_flock_service,
+    update_agent_in_current_flock_service,
+)
+
+router = APIRouter()
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+
+@router.get("/htmx/agent-list", response_class=HTMLResponse)
+async def htmx_get_agent_list(
+    request: Request, message: str = None, success: bool = None
+):
+    flock = get_current_flock_instance()
+    if not flock:
+        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
+    return templates.TemplateResponse(
+        "partials/_agent_list.html",
+        {
+            "request": request,
+            "flock": flock,
+            "message": message,
+            "success": success,
+        },
+    )
+
+
+@router.get(
+    "/htmx/agents/{agent_name}/details-form", response_class=HTMLResponse
+)
+async def htmx_get_agent_details_form(request: Request, agent_name: str):
+    flock = get_current_flock_instance()
+    if not flock:
+        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
+    agent = flock.agents.get(agent_name)
+    if not agent:
+        return HTMLResponse(
+            f"<p class='error'>Agent '{agent_name}' not found.</p>"
+        )
+
+    registered_tools = get_registered_items_service("tool")
+    current_tools = (
+        [tool.__name__ for tool in agent.tools] if agent.tools else []
+    )
+
+    return templates.TemplateResponse(
+        "partials/_agent_detail_form.html",
+        {
+            "request": request,
+            "agent": agent,
+            "is_new": False,
+            "registered_tools": registered_tools,
+            "current_tools": current_tools,
+        },
+    )
+
+
+@router.get("/htmx/agents/new-agent-form", response_class=HTMLResponse)
+async def htmx_get_new_agent_form(request: Request):
+    flock = get_current_flock_instance()
+    if not flock:
+        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
+    registered_tools = get_registered_items_service("tool")
+    return templates.TemplateResponse(
+        "partials/_agent_detail_form.html",
+        {
+            "request": request,
+            "agent": None,  # For new agent
+            "is_new": True,
+            "registered_tools": registered_tools,
+            "current_tools": [],
+        },
+    )
+
+
+@router.post(
+    "/htmx/agents", response_class=HTMLResponse
+)  # For creating new agent
+async def htmx_create_agent(
+    request: Request,
+    agent_name: str = Form(...),
+    agent_description: str = Form(""),
+    agent_model: str = Form(None),  # Can be empty to use Flock default
+    input_signature: str = Form(...),
+    output_signature: str = Form(...),
+    tools: list[str] = Form([]),
+):  # FastAPI handles list from multiple form fields with same name
+    flock = get_current_flock_instance()
+    if not flock:
+        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
+
+    if (
+        not agent_name.strip()
+        or not input_signature.strip()
+        or not output_signature.strip()
+    ):
+        # Render form again with error (or use a different target for error message)
+        registered_tools = get_registered_items_service("tool")
+        return templates.TemplateResponse(
+            "partials/_agent_detail_form.html",
+            {
+                "request": request,
+                "agent": None,
+                "is_new": True,
+                "error_message": "Name, Input Signature, and Output Signature are required.",
+                "registered_tools": registered_tools,
+                "current_tools": tools,  # Pass back selected tools
+            },
+        )
+
+    agent_config = {
+        "name": agent_name,
+        "description": agent_description,
+        "model": agent_model
+        if agent_model
+        else None,  # Pass None if empty string for FlockFactory
+        "input": input_signature,
+        "output": output_signature,
+        "tools_names": tools,  # Pass tool names
+    }
+    success = add_agent_to_current_flock_service(agent_config)
+
+    # After action, re-render the agent list and clear the detail form
+    # Set headers for HTMX to trigger multiple target updates
+    response_headers = {}
+    if success:
+        response_headers["HX-Trigger"] = (
+            "agentListChanged"  # Custom event to refresh list
+        )
+
+    # Render an empty detail form or a success message for the detail panel
+    empty_detail_form = templates.TemplateResponse(
+        "partials/_agent_detail_form.html",
+        {
+            "request": request,
+            "agent": None,
+            "is_new": True,
+            "registered_tools": get_registered_items_service("tool"),
+            "form_message": "Agent created successfully!"
+            if success
+            else "Failed to create agent.",
+            "success": success,
+        },
+    ).body.decode()
+
+    return HTMLResponse(content=empty_detail_form, headers=response_headers)
+
+
+@router.put(
+    "/htmx/agents/{original_agent_name}", response_class=HTMLResponse
+)  # For updating existing agent
+async def htmx_update_agent(
+    request: Request,
+    original_agent_name: str,
+    agent_name: str = Form(...),
+    agent_description: str = Form(""),
+    agent_model: str = Form(None),
+    input_signature: str = Form(...),
+    output_signature: str = Form(...),
+    tools: list[str] = Form([]),
+):
+    flock = get_current_flock_instance()
+    if not flock:
+        return HTMLResponse("<p class='error'>No Flock loaded.</p>")
+
+    agent_config = {
+        "name": agent_name,
+        "description": agent_description,
+        "model": agent_model if agent_model else None,
+        "input": input_signature,
+        "output": output_signature,
+        "tools_names": tools,
+    }
+    success = update_agent_in_current_flock_service(
+        original_agent_name, agent_config
+    )
+
+    response_headers = {}
+    if success:
+        response_headers["HX-Trigger"] = "agentListChanged"
+
+    # Re-render the form with update message
+    updated_agent = flock.agents.get(
+        agent_name
+    )  # Get the potentially renamed agent
+    registered_tools = get_registered_items_service("tool")
+    current_tools = (
+        [tool.__name__ for tool in updated_agent.tools]
+        if updated_agent and updated_agent.tools
+        else []
+    )
+
+    updated_form = templates.TemplateResponse(
+        "partials/_agent_detail_form.html",
+        {
+            "request": request,
+            "agent": updated_agent,  # Pass the updated agent
+            "is_new": False,
+            "form_message": "Agent updated successfully!"
+            if success
+            else "Failed to update agent.",
+            "success": success,
+            "registered_tools": registered_tools,
+            "current_tools": current_tools,
+        },
+    ).body.decode()
+    return HTMLResponse(content=updated_form, headers=response_headers)
+
+
+@router.delete("/htmx/agents/{agent_name}", response_class=HTMLResponse)
+async def htmx_delete_agent(request: Request, agent_name: str):
+    flock = get_current_flock_instance()
+    if not flock:
+        return HTMLResponse("")  # Return empty to clear detail view
+
+    success = remove_agent_from_current_flock_service(agent_name)
+
+    response_headers = {}
+    if success:
+        response_headers["HX-Trigger"] = "agentListChanged"
+        # Return an empty agent detail form to clear the panel
+        # Also, the agent list will re-render due to HX-Trigger
+        return HTMLResponse(
+            templates.TemplateResponse(
+                "partials/_agent_detail_form.html",
+                {
+                    "request": request,
+                    "agent": None,
+                    "is_new": True,
+                    "form_message": f"Agent '{agent_name}' removed.",
+                    "success": True,
+                    "registered_tools": get_registered_items_service("tool"),
+                },
+            ).body.decode(),
+            headers=response_headers,
+        )
+    else:
+        # If deletion fails, re-render the agent detail form with an error
+        # This scenario should be rare unless the agent was already removed
+        agent = flock.agents.get(
+            agent_name
+        )  # Should still exist if delete failed
+        registered_tools = get_registered_items_service("tool")
+        current_tools = (
+            [tool.__name__ for tool in agent.tools]
+            if agent and agent.tools
+            else []
+        )
+        return templates.TemplateResponse(
+            "partials/_agent_detail_form.html",
+            {
+                "request": request,
+                "agent": agent,
+                "is_new": False,
+                "form_message": f"Failed to remove agent '{agent_name}'.",
+                "success": False,
+                "registered_tools": registered_tools,
+                "current_tools": current_tools,
+            },
+        )

flock/webapp/app/api/execution.py

@@ -0,0 +1,173 @@
+import json
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+from flock.core.util.spliter import parse_schema
+from flock.webapp.app.services.flock_service import (
+    get_current_flock_instance,
+    run_current_flock_service,
+)
+from flock.webapp.app.utils import pydantic_to_dict
+
+router = APIRouter()
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+
+# RENAMED this endpoint to avoid clash and for clarity
+@router.get("/htmx/execution-form-content", response_class=HTMLResponse)
+async def htmx_get_execution_form_content(request: Request):  # Renamed function
+    flock = get_current_flock_instance()
+    return templates.TemplateResponse(
+        "partials/_execution_form.html",
+        {
+            "request": request,
+            "flock": flock,
+            "input_fields": [],
+            "selected_agent_name": None,
+        },
+    )
+
+
+@router.get("/htmx/agents/{agent_name}/input-form", response_class=HTMLResponse)
+async def htmx_get_agent_input_form(request: Request, agent_name: str):
+    # ... (same as before) ...
+    flock = get_current_flock_instance()
+    if not flock:
+        return HTMLResponse("")
+    agent = flock.agents.get(agent_name)
+    if not agent:
+        return HTMLResponse(
+            f"<p class='error'>Agent '{agent_name}' not found.</p>"
+        )
+    input_fields = []
+    if agent.input and isinstance(agent.input, str):
+        try:
+            parsed_spec = parse_schema(agent.input)
+            for name, type_str, description in parsed_spec:
+                field_info = {
+                    "name": name,
+                    "type": type_str.lower(),
+                    "description": description or "",
+                }
+                if "bool" in field_info["type"]:
+                    field_info["html_type"] = "checkbox"
+                elif (
+                    "int" in field_info["type"] or "float" in field_info["type"]
+                ):
+                    field_info["html_type"] = "number"
+                elif (
+                    "list" in field_info["type"] or "dict" in field_info["type"]
+                ):
+                    field_info["html_type"] = "textarea"
+                    field_info["placeholder"] = (
+                        f"Enter JSON for {field_info['type']}"
+                    )
+                else:
+                    field_info["html_type"] = "text"
+                input_fields.append(field_info)
+        except Exception as e:
+            return HTMLResponse(
+                f"<p class='error'>Error parsing input signature for {agent_name}: {e}</p>"
+            )
+    return templates.TemplateResponse(
+        "partials/_dynamic_input_form_content.html",
+        {"request": request, "input_fields": input_fields},
+    )
+
+
+@router.post("/htmx/run", response_class=HTMLResponse)
+async def htmx_run_flock(request: Request):
+    # ... (same as before, ensure it uses the correct _results_display.html) ...
+    flock = get_current_flock_instance()
+    if not flock:
+        return HTMLResponse("<p class='error'>No Flock loaded to run.</p>")
+    form_data = await request.form()
+    start_agent_name = form_data.get("start_agent_name")
+    if not start_agent_name:
+        return HTMLResponse("<p class='error'>Starting agent not selected.</p>")
+    agent = flock.agents.get(start_agent_name)
+    if not agent:
+        return HTMLResponse(
+            f"<p class='error'>Agent '{start_agent_name}' not found.</p>"
+        )
+    inputs = {}
+    if agent.input and isinstance(agent.input, str):
+        try:
+            parsed_spec = parse_schema(agent.input)
+            for name, type_str, _ in parsed_spec:
+                form_field_name = f"agent_input_{name}"
+                raw_value = form_data.get(form_field_name)
+                if raw_value is None and "bool" in type_str.lower():
+                    inputs[name] = False
+                    continue
+                if raw_value is None:
+                    inputs[name] = None
+                    continue
+                if "int" in type_str.lower():
+                    try:
+                        inputs[name] = int(raw_value)
+                    except ValueError:
+                        return HTMLResponse(
+                            f"<p class='error'>Invalid integer for '{name}'.</p>"
+                        )
+                elif "float" in type_str.lower():
+                    try:
+                        inputs[name] = float(raw_value)
+                    except ValueError:
+                        return HTMLResponse(
+                            f"<p class='error'>Invalid float for '{name}'.</p>"
+                        )
+                elif "bool" in type_str.lower():
+                    inputs[name] = raw_value.lower() in [
+                        "true",
+                        "on",
+                        "1",
+                        "yes",
+                    ]
+                elif "list" in type_str.lower() or "dict" in type_str.lower():
+                    try:
+                        inputs[name] = json.loads(raw_value)
+                    except json.JSONDecodeError:
+                        return HTMLResponse(
+                            f"<p class='error'>Invalid JSON for '{name}'.</p>"
+                        )
+                else:
+                    inputs[name] = raw_value
+        except Exception as e:
+            return HTMLResponse(
+                f"<p class='error'>Error processing inputs for {start_agent_name}: {e}</p>"
+            )
+
+    try:
+        # Run the flock service and get the result
+        result_data = await run_current_flock_service(start_agent_name, inputs)
+
+        # Detect Pydantic models and convert to dictionaries
+        try:
+            # Convert Pydantic models to dictionaries for JSON serialization
+            result_data = pydantic_to_dict(result_data)
+
+            # Test JSON serialization to catch any remaining issues
+            try:
+                json.dumps(result_data)
+            except (TypeError, ValueError) as e:
+                # If JSON serialization fails, convert to a string representation
+                result_data = f"Error: Result contains non-serializable data: {e!s}\nOriginal result: {result_data!s}"
+
+        except Exception as e:
+            result_data = f"Error: Failed to process result data: {e!s}"
+
+        return templates.TemplateResponse(
+            "partials/_results_display.html",
+            {"request": request, "result_data": result_data},
+        )
+    except Exception as e:
+        error_message = f"Error during execution: {e!s}"
+        return templates.TemplateResponse(
+            "partials/_results_display.html",
+            {"request": request, "result_data": error_message},
+        )

flock/webapp/app/api/flock_management.py

@@ -0,0 +1,102 @@
+from pathlib import Path
+
+from fastapi import APIRouter, Form, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+from flock.webapp.app.services.flock_service import (
+    get_current_flock_filename,
+    get_current_flock_instance,
+    save_current_flock_to_file_service,
+    update_flock_properties_service,
+)
+
+router = APIRouter()
+BASE_DIR = Path(__file__).resolve().parent.parent.parent  # Points to flock-ui/
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+
+@router.get("/htmx/flock-properties-form", response_class=HTMLResponse)
+async def htmx_get_flock_properties_form(
+    request: Request, update_message: str = None, success: bool = None
+):
+    flock = get_current_flock_instance()
+    if not flock:
+        # This case should ideally not be reached if editor page properly redirects
+        return HTMLResponse(
+            "<div class='error'>Error: No flock loaded. Please load or create one first.</div>"
+        )
+    return templates.TemplateResponse(
+        "partials/_flock_properties_form.html",
+        {
+            "request": request,
+            "flock": flock,
+            "current_filename": get_current_flock_filename(),
+            "update_message": update_message,
+            "success": success,
+        },
+    )
+
+
+@router.post("/htmx/flock-properties", response_class=HTMLResponse)
+async def htmx_update_flock_properties(
+    request: Request,
+    flock_name: str = Form(...),
+    default_model: str = Form(...),
+    description: str = Form(""),
+):
+    success_update = update_flock_properties_service(
+        flock_name, default_model, description
+    )
+    flock = get_current_flock_instance()  # Get updated instance
+    # Re-render the form with a message
+    return templates.TemplateResponse(
+        "partials/_flock_properties_form.html",
+        {
+            "request": request,
+            "flock": flock,
+            "current_filename": get_current_flock_filename(),
+            "update_message": "Flock properties updated!"
+            if success_update
+            else "Failed to update properties.",
+            "success": success_update,
+        },
+    )
+
+
+@router.post("/htmx/save-flock", response_class=HTMLResponse)
+async def htmx_save_flock(request: Request, save_filename: str = Form(...)):
+    if not save_filename.strip():  # Basic validation
+        flock = get_current_flock_instance()
+        return templates.TemplateResponse(
+            "partials/_flock_properties_form.html",
+            {
+                "request": request,
+                "flock": flock,
+                "current_filename": get_current_flock_filename(),
+                "save_message": "Filename cannot be empty.",
+                "success": False,
+            },
+        )
+
+    if not (
+        save_filename.endswith(".yaml")
+        or save_filename.endswith(".yml")
+        or save_filename.endswith(".flock")
+    ):
+        save_filename += ".flock.yaml"  # Add default extension
+
+    success, message = save_current_flock_to_file_service(save_filename)
+    flock = get_current_flock_instance()
+    return templates.TemplateResponse(
+        "partials/_flock_properties_form.html",
+        {
+            "request": request,
+            "flock": flock,
+            "current_filename": get_current_flock_filename()
+            if success
+            else get_current_flock_filename(),  # Update filename if save was successful
+            "save_message": message,
+            "success": success,
+        },
+    )

flock/webapp/app/api/registry_viewer.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+from flock.webapp.app.services.flock_service import get_registered_items_service
+
+router = APIRouter()
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+
+@router.get("/htmx/{item_type}/table", response_class=HTMLResponse)
+async def htmx_get_registry_table(request: Request, item_type: str):
+    valid_item_types = ["type", "tool", "component"]
+    if item_type not in valid_item_types:
+        return HTMLResponse(
+            "<p class='error'>Invalid item type requested.</p>", status_code=400
+        )
+
+    items = get_registered_items_service(item_type)
+    return templates.TemplateResponse(
+        "partials/_registry_table.html",
+        {
+            "request": request,
+            "item_type_display": item_type.capitalize() + "s",
+            "items": items,
+        },
+    )

flock/webapp/app/config.py

@@ -0,0 +1,9 @@
+import os
+from pathlib import Path
+
+FLOCK_FILES_DIR = Path(os.getenv("FLOCK_FILES_DIR", "./.flock_ui_projects"))
+FLOCK_FILES_DIR.mkdir(parents=True, exist_ok=True)
+
+# Global state for MVP - NOT SUITABLE FOR PRODUCTION/MULTI-USER
+CURRENT_FLOCK_INSTANCE = None
+CURRENT_FLOCK_FILENAME = None