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

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

@@ -39,12 +39,13 @@ news/
 hierarchical_memory/
 .repomix-output.txt
 .sesskey
-
+.flock_ui_projects/
 .env.*
 .flock/
 memory.txt
 pet_diary.json
 pet_state.json
+repository_data.txt
 
 # PyInstaller
 #  Usually these files are written by a python script from a template

{flock_core-0.4.0b33 → 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.0b33 → flock_core-0.4.0b35}/PKG-INFO

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

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

{flock_core-0.4.0b33 → 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.0b33 → 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/core/util/spliter.py

@@ -0,0 +1,211 @@
+import re
+
+
+def split_top_level(spec: str) -> list[str]:
+    """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 identifier
+
+    while i < len(spec):
+        ch = spec[i]
+
+        # ---------- 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 {"'", '"'}:
+            prev = spec[i - 1] if i else " "
+            if (
+                depth or prev.isspace() or prev in "=([{,:"
+            ):  # looks like a quote
+                quote_char = ch
+            i += 1
+            continue
+
+        # ---------- bracket / brace / paren ----------
+        if ch in "([{":
+            depth += 1
+            i += 1
+            continue
+        if ch in ")]}":
+            depth = max(depth - 1, 0)
+            i += 1
+            continue
+
+        # ---------- field separators ----------
+        if ch == "," and depth == 0:
+            j = i + 1
+            while j < len(spec) and spec[j].isspace():
+                j += 1
+            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
+
+    fields.append(spec[start:].strip())
+    return [f for f in fields if f]  # prune empties
+
+
+def parse_schema(spec: str) -> list[tuple[str, str, str]]:
+    """Turn *spec* into a list of (name, python_type, description)."""
+    result: list[tuple[str, str, str]] = []
+
+    for field in split_top_level(spec):
+        name = ""
+        type_str = "str"  # default type
+        description = ""
+
+        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
+
+        if name:  # skip broken pieces
+            result.append((name, type_str, description))
+
+    return result
+
+
+# ------------------------------ demo ------------------------------
+if __name__ == "__main__":
+    SAMPLE_1 = (
+        " name: str | The character's full name,"
+        "race: str | The character's fantasy race,"
+        "class: Literal['mage','thief'] | The character's profession,"
+        "background: str | A brief backstory for the character"
+    )
+
+    SAMPLE_2 = (
+        "field_with_internal_quotes: Literal['type_A', "
+        '"type_B_with_\'_apostrophe"] | A literal with mixed quotes,'
+        " 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')]
+
+    SAMPLE_7 = "path: str | The literal string 'C:\\\\Program Files\\\\My,App'"
+
+    # ➜ [('path', 'str',
+    #     "The literal string 'C:\\Program Files\\My,App'")]
+
+    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_core-0.4.0b35/src/flock/webapp/__init__.py

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