flock-core 0.4.0b18__py3-none-any.whl → 0.4.0b20__py3-none-any.whl

flock/cli/utils.py

@@ -0,0 +1,135 @@
+# src/pilot_rules/collector/utils.py
+import datetime
+from pathlib import Path
+from typing import Any
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+# Create a shared console instance for consistent styling
+console = Console()
+
+
+def get_file_metadata(file_path: str) -> dict[str, Any]:
+    """Extract metadata from a file."""
+    metadata = {
+        "path": file_path,
+        "size_bytes": 0,
+        "line_count": 0,
+        "last_modified": "Unknown",
+        "created": "Unknown",
+    }
+
+    try:
+        p = Path(file_path)
+        stats = p.stat()
+        metadata["size_bytes"] = stats.st_size
+        metadata["last_modified"] = datetime.datetime.fromtimestamp(
+            stats.st_mtime
+        ).strftime("%Y-%m-%d %H:%M:%S")
+        # ctime is platform dependent (creation on Windows, metadata change on Unix)
+        # Use mtime as a reliable fallback for "created" if ctime is older than mtime
+        ctime = stats.st_ctime
+        mtime = stats.st_mtime
+        best_ctime = ctime if ctime <= mtime else mtime  # Heuristic
+        metadata["created"] = datetime.datetime.fromtimestamp(
+            best_ctime
+        ).strftime("%Y-%m-%d %H:%M:%S")
+
+        try:
+            # Attempt to read as text, fallback for binary or encoding issues
+            with p.open("r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+                metadata["line_count"] = len(content.splitlines())
+        except (OSError, UnicodeDecodeError) as read_err:
+            # Handle cases where reading might fail (binary file, permissions etc.)
+            console.print(
+                f"[yellow]⚠ Warning:[/yellow] Could not read content/count lines for [cyan]{file_path}[/cyan]: [red]{read_err}[/red]"
+            )
+            metadata["line_count"] = 0  # Indicate unreadable or binary
+
+    except Exception as e:
+        console.print(
+            f"[yellow]⚠ Warning:[/yellow] Could not get complete metadata for [cyan]{file_path}[/cyan]: [red]{e}[/red]"
+        )
+
+    return metadata
+
+
+# --- Rich Formatting Utilities ---
+
+
+def print_header(title: str, style: str = "blue") -> None:
+    """Print a styled header with a panel."""
+    console.rule()
+    console.print(
+        Panel.fit(f"[bold {style}]{title}[/bold {style}]", border_style=style)
+    )
+
+
+def print_subheader(title: str, style: str = "cyan") -> None:
+    """Print a styled subheader."""
+    console.print(f"[bold {style}]== {title} ==[/bold {style}]")
+
+
+def print_success(message: str) -> None:
+    """Print a success message."""
+    console.print(f"[bold green]✓[/bold green] {message}")
+
+
+def print_error(message: str, exit_code: int | None = None) -> None:
+    """Print an error message and optionally exit."""
+    console.print(f"[bold red]✗ ERROR:[/bold red] {message}")
+    if exit_code is not None:
+        exit(exit_code)
+
+
+def print_warning(message: str) -> None:
+    """Print a warning message."""
+    console.print(f"[yellow]⚠ Warning:[/yellow] {message}")
+
+
+def create_progress() -> Progress:
+    """Create a standardized progress bar."""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]{task.description}"),
+        BarColumn(complete_style="green", finished_style="green"),
+        TextColumn("[bold]{task.completed}/{task.total}"),
+        console=console,
+    )
+
+
+def create_task_table(title: str) -> Table:
+    """Create a standardized table for displaying task information."""
+    table = Table(
+        title=title, show_header=True, header_style="bold cyan", box=box.ROUNDED
+    )
+    return table
+
+
+def print_file_stats(files: list[str], title: str = "File Statistics") -> None:
+    """Print statistics about a list of files."""
+    if not files:
+        console.print("[yellow]No files found to display statistics.[/yellow]")
+        return
+
+    table = Table(title=title, show_header=True, header_style="bold magenta")
+    table.add_column("Statistic", style="cyan")
+    table.add_column("Value", style="green")
+
+    extensions = {Path(f).suffix.lower() for f in files if Path(f).suffix}
+    total_size = sum(get_file_metadata(f).get("size_bytes", 0) for f in files)
+    total_lines = sum(get_file_metadata(f).get("line_count", 0) for f in files)
+
+    table.add_row("Total Files", str(len(files)))
+    table.add_row("Total Size", f"{total_size / 1024:.2f} KB")
+    table.add_row("Total Lines", str(total_lines))
+    table.add_row(
+        "Extensions", ", ".join(sorted(extensions)) if extensions else "None"
+    )
+
+    console.print(table)

flock/core/flock.py

@@ -150,8 +150,7 @@ class Flock(BaseModel, Serializable):
                     )
 
         # Initialize console if needed for banner
-        if self.show_flock_banner:  # Use instance attribute
-            init_console()
+        init_console(clear_screen=True, show_banner=self.show_flock_banner)
 
         # Set Temporal debug environment variable
         self._set_temporal_debug_flag()
@@ -225,7 +224,7 @@ class Flock(BaseModel, Serializable):
             raise ValueError("Agent must have a name.")
 
         if agent.name in self._agents:
-            logger.warning(f"Agent '{agent.name}' already exists. Overwriting.")
+            raise ValueError("Agent with this name already exists.")
         self._agents[agent.name] = agent
         FlockRegistry.register_agent(agent)  # Register globally
 

flock/core/flock_factory.py

@@ -38,6 +38,7 @@ class FlockFactory:
         print_context: bool = False,
         write_to_file: bool = False,
         stream: bool = False,
+        include_thought_process: bool = False,
     ) -> FlockAgent:
         """Creates a default FlockAgent.
 
@@ -52,6 +53,7 @@ class FlockFactory:
             max_tokens=max_tokens,
             temperature=temperature,
             stream=stream,
+            include_thought_process=include_thought_process,
         )
 
         evaluator = DeclarativeEvaluator(name="default", config=eval_config)

flock/core/logging/logging.py

@@ -79,6 +79,7 @@ COLOR_MAP = {
     "api.ui.routes": "light-blue",
     "api.ui.utils": "cyan",
     # Default/Unknown
+    "evaluators.declarative": "light-green",
     "unknown": "light-black",
 }
 
@@ -90,6 +91,7 @@ LOGGERS = [
     "serialization",  # General serialization (new - can be base for others)
     "serialization.utils",  # Serialization helpers (new, more specific)
     "evaluator",  # Base evaluator category (new/optional)
+    "evaluators.declarative",  # Declarative evaluator specifics
     "module",  # Base module category (new/optional)
     "router",  # Base router category (new/optional)
     "mixin.dspy",  # DSPy integration specifics (new)

flock/core/mixin/dspy_integration.py

@@ -336,8 +336,9 @@ class DSPyIntegrationMixin:
     def _select_task(
         self,
         signature: Any,
-        agent_type_override: AgentType,
+        override_evaluator_type: AgentType,
         tools: list[Any] | None = None,
+        kwargs: dict[str, Any] = {},
     ) -> Any:
         """Select and instantiate the appropriate DSPy Program/Module."""
         try:
@@ -360,7 +361,7 @@ class DSPyIntegrationMixin:
                     )
 
         dspy_program = None
-        selected_type = agent_type_override
+        selected_type = override_evaluator_type
 
         # Determine type if not overridden
         if not selected_type:
@@ -374,11 +375,12 @@ class DSPyIntegrationMixin:
 
         try:
             if selected_type == "ChainOfThought":
-                dspy_program = dspy.ChainOfThought(signature)
+                dspy_program = dspy.ChainOfThought(signature, **kwargs)
             elif selected_type == "ReAct":
-                # ReAct requires tools, even if empty list
+                if not kwargs:
+                    kwargs = {"max_iters": 10}
                 dspy_program = dspy.ReAct(
-                    signature, tools=processed_tools or [], max_iters=10
+                    signature, tools=processed_tools or [], **kwargs
                 )
             elif selected_type == "Predict":  # Default or explicitly Completion
                 dspy_program = dspy.Predict(signature)
@@ -401,8 +403,10 @@ class DSPyIntegrationMixin:
 
     def _process_result(
         self, result: Any, inputs: dict[str, Any]
-    ) -> dict[str, Any]:
+    ) -> tuple[dict[str, Any], float, list]:
         """Convert the DSPy result object to a dictionary."""
+        import dspy
+
         if result is None:
             logger.warning("DSPy program returned None result.")
             return {}
@@ -429,7 +433,12 @@ class DSPyIntegrationMixin:
             logger.debug(f"Processed DSPy result to dict: {output_dict}")
             # Optionally merge inputs back if desired (can make result dict large)
             final_result = {**inputs, **output_dict}
-            return final_result
+
+            lm = dspy.settings.get("lm")
+            cost = sum([x["cost"] for x in lm.history if x["cost"] is not None])
+            lm_history = lm.inspect_history()
+
+            return final_result, cost, lm_history
 
         except Exception as conv_error:
             logger.error(

flock/core/serialization/serialization_utils.py

@@ -5,8 +5,17 @@ import ast
 import builtins
 import importlib
 import sys
+import types
+import typing
 from collections.abc import Mapping, Sequence
-from typing import TYPE_CHECKING, Any, get_args, get_origin
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    Union,
+    get_args,
+    get_origin,
+)
 
 from pydantic import BaseModel
 
@@ -14,6 +23,7 @@ from pydantic import BaseModel
 if TYPE_CHECKING:
     pass
 
+from flock.core.flock_registry import get_registry
 from flock.core.logging.logging import get_logger
 
 logger = get_logger("serialization.utils")
@@ -23,6 +33,65 @@ logger = get_logger("serialization.utils")
 
 # --- Serialization Helper ---
 
+# src/flock/util/hydrator.py (or import from serialization_utils)
+
+
+def _format_type_to_string(type_hint: type) -> str:
+    """Converts a Python type object back into its string representation."""
+    # This needs to handle various typing scenarios (List, Dict, Union, Optional, Literal, custom types)
+    origin = typing.get_origin(type_hint)
+    args = typing.get_args(type_hint)
+
+    # Handle common cases first
+    if origin is list or origin is list:
+        if args:
+            return f"list[{_format_type_to_string(args[0])}]"
+        return "list[Any]"  # Or just "list"
+    elif origin is dict or origin is dict:
+        if args and len(args) == 2:
+            return f"dict[{_format_type_to_string(args[0])}, {_format_type_to_string(args[1])}]"
+        return "dict[Any, Any]"  # Or just "dict"
+    elif origin is Union or origin is types.UnionType:
+        # Handle Optional[T] as Union[T, NoneType]
+        if len(args) == 2 and type(None) in args:
+            inner_type = next(t for t in args if t is not type(None))
+            return _format_type_to_string(inner_type)
+        # return f"Optional[{_format_type_to_string(inner_type)}]"
+        return (
+            f"Union[{', '.join(_format_type_to_string(arg) for arg in args)}]"
+        )
+    elif origin is Literal:
+        formatted_args = []
+        for arg in args:
+            if isinstance(arg, str):
+                formatted_args.append(f"'{arg}'")
+            else:
+                formatted_args.append(str(arg))
+        return f"Literal[{', '.join(formatted_args)}]"
+    elif hasattr(
+        type_hint, "__forward_arg__"
+    ):  # Handle ForwardRefs if necessary
+        return type_hint.__forward_arg__
+    elif hasattr(type_hint, "__name__"):
+        # Handle custom types registered in registry (get preferred name)
+        registry = get_registry()
+        for (
+            name,
+            reg_type,
+        ) in registry._types.items():  # Access internal for lookup
+            if reg_type == type_hint:
+                return name  # Return registered name
+        return type_hint.__name__  # Fallback to class name if not registered
+    else:
+        # Fallback for complex types or types not handled above
+        type_repr = str(type_hint).replace("typing.", "")  # Basic cleanup
+        type_repr = str(type_hint).replace("| None", "")
+        type_repr = type_repr.strip()
+        logger.debug(
+            f"Using fallback string representation for type: {type_repr}"
+        )
+        return type_repr
+
 
 def extract_identifiers_from_type_str(type_str: str) -> set[str]:
     """Extract all identifiers from a type annotation string using the AST."""

flock/core/util/cli_helper.py

@@ -43,7 +43,7 @@ def display_hummingbird():
 """)
 
 
-def init_console(clear_screen: bool = True):
+def init_console(clear_screen: bool = True, show_banner: bool = True):
     """Display the Flock banner."""
     banner_text = Text(
         f"""
@@ -60,7 +60,9 @@ def init_console(clear_screen: bool = True):
     )
     if clear_screen:
         console.clear()
-    console.print(banner_text)
+
+    if show_banner:
+        console.print(banner_text)
     console.print(
         f"[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
     )