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

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/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/util/spliter.py

@@ -2,46 +2,37 @@ import re
 
 
 def split_top_level(spec: str) -> list[str]:
-    """Split *spec* on commas that are truly between fields (i.e. that
-    are **not** inside brackets, braces, parentheses, string literals,
-    or the free-form description).
-
-    Strategy
-    --------
-    1. Single pass, char-by-char.
-    2. Track    • nesting depth for (), [], {}
-                • whether we are inside a quoted string
-    3. Consider a comma a separator *only* if depth == 0, we are not
-       inside quotes **and** the text that follows matches
-       `optional-ws + identifier + optional-ws + ':'`
-       which can only be the start of the next field.
-    """
+    """Return raw field strings, split on *top-level* commas."""
     fields: list[str] = []
     start = 0
     depth = 0
     quote_char: str | None = None
     i = 0
-    ident_re = re.compile(r"[A-Za-z_]\w*")  # cheap Python identifier
+    ident_re = re.compile(r"[A-Za-z_]\w*")  # cheap identifier
 
     while i < len(spec):
         ch = spec[i]
 
-        # ---------------- string handling ----------------
+        # ---------- string handling ----------
         if quote_char:
+            if ch == "\\":
+                i += 2  # skip escaped char
+                continue
             if ch == quote_char:
                 quote_char = None
             i += 1
             continue
 
         if ch in {"'", '"'}:
-            # treat as string delimiter only in places regular Python would
             prev = spec[i - 1] if i else " "
-            if depth or prev.isspace() or prev in "=([{,:":  # likely a quote
+            if (
+                depth or prev.isspace() or prev in "=([{,:"
+            ):  # looks like a quote
                 quote_char = ch
             i += 1
             continue
 
-        # ---------------- bracket / brace / paren ----------------
+        # ---------- bracket / brace / paren ----------
         if ch in "([{":
             depth += 1
             i += 1
@@ -51,23 +42,28 @@ def split_top_level(spec: str) -> list[str]:
             i += 1
             continue
 
-        # ---------------- field separators ----------------
+        # ---------- field separators ----------
         if ch == "," and depth == 0:
             j = i + 1
             while j < len(spec) and spec[j].isspace():
                 j += 1
-            if j < len(spec):
-                id_match = ident_re.match(spec, j)
-                if id_match:
-                    k = id_match.end()
-                    while k < len(spec) and spec[k].isspace():
-                        k += 1
-                    if k < len(spec) and spec[k] == ":":
-                        # confirmed: the comma ends the current field
-                        fields.append(spec[start:i].strip())
-                        start = i + 1
-                        i += 1
-                        continue
+            if j >= len(spec):  # comma at end – split
+                fields.append(spec[start:i].strip())
+                start = i + 1
+                i += 1
+                continue
+
+            id_match = ident_re.match(spec, j)
+            if id_match:
+                k = id_match.end()
+                while k < len(spec) and spec[k].isspace():
+                    k += 1
+                if k >= len(spec) or spec[k] in {":", "|", ","}:
+                    # confirmed: comma separates two fields
+                    fields.append(spec[start:i].strip())
+                    start = i + 1
+                    i += 1
+                    continue
 
         i += 1
 
@@ -76,21 +72,29 @@ def split_top_level(spec: str) -> list[str]:
 
 
 def parse_schema(spec: str) -> list[tuple[str, str, str]]:
-    """Turn the raw *spec* into List[(name, python_type, description)]."""
+    """Turn *spec* into a list of (name, python_type, description)."""
     result: list[tuple[str, str, str]] = []
 
     for field in split_top_level(spec):
-        if ":" not in field:
-            raise ValueError(f"Malformed field (missing ':'): {field!r}")
+        name = ""
+        type_str = "str"  # default type
+        description = ""
 
-        name_part, rest = field.split(":", 1)
-        name = name_part.strip()
-
-        type_part, _, desc_part = rest.partition("|")
-        type_str = type_part.strip()
+        name_part, _, desc_part = field.partition("|")
         description = desc_part.strip()
+        main_part = name_part.strip()
+
+        if ":" in main_part:
+            name, type_candidate = main_part.split(":", 1)
+            name = name.strip()
+            type_candidate = type_candidate.strip()
+            if type_candidate:
+                type_str = type_candidate
+        else:
+            name = main_part  # keeps default type
 
-        result.append((name, type_str, description))
+        if name:  # skip broken pieces
+            result.append((name, type_str, description))
 
     return result
 
@@ -107,20 +111,101 @@ if __name__ == "__main__":
     SAMPLE_2 = (
         "field_with_internal_quotes: Literal['type_A', "
         '"type_B_with_\'_apostrophe"] | A literal with mixed quotes,'
-        " another_field: str"
+        " another_field :str| A field with a description"
+    )
+
+    SAMPLE_3 = (
+        "field_with_internal_quotes: Literal['type_A', "
+        '"type_B_with_\'_apostrophe"] | A literal with mixed quotes,'
+        " another_field | A field with a description"
+    )
+
+    SAMPLE_4 = "input, query, output"
+
+    SAMPLE_5 = (
+        "name: str | The character's full name,"
+        "race: str | The character's fantasy race,"
+        "class: Literal['mage','thief'] | The character's profession, which can be either mage or thief,"
+        "background: str | A brief backstory for the character"
+    )
+
+    SAMPLE_6 = (
+        "summary: str | A short blurb, e.g. key:value pairs that appear in logs"
     )
+    # ➜ [('summary', 'str',
+    #     'A short blurb, e.g. key:value pairs that appear in logs')]
 
-    print(f"Sample 1: {SAMPLE_1}")
-    print(f"Sample 2: {SAMPLE_2}")
+    SAMPLE_7 = "path: str | The literal string 'C:\\\\Program Files\\\\My,App'"
 
-    print("\nSplitting Sample 1:")
-    split_sample_1 = split_top_level(SAMPLE_1)
-    print(split_sample_1)
-    for field in split_sample_1:
-        print(parse_schema(field))
+    # ➜ [('path', 'str',
+    #     "The literal string 'C:\\Program Files\\My,App'")]
 
-    print("\nSplitting Sample 2:")
-    split_sample_2 = split_top_level(SAMPLE_2)
-    print(split_sample_2)
-    for field in split_sample_2:
-        print(parse_schema(field))
+    SAMPLE_8 = (
+        "transform: Callable[[int, str], bool] | Function that returns True on success,"
+        "retries: int | How many times to retry"
+    )
+    # ➜ ('transform', 'Callable[[int, str], bool]', 'Function that returns True on success')
+    #    ('retries',   'int',                         'How many times to retry')
+
+    SAMPLE_9 = (
+        r"regex: str | Pattern such as r'^[A-Z\|a-z]+$',"
+        "flags: int | re flags to use"
+    )
+    # ➜ ('regex', 'str', "Pattern such as r'^[A-Z\\|a-z]+$'")
+    #    ('flags', 'int', 're flags to use')
+
+    SAMPLE_10 = "id:int, name:str,"  # note the final comma!
+    # ➜ ('id', 'int', '')
+    #    ('name', 'str', '')
+
+    SAMPLE_11 = "id:int | Primary key\nname:str | Display name\nactive:bool"
+    # ➜ should not work!
+
+    SAMPLE_12 = (
+        'comment:str | The text "done | failed" goes here,'
+        'status:Literal["done","failed"]'
+    )
+    # ➜ ('comment', 'str',    'The text "done | failed" goes here')
+    #    ('status',  'Literal["done","failed"]', '')
+
+    SAMPLE_13 = "choice: Literal['He said \\'yes\\'', 'no'] | User response"
+    # ➜ ('choice', "Literal['He said \\'yes\\'', 'no']", 'User response')
+
+    SAMPLE_14 = ""
+    # ➜ []
+
+    SAMPLE_15 = "username"
+    # ➜ [('username', 'str', '')]
+
+    SAMPLE_16 = (
+        "payload: dict[str, list[dict[str, tuple[int,str]]]] "
+        "| Arbitrarily complex structure"
+    )
+    # ➜ ('payload', 'dict[str, list[dict[str, tuple[int,str]]]]',
+    #     'Arbitrarily complex structure')
+
+    SAMPLE_17 = "münze: str | Deutsche Münzbezeichnung, engl. 'coin'"
+    # ➜ [('münze', 'str', "Deutsche Münzbezeichnung, engl. 'coin'")]
+
+    for title, spec in [
+        ("Sample-1", SAMPLE_1),
+        ("Sample-2", SAMPLE_2),
+        ("Sample-3", SAMPLE_3),
+        ("Sample-4", SAMPLE_4),
+        ("Sample-5", SAMPLE_5),
+        ("Sample-6", SAMPLE_6),
+        ("Sample-7", SAMPLE_7),
+        ("Sample-8", SAMPLE_8),
+        ("Sample-9", SAMPLE_9),
+        ("Sample-10", SAMPLE_10),
+        ("Sample-11", SAMPLE_11),
+        ("Sample-12", SAMPLE_12),
+        ("Sample-13", SAMPLE_13),
+        ("Sample-14", SAMPLE_14),
+        ("Sample-15", SAMPLE_15),
+        ("Sample-16", SAMPLE_16),
+        ("Sample-17", SAMPLE_17),
+    ]:
+        print(f"\n{title}")
+        for row in parse_schema(spec):
+            print(row)

flock/webapp/__init__.py

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