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

{flock_core-0.4.0b34 → flock_core-0.4.0b36}/.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.0b36}/.vscode/settings.json

@@ -6,7 +6,7 @@
     "python.testing.unittestEnabled": false,
     "python.testing.pytestEnabled": true,
     "python.testing.autoTestDiscoverOnSaveEnabled": true,
-    "editor.formatOnSave": true,
+    "editor.formatOnSave": false,
     "editor.codeActionsOnSave": {
         "source.organizeImports.ruff": "always",
         "source.fixAll.ruff": "always"
@@ -15,11 +15,11 @@
     "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,
-    "editor.minimap.enabled": true,
+    "editor.minimap.enabled": false,
     "editor.tabSize": 2,
     "editor.semanticTokenColorCustomizations": {
         "enabled": true

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b34
+Version: 0.4.0b36
 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.0b36}/pyproject.toml

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

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

@@ -1,8 +1,61 @@
 """Flock package initialization."""
 
+import argparse
+import os
+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",
+    )
+    parser.add_argument(
+        "--theme",
+        type=str,
+        default=None,
+        help="Specify the theme name for the web interface (if --web is used).",
+    )
+    args = parser.parse_args()
+
+    # If --web flag is provided, start the web server
+    if args.web:
+        try:
+            # Set environment variable for theme if provided
+            if args.theme:
+                print(
+                    f"Setting FLOCK_WEB_THEME environment variable to: {args.theme}"
+                )
+                os.environ["FLOCK_WEB_THEME"] = args.theme
+            else:
+                # Ensure it's not set if no theme arg is passed
+                if "FLOCK_WEB_THEME" in os.environ:
+                    del os.environ["FLOCK_WEB_THEME"]
+
+            # Import and run the standalone webapp main function
+            # It will now read the theme from the environment variable
+            from flock.webapp.run import main as run_webapp_main
+
+            run_webapp_main()
+
+        except ImportError:
+            print(
+                "Error: Could not import webapp components. Ensure web dependencies are installed.",
+                file=sys.stderr,
+            )
+            sys.exit(1)
+        except Exception as e:
+            print(f"Error starting webapp: {e}", file=sys.stderr)
+            sys.exit(1)
+        return
+
+    # Otherwise, run the CLI interface
     import questionary
     from rich.console import Console
     from rich.panel import Panel
@@ -31,8 +84,6 @@ def main():
     console = Console()
 
     # Show a welcome message on first run with the new tool serialization format
-    import os
-
     cfg_file = os.path.expanduser(f"~/.flock/{CLI_CFG_FILE}")
     if not os.path.exists(cfg_file):
         # Create the directory if it doesn't exist
@@ -115,12 +166,6 @@ def main():
             manage_registry()
         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...")
         elif result == CLI_NOTES:
             load_release_notes()
         elif result == CLI_EXIT:

{flock_core-0.4.0b34 → flock_core-0.4.0b36}/src/flock/cli/loaded_flock_cli.py

@@ -12,8 +12,8 @@ from flock.cli.constants import (
     CLI_REGISTRY_MANAGEMENT,
     CLI_SETTINGS,
 )
-from flock.core.api import runner
 from flock.core.flock import Flock
+from flock.core.logging.logging import get_logger
 from flock.core.util.cli_helper import init_console
 
 # Import future modules we'll create
@@ -48,6 +48,7 @@ except ImportError:
 
 # Create console instance
 console = Console()
+logger = get_logger("cli.loaded_flock")
 
 
 def start_loaded_flock_cli(
@@ -188,17 +189,11 @@ def start_loaded_flock_cli(
 
 
 def _start_web_server(flock: Flock, create_ui: bool = False) -> None:
-    """Start a web server with the loaded Flock instance.
-
-    Args:
-        flock: The loaded Flock instance
-        create_ui: Whether to create a UI for the web server
-    """
+    """Start a web server with the loaded Flock instance."""
     host = "127.0.0.1"
     port = 8344
-    server_name = "Flock API"
+    # server_name = flock.name + " API" # Use flock name by default for server_name
 
-    # Get configuration from user
     console.print("\n[bold]Web Server Configuration[/]")
 
     host_input = questionary.text(
@@ -214,21 +209,46 @@ def _start_web_server(flock: Flock, create_ui: bool = False) -> None:
         port = int(port_input)
 
     server_name_input = questionary.text(
-        "Server name (default: FlockName API):", default=flock.name + " API"
+        "Server name (default: FlockName API):", default=f"{flock.name or 'Flock'} API"
     ).ask()
-    if server_name_input:
-        server_name = server_name_input
+    # if server_name_input: # server_name will be set by flock.start_api if not passed, or use its default
+    # server_name = server_name_input
+
+    ui_theme_to_pass = None
+    if create_ui:
+        try:
+            from flock.webapp.app.config import (
+                DEFAULT_THEME_NAME,
+                list_available_themes,
+            )
+            available_themes = list_available_themes()
+            theme_choices = ["default (current environment setting)", "random"] + sorted(available_themes)
+
+            selected_theme_choice = questionary.select(
+                "Select UI theme:",
+                choices=theme_choices,
+                default="default (current environment setting)"
+            ).ask()
+
+            if selected_theme_choice == "random":
+                ui_theme_to_pass = "random"
+            elif selected_theme_choice and selected_theme_choice != "default (current environment setting)":
+                ui_theme_to_pass = selected_theme_choice
+            # If "default" or None, ui_theme_to_pass remains None, Flock.start_api will use its logic
+
+        except ImportError:
+            logger.warning("Could not import webapp theme configuration for CLI selection. Theme will use default.")
+            ui_theme_to_pass = None # Fallback if webapp components not there
 
-    # Start the web server
     console.print(
-        f"\nStarting web server on {host}:{port} {'with UI' if create_ui else 'without UI'}..."
+        f"\nStarting web server on {host}:{port} {'with UI' if create_ui else 'without UI'}{' (Theme: ' + (ui_theme_to_pass if ui_theme_to_pass else 'default') + ')' if create_ui else ''}..."
     )
 
-    # Use the Flock's start_api method
-    runner.start_flock_api(
-        flock=flock,
+    # Call the Flock instance's own start_api method directly
+    flock.start_api(
         host=host,
         port=port,
-        server_name=server_name,
+        server_name=server_name_input, # Pass the chosen server name
         create_ui=create_ui,
+        ui_theme=ui_theme_to_pass,
     )

{flock_core-0.4.0b34 → flock_core-0.4.0b36}/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.0b34 → flock_core-0.4.0b36}/src/flock/core/flock.py

@@ -684,12 +684,57 @@ class Flock(BaseModel, Serializable):
         port: int = 8344,
         server_name: str = "Flock API",
         create_ui: bool = False,
+        ui_theme: str | None = None,
     ) -> None:
-        """Starts a REST API server for this Flock instance."""
+        """Starts a REST API server for this Flock instance.
+        If create_ui is True, integrates the web UI, potentially with a specific theme.
+        """
         # Import runner locally
-        from flock.core.api.runner import start_flock_api
+        # We need to decide if start_api now *always* tries to use the integrated approach
+        # or if it still calls the API-only runner when create_ui=False.
+        # Let's assume it uses the integrated approach starter if create_ui=True
+        # and the API-only starter (FlockAPI) if create_ui=False.
 
-        start_flock_api(self, host, port, server_name, create_ui)
+        if create_ui:
+            # Use the integrated server approach
+            try:
+                # We need a function similar to start_flock_api but for the integrated app
+                # Let's assume it exists in webapp.run for now, called start_integrated_server
+                from flock.webapp.run import start_integrated_server
+
+                start_integrated_server(
+                    flock_instance=self,
+                    host=host,
+                    port=port,
+                    server_name=server_name,
+                    theme_name=ui_theme,
+                )
+            except ImportError:
+                # Log error - cannot start integrated UI
+                from flock.core.logging.logging import get_logger
+
+                logger = get_logger("flock.core")
+                logger.error(
+                    "Cannot start integrated UI: Required components (e.g., flock.webapp.run.start_integrated_server) not found."
+                )
+            except Exception as e:
+                from flock.core.logging.logging import get_logger
+
+                logger = get_logger("flock.core")
+                logger.error(
+                    f"Failed to start integrated UI server: {e}", exc_info=True
+                )
+        else:
+            # Use the API-only server approach
+            from flock.core.api.runner import start_flock_api
+
+            start_flock_api(
+                flock=self,
+                host=host,
+                port=port,
+                server_name=server_name,
+                create_ui=False,  # Explicitly false for API only runner
+            )
 
     # --- CLI Starter ---
     def start_cli(

flock_core-0.4.0b36/src/flock/themes/alabaster.toml

@@ -0,0 +1,77 @@
+[rich]
+panel_style = "on #f7f7f7"
+table_header_style = "bold #000000 on #bfdbfe"
+table_title_style = "bold #000000"
+table_border_style = " #007acc"
+panel_border_style = " #007acc"
+column_output = "bold #000000"
+column_value = " #000000"
+bright_black = " #777777"
+bright_blue = " #007acc"
+bright_cyan = " #00aacb"
+bright_green = " #60cb00"
+bright_magenta = " #e64ce6"
+bright_red = " #f05050"
+bright_white = " #f7f7f7"
+bright_yellow = " #ffbc5d"
+normal_black = " #000000"
+normal_blue = " #325cc0"
+normal_cyan = " #0083b2"
+normal_green = " #448c27"
+normal_magenta = " #7a3e9d"
+normal_red = " #aa3731"
+normal_white = " #f7f7f7"
+normal_yellow = " #cb9000"
+cursor_cursor = " #007acc"
+cursor_text = " #bfdbfe"
+table_show_lines = false
+table_box = "MINIMAL"
+panel_padding = [ 1, 1,]
+panel_title_align = "center"
+table_row_styles = [ "", "italic",]
+table_safe_box = true
+table_padding = [ 0, 1,]
+table_collapse_padding = false
+table_pad_edge = true
+table_expand = false
+table_show_footer = false
+table_show_edge = true
+table_leading = 0
+table_style = "none"
+table_footer_style = "none"
+table_caption_style = "none"
+table_title_justify = "center"
+table_caption_justify = "center"
+table_highlight = false
+
+[colors.bright]
+black = " #777777"
+blue = " #007acc"
+cyan = " #00aacb"
+green = " #60cb00"
+magenta = " #e64ce6"
+red = " #f05050"
+white = " #f7f7f7"
+yellow = " #ffbc5d"
+
+[colors.cursor]
+cursor = " #007acc"
+text = " #bfdbfe"
+
+[colors.normal]
+black = " #000000"
+blue = " #325cc0"
+cyan = " #0083b2"
+green = " #448c27"
+magenta = " #7a3e9d"
+red = " #aa3731"
+white = " #f7f7f7"
+yellow = " #cb9000"
+
+[colors.primary]
+background = " #f7f7f7"
+foreground = " #000000"
+
+[colors.selection]
+background = " #bfdbfe"
+text = " #000000"

flock_core-0.4.0b36/src/flock/themes/guezwhoz.toml

@@ -0,0 +1,77 @@
+[rich]
+panel_style = "on #1c1c1c"
+table_header_style = "bold #eeeeee on #005f5f"
+table_title_style = "bold #d0d0d0"
+table_border_style = " #87afd7"
+panel_border_style = " #87afd7"
+column_output = "bold #d0d0d0"
+column_value = " #d0d0d0"
+bright_black = " #8a8a8a"
+bright_blue = " #87afd7"
+bright_cyan = " #87d7d7"
+bright_green = " #afd7af"
+bright_magenta = " #afafd7"
+bright_red = " #d75f5f"
+bright_white = " #dadada"
+bright_yellow = " #d7d7af"
+normal_black = " #080808"
+normal_blue = " #5fafd7"
+normal_cyan = " #5fd7d7"
+normal_green = " #87d7af"
+normal_magenta = " #afafff"
+normal_red = " #ff5f5f"
+normal_white = " #dadada"
+normal_yellow = " #d7d787"
+cursor_cursor = " #eeeeee"
+cursor_text = " #eeeeee"
+table_show_lines = false
+table_box = "ROUNDED"
+panel_padding = [ 1, 1,]
+panel_title_align = "left"
+table_row_styles = [ "", "underline",]
+table_safe_box = true
+table_padding = [ 0, 1,]
+table_collapse_padding = false
+table_pad_edge = true
+table_expand = false
+table_show_footer = false
+table_show_edge = true
+table_leading = 0
+table_style = "none"
+table_footer_style = "none"
+table_caption_style = "none"
+table_title_justify = "center"
+table_caption_justify = "center"
+table_highlight = false
+
+[colors.bright]
+black = " #8a8a8a"
+blue = " #87afd7"
+cyan = " #87d7d7"
+green = " #afd7af"
+magenta = " #afafd7"
+red = " #d75f5f"
+white = " #dadada"
+yellow = " #d7d7af"
+
+[colors.cursor]
+cursor = " #eeeeee"
+text = " #eeeeee"
+
+[colors.normal]
+black = " #080808"
+blue = " #5fafd7"
+cyan = " #5fd7d7"
+green = " #87d7af"
+magenta = " #afafff"
+red = " #ff5f5f"
+white = " #dadada"
+yellow = " #d7d787"
+
+[colors.primary]
+background = " #1c1c1c"
+foreground = " #d0d0d0"
+
+[colors.selection]
+background = " #005f5f"
+text = " #eeeeee"