agentpool 2.1.9__py3-none-any.whl

agentpool_cli/agent.py

@@ -0,0 +1,175 @@
+"""Agent-related CLI commands."""
+
+from __future__ import annotations
+
+import shutil
+from typing import Annotated
+
+import typer as t
+
+from agentpool_cli import agent_store, resolve_agent_config
+from agentpool_cli.common import verbose_opt
+
+
+agent_cli = t.Typer(help="Agent management commands", no_args_is_help=True)
+
+NAME_HELP = "Name for the configuration (defaults to filename)"
+
+INTERACTIVE_CMD = "--interactive/--no-interactive"
+INTERACTIVE_HELP = "Use interactive configuration wizard"
+
+
+@agent_cli.command("init")
+def init_agent_config(
+    output: Annotated[str, t.Argument(help="Path to write agent configuration file")],
+    name: Annotated[str | None, t.Option("--name", "-n", help=NAME_HELP)] = None,
+    interactive: Annotated[bool, t.Option(INTERACTIVE_CMD, help=INTERACTIVE_HELP)] = False,
+) -> None:
+    """Initialize a new agent configuration file.
+
+    Creates and activates a new agent configuration. The configuration will be
+    automatically registered and set as active.
+    """
+    from pathlib import Path
+
+    if interactive:
+        from agentpool.utils.inspection import validate_import
+
+        validate_import("promptantic", "chat")
+        from promptantic import ModelGenerator
+
+        from agentpool import AgentsManifest
+
+        generator = ModelGenerator()
+        manifest = generator.populate(AgentsManifest)
+        manifest.save(output)
+    else:
+        from agentpool import config_resources
+
+        shutil.copy2(config_resources.AGENTS_TEMPLATE, output)
+
+    config_name = name or Path(output).stem
+    agent_store.add_config(config_name, output)
+    agent_store.set_active(config_name)
+
+    print(f"\nCreated and activated agent configuration {config_name!r}: {output}")
+    print("\nTry these commands:")
+    print("  agentpool list")
+    print("  agentpool chat simple_agent")
+
+
+@agent_cli.command("add")
+def add_agent_file(
+    name: Annotated[str, t.Argument(help="Name for the agent configuration file")],
+    path: Annotated[str, t.Argument(help="Path to agent configuration file")],
+    verbose: bool = verbose_opt,
+) -> None:
+    """Add a new agent configuration file."""
+    try:
+        agent_store.add_config(name, path)
+        t.echo(f"Added agent configuration {name!r} -> {path}")
+    except Exception as e:
+        t.echo(f"Error adding configuration: {e}", err=True)
+        raise t.Exit(1) from e
+
+
+@agent_cli.command("set")
+def set_active_file(
+    name: Annotated[str, t.Argument(help="Name of agent configuration to set as active")],
+    verbose: bool = verbose_opt,
+) -> None:
+    """Set the active agent configuration file."""
+    try:
+        agent_store.set_active(name)
+        t.echo(f"Set {name!r} as active agent configuration")
+    except Exception as e:
+        t.echo(f"Error setting active configuration: {e}", err=True)
+        raise t.Exit(1) from e
+
+
+def list_configs() -> None:
+    """List stored agent configurations."""
+    from rich.console import Console
+    from rich.table import Table
+
+    configs = agent_store.list_configs()
+    active = agent_store.get_active()
+    active_name = active.name if active else None
+
+    if not configs:
+        t.echo("No configurations stored. Use 'agentpool add' to add one.")
+        return
+
+    table = Table(title="Stored Configurations")
+    table.add_column("Name", style="cyan")
+    table.add_column("Path")
+    table.add_column("Active", justify="center")
+
+    for name, path in configs:
+        marker = "✓" if name == active_name else ""
+        table.add_row(name, path, marker)
+
+    Console().print(table)
+
+
+def list_agents(
+    config_name: Annotated[
+        str | None,
+        t.Option(
+            "-c",
+            "--config",
+            help="Name of agent configuration to list (defaults to active)",
+        ),
+    ] = None,
+    verbose: bool = verbose_opt,
+) -> None:
+    """List agents from the active (or specified) configuration."""
+    import yaml
+
+    try:
+        try:
+            config_path = resolve_agent_config(config_name)
+        except ValueError as e:
+            msg = str(e)
+            raise t.BadParameter(msg) from e
+
+        # Parse YAML directly without loading full manifest
+        from upathtools import to_upath
+
+        text = to_upath(config_path).read_text()
+        data = yaml.safe_load(text)
+
+        agents = data.get("agents", {})
+        if not agents:
+            t.echo("No agents found in configuration.")
+            return
+
+        from rich.console import Console
+        from rich.table import Table
+
+        table = Table(title="Agents")
+        table.add_column("Name", style="cyan")
+        table.add_column("Type", style="magenta")
+        table.add_column("Display Name")
+        table.add_column("Description")
+
+        for name, config in agents.items():
+            agent_type = config.get("type", "native")
+            display = config.get("display_name", name)
+            desc = config.get("description", "")
+            # Truncate long descriptions
+            if len(desc) > 50:  # noqa: PLR2004
+                desc = desc[:47] + "..."
+            table.add_row(name, agent_type, display, desc)
+
+        Console().print(table)
+
+    except t.Exit:
+        raise
+    except Exception as e:
+        t.echo(f"Error: {e}", err=True)
+        if verbose:
+            import traceback
+
+            t.echo(traceback.format_exc(), err=True)
+        raise t.Exit(1) from e

agentpool_cli/cli_types.py

@@ -0,0 +1,23 @@
+"""Type definitions for CLI options."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+
+# Log levels
+LogLevel = Literal["debug", "info", "warning", "error"]
+
+# Output detail levels
+DetailLevel = Literal["simple", "detailed", "markdown"]
+
+# Statistics grouping options
+GroupBy = Literal["agent", "model", "hour", "day"]
+
+OutputFormat = Literal["json", "yaml", "table", "text"]
+
+# Provider types
+Provider = Literal["pydantic_ai"]
+
+# Merge methods for pull requests
+MergeMethod = Literal["merge", "squash", "rebase"]

agentpool_cli/common.py

@@ -0,0 +1,163 @@
+"""Common utilities for the CLI."""
+
+from __future__ import annotations
+
+from datetime import datetime
+import json
+import logging
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+import sys
+from typing import TYPE_CHECKING, Any, Literal, assert_never
+
+import platformdirs
+import typer as t
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+OutputFormat = Literal["text", "json", "yaml"]
+
+CONFIG_HELP = "Path to config file or name of stored config"
+OUTPUT_FORMAT_HELP = "Output format. One of: text, json, yaml"
+VERBOSE_HELP = "Enable debug logging"
+# Command options
+OUTPUT_FORMAT_CMDS = "-o", "--output-format"
+VERBOSE_CMDS = "-v", "--verbose"
+
+LOG_DIR = Path(platformdirs.user_log_dir("agentpool", "agentpool"))
+TIMESTAMP = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+LOG_FILE = LOG_DIR / f"agentpool_{TIMESTAMP}.log"
+
+MAX_LOG_SIZE = 10 * 1024 * 1024  # (10MB)
+
+BACKUP_COUNT = 5
+
+
+def setup_logging(
+    *,
+    level: int | str = logging.INFO,
+    handlers: Sequence[logging.Handler] | None = None,
+    format_string: str | None = None,
+    log_to_file: bool = True,
+) -> None:
+    """Configure logging.
+
+    Args:
+        level: The logging level for console output
+        handlers: Optional sequence of handlers to add
+        format_string: Optional custom format string
+        log_to_file: Whether to log to file in addition to stdout
+    """
+    logger = logging.getLogger("agentpool")
+    logger.setLevel(logging.DEBUG)
+    format_string = format_string or "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    formatter = logging.Formatter(format_string)
+    if not handlers:
+        handlers = []
+        # Add stdout handler with user-specified level
+        stdout_handler = logging.StreamHandler(sys.stdout)
+        stdout_handler.setFormatter(formatter)
+        stdout_handler.setLevel(level)
+        handlers.append(stdout_handler)
+        # Add file handler if requested (always DEBUG level)
+        if log_to_file:
+            try:
+                LOG_DIR.mkdir(parents=True, exist_ok=True)
+                file_handler = RotatingFileHandler(
+                    LOG_FILE,
+                    maxBytes=MAX_LOG_SIZE,
+                    backupCount=BACKUP_COUNT,
+                    encoding="utf-8",
+                )
+                file_handler.setFormatter(formatter)
+                file_handler.setLevel(logging.DEBUG)
+                handlers.append(file_handler)
+            except Exception as exc:  # noqa: BLE001
+                msg = f"Failed to create log file: {exc}"
+                print(msg, file=sys.stderr)
+
+    for handler in handlers:
+        if not handler.formatter:
+            handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    logger.info("Logging initialized")
+    if log_to_file:
+        msg = "Console logging level: %s, File logging level: DEBUG (%s)"
+        logger.debug(msg, logging.getLevelName(level), LOG_FILE)
+
+
+def complete_config_names() -> list[str]:
+    """Complete stored config names."""
+    from agentpool_cli import agent_store
+
+    return [name for name, _ in agent_store.list_configs()]
+
+
+def complete_output_formats() -> list[str]:
+    """Complete output format options."""
+    return ["text", "json", "yaml"]
+
+
+def verbose_callback(ctx: t.Context, _param: t.CallbackParam, value: bool) -> bool:
+    """Handle verbose flag."""
+    if value:
+        setup_logging(level=logging.DEBUG)
+    return value
+
+
+output_format_opt = t.Option(
+    "text",
+    *OUTPUT_FORMAT_CMDS,
+    help=OUTPUT_FORMAT_HELP,
+    autocompletion=complete_output_formats,
+)
+verbose_opt = t.Option(False, *VERBOSE_CMDS, help=VERBOSE_HELP, callback=verbose_callback)
+
+
+def format_output(result: Any, output_format: OutputFormat = "text") -> None:
+    """Format and print data in the requested format using TypeAdapter.
+
+    Args:
+        result: Any object to format
+        output_format: One of: text, json, yaml
+    """
+    from pydantic import TypeAdapter
+    from rich.console import Console
+
+    adapter = TypeAdapter(type(result))
+    data = adapter.dump_python(result)
+    console = Console()
+    match output_format:
+        case "json":
+            print(json.dumps(data, indent=2, default=str))
+        case "yaml":
+            import yamling
+
+            print(yamling.dump_yaml(data))
+        case "text":
+            console.print(data)
+        case _ as unreachable:
+            assert_never(unreachable)
+
+
+if __name__ == "__main__":
+    from dataclasses import dataclass
+
+    @dataclass
+    class Person:
+        """Test class."""
+
+        name: str
+        age: int
+
+    people = [Person("Alice", 30), Person("Bob", 25)]
+
+    print("=== JSON ===")
+    format_output(people, "json")
+    print("\n=== YAML ===")
+    format_output(people, "yaml")
+    print("\n=== TEXT ===")
+    format_output(people, "text")

agentpool_cli/create.py

@@ -0,0 +1,175 @@
+"""Web interface commands."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated, Any, ClassVar
+
+import typer
+
+from agentpool_cli.cli_types import Provider  # noqa: TC001
+
+
+def create(
+    output: Annotated[
+        str | None,
+        typer.Option(
+            "-o",
+            "--output",
+            help="Output file path. If not provided, only displays the config.",
+        ),
+    ] = None,
+    add_to_store: Annotated[
+        bool, typer.Option("-a", "--add-to-store", help="Add generated config to ConfigStore")
+    ] = False,
+    model: Annotated[
+        str, typer.Option("-m", "--model", help="Model to use for generation")
+    ] = "gpt-5",
+    provider: Annotated[
+        Provider, typer.Option("-p", "--provider", help="Provider to use")
+    ] = "pydantic_ai",
+) -> None:
+    """Interactive config generator for agents and teams."""
+    from schemez import YAMLCode
+    from textual.app import App
+    from textual.binding import Binding
+    from textual.containers import ScrollableContainer
+    from textual.widgets import Header, Input, Static
+
+    from agentpool import Agent, AgentsManifest
+    from agentpool.agents.architect import create_architect_agent
+    from agentpool.utils.count_tokens import count_tokens
+    from agentpool_cli import agent_store
+
+    if TYPE_CHECKING:
+        from textual.app import ComposeResult
+
+    class StatsDisplay(Static):
+        """Display for token count and validation status."""
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            super().__init__(*args, markup=kwargs.pop("markup", False), **kwargs)
+
+        def update_stats(self, token_count: int, status: str | None = None) -> None:
+            """Update the stats display."""
+            text = f"Context tokens: {token_count:,}"
+            if status:
+                text = f"{status} | {text}"
+            self.update(text)
+
+    class YamlDisplay(ScrollableContainer):
+        """Display for YAML content with syntax highlighting."""
+
+        def __init__(self) -> None:
+            super().__init__()
+            self._content = Static("")
+
+        def compose(self) -> ComposeResult:
+            """Initial empty content."""
+            yield self._content
+
+        def update_yaml(self, content: str) -> None:
+            """Update the YAML content with syntax highlighting."""
+            from rich.syntax import Syntax
+
+            syntax = Syntax(content, "yaml", theme="monokai")
+            self._content.update(syntax)
+
+    class ConfigGeneratorApp(App[None]):
+        """Application for generating configuration files."""
+
+        CSS = """
+        Screen {
+            layout: grid;
+            grid-size: 1;
+            padding: 1;
+        }
+
+        Input {
+            dock: top;
+            margin: 1 0;
+        }
+
+        YamlDisplay {
+            height: 1fr;
+            border: solid green;
+        }
+
+        StatsDisplay {
+            dock: bottom;
+            height: 3;
+            content-align: center middle;
+        }
+        """
+
+        BINDINGS: ClassVar = [
+            Binding("ctrl+s", "save", "Save Config", show=True),
+            ("escape", "quit", "Quit"),
+        ]
+
+        def __init__(
+            self,
+            model: str = "openai:gpt-5-mini",
+            output_path: str | None = None,
+            add_to_store: bool = False,
+        ) -> None:
+            from upathtools import to_upath
+
+            super().__init__()
+            agent = Agent(output_type=YAMLCode)
+            self.agent = agent
+            self.current_config: str | None = None
+            self.output_path = to_upath(output_path) if output_path else None
+            self.add_to_store = add_to_store
+            self._token_count: int = 0
+
+        def compose(self) -> ComposeResult:
+            yield Header()
+            yield Input(placeholder="Describe your configuration needs...")
+            yield YamlDisplay()
+            yield StatsDisplay("Context tokens: calculating...")
+
+        async def on_mount(self) -> None:
+            """Load schema and calculate token count."""
+            self.agent = await create_architect_agent(model="openai:gpt-5-nano")
+            assert self.agent.model_name
+            model_name = self.agent.model_name.split(":")[-1]
+            context = await self.agent.conversation.format_history()
+            self._token_count = count_tokens(context, model_name)
+            stats = self.query_one(StatsDisplay)
+            stats.update_stats(self._token_count)
+
+        async def on_input_submitted(self, message: Input.Submitted) -> None:
+            """Generate config when user hits enter."""
+            from pydantic import ValidationError
+            from yamling import YAMLError
+
+            yaml = await self.agent.run(message.value)
+            self.current_config = yaml.content.code
+            try:
+                AgentsManifest.from_yaml(yaml.content.code)
+                status = "✓ Valid configuration"
+            except (ValidationError, YAMLError) as e:
+                status = f"✗ Invalid: {e}"
+
+            content = self.query_one(YamlDisplay)
+            content.update_yaml(yaml.content.code)
+            stats = self.query_one(StatsDisplay)
+            stats.update_stats(self._token_count, status)
+
+        def action_save(self) -> None:
+            """Save current config."""
+            if not self.current_config:
+                self.notify("No configuration generated yet!")
+                return
+
+            if not self.output_path:
+                self.notify("No output path specified!")
+                return
+
+            self.output_path.write_text(self.current_config)
+            if self.add_to_store:
+                agent_store.add_config(self.output_path.stem, str(self.output_path))
+            self.notify(f"Saved to {self.output_path}")
+
+    app = ConfigGeneratorApp(model=model, provider=provider)  # type: ignore
+    app.run()