flock-core 0.4.0b43__py3-none-any.whl → 0.4.0b45__py3-none-any.whl

flock/webapp/app/api/flock_management.py

@@ -1,28 +1,44 @@
+# src/flock/webapp/app/api/flock_management.py
 from pathlib import Path
+from typing import TYPE_CHECKING
 
-from fastapi import APIRouter, Form, Request
+from fastapi import APIRouter, Depends, Form, Request  # Added Depends
 from fastapi.responses import HTMLResponse
 from fastapi.templating import Jinja2Templates
 
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
+
+# Import the dependency to get the current Flock instance
+from flock.webapp.app.dependencies import (
+    get_flock_instance,
+)
+
+# Service functions now take app_state
 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,
+    # get_current_flock_filename IS NO LONGER IMPORTED
+    # get_current_flock_instance IS NO LONGER IMPORTED
 )
 
 router = APIRouter()
-BASE_DIR = Path(__file__).resolve().parent.parent.parent  # Points to flock-ui/
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
 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
+    request: Request,
+    update_message: str = None,
+    success: bool = None,
+    current_flock: "Flock" = Depends(get_flock_instance) # Expect flock to be loaded for this form
 ):
-    flock = get_current_flock_instance()
-    if not flock:
-        # This case should ideally not be reached if editor page properly redirects
+    # current_flock is now injected by FastAPI
+    # Get the filename from app.state, as it's managed there
+    current_filename: str | None = getattr(request.app.state, 'flock_filename', None)
+
+    if not current_flock: # Should be caught by Depends if get_flock_instance raises error
         return HTMLResponse(
             "<div class='error'>Error: No flock loaded. Please load or create one first.</div>"
         )
@@ -30,8 +46,8 @@ async def htmx_get_flock_properties_form(
         "partials/_flock_properties_form.html",
         {
             "request": request,
-            "flock": flock,
-            "current_filename": get_current_flock_filename(),
+            "flock": current_flock,
+            "current_filename": current_filename,
             "update_message": update_message,
             "success": success,
         },
@@ -44,58 +60,69 @@ async def htmx_update_flock_properties(
     flock_name: str = Form(...),
     default_model: str = Form(...),
     description: str = Form(""),
+    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
 ):
+    # Pass request.app.state to the service function
     success_update = update_flock_properties_service(
-        flock_name, default_model, description
+        flock_name, default_model, description, request.app.state
     )
-    flock = get_current_flock_instance()  # Get updated instance
-    # Re-render the form with a message
+
+    # Retrieve updated flock and filename from app.state for rendering the form
+    updated_flock: Flock | None = getattr(request.app.state, 'flock_instance', None)
+    updated_filename: str | None = getattr(request.app.state, 'flock_filename', None)
+
     return templates.TemplateResponse(
         "partials/_flock_properties_form.html",
         {
             "request": request,
-            "flock": flock,
-            "current_filename": get_current_flock_filename(),
+            "flock": updated_flock,
+            "current_filename": updated_filename,
             "update_message": "Flock properties updated!"
             if success_update
-            else "Failed to update properties.",
+            else "Failed to update properties. Check logs.",
             "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()
+async def htmx_save_flock(
+    request: Request,
+    save_filename: str = Form(...),
+    # current_flock: Flock = Depends(get_flock_instance) # Service will use app_state
+):
+    current_flock_from_state: Flock | None = getattr(request.app.state, 'flock_instance', None)
+    current_filename_from_state: str | None = getattr(request.app.state, 'flock_filename', None)
+
+    if not save_filename.strip():
         return templates.TemplateResponse(
             "partials/_flock_properties_form.html",
             {
                 "request": request,
-                "flock": flock,
-                "current_filename": get_current_flock_filename(),
+                "flock": current_flock_from_state,
+                "current_filename": current_filename_from_state,
                 "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
+    if not (save_filename.endswith(".yaml") or save_filename.endswith(".yml") or save_filename.endswith(".flock")):
+        save_filename += ".flock.yaml"
+
+    # Pass request.app.state to the service function
+    success, message = save_current_flock_to_file_service(save_filename, request.app.state)
+
+    # Retrieve potentially updated flock and filename from app.state
+    saved_flock: Flock | None = getattr(request.app.state, 'flock_instance', None)
+    saved_filename: str | None = getattr(request.app.state, 'flock_filename', None)
+
 
-    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
+            "flock": saved_flock, # Use the instance from app_state
+            "current_filename": saved_filename, # Use the filename from app_state (updated on successful save)
             "save_message": message,
             "success": success,
         },

flock/webapp/app/chat.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from uuid import uuid4
+
+from fastapi import APIRouter, Form, Request
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+
+from flock.webapp.app.main import get_base_context_web, templates
+
+router = APIRouter()
+
+# ---------------------------------------------------------------------------
+# In-memory session store (cookie-based). Not suitable for production scale.
+# ---------------------------------------------------------------------------
+_chat_sessions: dict[str, list[dict[str, str]]] = {}
+
+COOKIE_NAME = "chat_sid"
+
+
+def _ensure_session(request: Request):
+    """Returns (sid, history_list) tuple and guarantees cookie presence."""
+    sid: str | None = request.cookies.get(COOKIE_NAME)
+    if not sid:
+        sid = uuid4().hex
+    if sid not in _chat_sessions:
+        _chat_sessions[sid] = []
+    return sid, _chat_sessions[sid]
+
+
+# ---------------------------------------------------------------------------
+# Chat configuration (per app instance)
+# ---------------------------------------------------------------------------
+
+
+class ChatConfig(BaseModel):
+    agent_name: str | None = None  # Name of the Flock agent to chat with
+    message_key: str = "message"
+    history_key: str = "history"
+    response_key: str = "response"
+
+
+# Store a single global chat config on the FastAPI app state
+def get_chat_config(request: Request) -> ChatConfig:
+    if not hasattr(request.app.state, "chat_config"):
+        request.app.state.chat_config = ChatConfig()
+    return request.app.state.chat_config
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+
+@router.get("/chat", response_class=HTMLResponse, tags=["Chat"])
+async def chat_page(request: Request):
+    """Full-page chat UI (works even when the main UI is disabled)."""
+    sid, history = _ensure_session(request)
+    cfg = get_chat_config(request)
+    context = get_base_context_web(request, ui_mode="standalone")
+    context.update({"history": history, "chat_cfg": cfg, "chat_subtitle": f"Agent: {cfg.agent_name}" if cfg.agent_name else "Echo demo"})
+    response = templates.TemplateResponse("chat.html", context)
+    # Set cookie if not already present
+    if COOKIE_NAME not in request.cookies:
+        response.set_cookie(COOKIE_NAME, sid, max_age=60 * 60 * 24 * 7)
+    return response
+
+
+@router.get("/chat/messages", response_class=HTMLResponse, tags=["Chat"], include_in_schema=False)
+async def chat_history_partial(request: Request):
+    """HTMX endpoint that returns the rendered message list."""
+    _, history = _ensure_session(request)
+    return templates.TemplateResponse(
+        "partials/_chat_messages.html",
+        {"request": request, "history": history, "now": datetime.now}
+    )
+
+
+@router.post("/chat/send", response_class=HTMLResponse, tags=["Chat"])
+async def chat_send(request: Request, message: str = Form(...)):
+    """Echo-back mock implementation. Adds user msg + bot reply to history."""
+    _, history = _ensure_session(request)
+    current_time = datetime.now().strftime('%H:%M')
+    cfg = get_chat_config(request)
+    history.append({"role": "user", "text": message, "timestamp": current_time})
+    start_time = datetime.now()
+
+    flock_inst = getattr(request.app.state, "flock_instance", None)
+    bot_agent = cfg.agent_name if cfg.agent_name else None
+    bot_text: str
+    if bot_agent and flock_inst and bot_agent in getattr(flock_inst, "agents", {}):
+        # Build input according to mapping keys
+        run_input: dict = {}
+        if cfg.message_key:
+            run_input[cfg.message_key] = message
+        if cfg.history_key:
+            # Provide history without timestamps to keep things small
+            run_input[cfg.history_key] = [h["text"] for h in history]
+
+        try:
+            result_dict = await flock_inst.run_async(start_agent=bot_agent, input=run_input, box_result=False)
+        except Exception as e:
+            bot_text = f"Error: {e}"
+        else:
+            if cfg.response_key:
+                bot_text = str(result_dict.get(cfg.response_key, result_dict))
+            else:
+                bot_text = str(result_dict)
+    else:
+        # Fallback echo behavior
+        bot_text = f"Echo: {message}"
+
+    duration_ms = int((datetime.now() - start_time).total_seconds() * 1000)
+    history.append({"role": "bot", "text": bot_text, "timestamp": current_time, "agent": bot_agent or "echo", "duration_ms": duration_ms})
+    # Return updated history partial
+    return templates.TemplateResponse(
+        "partials/_chat_messages.html",
+        {"request": request, "history": history, "now": datetime.now}
+    )
+
+
+@router.get("/ui/htmx/chat-view", response_class=HTMLResponse, tags=["Chat"], include_in_schema=False)
+async def chat_container_partial(request: Request):
+    _ensure_session(request)
+    return templates.TemplateResponse("partials/_chat_container.html", {"request": request})
+
+
+# ---------------------------------------------------------------------------
+# Chat settings management
+# ---------------------------------------------------------------------------
+
+
+@router.get("/ui/htmx/chat-settings-form", response_class=HTMLResponse, include_in_schema=False)
+async def chat_settings_form(request: Request):
+    """Returns the form for configuring chat behaviour (HTMX partial)."""
+    cfg = get_chat_config(request)
+    flock_inst = getattr(request.app.state, "flock_instance", None)
+    input_fields, output_fields = [], []
+    if cfg.agent_name and flock_inst and cfg.agent_name in flock_inst.agents:
+        agent_obj = flock_inst.agents[cfg.agent_name]
+        # Expect signatures like "field: type | desc, ..." or "field: type" etc.
+        def _extract(sig: str):
+            fields = []
+            for seg in sig.split(','):
+                parts = seg.strip().split(':')
+                if parts:
+                    fields.append(parts[0].strip())
+            return [f for f in fields if f]
+        input_fields = _extract(agent_obj.input) if getattr(agent_obj, 'input', '') else []
+        output_fields = _extract(agent_obj.output) if getattr(agent_obj, 'output', '') else []
+
+    context = get_base_context_web(request)
+    context.update({
+        "chat_cfg": cfg,
+        "current_flock": flock_inst,
+        "input_fields": input_fields,
+        "output_fields": output_fields,
+    })
+    return templates.TemplateResponse("partials/_chat_settings_form.html", context)
+
+
+@router.post("/chat/settings", response_class=HTMLResponse, include_in_schema=False)
+async def chat_settings_submit(
+    request: Request,
+    agent_name: str | None = Form(default=None),
+    message_key: str = Form("message"),
+    history_key: str = Form("history"),
+    response_key: str = Form("response"),
+):
+    """Apply submitted chat config, then re-render the form with a success message."""
+    cfg = get_chat_config(request)
+    cfg.agent_name = agent_name or None
+    cfg.message_key = message_key
+    cfg.history_key = history_key
+    cfg.response_key = response_key
+
+    headers = {
+        "HX-Trigger": json.dumps({"notify": {"type": "success", "message": "Chat settings saved"}}),
+        "HX-Redirect": "/chat"
+    }
+    # Response body empty; HTMX will redirect
+    return HTMLResponse("", headers=headers)
+
+
+# --- Stand-alone Chat HTML page access to settings --------------------------
+
+
+@router.get("/chat/settings-standalone", response_class=HTMLResponse, tags=["Chat"], include_in_schema=False)
+async def chat_settings_standalone(request: Request):
+    """Standalone page to render chat settings (used by full-page chat HTML)."""
+    cfg = get_chat_config(request)
+    context = get_base_context_web(request, ui_mode="standalone")
+    context.update({
+        "chat_cfg": cfg,
+        "current_flock": getattr(request.app.state, "flock_instance", None),
+    })
+    return templates.TemplateResponse("chat_settings.html", context)
+
+
+# ---------------------------------------------------------------------------
+# Stand-alone HTMX partials (chat view & settings) for in-page swapping
+# ---------------------------------------------------------------------------
+
+
+@router.get("/chat/htmx/chat-view", response_class=HTMLResponse, include_in_schema=False)
+async def htmx_chat_view(request: Request):
+    """Return chat container partial for standalone page reload via HTMX."""
+    _ensure_session(request)
+    return templates.TemplateResponse("partials/_chat_container.html", {"request": request})
+
+
+@router.get("/chat/htmx/settings-form", response_class=HTMLResponse, include_in_schema=False)
+async def htmx_chat_settings_partial(request: Request):
+    cfg = get_chat_config(request)
+    # Allow temporarily selecting agent via query param without saving
+    agent_override = request.query_params.get("agent_name")
+    if agent_override is not None:
+        cfg = cfg.copy()
+        cfg.agent_name = agent_override or None
+
+    flock_inst = getattr(request.app.state, "flock_instance", None)
+    input_fields, output_fields = [], []
+    if cfg.agent_name and flock_inst and cfg.agent_name in flock_inst.agents:
+        agent_obj = flock_inst.agents[cfg.agent_name]
+        def _extract(sig: str):
+            return [seg.strip().split(':')[0].strip() for seg in sig.split(',') if seg.strip()]
+        input_fields = _extract(agent_obj.input) if getattr(agent_obj, 'input', '') else []
+        output_fields = _extract(agent_obj.output) if getattr(agent_obj, 'output', '') else []
+
+    context = {"request": request, "chat_cfg": cfg, "current_flock": flock_inst, "input_fields": input_fields, "output_fields": output_fields}
+    return templates.TemplateResponse("partials/_chat_settings_form.html", context)

flock/webapp/app/config.py

@@ -1,8 +1,11 @@
 import os
 import random  # Added for random theme selection
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
 
-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"))
@@ -18,10 +21,10 @@ 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_INSTANCE: "Flock | None" = None
 CURRENT_FLOCK_FILENAME: str | None = None
 
-DEFAULT_THEME_NAME = OutputTheme.ayu.value # Default if random fails or invalid theme specified
+DEFAULT_THEME_NAME = OutputTheme.everblush.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)."""

flock/webapp/app/dependencies.py

@@ -0,0 +1,95 @@
+# src/flock/webapp/app/dependencies.py
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Optional
+
+# Import FlockEndpoint for type hinting
+from flock.core.api.custom_endpoint import FlockEndpoint
+
+if TYPE_CHECKING:
+    from flock.core.api.run_store import RunStore
+    from flock.core.flock import Flock
+
+
+# These will be set once when the FastAPI app starts, via set_global_flock_services
+_flock_instance: Optional["Flock"] = None
+_run_store_instance: Optional["RunStore"] = None
+
+# Global-like variable (scoped to this module) to temporarily store custom endpoints
+# before the app is fully configured and the lifespan event runs.
+_pending_custom_endpoints: list[FlockEndpoint] = []
+
+
+def add_pending_custom_endpoints(endpoints: Sequence[FlockEndpoint] | None):
+    """Temporarily stores custom endpoints. Called by `start_unified_server`
+    before the FastAPI app's lifespan event can process them.
+    """
+    global _pending_custom_endpoints
+    if endpoints:
+        # Ensure we are adding FlockEndpoint instances
+        for ep in endpoints:
+            if not isinstance(ep, FlockEndpoint):
+                # If it's a dict, try to convert it, assuming it was the old format
+                if isinstance(ep, dict) and "path" in ep and "callback" in ep:
+                    try:
+                        # Attempt to create FlockEndpoint from dict - assumes correct keys
+                        # This is a basic conversion; more robust parsing might be needed
+                        # if the dict structure is very different.
+                        _pending_custom_endpoints.append(FlockEndpoint(**ep)) # type: ignore
+                    except Exception as e:
+                        print(f"Warning: Could not convert custom endpoint dict to FlockEndpoint: {ep}. Error: {e}")
+                else:
+                    print(f"Warning: Custom endpoint is not a FlockEndpoint instance and cannot be automatically converted: {type(ep)}")
+            else:
+                _pending_custom_endpoints.append(ep)
+        print(f"Dependencies: Added {len(endpoints)} pending custom endpoints.")
+
+
+def get_pending_custom_endpoints_and_clear() -> list[FlockEndpoint]:
+    """Retrieves and clears pending custom endpoints.
+    Called by the FastAPI app's lifespan event manager in `webapp/app/main.py`.
+    """
+    global _pending_custom_endpoints
+    endpoints_to_add = _pending_custom_endpoints[:] # Create a copy
+    _pending_custom_endpoints = [] # Clear the pending list
+    if endpoints_to_add:
+        print(f"Dependencies: Retrieved {len(endpoints_to_add)} pending custom endpoints for app registration.")
+    return endpoints_to_add
+
+
+def set_global_flock_services(flock: Optional["Flock"], run_store: "RunStore"):
+    """Called once at application startup to set the global Flock and RunStore.
+    This is typically invoked by the server startup script (e.g., in webapp/run.py).
+    """
+    global _flock_instance, _run_store_instance
+    from flock.core.logging.logging import (
+        get_logger,  # Local import to avoid circularity at module level
+    )
+    logger = get_logger("dependencies")
+
+    if _flock_instance is not None or _run_store_instance is not None:
+        logger.warning("Global Flock services are being re-initialized in dependencies.py.")
+
+    _flock_instance = flock
+    _run_store_instance = run_store
+    logger.info(f"Global services set in dependencies: Flock='{flock.name if flock else 'None'}', RunStore type='{type(run_store)}'")
+
+
+def get_flock_instance() -> "Flock":
+    """FastAPI dependency to get the globally available Flock instance."""
+    if _flock_instance is None:
+        # This can happen if accessed before `set_global_flock_services` or if it was cleared.
+        # The application should handle this gracefully, e.g. by redirecting to a setup page.
+        raise RuntimeError("Flock instance has not been initialized or is not currently available for DI.")
+    return _flock_instance
+
+def get_optional_flock_instance() -> Optional["Flock"]:
+    """FastAPI dependency to optionally get the Flock instance. Returns None if not set."""
+    return _flock_instance
+
+
+def get_run_store() -> "RunStore":
+    """FastAPI dependency to get the globally available RunStore instance."""
+    if _run_store_instance is None:
+        # Similar to Flock instance, should be initialized at app startup.
+        raise RuntimeError("RunStore instance has not been initialized in the application.")
+    return _run_store_instance