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

daveloop-1.5.0.dist-info/METADATA

@@ -0,0 +1,392 @@
+Metadata-Version: 2.1
+Name: daveloop
+Version: 1.5.0
+Summary: Self-healing debug agent powered by Claude Code CLI
+Home-page: https://github.com/davebruzil/DaveLoop
+Author: Dave Bruzil
+Keywords: debugging ai claude automation agent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# DaveLoop
+
+<img width="842" height="258" alt="DaveLoop Banner" src="https://github.com/user-attachments/assets/97212a83-6eb9-43ed-95c7-ec236718ee16" />
+
+### The agent that doesn't quit until the job is done.
+
+**DaveLoop** is a self-healing autonomous agent powered by LLM-driven iterative reasoning. It was designed for debugging. Then it started building features, writing test suites, fixing production workflows, and improving its own source code -- all without being asked.
+
+You give it a problem. It reasons, hypothesizes, executes, verifies, and loops until the problem is gone. No hand-holding. No copy-pasting context between retries. No pressing "approve" every 10 seconds. It just works.
+
+```bash
+pip install daveloop
+```
+
+---
+
+## What DaveLoop Has Actually Done
+
+This isn't a toy demo. These are real, logged, verifiable results from DaveLoop running autonomously.
+
+### It Upgraded Itself
+
+DaveLoop was given a feature request file and told to add capabilities to its own codebase. It read its own source code, understood the architecture, and implemented 4 major features:
+
+- **TaskQueue** -- multi-bug sequential processing with status tracking
+- **Session Memory** -- persistent history across runs via `.daveloop_history.json`
+- **InputMonitor** -- real-time interrupt system (type `wait` mid-execution to redirect it)
+- **Multi-task CLI** -- queue multiple bugs in one command
+
+It verified the syntax, tested the integration, and resolved. One session. Its own codebase. No guidance.
+
+### It Built a Complete Mobile Test Suite From Scratch
+
+Pointed at an Android Dog Dating app on an emulator, DaveLoop:
+
+1. Located and installed the APK autonomously
+2. Dumped the UI hierarchy with `uiautomator` to understand the screen layout
+3. Read the Kotlin source files to understand data models and navigation
+4. Discovered the Room DB seeds 10 mock dog profiles on fresh install
+5. **Wrote 3 comprehensive Maestro YAML test flows:**
+   - Swipe card functionality (left/right swipe with profile progression)
+   - Matches vs Chat screen separation (distinct bottom nav destinations)
+   - Chat recipient verification (message send and display)
+6. Ran all tests 3 consecutive times -- all passed
+
+**One iteration. Zero human input. From APK to passing test suite.**
+
+### It Debugged a Production n8n Workflow
+
+A WhatsApp webhook integration was returning 500 errors on every request. Hebrew and English messages both failing. DaveLoop:
+
+- Traced the data flow through the entire n8n workflow JSON
+- Found Bug #1: incorrect nested path `webhookData.data.messages` instead of `webhookData.data.messages.message`
+- Found Bug #2: the `If2` node was reading from MongoDB output (`$json.body`) instead of referencing the webhook node directly
+- Fixed both, preserving the Hebrew goodbye detection logic that was actually correct
+- Generated a test script and deployment guide
+
+Two bugs, both data structure traversal errors buried in a multi-node workflow. Found and fixed.
+
+### It Solved a Django ORM Bug in One Iteration
+
+Running against [SWE-bench](https://www.swebench.com/), DaveLoop resolved `django__django-13321` -- a real bug from the Django issue tracker -- in a single iteration. 5 minutes from start to `[DAVELOOP:RESOLVED]`.
+
+```json
+{
+  "instance_id": "django__django-13321",
+  "repo": "django/django",
+  "resolved": true,
+  "iterations": 1
+}
+```
+
+### It Fixed a Bug in tqdm (47k+ GitHub Stars)
+
+A `ZeroDivisionError` when `total=0`. DaveLoop explored the entire tqdm codebase, traced all division operations across multiple files, identified that `if total:` was treating `0` the same as `None`, and applied a targeted fix. One iteration.
+
+---
+
+## How It Works
+
+```
+You describe the bug
+       |
+       v
+  DaveLoop injects a reasoning protocol into the LLM
+       |
+       v
+  The agent analyzes: KNOWN / UNKNOWN / HYPOTHESIS / NEXT ACTION
+       |
+       v
+  Executes the fix, runs verification
+       |
+       v
+  Not fixed? Loop again with full context (--continue)
+       |
+       v
+  Fixed? --> [DAVELOOP:RESOLVED]
+  Stuck? --> [DAVELOOP:BLOCKED] (documents what it tried)
+```
+
+The key insight: even the best coding agents sometimes need multiple attempts for complex bugs. DaveLoop automates that retry loop with persistent context and structured reasoning, so each iteration builds on everything the agent already learned.
+
+---
+
+## The 4-Level Reasoning Protocol
+
+![Reasoning Example](https://github.com/user-attachments/assets/a1bbd83a-27f2-4543-9d48-ef089b3cbd75)
+
+Every iteration, DaveLoop forces the agent to state:
+
+| Level | Purpose |
+|-------|---------|
+| **KNOWN** | What facts have been established so far |
+| **UNKNOWN** | What gaps remain |
+| **HYPOTHESIS** | A testable guess about the root cause |
+| **NEXT ACTION** | The concrete step to test that hypothesis |
+
+This prevents random shotgun debugging. Each iteration's KNOWN section grows. The UNKNOWN list shrinks or shifts focus. You can watch the agent systematically close in on the bug in real time.
+
+---
+
+## Install
+
+```bash
+pip install daveloop
+```
+
+Zero external dependencies. Python 3.7+ and an LLM CLI agent.
+
+---
+
+## Use It Straight From Chat
+
+After installing, paste the following block into your global agent instructions file (the markdown file your coding agent reads for project instructions). This lets you trigger DaveLoop by just talking naturally in chat -- no terminal switching needed.
+
+<details>
+<summary><b>Click to expand -- copy this into your global agent instructions file</b></summary>
+
+```markdown
+## DaveLoop - Self-Healing Debug Agent
+
+DaveLoop is a Python wrapper that runs the coding agent in a loop until bugs are resolved. It keeps iterating until the issue is fixed.
+
+### Basic Commands
+
+\`\`\`bash
+# Basic usage - describe the bug directly
+daveloop "your bug description here"
+
+# Specify working directory
+daveloop -d /path/to/project "bug description"
+
+# Set max iterations (default is unlimited until resolved)
+daveloop -m 10 "bug description"
+
+# Read bug description from a file
+daveloop -f error.txt
+
+# Verbose output for debugging
+daveloop -v "bug description"
+\`\`\`
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `-h, --help` | Show help message |
+| `-f, --file FILE` | Read bug description from file |
+| `-d, --dir DIR` | Working directory |
+| `-m, --max-iterations N` | Maximum iterations before stopping |
+| `-v, --verbose` | Enable verbose output |
+
+### How It Works
+
+1. DaveLoop sends your bug description to the coding agent
+2. The agent analyzes, hypothesizes, and attempts fixes
+3. Runs verification (build/tests)
+4. If not resolved, DaveLoop loops back with updated context
+5. Continues until `[DAVELOOP:RESOLVED]` or max iterations reached
+
+### Giving DaveLoop a Command via Chat
+
+When the user says "daveloop this" or "run daveloop" with a task, run:
+
+\`\`\`bash
+daveloop "the bug description here"
+
+# Or with a specific project directory:
+daveloop -d /path/to/project "the bug description"
+\`\`\`
+```
+
+</details>
+
+Once that's in your agent instructions file, just say:
+
+```
+daveloop this: "mongodb connection error in the lookup node"
+```
+
+or
+
+```
+run daveloop on the jwt validation bug
+```
+
+The agent picks it up and runs DaveLoop automatically. No special syntax.
+
+---
+
+## Usage
+
+### Give it a bug
+
+```bash
+daveloop "routes/order.ts has a race condition on wallet balance. two concurrent orders overdraw the account"
+```
+
+### Give it a file
+
+```bash
+daveloop --file bug-report.txt
+```
+
+### Queue multiple bugs
+
+```bash
+daveloop "fix the login crash" "fix payment validation" "add dark mode toggle"
+```
+
+### Point it at a project
+
+```bash
+daveloop --dir /path/to/project "the bug description"
+```
+
+### Limit iterations
+
+```bash
+daveloop --max-iterations 10 "fix the bug"
+```
+
+### Mobile testing mode (Maestro)
+
+```bash
+daveloop --maestro "write UI tests for the onboarding flow"
+```
+
+### Web testing mode (Playwright)
+
+```bash
+daveloop --web "test the checkout flow end to end"
+```
+
+---
+
+## Interactive Controls
+
+DaveLoop doesn't lock you out. While it's running, type:
+
+| Command | What happens |
+|---------|-------------|
+| `wait` / `pause` | Stops the current iteration. You type a correction. It resumes with your new context. |
+| `add` | Queue a new bug without stopping the current one |
+| `done` | Graceful exit, saves history |
+| `Ctrl+C` | Kill it |
+
+The `wait` command is the standout feature. When you see the agent going down the wrong path, type `wait`, tell it what you know, and it course-corrects with full context preserved.
+
+---
+
+## Three Modes
+
+### Standard Mode (default)
+Classic iterative debugging. Reads code, makes hypotheses, applies fixes, verifies.
+
+### Maestro Mode (`--maestro`)
+Autonomous mobile UI testing. Auto-detects devices/emulators, installs APKs, explores UI hierarchy, writes Maestro YAML test flows, and verifies with 3 consecutive passes.
+
+### Web Mode (`--web`)
+Playwright-based web testing. Detects your framework (React, Next.js, Vue, etc.), installs Playwright, starts dev servers, and tests with human-like interactions -- real mouse movements, drags, hovers, not just DOM manipulation.
+
+---
+
+## Session Memory
+
+DaveLoop remembers. It saves a history of past sessions in `.daveloop_history.json` and loads that context into future runs. If it fixed a similar bug before, it knows.
+
+---
+
+## SWE-bench Integration
+
+Test DaveLoop against real-world bugs from open source projects:
+
+```bash
+daveloop-swebench --file django_hash_task.json --max-iterations 15
+```
+
+Pre-configured tasks from Django, Pytest, SymPy, and Sklearn included.
+
+---
+
+## Battle-Tested On
+
+| Domain | What it solved |
+|--------|---------------|
+| **Security** | Juice-Shop race conditions, NoSQL injection, ReDoS, path traversal |
+| **Backend** | Django ORM bugs, session handling crashes |
+| **Workflow Automation** | n8n webhook failures, MongoDB connection errors, multi-node data flow bugs |
+| **Testing Frameworks** | Pytest AST rewriting issues, Material-UI flaky visual regression tests |
+| **Libraries** | tqdm ZeroDivisionError, SymPy C-code generation |
+| **Mobile** | Android Maestro test suite generation from scratch |
+| **Self** | Added features to its own codebase autonomously |
+
+---
+
+## Writing Good Bug Descriptions
+
+More context = fewer iterations.
+
+**Vague (works, but slow):**
+```bash
+daveloop "fix the bug"
+```
+
+**Specific (fast):**
+```bash
+daveloop "RACE CONDITION: routes/order.ts lines 139-148. Balance check at 141 before decrement at 142. Two concurrent $100 orders both pass and overdraw to -$100. Need atomic check+decrement."
+```
+
+Include: bug type, file location, reproduction steps, root cause if known, fix direction if you have one.
+
+---
+
+## Logs
+
+Every session is fully logged:
+
+```
+logs/
+  20260131_142120_iteration_01.log    <- what it tried
+  20260131_142120_iteration_02.log    <- what it tried next
+  20260131_142120_summary.md          <- overview
+```
+
+Every reasoning block, every file read, every edit, every command. Full audit trail.
+
+---
+
+## Why DaveLoop Exists
+
+Some bugs don't fall in one shot. Race conditions. Multi-file refactors. Subtle logic errors buried in nested data structures. Production workflows with 12 interconnected nodes.
+
+DaveLoop wraps your coding agent in a persistence layer -- structured reasoning, iterative context, session memory, and the stubbornness to keep going until the job is done or honestly admit it's stuck.
+
+It started as a debug loop. It turned out to be something more.
+
+---
+
+## License
+
+MIT
+
+---
+
+**Built by [Dave Bruzil](https://github.com/davebruzil)**
+
+```bash
+pip install daveloop
+```

daveloop-1.5.0.dist-info/RECORD

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

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

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

daveloop.py

@@ -29,6 +29,12 @@ SIGNAL_RESOLVED = "[DAVELOOP:RESOLVED]"
 SIGNAL_BLOCKED = "[DAVELOOP:BLOCKED]"
 SIGNAL_CLARIFY = "[DAVELOOP:CLARIFY]"
 
+# Allowed tools for Claude Code CLI
+# Default: no Task tool (prevents recursive sub-agent spawning)
+ALLOWED_TOOLS_DEFAULT = "Bash,Read,Write,Edit,Glob,Grep"
+# Swarm mode: Task tool enabled for controlled sub-agent spawning
+ALLOWED_TOOLS_SWARM = "Bash,Read,Write,Edit,Glob,Grep,Task"
+
 # ============================================================================
 # ANSI Color Codes
 # ============================================================================
@@ -268,6 +274,128 @@ class TaskQueue:
         print()
 
 
+# ============================================================================
+# Swarm Budget
+# ============================================================================
+class SwarmBudget:
+    """Tracks and enforces sub-agent spawn budget for swarm mode."""
+
+    def __init__(self, max_spawns: int = 5, max_depth: int = 1):
+        self.max_spawns = max_spawns
+        self.max_depth = max_depth
+        self.spawn_count = 0
+        self.active_agents = 0
+        self.completed_agents = 0
+
+    def can_spawn(self) -> bool:
+        """Check if spawning another sub-agent is within budget."""
+        return self.spawn_count < self.max_spawns
+
+    def record_spawn(self, description: str):
+        """Record a sub-agent spawn."""
+        self.spawn_count += 1
+        self.active_agents += 1
+        print(f"  {C.BRIGHT_CYAN}[Swarm]{C.RESET} Sub-agent {self.spawn_count}/{self.max_spawns}: {description}")
+
+    def record_completion(self):
+        """Record a sub-agent completion."""
+        self.active_agents -= 1
+        self.completed_agents += 1
+
+    def budget_exhausted_message(self) -> str:
+        """Return message when budget is exhausted."""
+        return (
+            f"Sub-agent budget exhausted ({self.spawn_count}/{self.max_spawns}). "
+            f"Complete remaining work directly without spawning more sub-agents."
+        )
+
+    def summary(self) -> dict:
+        """Return budget tracking summary."""
+        return {
+            "total_spawned": self.spawn_count,
+            "completed": self.completed_agents,
+            "budget": self.max_spawns,
+        }
+
+
+# ============================================================================
+# Token Tracker
+# ============================================================================
+class TokenTracker:
+    """Tracks token usage across API turns in a DaveLoop session."""
+
+    def __init__(self):
+        self.total_input = 0
+        self.total_output = 0
+        self.turn_count = 0
+        self.peak_input = 0
+        self.peak_output = 0
+        self.peak_total = 0
+        self.per_tool = {}  # tool_name -> {"input": int, "output": int, "count": int}
+        self._current_tool = None  # Track which tool is active for per-tool attribution
+        self._turn_input = 0  # Accumulate within a turn for per-tool attribution
+        self._turn_output = 0
+
+    def set_current_tool(self, tool_name: str):
+        """Set the currently active tool for per-tool token attribution."""
+        self._current_tool = tool_name
+
+    def record_usage(self, input_tokens: int, output_tokens: int):
+        """Record token usage from an API turn."""
+        self.total_input += input_tokens
+        self.total_output += output_tokens
+        self.turn_count += 1
+
+        turn_total = input_tokens + output_tokens
+        if turn_total > self.peak_total:
+            self.peak_total = turn_total
+            self.peak_input = input_tokens
+            self.peak_output = output_tokens
+
+        # Attribute to current tool if one is active
+        if self._current_tool:
+            if self._current_tool not in self.per_tool:
+                self.per_tool[self._current_tool] = {"input": 0, "output": 0, "count": 0}
+            self.per_tool[self._current_tool]["input"] += input_tokens
+            self.per_tool[self._current_tool]["output"] += output_tokens
+            self.per_tool[self._current_tool]["count"] += 1
+
+    @property
+    def total_tokens(self) -> int:
+        return self.total_input + self.total_output
+
+    def summary(self) -> dict:
+        """Return a dict with all token stats."""
+        return {
+            "input_tokens": self.total_input,
+            "output_tokens": self.total_output,
+            "total_tokens": self.total_tokens,
+            "turn_count": self.turn_count,
+            "peak_turn": {
+                "input": self.peak_input,
+                "output": self.peak_output,
+                "total": self.peak_total,
+            },
+            "per_tool": dict(self.per_tool),
+        }
+
+    def summary_line(self) -> str:
+        """Return a one-line summary string for display."""
+        return (
+            f"Tokens: {self.total_input:,} in / {self.total_output:,} out / "
+            f"{self.total_tokens:,} total ({self.turn_count} turns)"
+        )
+
+    def verbose_turn_line(self, input_tokens: int, output_tokens: int) -> str:
+        """Return a per-turn detail line for --show-tokens mode."""
+        total = input_tokens + output_tokens
+        tool_info = f" [{self._current_tool}]" if self._current_tool else ""
+        return (
+            f"  Turn {self.turn_count}: {input_tokens:,} in / {output_tokens:,} out / "
+            f"{total:,} total{tool_info}"
+        )
+
+
 # ============================================================================
 # Session Memory
 # ============================================================================
@@ -294,16 +422,21 @@ def save_history(working_dir: str, history_data: dict):
     history_file.write_text(json.dumps(history_data, indent=2), encoding="utf-8")
 
 
-def summarize_session(bug: str, outcome: str, iterations: int) -> dict:
+def summarize_session(bug: str, outcome: str, iterations: int, token_tracker: "TokenTracker" = None) -> dict:
     """Return a dict summarizing a session."""
     now = datetime.now()
-    return {
+    entry = {
         "session_id": now.strftime("%Y%m%d_%H%M%S"),
         "bug": bug,
         "outcome": outcome,
         "iterations": iterations,
         "timestamp": now.isoformat()
     }
+    if token_tracker and token_tracker.turn_count > 0:
+        entry["tokens_in"] = token_tracker.total_input
+        entry["tokens_out"] = token_tracker.total_output
+        entry["tokens_total"] = token_tracker.total_tokens
+    return entry
 
 
 def format_history_context(sessions: list) -> str:
@@ -329,10 +462,12 @@ def print_history_box(sessions: list):
         outcome = s.get("outcome", "UNKNOWN")
         bug = s.get("bug", "unknown")[:55]
         iters = s.get("iterations", "?")
+        tokens_total = s.get("tokens_total")
+        token_str = f" · {tokens_total:,} tok" if tokens_total else ""
         if outcome == "RESOLVED":
-            print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+            print(f"  {C.BRIGHT_GREEN}✓{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter{token_str}){C.RESET}")
         else:
-            print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter){C.RESET}")
+            print(f"  {C.BRIGHT_RED}✗{C.RESET} {C.WHITE}{bug}{C.RESET} {C.DIM}({iters} iter{token_str}){C.RESET}")
     print()
 
 
@@ -426,7 +561,7 @@ class InputMonitor:
     Call resume_reading() after the main thread is done with input().
     """
 
-    VALID_COMMANDS = ("wait", "pause", "add", "done")
+    VALID_COMMANDS = ("wait", "pause", "add", "done", "stop")
 
     def __init__(self):
         self._command = None
@@ -554,12 +689,17 @@ 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, input_monitor=None) -> 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, swarm_mode: bool = False, swarm_budget_max: int = 5, swarm_depth_max: int = 1, token_tracker: "TokenTracker" = None, show_tokens: bool = False) -> 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.
+    swarm_mode: if True, enables Task tool for sub-agent spawning.
+    swarm_budget_max: max sub-agents per session in swarm mode.
+    swarm_depth_max: max sub-agent depth in swarm mode.
+    token_tracker: optional TokenTracker to accumulate token usage from the stream.
+    show_tokens: if True, print per-turn token usage during execution.
     """
     claude_cmd = find_claude_cli()
     if not claude_cmd:
@@ -578,7 +718,8 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
     if continue_session:
         cmd.append("--continue")
 
-    cmd.extend(["-p", "--verbose", "--output-format", "stream-json", "--allowedTools", "Bash,Read,Write,Edit,Glob,Grep,Task"])
+    allowed = ALLOWED_TOOLS_SWARM if swarm_mode else ALLOWED_TOOLS_DEFAULT
+    cmd.extend(["-p", "--verbose", "--output-format", "stream-json", "--allowedTools", allowed])
 
     try:
         if stream:
@@ -602,6 +743,9 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
             # Track start time
             start_time = time.time()
 
+            # Swarm budget tracking (only active in swarm mode)
+            swarm_budget = SwarmBudget(max_spawns=swarm_budget_max, max_depth=swarm_depth_max) if swarm_mode else None
+
             # Read and display JSON stream output
             output_lines = []
             full_text = []
@@ -617,6 +761,19 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                     msg_type = data.get("type", "")
 
 
+                    # Extract token usage from any message that has it
+                    if token_tracker:
+                        usage = (data.get("message", {}).get("usage")
+                                 or data.get("usage")
+                                 or None)
+                        if usage and isinstance(usage, dict):
+                            inp = usage.get("input_tokens", 0)
+                            outp = usage.get("output_tokens", 0)
+                            if inp or outp:
+                                token_tracker.record_usage(inp, outp)
+                                if show_tokens:
+                                    print(f"  {C.DIM}{token_tracker.verbose_turn_line(inp, outp)}{C.RESET}")
+
                     # Handle different message types
                     if msg_type == "assistant":
                         # Assistant text message
@@ -631,6 +788,8 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                             elif block.get("type") == "tool_use":
                                 # Tool being called - show what Claude is doing
                                 tool_name = block.get("name", "unknown")
+                                if token_tracker:
+                                    token_tracker.set_current_tool(tool_name)
                                 tool_input = block.get("input", {})
 
                                 # Format tool call based on type
@@ -660,6 +819,18 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                                 elif tool_name == "Task":
                                     desc = tool_input.get("description", "")
                                     tool_display = f"{C.BRIGHT_BLUE}Task{C.RESET}({C.WHITE}{desc}{C.RESET})"
+                                    # Swarm budget enforcement
+                                    if swarm_budget:
+                                        if not swarm_budget.can_spawn():
+                                            print(f"  {C.BRIGHT_YELLOW}[Swarm] Budget exhausted. Terminating to restart without Task tool.{C.RESET}")
+                                            process.terminate()
+                                            try:
+                                                process.wait(timeout=10)
+                                            except Exception:
+                                                process.kill()
+                                            return '\n'.join(full_text) + "\n[DAVELOOP:SWARM_BUDGET_EXHAUSTED]"
+                                        else:
+                                            swarm_budget.record_spawn(desc)
                                 else:
                                     tool_display = f"{C.BRIGHT_BLUE}{tool_name}{C.RESET}"
 
@@ -677,6 +848,8 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                     elif msg_type == "tool_use":
                         # Tool being used - show what Claude is doing
                         tool_name = data.get("name", "unknown")
+                        if token_tracker:
+                            token_tracker.set_current_tool(tool_name)
                         tool_input = data.get("input", {})
 
                         # Format tool call based on type
@@ -706,6 +879,18 @@ def run_claude_code(prompt: str, working_dir: str = None, continue_session: bool
                         elif tool_name == "Task":
                             desc = tool_input.get("description", "")
                             tool_display = f"{C.BRIGHT_BLUE}Task{C.RESET}({C.WHITE}{desc}{C.RESET})"
+                            # Swarm budget enforcement
+                            if swarm_budget:
+                                if not swarm_budget.can_spawn():
+                                    print(f"  {C.BRIGHT_YELLOW}[Swarm] Budget exhausted. Terminating to restart without Task tool.{C.RESET}")
+                                    process.terminate()
+                                    try:
+                                        process.wait(timeout=10)
+                                    except Exception:
+                                        process.kill()
+                                    return '\n'.join(full_text) + "\n[DAVELOOP:SWARM_BUDGET_EXHAUSTED]"
+                                else:
+                                    swarm_budget.record_spawn(desc)
                         else:
                             tool_display = f"{C.BRIGHT_BLUE}{tool_name}{C.RESET}"
 
@@ -859,6 +1044,14 @@ def main():
     parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
     parser.add_argument("--maestro", action="store_true", help="Enable Maestro mobile testing mode")
     parser.add_argument("--web", action="store_true", help="Enable Playwright web UI testing mode")
+    parser.add_argument("--swarm", action="store_true",
+                        help="Enable swarm mode: DaveLoop can spawn sub-agents via Task tool")
+    parser.add_argument("--swarm-budget", type=int, default=5,
+                        help="Max sub-agents per DaveLoop worker in swarm mode (default: 5)")
+    parser.add_argument("--swarm-depth", type=int, default=1, choices=[1, 2],
+                        help="Max sub-agent depth in swarm mode (default: 1, no recursive spawning)")
+    parser.add_argument("--show-tokens", action="store_true",
+                        help="Show verbose per-turn token usage during execution")
 
     args = parser.parse_args()
 
@@ -908,6 +1101,11 @@ def main():
     print_status("Tasks", str(len(bug_descriptions)), C.WHITE)
     mode_name = "Maestro Mobile Testing" if args.maestro else "Playwright Web Testing" if args.web else "Autonomous"
     print_status("Mode", mode_name, C.WHITE)
+    if args.swarm:
+        print_status("Swarm", f"ENABLED (budget: {args.swarm_budget}, depth: {args.swarm_depth})", C.BRIGHT_CYAN)
+        print_status("Tools", ALLOWED_TOOLS_SWARM, C.WHITE)
+    else:
+        print_status("Tools", ALLOWED_TOOLS_DEFAULT, C.WHITE)
     print(f"{C.BRIGHT_BLUE}└{'─' * 70}┘{C.RESET}")
 
     # Build task queue
@@ -917,7 +1115,7 @@ def main():
 
     # 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}│{C.RESET} Type while running:  {C.BRIGHT_WHITE}wait{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}pause{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}add{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}done{C.RESET} {C.DIM}·{C.RESET} {C.BRIGHT_WHITE}stop{C.RESET}                {C.BRIGHT_BLUE}│{C.RESET}")
     print(f"{C.BRIGHT_BLUE}└{'─' * 70}┘{C.RESET}")
 
     # Start input monitor
@@ -929,6 +1127,9 @@ def main():
     if history_data["sessions"]:
         history_context = "\n\n" + format_history_context(history_data["sessions"])
 
+    # Session-wide token tracking (aggregates across all tasks)
+    session_token_tracker = TokenTracker()
+
     # === OUTER LOOP: iterate over tasks ===
     while True:
         task = task_queue.next()
@@ -1004,6 +1205,7 @@ Then fix it. Use the reasoning protocol before each action.
 """
 
         iteration_history = []
+        task_token_tracker = TokenTracker()
 
         # === INNER LOOP: iterations for current task ===
         for iteration in range(1, args.max_iterations + 1):
@@ -1027,11 +1229,20 @@ Then fix it. Use the reasoning protocol before each action.
                 full_prompt, working_dir,
                 continue_session=continue_session,
                 stream=True, timeout=args.timeout,
-                input_monitor=input_monitor
+                input_monitor=input_monitor,
+                swarm_mode=args.swarm,
+                swarm_budget_max=args.swarm_budget,
+                swarm_depth_max=args.swarm_depth,
+                token_tracker=task_token_tracker,
+                show_tokens=args.show_tokens
             )
 
             print(f"\n{C.BRIGHT_BLUE}  {'─' * 70}{C.RESET}")
 
+            # Print token usage summary for this iteration
+            if task_token_tracker.turn_count > 0:
+                print(f"  {C.BRIGHT_CYAN}⊛ {task_token_tracker.summary_line()}{C.RESET}")
+
             # Save log
             save_log(iteration, output, session_id)
             iteration_history.append(output)
@@ -1085,22 +1296,34 @@ Continue the current debugging task. Use the reasoning protocol before each acti
                 elif user_cmd == "done":
                     # Clean exit
                     input_monitor.stop()
-                    session_entry = summarize_session(bug_input, "DONE_BY_USER", iteration)
+                    session_entry = summarize_session(bug_input, "DONE_BY_USER", iteration, task_token_tracker)
                     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
 
+                elif user_cmd == "stop":
+                    # Boris-commanded stop - terminate this iteration immediately
+                    print(f"\n  {C.BRIGHT_RED}{C.BOLD}  ■ STOPPED BY BORIS{C.RESET}")
+                    print(f"{C.BRIGHT_RED}  {'─' * 70}{C.RESET}")
+                    input_monitor.stop()
+                    session_entry = summarize_session(bug_input, "STOPPED_BY_BORIS", iteration, task_token_tracker)
+                    history_data["sessions"].append(session_entry)
+                    save_history(working_dir, history_data)
+                    return 1
+
             # Check exit condition
             signal, should_exit = check_exit_condition(output)
 
             if should_exit:
                 if signal == "RESOLVED":
                     print_success_box("")
+                    if task_token_tracker.turn_count > 0:
+                        print(f"  {C.BRIGHT_CYAN}⊛ {task_token_tracker.summary_line()}{C.RESET}")
                     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)
+                    session_entry = summarize_session(bug_input, "RESOLVED", iteration, task_token_tracker)
                     history_data["sessions"].append(session_entry)
                     save_history(working_dir, history_data)
                     break  # Move to next task
@@ -1126,14 +1349,14 @@ Continue debugging with this information. Use the reasoning protocol before each
                     print_status("Logs", str(LOG_DIR), C.WHITE)
                     print()
                     task_queue.mark_failed()
-                    session_entry = summarize_session(bug_input, "BLOCKED", iteration)
+                    session_entry = summarize_session(bug_input, "BLOCKED", iteration, task_token_tracker)
                     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)
+                    session_entry = summarize_session(bug_input, "ERROR", iteration, task_token_tracker)
                     history_data["sessions"].append(session_entry)
                     save_history(working_dir, history_data)
                     break  # Move to next task
@@ -1173,15 +1396,33 @@ Use the reasoning protocol before each action.
             # 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)
+            session_entry = summarize_session(bug_input, "MAX_ITERATIONS", args.max_iterations, task_token_tracker)
             history_data["sessions"].append(session_entry)
             save_history(working_dir, history_data)
 
+        # Aggregate task tokens into session-level tracker
+        if task_token_tracker.turn_count > 0:
+            session_token_tracker.total_input += task_token_tracker.total_input
+            session_token_tracker.total_output += task_token_tracker.total_output
+            session_token_tracker.turn_count += task_token_tracker.turn_count
+            if task_token_tracker.peak_total > session_token_tracker.peak_total:
+                session_token_tracker.peak_total = task_token_tracker.peak_total
+                session_token_tracker.peak_input = task_token_tracker.peak_input
+                session_token_tracker.peak_output = task_token_tracker.peak_output
+            for tool, stats in task_token_tracker.per_tool.items():
+                if tool not in session_token_tracker.per_tool:
+                    session_token_tracker.per_tool[tool] = {"input": 0, "output": 0, "count": 0}
+                session_token_tracker.per_tool[tool]["input"] += stats["input"]
+                session_token_tracker.per_tool[tool]["output"] += stats["output"]
+                session_token_tracker.per_tool[tool]["count"] += stats["count"]
+
         # 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"
+        if task_token_tracker.turn_count > 0:
+            summary += f"Token Usage: {task_token_tracker.summary_line()}\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"
@@ -1203,6 +1444,16 @@ Use the reasoning protocol before each action.
             print(f"  {C.DIM}○ {desc}{C.RESET}")
     print()
 
+    # Print session-wide token usage
+    if session_token_tracker.turn_count > 0:
+        print(f"  {C.BRIGHT_CYAN}⊛ {session_token_tracker.summary_line()}{C.RESET}")
+        if session_token_tracker.per_tool:
+            print(f"  {C.DIM}  Per tool:{C.RESET}")
+            for tool, stats in sorted(session_token_tracker.per_tool.items(), key=lambda x: x[1]["input"] + x[1]["output"], reverse=True):
+                tool_total = stats["input"] + stats["output"]
+                print(f"  {C.DIM}    {tool}: {stats['input']:,} in / {stats['output']:,} out / {tool_total:,} total ({stats['count']} calls){C.RESET}")
+        print()
+
     print(f"  {C.DIM}Session: {session_id}{C.RESET}")
     print(f"  {C.DIM}Logs: {LOG_DIR}{C.RESET}\n")
 

daveloop-1.4.0.dist-info/METADATA

@@ -1,391 +0,0 @@
-Metadata-Version: 2.4
-Name: daveloop
-Version: 1.4.0
-Summary: Self-healing debug agent powered by Claude Code CLI
-Home-page: https://github.com/davebruzil/DaveLoop
-Author: Dave Bruzil
-Keywords: debugging ai claude automation agent
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-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 Banner](https://github.com/user-attachments/assets/c0611446-41f2-4d10-ad0b-bcdde63bcfd3)
-
- **DaveLoop** is a Claude CLI based debug agent designed to solve bugs in cases where Claude Code fails to one-shot them.
- It feeds itself bugs iteratively until it resolves them or gets blocked. Each iteration builds on the previous one with
- full context thanks to the `--continue` flag.
-
- ---
-
- ## How It Works
-
- 1. You give it a bug description
- 2. It analyzes, makes a hypothesis, and tries a fix
- 3. If not fixed, it loops again with new context
- 4. Keeps going until it outputs `[DAVELOOP:RESOLVED]`
-
- ---
-
- ## Why Use It
-
- - Claude Code sometimes needs multiple attempts to fix complex bugs
- - Race conditions, subtle logic errors, multi-file refactors
- - You dont want to manually copy-paste context every iteration
- - Autonomous operation means you dont need to press enter for permissions all the time
-
- ---
-
- ## Key Features
-
- - **Persistent Context** - uses `claude --continue` so it remembers everything
- - **Exit Signals** - explicitly tells you when done or blocked
- - **Real-time Streaming** - watch it think and debug live
- - **Pragmatic Exits** - if environment is broken, it documents the fix and exits
- - **4-Level Reasoning** - KNOWN, UNKNOWN, HYPOTHESIS, and WHY
-
- ---
-
- ## The 4-Level Reasoning Protocol
-
- ![Reasoning Example](https://github.com/user-attachments/assets/a1bbd83a-27f2-4543-9d48-ef089b3cbd75)
-
- The reasoning protocol forces systematic debugging:
-
- 1. **Prevents random changes** - cant just try stuff without stating why
- 2. **Builds knowledge incrementally** - each iterations KNOWN grows
- 3. **Explicit about uncertainty** - UNKNOWN list gets smaller or changes focus
- 4. **Testable hypotheses** - you can verify if the guess matches symptoms
- 5. **Clear action items** - NEXT ACTION is concrete and measurable
-
- ---
- ## INSTALL
- ### Via pip  
-  ```bash                                                                                                   
-      pip install daveloop                                                                                                            
-  ```  
-
- ## How to Use
-
- ### Basic Usage
-
- ```bash
- python daveloop.py "your bug description here"
- ```
-
- **Example:**
- ```bash
- python daveloop.py "routes/order.ts has a race condition on wallet balance. two concurrent orders can overdraw the account"
- ```
-
- ---
-
- ### From a File
-
- If you have a detailed bug report:
-
- ```bash
- python daveloop.py --file bug-report.txt
- ```
-
- The file should contain the bug description. Can be as detailed as you want - stack traces, error logs, reproduction steps, whatever.    
-
- ---
-
- ### From Claude Code Chat
-
- Just talk naturally to Claude Code:
-
- ```
- "daveloop this: mongodb connection error in lookup artist node"
- ```
-
- Or:
-
- ```
- "run daveloop on the jwt validation bug"
- ```
-
- Claude Code will automatically run:
-
- ```bash
- python daveloop.py "mongodb connection error in lookup artist node"
- ```
-
- No special commands needed. Just mention "daveloop" and describe the bug.
-
- ---
-
- ### With Options
-
- ```bash
- # Custom working directory
- python daveloop.py "fix the bug" --dir /path/to/your/project
-
- # Limit iterations (default is 20)
- python daveloop.py "fix the bug" --max-iterations 10
-
- # All together
- python daveloop.py --file bug.txt --dir ./my-app --max-iterations 15
- ```
-
- ---
-
- ## If Claude CLI Not Found
-
- DaveLoop automatically searches for Claude CLI in common locations. But if you get:
-
- ```
- ERROR: Claude CLI not found!
-
- Please install Claude Code CLI or set CLAUDE_CLI_PATH environment variable:
-   Windows: set CLAUDE_CLI_PATH=C:\path\to\claude.cmd
-   Linux/Mac: export CLAUDE_CLI_PATH=/path/to/claude
-
- Install from: https://github.com/anthropics/claude-code
- ```
-
- ### Option 1: Set Environment Variable (Recommended)
-
- Find where Claude CLI is installed:
-
- **Windows:**
- ```cmd
- where claude.cmd
- ```
-
- **Linux/Mac:**
- ```bash
- which claude
- ```
-
- Then set the path:
-
- **Windows (temporary - current session):**
- ```cmd
- set CLAUDE_CLI_PATH=C:\Users\YourName\AppData\Roaming\npm\claude.cmd
- ```
-
- **Windows (permanent):**
- ```cmd
- setx CLAUDE_CLI_PATH "C:\Users\YourName\AppData\Roaming\npm\claude.cmd"
- ```
-
- **Linux/Mac (add to ~/.bashrc or ~/.zshrc):**
- ```bash
- export CLAUDE_CLI_PATH=/usr/local/bin/claude
- ```
-
- ---
-
- ### Option 2: Add to PATH
-
- **Windows:**
- 1. Search for "environment variables" in start menu
- 2. Click "Environment Variables" button
- 3. Under "User variables", find "Path"
- 4. Add the directory containing claude.cmd
- 5. Restart terminal
-
- **Linux/Mac:**
- ```bash
- # Add to ~/.bashrc or ~/.zshrc
- export PATH="$PATH:/path/to/claude/directory"
- ```
-
- ---
-
- ### Option 3: Install/Reinstall Claude CLI
-
- If Claude CLI isnt installed:
-
- ```bash
- npm install -g @anthropics/claude-code
- ```
-
- After setting the path, run DaveLoop again.
-
- ---
-
- ## What Happens When You Run It
-
- 1. **Banner shows up** - you see the DAVELOOP ASCII art
- 2. **Session info** - working dir, max iterations, prompt loaded
- 3. **Bug report** - your description echoed back
- 4. **Iteration 1 starts** - progress bar shows up
- 5. **You see the reasoning** - KNOWN, UNKNOWN, HYPOTHESIS, NEXT ACTION
- 6. **You see the actions** - file reads, edits, bash commands
- 7. **Iteration completes** - either continues or exits
-
- ---
-
- ## Reading the Output
-
- Output is color coded:
-
- - **Blue** - reasoning blocks and actions
- - **White** - normal text and code
- - **Dim** - less important details
- - **Green** - success messages
- - **Red** - errors
- - **Yellow** - warnings
-
- Key things to watch for:
-
- - **Reasoning blocks** - shows how its thinking through the problem
- - **Tool usage** - what files its reading/editing
- - **Exit signals** - `[Exit signal detected: RESOLVED]` means its done
-
- ---
-
- ## When It Finishes
-
- ### Three Possible Outcomes:
-
- **1. Success - Bug is Fixed**
-
- ★ ★ ★  BUG SUCCESSFULLY RESOLVED  ★ ★ ★
-
- Bug fixed in 3 iteration(s)!
- ```
-
- **2. Blocked - Needs Human Help**
- ```
- ERROR: Claude is blocked - needs human help
- ```
-
- Check the logs to see what it tried. Usually means:
- - Environment issues (missing dependencies)
- - Need clarification on requirements
- - Need access to external systems
-
- **3. Max Iterations - Ran Out of Attempts**
- ```
- WARNING: Max iterations (20) reached without resolution
- ```
-
- Check logs in `logs/` directory. Either:
- - Increase max iterations
- - Provide more context about the bug
- - Manually help it past a blocker
-
- ---
-
- ## Logs Location
-
- Every session creates logs:
-
- ```
- logs/
-   20240127_143022_iteration_01.log    <- first attempt
-   20240127_143022_iteration_02.log    <- second attempt
-   20240127_143022_summary.md          <- overview
- ```
-
- Session ID format: `YYYYMMDD_HHMMSS`
-
- Useful for:
- - Seeing what the agent tried
- - Debugging why it got stuck
- - Understanding its reasoning process
- - Proving to your team that the AI actually fixed the bug
-
- ---
-
- ## Tips for Good Bug Descriptions
-
- **Bad:**
- ```bash
- python daveloop.py "fix the bug"
- ```
- Too vague. What bug? Where?
-
- **Better:**
- ```bash
- python daveloop.py "wallet balance goes negative when two users checkout simultaneously"
- ```
- Has symptom and context.
-
- **Best:**
- ```bash
- python daveloop.py "RACE CONDITION: routes/order.ts wallet payment (lines 139-148). Balance check at line 141 happens BEFORE decrement   
- at line 142. Two concurrent $100 orders both pass the check and overdraw wallet to -$100. Need atomic check+decrement."
- ```
-
- Has:
- - Bug type (race condition)
- - Location (file and lines)
- - Reproduction (concurrent orders)
- - Root cause (non-atomic operations)
- - Suggested fix direction (atomic operation)
-
- **More context = faster resolution = fewer iterations**
-
- ---
-
- ## Interrupting the Agent
-
- If you need to stop it:
- - Press `Ctrl+C` once - graceful shutdown
- - Press `Ctrl+C` twice - force kill
-
- Logs are saved even if interrupted.
-
- ---
-
- ## Testing Before Production
-
- Run on test bugs first:
-
- ```bash
- # Simple test
- python daveloop.py "create a file test.txt with 'hello world' and output [DAVELOOP:RESOLVED]"
- ```
-
- Should resolve in 1-2 iterations. If it works, youre good to go.
-
- ---
-
- ## Using with SWE-bench
-
- For testing against real-world benchmark bugs:
-
- ```bash
- python daveloop_swebench.py --file django_hash_task.json --max-iterations 15
- ```
-
- Comes with pre-configured bugs from:
- - Django ORM
- - Pytest AST rewriting
- - SymPy code generation
- - Sklearn edge cases
-
- ---
-
- ## Tested On
-
- - Juice-Shop security vulnerabilities (race conditions, NoSQL injection, ReDoS, path traversal)
- - SWE-bench real-world bugs (Django ORM, Pytest AST, SymPy C-code generation)
- - Production n8n workflow errors (MongoDB connection, webhook failures)
-
- **Success rate significantly higher than one-shot attempts because of the iterative + reasoning approach**

daveloop-1.4.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-daveloop.py,sha256=vO_mKj_kSciLmupY_GAw3qkRp4Axo6rsrTJx-lhFIZc,53540
-daveloop_swebench.py,sha256=iD9AU3XRiMQpt7TknFNlvnmPCNp64V-JaTfqTFgsGBM,15996
-daveloop-1.4.0.dist-info/METADATA,sha256=KFXheqH4I1_XexxlhPXlXnMRNzeYEVDnDKCGydjFqEg,10463
-daveloop-1.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-daveloop-1.4.0.dist-info/entry_points.txt,sha256=QcFAZgFrDfPtIikNQb7eW9DxOpBK7T-qWrKqbGAS9Ww,86
-daveloop-1.4.0.dist-info/top_level.txt,sha256=36DiYt70m4DIK8t7IhV_y6hAzUIyeb5-qDUf3-gbDdg,27
-daveloop-1.4.0.dist-info/RECORD,,