daveloop 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

daveloop.py

@@ -1,716 +1,767 @@
-#!/usr/bin/env python3
-"""
-DaveLoop - Self-Healing Debug Agent
-Orchestrates Claude Code CLI in a feedback loop until bugs are resolved.
-"""
-
-import subprocess
-import sys
-import os
-import argparse
-import threading
-import time
-import itertools
-from datetime import datetime
-from pathlib import Path
-
-# Configuration
-MAX_ITERATIONS = 20
-
-# Find prompt file - works both when running as script and when installed as package
-def find_prompt_file():
-    """Find the prompt file in the correct location."""
-    # Try script directory first (for development)
-    script_dir = Path(__file__).parent
-    script_prompt = script_dir / "daveloop_prompt.md"
-    if script_prompt.exists():
-        return script_prompt
-
-    # Try package resources (for pip install)
-    try:
-        import importlib.resources as pkg_resources
-        try:
-            # Python 3.9+
-            files = pkg_resources.files(__package__ or __name__.split('.')[0])
-            return files / "daveloop_prompt.md"
-        except AttributeError:
-            # Python 3.7-3.8
-            with pkg_resources.path(__package__ or __name__.split('.')[0], "daveloop_prompt.md") as p:
-                return p
-    except (ImportError, FileNotFoundError):
-        pass
-
-    # Fallback to script directory
-    return script_prompt
-
-SCRIPT_DIR = Path(__file__).parent
-PROMPT_FILE = find_prompt_file()
-LOG_DIR = Path.cwd() / "logs"  # Use current working directory for logs
-
-# Exit signals from Claude Code
-SIGNAL_RESOLVED = "[DAVELOOP:RESOLVED]"
-SIGNAL_BLOCKED = "[DAVELOOP:BLOCKED]"
-SIGNAL_CLARIFY = "[DAVELOOP:CLARIFY]"
-
-# ============================================================================
-# ANSI Color Codes
-# ============================================================================
-class Colors:
-    RESET = "\033[0m"
-    BOLD = "\033[1m"
-    DIM = "\033[2m"
-
-    # Foreground
-    BLACK = "\033[30m"
-    RED = "\033[31m"
-    GREEN = "\033[32m"
-    YELLOW = "\033[33m"
-    BLUE = "\033[34m"
-    MAGENTA = "\033[35m"
-    CYAN = "\033[36m"
-    WHITE = "\033[37m"
-
-    # Bright foreground
-    BRIGHT_RED = "\033[91m"
-    BRIGHT_GREEN = "\033[92m"
-    BRIGHT_YELLOW = "\033[93m"
-    BRIGHT_BLUE = "\033[94m"
-    BRIGHT_MAGENTA = "\033[95m"
-    BRIGHT_CYAN = "\033[96m"
-    BRIGHT_WHITE = "\033[97m"
-
-    # Background
-    BG_BLACK = "\033[40m"
-    BG_RED = "\033[41m"
-    BG_GREEN = "\033[42m"
-    BG_BLUE = "\033[44m"
-    BG_MAGENTA = "\033[45m"
-    BG_CYAN = "\033[46m"
-
-C = Colors  # Shorthand
-
-# Enable ANSI and UTF-8 on Windows
-if sys.platform == "win32":
-    os.system("chcp 65001 >nul 2>&1")  # Set console to UTF-8
-    os.system("")  # Enables ANSI escape sequences in Windows terminal
-    # Force UTF-8 encoding for stdout/stderr (only if not already wrapped)
-    import io
-    if not isinstance(sys.stdout, io.TextIOWrapper) or sys.stdout.encoding != 'utf-8':
-        if hasattr(sys.stdout, 'buffer'):
-            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
-    if not isinstance(sys.stderr, io.TextIOWrapper) or sys.stderr.encoding != 'utf-8':
-        if hasattr(sys.stderr, 'buffer'):
-            sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
-
-# ============================================================================
-# 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}
-"""
-
-# ============================================================================
-# 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")
-
-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")
-
-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}")
-
-def print_iteration_header(iteration: int, max_iter: int):
-    """Print the iteration header with visual progress."""
-    progress = iteration / max_iter
-    bar_width = 30
-    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)}%"
-
-    print(f"\n{C.BOLD}{C.WHITE}{iteration_text}{C.RESET}  {bar}  {C.BRIGHT_BLUE}{percentage_text}{C.RESET}\n")
-
-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")
-
-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")
-
-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")
-
-# ============================================================================
-# Spinner Animation
-# ============================================================================
-class Spinner:
-    """Animated spinner for showing work in progress."""
-
-    def __init__(self, message: str = "Processing"):
-        self.message = message
-        self.running = False
-        self.thread = None
-        self.frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
-        self.start_time = None
-
-    def spin(self):
-        idx = 0
-        while self.running:
-            elapsed = time.time() - self.start_time
-            frame = self.frames[idx % len(self.frames)]
-            sys.stdout.write(f"\r  {C.BRIGHT_CYAN}{frame}{C.RESET} {C.BOLD}{self.message}{C.RESET} {C.DIM}({elapsed:.0f}s){C.RESET}  ")
-            sys.stdout.flush()
-            idx += 1
-            time.sleep(0.1)
-
-    def start(self):
-        self.running = True
-        self.start_time = time.time()
-        self.thread = threading.Thread(target=self.spin)
-        self.thread.start()
-
-    def stop(self, final_message: str = None):
-        self.running = False
-        if self.thread:
-            self.thread.join()
-        elapsed = time.time() - self.start_time
-        if final_message:
-            sys.stdout.write(f"\r  {C.GREEN}✓{C.RESET} {final_message} {C.DIM}({elapsed:.1f}s){C.RESET}                    \n")
-        else:
-            sys.stdout.write(f"\r  {C.GREEN}✓{C.RESET} {self.message} complete {C.DIM}({elapsed:.1f}s){C.RESET}                    \n")
-        sys.stdout.flush()
-
-# ============================================================================
-# Output Formatter
-# ============================================================================
-def format_claude_output(output: str) -> str:
-    """Format Claude's output with colors and sections."""
-    lines = output.split('\n')
-    formatted = []
-    in_reasoning = False
-    in_code = False
-
-    for line in lines:
-        # Reasoning block
-        if "=== DAVELOOP REASONING ===" in line:
-            in_reasoning = True
-            formatted.append(f"\n{C.BRIGHT_YELLOW}┌{'─'*50}┐{C.RESET}")
-            formatted.append(f"{C.BRIGHT_YELLOW}│{C.BOLD} 🧠 REASONING{C.RESET}")
-            formatted.append(f"{C.BRIGHT_YELLOW}├{'─'*50}┤{C.RESET}")
-            continue
-        elif "===========================" in line and in_reasoning:
-            in_reasoning = False
-            formatted.append(f"{C.BRIGHT_YELLOW}└{'─'*50}┘{C.RESET}\n")
-            continue
-
-        # Verification block
-        if "=== VERIFICATION ===" in line:
-            formatted.append(f"\n{C.BRIGHT_GREEN}┌{'─'*50}┐{C.RESET}")
-            formatted.append(f"{C.BRIGHT_GREEN}│{C.BOLD} ✓ VERIFICATION{C.RESET}")
-            formatted.append(f"{C.BRIGHT_GREEN}├{'─'*50}┤{C.RESET}")
-            continue
-        elif "====================" in line:
-            formatted.append(f"{C.BRIGHT_GREEN}└{'─'*50}┘{C.RESET}\n")
-            continue
-
-        # Code blocks
-        if line.strip().startswith("```"):
-            in_code = not in_code
-            if in_code:
-                formatted.append(f"{C.DIM}┌─ code ────────────────────────────────{C.RESET}")
-            else:
-                formatted.append(f"{C.DIM}└───────────────────────────────────────{C.RESET}")
-            continue
-
-        # Reasoning labels
-        if in_reasoning:
-            if line.startswith("KNOWN:"):
-                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.CYAN}KNOWN:{C.RESET}{line[6:]}")
-            elif line.startswith("UNKNOWN:"):
-                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.MAGENTA}UNKNOWN:{C.RESET}{line[8:]}")
-            elif line.startswith("HYPOTHESIS:"):
-                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.YELLOW}HYPOTHESIS:{C.RESET}{line[11:]}")
-            elif line.startswith("NEXT ACTION:"):
-                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.GREEN}NEXT ACTION:{C.RESET}{line[12:]}")
-            elif line.startswith("WHY:"):
-                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.BLUE}WHY:{C.RESET}{line[4:]}")
-            else:
-                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {line}")
-            continue
-
-        # Exit signals - dim them out, don't make prominent
-        if "[DAVELOOP:RESOLVED]" in line:
-            formatted.append(f"  {C.DIM}→ [Exit signal: RESOLVED]{C.RESET}")
-            continue
-        elif "[DAVELOOP:BLOCKED]" in line:
-            formatted.append(f"  {C.DIM}→ [Exit signal: BLOCKED]{C.RESET}")
-            continue
-        elif "[DAVELOOP:CLARIFY]" in line:
-            formatted.append(f"  {C.DIM}→ [Exit signal: CLARIFY]{C.RESET}")
-            continue
-
-        # Code content
-        if in_code:
-            formatted.append(f"{C.DIM}│{C.RESET} {C.WHITE}{line}{C.RESET}")
-            continue
-
-        # Regular content
-        formatted.append(f"  {line}")
-
-    return '\n'.join(formatted)
-
-# ============================================================================
-# Core Functions
-# ============================================================================
-def load_prompt() -> str:
-    """Load the DaveLoop system prompt."""
-    if PROMPT_FILE.exists():
-        return PROMPT_FILE.read_text(encoding="utf-8")
-    else:
-        print_warning_box(f"Prompt file not found: {PROMPT_FILE}")
-        return "You are debugging. Fix the bug. Output [DAVELOOP:RESOLVED] when done."
-
-
-def find_claude_cli():
-    """Find Claude CLI executable path."""
-    import platform
-    import shutil
-
-    # 1. Check environment variable (highest priority)
-    env_path = os.environ.get('CLAUDE_CLI_PATH')
-    if env_path and os.path.exists(env_path):
-        return env_path
-
-    # 2. Try common installation paths
-    is_windows = platform.system() == "Windows"
-    if is_windows:
-        common_paths = [
-            os.path.expanduser("~\\AppData\\Local\\Programs\\claude\\claude.cmd"),
-            os.path.expanduser("~\\AppData\\Roaming\\npm\\claude.cmd"),
-            "C:\\Program Files\\Claude\\claude.cmd",
-            "C:\\Program Files (x86)\\Claude\\claude.cmd",
-        ]
-        for path in common_paths:
-            if os.path.exists(path):
-                return path
-    else:
-        common_paths = [
-            "/usr/local/bin/claude",
-            "/usr/bin/claude",
-            os.path.expanduser("~/.local/bin/claude"),
-        ]
-        for path in common_paths:
-            if os.path.exists(path):
-                return path
-
-    # 3. Check if it's in PATH
-    claude_name = "claude.cmd" if is_windows else "claude"
-    if shutil.which(claude_name):
-        return claude_name
-
-    # 4. Not found
-    return None
-
-
-def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool = False, stream: bool = True) -> str:
-    """Execute Claude Code CLI with the given prompt.
-
-    If stream=True, output is printed in real-time and also returned.
-    """
-    claude_cmd = find_claude_cli()
-    if not claude_cmd:
-        error_msg = (
-            "Claude CLI not found!\n\n"
-            "Please install Claude Code CLI or set CLAUDE_CLI_PATH environment variable:\n"
-            "  Windows: set CLAUDE_CLI_PATH=C:\\path\\to\\claude.cmd\n"
-            "  Linux/Mac: export CLAUDE_CLI_PATH=/path/to/claude\n\n"
-            "Install from: https://github.com/anthropics/claude-code"
-        )
-        print_error_box(error_msg)
-        return "[DAVELOOP:ERROR] Claude CLI not found"
-
-    cmd = [claude_cmd]
-
-    if continue_session:
-        cmd.append("--continue")
-
-    cmd.extend(["-p", "--verbose", "--output-format", "stream-json", "--allowedTools", "Bash,Read,Write,Edit,Glob,Grep,Task"])
-
-    try:
-        if stream:
-            # Stream output in real-time
-            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  # Line buffered
-            )
-
-            # Send prompt and close stdin
-            process.stdin.write(prompt)
-            process.stdin.close()
-
-            # Heartbeat thread to show we're alive
-            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:
-                    continue
-
-                try:
-                    data = json.loads(line)
-                    msg_type = data.get("type", "")
-
-                    # Handle different message types
-                    if msg_type == "assistant":
-                        # Assistant text message
-                        content = data.get("message", {}).get("content", [])
-                        for block in content:
-                            if block.get("type") == "text":
-                                text = block.get("text", "")
-                                for line_text in text.split('\n'):
-                                    formatted = format_output_line(line_text)
-                                    print(formatted)
-                                full_text.append(text)
-
-                    elif msg_type == "content_block_delta":
-                        # Streaming text delta
-                        delta = data.get("delta", {})
-                        if delta.get("type") == "text_delta":
-                            text = delta.get("text", "")
-                            print(text, end='')
-                            full_text.append(text)
-
-                    elif msg_type == "tool_use":
-                        # Tool being used
-                        tool_name = data.get("name", "unknown")
-                        print(f"\n  {C.BLUE}🔧 Using tool: {tool_name}{C.RESET}")
-
-                    elif msg_type == "tool_result":
-                        # Tool result
-                        print(f"  {C.BLUE}✓ Tool completed{C.RESET}\n")
-
-                    elif msg_type == "result":
-                        # Final result
-                        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":
-                        error_msg = data.get("error", {}).get("message", "Unknown error")
-                        print(f"  {C.RED}ERROR: {error_msg}{C.RESET}")
-
-                    sys.stdout.flush()
-
-                except json.JSONDecodeError:
-                    # Not JSON, just print as-is
-                    print(f"  {line}")
-                    full_text.append(line)
-
-                output_lines.append(line)
-
-            heartbeat_active = False
-            print(f"\r{' '*40}\r", end='')  # Clear final heartbeat
-
-            process.wait(timeout=600)
-            return '\n'.join(full_text)
-        else:
-            # Non-streaming mode
-            result = subprocess.run(
-                cmd,
-                input=prompt,
-                capture_output=True,
-                text=True,
-                encoding='utf-8',
-                errors='replace',
-                cwd=working_dir,
-                timeout=600
-            )
-            output = result.stdout
-            if result.stderr:
-                output += f"\n{C.RED}[STDERR]{C.RESET}\n{result.stderr}"
-            return output
-
-    except subprocess.TimeoutExpired:
-        return "[DAVELOOP:TIMEOUT] Claude Code iteration timed out after 10 minutes"
-    except FileNotFoundError:
-        return "[DAVELOOP:ERROR] Claude Code CLI not found. Is it installed?"
-    except Exception as e:
-        return f"[DAVELOOP:ERROR] {str(e)}"
-
-
-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}"
-    if "===========================" in line:
-        return f"{C.BRIGHT_BLUE}{'─'*50}{C.RESET}\n"
-
-    # Reasoning labels
-    if line.startswith("KNOWN:"):
-        return f"  {C.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}"
-    if line.startswith("HYPOTHESIS:"):
-        return f"  {C.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}"
-    if line.startswith("WHY:"):
-        return f"  {C.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
-    if "[DAVELOOP:RESOLVED]" in line:
-        return f"  {C.DIM}→ [Exit signal detected: RESOLVED]{C.RESET}"
-    if "[DAVELOOP:BLOCKED]" in line:
-        return f"  {C.DIM}→ [Exit signal detected: BLOCKED]{C.RESET}"
-    if "[DAVELOOP:CLARIFY]" in line:
-        return f"  {C.DIM}→ [Exit signal detected: CLARIFY]{C.RESET}"
-
-    # Code blocks
-    if line.strip().startswith("```"):
-        return f"{C.BLUE}{'─'*40}{C.RESET}"
-
-    # Default - white text
-    return f"  {C.WHITE}{line}{C.RESET}"
-
-
-def check_exit_condition(output: str) -> tuple[str, bool]:
-    """Check if we should exit the loop."""
-    if SIGNAL_RESOLVED in output:
-        return "RESOLVED", True
-    if SIGNAL_BLOCKED in output:
-        return "BLOCKED", True
-    if SIGNAL_CLARIFY in output:
-        return "CLARIFY", True
-    if "[DAVELOOP:ERROR]" in output:
-        return "ERROR", True
-    if "[DAVELOOP:TIMEOUT]" in output:
-        return "TIMEOUT", False
-    return "CONTINUE", False
-
-
-def save_log(iteration: int, content: str, session_id: str):
-    """Save iteration log to file."""
-    LOG_DIR.mkdir(exist_ok=True)
-    log_file = LOG_DIR / f"{session_id}_iteration_{iteration:02d}.log"
-    log_file.write_text(content, encoding="utf-8")
-
-
-# ============================================================================
-# Main Entry Point
-# ============================================================================
-def main():
-    parser = argparse.ArgumentParser(
-        description="DaveLoop - Self-Healing Debug Agent",
-        formatter_class=argparse.RawDescriptionHelpFormatter
-    )
-    parser.add_argument("bug", nargs="?", help="Bug description or error message")
-    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)
-    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
-
-    args = parser.parse_args()
-
-    # Clear screen and show banner
-    os.system('cls' if os.name == 'nt' else 'clear')
-    print(BANNER)
-
-    # Get bug description
-    if args.file:
-        bug_input = Path(args.file).read_text(encoding="utf-8")
-    elif args.bug:
-        bug_input = 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()
-
-    if not bug_input:
-        print_error_box("No bug description provided")
-        return 1
-
-    # Setup
-    session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
-    system_prompt = load_prompt()
-    working_dir = args.dir or os.getcwd()
-
-    # 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("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()
-
-    # Initial context
-    context = f"""
-## Bug Report
-
-{bug_input}
-
-## Instructions
-
-Analyze this bug. Gather whatever logs/information you need to understand it.
-Then fix it. Use the reasoning protocol before each action.
-"""
-
-    iteration_history = []
-
-    for iteration in range(1, args.max_iterations + 1):
-        print_iteration_header(iteration, args.max_iterations)
-
-        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}")
-
-        # Show "Claude is working" indicator
-        print(f"\n  {C.BRIGHT_BLUE}▶ Claude is working...{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)
-
-        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"""
-## 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"""
-## 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
-    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)
-    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")
-
-    return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
+#!/usr/bin/env python3
+"""
+DaveLoop - Self-Healing Debug Agent
+Orchestrates Claude Code CLI in a feedback loop until bugs are resolved.
+"""
+
+import subprocess
+import sys
+import os
+import argparse
+import threading
+import time
+import itertools
+from datetime import datetime
+from pathlib import Path
+
+# Configuration
+MAX_ITERATIONS = 20
+DEFAULT_TIMEOUT = 600  # 10 minutes in seconds
+SCRIPT_DIR = Path(__file__).parent
+PROMPT_FILE = SCRIPT_DIR / "daveloop_prompt.md"
+LOG_DIR = SCRIPT_DIR / "logs"
+
+# Exit signals from Claude Code
+SIGNAL_RESOLVED = "[DAVELOOP:RESOLVED]"
+SIGNAL_BLOCKED = "[DAVELOOP:BLOCKED]"
+SIGNAL_CLARIFY = "[DAVELOOP:CLARIFY]"
+
+# ============================================================================
+# ANSI Color Codes
+# ============================================================================
+class Colors:
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+
+    # Foreground
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+
+    # Bright foreground
+    BRIGHT_RED = "\033[91m"
+    BRIGHT_GREEN = "\033[92m"
+    BRIGHT_YELLOW = "\033[93m"
+    BRIGHT_BLUE = "\033[94m"
+    BRIGHT_MAGENTA = "\033[95m"
+    BRIGHT_CYAN = "\033[96m"
+    BRIGHT_WHITE = "\033[97m"
+
+    # Background
+    BG_BLACK = "\033[40m"
+    BG_RED = "\033[41m"
+    BG_GREEN = "\033[42m"
+    BG_BLUE = "\033[44m"
+    BG_MAGENTA = "\033[45m"
+    BG_CYAN = "\033[46m"
+
+C = Colors  # Shorthand
+
+# Enable ANSI and UTF-8 on Windows
+if sys.platform == "win32":
+    os.system("chcp 65001 >nul 2>&1")  # Set console to UTF-8
+    os.system("")  # Enables ANSI escape sequences in Windows terminal
+    # Force UTF-8 encoding for stdout/stderr (only if not already wrapped)
+    import io
+    if not isinstance(sys.stdout, io.TextIOWrapper) or sys.stdout.encoding != 'utf-8':
+        if hasattr(sys.stdout, 'buffer'):
+            sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
+    if not isinstance(sys.stderr, io.TextIOWrapper) or sys.stderr.encoding != 'utf-8':
+        if hasattr(sys.stderr, 'buffer'):
+            sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
+
+# ============================================================================
+# ASCII Art Banner
+# ============================================================================
+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"{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}{'─' * 70}{C.RESET}")
+
+def print_status(label: str, value: str, color: str = C.WHITE):
+    """Print a status line."""
+    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 = 25
+    filled = int(bar_width * progress)
+    empty = bar_width - filled
+    bar = '█' * filled + '░' * empty
+
+    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 = ""):
+    """Print an epic success message."""
+    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"""
+{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"""
+{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
+# ============================================================================
+class Spinner:
+    """Animated spinner for showing work in progress."""
+
+    def __init__(self, message: str = "Processing"):
+        self.message = message
+        self.running = False
+        self.thread = None
+        self.frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+        self.start_time = None
+
+    def spin(self):
+        idx = 0
+        while self.running:
+            elapsed = time.time() - self.start_time
+            frame = self.frames[idx % len(self.frames)]
+            sys.stdout.write(f"\r  {C.BRIGHT_CYAN}{frame}{C.RESET} {C.BOLD}{self.message}{C.RESET} {C.DIM}({elapsed:.0f}s){C.RESET}  ")
+            sys.stdout.flush()
+            idx += 1
+            time.sleep(0.1)
+
+    def start(self):
+        self.running = True
+        self.start_time = time.time()
+        self.thread = threading.Thread(target=self.spin)
+        self.thread.start()
+
+    def stop(self, final_message: str = None):
+        self.running = False
+        if self.thread:
+            self.thread.join()
+        elapsed = time.time() - self.start_time
+        if final_message:
+            sys.stdout.write(f"\r  {C.GREEN}✓{C.RESET} {final_message} {C.DIM}({elapsed:.1f}s){C.RESET}                    \n")
+        else:
+            sys.stdout.write(f"\r  {C.GREEN}✓{C.RESET} {self.message} complete {C.DIM}({elapsed:.1f}s){C.RESET}                    \n")
+        sys.stdout.flush()
+
+# ============================================================================
+# Output Formatter
+# ============================================================================
+def format_claude_output(output: str) -> str:
+    """Format Claude's output with colors and sections."""
+    lines = output.split('\n')
+    formatted = []
+    in_reasoning = False
+    in_code = False
+
+    for line in lines:
+        # Reasoning block
+        if "=== DAVELOOP REASONING ===" in line:
+            in_reasoning = True
+            formatted.append(f"\n{C.BRIGHT_YELLOW}┌{'─'*50}┐{C.RESET}")
+            formatted.append(f"{C.BRIGHT_YELLOW}│{C.BOLD} 🧠 REASONING{C.RESET}")
+            formatted.append(f"{C.BRIGHT_YELLOW}├{'─'*50}┤{C.RESET}")
+            continue
+        elif "===========================" in line and in_reasoning:
+            in_reasoning = False
+            formatted.append(f"{C.BRIGHT_YELLOW}└{'─'*50}┘{C.RESET}\n")
+            continue
+
+        # Verification block
+        if "=== VERIFICATION ===" in line:
+            formatted.append(f"\n{C.BRIGHT_GREEN}┌{'─'*50}┐{C.RESET}")
+            formatted.append(f"{C.BRIGHT_GREEN}│{C.BOLD} ✓ VERIFICATION{C.RESET}")
+            formatted.append(f"{C.BRIGHT_GREEN}├{'─'*50}┤{C.RESET}")
+            continue
+        elif "====================" in line:
+            formatted.append(f"{C.BRIGHT_GREEN}└{'─'*50}┘{C.RESET}\n")
+            continue
+
+        # Code blocks
+        if line.strip().startswith("```"):
+            in_code = not in_code
+            if in_code:
+                formatted.append(f"{C.DIM}┌─ code ────────────────────────────────{C.RESET}")
+            else:
+                formatted.append(f"{C.DIM}└───────────────────────────────────────{C.RESET}")
+            continue
+
+        # Reasoning labels
+        if in_reasoning:
+            if line.startswith("KNOWN:"):
+                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.CYAN}KNOWN:{C.RESET}{line[6:]}")
+            elif line.startswith("UNKNOWN:"):
+                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.MAGENTA}UNKNOWN:{C.RESET}{line[8:]}")
+            elif line.startswith("HYPOTHESIS:"):
+                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.YELLOW}HYPOTHESIS:{C.RESET}{line[11:]}")
+            elif line.startswith("NEXT ACTION:"):
+                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.GREEN}NEXT ACTION:{C.RESET}{line[12:]}")
+            elif line.startswith("WHY:"):
+                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {C.BLUE}WHY:{C.RESET}{line[4:]}")
+            else:
+                formatted.append(f"{C.BRIGHT_YELLOW}│{C.RESET} {line}")
+            continue
+
+        # Exit signals - dim them out, don't make prominent
+        if "[DAVELOOP:RESOLVED]" in line:
+            formatted.append(f"  {C.DIM}→ [Exit signal: RESOLVED]{C.RESET}")
+            continue
+        elif "[DAVELOOP:BLOCKED]" in line:
+            formatted.append(f"  {C.DIM}→ [Exit signal: BLOCKED]{C.RESET}")
+            continue
+        elif "[DAVELOOP:CLARIFY]" in line:
+            formatted.append(f"  {C.DIM}→ [Exit signal: CLARIFY]{C.RESET}")
+            continue
+
+        # Code content
+        if in_code:
+            formatted.append(f"{C.DIM}│{C.RESET} {C.WHITE}{line}{C.RESET}")
+            continue
+
+        # Regular content
+        formatted.append(f"  {line}")
+
+    return '\n'.join(formatted)
+
+# ============================================================================
+# Core Functions
+# ============================================================================
+def load_prompt() -> str:
+    """Load the DaveLoop system prompt."""
+    if PROMPT_FILE.exists():
+        return PROMPT_FILE.read_text(encoding="utf-8")
+    else:
+        print_warning_box(f"Prompt file not found: {PROMPT_FILE}")
+        return "You are debugging. Fix the bug. Output [DAVELOOP:RESOLVED] when done."
+
+
+def find_claude_cli():
+    """Find Claude CLI executable path."""
+    import platform
+    import shutil
+
+    # 1. Check environment variable (highest priority)
+    env_path = os.environ.get('CLAUDE_CLI_PATH')
+    if env_path and os.path.exists(env_path):
+        return env_path
+
+    # 2. Try common installation paths
+    is_windows = platform.system() == "Windows"
+    if is_windows:
+        common_paths = [
+            os.path.expanduser("~\\AppData\\Local\\Programs\\claude\\claude.cmd"),
+            os.path.expanduser("~\\AppData\\Roaming\\npm\\claude.cmd"),
+            "C:\\Program Files\\Claude\\claude.cmd",
+            "C:\\Program Files (x86)\\Claude\\claude.cmd",
+        ]
+        for path in common_paths:
+            if os.path.exists(path):
+                return path
+    else:
+        common_paths = [
+            "/usr/local/bin/claude",
+            "/usr/bin/claude",
+            os.path.expanduser("~/.local/bin/claude"),
+        ]
+        for path in common_paths:
+            if os.path.exists(path):
+                return path
+
+    # 3. Check if it's in PATH
+    claude_name = "claude.cmd" if is_windows else "claude"
+    if shutil.which(claude_name):
+        return claude_name
+
+    # 4. Not found
+    return None
+
+
+def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool = False, stream: bool = True, timeout: int = DEFAULT_TIMEOUT) -> 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).
+    """
+    claude_cmd = find_claude_cli()
+    if not claude_cmd:
+        error_msg = (
+            "Claude CLI not found!\n\n"
+            "Please install Claude Code CLI or set CLAUDE_CLI_PATH environment variable:\n"
+            "  Windows: set CLAUDE_CLI_PATH=C:\\path\\to\\claude.cmd\n"
+            "  Linux/Mac: export CLAUDE_CLI_PATH=/path/to/claude\n\n"
+            "Install from: https://github.com/anthropics/claude-code"
+        )
+        print_error_box(error_msg)
+        return "[DAVELOOP:ERROR] Claude CLI not found"
+
+    cmd = [claude_cmd]
+
+    if continue_session:
+        cmd.append("--continue")
+
+    cmd.extend(["-p", "--verbose", "--output-format", "stream-json", "--allowedTools", "Bash,Read,Write,Edit,Glob,Grep,Task"])
+
+    try:
+        if stream:
+            # Stream output in real-time
+            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  # Line buffered
+            )
+
+            # Send prompt and close stdin
+            process.stdin.write(prompt)
+            process.stdin.close()
+
+            # Track start time
+            start_time = time.time()
+
+            # Read and display JSON stream output
+            import json
+            output_lines = []
+            full_text = []
+
+            for line in process.stdout:
+
+                line = line.strip()
+                if not line:
+                    continue
+
+                try:
+                    data = json.loads(line)
+                    msg_type = data.get("type", "")
+
+
+                    # Handle different message types
+                    if msg_type == "assistant":
+                        # Assistant text message
+                        content = data.get("message", {}).get("content", [])
+                        for block in content:
+                            if block.get("type") == "text":
+                                text = block.get("text", "")
+                                for line_text in text.split('\n'):
+                                    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
+                        delta = data.get("delta", {})
+                        if delta.get("type") == "text_delta":
+                            text = delta.get("text", "")
+                            print(text, end='')
+                            full_text.append(text)
+
+                    elif msg_type == "tool_use":
+                        # Tool being used - show what Claude is doing
+                        tool_name = data.get("name", "unknown")
+                        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 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
+                        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":
+                        error_msg = data.get("error", {}).get("message", "Unknown error")
+                        print(f"  {C.RED}ERROR: {error_msg}{C.RESET}")
+
+                    sys.stdout.flush()
+
+                except json.JSONDecodeError:
+                    # Not JSON, just print as-is
+                    print(f"  {line}")
+                    full_text.append(line)
+
+                output_lines.append(line)
+
+            process.wait(timeout=timeout)
+            return '\n'.join(full_text)
+        else:
+            # Non-streaming mode
+            result = subprocess.run(
+                cmd,
+                input=prompt,
+                capture_output=True,
+                text=True,
+                encoding='utf-8',
+                errors='replace',
+                cwd=working_dir,
+                timeout=timeout
+            )
+            output = result.stdout
+            if result.stderr:
+                output += f"\n{C.RED}[STDERR]{C.RESET}\n{result.stderr}"
+            return output
+
+    except subprocess.TimeoutExpired:
+        return f"[DAVELOOP:TIMEOUT] Claude Code iteration timed out after {timeout // 60} minutes"
+    except FileNotFoundError:
+        return "[DAVELOOP:ERROR] Claude Code CLI not found. Is it installed?"
+    except Exception as e:
+        return f"[DAVELOOP:ERROR] {str(e)}"
+
+
+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"""
+{C.BRIGHT_BLUE}  ┌─ 🧠 REASONING ─────────────────────────────────────────────────────┐{C.RESET}"""
+    if "===========================" in line:
+        return f"{C.BRIGHT_BLUE}  └─────────────────────────────────────────────────────────────────────┘{C.RESET}"
+
+    # Reasoning labels
+    if line.startswith("KNOWN:"):
+        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.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}UNKNOWN:{C.RESET} {C.WHITE}{line[8:]}{C.RESET}"
+    if line.startswith("HYPOTHESIS:"):
+        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.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}NEXT:{C.RESET} {C.WHITE}{line[12:]}{C.RESET}"
+    if line.startswith("WHY:"):
+        return f"  {C.BRIGHT_BLUE}│{C.RESET} {C.BRIGHT_BLUE}WHY:{C.RESET} {C.WHITE}{line[4:]}{C.RESET}"
+
+    # Exit signals - hide them, the success/error box will show
+    if "[DAVELOOP:RESOLVED]" in line:
+        return ""
+    if "[DAVELOOP:BLOCKED]" in line:
+        return ""
+    if "[DAVELOOP:CLARIFY]" in line:
+        return ""
+
+    # Code blocks - hide the markers
+    if line.strip().startswith("```"):
+        return ""
+
+    # Empty lines - minimal spacing
+    if not line.strip():
+        return ""
+
+    # Default - white text with subtle indent
+    return f"  {C.WHITE}{line}{C.RESET}"
+
+
+def check_exit_condition(output: str) -> tuple[str, bool]:
+    """Check if we should exit the loop."""
+    if SIGNAL_RESOLVED in output:
+        return "RESOLVED", True
+    if SIGNAL_BLOCKED in output:
+        return "BLOCKED", True
+    if SIGNAL_CLARIFY in output:
+        return "CLARIFY", True
+    if "[DAVELOOP:ERROR]" in output:
+        return "ERROR", True
+    if "[DAVELOOP:TIMEOUT]" in output:
+        return "TIMEOUT", False
+    return "CONTINUE", False
+
+
+def save_log(iteration: int, content: str, session_id: str):
+    """Save iteration log to file."""
+    LOG_DIR.mkdir(exist_ok=True)
+    log_file = LOG_DIR / f"{session_id}_iteration_{iteration:02d}.log"
+    log_file.write_text(content, encoding="utf-8")
+
+
+# ============================================================================
+# Main Entry Point
+# ============================================================================
+def main():
+    parser = argparse.ArgumentParser(
+        description="DaveLoop - Self-Healing Debug Agent",
+        formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("bug", nargs="?", help="Bug description or error message")
+    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)
+    parser.add_argument("-t", "--timeout", type=int, default=DEFAULT_TIMEOUT,
+                        help="Timeout per iteration in seconds (default: 600)")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
+
+    args = parser.parse_args()
+
+    # Clear screen and show banner
+    os.system('cls' if os.name == 'nt' else 'clear')
+    print(BANNER)
+
+    # Get bug description
+    if args.file:
+        bug_input = Path(args.file).read_text(encoding="utf-8")
+    elif args.bug:
+        bug_input = 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()
+
+    if not bug_input:
+        print_error_box("No bug description provided")
+        return 1
+
+    # Setup
+    session_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+    system_prompt = load_prompt()
+    working_dir = args.dir or os.getcwd()
+
+    # Session info
+    print_header_box(f"SESSION: {session_id}", C.BRIGHT_BLUE)
+    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("Mode", "Autonomous", C.WHITE)
+    print(f"{C.BRIGHT_BLUE}└{'─' * 70}┘{C.RESET}")
+
+    print_section("BUG REPORT", C.BRIGHT_RED)
+    # Wrap bug input nicely
+    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"""
+## Bug Report
+
+{bug_input}
+
+## Instructions
+
+Analyze this bug. Gather whatever logs/information you need to understand it.
+Then fix it. Use the reasoning protocol before each action.
+"""
+
+    iteration_history = []
+
+    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 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}◆ 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)
+
+        print(f"\n{C.BRIGHT_BLUE}  {'─' * 70}{C.RESET}")
+
+        # 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("")
+                print(f"  {C.DIM}Session: {session_id}{C.RESET}")
+                print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")
+                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"""
+## 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"""
+## 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
+    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)
+    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")
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())