flock-core 0.4.0b34__py3-none-any.whl → 0.4.0b36__py3-none-any.whl

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,87 @@
+import os
+import random  # Added for random theme selection
+from pathlib import Path
+
+from flock.core import Flock  # Add type hint
+from flock.core.logging.formatters.themes import OutputTheme
+
+FLOCK_FILES_DIR = Path(os.getenv("FLOCK_FILES_DIR", "./.flock_ui_projects"))
+FLOCK_FILES_DIR.mkdir(parents=True, exist_ok=True)
+
+# --- Theme Configuration ---
+# Calculate themes directory relative to this config file's location, assuming structure:
+# src/flock/webapp/app/config.py
+# src/flock/themes/
+CONFIG_FILE_PATH = Path(__file__).resolve() # src/flock/webapp/app/config.py
+FLOCK_WEBAPP_DIR = CONFIG_FILE_PATH.parent.parent # src/flock/webapp/
+FLOCK_BASE_DIR = FLOCK_WEBAPP_DIR.parent # src/flock/
+THEMES_DIR = FLOCK_BASE_DIR / "themes"
+
+# Global state for MVP - NOT SUITABLE FOR PRODUCTION/MULTI-USER
+CURRENT_FLOCK_INSTANCE: Flock | None = None
+CURRENT_FLOCK_FILENAME: str | None = None
+
+DEFAULT_THEME_NAME = OutputTheme.crayonponyfish.value # Default if random fails or invalid theme specified
+
+def list_available_themes() -> list[str]:
+    """Scans the THEMES_DIR for .toml files and returns their names (without .toml)."""
+    if not THEMES_DIR.exists() or not THEMES_DIR.is_dir():
+        return []
+    return sorted([p.stem for p in THEMES_DIR.glob("*.toml") if p.is_file()])
+
+# Initialize CURRENT_THEME_NAME
+_initial_theme_from_env = os.environ.get("FLOCK_WEB_THEME")
+_resolved_initial_theme = DEFAULT_THEME_NAME
+
+if _initial_theme_from_env:
+    if _initial_theme_from_env.lower() == "random":
+        available_themes = list_available_themes()
+        if available_themes:
+            _resolved_initial_theme = random.choice(available_themes)
+            print(f"Config: Initial theme from FLOCK_WEB_THEME='random' resolved to: {_resolved_initial_theme}")
+        else:
+            print(f"Warning: FLOCK_WEB_THEME='random' specified, but no themes found in {THEMES_DIR}. Using default: {DEFAULT_THEME_NAME}")
+            _resolved_initial_theme = DEFAULT_THEME_NAME
+    elif _initial_theme_from_env in [t.value for t in OutputTheme] or _initial_theme_from_env in list_available_themes():
+        _resolved_initial_theme = _initial_theme_from_env
+        print(f"Config: Initial theme set from FLOCK_WEB_THEME env var: {_resolved_initial_theme}")
+    else:
+        print(f"Warning: Invalid theme name '{_initial_theme_from_env}' in FLOCK_WEB_THEME. Using default: {DEFAULT_THEME_NAME}")
+        _resolved_initial_theme = DEFAULT_THEME_NAME
+
+CURRENT_THEME_NAME: str = _resolved_initial_theme
+
+def set_current_theme_name(theme_name: str | None):
+    """Sets the globally accessible current theme name.
+    If 'random' is passed, a random theme is chosen.
+    """
+    global CURRENT_THEME_NAME
+    resolved_theme = DEFAULT_THEME_NAME # Default to start
+
+    if theme_name:
+        if theme_name.lower() == "random":
+            available = list_available_themes()
+            if available:
+                resolved_theme = random.choice(available)
+                print(f"Config: Theme 'random' resolved to: {resolved_theme}")
+            else:
+                print(f"Warning: Theme 'random' specified, but no themes found in {THEMES_DIR}. Using default: {DEFAULT_THEME_NAME}")
+                # resolved_theme remains DEFAULT_THEME_NAME
+        elif theme_name in [t.value for t in OutputTheme] or theme_name in list_available_themes():
+            resolved_theme = theme_name
+        else:
+            print(f"Warning: Invalid theme name provided ('{theme_name}'). Using default: {DEFAULT_THEME_NAME}")
+            # resolved_theme remains DEFAULT_THEME_NAME
+    else: # theme_name is None
+        # resolved_theme remains DEFAULT_THEME_NAME (set at the beginning of function)
+        pass
+
+    CURRENT_THEME_NAME = resolved_theme
+    # Ensure the theme name is set in the environment if we want other processes to see it,
+    # though this might be better handled by the calling process (e.g. CLI)
+    # os.environ["FLOCK_WEB_THEME"] = CURRENT_THEME_NAME
+    print(f"Config: Current theme explicitly set to: {CURRENT_THEME_NAME}")
+
+def get_current_theme_name() -> str:
+    """Gets the globally accessible current theme name."""
+    return CURRENT_THEME_NAME