flock-core 0.4.542__py3-none-any.whl → 0.5.0__py3-none-any.whl

flock/cli/utils.py

@@ -1,135 +0,0 @@
-# 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/cli/view_results.py

@@ -1,29 +0,0 @@
-"""View execution results and history.
-
-This module provides functionality to view the results of previous Flock executions.
-"""
-
-from rich.console import Console
-from rich.panel import Panel
-
-from flock.core.flock import Flock
-from flock.core.util.cli_helper import init_console
-
-# Create console instance
-console = Console()
-
-
-def view_results(flock: Flock):
-    """View execution results for a Flock instance.
-
-    Args:
-        flock: The Flock instance to view results for
-    """
-    init_console()
-    console.print(Panel("[bold green]View Results[/]"), justify="center")
-    console.print(
-        "[yellow]Results history functionality not yet implemented.[/]"
-    )
-    console.print(
-        "This feature will allow viewing and filtering past execution results."
-    )

flock/cli/yaml_editor.py

@@ -1,396 +0,0 @@
-"""YAML Editor for Flock CLI.
-
-This module provides functionality to view, edit, and validate YAML configurations
-for Flock and FlockAgent instances.
-"""
-
-import os
-import subprocess
-import tempfile
-from pathlib import Path
-
-import questionary
-import yaml
-from rich.console import Console
-from rich.panel import Panel
-from rich.syntax import Syntax
-from rich.table import Table
-
-from flock.core.flock import Flock
-from flock.core.flock_agent import FlockAgent
-from flock.core.util.cli_helper import init_console
-
-# Create console instance
-console = Console()
-
-
-def yaml_editor(flock_or_agent: Flock | FlockAgent | None = None):
-    """YAML Editor main entry point.
-
-    Args:
-        flock_or_agent: Optional Flock or FlockAgent instance to edit
-    """
-    init_console()
-    console.print(Panel("[bold green]YAML Editor[/]"), justify="center")
-
-    if flock_or_agent is None:
-        # If no object provided, provide options to load from file
-        _yaml_file_browser()
-        return
-
-    while True:
-        init_console()
-        console.print(Panel("[bold green]YAML Editor[/]"), justify="center")
-
-        # Determine object type
-        if isinstance(flock_or_agent, Flock):
-            obj_type = "Flock"
-            console.print(
-                f"Editing [bold cyan]Flock[/] with {len(flock_or_agent._agents)} agents"
-            )
-        elif isinstance(flock_or_agent, FlockAgent):
-            obj_type = "FlockAgent"
-            console.print(
-                f"Editing [bold cyan]FlockAgent[/]: {flock_or_agent.name}"
-            )
-        else:
-            console.print("[bold red]Error: Unknown object type[/]")
-            input("\nPress Enter to continue...")
-            return
-
-        console.line()
-
-        choice = questionary.select(
-            "What would you like to do?",
-            choices=[
-                questionary.Separator(line=" "),
-                "View Current YAML",
-                "Edit YAML Directly",
-                "Abstract Editor (Visual)",
-                "Validate YAML",
-                "Save to File",
-                questionary.Separator(),
-                "Back to Main Menu",
-            ],
-        ).ask()
-
-        if choice == "View Current YAML":
-            _view_yaml(flock_or_agent)
-        elif choice == "Edit YAML Directly":
-            flock_or_agent = _edit_yaml_directly(flock_or_agent)
-        elif choice == "Abstract Editor (Visual)":
-            flock_or_agent = _abstract_editor(flock_or_agent)
-        elif choice == "Validate YAML":
-            _validate_yaml(flock_or_agent)
-        elif choice == "Save to File":
-            _save_to_file(flock_or_agent)
-        elif choice == "Back to Main Menu":
-            break
-
-        if choice != "Back to Main Menu":
-            input("\nPress Enter to continue...")
-
-
-def _yaml_file_browser():
-    """Browser for YAML files to load."""
-    console.print("\n[bold]YAML File Browser[/]")
-    console.line()
-
-    current_dir = os.getcwd()
-    console.print(f"Current directory: [cyan]{current_dir}[/]")
-
-    # List .yaml/.yml files in current directory
-    yaml_files = list(Path(current_dir).glob("*.yaml")) + list(
-        Path(current_dir).glob("*.yml")
-    )
-
-    if not yaml_files:
-        console.print("[yellow]No YAML files found in current directory.[/]")
-        input("\nPress Enter to continue...")
-        return
-
-    # Display files
-    table = Table(title="YAML Files")
-    table.add_column("Filename", style="cyan")
-    table.add_column("Size", style="green")
-    table.add_column("Last Modified", style="yellow")
-
-    for file in yaml_files:
-        table.add_row(
-            file.name, f"{file.stat().st_size} bytes", f"{file.stat().st_mtime}"
-        )
-
-    console.print(table)
-
-    # TODO: Add file selection and loading
-
-
-def _view_yaml(obj: Flock | FlockAgent):
-    """View the YAML representation of an object.
-
-    Args:
-        obj: The object to view as YAML
-    """
-    yaml_str = obj.to_yaml()
-
-    # Add file path information header if it's a Flock with component file paths
-    if isinstance(obj, Flock) and hasattr(obj, "_component_file_paths"):
-        has_file_paths = bool(getattr(obj, "_component_file_paths", {}))
-        if has_file_paths:
-            console.print(
-                "[bold yellow]Note: This Flock contains components with file paths[/]"
-            )
-
-    # Display with syntax highlighting
-    syntax = Syntax(
-        yaml_str,
-        "yaml",
-        theme="monokai",
-        line_numbers=True,
-        code_width=100,
-        word_wrap=True,
-    )
-
-    init_console()
-    console.print(Panel("[bold green]YAML View[/]"), justify="center")
-    console.print(syntax)
-
-    # Show file path information if available
-    if isinstance(obj, Flock):
-        # Get registry for checking file paths
-        try:
-            from flock.core.flock_registry import get_registry
-
-            registry = get_registry()
-
-            if (
-                hasattr(registry, "_component_file_paths")
-                and registry._component_file_paths
-            ):
-                # Get component names in this Flock
-                components = set()
-                for agent in obj._agents.values():
-                    if hasattr(agent, "module") and agent.module:
-                        module_path = getattr(agent.module, "module_path", None)
-                        if module_path:
-                            components.add(module_path)
-
-                # Show file paths for components in this Flock
-                file_paths = []
-                for component_name in components:
-                    if component_name in registry._component_file_paths:
-                        file_paths.append(
-                            (
-                                component_name,
-                                registry._component_file_paths[component_name],
-                            )
-                        )
-
-                if file_paths:
-                    console.print("\n[bold cyan]Component File Paths:[/]")
-                    table = Table()
-                    table.add_column("Component", style="green")
-                    table.add_column("File Path", style="yellow")
-
-                    for component_name, file_path in file_paths:
-                        table.add_row(component_name, file_path)
-
-                    console.print(table)
-        except ImportError:
-            pass  # Skip if registry is not available
-
-
-def _edit_yaml_directly(obj: Flock | FlockAgent) -> Flock | FlockAgent:
-    """Edit the YAML representation directly using an external editor.
-
-    Args:
-        obj: The object to edit
-
-    Returns:
-        The updated object
-    """
-    # Convert to YAML
-    yaml_str = obj.to_yaml()
-
-    # Get file path information if it's a Flock
-    component_file_paths = {}
-    if isinstance(obj, Flock):
-        try:
-            from flock.core.flock_registry import get_registry
-
-            registry = get_registry()
-
-            if hasattr(registry, "_component_file_paths"):
-                # Save the file paths to restore later
-                component_file_paths = registry._component_file_paths.copy()
-        except ImportError:
-            pass
-
-    # Create a temporary file
-    with tempfile.NamedTemporaryFile(
-        suffix=".yaml", mode="w+", delete=False
-    ) as tmp:
-        tmp.write(yaml_str)
-        tmp_path = tmp.name
-
-    try:
-        # Determine which editor to use
-        editor = os.environ.get(
-            "EDITOR", "notepad" if os.name == "nt" else "nano"
-        )
-
-        # Open the editor
-        console.print(
-            f"\nOpening {editor} to edit YAML. Save and exit when done."
-        )
-        subprocess.call([editor, tmp_path])
-
-        # Read updated YAML
-        with open(tmp_path) as f:
-            updated_yaml = f.read()
-
-        # Parse back to object
-        try:
-            if isinstance(obj, Flock):
-                updated_obj = Flock.from_yaml(updated_yaml)
-
-                # Restore file path information
-                if component_file_paths:
-                    from flock.core.flock_registry import get_registry
-
-                    registry = get_registry()
-
-                    if not hasattr(registry, "_component_file_paths"):
-                        registry._component_file_paths = {}
-
-                    # Merge the updated registry with the saved file paths
-                    for (
-                        component_name,
-                        file_path,
-                    ) in component_file_paths.items():
-                        if component_name in registry._components:
-                            registry._component_file_paths[component_name] = (
-                                file_path
-                            )
-
-                console.print("\n[green]✓[/] YAML parsed successfully!")
-                return updated_obj
-            elif isinstance(obj, FlockAgent):
-                updated_obj = FlockAgent.from_yaml(updated_yaml)
-                console.print("\n[green]✓[/] YAML parsed successfully!")
-                return updated_obj
-        except Exception as e:
-            console.print(f"\n[bold red]Error parsing YAML:[/] {e!s}")
-            console.print("\nKeeping original object.")
-            return obj
-
-    finally:
-        # Clean up the temporary file
-        try:
-            os.unlink(tmp_path)
-        except Exception:
-            pass
-
-    return obj
-
-
-def _abstract_editor(obj: Flock | FlockAgent) -> Flock | FlockAgent:
-    """Edit object using an abstract form-based editor.
-
-    Args:
-        obj: The object to edit
-
-    Returns:
-        The updated object
-    """
-    console.print("\n[yellow]Abstract visual editor not yet implemented.[/]")
-    console.print("Will provide a form-based editor for each field.")
-
-    # For now, just return the original object
-    return obj
-
-
-def _validate_yaml(obj: Flock | FlockAgent):
-    """Validate the YAML representation of an object.
-
-    Args:
-        obj: The object to validate
-    """
-    try:
-        yaml_str = obj.to_yaml()
-
-        # Attempt to parse with PyYAML
-        yaml.safe_load(yaml_str)
-
-        # Attempt to deserialize back to object
-        if isinstance(obj, Flock):
-            Flock.from_yaml(yaml_str)
-        elif isinstance(obj, FlockAgent):
-            FlockAgent.from_yaml(yaml_str)
-
-        console.print("\n[green]✓[/] YAML validation successful!")
-    except Exception as e:
-        console.print(f"\n[bold red]YAML validation failed:[/] {e!s}")
-
-
-def _save_to_file(obj: Flock | FlockAgent):
-    """Save object to a YAML file.
-
-    Args:
-        obj: The object to save
-    """
-    # Determine default filename based on object type
-    if isinstance(obj, Flock):
-        default_name = "my_flock.flock.yaml"
-    elif isinstance(obj, FlockAgent):
-        default_name = f"{obj.name}.agent.yaml"
-    else:
-        default_name = "unknown.yaml"
-
-    # Get file path
-    file_path = questionary.text(
-        "Enter file path to save YAML:",
-        default=default_name,
-    ).ask()
-
-    # Ensure the file has the correct extension
-    if not file_path.endswith((".yaml", ".yml")):
-        file_path += ".yaml"
-
-    # Create directory if it doesn't exist
-    save_path = Path(file_path)
-    save_path.parent.mkdir(parents=True, exist_ok=True)
-
-    # For Flock instances, ask about path_type
-    path_type = "absolute"  # Default
-    if isinstance(obj, Flock):
-        path_type_choice = questionary.select(
-            "How should file paths be formatted?",
-            choices=[
-                "absolute (full paths, best for local use)",
-                "relative (relative paths, better for sharing)",
-            ],
-            default="absolute (full paths, best for local use)",
-        ).ask()
-
-        # Extract just the first word
-        path_type = path_type_choice.split()[0]
-
-        console.print(
-            f"[bold]Path type selected: [green]{path_type}[/green][/bold]"
-        )
-
-    try:
-        # Save to file with path_type for Flock instances
-        if isinstance(obj, Flock):
-            obj.to_yaml_file(file_path, path_type=path_type)
-            console.print(
-                f"\n[green]✓[/] Saved to {file_path} with {path_type} paths"
-            )
-        else:
-            # For FlockAgent or other types, use the original method
-            with open(file_path, "w") as f:
-                f.write(obj.to_yaml())
-            console.print(f"\n[green]✓[/] Saved to {file_path}")
-    except Exception as e:
-        console.print(f"\n[bold red]Error saving file:[/] {e!s}")

flock/config.py

@@ -1,56 +0,0 @@
-# flock/config.py
-import os
-
-from decouple import config
-
-from flock.core.logging.telemetry import TelemetryConfig
-
-cfg_file = os.path.expanduser(f"~/.flock/flock.cfg")
-
-
-# -- Connection and External Service Configurations --
-TEMPORAL_SERVER_URL = config("TEMPORAL_SERVER_URL", "localhost:7233")
-DEFAULT_MODEL = config("DEFAULT_MODEL", "openai/gpt-4o")
-
-
-# API Keys and related settings
-TAVILY_API_KEY = config("TAVILY_API_KEY", "")
-GITHUB_PAT = config("GITHUB_PAT", "")
-GITHUB_REPO = config("GITHUB_REPO", "")
-GITHUB_USERNAME = config("GITHUB_USERNAME", "")
-
-# -- Debugging and Logging Configurations --
-LOCAL_DEBUG = config("LOCAL_DEBUG", True)
-LOG_LEVEL = config("LOG_LEVEL", "DEBUG")
-LOGGING_DIR = config("LOGGING_DIR", ".flock/logs")
-
-OTEL_SERVICE_NAME = config("OTL_SERVICE_NAME", "otel-flock")
-JAEGER_ENDPOINT = config(
-    "JAEGER_ENDPOINT", "http://localhost:14268/api/traces"
-)  # Default gRPC endpoint for Jaeger
-JAEGER_TRANSPORT = config(
-    "JAEGER_TRANSPORT", "http"
-).lower()  # Options: "grpc" or "http"
-OTEL_SQL_DATABASE_NAME = config("OTEL_SQL_DATABASE", "flock_events.db")
-OTEL_FILE_NAME = config("OTEL_FILE_NAME", "flock_events.jsonl")
-OTEL_ENABLE_SQL: bool = config("OTEL_ENABLE_SQL", True) == "True"
-OTEL_ENABLE_FILE: bool = config("OTEL_ENABLE_FILE", True) == "True"
-OTEL_ENABLE_JAEGER: bool = config("OTEL_ENABLE_JAEGER", False) == "True"
-OTEL_ENABLE_OTLP: bool = config("OTEL_ENABLE_OTLP", False) == "True"
-OTEL_EXPORTER_OTLP_PROTOCOL: str = config("OTEL_EXPORTER_OTLP_PROTOCOL", "grpc")
-OTEL_EXPORTER_OTLP_ENDPOINT: str = config("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317")
-
-TELEMETRY = TelemetryConfig(
-    OTEL_SERVICE_NAME,
-    JAEGER_ENDPOINT,
-    JAEGER_TRANSPORT,
-    LOGGING_DIR,
-    OTEL_FILE_NAME,
-    OTEL_SQL_DATABASE_NAME,
-    OTEL_ENABLE_JAEGER,
-    OTEL_ENABLE_FILE,
-    OTEL_ENABLE_SQL,
-    OTEL_ENABLE_OTLP,
-    OTEL_EXPORTER_OTLP_PROTOCOL,
-    OTEL_EXPORTER_OTLP_ENDPOINT,
-)

flock/core/__init__.py

@@ -1,44 +0,0 @@
-"""This module contains the core classes of the flock package."""
-
-from flock.core.context.context import FlockContext
-from flock.core.flock import Flock
-from flock.core.flock_agent import FlockAgent
-from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
-from flock.core.flock_factory import FlockFactory
-from flock.core.flock_module import FlockModule, FlockModuleConfig
-from flock.core.flock_registry import (
-    FlockRegistry,
-    flock_callable,
-    flock_component,
-    flock_tool,
-    flock_type,
-    get_registry,
-)
-from flock.core.mcp.flock_mcp_server import (
-    FlockMCPServerBase,
-)
-from flock.core.mcp.flock_mcp_tool_base import FlockMCPToolBase
-from flock.core.mcp.mcp_client import FlockMCPClientBase
-from flock.core.mcp.mcp_client_manager import FlockMCPClientManagerBase
-
-__all__ = [
-    "Flock",
-    "FlockAgent",
-    "FlockContext",
-    "FlockEvaluator",
-    "FlockEvaluatorConfig",
-    "FlockFactory",
-    "FlockMCPClientBase",
-    "FlockMCPClientManagerBase",
-    "FlockMCPServerBase",
-    "FlockMCPServerConfig",
-    "FlockMCPToolBase",
-    "FlockModule",
-    "FlockModuleConfig",
-    "FlockRegistry",
-    "flock_callable",
-    "flock_component",
-    "flock_tool",
-    "flock_type",
-    "get_registry",
-]

flock/core/api/__init__.py

@@ -1,10 +0,0 @@
-# src/flock/core/api/__init__.py
-"""Flock API Server components."""
-
-
-from .models import FlockAPIRequest, FlockAPIResponse
-
-__all__ = [
-    "FlockAPIRequest",
-    "FlockAPIResponse",
-]