ouroboros-ai 0.1.0__py3-none-any.whl

ouroboros/cli/formatters/__init__.py

@@ -0,0 +1,31 @@
+"""Rich formatters for CLI output.
+
+This module provides a shared Console instance and exports all formatters
+for consistent terminal output across the Ouroboros CLI.
+
+Semantic Colors:
+- green: success
+- yellow: warning
+- red: error
+- blue: info
+"""
+
+from rich.console import Console
+from rich.theme import Theme
+
+# Semantic color theme for consistent output
+OUROBOROS_THEME = Theme(
+    {
+        "success": "green",
+        "warning": "yellow",
+        "error": "red",
+        "info": "blue",
+        "muted": "dim",
+        "highlight": "bold cyan",
+    }
+)
+
+# Shared Console instance for all CLI modules
+console = Console(theme=OUROBOROS_THEME)
+
+__all__ = ["console", "OUROBOROS_THEME"]

ouroboros/cli/formatters/panels.py

@@ -0,0 +1,157 @@
+"""Rich panels for important messages.
+
+Provides panel templates for displaying info, warning, error,
+and success messages with consistent styling.
+"""
+
+from rich.panel import Panel
+
+from ouroboros.cli.formatters import console
+
+
+def info_panel(
+    message: str,
+    title: str = "Info",
+    *,
+    expand: bool = False,
+) -> Panel:
+    """Create an info panel with blue styling.
+
+    Args:
+        message: Message content to display.
+        title: Panel title.
+        expand: Whether to expand panel to full width.
+
+    Returns:
+        Configured Rich Panel.
+    """
+    return Panel(
+        f"[info]{message}[/]",
+        title=f"[bold blue]{title}[/]",
+        border_style="blue",
+        expand=expand,
+    )
+
+
+def warning_panel(
+    message: str,
+    title: str = "Warning",
+    *,
+    expand: bool = False,
+) -> Panel:
+    """Create a warning panel with yellow styling.
+
+    Args:
+        message: Message content to display.
+        title: Panel title.
+        expand: Whether to expand panel to full width.
+
+    Returns:
+        Configured Rich Panel.
+    """
+    return Panel(
+        f"[warning]{message}[/]",
+        title=f"[bold yellow]{title}[/]",
+        border_style="yellow",
+        expand=expand,
+    )
+
+
+def error_panel(
+    message: str,
+    title: str = "Error",
+    *,
+    expand: bool = False,
+) -> Panel:
+    """Create an error panel with red styling.
+
+    Args:
+        message: Message content to display.
+        title: Panel title.
+        expand: Whether to expand panel to full width.
+
+    Returns:
+        Configured Rich Panel.
+    """
+    return Panel(
+        f"[error]{message}[/]",
+        title=f"[bold red]{title}[/]",
+        border_style="red",
+        expand=expand,
+    )
+
+
+def success_panel(
+    message: str,
+    title: str = "Success",
+    *,
+    expand: bool = False,
+) -> Panel:
+    """Create a success panel with green styling.
+
+    Args:
+        message: Message content to display.
+        title: Panel title.
+        expand: Whether to expand panel to full width.
+
+    Returns:
+        Configured Rich Panel.
+    """
+    return Panel(
+        f"[success]{message}[/]",
+        title=f"[bold green]{title}[/]",
+        border_style="green",
+        expand=expand,
+    )
+
+
+def print_info(message: str, title: str = "Info") -> None:
+    """Print an info message in a panel.
+
+    Args:
+        message: Message content to display.
+        title: Panel title.
+    """
+    console.print(info_panel(message, title))
+
+
+def print_warning(message: str, title: str = "Warning") -> None:
+    """Print a warning message in a panel.
+
+    Args:
+        message: Message content to display.
+        title: Panel title.
+    """
+    console.print(warning_panel(message, title))
+
+
+def print_error(message: str, title: str = "Error") -> None:
+    """Print an error message in a panel.
+
+    Args:
+        message: Message content to display.
+        title: Panel title.
+    """
+    console.print(error_panel(message, title))
+
+
+def print_success(message: str, title: str = "Success") -> None:
+    """Print a success message in a panel.
+
+    Args:
+        message: Message content to display.
+        title: Panel title.
+    """
+    console.print(success_panel(message, title))
+
+
+__all__ = [
+    "info_panel",
+    "warning_panel",
+    "error_panel",
+    "success_panel",
+    "print_info",
+    "print_warning",
+    "print_error",
+    "print_success",
+]

ouroboros/cli/formatters/progress.py

@@ -0,0 +1,112 @@
+"""Rich progress bars for async operations.
+
+Provides spinner-based progress indication for long-running operations,
+with async-aware context managers for clean progress display.
+"""
+
+from collections.abc import AsyncIterator, Iterator
+from contextlib import asynccontextmanager, contextmanager
+
+from rich.progress import Progress, SpinnerColumn, TaskID, TextColumn, TimeElapsedColumn
+
+from ouroboros.cli.formatters import console
+
+
+def create_progress() -> Progress:
+    """Create a Progress instance with spinner for async operations.
+
+    Returns:
+        Progress instance configured with spinner, text, and elapsed time columns.
+    """
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        TimeElapsedColumn(),
+        console=console,
+        transient=True,
+    )
+
+
+@contextmanager
+def progress_spinner(description: str = "Processing...") -> Iterator[tuple[Progress, TaskID]]:
+    """Context manager for displaying a progress spinner.
+
+    Args:
+        description: Text description to display alongside the spinner.
+
+    Yields:
+        Tuple of (Progress instance, TaskID) for the running task.
+
+    Example:
+        with progress_spinner("Loading configuration...") as (progress, task):
+            # Do work here
+            pass
+    """
+    progress = create_progress()
+    with progress:
+        task_id = progress.add_task(description, total=None)
+        yield progress, task_id
+
+
+@asynccontextmanager
+async def async_progress_spinner(
+    description: str = "Processing...",
+) -> AsyncIterator[tuple[Progress, TaskID]]:
+    """Async context manager for displaying a progress spinner.
+
+    Use this for async operations that need visual progress indication.
+
+    Args:
+        description: Text description to display alongside the spinner.
+
+    Yields:
+        Tuple of (Progress instance, TaskID) for the running task.
+
+    Example:
+        async with async_progress_spinner("Fetching data...") as (progress, task):
+            await fetch_data()
+    """
+    progress = create_progress()
+    with progress:
+        task_id = progress.add_task(description, total=None)
+        yield progress, task_id
+
+
+def create_determinate_progress(
+    total: float,
+    description: str = "Processing...",
+) -> tuple[Progress, TaskID]:
+    """Create a determinate progress bar for operations with known total.
+
+    Args:
+        total: Total number of steps/items.
+        description: Text description to display.
+
+    Returns:
+        Tuple of (Progress instance, TaskID). Caller must manage Progress lifecycle.
+
+    Example:
+        progress, task = create_determinate_progress(100, "Processing files...")
+        with progress:
+            for i in range(100):
+                do_work()
+                progress.update(task, advance=1)
+    """
+    progress = Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        "[progress.percentage]{task.percentage:>3.0f}%",
+        TimeElapsedColumn(),
+        console=console,
+        transient=True,
+    )
+    task_id = progress.add_task(description, total=total)
+    return progress, task_id
+
+
+__all__ = [
+    "create_progress",
+    "progress_spinner",
+    "async_progress_spinner",
+    "create_determinate_progress",
+]

ouroboros/cli/formatters/tables.py

@@ -0,0 +1,166 @@
+"""Rich tables for structured data display.
+
+Provides table formatting utilities with consistent styling
+for displaying structured data in the Ouroboros CLI.
+"""
+
+from typing import Any
+
+from rich.table import Table
+
+from ouroboros.cli.formatters import console
+
+
+def create_table(
+    title: str | None = None,
+    *,
+    show_header: bool = True,
+    show_lines: bool = False,
+    border_style: str = "blue",
+    header_style: str = "bold cyan",
+    row_styles: list[str] | None = None,
+) -> Table:
+    """Create a Rich Table with consistent Ouroboros styling.
+
+    Args:
+        title: Optional table title.
+        show_header: Whether to show the header row.
+        show_lines: Whether to show lines between rows.
+        border_style: Style for table borders.
+        header_style: Style for header row.
+        row_styles: Alternating row styles (default: subtle alternation).
+
+    Returns:
+        Configured Rich Table instance.
+
+    Example:
+        table = create_table("Results")
+        table.add_column("Name", style="cyan")
+        table.add_column("Status", style="green")
+        table.add_row("Task 1", "Complete")
+        print_table(table)
+    """
+    if row_styles is None:
+        row_styles = ["", "dim"]
+
+    return Table(
+        title=title,
+        show_header=show_header,
+        show_lines=show_lines,
+        border_style=border_style,
+        header_style=header_style,
+        row_styles=row_styles,
+    )
+
+
+def create_key_value_table(
+    data: dict[str, Any],
+    title: str | None = None,
+    *,
+    key_style: str = "cyan",
+    value_style: str = "",
+) -> Table:
+    """Create a two-column table for key-value data.
+
+    Args:
+        data: Dictionary of key-value pairs to display.
+        title: Optional table title.
+        key_style: Style for the key column.
+        value_style: Style for the value column.
+
+    Returns:
+        Rich Table populated with the key-value data.
+
+    Example:
+        info = {"Version": "1.0.0", "Status": "Running"}
+        table = create_key_value_table(info, "System Info")
+        print_table(table)
+    """
+    table = create_table(title, show_header=False)
+    table.add_column("Key", style=key_style, no_wrap=True)
+    table.add_column("Value", style=value_style)
+
+    for key, value in data.items():
+        table.add_row(str(key), str(value))
+
+    return table
+
+
+def create_status_table(
+    items: list[dict[str, Any]],
+    title: str | None = None,
+    *,
+    name_key: str = "name",
+    status_key: str = "status",
+) -> Table:
+    """Create a table for displaying status information.
+
+    Automatically applies semantic colors based on status values:
+    - "success", "complete", "running": green
+    - "warning", "pending": yellow
+    - "error", "failed": red
+
+    Args:
+        items: List of dictionaries containing at least name and status.
+        title: Optional table title.
+        name_key: Key for the name/identifier field.
+        status_key: Key for the status field.
+
+    Returns:
+        Rich Table populated with status information.
+
+    Example:
+        items = [
+            {"name": "Task 1", "status": "complete"},
+            {"name": "Task 2", "status": "running"},
+        ]
+        table = create_status_table(items, "Task Status")
+        print_table(table)
+    """
+    table = create_table(title)
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Status", justify="center")
+
+    for item in items:
+        name = str(item.get(name_key, ""))
+        status = str(item.get(status_key, ""))
+        status_style = _get_status_style(status)
+        table.add_row(name, f"[{status_style}]{status}[/]")
+
+    return table
+
+
+def _get_status_style(status: str) -> str:
+    """Get semantic style for a status value.
+
+    Args:
+        status: Status string to style.
+
+    Returns:
+        Style string for Rich formatting.
+    """
+    status_lower = status.lower()
+    if status_lower in ("success", "complete", "completed", "running", "active", "ok"):
+        return "success"
+    elif status_lower in ("warning", "pending", "waiting", "paused"):
+        return "warning"
+    elif status_lower in ("error", "failed", "failure", "critical"):
+        return "error"
+    return ""
+
+
+def print_table(table: Table) -> None:
+    """Print a Rich Table to the shared console.
+
+    Args:
+        table: Table to print.
+    """
+    console.print(table)
+
+
+__all__ = [
+    "create_table",
+    "create_key_value_table",
+    "create_status_table",
+    "print_table",
+]

ouroboros/cli/main.py

@@ -0,0 +1,60 @@
+"""Ouroboros CLI main entry point.
+
+This module defines the main Typer application and registers
+all command groups for the Ouroboros CLI.
+"""
+
+from typing import Annotated
+
+import typer
+
+from ouroboros import __version__
+from ouroboros.cli.commands import config, init, run, status
+from ouroboros.cli.formatters import console
+
+# Create the main Typer app
+app = typer.Typer(
+    name="ouroboros",
+    help="Ouroboros - Self-Improving AI Workflow System",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+# Register command groups
+app.add_typer(init.app, name="init")
+app.add_typer(run.app, name="run")
+app.add_typer(config.app, name="config")
+app.add_typer(status.app, name="status")
+
+
+def version_callback(value: bool) -> None:
+    """Print version and exit."""
+    if value:
+        console.print(f"[bold cyan]Ouroboros[/] version [green]{__version__}[/]")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool | None,
+        typer.Option(
+            "--version",
+            "-V",
+            callback=version_callback,
+            is_eager=True,
+            help="Show version and exit.",
+        ),
+    ] = None,
+) -> None:
+    """Ouroboros - Self-Improving AI Workflow System.
+
+    A self-improving AI workflow system with 6 phases:
+    Big Bang, PAL Router, Execution, Resilience, Evaluation, and Consensus.
+
+    Use [bold cyan]ouroboros COMMAND --help[/] for command-specific help.
+    """
+    pass
+
+
+__all__ = ["app", "main"]

ouroboros/config/__init__.py

@@ -0,0 +1,81 @@
+"""Configuration module for Ouroboros.
+
+This module provides configuration loading, validation, and management
+for the Ouroboros system. Configuration is stored in ~/.ouroboros/.
+
+Main exports:
+    OuroborosConfig: Main configuration model
+    CredentialsConfig: Provider credentials model
+    TierConfig: Tier configuration model
+    load_config: Load config from YAML file
+    load_credentials: Load credentials from YAML file
+    create_default_config: Create default config files
+    config_exists: Check if config files exist
+
+Usage:
+    from ouroboros.config import load_config, load_credentials
+
+    config = load_config()
+    credentials = load_credentials()
+
+    # Access configuration
+    default_tier = config.economics.default_tier
+    api_key = credentials.providers["openai"].api_key
+"""
+
+from ouroboros.config.loader import (
+    config_exists,
+    create_default_config,
+    credentials_file_secure,
+    ensure_config_dir,
+    load_config,
+    load_credentials,
+)
+from ouroboros.config.models import (
+    ClarificationConfig,
+    ConsensusConfig,
+    CredentialsConfig,
+    DriftConfig,
+    EconomicsConfig,
+    EvaluationConfig,
+    ExecutionConfig,
+    LoggingConfig,
+    ModelConfig,
+    OuroborosConfig,
+    PersistenceConfig,
+    ProviderCredentials,
+    ResilienceConfig,
+    TierConfig,
+    get_config_dir,
+    get_default_config,
+    get_default_credentials,
+)
+
+__all__ = [
+    # Models
+    "OuroborosConfig",
+    "CredentialsConfig",
+    "TierConfig",
+    "ModelConfig",
+    "ProviderCredentials",
+    "EconomicsConfig",
+    "ClarificationConfig",
+    "ExecutionConfig",
+    "ResilienceConfig",
+    "EvaluationConfig",
+    "ConsensusConfig",
+    "PersistenceConfig",
+    "DriftConfig",
+    "LoggingConfig",
+    # Loader functions
+    "load_config",
+    "load_credentials",
+    "create_default_config",
+    "ensure_config_dir",
+    "config_exists",
+    "credentials_file_secure",
+    # Model helpers
+    "get_config_dir",
+    "get_default_config",
+    "get_default_credentials",
+]