etch-loop 0.3.2__tar.gz → 0.4.2__tar.gz

{etch_loop-0.3.2 → etch_loop-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: etch-loop
-Version: 0.3.2
+Version: 0.4.2
 Summary: Run Claude Code in a fix-break loop until your codebase is clean
 License: MIT
 Requires-Python: >=3.11

{etch_loop-0.3.2 → etch_loop-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "etch-loop"
-version = "0.3.2"
+version = "0.4.2"
 requires-python = ">=3.11"
 description = "Run Claude Code in a fix-break loop until your codebase is clean"
 readme = "README.md"

etch_loop-0.4.2/src/etch/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.2"

{etch_loop-0.3.2 → etch_loop-0.4.2}/src/etch/analyze.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import json
 import subprocess
 from collections import Counter
 from pathlib import Path
@@ -259,6 +260,78 @@ Be adversarial — think like someone actively trying to make this code fail.
 """
 
 
+def build_run_md(info: dict) -> str:
+    """Generate a tailored RUN.md based on detected build system."""
+    root = info.get("root", Path.cwd())
+    commands = _detect_run_commands(root)
+
+    if commands:
+        cmd_list = "\n".join(f"- `{cmd}`" for cmd in commands)
+    else:
+        cmd_list = "- (detect and run the appropriate build/test command for this project)"
+
+    return f"""# RUN — build and test validation
+
+You are a build validator. The fixer has made changes. Your job is to run the project's build and test suite to confirm everything still works.
+
+## Commands to run
+
+{cmd_list}
+
+## Rules
+
+1. Run each command and observe the output
+2. If ALL commands pass:
+   - Write `ETCH_SUMMARY: <e.g. "all 47 tests passed">`
+   - Write `ETCH_ALL_CLEAR`
+3. If ANY command fails:
+   - Write `ETCH_SUMMARY: <what failed, e.g. "3 tests failed in test_auth.py — TypeError on line 42">`
+   - Include the relevant error output so the fixer can diagnose it
+   - Write `ETCH_ISSUES_FOUND`
+
+Do not fix anything — only run and report.
+"""
+
+
+def _detect_run_commands(root: Path) -> list[str]:
+    """Detect build/test commands from project files."""
+    commands: list[str] = []
+
+    if (root / "pyproject.toml").exists() or (root / "setup.py").exists():
+        commands.append("python -m pytest")
+
+    if (root / "package.json").exists():
+        try:
+            pkg = json.loads((root / "package.json").read_text(encoding="utf-8"))
+            scripts = pkg.get("scripts", {})
+            if "build" in scripts:
+                commands.append("npm run build")
+            if "test" in scripts:
+                commands.append("npm test")
+        except (OSError, json.JSONDecodeError):
+            commands.append("npm test")
+
+    if (root / "Cargo.toml").exists():
+        commands.append("cargo test")
+
+    if (root / "go.mod").exists():
+        commands.append("go test ./...")
+
+    if (root / "Gemfile").exists():
+        commands.append("bundle exec rspec")
+
+    if (root / "mix.exs").exists():
+        commands.append("mix test")
+
+    if (root / "pom.xml").exists():
+        commands.append("mvn test -q")
+
+    if not commands and (root / "Makefile").exists():
+        commands.append("make test")
+
+    return commands
+
+
 def _format_scope(info: dict) -> str:
     lines = []
     if info["source_dirs"]:

{etch_loop-0.3.2 → etch_loop-0.4.2}/src/etch/cli.py

@@ -40,6 +40,7 @@ def init() -> None:
             (etch_dir / "SCAN.md",  analyze.build_scan_md(info, agent_scope),  "etch-loop/SCAN.md"),
             (etch_dir / "ETCH.md",  analyze.build_etch_md(info, agent_scope),  "etch-loop/ETCH.md"),
             (etch_dir / "BREAK.md", analyze.build_break_md(info, agent_scope), "etch-loop/BREAK.md"),
+            (etch_dir / "RUN.md",   analyze.build_run_md(info),                "etch-loop/RUN.md"),
         ]:
             if dest.exists():
                 disp.add_line(display.SYM_NEUTRAL, display.DIM, f"{label} already exists, skipping")

{etch_loop-0.3.2 → etch_loop-0.4.2}/src/etch/loop.py

@@ -49,6 +49,9 @@ def run(
         display.print_error(str(exc))
         return
 
+    # Runner is optional — None means the phase is skipped
+    run_text = prompt.load_run(prompt_path)
+
     if focus:
         scan_text += f"\n\n## User focus\n\nConcentrate on: {focus}\n"
         break_text += f"\n\n## User focus\n\nConcentrate your adversarial review on: {focus}\n"
@@ -63,9 +66,59 @@ def run(
     }
     last_breaker_signal: str | None = None
     last_breaker_output: str | None = None
+    last_runner_output: str | None = None
     iteration_log: list[dict] = []
 
     with display.EtchDisplay(target=str(prompt_path.parent)) as disp:
+
+        # ── Runner helper — called at every clean exit point ──────────────────
+        def try_runner(iter_entry: dict) -> str:
+            """Run the runner phase if configured.
+
+            Returns:
+                "skip"   — no RUN.md, proceed with clean exit
+                "clear"  — runner passed, proceed with clean exit
+                "issues" — runner failed, continue the loop
+                "error"  — agent error, break the loop
+            """
+            nonlocal last_runner_output
+            if not run_text:
+                return "skip"
+
+            disp.start_phase("runner")
+            runner_start = time.monotonic()
+            try:
+                runner_output = agent.run(run_text, verbose=verbose)
+            except AgentError as exc:
+                disp.finish_phase("runner", status="error", detail=str(exc),
+                                  duration=time.monotonic() - runner_start, success=False)
+                return "error"
+
+            runner_duration = time.monotonic() - runner_start
+            runner_signal = signals.parse(runner_output)
+            runner_detail = (
+                signals.extract_summary(runner_output)
+                or signals.extract_finding(runner_output)
+            )
+
+            if runner_signal == "clear":
+                disp.finish_phase("runner", status="all clear",
+                                  detail=runner_detail or "build passed",
+                                  duration=runner_duration, success=True)
+                iter_entry["runner"] = {"status": "all clear", "detail": runner_detail}
+                last_runner_output = None
+                return "clear"
+            else:
+                disp.record_issue()
+                stats["issues"] += 1
+                disp.finish_phase("runner", status="build failed",
+                                  detail=runner_detail or "build failed",
+                                  duration=runner_duration, success=False)
+                iter_entry["runner"] = {"status": "build failed", "detail": runner_detail}
+                last_runner_output = runner_output
+                return "issues"
+
+        # ── Main loop ─────────────────────────────────────────────────────────
         for iteration in range(1, max_iterations + 1):
             stats["iterations"] = iteration
             disp.start_iteration(iteration)
@@ -116,6 +169,12 @@ def run(
                     f"{last_breaker_output.strip()}\n\n"
                     f"Also address these if not already covered above.\n"
                 )
+            if last_runner_output:
+                fixer_prompt += (
+                    f"\n\n## Build/test failures from previous iteration\n\n"
+                    f"{last_runner_output.strip()}\n\n"
+                    f"Fix the underlying code issues causing these failures.\n"
+                )
 
             # ── Fixer phase ───────────────────────────────────────────────────
             disp.start_phase("fixer")
@@ -205,9 +264,19 @@ def run(
                                   detail=breaker_detail or "no issues found",
                                   duration=breaker_duration, success=True)
                 iter_entry["breaker"] = {"status": "all clear", "detail": breaker_detail}
-                stats["reason"] = "clear"
-                iteration_log.append(iter_entry)
-                break
+                runner_result = try_runner(iter_entry)
+                if runner_result == "error":
+                    stats["reason"] = "agent_error"
+                    iteration_log.append(iter_entry)
+                    break
+                elif runner_result == "issues":
+                    stats["reason"] = "issues"
+                    iteration_log.append(iter_entry)
+                    continue
+                else:  # "clear" or "skip"
+                    stats["reason"] = "clear"
+                    iteration_log.append(iter_entry)
+                    break
             else:
                 disp.record_issue()
                 stats["issues"] += 1

{etch_loop-0.3.2 → etch_loop-0.4.2}/src/etch/prompt.py

@@ -75,6 +75,35 @@ def load_break(path: str | Path | None = None) -> str:
     raise PromptError(f"BREAK.md not found. Searched: {searched}")
 
 
+def load_run(path: str | Path | None = None) -> str | None:
+    """Load RUN.md if it exists. Returns None if not found — runner phase is optional.
+
+    Args:
+        path: Optional path. If this is ETCH.md, looks for RUN.md alongside it.
+
+    Returns:
+        File contents as a string, or None if RUN.md is not present.
+    """
+    candidates: list[Path] = []
+
+    if path is not None:
+        p = Path(path)
+        if p.name.upper() == "RUN.MD":
+            candidates.append(p)
+        else:
+            candidates.append(p.parent / "RUN.md")
+
+    candidates.append(Path.cwd() / "RUN.md")
+
+    for candidate in candidates:
+        if candidate.exists() and candidate.is_file():
+            content = candidate.read_text(encoding="utf-8")
+            if content.strip():
+                return content
+
+    return None  # Optional phase — no error if absent
+
+
 def load_scan(path: str | Path | None = None) -> str:
     """Load and return the content of SCAN.md.
 

{etch_loop-0.3.2 → etch_loop-0.4.2}/src/etch/report.py

@@ -67,6 +67,14 @@ def write(
             if detail:
                 lines.append(f"\n> {detail}\n")
 
+        runner = entry.get("runner")
+        if runner:
+            status = runner.get("status", "")
+            detail = runner.get("detail", "")
+            lines.append(f"**runner** — {status}")
+            if detail:
+                lines.append(f"\n> {detail}\n")
+
     path.write_text("\n".join(lines), encoding="utf-8")
     return path
 

etch_loop-0.4.2/src/etch/templates/RUN.md

@@ -0,0 +1,20 @@
+# RUN — build and test validation
+
+You are a build validator. The fixer has made changes. Your job is to run the project's build and test suite to confirm everything still works.
+
+## Commands to run
+
+[configured by etch init]
+
+## Rules
+
+1. Run each command and observe the output
+2. If ALL commands pass:
+   - Write `ETCH_SUMMARY: <e.g. "all 47 tests passed">`
+   - Write `ETCH_ALL_CLEAR`
+3. If ANY command fails:
+   - Write `ETCH_SUMMARY: <what failed, e.g. "3 tests failed in test_auth.py — TypeError on line 42">`
+   - Include the relevant error output so the fixer can diagnose it
+   - Write `ETCH_ISSUES_FOUND`
+
+Do not fix anything — only run and report.

etch_loop-0.3.2/src/etch/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.2"