flock-core 0.4.0b34__tar.gz → 0.4.0b35__tar.gz

{flock_core-0.4.0b34 → flock_core-0.4.0b35}/.gitignore

@@ -39,7 +39,7 @@ news/
 hierarchical_memory/
 .repomix-output.txt
 .sesskey
-
+.flock_ui_projects/
 .env.*
 .flock/
 memory.txt

{flock_core-0.4.0b34 → flock_core-0.4.0b35}/.vscode/settings.json

@@ -15,7 +15,7 @@
     "editor.smoothScrolling": true,
     "terminal.integrated.fontFamily": "'Jetbrains Mono', 'FiraCode Nerd Font', 'Hack Nerd Font', 'monospace'",
     "editor.renderWhitespace": "none",
-    "terminal.integrated.lineHeight": 1.5,
+    //"terminal.integrated.lineHeight": 1.5,
     "editor.fontSize": 15.5,
     "editor.fontLigatures": true,
     "editor.lineHeight": 1.5,

{flock_core-0.4.0b34 → flock_core-0.4.0b35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b34
+Version: 0.4.0b35
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

{flock_core-0.4.0b34 → flock_core-0.4.0b35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.4.0b-34"
+version = "0.4.0b-35"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [

{flock_core-0.4.0b34 → flock_core-0.4.0b35}/src/flock/__init__.py

@@ -1,8 +1,30 @@
 """Flock package initialization."""
 
+import argparse
+import sys
+
 
 def main():
     """Main function."""
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(
+        description="Flock - Declarative LLM Orchestration at Scale"
+    )
+    parser.add_argument(
+        "--web",
+        action="store_true",
+        help="Start the web interface instead of the CLI",
+    )
+    args = parser.parse_args()
+
+    # If --web flag is provided, start the web server
+    if args.web:
+        from flock.webapp.run import main as run_webapp
+
+        run_webapp()
+        return
+
+    # Otherwise, run the CLI interface
     import questionary
     from rich.console import Console
     from rich.panel import Panel
@@ -116,11 +138,11 @@ def main():
         elif result == CLI_SETTINGS:
             settings_editor()
         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...")
+            # Start the web server
+            from flock.webapp.run import main as run_webapp
+
+            run_webapp()
+            break
         elif result == CLI_NOTES:
             load_release_notes()
         elif result == CLI_EXIT:

{flock_core-0.4.0b34 → flock_core-0.4.0b35}/src/flock/core/api/main.py

@@ -12,14 +12,56 @@ from flock.core.api.models import FlockBatchRequest
 from flock.core.flock import Flock
 from flock.core.logging.logging import get_logger
 
+logger = get_logger("api.main")
+
 from .endpoints import create_api_router
 
 # Import components from the api package
 from .run_store import RunStore
-from .ui.routes import FASTHTML_AVAILABLE, create_ui_app
-from .ui.utils import format_result_to_html, parse_input_spec  # Import UI utils
 
-logger = get_logger("api.main")
+# Conditionally import for the new UI integration
+NEW_UI_SERVICE_AVAILABLE = False
+WEBAPP_FASTAPI_APP = None
+try:
+    from flock.webapp.app.main import (
+        app as webapp_fastapi_app,  # Import the FastAPI app instance
+    )
+    from flock.webapp.app.services.flock_service import (
+        set_current_flock_instance_programmatically,
+    )
+
+    WEBAPP_FASTAPI_APP = webapp_fastapi_app
+    NEW_UI_SERVICE_AVAILABLE = True
+except ImportError:
+    logger.warning(
+        "New webapp components (flock.webapp.app.main:app or flock.webapp.app.services.flock_service) not found. "
+        "UI mode will fall back to old FastHTML UI if available."
+    )
+    # Fallback: Import old UI components if new one isn't available and create_ui is True
+    try:
+        from .ui.routes import FASTHTML_AVAILABLE, create_ui_app
+
+        if FASTHTML_AVAILABLE:  # Only import utils if fasthtml is there
+            from .ui.utils import format_result_to_html, parse_input_spec
+        else:
+            # Define placeholders if fasthtml itself is not available
+            def parse_input_spec(*args, **kwargs):
+                return []
+
+            def format_result_to_html(*args, **kwargs):
+                return ""
+
+            FASTHTML_AVAILABLE = False  # Ensure it's false if import failed
+
+    except ImportError:
+        FASTHTML_AVAILABLE = False  # Ensure it's defined as false
+
+        # Define placeholders if utils can't be imported
+        def parse_input_spec(*args, **kwargs):
+            return []
+
+        def format_result_to_html(*args, **kwargs):
+            return ""
 
 
 class FlockAPI:
@@ -390,62 +432,119 @@ class FlockAPI:
         server_name: str = "Flock API",
         create_ui: bool = False,
     ):
-        """Start the API server, optionally creating and mounting a FastHTML UI."""
+        """Start the API server. If create_ui is True, it mounts the new webapp or the old FastHTML UI at the root."""
         if create_ui:
-            if not FASTHTML_AVAILABLE:
-                logger.error(
-                    "FastHTML not installed. Cannot create UI. Running API only."
+            if NEW_UI_SERVICE_AVAILABLE and WEBAPP_FASTAPI_APP:
+                logger.info(
+                    f"Preparing to mount new Scoped Web UI at root for Flock: {self.flock.name}"
                 )
-            else:
-                logger.info("Attempting to create and mount FastHTML UI at /ui")
                 try:
-                    # Pass self (FlockAPI instance) to the UI creation function
-                    # It needs access to self.flock and self._parse_input_spec
-                    fh_app = create_ui_app(
-                        self,
-                        api_host=host,
-                        api_port=port,
-                        server_name=server_name,
+                    # Set the flock instance for the webapp
+                    set_current_flock_instance_programmatically(
+                        self.flock,
+                        f"{self.flock.name.replace(' ', '_').lower()}_api_scoped.flock",
                     )
-                    self.app.mount("/ui", fh_app, name="ui")
-                    logger.info("FastHTML UI mounted successfully.")
-
-                    # Add root redirect only if UI was successfully mounted
-                    @self.app.get(
-                        "/",
-                        include_in_schema=False,
-                        response_class=RedirectResponse,
+                    logger.info(
+                        f"Flock '{self.flock.name}' set for the new web UI (now part of the main app)."
                     )
-                    async def root_redirect():
-                        logger.debug("Redirecting / to /ui/")
-                        return "/ui/"
 
-                except ImportError as e:
-                    logger.error(
-                        f"Could not create UI due to import error: {e}. Running API only."
+                    # Mount the new web UI app at the root of self.app
+                    # The WEBAPP_FASTAPI_APP handles its own routes including '/', static files etc.
+                    # It will need to be started with ui_mode=scoped, which should be handled by
+                    # the client accessing /?ui_mode=scoped initially.
+                    self.app.mount(
+                        "/", WEBAPP_FASTAPI_APP, name="flock_ui_root"
+                    )
+                    logger.info(
+                        f"New Web UI (scoped mode) mounted at root. Access at http://{host}:{port}/?ui_mode=scoped"
                     )
+                    # No explicit root redirect needed from self.app to WEBAPP_FASTAPI_APP's root,
+                    # as WEBAPP_FASTAPI_APP now *is* the handler for "/".
+                    # The API's own routes (e.g. /api/...) will still be served by self.app if they don't conflict.
+
+                    logger.info(
+                        f"API server '{server_name}' (with integrated UI) starting on http://{host}:{port}"
+                    )
+                    logger.info(
+                        f"Access the Scoped UI for '{self.flock.name}' at http://{host}:{port}/?ui_mode=scoped"
+                    )
+
                 except Exception as e:
                     logger.error(
-                        f"An error occurred setting up the UI: {e}. Running API only.",
+                        f"Error setting up or mounting new scoped UI at root: {e}. "
+                        "API will start, UI might be impacted.",
                         exc_info=True,
                     )
+            elif FASTHTML_AVAILABLE:  # Fallback to old FastHTML UI
+                logger.warning(
+                    "New webapp not available or WEBAPP_FASTAPI_APP is None. Falling back to old FastHTML UI (mounted at /ui)."
+                )
+                try:
+                    from .ui.routes import create_ui_app
+                except ImportError:
+                    logger.error(
+                        "Failed to import create_ui_app for old UI. API running without UI."
+                    )
+                    FASTHTML_AVAILABLE = False
 
-        logger.info(f"Starting API server on http://{host}:{port}")
-        if (
-            create_ui
-            and FASTHTML_AVAILABLE
-            and any(
-                m.path == "/ui" for m in self.app.routes if hasattr(m, "path")
+                if FASTHTML_AVAILABLE:
+                    logger.info(
+                        "Attempting to create and mount old FastHTML UI at /ui"
+                    )  # Old UI stays at /ui
+                    try:
+                        fh_app = create_ui_app(
+                            self,
+                            api_host=host,
+                            api_port=port,
+                            server_name=server_name,
+                        )
+                        self.app.mount(
+                            "/ui", fh_app, name="old_flock_ui"
+                        )  # Old UI still at /ui
+                        logger.info(
+                            "Old FastHTML UI mounted successfully at /ui."
+                        )
+
+                        @self.app.get(
+                            "/",
+                            include_in_schema=False,
+                            response_class=RedirectResponse,
+                        )
+                        async def root_redirect_to_old_ui():  # Redirect / to /ui/ for old UI
+                            logger.debug("Redirecting / to /ui/ (old UI)")
+                            return RedirectResponse(url="/ui/", status_code=303)
+
+                        logger.info(
+                            f"Old FastHTML UI available at http://{host}:{port}/ui/"
+                        )
+                    except Exception as e:
+                        logger.error(
+                            f"An error occurred setting up the old FastHTML UI: {e}. Running API only.",
+                            exc_info=True,
+                        )
+            else:
+                logger.error(
+                    "No UI components available. API running without UI."
+                )
+
+        if not create_ui:
+            logger.info(
+                f"API server '{server_name}' starting on http://{host}:{port} (UI not requested)."
             )
+        elif (
+            not (NEW_UI_SERVICE_AVAILABLE and WEBAPP_FASTAPI_APP)
+            and not FASTHTML_AVAILABLE
         ):
-            logger.info(f"UI available at http://{host}:{port}/ui/")
+            logger.info(
+                f"API server '{server_name}' starting on http://{host}:{port}. UI was requested but no components found."
+            )
 
         uvicorn.run(self.app, host=host, port=port)
 
     async def stop(self):
         """Stop the API server."""
         logger.info("Stopping API server (cleanup if necessary)")
-        pass  # Add cleanup logic if needed
+        pass
 
 
 # --- End of file ---

flock_core-0.4.0b35/src/flock/webapp/__init__.py

@@ -0,0 +1 @@
+"""Flock Web Application Package."""

flock_core-0.4.0b35/src/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,
+            },
+        )