daveloop 1.5.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

{daveloop-1.5.0.dist-info → daveloop-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: daveloop
-Version: 1.5.0
+Version: 1.5.1
 Summary: Self-healing debug agent powered by Claude Code CLI
 Home-page: https://github.com/davebruzil/DaveLoop
 Author: Dave Bruzil
@@ -19,6 +19,17 @@ Classifier: Topic :: Software Development :: Debuggers
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Provides-Extra: turbo
+Requires-Dist: rich>=13.0; extra == "turbo"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
 
 # DaveLoop
 

daveloop-1.5.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+daveloop.py,sha256=SrIlZMZpRgYw8dPEequNoWbZ2hMyip0wLMNFVzVskcQ,85885
+daveloop_swebench.py,sha256=iD9AU3XRiMQpt7TknFNlvnmPCNp64V-JaTfqTFgsGBM,15996
+daveloop-1.5.1.dist-info/METADATA,sha256=c6DPGhLDRu5ODmf7iu2bSyMsqCQDk0SdOVjUQKrxRxQ,13113
+daveloop-1.5.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+daveloop-1.5.1.dist-info/entry_points.txt,sha256=QcFAZgFrDfPtIikNQb7eW9DxOpBK7T-qWrKqbGAS9Ww,86
+daveloop-1.5.1.dist-info/top_level.txt,sha256=36DiYt70m4DIK8t7IhV_y6hAzUIyeb5-qDUf3-gbDdg,27
+daveloop-1.5.1.dist-info/RECORD,,

{daveloop-1.5.0.dist-info → daveloop-1.5.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.46.3)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

daveloop.py

@@ -14,6 +14,8 @@ import itertools
 import json
 from datetime import datetime
 from pathlib import Path
+from collections import deque
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 # Configuration
 MAX_ITERATIONS = 20
@@ -318,6 +320,386 @@ class SwarmBudget:
         }
 
 
+# ============================================================================
+# Turbo Dashboard (Rich-based split-pane UI)
+# ============================================================================
+class TurboDashboard:
+    """Rich-based split-pane terminal dashboard for parallel DaveLoop instances.
+
+    Shows one panel per instance with: instance ID, current task name,
+    and a scrolling window of the last ~20 lines of output.
+    """
+
+    PANEL_COLORS = ["cyan", "green", "yellow", "magenta", "blue", "red"]
+
+    def __init__(self, instance_count: int):
+        from rich.live import Live
+        from rich.layout import Layout
+        from rich.panel import Panel
+        from rich.text import Text
+        from rich.console import Console
+
+        self._Live = Live
+        self._Layout = Layout
+        self._Panel = Panel
+        self._Text = Text
+        self._console = Console()
+
+        self.instance_count = instance_count
+        self._lock = threading.Lock()
+
+        # Per-instance state
+        self.task_names = ["Waiting..."] * instance_count
+        self.statuses = ["pending"] * instance_count  # pending, running, done, failed
+        self.output_buffers = [deque(maxlen=20) for _ in range(instance_count)]
+        self.iterations = [0] * instance_count
+        self.max_iterations = [0] * instance_count
+        self.start_times = [None] * instance_count
+
+        self._live = None
+
+    def _build_layout(self):
+        """Build the Rich Layout with panels for each instance."""
+        layout = self._Layout()
+
+        # Create rows of 2 panels each
+        rows = []
+        for i in range(0, self.instance_count, 2):
+            row_name = f"row_{i // 2}"
+            row = self._Layout(name=row_name)
+            left = self._Layout(name=f"inst_{i}")
+
+            if i + 1 < self.instance_count:
+                right = self._Layout(name=f"inst_{i + 1}")
+                row.split_row(left, right)
+            else:
+                row.split_row(left)
+
+            rows.append(row)
+
+        if rows:
+            layout.split_column(*rows)
+
+        return layout
+
+    def _render_panel(self, idx: int):
+        """Render a single instance panel."""
+        color = self.PANEL_COLORS[idx % len(self.PANEL_COLORS)]
+        status = self.statuses[idx]
+
+        # Status indicator
+        if status == "running":
+            status_icon = "[bold bright_green]\u25cf RUNNING[/]"
+        elif status == "done":
+            status_icon = "[bold bright_green]\u2713 RESOLVED[/]"
+        elif status == "failed":
+            status_icon = "[bold bright_red]\u2717 FAILED[/]"
+        else:
+            status_icon = "[dim]\u25cb PENDING[/]"
+
+        # Iteration info
+        iter_info = ""
+        if self.max_iterations[idx] > 0:
+            iter_info = f" | Iter {self.iterations[idx]}/{self.max_iterations[idx]}"
+
+        # Elapsed time
+        elapsed = ""
+        if self.start_times[idx]:
+            secs = int(time.time() - self.start_times[idx])
+            mins, secs = divmod(secs, 60)
+            elapsed = f" | {mins}m{secs:02d}s"
+
+        # Build subtitle
+        subtitle = f"{status_icon}{iter_info}{elapsed}"
+
+        # Build output text
+        lines = list(self.output_buffers[idx])
+        if not lines:
+            lines = ["[dim]Waiting for output...[/]"]
+
+        output_text = "\n".join(lines)
+
+        task_name = self.task_names[idx]
+        if len(task_name) > 50:
+            task_name = task_name[:47] + "..."
+
+        panel = self._Panel(
+            output_text,
+            title=f"[bold {color}] Instance {idx + 1} [/] {task_name}",
+            subtitle=subtitle,
+            border_style=color if status == "running" else "dim" if status == "pending" else "green" if status == "done" else "red",
+            padding=(0, 1),
+        )
+        return panel
+
+    def _refresh(self):
+        """Rebuild and update the live display."""
+        layout = self._build_layout()
+        for i in range(self.instance_count):
+            try:
+                layout[f"inst_{i}"].update(self._render_panel(i))
+            except KeyError:
+                pass
+        return layout
+
+    def start(self):
+        """Start the live dashboard."""
+        self._live = self._Live(
+            self._refresh(),
+            console=self._console,
+            refresh_per_second=4,
+            screen=True,
+        )
+        self._live.start()
+
+    def stop(self):
+        """Stop the live dashboard."""
+        if self._live:
+            self._live.stop()
+
+    def update_task(self, idx: int, task_name: str, max_iterations: int):
+        """Set the task name and max iterations for an instance."""
+        with self._lock:
+            self.task_names[idx] = task_name
+            self.max_iterations[idx] = max_iterations
+            self.statuses[idx] = "running"
+            self.start_times[idx] = time.time()
+            if self._live:
+                self._live.update(self._refresh())
+
+    def update_iteration(self, idx: int, iteration: int):
+        """Update the current iteration number for an instance."""
+        with self._lock:
+            self.iterations[idx] = iteration
+            if self._live:
+                self._live.update(self._refresh())
+
+    def append_output(self, idx: int, line: str):
+        """Append a line to an instance's output buffer."""
+        with self._lock:
+            # Strip ANSI codes for cleaner display in Rich panels
+            clean = _strip_ansi(line)
+            if clean.strip():
+                self.output_buffers[idx].append(clean)
+                if self._live:
+                    self._live.update(self._refresh())
+
+    def mark_done(self, idx: int, outcome: str = "done"):
+        """Mark an instance as completed."""
+        with self._lock:
+            self.statuses[idx] = outcome
+            if self._live:
+                self._live.update(self._refresh())
+
+
+def _strip_ansi(text: str) -> str:
+    """Remove ANSI escape sequences from a string."""
+    import re
+    return re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', text)
+
+
+def run_claude_code_turbo(prompt: str, working_dir: str, instance_idx: int,
+                          dashboard: TurboDashboard, timeout: int = DEFAULT_TIMEOUT,
+                          swarm_mode: bool = False, swarm_budget_max: int = 5,
+                          swarm_depth_max: int = 1) -> str:
+    """Execute Claude Code CLI for turbo mode, streaming output to a dashboard panel.
+
+    Similar to run_claude_code but routes output to a TurboDashboard panel
+    instead of printing directly to stdout.
+    """
+    claude_cmd = find_claude_cli()
+    if not claude_cmd:
+        return "[DAVELOOP:ERROR] Claude CLI not found"
+
+    cmd = [claude_cmd]
+    allowed = ALLOWED_TOOLS_SWARM if swarm_mode else ALLOWED_TOOLS_DEFAULT
+    cmd.extend(["-p", "--verbose", "--output-format", "stream-json", "--allowedTools", allowed])
+
+    try:
+        process = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding='utf-8',
+            errors='replace',
+            cwd=working_dir,
+            bufsize=1
+        )
+
+        process.stdin.write(prompt)
+        process.stdin.close()
+
+        full_text = []
+
+        for line in process.stdout:
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                data = json.loads(line)
+                msg_type = data.get("type", "")
+
+                if msg_type == "assistant":
+                    content = data.get("message", {}).get("content", [])
+                    for block in content:
+                        if block.get("type") == "text":
+                            text = block.get("text", "")
+                            for text_line in text.split('\n'):
+                                if text_line.strip():
+                                    dashboard.append_output(instance_idx, text_line)
+                            full_text.append(text)
+                        elif block.get("type") == "tool_use":
+                            tool_name = block.get("name", "unknown")
+                            tool_input = block.get("input", {})
+                            tool_desc = _format_tool_short(tool_name, tool_input)
+                            dashboard.append_output(instance_idx, f"\u25b6 {tool_desc}")
+
+                elif msg_type == "content_block_delta":
+                    delta = data.get("delta", {})
+                    if delta.get("type") == "text_delta":
+                        text = delta.get("text", "")
+                        full_text.append(text)
+                        # Only push meaningful chunks to dashboard
+                        for text_line in text.split('\n'):
+                            if text_line.strip():
+                                dashboard.append_output(instance_idx, text_line)
+
+                elif msg_type == "tool_use":
+                    tool_name = data.get("name", "unknown")
+                    tool_input = data.get("input", {})
+                    tool_desc = _format_tool_short(tool_name, tool_input)
+                    dashboard.append_output(instance_idx, f"\u25b6 {tool_desc}")
+
+                elif msg_type == "tool_result":
+                    dashboard.append_output(instance_idx, "\u2514\u2500 \u2713 done")
+
+                elif msg_type == "result":
+                    text = data.get("result", "")
+                    if text:
+                        full_text.append(text)
+
+                elif msg_type == "error":
+                    error_msg = data.get("error", {}).get("message", "Unknown error")
+                    dashboard.append_output(instance_idx, f"\u2717 ERROR: {error_msg}")
+
+            except json.JSONDecodeError:
+                dashboard.append_output(instance_idx, line)
+                full_text.append(line)
+
+        process.wait(timeout=timeout)
+        return '\n'.join(full_text)
+
+    except subprocess.TimeoutExpired:
+        return f"[DAVELOOP:TIMEOUT] Claude Code timed out after {timeout // 60} minutes"
+    except FileNotFoundError:
+        return "[DAVELOOP:ERROR] Claude Code CLI not found"
+    except Exception as e:
+        return f"[DAVELOOP:ERROR] {str(e)}"
+
+
+def _format_tool_short(tool_name: str, tool_input: dict) -> str:
+    """Format a tool call for compact dashboard display."""
+    if tool_name == "Bash":
+        cmd = tool_input.get("command", "")
+        return f"Bash({cmd[:40]}{'...' if len(cmd) > 40 else ''})"
+    elif tool_name in ("Read", "Write", "Edit"):
+        fp = tool_input.get("file_path", "")
+        fname = fp.split("\\")[-1].split("/")[-1]
+        return f"{tool_name}({fname})"
+    elif tool_name == "Grep":
+        pat = tool_input.get("pattern", "")
+        return f"Grep({pat[:25]}{'...' if len(pat) > 25 else ''})"
+    elif tool_name == "Glob":
+        pat = tool_input.get("pattern", "")
+        return f"Glob({pat})"
+    elif tool_name == "Task":
+        desc = tool_input.get("description", "")
+        return f"Task({desc[:30]}{'...' if len(desc) > 30 else ''})"
+    return tool_name
+
+
+def run_turbo_task(task_desc: str, task_idx: int, system_prompt: str,
+                   working_dir: str, max_iterations: int, timeout: int,
+                   dashboard: TurboDashboard, swarm_mode: bool = False,
+                   swarm_budget_max: int = 5, swarm_depth_max: int = 1) -> dict:
+    """Run a single DaveLoop task inside the turbo dashboard.
+
+    Returns a dict with outcome, iterations, and output.
+    """
+    dashboard.update_task(task_idx, task_desc[:50], max_iterations)
+
+    context = f"""
+## Bug Report
+
+{task_desc}
+
+## Instructions
+
+Analyze this bug. Gather whatever logs/information you need to understand it.
+Then fix it. Use the reasoning protocol before each action.
+"""
+    full_output = []
+
+    for iteration in range(1, max_iterations + 1):
+        dashboard.update_iteration(task_idx, iteration)
+        dashboard.append_output(task_idx, f"--- Iteration {iteration}/{max_iterations} ---")
+
+        if iteration == 1:
+            full_prompt = f"{system_prompt}\n\n---\n\n{context}"
+        else:
+            full_prompt = context
+
+        output = run_claude_code_turbo(
+            full_prompt, working_dir,
+            instance_idx=task_idx,
+            dashboard=dashboard,
+            timeout=timeout,
+            swarm_mode=swarm_mode,
+            swarm_budget_max=swarm_budget_max,
+            swarm_depth_max=swarm_depth_max,
+        )
+
+        full_output.append(output)
+
+        signal, should_exit = check_exit_condition(output)
+
+        if should_exit:
+            if signal == "RESOLVED":
+                dashboard.append_output(task_idx, "\u2713 BUG RESOLVED!")
+                dashboard.mark_done(task_idx, "done")
+                return {"outcome": "RESOLVED", "iterations": iteration, "output": '\n'.join(full_output)}
+            elif signal == "BLOCKED":
+                dashboard.append_output(task_idx, "\u2717 BLOCKED - needs human help")
+                dashboard.mark_done(task_idx, "failed")
+                return {"outcome": "BLOCKED", "iterations": iteration, "output": '\n'.join(full_output)}
+            elif signal == "CLARIFY":
+                dashboard.append_output(task_idx, "\u2717 NEEDS CLARIFICATION")
+                dashboard.mark_done(task_idx, "failed")
+                return {"outcome": "CLARIFY", "iterations": iteration, "output": '\n'.join(full_output)}
+            else:
+                dashboard.append_output(task_idx, f"\u2717 Error: {signal}")
+                dashboard.mark_done(task_idx, "failed")
+                return {"outcome": signal, "iterations": iteration, "output": '\n'.join(full_output)}
+
+        # Prepare next iteration context
+        context = f"""
+## Iteration {iteration + 1}
+
+The bug is NOT yet resolved. You have full context from previous iterations.
+
+Continue debugging. Analyze what happened, determine next steps, and proceed.
+Use the reasoning protocol before each action.
+"""
+
+    # Max iterations reached
+    dashboard.append_output(task_idx, f"\u2717 Max iterations ({max_iterations}) reached")
+    dashboard.mark_done(task_idx, "failed")
+    return {"outcome": "MAX_ITERATIONS", "iterations": max_iterations, "output": '\n'.join(full_output)}
+
+
 # ============================================================================
 # Token Tracker
 # ============================================================================
@@ -1052,6 +1434,10 @@ def main():
                         help="Max sub-agent depth in swarm mode (default: 1, no recursive spawning)")
     parser.add_argument("--show-tokens", action="store_true",
                         help="Show verbose per-turn token usage during execution")
+    parser.add_argument("--turbo", action="store_true",
+                        help="Run all tasks in parallel with a Rich split-pane dashboard")
+    parser.add_argument("--turbo-workers", type=int, default=None,
+                        help="Max parallel workers in turbo mode (default: number of tasks)")
 
     args = parser.parse_args()
 
@@ -1106,6 +1492,9 @@ def main():
         print_status("Tools", ALLOWED_TOOLS_SWARM, C.WHITE)
     else:
         print_status("Tools", ALLOWED_TOOLS_DEFAULT, C.WHITE)
+    if args.turbo:
+        workers = args.turbo_workers or len(bug_descriptions)
+        print_status("Turbo", f"ENABLED ({workers} parallel workers)", C.BRIGHT_MAGENTA)
     print(f"{C.BRIGHT_BLUE}└{'─' * 70}┘{C.RESET}")
 
     # Build task queue
@@ -1118,15 +1507,97 @@ def main():
     print(f"{C.BRIGHT_BLUE}│{C.RESET} Type while running:  {C.BRIGHT_WHITE}wait{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}pause{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}add{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}done{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}stop{C.RESET}                {C.BRIGHT_BLUE}│{C.RESET}")
     print(f"{C.BRIGHT_BLUE}└{'─' * 70}┘{C.RESET}")
 
-    # Start input monitor
-    input_monitor = InputMonitor()
-    input_monitor.start()
-
     # Build history context for initial prompt
     history_context = ""
     if history_data["sessions"]:
         history_context = "\n\n" + format_history_context(history_data["sessions"])
 
+    # ========================================================================
+    # TURBO MODE: parallel execution with Rich dashboard
+    # ========================================================================
+    if args.turbo and len(bug_descriptions) >= 1:
+        num_workers = args.turbo_workers or len(bug_descriptions)
+        num_workers = min(num_workers, len(bug_descriptions))
+
+        print(f"\n  {C.BRIGHT_MAGENTA}{C.BOLD}◆ Launching Turbo Mode with {num_workers} parallel workers...{C.RESET}\n")
+        time.sleep(1)  # Brief pause so user sees the message before dashboard takes over
+
+        dashboard = TurboDashboard(len(bug_descriptions))
+        system_prompt_full = system_prompt + history_context
+
+        # Launch all tasks in parallel
+        results = [None] * len(bug_descriptions)
+
+        dashboard.start()
+        try:
+            with ThreadPoolExecutor(max_workers=num_workers) as executor:
+                futures = {}
+                for idx, desc in enumerate(bug_descriptions):
+                    future = executor.submit(
+                        run_turbo_task,
+                        task_desc=desc,
+                        task_idx=idx,
+                        system_prompt=system_prompt_full,
+                        working_dir=working_dir,
+                        max_iterations=args.max_iterations,
+                        timeout=args.timeout,
+                        dashboard=dashboard,
+                        swarm_mode=args.swarm,
+                        swarm_budget_max=args.swarm_budget,
+                        swarm_depth_max=args.swarm_depth,
+                    )
+                    futures[future] = idx
+
+                for future in as_completed(futures):
+                    idx = futures[future]
+                    try:
+                        results[idx] = future.result()
+                    except Exception as e:
+                        results[idx] = {"outcome": "ERROR", "iterations": 0, "output": str(e)}
+                        dashboard.append_output(idx, f"\u2717 Exception: {e}")
+                        dashboard.mark_done(idx, "failed")
+        finally:
+            # Keep dashboard visible for a moment so user can see final state
+            time.sleep(2)
+            dashboard.stop()
+
+        # Print final summary
+        print(f"\n{BANNER}\n")
+        print(f"\n{C.BRIGHT_BLUE}{C.BOLD}◆ TURBO MODE COMPLETE{C.RESET}")
+        print(f"{C.BRIGHT_BLUE}{'─' * 70}{C.RESET}")
+        for idx, desc in enumerate(bug_descriptions):
+            r = results[idx]
+            outcome = r["outcome"] if r else "ERROR"
+            iters = r["iterations"] if r else 0
+            desc_short = desc[:55]
+            if outcome == "RESOLVED":
+                print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{desc_short}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+            else:
+                print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.RED}{desc_short}{C.RESET} {C.DIM}({outcome}, {iters} iter){C.RESET}")
+
+            # Save to history
+            session_entry = summarize_session(desc, outcome, iters)
+            history_data["sessions"].append(session_entry)
+
+            # Save log
+            save_log(idx + 1, r.get("output", "") if r else "", session_id)
+
+        save_history(working_dir, history_data)
+
+        print(f"\n  {C.DIM}Session: {session_id}{C.RESET}")
+        print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")
+
+        all_resolved = all(r and r["outcome"] == "RESOLVED" for r in results)
+        return 0 if all_resolved else 1
+
+    # ========================================================================
+    # SEQUENTIAL MODE (original behavior)
+    # ========================================================================
+
+    # Start input monitor
+    input_monitor = InputMonitor()
+    input_monitor.start()
+
     # Session-wide token tracking (aggregates across all tasks)
     session_token_tracker = TokenTracker()
 

daveloop-1.5.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-daveloop.py,sha256=ge03G7KAmYwCZllCFztGlfpuwbhzo70Wdaki0loSaO0,66852
-daveloop_swebench.py,sha256=iD9AU3XRiMQpt7TknFNlvnmPCNp64V-JaTfqTFgsGBM,15996
-daveloop-1.5.0.dist-info/METADATA,sha256=FyXtTgGZmdn8jooM6q6MWEhD5Rs0Mhk65jVOj7iYIAk,12842
-daveloop-1.5.0.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
-daveloop-1.5.0.dist-info/entry_points.txt,sha256=QcFAZgFrDfPtIikNQb7eW9DxOpBK7T-qWrKqbGAS9Ww,86
-daveloop-1.5.0.dist-info/top_level.txt,sha256=36DiYt70m4DIK8t7IhV_y6hAzUIyeb5-qDUf3-gbDdg,27
-daveloop-1.5.0.dist-info/RECORD,,