devpilot-agentic-cli 1.0.0__py3-none-any.whl

agent/__init__.py

@@ -0,0 +1 @@
+# DevPilot Agent Package

agent/a2a_client.py

@@ -0,0 +1,94 @@
+"""
+agent/a2a_client.py
+───────────────────
+A2A client implementation. Discovers peer agents via their AgentCard
+and delegates tasks to them using HTTP SSE.
+"""
+
+import json
+from typing import Any
+
+import httpx
+
+from agent.tools import ToolResult
+from agent.ui import UI
+
+
+async def _fetch_agent_card(peer_url: str, token: str | None) -> dict[str, Any]:
+    headers = {}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+        
+    card_url = f"{peer_url.rstrip('/')}/.well-known/agent.json"
+    async with httpx.AsyncClient() as client:
+        response = await client.get(card_url, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+
+async def delegate_task_to_peer(peer_url: str, prompt: str, token: str | None = None) -> ToolResult:
+    """
+    Delegate a task to an A2A peer agent.
+    1. Fetch AgentCard to find the /tasks/send endpoint.
+    2. POST the task.
+    3. Stream SSE events to get the artifact.
+    """
+    try:
+        card = await _fetch_agent_card(peer_url, token)
+    except Exception as e:
+        return ToolResult(f"Failed to fetch AgentCard from {peer_url}: {e}", is_error=True)
+
+    endpoints = card.get("endpoints", {})
+    send_url = endpoints.get("tasks")
+    if not send_url:
+        return ToolResult(f"Peer AgentCard missing 'tasks' endpoint. Card: {card}", is_error=True)
+
+    headers = {}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    try:
+        async with httpx.AsyncClient() as client:
+            # Send task
+            response = await client.post(send_url, json={"prompt": prompt}, headers=headers)
+            response.raise_for_status()
+            data = response.json()
+            task_id = data.get("task_id")
+            
+            if not task_id:
+                return ToolResult("Peer did not return a task_id.", is_error=True)
+                
+            base = send_url[: send_url.rfind("/send")]
+            stream_url = f"{base}/{task_id}/stream"
+            
+            # Read SSE
+            UI.print_info(f"Delegated task {task_id} to {peer_url}. Waiting for results...")
+            
+            final_artifact = ""
+            status = "working"
+            
+            async with client.stream("GET", stream_url, headers=headers) as stream_resp:
+                stream_resp.raise_for_status()
+                async for line in stream_resp.aiter_lines():
+                    line = line.strip()
+                    if not line:
+                        continue
+                    if line.startswith("event: "):
+                        current_event = line[7:]
+                    elif line.startswith("data: "):
+                        data_payload = line[6:]
+                        if "current_event" in locals():
+                            if current_event == "artifact":
+                                final_artifact += data_payload + "\n"
+                            elif current_event == "status":
+                                status = data_payload
+            
+            if status == "failed":
+                return ToolResult(f"Task failed on peer: {final_artifact}", is_error=True)
+                
+            return ToolResult(f"Task completed successfully by peer. Artifact:\n{final_artifact}", is_error=False)
+
+    except Exception as e:
+        return ToolResult(f"A2A connection error: {e}", is_error=True)
+
+

agent/a2a_server.py

@@ -0,0 +1,148 @@
+"""
+agent/a2a_server.py
+───────────────────
+FastAPI server implementing the Agent-to-Agent (A2A) protocol.
+Handles incoming task delegation requests and streams results via SSE.
+"""
+
+import asyncio
+import uuid
+from typing import Any, AsyncGenerator
+
+from fastapi import Depends, FastAPI, HTTPException, Request
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel
+from sse_starlette.sse import EventSourceResponse
+
+from agent.config import Config
+from agent.history import HistoryManager
+from agent.loop import run_agent_loop
+from agent.providers.factory import create_provider
+from agent.tools import ToolRegistry
+
+app = FastAPI(title="DevPilot A2A Server")
+security = HTTPBearer(auto_error=False)
+
+# Global task queues for SSE streaming
+# task_id -> asyncio.Queue
+_task_queues: dict[str, asyncio.Queue] = {}
+
+# We'll store config, registry, etc in app.state during startup
+# app.state.config
+# app.state.registry
+
+
+class TaskRequest(BaseModel):
+    prompt: str
+
+
+def verify_token(credentials: HTTPAuthorizationCredentials | None = Depends(security)) -> None:
+    config: Config = app.state.config
+    if config.a2a_token:
+        if not credentials or credentials.credentials != config.a2a_token:
+            raise HTTPException(status_code=401, detail="Invalid or missing bearer token")
+
+
+@app.get("/.well-known/agent.json")
+async def get_agent_card() -> dict[str, Any]:
+    """Return the A2A AgentCard describing this agent."""
+    port = app.state.config.a2a_port
+    return {
+        "name": "DevPilot",
+        "description": "AI-Powered Terminal Coding Agent",
+        "protocols": ["A2A v0.2"],
+        "endpoints": {
+            "tasks": f"http://localhost:{port}/tasks/send"
+        }
+    }
+
+
+async def background_task_runner(task_id: str, prompt: str) -> None:
+    """Executes the agentic loop in the background and pushes SSE events."""
+    queue = _task_queues[task_id]
+    await queue.put({"event": "status", "data": "working"})
+
+    try:
+        config: Config = app.state.config
+        registry: ToolRegistry = app.state.registry
+        
+        # Instantiate a fresh provider and history for this task
+        provider = create_provider(config)
+        history = HistoryManager()
+        
+        # Add the prompt
+        history.append(provider.make_user_message(prompt))
+        
+        # Run loop. We force no_confirm=True for background tasks to avoid hanging.
+        # Use dataclasses.replace() so we don't duplicate every field.
+        import dataclasses
+        task_config = dataclasses.replace(config, no_confirm=True)
+        
+        await run_agent_loop(
+            provider=provider,
+            registry=registry,
+            history=history,
+            config=task_config,
+            max_iterations=task_config.max_iterations,
+        )
+        
+        # After loop finishes, the last message should be the assistant's final output
+        messages = history.get_messages()
+        if messages and messages[-1].get("role") == "assistant":
+            content = messages[-1].get("content", "")
+            if isinstance(content, list):
+                # Canonical format: list of typed blocks — extract text blocks only
+                final_text = " ".join(
+                    b.get("text", "")
+                    for b in content
+                    if isinstance(b, dict) and b.get("type") == "text"
+                ).strip() or "Task completed."
+            else:
+                final_text = str(content)
+        else:
+            final_text = "Task completed, but no final response was generated."
+            
+        await queue.put({"event": "artifact", "data": final_text})
+        await queue.put({"event": "status", "data": "completed"})
+        
+    except Exception as e:
+        await queue.put({"event": "artifact", "data": f"Error: {e}"})
+        await queue.put({"event": "status", "data": "failed"})
+    finally:
+        await queue.put(None)  # Sentinel to close stream
+
+
+@app.post("/tasks/send", dependencies=[Depends(verify_token)])
+async def create_task(request: TaskRequest) -> dict[str, str]:
+    """Receive a task, spin up background executor, and return task_id."""
+    task_id = str(uuid.uuid4())
+    _task_queues[task_id] = asyncio.Queue()
+    
+    # Spin up background task
+    asyncio.create_task(background_task_runner(task_id, request.prompt))
+    
+    return {"task_id": task_id}
+
+
+@app.get("/tasks/{task_id}/stream", dependencies=[Depends(verify_token)])
+async def stream_task(task_id: str, request: Request) -> EventSourceResponse:
+    """Stream SSE events for a specific task."""
+    if task_id not in _task_queues:
+        raise HTTPException(status_code=404, detail="Task not found")
+        
+    queue = _task_queues[task_id]
+
+    async def event_generator() -> AsyncGenerator[dict[str, str], None]:
+        while True:
+            if await request.is_disconnected():
+                break
+            
+            event = await queue.get()
+            if event is None:
+                # Task finished
+                del _task_queues[task_id]
+                break
+                
+            yield event
+
+    return EventSourceResponse(event_generator())

agent/cli.py

@@ -0,0 +1,233 @@
+"""
+agent/cli.py
+─────────────
+CLI entry point for DevPilot.
+Parses arguments, runs first-run setup wizard if needed,
+initializes components, and starts the interactive TUI or CI loop.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from agent.a2a_server import app as a2a_app
+from agent.config import Config, ConfigError
+from agent.history import HistoryManager
+from agent.loop import run_agent_loop
+from agent.mcp_client import MCPManager
+from agent.providers.factory import create_provider
+from agent.tools import ToolRegistry
+from agent.ui import UI
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="devpilot",
+        description="DevPilot — Autonomous AI coding agent for your terminal",
+    )
+    parser.add_argument("--provider", choices=["anthropic", "openai"], help="Model provider")
+    parser.add_argument("--model", help="Model name")
+    parser.add_argument("--base-url", help="OpenAI-compatible base URL (e.g. Ollama)")
+    parser.add_argument("--no-confirm", action="store_true", help="Skip confirmation prompts")
+    parser.add_argument("--thinking", action="store_true", help="Enable extended thinking (Claude only)")
+    parser.add_argument("--thinking-budget", type=int, help="Extended thinking token budget (default: 10000)")
+    parser.add_argument("--no-web-search", action="store_true", help="Disable web search tool")
+    parser.add_argument("--no-memory", action="store_true", help="Disable long-term memory")
+    parser.add_argument("--workdir", help="Working directory for file operations (default: cwd)")
+    parser.add_argument("--task", help="Run a single task and exit (CI mode)")
+    parser.add_argument("--resume", help="Resume a previous session by ID")
+    parser.add_argument("--a2a-port", type=int, help="A2A server port (default: 8000)")
+    parser.add_argument("--no-a2a", action="store_true", help="Disable A2A server")
+    parser.add_argument("--setup", action="store_true", help="Re-run the setup wizard")
+    return parser.parse_args()
+
+
+def _apply_cli_overrides(args: argparse.Namespace) -> None:
+    """Push CLI flag values into env vars so Config.load() picks them up."""
+    if args.provider:
+        os.environ["DEVPILOT_PROVIDER"] = args.provider
+    if args.model:
+        os.environ["DEVPILOT_MODEL"] = args.model
+    if args.base_url:
+        os.environ["DEVPILOT_BASE_URL"] = args.base_url
+    if args.no_confirm:
+        os.environ["DEVPILOT_NO_CONFIRM"] = "true"
+    if args.thinking:
+        os.environ["DEVPILOT_THINKING"] = "true"
+    if args.thinking_budget:
+        os.environ["DEVPILOT_THINKING_BUDGET"] = str(args.thinking_budget)
+    if args.no_web_search:
+        os.environ["DEVPILOT_NO_WEB_SEARCH"] = "true"
+    if args.no_memory:
+        os.environ["DEVPILOT_NO_MEMORY"] = "true"
+    if args.workdir:
+        os.environ["DEVPILOT_WORKDIR"] = args.workdir
+    if args.a2a_port:
+        os.environ["DEVPILOT_A2A_PORT"] = str(args.a2a_port)
+    if args.no_a2a:
+        os.environ["DEVPILOT_NO_A2A"] = "true"
+
+
+def _ensure_api_key(config: Config, args: argparse.Namespace) -> Config:
+    """
+    Check for a valid API key. If missing, run the setup wizard.
+    Re-loads config after wizard so the new key is picked up.
+    Returns the (possibly reloaded) config.
+    """
+    from agent.config import REQUIRED_ENV_KEYS
+    key_name = REQUIRED_ENV_KEYS[config.provider]
+
+    if config.active_api_key:
+        return config  # Key present — nothing to do
+
+    # Force re-run wizard if --setup flag passed
+    if args.setup or not config.active_api_key:
+        from agent.setup_wizard import run_setup_wizard
+        success = run_setup_wizard(env_path=Path(".env"))
+        if not success:
+            # Wizard skipped (CI/no TTY) or failed — print helpful error
+            UI.print_error(
+                f"Missing API key for provider '{config.provider}'.\n"
+                f"  Set {key_name} in your environment or .env file.\n"
+                f"  Run 'devpilot --setup' to configure interactively."
+            )
+            sys.exit(1)
+
+        # Reload config so the new env vars are picked up
+        try:
+            config = Config.load()
+            _apply_cli_overrides(args)
+            config = Config.load()
+        except ConfigError as e:
+            UI.print_error(str(e))
+            sys.exit(1)
+
+    return config
+
+
+async def main_async() -> None:
+    args = parse_args()
+    _apply_cli_overrides(args)
+
+    # Load config
+    try:
+        config = Config.load()
+    except ConfigError as e:
+        UI.print_error(str(e))
+        sys.exit(1)
+
+    # Handle --setup flag (force wizard even if key exists)
+    if args.setup:
+        from agent.setup_wizard import run_setup_wizard
+        run_setup_wizard(env_path=Path(".env"))
+        try:
+            config = Config.load()
+        except ConfigError as e:
+            UI.print_error(str(e))
+            sys.exit(1)
+    else:
+        # Ensure API key — runs wizard if missing
+        config = _ensure_api_key(config, args)
+
+    # Final key validation (catches invalid key format etc.)
+    try:
+        config.validate_api_key()
+    except ConfigError as e:
+        UI.print_error(str(e))
+        sys.exit(1)
+
+    # Wire up provider, context, registry
+    provider = create_provider(config)
+
+    from agent.context import RepoContext
+    repo_context = RepoContext(config.workdir)
+    registry = ToolRegistry(config, _context=repo_context)
+
+    # MCP
+    mcp_config_path = Path("mcp_servers.json")
+    if not mcp_config_path.exists():
+        mcp_config_path = Path(__file__).parent.parent / "mcp_servers.json"
+    mcp_manager = MCPManager(mcp_config_path)
+    await mcp_manager.connect_all(registry)
+
+    # A2A server
+    a2a_app.state.config   = config
+    a2a_app.state.registry = registry
+
+    if config.a2a_enabled:
+        import uvicorn
+        a2a_cfg = uvicorn.Config(
+            app=a2a_app,
+            host="0.0.0.0",
+            port=config.a2a_port,
+            log_level="error",
+        )
+        a2a_server = uvicorn.Server(a2a_cfg)
+        a2a_task   = asyncio.create_task(a2a_server.serve())
+    else:
+        a2a_server = None
+        a2a_task   = None
+
+    # History / session
+    history    = HistoryManager()
+    session_id = args.resume or datetime.now().strftime("%Y%m%d_%H%M%S")
+    session_file = config.sessions_dir / f"{session_id}.json"
+
+    if args.resume:
+        if session_file.exists():
+            history.load(session_file)
+            if args.task:
+                UI.print_info(f"Resumed session: {session_id}")
+        else:
+            UI.print_error(f"Session '{session_id}' not found at {session_file}")
+            sys.exit(1)
+    else:
+        if args.task:
+            UI.print_info(f"New session: {session_id}")
+
+    # ── CI / single-task mode ─────────────────────────────────────────────────
+    if args.task:
+        history.append(provider.make_user_message(args.task))
+        await run_agent_loop(
+            provider=provider,
+            registry=registry,
+            history=history,
+            config=config,
+            max_iterations=config.max_iterations,
+            context=repo_context,
+        )
+        history.save(session_file)
+        if a2a_server and a2a_task:
+            a2a_server.should_exit = True
+            await a2a_task
+        await mcp_manager.close()
+        sys.exit(0)
+
+    # ── Interactive TUI mode ──────────────────────────────────────────────────
+    from agent.tui.app import DevPilotApp
+    app = DevPilotApp(
+        provider=provider,
+        registry=registry,
+        history=history,
+        config=config,
+        repo_context=repo_context,
+    )
+    await app.run_async()
+
+    if a2a_server and a2a_task:
+        a2a_server.should_exit = True
+        await a2a_task
+    await mcp_manager.close()
+
+
+def main() -> None:
+    asyncio.run(main_async())
+
+
+if __name__ == "__main__":
+    main()