@oswaldzsh/devhive 0.1.0

package/control_plane/notifications.py

@@ -0,0 +1,54 @@
+"""Desktop notification helper for DevHive."""
+
+import subprocess
+import platform
+from typing import Optional
+
+
+def notify(title: str, message: str, urgency: str = "normal") -> bool:
+    """Send a desktop notification. Returns True if successful."""
+    system = platform.system()
+
+    try:
+        if system == "Linux":
+            subprocess.run(
+                ["notify-send", "-u", urgency, title, message],
+                timeout=5, capture_output=True,
+            )
+            return True
+        elif system == "Darwin":
+            subprocess.run(
+                ["osascript", "-e",
+                 f'display notification "{message}" with title "{title}"'],
+                timeout=5, capture_output=True,
+            )
+            return True
+        elif system == "Windows":
+            # Windows toast notification via PowerShell
+            subprocess.run(
+                ["powershell", "-Command",
+                 f'New-BurntToastNotification -Text "{title}", "{message}"'],
+                timeout=5, capture_output=True,
+            )
+            return True
+    except Exception:
+        pass
+
+    return False
+
+
+def terminal_bell():
+    """Ring the terminal bell."""
+    print("\a", end="", flush=True)
+
+
+def escalate(task_id: str, reason: str):
+    """Send escalation notification via all available channels."""
+    title = f"DevHive: {task_id}"
+    message = f"Needs attention: {reason}"
+    notify(title, message, urgency="critical")
+    terminal_bell()
+    print(f"\n{'!'*60}")
+    print(f"  ESCALATION: {task_id}")
+    print(f"  {reason}")
+    print(f"{'!'*60}\n")

package/control_plane/tui.py

@@ -0,0 +1,352 @@
+"""
+DevHive TUI — Rich terminal UI components.
+
+Layout:
+┌─ Header ───────────────────────────────────────────────┐
+│ Model: xxx | Uptime: 12m | Tasks: 3 done / 5 total     │
+├─ Pipeline ───────┬─ Detail ────────────────────────────┤
+│ ● SPECIFY        │  Task: fix-login-timeout            │
+│ ● EXECUTE        │  Stage: VERIFY_L1                   │
+│ ◐ VERIFY_L1      │  Static  ✓  Dynamic  ◐ running      │
+│ ○ VERIFY_L2      │  Age: 45s                           │
+│ ○ MERGE          │                                     │
+├─ Activity ───────┴─────────────────────────────────────┤
+│ [14:30:01] execute-1    Started task-abc123            │
+│ [14:30:15] static-v     PASS - No issues found         │
+├─ Input ────────────────────────────────────────────────┤
+│ :help :quit :do :log :review :status                   │
+└────────────────────────────────────────────────────────┘
+"""
+
+import time
+import asyncio
+from datetime import datetime, timezone
+from typing import Optional
+
+from rich.console import Console, RenderableType
+from rich.live import Live
+from rich.layout import Layout
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.align import Align
+from rich.spinner import Spinner
+from rich.columns import Columns
+from rich import box
+
+
+STAGE_ORDER = ["SPECIFY", "EXECUTE", "VERIFY_L1", "VERIFY_L2", "MERGE"]
+STAGE_COLORS = {
+    "SPECIFY": "dim cyan",
+    "EXECUTE": "bright_yellow",
+    "VERIFY_L1": "bright_magenta",
+    "VERIFY_L2": "bright_blue",
+    "MERGE": "bright_green",
+}
+STAGE_SPINNERS = {
+    "SPECIFY": "dots",
+    "EXECUTE": "bouncingBar",
+    "VERIFY_L1": "arc",
+    "VERIFY_L2": "arc",
+    "MERGE": "dots",
+}
+
+
+class DevHiveTUI:
+    """Rich-based terminal UI for DevHive."""
+
+    def __init__(self, orchestrator=None):
+        self.console = Console()
+        self._orchestrator = orchestrator
+        self._start_time = time.monotonic()
+        self._activity: list[tuple[str, str, str]] = []  # (time, source, message)
+        self._tasks: dict = {}
+        self._selected_task: Optional[str] = None
+        self._running = False
+
+    def log_activity(self, source: str, message: str):
+        """Add an entry to the activity feed."""
+        ts = datetime.now(timezone.utc).replace(tzinfo=None).strftime("%H:%M:%S")
+        self._activity.append((ts, source, message))
+        if len(self._activity) > 100:
+            self._activity = self._activity[-50:]
+
+    def update_task(self, task_id: str, stage: str, status: str = "", detail: str = ""):
+        self._tasks[task_id] = {"stage": stage, "status": status, "detail": detail,
+                                "updated": time.monotonic()}
+
+    def set_tasks(self, tasks: dict):
+        self._tasks = tasks
+
+    @property
+    def uptime(self) -> str:
+        seconds = int(time.monotonic() - self._start_time)
+        if seconds < 60:
+            return f"{seconds}s"
+        elif seconds < 3600:
+            return f"{seconds // 60}m {seconds % 60}s"
+        else:
+            h = seconds // 3600
+            m = (seconds % 3600) // 60
+            return f"{h}h {m}m"
+
+    def make_layout(self) -> Layout:
+        """Build the main layout tree."""
+        layout = Layout()
+        layout.split(
+            Layout(name="header", size=3),
+            Layout(name="main"),
+            Layout(name="input", size=3),
+        )
+        layout["main"].split_row(
+            Layout(name="pipeline", ratio=1),
+            Layout(name="detail", ratio=2),
+        )
+        return layout
+
+    def _header(self) -> Panel:
+        model = "deepseek-v4-pro"
+        task_count = len(self._tasks)
+        active_count = sum(1 for t in self._tasks.values()
+                          if t.get("stage") not in ("MERGE", ""))
+        escalations = sum(1 for t in self._tasks.values()
+                         if t.get("status") == "ESCALATED")
+
+        grid = Table.grid(expand=True)
+        grid.add_column(justify="left")
+        grid.add_column(justify="right")
+
+        left = Text()
+        left.append("⚙  DevHive", style="bold white")
+        left.append(f"  │  Model: {model}", style="dim")
+        left.append(f"  │  Uptime: {self.uptime}", style="dim")
+
+        right = Text()
+        right.append(f"Tasks: {active_count} active", style="bright_cyan")
+        right.append(f"  │  {task_count - active_count} done", style="dim green")
+        if escalations:
+            right.append(f"  │  {escalations} escalated", style="bright_red")
+
+        grid.add_row(left, right)
+        return Panel(grid, style="bold", border_style="bright_black")
+
+    def _pipeline_panel(self) -> Panel:
+        """Render the pipeline stage list with spinners."""
+        table = Table.grid(padding=(0, 1))
+        table.add_column(style="bold")
+
+        active_stages = set()
+        for t in self._tasks.values():
+            stage = t.get("stage", "")
+            if stage in STAGE_ORDER:
+                active_stages.add(stage)
+
+        for stage in STAGE_ORDER:
+            style = STAGE_COLORS.get(stage, "")
+            if stage in active_stages:
+                indicator = Spinner(STAGE_SPINNERS.get(stage, "dots"), text="",
+                                   style=style)
+            else:
+                indicator = Text("○", style="dim")
+            label = Text(f" {stage.replace('_', ' ')}", style=style if stage in active_stages else "dim")
+            table.add_row(Align.left(indicator), Align.left(label))
+
+        for _ in range(len(STAGE_ORDER), 7):
+            table.add_row(Text(""))
+
+        return Panel(table, title="Pipeline", border_style="bright_black",
+                    title_align="left")
+
+    def _detail_panel(self) -> Panel:
+        """Detail view for selected or most recent task."""
+        if self._selected_task and self._selected_task in self._tasks:
+            tasks_to_show = {self._selected_task: self._tasks[self._selected_task]}
+        elif self._tasks:
+            # Show most recently updated tasks
+            sorted_tasks = sorted(self._tasks.items(),
+                                  key=lambda x: x[1].get("updated", 0), reverse=True)
+            tasks_to_show = dict(sorted_tasks[:5])
+        else:
+            tasks_to_show = {}
+
+        if not tasks_to_show:
+            return Panel(
+                Align.center(Text("No tasks yet.\n\nType :do <description> to submit one.",
+                            style="dim")),
+                title="Tasks", border_style="bright_black", title_align="left"
+            )
+
+        content = Table.grid(padding=(0, 1))
+        content.add_column(style="bold", width=30)
+        content.add_column()
+
+        for task_id, info in tasks_to_show.items():
+            stage = info.get("stage", "?")
+            status = info.get("status", "")
+            detail = info.get("detail", "")
+            style = STAGE_COLORS.get(stage, "white")
+
+            # Task header
+            short_id = task_id[-16:] if len(task_id) > 16 else task_id
+            stage_icon = "◐" if stage not in ("MERGE", "") else "✓"
+
+            row_text = Text()
+            row_text.append(f"{stage_icon} ", style=style)
+            row_text.append(short_id, style="bold")
+            content.add_row(row_text, Text(detail[:80] or stage, style="dim"))
+
+            # Stage and status
+            stage_status = Text()
+            stage_status.append(stage, style=style)
+            if status:
+                stage_status.append(f"  {status}", style="dim")
+
+            content.add_row(Text(""), stage_status)
+            content.add_row(Text(""), Text(""))  # spacer
+
+        return Panel(content, title="Tasks", border_style="bright_black",
+                    title_align="left")
+
+    def _activity_panel(self) -> Panel:
+        """Activity feed showing recent events."""
+        recent = self._activity[-8:] if self._activity else []
+        if not recent:
+            return Panel(Text("Waiting for activity...", style="dim"),
+                        title="Activity", border_style="bright_black",
+                        title_align="left")
+
+        lines = []
+        for ts, source, msg in recent:
+            line = Text()
+            line.append(f"[{ts}] ", style="dim")
+            line.append(f"{source:<14}", style="bold cyan")
+            line.append(msg[:80], style="")
+            lines.append(line)
+
+        return Panel(Text("\n").join(lines),
+                    title="Activity", border_style="bright_black",
+                    title_align="left")
+
+    def _input_bar(self) -> Panel:
+        """Command input bar."""
+        hints = Text(":help  :quit  :do  :status  :review  :log  :resolve",
+                     style="dim")
+        return Panel(hints, border_style="bright_black")
+
+    def render(self) -> Layout:
+        layout = self.make_layout()
+        layout["header"].update(self._header())
+        layout["pipeline"].update(self._pipeline_panel())
+        layout["detail"].update(self._detail_panel())
+        layout["input"].update(self._input_bar())
+        return layout
+
+
+# ── Standalone display helpers (non-interactive) ─────────
+
+def status_display(tasks: list[dict], escalations: list[dict]) -> RenderableType:
+    """One-shot status display (for `dh status`)."""
+    console = Console()
+
+    # Header
+    console.print()
+    console.print(Panel(Text("DevHive Status", style="bold white"),
+                  border_style="bright_blue"))
+    console.print(f"  Active tasks: {len(tasks)}")
+    console.print(f"  Open escalations: {len(escalations)}")
+    console.print()
+
+    # Tasks table
+    if tasks:
+        table = Table(title="Tasks", box=box.ROUNDED, border_style="bright_black")
+        table.add_column("Task ID", style="dim")
+        table.add_column("Stage")
+        table.add_column("Status")
+
+        for t in tasks:
+            stage = t.get("current_stage", "?")
+            style = STAGE_COLORS.get(stage, "white")
+            table.add_row(
+                t.get("id", "")[-24:],
+                f"[{style}]{stage}[/]",
+                t.get("status", "pending"),
+            )
+        console.print(table)
+
+    # Escalations
+    if escalations:
+        console.print()
+        for e in escalations:
+            console.print(Panel(
+                f"Task: {e.get('task_id', '?')}\n"
+                f"Escalation ID: {e.get('id', '?')}\n"
+                f"Created: {e.get('created_at', '?')}",
+                title="⚠ Escalation", border_style="red"
+            ))
+
+    return ""
+
+
+def task_timeline(checkpoints: list[dict]) -> RenderableType:
+    """Render a task's execution timeline."""
+    console = Console()
+
+    if not checkpoints:
+        return Panel(Text("No history found.", style="dim"),
+                    title="Task Timeline", border_style="yellow")
+
+    console.print()
+    console.print(Panel(Text("Task Timeline", style="bold white"),
+                  border_style="bright_blue"))
+    console.print()
+
+    for i, cp in enumerate(checkpoints):
+        stage = cp.get("stage", "?")
+        outcome = cp.get("outcome", "?")
+        created = cp.get("created_at", "?")
+        style = STAGE_COLORS.get(stage, "white")
+
+        icon = "✓" if outcome == "COMPLETED" or outcome == "PASS" else \
+               "✗" if outcome == "FAIL" else \
+               "⚠" if outcome == "WARN" else "●"
+
+        color = "green" if outcome in ("COMPLETED", "PASS") else \
+                "red" if outcome == "FAIL" else \
+                "yellow" if outcome == "WARN" else "dim"
+
+        connector = "├─" if i < len(checkpoints) - 1 else "└─"
+        console.print(f"  {connector} [{color}]{icon} {stage}[/] [{style}]{outcome}[/] [dim]{created}[/]")
+
+    console.print()
+    return ""
+
+
+def escalation_review(escalations: list[dict]) -> Optional[str]:
+    """Interactive escalation review. Returns selected escalation_id or None."""
+    console = Console()
+
+    if not escalations:
+        console.print(Panel(Text("No open escalations! 🎉", style="green"),
+                      border_style="green"))
+        return None
+
+    console.print()
+    console.print(Panel(Text("Pending Escalations", style="bold white"),
+                  border_style="bright_red"))
+
+    for i, e in enumerate(escalations):
+        console.print(f"  [{i+1}] {e.get('id', '?')[:30]}")
+        console.print(f"      Task: {e.get('task_id', '?')[-30:]}")
+        console.print(f"      Created: {e.get('created_at', '?')}")
+        console.print()
+
+    try:
+        choice = input(f"  Select [1-{len(escalations)}] or Enter to skip: ").strip()
+        if choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(escalations):
+                return escalations[idx].get("id")
+    except (EOFError, KeyboardInterrupt):
+        pass
+
+    return None

package/install.sh

@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+# DevHive post-install script
+# Installs Python dependencies and links the module.
+
+set -e
+
+DEVHIVE_HOME="${DEVHIVE_HOME:-$HOME/.devhive}"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+echo ""
+echo "  ╔══════════════════════════════════╗"
+echo "  ║   DevHive v0.1.0 — Installing   ║"
+echo "  ╚══════════════════════════════════╝"
+echo ""
+
+# 1. Find Python
+PYTHON=""
+for cmd in python3 python; do
+    if command -v "$cmd" &>/dev/null; then
+        PYTHON="$cmd"
+        break
+    fi
+done
+
+if [ -z "$PYTHON" ]; then
+    echo "  ⚠ Python 3 not found. Please install Python 3.12+ first."
+    echo "  ⚠ DevHive installed but Python components are not available."
+    exit 0
+fi
+
+echo "  Python: $PYTHON ($($PYTHON --version))"
+
+# 2. Install pip deps
+echo "  Installing Python dependencies..."
+$PYTHON -m pip install --quiet httpx pydantic pyyaml rich 2>/dev/null || {
+    echo "  ⚠ pip install failed. Please run manually:"
+    echo "    pip3 install httpx pydantic pyyaml rich"
+}
+
+# 3. Link module
+mkdir -p "$DEVHIVE_HOME"
+if [ "$SCRIPT_DIR" != "$DEVHIVE_HOME" ]; then
+    echo "  Linking module to $DEVHIVE_HOME..."
+    # Copy module files
+    for dir in control_plane agents orchestrator protocol verification signature storage tools; do
+        if [ -d "$SCRIPT_DIR/$dir" ]; then
+            cp -r "$SCRIPT_DIR/$dir" "$DEVHIVE_HOME/"
+        fi
+    done
+    # Copy root files
+    for f in __init__.py config.yaml setup.py; do
+        if [ -f "$SCRIPT_DIR/$f" ]; then
+            cp "$SCRIPT_DIR/$f" "$DEVHIVE_HOME/"
+        fi
+    done
+fi
+
+# 4. Verify installation
+echo ""
+echo "  ✓ DevHive installed successfully!"
+echo ""
+echo "  Quick start:"
+echo "    dh                  # Interactive REPL with live dashboard"
+echo "    dh do \"fix bug\"     # Submit a task"
+echo "    dh status           # Check system status"
+echo "    dh review           # Review escalations"
+echo ""

package/orchestrator/agent_pool.py

@@ -0,0 +1,107 @@
+"""Agent Pool Manager — manages agent process lifecycle."""
+
+import multiprocessing
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+from protocol.schemas import Task
+
+
+class AgentType(str, Enum):
+    EXECUTE = "execute"
+    STATIC_VERIFIER = "static_verifier"
+    DYNAMIC_VERIFIER = "dynamic_verifier"
+    SEMANTIC_VERIFIER = "semantic_verifier"
+
+
+@dataclass
+class AgentHandle:
+    agent_id: str
+    agent_type: AgentType
+    process: multiprocessing.Process
+    task_queue: multiprocessing.Queue
+    result_queue: multiprocessing.Queue
+    busy: bool = False
+    current_task_id: Optional[str] = None
+
+
+class AgentPool:
+    """Manages a pool of agent processes with task dispatching."""
+
+    def __init__(self, config: dict = None):
+        self.config = config or {}
+        self.agents: dict[str, AgentHandle] = {}
+        self._next_id: dict[AgentType, int] = {}
+
+    def start_agent(self, agent_type: AgentType) -> AgentHandle:
+        """Start a new agent process."""
+        from agents.execute import ExecuteAgent
+        from agents.verifier_static import StaticVerifier
+        from agents.verifier_dynamic import DynamicVerifier
+        from agents.verifier_semantic import SemanticVerifier
+
+        idx = self._next_id.get(agent_type, 0) + 1
+        self._next_id[agent_type] = idx
+        agent_id = f"{agent_type.value}-{idx}"
+
+        task_queue = multiprocessing.Queue()
+        result_queue = multiprocessing.Queue()
+
+        agent_classes = {
+            AgentType.EXECUTE: ExecuteAgent,
+            AgentType.STATIC_VERIFIER: StaticVerifier,
+            AgentType.DYNAMIC_VERIFIER: DynamicVerifier,
+            AgentType.SEMANTIC_VERIFIER: SemanticVerifier,
+        }
+
+        agent_cls = agent_classes[agent_type]
+        agent = agent_cls(agent_id, task_queue, result_queue, self.config)
+        agent.start()
+
+        handle = AgentHandle(
+            agent_id=agent_id,
+            agent_type=agent_type,
+            process=agent,
+            task_queue=task_queue,
+            result_queue=result_queue,
+        )
+        self.agents[agent_id] = handle
+        return handle
+
+    def get_idle(self, agent_type: AgentType) -> Optional[AgentHandle]:
+        """Find an idle agent of the specified type."""
+        for handle in self.agents.values():
+            if handle.agent_type == agent_type and not handle.busy:
+                return handle
+        return None
+
+    def dispatch(self, handle: AgentHandle, task: Task):
+        """Send a task to an idle agent."""
+        handle.busy = True
+        handle.current_task_id = task.id
+        handle.task_queue.put(task.model_dump())
+
+    def mark_idle(self, agent_id: str):
+        """Mark an agent as idle after task completion."""
+        if agent_id in self.agents:
+            self.agents[agent_id].busy = False
+            self.agents[agent_id].current_task_id = None
+
+    def stop_all(self):
+        """Stop all agent processes."""
+        for handle in self.agents.values():
+            handle.task_queue.put(None)  # poison pill
+            handle.process.join(timeout=10)
+            if handle.process.is_alive():
+                handle.process.terminate()
+
+    def idle_count(self, agent_type: AgentType) -> int:
+        """Count idle agents of a given type."""
+        return sum(1 for h in self.agents.values()
+                   if h.agent_type == agent_type and not h.busy)
+
+    def total_count(self, agent_type: AgentType) -> int:
+        """Count total agents of a given type."""
+        return sum(1 for h in self.agents.values()
+                   if h.agent_type == agent_type)