@oswaldzsh/devhive 0.1.0

package/control_plane/cli.py

@@ -0,0 +1,596 @@
+#!/usr/bin/env python3
+"""
+dh — DevHive CLI
+
+Usage:
+  dh                      Start interactive REPL with live dashboard
+  dh do <description>     Submit a task, auto-parse into TaskSpec
+  dh do -f <file>         Submit a task from JSON/YAML spec file
+  dh run                  Start orchestrator daemon
+  dh status               Show system status
+  dh log <task-id>        Show task execution timeline
+  dh review               Interactive escalation review
+  dh resolve <id>         Resolve an escalation
+  dh !<shell command>      Escape to shell (from interactive mode)
+
+Examples:
+  dh do "fix the login timeout bug in auth/session.py"
+  dh do "add rate limiting middleware to all API endpoints" -p HIGH
+  dh do -f task_spec.yaml
+  dh status
+  dh log task-20260624-143000-abc123
+  dh review
+"""
+
+import argparse
+import asyncio
+import json
+import os
+import shlex
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+# Rich imports
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+from rich.table import Table
+from rich import box
+
+# DevHive imports
+from protocol.schemas import TaskSpec, Priority
+from orchestrator.engine import Orchestrator
+from control_plane.tui import (
+    DevHiveTUI, status_display, task_timeline, escalation_review,
+)
+
+
+VERSION = "0.1.0"
+BANNER = r"""
+  ╔══════════════════════════════════════════╗
+  ║   ____             __  __  _             ║
+  ║  / __ \ ___ __   __/ / / / (_)   _____   ║
+  ║ / / / // _ \\ \ / / /_/ / / / | / / _ \  ║
+  ║/ /_/ /|  __/\ V / __  / / /| |/ /  __/  ║
+  ║\_____/  \___| \_/ /_/ /_/ /_/ |___/\___| ║
+  ║                                          ║
+  ║   Multi-Agent Software Development       ║
+  ╚══════════════════════════════════════════╝
+"""
+
+HELP_TEXT = """
+  Commands:
+    :do, :d <desc>      Submit a task from description
+    :status, :st         Show system status
+    :log, :l <id>        Show task execution timeline
+    :review, :rv         Review pending escalations
+    :resolve, :rs <id>   Resolve an escalation
+    :tasks, :t           List all tasks
+    :watch <id>          Watch a specific task in detail
+    :quit, :q            Exit DevHive
+
+  Shortcuts:
+    !<cmd>               Escape to shell (e.g., !git status)
+    Ctrl+C               Interrupt current operation
+
+  From terminal:
+    dh do "description"  Quick task submission
+    dh status            Quick status check
+    dh review            Quick escalation review
+"""
+
+
+# ── Config ──────────────────────────────────────────────────
+
+def load_config(config_path: str = None) -> dict:
+    """Load YAML config, resolving env vars."""
+    import yaml
+    paths = [
+        config_path,
+        os.path.join(os.path.dirname(__file__), "..", "config.yaml"),
+        os.path.join(os.path.dirname(__file__), "..", "config.local.yaml"),
+        os.path.expanduser("~/.config/devhive/config.yaml"),
+    ]
+    for p in paths:
+        if p and os.path.exists(p):
+            with open(p) as f:
+                raw = f.read()
+            # Resolve ${VAR} placeholders
+            import re
+            def _sub(m):
+                return os.environ.get(m.group(1), m.group(0))
+            raw = re.sub(r'\$\{(\w+)\}', _sub, raw)
+            return yaml.safe_load(raw)
+    return {}
+
+
+# ── Natural Language Task Parsing ────────────────────────────
+
+async def parse_task_from_nl(description: str, priority: str = "MEDIUM",
+                             config: dict = None) -> TaskSpec:
+    """Use the model to parse a natural language description into a TaskSpec."""
+    from tools.api_client import APIClient, extract_text_from_response
+
+    config = config or {}
+    api_cfg = config.get("api", {})
+    client = APIClient(
+        base_url=api_cfg.get("base_url"),
+        auth_token=api_cfg.get("auth_token"),
+        default_model=api_cfg.get("default_model"),
+    )
+
+    system = """You are a task parser. Convert the user's natural language description
+into a structured JSON task specification. Output ONLY the JSON, no explanation.
+
+Format:
+{
+  "title": "concise one-line title",
+  "description": "expanded description with context and requirements",
+  "acceptance_criteria": ["criterion 1", "criterion 2"],
+  "scope_constraints": ["constraint 1"],
+  "sensitive_modules": [],
+  "priority": "MEDIUM"
+}
+
+Rules:
+- title: one line, action-oriented (start with a verb)
+- description: include what, why, and any context the user provided
+- acceptance_criteria: specific, testable conditions of done
+- scope_constraints: what NOT to touch
+- sensitive_modules: detect if auth/payment/data/permission is involved
+- priority: use the provided priority if specified
+"""
+
+    response = await client.create_message(
+        system=system,
+        messages=[{"role": "user", "content": f"Priority: {priority}\n\n{description}"}],
+        max_tokens=1024,
+        temperature=0.1,
+    )
+
+    text = extract_text_from_response(response)
+
+    # Extract JSON
+    import re
+    match = re.search(r'\{.*\}', text, re.DOTALL)
+    if match:
+        data = json.loads(match.group(0))
+    else:
+        # Fallback: build simple spec
+        data = {
+            "title": description[:80],
+            "description": description,
+            "acceptance_criteria": [],
+            "scope_constraints": [],
+            "sensitive_modules": [],
+            "priority": priority,
+        }
+
+    return TaskSpec(
+        title=data.get("title", description[:80]),
+        description=data.get("description", description),
+        acceptance_criteria=data.get("acceptance_criteria", []),
+        scope_constraints=data.get("scope_constraints", []),
+        sensitive_modules=data.get("sensitive_modules", []),
+        priority=Priority(data.get("priority", priority)),
+    )
+
+
+# ── Interactive REPL ────────────────────────────────────────
+
+class DevHiveREPL:
+    """Interactive REPL with live dashboard."""
+
+    def __init__(self, config: dict):
+        self.config = config
+        self.console = Console()
+        self.orchestrator: Optional[Orchestrator] = None
+        self.tui = DevHiveTUI()
+        self._running = False
+        self._command_task: Optional[asyncio.Task] = None
+
+    async def start(self):
+        """Start orchestrator and enter interactive loop."""
+        self.console.print(BANNER, style="bold cyan")
+        self.console.print(f"  Version {VERSION}", style="dim")
+        model = self.config.get("api", {}).get("default_model", "unknown")
+        self.console.print(f"  Model: {model}", style="dim")
+        self.console.print()
+
+        # Start orchestrator
+        self.orchestrator = Orchestrator(self.config)
+        self.tui._orchestrator = self.orchestrator
+
+        # Start orchestrator in background
+        orchestrator_task = asyncio.create_task(
+            self.orchestrator.start(agent_counts={"execute": 1})
+        )
+        await asyncio.sleep(0.5)  # Let it initialize
+
+        self.tui.log_activity("system", "Orchestrator started")
+        self._running = True
+
+        # Start TUI refresh and command input concurrently
+        try:
+            await self._repl_loop()
+        except (KeyboardInterrupt, EOFError):
+            pass
+        finally:
+            self._running = False
+            await self.orchestrator.stop()
+            orchestrator_task.cancel()
+            try:
+                await orchestrator_task
+            except asyncio.CancelledError:
+                pass
+
+        self.console.print("\n  DevHive stopped.", style="dim")
+
+    async def _repl_loop(self):
+        """Main REPL: live dashboard + command input."""
+        from rich.live import Live
+        from prompt_toolkit import PromptSession
+        from prompt_toolkit.history import FileHistory
+        from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+
+        # Try prompt_toolkit for fancy input; fall back to input()
+        try:
+            session = PromptSession(
+                history=FileHistory(os.path.expanduser("~/.devhive_history")),
+                auto_suggest=AutoSuggestFromHistory(),
+            )
+            use_prompt_toolkit = True
+        except ImportError:
+            session = None
+            use_prompt_toolkit = False
+
+        with Live(self.tui.render(), console=self.console,
+                  refresh_per_second=4, screen=True) as live:
+
+            # Background task to push TUI updates
+            async def _refresh_tui():
+                while self._running:
+                    live.update(self.tui.render())
+                    await asyncio.sleep(0.25)
+
+            refresh_task = asyncio.create_task(_refresh_tui())
+
+            # Command input loop
+            while self._running:
+                try:
+                    live.stop()  # Pause TUI for input
+                    if use_prompt_toolkit:
+                        cmd = await asyncio.get_event_loop().run_in_executor(
+                            None, lambda: session.prompt("dh> "))
+                    else:
+                        cmd = await asyncio.get_event_loop().run_in_executor(
+                            None, lambda: input("dh> "))
+                    live.start()
+
+                    if cmd:
+                        await self._handle_command(cmd.strip())
+                except (KeyboardInterrupt, EOFError):
+                    break
+                except Exception as e:
+                    self.tui.log_activity("error", str(e))
+
+            refresh_task.cancel()
+            try:
+                await refresh_task
+            except asyncio.CancelledError:
+                pass
+
+    async def _handle_command(self, cmd: str):
+        """Dispatch a REPL command."""
+        # Shell escape
+        if cmd.startswith("!"):
+            shell_cmd = cmd[1:].strip()
+            if shell_cmd:
+                self.tui.log_activity("shell", shell_cmd)
+                try:
+                    result = subprocess.run(
+                        shell_cmd, shell=True, capture_output=True,
+                        text=True, timeout=30
+                    )
+                    output = result.stdout or result.stderr
+                    for line in output.strip().split("\n")[:20]:
+                        self.tui.log_activity("shell", line)
+                except Exception as e:
+                    self.tui.log_activity("shell", f"Error: {e}")
+            return
+
+        # Colon commands
+        if cmd.startswith(":"):
+            parts = shlex.split(cmd)
+            cmd_name = parts[0][1:].lower() if parts else ""
+            args = parts[1:] if len(parts) > 1 else []
+        else:
+            # Bare text → submit as task
+            cmd_name = "do"
+            args = [cmd]
+
+        match cmd_name:
+            case "help" | "h":
+                self.console.print(HELP_TEXT, style="dim")
+                self.tui.log_activity("system", "Showed help")
+
+            case "quit" | "q" | "exit":
+                self._running = False
+                self.tui.log_activity("system", "Shutting down...")
+
+            case "do" | "d":
+                await self._cmd_submit(" ".join(args) if args else "")
+
+            case "status" | "st":
+                await self._cmd_show_status()
+
+            case "tasks" | "t":
+                await self._cmd_list_tasks()
+
+            case "log" | "l":
+                await self._cmd_show_log(args[0] if args else None)
+
+            case "review" | "rv":
+                await self._cmd_review()
+
+            case "resolve" | "rs":
+                if args:
+                    await self._cmd_resolve(args[0])
+
+            case "watch" | "w":
+                if args:
+                    self.tui._selected_task = args[0]
+                    self.tui.log_activity("system", f"Watching task {args[0]}")
+
+            case _:
+                # Unknown command → treat as task description
+                desc = cmd[1:] if cmd.startswith(":") else cmd
+                await self._cmd_submit(desc)
+
+    async def _cmd_submit(self, description: str):
+        """Submit a new task."""
+        if not description:
+            self.tui.log_activity("error", "Usage: :do <description>")
+            return
+
+        self.tui.log_activity("system", f"Parsing: {description[:60]}...")
+
+        try:
+            spec = await parse_task_from_nl(description, config=self.config)
+            task_id = await self.orchestrator.submit_task(spec)
+            self.tui.update_task(task_id, "SPECIFY", "parsed",
+                                spec.title)
+            self.tui.log_activity("task", f"Created {task_id[-16:]}: {spec.title}")
+            self.console.print(f"  ✓ Task created: {task_id}", style="green")
+        except Exception as e:
+            self.tui.log_activity("error", f"Failed: {e}")
+
+    async def _cmd_show_status(self):
+        """Show system status."""
+        store = self.orchestrator.checkpoint
+        tasks = store.get_pending_tasks()
+        escs = store.get_open_escalations()
+        status_display(tasks, escs)
+
+    async def _cmd_list_tasks(self):
+        """List all tasks in the TUI detail panel."""
+        store = self.orchestrator.checkpoint
+        tasks = store.get_pending_tasks()
+        for t in tasks:
+            stage = t.get("current_stage", "?")
+            self.tui.update_task(t["id"], stage, t.get("status", ""),
+                                t.get("spec_json", "{}")[:80])
+        self.tui.log_activity("system", f"Loaded {len(tasks)} tasks")
+
+    async def _cmd_show_log(self, task_id: str = None):
+        """Show task execution timeline."""
+        if not task_id:
+            task_id = self.tui._selected_task
+        if not task_id:
+            self.tui.log_activity("error", "Usage: :log <task-id>")
+            return
+
+        store = self.orchestrator.checkpoint
+        history = store.get_task_history(task_id)
+        task_timeline(history)
+
+    async def _cmd_review(self):
+        """Interactive escalation review."""
+        store = self.orchestrator.checkpoint
+        escs = store.get_open_escalations()
+        selected = escalation_review(escs)
+        if selected:
+            self.console.print(f"\n  Resolving {selected}...")
+            store.resolve_escalation(selected, "human-operator")
+            self.tui.log_activity("system", f"Resolved escalation {selected[:20]}...")
+            self.console.print("  ✓ Resolved", style="green")
+
+    async def _cmd_resolve(self, esc_id: str):
+        """Resolve an escalation by ID."""
+        self.orchestrator.checkpoint.resolve_escalation(esc_id, "human-operator")
+        self.tui.log_activity("system", f"Resolved {esc_id[:20]}...")
+        self.console.print(f"  ✓ Escalation resolved", style="green")
+
+
+# ── One-shot Commands ───────────────────────────────────────
+
+async def cmd_do(args, config: dict):
+    """Quick task submission from the command line."""
+    console = Console()
+    console.print(BANNER, style="bold cyan")
+
+    if args.file:
+        import yaml
+        with open(args.file) as f:
+            data = json.load(f) if args.file.endswith(".json") else yaml.safe_load(f)
+        spec = TaskSpec(**data)
+        console.print(f"  Loaded spec from {args.file}", style="dim")
+    elif args.description:
+        console.print("  Parsing task description...", style="dim")
+        spec = await parse_task_from_nl(
+            args.description,
+            priority=args.priority or "MEDIUM",
+            config=config,
+        )
+        console.print(f"  Title: {spec.title}", style="bold")
+        console.print(f"  Priority: {spec.priority.value}", style="dim")
+    else:
+        console.print("  Usage: dh do <description>  or  dh do -f <file>", style="red")
+        return
+
+    orch = Orchestrator(config)
+    await orch.start(agent_counts={"execute": 1})
+    await asyncio.sleep(0.3)
+
+    task_id = await orch.submit_task(spec)
+    console.print(f"\n  ✓ Task submitted: {task_id}", style="green")
+
+    # Wait briefly for execution to start
+    await asyncio.sleep(2)
+
+    # Show task status
+    history = orch.checkpoint.get_task_history(task_id)
+    if history:
+        task_timeline(history)
+
+    await orch.stop()
+
+
+async def cmd_status(args, config: dict):
+    """Quick status check."""
+    orch = Orchestrator(config)
+    await orch.start(agent_counts={})
+    await asyncio.sleep(0.3)
+
+    tasks = orch.checkpoint.get_pending_tasks()
+    escs = orch.checkpoint.get_open_escalations()
+    status_display(tasks, escs)
+
+    await orch.stop()
+
+
+async def cmd_log(args, config: dict):
+    """Show task timeline."""
+    orch = Orchestrator(config)
+    await orch.start(agent_counts={})
+
+    history = orch.checkpoint.get_task_history(args.task_id)
+    task_timeline(history)
+
+    await orch.stop()
+
+
+async def cmd_review(args, config: dict):
+    """Interactive escalation review."""
+    orch = Orchestrator(config)
+    await orch.start(agent_counts={})
+
+    escs = orch.checkpoint.get_open_escalations()
+    selected = escalation_review(escs)
+
+    if selected:
+        orch.checkpoint.resolve_escalation(selected, "human-operator")
+        Console().print(f"\n  ✓ Resolved", style="green")
+
+    await orch.stop()
+
+
+async def cmd_resolve(args, config: dict):
+    """Resolve an escalation."""
+    orch = Orchestrator(config)
+    await orch.start(agent_counts={})
+    orch.checkpoint.resolve_escalation(args.escalation_id, "human-operator")
+    Console().print(f"  ✓ Resolved {args.escalation_id}", style="green")
+    await orch.stop()
+
+
+# ── Daemon ──────────────────────────────────────────────────
+
+async def cmd_run(args, config: dict):
+    """Start orchestrator daemon (for long-running use)."""
+    console = Console()
+    console.print(BANNER, style="bold cyan")
+    console.print("  Starting DevHive daemon...", style="dim")
+
+    orch = Orchestrator(config)
+    await orch.start(agent_counts=args.agents)
+    console.print("  ✓ Daemon running. Press Ctrl+C to stop.", style="green")
+    console.print()
+
+    try:
+        await asyncio.Event().wait()
+    except KeyboardInterrupt:
+        console.print("\n  Shutting down...", style="dim")
+        await orch.stop()
+
+
+# ── Entry Point ─────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="dh",
+        description="DevHive — Multi-Agent Software Development System",
+    )
+    parser.add_argument("-c", "--config", help="Config file path")
+    parser.add_argument("-v", "--version", action="version",
+                        version=f"DevHive {VERSION}")
+    sub = parser.add_subparsers(dest="command")
+
+    # dh (no args) → interactive REPL
+    # (handled by checking if command is None below)
+
+    # dh do
+    p_do = sub.add_parser("do", help="Submit a task")
+    p_do.add_argument("description", nargs="?", help="Task description in natural language")
+    p_do.add_argument("-f", "--file", help="Task spec JSON/YAML file")
+    p_do.add_argument("-p", "--priority", choices=["CRITICAL", "HIGH", "MEDIUM", "LOW"])
+
+    # dh run
+    p_run = sub.add_parser("run", help="Start orchestrator daemon")
+    p_run.add_argument("-a", "--agents", type=int, default=1,
+                       help="Number of execute agents")
+
+    # dh status
+    sub.add_parser("status", help="Show system status")
+
+    # dh log
+    p_log = sub.add_parser("log", help="Show task execution timeline")
+    p_log.add_argument("task_id", help="Task ID")
+
+    # dh review
+    sub.add_parser("review", help="Interactive escalation review")
+
+    # dh resolve
+    p_resolve = sub.add_parser("resolve", help="Resolve an escalation")
+    p_resolve.add_argument("escalation_id", help="Escalation ID")
+
+    args = parser.parse_args()
+    config = load_config(args.config)
+
+    if args.command is None:
+        # Interactive REPL mode
+        repl = DevHiveREPL(config)
+        try:
+            asyncio.run(repl.start())
+        except KeyboardInterrupt:
+            pass
+    elif args.command == "do":
+        asyncio.run(cmd_do(args, config))
+    elif args.command == "run":
+        asyncio.run(cmd_run(args, config))
+    elif args.command == "status":
+        asyncio.run(cmd_status(args, config))
+    elif args.command == "log":
+        asyncio.run(cmd_log(args, config))
+    elif args.command == "review":
+        asyncio.run(cmd_review(args, config))
+    elif args.command == "resolve":
+        asyncio.run(cmd_resolve(args, config))
+
+
+if __name__ == "__main__":
+    main()

package/control_plane/dashboard.py

@@ -0,0 +1,57 @@
+"""DevHive Dashboard — terminal UI for monitoring agent activity."""
+
+import time
+from typing import Optional
+
+
+class Dashboard:
+    """Simple terminal-based status dashboard."""
+
+    def __init__(self, checkpoint_store):
+        self.store = checkpoint_store
+        self._last_refresh = 0
+
+    def render(self) -> str:
+        """Render the dashboard to a string."""
+        self._last_refresh = time.monotonic()
+
+        pending = self.store.get_pending_tasks()
+        escalations = self.store.get_open_escalations()
+
+        lines = []
+        lines.append("=" * 60)
+        lines.append("  DevHive Dashboard")
+        lines.append("=" * 60)
+        lines.append("")
+        lines.append(f"  Pending Tasks:     {len(pending)}")
+        lines.append(f"  Open Escalations:  {len(escalations)}")
+        lines.append("")
+
+        if escalations:
+            lines.append("  ── Escalations ──")
+            for esc in escalations:
+                lines.append(f"  ! {esc['id'][:20]}... | Task: {esc['task_id'][:20]}...")
+
+        if pending:
+            lines.append("  ── Pending Tasks ──")
+            for t in pending[:10]:
+                lines.append(f"  • {t['id'][:20]}... | Stage: {t.get('current_stage', '?')}")
+
+        lines.append("")
+        lines.append("  Press Ctrl+C to exit")
+        lines.append("-" * 60)
+
+        return "\n".join(lines)
+
+    async def run_interactive(self, interval: float = 2.0):
+        """Run an interactive dashboard loop."""
+        import asyncio
+        import os
+
+        try:
+            while True:
+                os.system("clear" if os.name != "nt" else "cls")
+                print(self.render())
+                await asyncio.sleep(interval)
+        except KeyboardInterrupt:
+            print("\nDashboard stopped.")