polycoding 0.1.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,53 @@
+"""Central CLI tool for Polycode.
+
+Entry point: `polycode` command.
+
+Usage:
+    polycode server webhook       # Start webhook server
+    polycode server socketio      # Start Socket.IO server
+    polycode server flower        # Start Flower monitoring
+    polycode worker start         # Start Celery worker
+    polycode flow run ralph     # Run a flow manually
+    polycode project sync         # Sync issues to project
+"""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+__version__ = "0.1.0"
+
+
+def print_banner():
+    """Print pretty CLI banner."""
+    banner = Text.assemble(
+        ("🚀 ", "bold cyan"),
+        ("polycode", "bold white"),
+        (f" v{__version__}", "dim"),
+    )
+    console.print(Panel(banner, border_style="cyan"))
+
+
+def print_error(message: str) -> None:
+    """Print error message in red."""
+    console.print(f"[bold red]❌ {message}[/]")
+
+
+def print_success(message: str) -> None:
+    """Print success message in green."""
+    console.print(f"[bold green]✓ {message}[/]")
+
+
+def print_warning(message: str) -> None:
+    """Print warning message in yellow."""
+    console.print(f"[bold yellow]⚠️ {message}[/]")
+
+
+def print_info(message: str) -> None:
+    """Print info message in blue."""
+    console.print(f"[bold blue]ℹ️ {message}[/]")
+
+
+__all__ = ["print_error", "print_success", "print_warning", "print_info", "console"]

cli/db.py

@@ -0,0 +1,67 @@
+"""Database management commands for Polycode CLI."""
+
+import sys
+
+import typer
+from sqlalchemy import create_engine
+
+from cli import print_error, print_info, print_success, print_warning
+from cli.utils import get_logger
+from persistence.postgres import Base
+
+log = get_logger(__name__)
+db_app = typer.Typer(help="Database management commands")
+
+
+@db_app.command("init")
+def db_init(
+    drop: bool = typer.Option(False, "--drop", help="Drop existing tables first"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Initialize database tables.
+
+    Creates all tables defined in the persistence layer.
+    """
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_info("🔧 Initializing database...")
+
+    try:
+        from project_manager.config import settings
+
+        connection_string = settings.DATABASE_URL
+        engine = create_engine(connection_string)
+
+        if drop:
+            print_info("🗑 Dropping existing tables...")
+            Base.metadata.drop_all(engine)
+            print_success("Existing tables dropped")
+
+        print_info("📊 Creating tables...")
+        Base.metadata.create_all(engine)
+        print_success("Database initialized successfully")
+
+    except Exception as e:
+        print_error(f"Database initialization failed: {e}")
+        log.exception(f"Database init failed: {e}")
+        sys.exit(1)
+
+
+@db_app.command("migrate")
+def db_migrate(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Run database migrations.
+
+    Note: Migration support not yet implemented.
+    """
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_warning("⚠️ Migration support not yet implemented")
+    print_info("Use 'polycode db init --drop' to recreate tables")

cli/flow.py

@@ -0,0 +1,187 @@
+"""Flow execution commands for Polycode CLI."""
+
+import json
+import sys
+from typing import Any
+
+import typer
+from alive_progress import alive_bar
+from uuid import NAMESPACE_DNS, uuid5
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from bootstrap import init_plugins
+from cli import print_error, print_info, print_success
+from cli.utils import get_logger
+from flows.base import KickoffIssue, KickoffRepo
+from project_manager.github import GitHubProjectManager
+from project_manager.types import ProjectConfig, StatusMapping
+
+log = get_logger(__name__)
+console = Console()
+flow_app = typer.Typer(help="Flow execution commands")
+
+
+@flow_app.command("list")
+def flow_list(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """List all available flows."""
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_info("📋 Available flows:")
+
+    flows: dict[str, str] = {
+        "ralph": "Ralph - Feature development orchestrator with per-story commits",
+    }
+
+    table = Table(title="Available Flows", box=box.ROUNDED)
+    table.add_column("Name", style="cyan", header_style="bold")
+    table.add_column("Description", style="white")
+
+    for name, description in flows.items():
+        table.add_row(name, description)
+
+    console.print(table)
+    print_success(f"Found {len(flows)} flow(s)")
+
+
+@flow_app.command("run")
+def flow_run(
+    flow_name: str = typer.Argument(..., help="Flow name to execute"),
+    repo_owner: str = typer.Option(None, "--repo-owner", "-o", help="Repository owner (required)"),
+    repo_name: str = typer.Option(None, "--repo-name", "-r", help="Repository name (required)"),
+    issue_number: int = typer.Option(None, "--issue-number", "-i", help="Issue number to process (required)"),
+    project_id: str | None = typer.Option(None, "--project-id", "-p", help="GitHub project ID/number"),
+    provider: str = typer.Option("github", "--provider", help="Provider type (default: github)"),
+    token: str | None = typer.Option(None, "--token", "-t", help="GitHub token (or use GITHUB_TOKEN env var)"),
+    status_mapping: str | None = typer.Option(None, "--status-mapping", help="Custom status mapping as JSON"),
+    plugins: list[str] = typer.Option([], "--plugin", help="Load additional plugins (repeatable)"),
+    extra: str | None = typer.Option(None, "--extra", help="Extra configuration as JSON (for communications, etc.)"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Run a flow manually against a repository.
+
+    Requires full project configuration including provider, repository details,
+    and optional extras for custom behavior.
+    """
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    if not repo_owner:
+        print_error("--repo-owner is required when specifying repo configuration")
+        sys.exit(1)
+
+    if not repo_name:
+        print_error("--repo-name is required when specifying repo configuration")
+        sys.exit(1)
+
+    if not issue_number:
+        print_error("--issue-number is required")
+        sys.exit(1)
+
+    print_info(f"🚀 Running flow '{flow_name}'")
+    print_info(f"   Repository: {repo_owner}/{repo_name}")
+    print_info(f"   Issue: #{issue_number}")
+
+    try:
+        init_plugins()
+
+        if status_mapping:
+            try:
+                mapping_data = json.loads(status_mapping)
+                status_map = StatusMapping.from_dict(mapping_data)
+            except json.JSONDecodeError as e:
+                print_error(f"Invalid status mapping JSON: {e}")
+                sys.exit(1)
+        else:
+            status_map = StatusMapping()
+
+        extra_data: dict[str, Any] = {}
+        if extra:
+            try:
+                extra_data = json.loads(extra)
+            except json.JSONDecodeError as e:
+                print_error(f"Invalid extra JSON: {e}")
+                sys.exit(1)
+
+        if plugins:
+            print_info(f"   Plugins: {', '.join(plugins)}")
+
+        config = ProjectConfig(
+            provider=provider,
+            repo_owner=repo_owner,
+            repo_name=repo_name,
+            project_identifier=project_id,
+            token=token,
+            status_mapping=status_map,
+            extra=extra_data,
+        )
+
+        manager = GitHubProjectManager(config)
+        issue = manager.get_issue(issue_number)
+
+        if not issue:
+            print_error(f"Issue #{issue_number} not found")
+            sys.exit(1)
+
+        print_info(f"   Title: {issue.title}")
+
+        from bootstrap import bootstrap
+
+        bootstrap(config={"modules": {p: {} for p in plugins}})
+
+        flow_identifier = f"{manager.config.repo_owner}/{manager.config.repo_name}/{issue_number}"
+
+        comments = manager.get_comments(issue_number)
+
+        kickoff_issue = KickoffIssue(
+            id=issue_number,
+            flow_id=uuid5(NAMESPACE_DNS, flow_identifier),
+            title=issue.title,
+            body=issue.body or "",
+            comments=[
+                {
+                    "id": c.id,
+                    "user": c.user.login if c.user else None,
+                    "body": c.body,
+                    "created_at": c.created_at.isoformat() if c.created_at else None,
+                }
+                for c in comments
+            ],
+            memory_prefix=f"{manager.config.repo_owner}/{manager.config.repo_name}",
+            repository=KickoffRepo(
+                owner=manager.config.repo_owner,
+                repository=manager.config.repo_name,
+            ),
+            project_config=config,
+        )
+        with alive_bar(
+            0,
+            title=f"Running {flow_name}",
+            spinner="squares",
+            force_tty=True,
+            enrich_print=False,
+            enrich_offset=0,
+            monitor=False,
+        ) as bar:
+            bar.text = f"Processing issue #{issue_number}: {issue.title}"
+
+            from flows.ralph import ralph_kickoff
+
+            ralph_kickoff(kickoff_issue)
+
+            bar()
+
+        print_success(f"Flow '{flow_name}' completed for issue #{issue_number}")
+
+    except Exception as e:
+        print_error(f"Flow execution failed: {e}")
+        log.exception(f"Flow execution failed: {e}")
+        sys.exit(1)

cli/main.py

@@ -0,0 +1,44 @@
+"""Main CLI entry point using Typer."""
+
+import typer
+
+from . import console, db, flow, print_banner, project, server, worker
+from .utils import setup_logging
+
+app = typer.Typer(
+    name="polycode",
+    help="🚀 Polycode: Multi-agent software development automation",
+    add_completion=False,
+    no_args_is_help=True,
+    pretty_exceptions_enable=False,
+)
+
+app.add_typer(server.server_app, name="server", help="Server management commands")
+app.add_typer(worker.worker_app, name="worker", help="Celery worker management commands")
+app.add_typer(flow.flow_app, name="flow", help="Flow execution commands")
+app.add_typer(project.project_app, name="project", help="GitHub project management commands")
+app.add_typer(db.db_app, name="db", help="Database management commands")
+
+
+@app.callback()
+def main(
+    log_level: str = typer.Option(
+        "INFO",
+        "--log-level",
+        "-l",
+        help="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose (DEBUG) logging"),
+) -> None:
+    """Polycode CLI - Multi-agent software development automation."""
+    level = "DEBUG" if verbose else log_level
+    setup_logging(level)
+
+    if verbose or level.upper() == "DEBUG":
+        console.print("[dim]🔍 Verbose mode enabled[/]")
+
+    print_banner()
+
+
+if __name__ == "__main__":
+    app()

cli/project.py

@@ -0,0 +1,166 @@
+"""Project management commands for Polycode CLI."""
+
+import sys
+
+import typer
+from rich import box
+from rich.console import Console
+from rich.table import Table
+
+from cli import print_error, print_info, print_success
+from cli.utils import get_logger
+
+log = get_logger(__name__)
+console = Console()
+
+project_app = typer.Typer(help="GitHub project management commands")
+
+
+def create_manager_from_env():
+    """Create project manager from environment variables.
+
+    Returns:
+        Configured project manager
+    """
+    import os
+
+    from project_manager.config import settings
+    from project_manager.types import ProjectConfig, StatusMapping
+
+    provider = settings.PROJECT_PROVIDER or "github"
+    repo_owner = settings.REPO_OWNER or os.getenv("REPO_OWNER")
+    repo_name = settings.REPO_NAME or os.getenv("REPO_NAME")
+    project_identifier = settings.PROJECT_IDENTIFIER or os.getenv("PROJECT_IDENTIFIER")
+
+    status_mapping = StatusMapping(
+        todo=os.getenv("STATUS_TODO", "Todo"),
+        ready=os.getenv("STATUS_READY", "Ready"),
+        in_progress=os.getenv("STATUS_IN_PROGRESS", "In progress"),
+        reviewing=os.getenv("STATUS_REVIEWING", "In review"),
+        done=os.getenv("STATUS_DONE", "Done"),
+        blocked=os.getenv("STATUS_BLOCKED", "Blocked"),
+    )
+
+    config = ProjectConfig(
+        provider=provider,
+        repo_owner=repo_owner or "",
+        repo_name=repo_name or "",
+        project_identifier=project_identifier,
+        status_mapping=status_mapping,
+    )
+
+    if provider == "github":
+        from project_manager.github import GitHubProjectManager
+
+        return GitHubProjectManager(config)
+    else:
+        raise ValueError(f"Unsupported provider: {provider}")
+
+
+@project_app.command("sync")
+def project_sync(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Sync all open issues to project."""
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_info("🔄 Syncing issues to project...")
+
+    try:
+        manager = create_manager_from_env()
+        added = manager.sync_issues_to_project()
+
+        if added > 0:
+            print_success(f"Added {added} issues to project")
+        else:
+            print_info("All issues already in project")
+
+    except Exception as e:
+        print_error(f"Sync failed: {e}")
+        log.exception(f"Sync failed: {e}")
+        sys.exit(1)
+
+
+@project_app.command("list")
+def project_list(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """List all project items."""
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_info("📋 Listing project items...")
+
+    try:
+        manager = create_manager_from_env()
+        items = manager.get_project_items()
+
+        table = Table(title="Project Items", box=box.ROUNDED)
+        table.add_column("#", style="cyan", header_style="bold")
+        table.add_column("Status", style="green")
+        table.add_column("Title", style="white")
+
+        for item in items:
+            status = item.status or "No status"
+            table.add_row(f"#{item.issue_number}", f"[{status}]", item.title)
+
+        console.print(table)
+        print_success(f"Found {len(items)} item(s)")
+
+    except Exception as e:
+        print_error(f"List failed: {e}")
+        log.exception(f"List failed: {e}")
+        sys.exit(1)
+
+
+@project_app.command("status")
+def project_status(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Show current flow status from GitHub Project."""
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_info("🔍 Checking flow status...")
+
+    try:
+        manager = create_manager_from_env()
+
+        items = manager.get_project_items()
+
+        from project_manager.types import IssueStatus
+
+        ready_status = manager.config.status_mapping.to_provider_status(IssueStatus.READY)
+        in_progress_status = manager.config.status_mapping.to_provider_status(IssueStatus.IN_PROGRESS)
+
+        ready = [item for item in items if item.status == ready_status]
+        in_progress = [item for item in items if item.status == in_progress_status]
+
+        if in_progress:
+            item = in_progress[0]
+            console.print(f"[bold green]✓ Flow running:[/] Issue #{item.issue_number}")
+            console.print(f"  Title: {item.title}")
+            console.print(f"  Status: {item.status}")
+        else:
+            console.print("[yellow]✗ No flow currently running[/]")
+
+        console.print(f"\n[bold]Ready:[/] {len(ready)}, [bold]In progress:[/] {len(in_progress)}")
+
+        if ready:
+            console.print("\n[cyan]Next ready issues:[/]")
+            for item in ready[:5]:
+                console.print(f"  #{item.issue_number}: {item.title}")
+
+        print_success("Status check complete")
+
+    except Exception as e:
+        print_error(f"Status check failed: {e}")
+        log.exception(f"Status check failed: {e}")
+        sys.exit(1)

cli/server.py

@@ -0,0 +1,127 @@
+"""Server commands for Polycode CLI."""
+
+import sys
+
+import typer
+import uvicorn
+from rich.console import Console
+
+from cli import print_error, print_info
+from cli.utils import get_logger
+from github_app.app import app as github_app
+
+log = get_logger(__name__)
+console = Console()
+
+server_app = typer.Typer(help="Server management commands")
+
+
+@server_app.command("webhook")
+def webhook_server(
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Webhook server host"),
+    port: int = typer.Option(8000, "--port", "-p", help="Webhook server port"),
+    reload: bool = typer.Option(False, "--reload", help="Enable auto-reload (development)"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Start webhook server for GitHub events.
+
+    Uses unified GitHub App webhook server.
+    For GitHub App webhooks (multi-repo), set GITHUB_APP_ID and GITHUB_APP_PRIVATE_KEY.
+    For legacy webhooks (single repo), set GITHUB_TOKEN and repo env vars.
+    """
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_info(f"🚀 Starting webhook server on {host}:{port}")
+
+    if reload:
+        print_info("🔁 Auto-reload enabled")
+
+    try:
+        uvicorn.run(
+            github_app,
+            host=host,
+            port=port,
+            reload=reload,
+            log_level="debug" if verbose else "warning",
+        )
+    except KeyboardInterrupt:
+        print_info("⏹ Server stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        print_error(f"Failed to start server: {e}")
+        log.exception(f"Server startup failed: {e}")
+        sys.exit(1)
+
+
+@server_app.command("socketio")
+def socketio_server(
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Socket.IO server host"),
+    port: int = typer.Option(8001, "--port", "-p", help="Socket.IO server port"),
+    reload: bool = typer.Option(False, "--reload", help="Enable auto-reload (development)"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Start Socket.IO streaming server.
+
+    Bridges Redis pub/sub to Socket.IO clients for real-time flow updates.
+    """
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_info(f"🔌 Starting Socket.IO server on {host}:{port}")
+
+    if reload:
+        print_info("🔁 Auto-reload enabled")
+
+    try:
+        uvicorn.run(
+            "channels.stream.server_app:asgi_app",
+            host=host,
+            port=port,
+            reload=reload,
+            log_level="debug" if verbose else "warning",
+        )
+    except KeyboardInterrupt:
+        print_info("⏹ Server stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        print_error(f"Failed to start Socket.IO server: {e}")
+        log.exception(f"Socket.IO server startup failed: {e}")
+        sys.exit(1)
+
+
+@server_app.command("flower")
+def flower_server(
+    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Flower server host"),
+    port: int = typer.Option(5555, "--port", "-p", help="Flower server port"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+) -> None:
+    """Start Flower monitoring UI for Celery workers.
+
+    Flower provides real-time monitoring of Celery tasks and workers.
+    """
+    if verbose:
+        import cli.utils
+
+        cli.utils.setup_logging("DEBUG")
+
+    print_info(f"🌸 Starting Flower monitoring on {host}:{port}")
+
+    try:
+        uvicorn.run(
+            "flower:app",
+            host=host,
+            port=port,
+            log_level="debug" if verbose else "warning",
+        )
+    except KeyboardInterrupt:
+        print_info("⏹ Flower stopped by user")
+        sys.exit(0)
+    except Exception as e:
+        print_error(f"Failed to start Flower: {e}")
+        log.exception(f"Flower startup failed: {e}")
+        sys.exit(1)