daveloop 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

{daveloop-1.1.0.dist-info → daveloop-1.3.0.dist-info}/METADATA

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

daveloop-1.3.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+daveloop.py,sha256=Htq9-ga4EPeyfIUW2Llq6yz7TJi4umfWD7-zlQPGZLs,49406
+daveloop_swebench.py,sha256=iD9AU3XRiMQpt7TknFNlvnmPCNp64V-JaTfqTFgsGBM,15996
+daveloop-1.3.0.dist-info/METADATA,sha256=eOrj3xTjeHWdrS9_Y87_H3KfHYa3KOtv5fXBDDC485w,10463
+daveloop-1.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+daveloop-1.3.0.dist-info/entry_points.txt,sha256=QcFAZgFrDfPtIikNQb7eW9DxOpBK7T-qWrKqbGAS9Ww,86
+daveloop-1.3.0.dist-info/top_level.txt,sha256=36DiYt70m4DIK8t7IhV_y6hAzUIyeb5-qDUf3-gbDdg,27
+daveloop-1.3.0.dist-info/RECORD,,

{daveloop-1.1.0.dist-info → daveloop-1.3.0.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

@@ -11,6 +11,7 @@ import argparse
 import threading
 import time
 import itertools
+import json
 from datetime import datetime
 from pathlib import Path
 
@@ -79,70 +80,81 @@ if sys.platform == "win32":
 # ============================================================================
 # ASCII Art Banner
 # ============================================================================
-BANNER = f"""
-{C.BRIGHT_BLUE}{C.BOLD}
-   ██████╗  █████╗ ██╗   ██╗███████╗██╗      ██████╗  ██████╗ ██████╗
-   ██╔══██╗██╔══██╗██║   ██║██╔════╝██║     ██╔═══██╗██╔═══██╗██╔══██╗
-   ██║  ██║███████║██║   ██║█████╗  ██║     ██║   ██║██║   ██║██████╔╝
-   ██║  ██║██╔══██║╚██╗ ██╔╝██╔══╝  ██║     ██║   ██║██║   ██║██╔═══╝
-   ██████╔╝██║  ██║ ╚████╔╝ ███████╗███████╗╚██████╔╝╚██████╔╝██║
-   ╚═════╝ ╚═╝  ╚═╝  ╚═══╝  ╚══════╝╚══════╝ ╚═════╝  ╚═════╝ ╚═╝
-{C.RESET}
-{C.BRIGHT_WHITE}{C.BOLD}                  Self-Healing Debug Agent{C.RESET}
-{C.WHITE}            Powered by Claude Code - Autonomous Mode{C.RESET}
-"""
+BANNER = f"""{C.BRIGHT_BLUE}  ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄{C.RESET}
+
+{C.BRIGHT_BLUE}{C.BOLD}  ██████╗  █████╗ ██╗   ██╗███████╗██╗      ██████╗  ██████╗ ██████╗
+  ██╔══██╗██╔══██╗██║   ██║██╔════╝██║     ██╔═══██╗██╔═══██╗██╔══██╗
+  ██║  ██║███████║██║   ██║█████╗  ██║     ██║   ██║██║   ██║██████╔╝
+  ██║  ██║██╔══██║╚██╗ ██╔╝██╔══╝  ██║     ██║   ██║██║   ██║██╔═══╝
+  ██████╔╝██║  ██║ ╚████╔╝ ███████╗███████╗╚██████╔╝╚██████╔╝██║
+  ╚═════╝ ╚═╝  ╚═╝  ╚═══╝  ╚══════╝╚══════╝ ╚═════╝  ╚═════╝ ╚═╝{C.RESET}
+
+{C.BRIGHT_BLUE}  ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄ · ✦ · ❄{C.RESET}
+
+{C.BRIGHT_WHITE}{C.BOLD}                    Self-Healing Debug Agent{C.RESET}
+{C.DIM}                Powered by Claude Code · Autonomous{C.RESET}"""
 
 # ============================================================================
 # UI Components
 # ============================================================================
 def print_header_box(title: str, color: str = C.BRIGHT_BLUE):
     """Print a header."""
-    print(f"\n{color}{C.BOLD}{title}{C.RESET}")
-    print(f"{color}{'─'*len(title)}{C.RESET}\n")
+    print(f"{color}{C.BOLD}┌─ {title} {'─' * (66 - len(title))}┐{C.RESET}")
 
 def print_section(title: str, color: str = C.BRIGHT_BLUE):
     """Print a section divider."""
-    print(f"\n{color}{C.BOLD}{title}{C.RESET}")
-    print(f"{color}{'─'*len(title)}{C.RESET}\n")
+    print(f"\n{color}{C.BOLD}◆ {title}{C.RESET}")
+    print(f"{color}{'─' * 70}{C.RESET}")
 
 def print_status(label: str, value: str, color: str = C.WHITE):
     """Print a status line."""
-    print(f"  {C.WHITE}{label}:{C.RESET} {color}{value}{C.RESET}")
+    print(f"  {C.BRIGHT_BLUE}│{C.RESET} {C.DIM}{label}:{C.RESET} {color}{value}{C.RESET}")
 
 def print_iteration_header(iteration: int, max_iter: int):
     """Print the iteration header with visual progress."""
     progress = iteration / max_iter
-    bar_width = 30
+    bar_width = 25
     filled = int(bar_width * progress)
-    bar = f"{C.BLUE}{'█' * filled}{C.DIM}{'░' * (bar_width - filled)}{C.RESET}"
-
-    iteration_text = f"ITERATION {iteration}/{max_iter}"
-    percentage_text = f"{int(progress*100)}%"
+    empty = bar_width - filled
+    bar = '█' * filled + '░' * empty
 
-    print(f"\n{C.BOLD}{C.WHITE}{iteration_text}{C.RESET}  {bar}  {C.BRIGHT_BLUE}{percentage_text}{C.RESET}\n")
+    print(f"""
+{C.BRIGHT_BLUE}  ──────────────────────────────────────────────────────────────────────{C.RESET}
+{C.BRIGHT_WHITE}{C.BOLD}                         ITERATION {iteration}/{max_iter}{C.RESET}
+{C.BRIGHT_BLUE}                      [{bar}] {int(progress*100)}%{C.RESET}
+{C.BRIGHT_BLUE}  ──────────────────────────────────────────────────────────────────────{C.RESET}
+""")
 
-def print_success_box(message: str):
+def print_success_box(message: str = ""):
     """Print an epic success message."""
-    print(f"\n{C.BRIGHT_GREEN}{C.BOLD}")
-    print("    ███████╗ ██╗   ██╗  ██████╗  ██████╗ ███████╗ ███████╗ ███████╗")
-    print("    ██╔════╝ ██║   ██║ ██╔════╝ ██╔════╝ ██╔════╝ ██╔════╝ ██╔════╝")
-    print("    ███████╗ ██║   ██║ ██║      ██║      █████╗   ███████╗ ███████╗")
-    print("    ╚════██║ ██║   ██║ ██║      ██║      ██╔══╝   ╚════██║ ╚════██║")
-    print("    ███████║ ╚██████╔╝ ╚██████╗ ╚██████╗ ███████╗ ███████║ ███████║")
-    print("    ╚══════╝  ╚═════╝   ╚═════╝  ╚═════╝ ╚══════╝ ╚══════╝ ╚══════╝")
-    print()
-    print(f"         {C.BRIGHT_YELLOW}★ ★ ★{C.RESET}{C.BRIGHT_GREEN}{C.BOLD}  {C.BRIGHT_WHITE}BUG SUCCESSFULLY RESOLVED{C.RESET}{C.BRIGHT_GREEN}{C.BOLD}  {C.BRIGHT_YELLOW}★ ★ ★{C.RESET}")
-    print()
-    print(f"                      {C.WHITE}{message}{C.RESET}")
-    print(f"{C.RESET}\n")
+    print(f"""
+{C.BRIGHT_GREEN}{C.BOLD}  ███████╗██╗   ██╗ ██████╗ ██████╗███████╗███████╗███████╗
+  ██╔════╝██║   ██║██╔════╝██╔════╝██╔════╝██╔════╝██╔════╝
+  ███████╗██║   ██║██║     ██║     █████╗  ███████╗███████╗
+  ╚════██║██║   ██║██║     ██║     ██╔══╝  ╚════██║╚════██║
+  ███████║╚██████╔╝╚██████╗╚██████╗███████╗███████║███████║
+  ╚══════╝ ╚═════╝  ╚═════╝ ╚═════╝╚══════╝╚══════╝╚══════╝{C.RESET}
+
+{C.BRIGHT_WHITE}{C.BOLD}                  ✓ BUG SUCCESSFULLY RESOLVED{C.RESET}
+""")
 
 def print_error_box(message: str):
     """Print an error message."""
-    print(f"\n{C.BRIGHT_RED}{C.BOLD}✗ ERROR: {C.WHITE}{message}{C.RESET}\n")
+    print(f"""
+{C.BRIGHT_RED}╭{'─' * 70}╮
+│{C.RESET} {C.BOLD}{C.BRIGHT_RED}✗ ERROR{C.RESET}                                                              {C.BRIGHT_RED}│
+│{C.RESET} {C.WHITE}{message[:66]}{C.RESET} {C.BRIGHT_RED}│
+╰{'─' * 70}╯{C.RESET}
+""")
 
 def print_warning_box(message: str):
     """Print a warning message."""
-    print(f"\n{C.BRIGHT_YELLOW}{C.BOLD}⚠ WARNING: {C.WHITE}{message}{C.RESET}\n")
+    print(f"""
+{C.BRIGHT_YELLOW}╭{'─' * 70}╮
+│{C.RESET} {C.BOLD}{C.BRIGHT_YELLOW}⚠ WARNING{C.RESET}                                                            {C.BRIGHT_YELLOW}│
+│{C.RESET} {C.WHITE}{message[:66]}{C.RESET} {C.BRIGHT_YELLOW}│
+╰{'─' * 70}╯{C.RESET}
+""")
 
 # ============================================================================
 # Spinner Animation
@@ -184,6 +196,144 @@ class Spinner:
             sys.stdout.write(f"\r  {C.GREEN}✓{C.RESET} {self.message} complete {C.DIM}({elapsed:.1f}s){C.RESET}                    \n")
         sys.stdout.flush()
 
+# ============================================================================
+# Task Queue
+# ============================================================================
+class TaskQueue:
+    """Manages multiple bug tasks in sequence."""
+
+    def __init__(self):
+        self.tasks = []  # list of {"description": str, "status": "pending"|"active"|"done"|"failed"}
+
+    def add(self, description: str):
+        """Add a new task with pending status."""
+        self.tasks.append({"description": description, "status": "pending"})
+
+    def next(self):
+        """Find first pending task, set it to active, return it. None if no pending tasks."""
+        for task in self.tasks:
+            if task["status"] == "pending":
+                task["status"] = "active"
+                return task
+        return None
+
+    def current(self):
+        """Return the task with status active, or None."""
+        for task in self.tasks:
+            if task["status"] == "active":
+                return task
+        return None
+
+    def mark_done(self):
+        """Set current active task to done."""
+        task = self.current()
+        if task:
+            task["status"] = "done"
+
+    def mark_failed(self):
+        """Set current active task to failed."""
+        task = self.current()
+        if task:
+            task["status"] = "failed"
+
+    def remaining(self) -> int:
+        """Count of pending tasks."""
+        return sum(1 for t in self.tasks if t["status"] == "pending")
+
+    def all(self):
+        """Return all tasks."""
+        return self.tasks
+
+    def summary_display(self):
+        """Print a nice box showing all tasks with status icons."""
+        active_count = sum(1 for t in self.tasks if t["status"] == "active")
+        done_count = sum(1 for t in self.tasks if t["status"] == "done")
+        total = len(self.tasks)
+        active_idx = next((i for i, t in enumerate(self.tasks) if t["status"] == "active"), 0)
+
+        print(f"\n{C.BRIGHT_BLUE}{C.BOLD}◆ TASK QUEUE ({active_idx + 1}/{total} active){C.RESET}")
+        print(f"{C.BRIGHT_BLUE}{'─' * 70}{C.RESET}")
+        for task in self.tasks:
+            desc = task["description"][:50]
+            if task["status"] == "done":
+                print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{desc}{C.RESET}")
+            elif task["status"] == "active":
+                print(f"  {C.BRIGHT_CYAN}▶{C.RESET} {C.BRIGHT_WHITE}{desc}{C.RESET}  {C.DIM}(active){C.RESET}")
+            elif task["status"] == "pending":
+                print(f"  {C.DIM}○{C.RESET} {C.DIM}{desc}{C.RESET}    {C.DIM}(pending){C.RESET}")
+            elif task["status"] == "failed":
+                print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.RED}{desc}{C.RESET}")
+        print()
+
+
+# ============================================================================
+# Session Memory
+# ============================================================================
+def load_history(working_dir: str) -> dict:
+    """Read .daveloop_history.json from working_dir. Return default if missing or corrupted."""
+    history_file = Path(working_dir) / ".daveloop_history.json"
+    if not history_file.exists():
+        return {"sessions": []}
+    try:
+        data = json.loads(history_file.read_text(encoding="utf-8"))
+        if not isinstance(data, dict) or "sessions" not in data:
+            print_warning_box("Corrupted history file - resetting")
+            return {"sessions": []}
+        return data
+    except (json.JSONDecodeError, ValueError):
+        print_warning_box("Corrupted history JSON - resetting")
+        return {"sessions": []}
+
+
+def save_history(working_dir: str, history_data: dict):
+    """Write to .daveloop_history.json. Keep only last 20 sessions."""
+    history_file = Path(working_dir) / ".daveloop_history.json"
+    history_data["sessions"] = history_data["sessions"][-20:]
+    history_file.write_text(json.dumps(history_data, indent=2), encoding="utf-8")
+
+
+def summarize_session(bug: str, outcome: str, iterations: int) -> dict:
+    """Return a dict summarizing a session."""
+    now = datetime.now()
+    return {
+        "session_id": now.strftime("%Y%m%d_%H%M%S"),
+        "bug": bug,
+        "outcome": outcome,
+        "iterations": iterations,
+        "timestamp": now.isoformat()
+    }
+
+
+def format_history_context(sessions: list) -> str:
+    """Return markdown string summarizing recent sessions for Claude context."""
+    if not sessions:
+        return ""
+    lines = ["## Previous DaveLoop Sessions"]
+    for s in sessions[-10:]:  # Show last 10
+        outcome = s.get("outcome", "UNKNOWN")
+        bug = s.get("bug", "unknown")[:60]
+        iters = s.get("iterations", "?")
+        lines.append(f"- [{outcome}] \"{bug}\" ({iters} iterations)")
+    return "\n".join(lines)
+
+
+def print_history_box(sessions: list):
+    """Print a nice UI box showing loaded history."""
+    if not sessions:
+        return
+    print(f"\n{C.BRIGHT_BLUE}{C.BOLD}◆ SESSION HISTORY{C.RESET}")
+    print(f"{C.BRIGHT_BLUE}{'─' * 70}{C.RESET}")
+    for s in sessions[-10:]:
+        outcome = s.get("outcome", "UNKNOWN")
+        bug = s.get("bug", "unknown")[:55]
+        iters = s.get("iterations", "?")
+        if outcome == "RESOLVED":
+            print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+        else:
+            print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+    print()
+
+
 # ============================================================================
 # Output Formatter
 # ============================================================================
@@ -263,6 +413,74 @@ def format_claude_output(output: str) -> str:
 
     return '\n'.join(formatted)
 
+# ============================================================================
+# Input Monitor
+# ============================================================================
+class InputMonitor:
+    """Daemon thread that reads stdin for commands while Claude is running.
+
+    After detecting a command, stops reading stdin so that input() calls
+    in the main thread can safely read without a race condition.
+    Call resume_reading() after the main thread is done with input().
+    """
+
+    VALID_COMMANDS = ("wait", "pause", "add", "done")
+
+    def __init__(self):
+        self._command = None
+        self._lock = threading.Lock()
+        self._thread = threading.Thread(target=self._read_loop, daemon=True)
+        self._running = False
+        self._read_gate = threading.Event()
+        self._read_gate.set()  # Start with reading enabled
+
+    def start(self):
+        """Start monitoring stdin."""
+        self._running = True
+        self._thread.start()
+
+    def stop(self):
+        """Stop monitoring stdin."""
+        self._running = False
+        self._read_gate.set()  # Unblock the thread so it can exit
+
+    def resume_reading(self):
+        """Resume reading stdin after an interrupt has been handled."""
+        self._read_gate.set()
+
+    def _read_loop(self):
+        """Read lines from stdin, looking for valid commands."""
+        while self._running:
+            # Wait until reading is enabled (blocks after a command is detected)
+            self._read_gate.wait()
+            if not self._running:
+                break
+            try:
+                line = sys.stdin.readline()
+                if not line:
+                    break
+                cmd = line.strip().lower()
+                if cmd in self.VALID_COMMANDS:
+                    with self._lock:
+                        self._command = cmd
+                    # Stop reading so input() in the main thread has no competition
+                    self._read_gate.clear()
+            except (EOFError, OSError):
+                break
+
+    def has_command(self) -> bool:
+        """Check if a command has been received."""
+        with self._lock:
+            return self._command is not None
+
+    def get_command(self) -> str:
+        """Get and clear the current command."""
+        with self._lock:
+            cmd = self._command
+            self._command = None
+            return cmd
+
+
 # ============================================================================
 # Core Functions
 # ============================================================================
@@ -316,11 +534,12 @@ def find_claude_cli():
     return None
 
 
-def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool = False, stream: bool = True, timeout: int = DEFAULT_TIMEOUT) -> str:
+def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool = False, stream: bool = True, timeout: int = DEFAULT_TIMEOUT, input_monitor=None) -> str:
     """Execute Claude Code CLI with the given prompt.
 
     If stream=True, output is printed in real-time and also returned.
     timeout is in seconds (default 600 = 10 minutes).
+    input_monitor: optional InputMonitor to check for user commands during execution.
     """
     claude_cmd = find_claude_cli()
     if not claude_cmd:
@@ -360,28 +579,14 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
             process.stdin.write(prompt)
             process.stdin.close()
 
-            # Heartbeat thread to show we're alive
+            # Track start time
             start_time = time.time()
-            heartbeat_active = True
-
-            def heartbeat():
-                while heartbeat_active:
-                    elapsed = int(time.time() - start_time)
-                    print(f"\r  {C.BLUE}[{elapsed}s elapsed...]{C.RESET}    ", end='')
-                    sys.stdout.flush()
-                    time.sleep(3)
-
-            heartbeat_thread = threading.Thread(target=heartbeat, daemon=True)
-            heartbeat_thread.start()
 
             # Read and display JSON stream output
-            import json
             output_lines = []
             full_text = []
 
             for line in process.stdout:
-                # Clear heartbeat line
-                print(f"\r{' '*40}\r", end='')
 
                 line = line.strip()
                 if not line:
@@ -391,6 +596,7 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                     data = json.loads(line)
                     msg_type = data.get("type", "")
 
+
                     # Handle different message types
                     if msg_type == "assistant":
                         # Assistant text message
@@ -402,6 +608,43 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                                     formatted = format_output_line(line_text)
                                     print(formatted)
                                 full_text.append(text)
+                            elif block.get("type") == "tool_use":
+                                # Tool being called - show what Claude is doing
+                                tool_name = block.get("name", "unknown")
+                                tool_input = block.get("input", {})
+
+                                # Format tool call based on type
+                                if tool_name == "Bash":
+                                    cmd = tool_input.get("command", "")
+                                    cmd_display = cmd[:50] + "..." if len(cmd) > 50 else cmd
+                                    tool_display = f"{C.BRIGHT_BLUE}Bash{C.RESET}({C.WHITE}{cmd_display}{C.RESET})"
+                                elif tool_name == "Read":
+                                    file_path = tool_input.get("file_path", "")
+                                    filename = file_path.split("\\")[-1].split("/")[-1]
+                                    tool_display = f"{C.BRIGHT_BLUE}Read{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                                elif tool_name == "Write":
+                                    file_path = tool_input.get("file_path", "")
+                                    filename = file_path.split("\\")[-1].split("/")[-1]
+                                    tool_display = f"{C.BRIGHT_BLUE}Write{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                                elif tool_name == "Edit":
+                                    file_path = tool_input.get("file_path", "")
+                                    filename = file_path.split("\\")[-1].split("/")[-1]
+                                    tool_display = f"{C.BRIGHT_BLUE}Edit{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                                elif tool_name == "Grep":
+                                    pattern = tool_input.get("pattern", "")
+                                    pattern_display = pattern[:25] + "..." if len(pattern) > 25 else pattern
+                                    tool_display = f"{C.BRIGHT_BLUE}Grep{C.RESET}({C.WHITE}{pattern_display}{C.RESET})"
+                                elif tool_name == "Glob":
+                                    pattern = tool_input.get("pattern", "")
+                                    tool_display = f"{C.BRIGHT_BLUE}Glob{C.RESET}({C.WHITE}{pattern}{C.RESET})"
+                                elif tool_name == "Task":
+                                    desc = tool_input.get("description", "")
+                                    tool_display = f"{C.BRIGHT_BLUE}Task{C.RESET}({C.WHITE}{desc}{C.RESET})"
+                                else:
+                                    tool_display = f"{C.BRIGHT_BLUE}{tool_name}{C.RESET}"
+
+                                print(f"  {C.BRIGHT_BLUE}▶{C.RESET} {tool_display}")
+                                sys.stdout.flush()
 
                     elif msg_type == "content_block_delta":
                         # Streaming text delta
@@ -412,21 +655,58 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                             full_text.append(text)
 
                     elif msg_type == "tool_use":
-                        # Tool being used
+                        # Tool being used - show what Claude is doing
                         tool_name = data.get("name", "unknown")
-                        print(f"\n  {C.BLUE}🔧 Using tool: {tool_name}{C.RESET}")
+                        tool_input = data.get("input", {})
+
+                        # Format tool call based on type
+                        if tool_name == "Bash":
+                            cmd = tool_input.get("command", "")
+                            cmd_display = cmd[:50] + "..." if len(cmd) > 50 else cmd
+                            tool_display = f"{C.BRIGHT_BLUE}Bash{C.RESET}({C.WHITE}{cmd_display}{C.RESET})"
+                        elif tool_name == "Read":
+                            file_path = tool_input.get("file_path", "")
+                            filename = file_path.split("\\")[-1].split("/")[-1]
+                            tool_display = f"{C.BRIGHT_BLUE}Read{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                        elif tool_name == "Write":
+                            file_path = tool_input.get("file_path", "")
+                            filename = file_path.split("\\")[-1].split("/")[-1]
+                            tool_display = f"{C.BRIGHT_BLUE}Write{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                        elif tool_name == "Edit":
+                            file_path = tool_input.get("file_path", "")
+                            filename = file_path.split("\\")[-1].split("/")[-1]
+                            tool_display = f"{C.BRIGHT_BLUE}Edit{C.RESET}({C.WHITE}{filename}{C.RESET})"
+                        elif tool_name == "Grep":
+                            pattern = tool_input.get("pattern", "")
+                            pattern_display = pattern[:25] + "..." if len(pattern) > 25 else pattern
+                            tool_display = f"{C.BRIGHT_BLUE}Grep{C.RESET}({C.WHITE}{pattern_display}{C.RESET})"
+                        elif tool_name == "Glob":
+                            pattern = tool_input.get("pattern", "")
+                            tool_display = f"{C.BRIGHT_BLUE}Glob{C.RESET}({C.WHITE}{pattern}{C.RESET})"
+                        elif tool_name == "Task":
+                            desc = tool_input.get("description", "")
+                            tool_display = f"{C.BRIGHT_BLUE}Task{C.RESET}({C.WHITE}{desc}{C.RESET})"
+                        else:
+                            tool_display = f"{C.BRIGHT_BLUE}{tool_name}{C.RESET}"
+
+                        print(f"  {C.BRIGHT_BLUE}▶{C.RESET} {tool_display}")
+                        sys.stdout.flush()
 
                     elif msg_type == "tool_result":
-                        # Tool result
-                        print(f"  {C.BLUE}✓ Tool completed{C.RESET}\n")
+                        # Tool completed
+                        print(f"  {C.BRIGHT_BLUE}└─{C.RESET} {C.GREEN}✓{C.RESET}")
+
+                    elif msg_type == "user":
+                        # Tool results come back as user messages
+                        content = data.get("message", {}).get("content", [])
+                        for block in content:
+                            if block.get("type") == "tool_result":
+                                print(f"  {C.BRIGHT_BLUE}└─{C.RESET} {C.GREEN}✓{C.RESET}")
 
                     elif msg_type == "result":
-                        # Final result
+                        # Final result - skip printing as it duplicates streamed content
                         text = data.get("result", "")
                         if text:
-                            for line_text in text.split('\n'):
-                                formatted = format_output_line(line_text)
-                                print(formatted)
                             full_text.append(text)
 
                     elif msg_type == "error":
@@ -442,8 +722,15 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
 
                 output_lines.append(line)
 
-            heartbeat_active = False
-            print(f"\r{' '*40}\r", end='')  # Clear final heartbeat
+                # Check for user commands from InputMonitor
+                if input_monitor and input_monitor.has_command():
+                    user_cmd = input_monitor.get_command()
+                    try:
+                        process.terminate()
+                        process.wait(timeout=5)
+                    except Exception:
+                        pass
+                    return f"[DAVELOOP:INTERRUPTED:{user_cmd}]"
 
             process.wait(timeout=timeout)
             return '\n'.join(full_text)
@@ -476,36 +763,40 @@ def format_output_line(line: str) -> str:
     """Format a single line of Claude's output with colors."""
     # Reasoning markers
     if "=== DAVELOOP REASONING ===" in line:
-        return f"\n{C.BRIGHT_BLUE}{'─'*50}\n  🧠 REASONING\n{'─'*50}{C.RESET}"
+        return f"""
+{C.BRIGHT_BLUE}  ┌─ 🧠 REASONING ─────────────────────────────────────────────────────┐{C.RESET}"""
     if "===========================" in line:
-        return f"{C.BRIGHT_BLUE}{'─'*50}{C.RESET}\n"
+        return f"{C.BRIGHT_BLUE}  └─────────────────────────────────────────────────────────────────────┘{C.RESET}"
 
     # Reasoning labels
     if line.startswith("KNOWN:"):
-        return f"  {C.BLUE}KNOWN:{C.RESET}{C.WHITE}{line[6:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}KNOWN:{C.RESET} {C.WHITE}{line[6:]}{C.RESET}"
     if line.startswith("UNKNOWN:"):
-        return f"  {C.BLUE}UNKNOWN:{C.RESET}{C.WHITE}{line[8:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}UNKNOWN:{C.RESET} {C.WHITE}{line[8:]}{C.RESET}"
     if line.startswith("HYPOTHESIS:"):
-        return f"  {C.BLUE}HYPOTHESIS:{C.RESET}{C.WHITE}{line[11:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}HYPOTHESIS:{C.RESET} {C.WHITE}{line[11:]}{C.RESET}"
     if line.startswith("NEXT ACTION:"):
-        return f"  {C.BLUE}NEXT ACTION:{C.RESET}{C.WHITE}{line[12:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}NEXT:{C.RESET} {C.WHITE}{line[12:]}{C.RESET}"
     if line.startswith("WHY:"):
-        return f"  {C.BLUE}WHY:{C.RESET}{C.WHITE}{line[4:]}{C.RESET}"
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}WHY:{C.RESET} {C.WHITE}{line[4:]}{C.RESET}"
 
-    # Exit signals - just dim them out in the stream, don't make them prominent
-    # The actual success/error boxes will be shown after iteration completes
+    # Exit signals - hide them, the success/error box will show
     if "[DAVELOOP:RESOLVED]" in line:
-        return f"  {C.DIM}→ [Exit signal detected: RESOLVED]{C.RESET}"
+        return ""
     if "[DAVELOOP:BLOCKED]" in line:
-        return f"  {C.DIM}→ [Exit signal detected: BLOCKED]{C.RESET}"
+        return ""
     if "[DAVELOOP:CLARIFY]" in line:
-        return f"  {C.DIM}→ [Exit signal detected: CLARIFY]{C.RESET}"
+        return ""
 
-    # Code blocks
+    # Code blocks - hide the markers
     if line.strip().startswith("```"):
-        return f"{C.BLUE}{'─'*40}{C.RESET}"
+        return ""
 
-    # Default - white text
+    # Empty lines - minimal spacing
+    if not line.strip():
+        return ""
+
+    # Default - white text with subtle indent
     return f"  {C.WHITE}{line}{C.RESET}"
 
 
@@ -539,7 +830,7 @@ def main():
         description="DaveLoop - Self-Healing Debug Agent",
         formatter_class=argparse.RawDescriptionHelpFormatter
     )
-    parser.add_argument("bug", nargs="?", help="Bug description or error message")
+    parser.add_argument("bug", nargs="*", help="Bug description(s) or error message(s)")
     parser.add_argument("-f", "--file", help="Read bug description from file")
     parser.add_argument("-d", "--dir", help="Working directory for Claude Code")
     parser.add_argument("-m", "--max-iterations", type=int, default=MAX_ITERATIONS)
@@ -553,16 +844,19 @@ def main():
     os.system('cls' if os.name == 'nt' else 'clear')
     print(BANNER)
 
-    # Get bug description
+    # Collect bug descriptions
+    bug_descriptions = []
     if args.file:
-        bug_input = Path(args.file).read_text(encoding="utf-8")
+        bug_descriptions.append(Path(args.file).read_text(encoding="utf-8"))
     elif args.bug:
-        bug_input = args.bug
+        bug_descriptions.extend(args.bug)
     else:
         print(f"  {C.CYAN}Describe the bug (Ctrl+D or Ctrl+Z to finish):{C.RESET}")
-        bug_input = sys.stdin.read().strip()
+        stdin_input = sys.stdin.read().strip()
+        if stdin_input:
+            bug_descriptions.append(stdin_input)
 
-    if not bug_input:
+    if not bug_descriptions:
         print_error_box("No bug description provided")
         return 1
 
@@ -571,30 +865,61 @@ def main():
     system_prompt = load_prompt()
     working_dir = args.dir or os.getcwd()
 
+    # Load session history
+    history_data = load_history(working_dir)
+    if history_data["sessions"]:
+        print_history_box(history_data["sessions"])
+
     # Session info
     print_header_box(f"SESSION: {session_id}", C.BRIGHT_BLUE)
-    print_status("Working Directory", working_dir, C.WHITE)
-    print_status("Max Iterations", str(args.max_iterations), C.WHITE)
-    print_status("Timeout", f"{args.timeout // 60} min ({args.timeout}s) per iteration", C.WHITE)
-    print_status("Context Mode", "PERSISTENT (--continue)", C.WHITE)
-    print_status("System Prompt", f"{len(system_prompt)} chars loaded", C.WHITE)
-    print()
-
-    print_section("BUG REPORT", C.BRIGHT_RED)
-    # Wrap bug input nicely
-    for line in bug_input.split('\n')[:10]:
-        print(f"  {C.RED}{line[:80]}{C.RESET}")
-    if len(bug_input.split('\n')) > 10:
-        print(f"  {C.RED}... ({len(bug_input.split(chr(10))) - 10} more lines){C.RESET}")
-    print()
-
-    sys.stdout.flush()
+    print_status("Directory", working_dir, C.WHITE)
+    print_status("Iterations", str(args.max_iterations), C.WHITE)
+    print_status("Timeout", f"{args.timeout // 60}m per iteration", C.WHITE)
+    print_status("Tasks", str(len(bug_descriptions)), C.WHITE)
+    print_status("Mode", "Autonomous", C.WHITE)
+    print(f"{C.BRIGHT_BLUE}└{'─' * 70}┘{C.RESET}")
+
+    # Build task queue
+    task_queue = TaskQueue()
+    for desc in bug_descriptions:
+        task_queue.add(desc)
+
+    # Print controls hint
+    print(f"\n{C.BRIGHT_BLUE}{C.BOLD}┌─ CONTROLS {'─' * 58}┐{C.RESET}")
+    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.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"])
+
+    # === OUTER LOOP: iterate over tasks ===
+    while True:
+        task = task_queue.next()
+        if task is None:
+            break
+
+        bug_input = task["description"]
+        task_queue.summary_display()
+
+        print_section("BUG REPORT", C.BRIGHT_RED)
+        for line in bug_input.split('\n')[:8]:
+            print(f"  {C.BRIGHT_RED}{line[:70]}{C.RESET}")
+        if len(bug_input.split('\n')) > 8:
+            print(f"  {C.RED}... +{len(bug_input.split(chr(10))) - 8} more lines{C.RESET}")
+        sys.stdout.flush()
 
-    # Initial context
-    context = f"""
+        # Initial context for this task
+        context = f"""
 ## Bug Report
 
 {bug_input}
+{history_context}
 
 ## Instructions
 
@@ -602,68 +927,143 @@ Analyze this bug. Gather whatever logs/information you need to understand it.
 Then fix it. Use the reasoning protocol before each action.
 """
 
-    iteration_history = []
+        iteration_history = []
 
-    for iteration in range(1, args.max_iterations + 1):
-        print_iteration_header(iteration, args.max_iterations)
+        # === INNER LOOP: iterations for current task ===
+        for iteration in range(1, args.max_iterations + 1):
 
-        if iteration == 1:
-            full_prompt = f"{system_prompt}\n\n---\n\n{context}"
-            continue_session = False
-        else:
-            full_prompt = context
-            continue_session = True
+            if iteration == 1:
+                full_prompt = f"{system_prompt}\n\n---\n\n{context}"
+                continue_session = False
+            else:
+                full_prompt = context
+                continue_session = True
 
-        if args.verbose:
-            print(f"  {C.DIM}[DEBUG] Prompt: {len(full_prompt)} chars, continue={continue_session}{C.RESET}")
+            if args.verbose:
+                print(f"  {C.DIM}[DEBUG] Prompt: {len(full_prompt)} chars, continue={continue_session}{C.RESET}")
 
-        # Show "Claude is working" indicator
-        print(f"\n  {C.BRIGHT_BLUE}▶ Claude is working...{C.RESET}\n")
-        sys.stdout.flush()
+            # Show "Claude is working" indicator
+            print(f"\n  {C.BRIGHT_BLUE}◆ Agent active...{C.RESET}\n")
+            sys.stdout.flush()
+
+            # Run Claude with real-time streaming output
+            output = run_claude_code(
+                full_prompt, working_dir,
+                continue_session=continue_session,
+                stream=True, timeout=args.timeout,
+                input_monitor=input_monitor
+            )
 
-        # Run Claude with real-time streaming output
-        output = run_claude_code(full_prompt, working_dir, continue_session=continue_session, stream=True, timeout=args.timeout)
-
-        print(f"\n  {C.BLUE}✓ Iteration complete{C.RESET}\n")
-
-        # Save log
-        save_log(iteration, output, session_id)
-        iteration_history.append(output)
-
-        # Check exit condition
-        signal, should_exit = check_exit_condition(output)
-
-        if should_exit:
-            if signal == "RESOLVED":
-                print_success_box(f"Bug fixed in {iteration} iteration(s)!")
-                print_status("Session", session_id, C.WHITE)
-                print_status("Logs", str(LOG_DIR), C.WHITE)
-                print()
-                return 0
-            elif signal == "CLARIFY":
-                print_warning_box("Claude needs clarification")
-                print(f"\n  {C.BLUE}Your response:{C.RESET}")
-                human_input = input(f"  {C.WHITE}> {C.RESET}")
-                context = f"""
+            print(f"\n{C.BRIGHT_BLUE}  {'─' * 70}{C.RESET}")
+
+            # Save log
+            save_log(iteration, output, session_id)
+            iteration_history.append(output)
+
+            # Check for user interrupt commands
+            if "[DAVELOOP:INTERRUPTED:" in output:
+                # Extract the command name
+                cmd_start = output.index("[DAVELOOP:INTERRUPTED:") + len("[DAVELOOP:INTERRUPTED:")
+                cmd_end = output.index("]", cmd_start)
+                user_cmd = output[cmd_start:cmd_end]
+
+                if user_cmd in ("wait", "pause"):
+                    # Pause and get user correction
+                    print(f"\n{C.BRIGHT_YELLOW}{C.BOLD}  \u23f8 PAUSED - DaveLoop is waiting for your input{C.RESET}")
+                    print(f"{C.BRIGHT_YELLOW}  {'─' * 70}{C.RESET}")
+                    print(f"  {C.WHITE}  Type your correction or additional context:{C.RESET}")
+                    try:
+                        human_input = input(f"  {C.WHITE}> {C.RESET}")
+                    except EOFError:
+                        human_input = ""
+                    input_monitor.resume_reading()
+                    context = f"""
+## Human Correction (pause/wait command)
+
+{human_input}
+
+Continue debugging with this corrected context. Use the reasoning protocol before each action.
+"""
+                    continue
+
+                elif user_cmd == "add":
+                    # Prompt for new task, then resume current
+                    print(f"\n  {C.BRIGHT_CYAN}Enter new task description:{C.RESET}")
+                    try:
+                        new_desc = input(f"  {C.WHITE}> {C.RESET}")
+                    except EOFError:
+                        new_desc = ""
+                    input_monitor.resume_reading()
+                    if new_desc.strip():
+                        task_queue.add(new_desc.strip())
+                        print(f"  {C.GREEN}✓{C.RESET} Task added to queue")
+                        task_queue.summary_display()
+                    # Resume current task with --continue
+                    context = f"""
+## Continuing after user added a new task to the queue
+
+Continue the current debugging task. Use the reasoning protocol before each action.
+"""
+                    continue
+
+                elif user_cmd == "done":
+                    # Clean exit
+                    input_monitor.stop()
+                    session_entry = summarize_session(bug_input, "DONE_BY_USER", iteration)
+                    history_data["sessions"].append(session_entry)
+                    save_history(working_dir, history_data)
+                    print(f"\n  {C.GREEN}✓{C.RESET} Session saved. Exiting by user request.")
+                    return 0
+
+            # Check exit condition
+            signal, should_exit = check_exit_condition(output)
+
+            if should_exit:
+                if signal == "RESOLVED":
+                    print_success_box("")
+                    print(f"  {C.DIM}Session: {session_id}{C.RESET}")
+                    print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")
+                    task_queue.mark_done()
+                    session_entry = summarize_session(bug_input, "RESOLVED", iteration)
+                    history_data["sessions"].append(session_entry)
+                    save_history(working_dir, history_data)
+                    break  # Move to next task
+                elif signal == "CLARIFY":
+                    print_warning_box("Claude needs clarification")
+                    print(f"\n  {C.BLUE}Your response:{C.RESET}")
+                    try:
+                        human_input = input(f"  {C.WHITE}> {C.RESET}")
+                    except EOFError:
+                        human_input = ""
+                    input_monitor.resume_reading()
+                    context = f"""
 ## Human Clarification
 
 {human_input}
 
 Continue debugging with this information. Use the reasoning protocol before each action.
 """
-                continue
-            elif signal == "BLOCKED":
-                print_error_box(f"Claude is blocked - needs human help")
-                print_status("Session", session_id, C.WHITE)
-                print_status("Logs", str(LOG_DIR), C.WHITE)
-                print()
-                return 1
-            else:
-                print_error_box(f"Error occurred: {signal}")
-                return 1
-
-        # Prepare context for next iteration
-        context = f"""
+                    continue
+                elif signal == "BLOCKED":
+                    print_error_box("Claude is blocked - needs human help")
+                    print_status("Session", session_id, C.WHITE)
+                    print_status("Logs", str(LOG_DIR), C.WHITE)
+                    print()
+                    task_queue.mark_failed()
+                    session_entry = summarize_session(bug_input, "BLOCKED", iteration)
+                    history_data["sessions"].append(session_entry)
+                    save_history(working_dir, history_data)
+                    break  # Move to next task
+                else:
+                    print_error_box(f"Error occurred: {signal}")
+                    task_queue.mark_failed()
+                    session_entry = summarize_session(bug_input, "ERROR", iteration)
+                    history_data["sessions"].append(session_entry)
+                    save_history(working_dir, history_data)
+                    break  # Move to next task
+
+            # Prepare context for next iteration
+            context = f"""
 ## Iteration {iteration + 1}
 
 The bug is NOT yet resolved. You have full context from previous iterations.
@@ -671,23 +1071,46 @@ 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
-    print_warning_box(f"Max iterations ({args.max_iterations}) reached")
-    print_status("Session", session_id, C.WHITE)
-    print_status("Logs", str(LOG_DIR), C.WHITE)
+        else:
+            # Max iterations reached for this task (for-else)
+            print_warning_box(f"Max iterations ({args.max_iterations}) reached for current task")
+            task_queue.mark_failed()
+            session_entry = summarize_session(bug_input, "MAX_ITERATIONS", args.max_iterations)
+            history_data["sessions"].append(session_entry)
+            save_history(working_dir, history_data)
+
+        # Save iteration summary for this task
+        LOG_DIR.mkdir(exist_ok=True)
+        summary = f"# DaveLoop Session {session_id}\n\n"
+        summary += f"Bug: {bug_input[:200]}...\n\n"
+        summary += f"Iterations: {len(iteration_history)}\n\n"
+        summary += "## Iteration History\n\n"
+        for i, hist in enumerate(iteration_history, 1):
+            summary += f"### Iteration {i}\n```\n{hist[:500]}...\n```\n\n"
+        (LOG_DIR / f"{session_id}_summary.md").write_text(summary, encoding="utf-8")
+
+    # === All tasks done - print final summary ===
+    input_monitor.stop()
+
+    print(f"\n{C.BRIGHT_BLUE}{C.BOLD}◆ ALL TASKS COMPLETE{C.RESET}")
+    print(f"{C.BRIGHT_BLUE}{'─' * 70}{C.RESET}")
+    for task in task_queue.all():
+        desc = task["description"][:55]
+        status = task["status"]
+        if status == "done":
+            print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{desc}{C.RESET}")
+        elif status == "failed":
+            print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.RED}{desc}{C.RESET}")
+        else:
+            print(f"  {C.DIM}○ {desc}{C.RESET}")
     print()
 
-    # Save summary
-    summary = f"# DaveLoop Session {session_id}\n\n"
-    summary += f"Bug: {bug_input[:200]}...\n\n"
-    summary += f"Iterations: {args.max_iterations}\n\n"
-    summary += "## Iteration History\n\n"
-    for i, hist in enumerate(iteration_history, 1):
-        summary += f"### Iteration {i}\n```\n{hist[:500]}...\n```\n\n"
-    (LOG_DIR / f"{session_id}_summary.md").write_text(summary, encoding="utf-8")
+    print(f"  {C.DIM}Session: {session_id}{C.RESET}")
+    print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")
 
-    return 1
+    # Return 0 if all tasks done, 1 if any failed
+    all_done = all(t["status"] == "done" for t in task_queue.all())
+    return 0 if all_done else 1
 
 
 if __name__ == "__main__":

daveloop-1.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-daveloop.py,sha256=qSdddbGuqeAbwpKRrloy9BHfReRp5KqemJoTkO4OgeQ,28496
-daveloop_swebench.py,sha256=iD9AU3XRiMQpt7TknFNlvnmPCNp64V-JaTfqTFgsGBM,15996
-daveloop-1.1.0.dist-info/METADATA,sha256=AQ6vfEzvM2yGDxvuHROHjki3QS_w_CpCFJ1KE6D482M,10285
-daveloop-1.1.0.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
-daveloop-1.1.0.dist-info/entry_points.txt,sha256=QcFAZgFrDfPtIikNQb7eW9DxOpBK7T-qWrKqbGAS9Ww,86
-daveloop-1.1.0.dist-info/top_level.txt,sha256=36DiYt70m4DIK8t7IhV_y6hAzUIyeb5-qDUf3-gbDdg,27
-daveloop-1.1.0.dist-info/RECORD,,