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

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "etch-loop"
-version = "0.4.2"
+version = "0.4.4"
 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.4/src/etch/__init__.py

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

{etch_loop-0.4.2 → etch_loop-0.4.4}/src/etch/display.py

@@ -216,6 +216,8 @@ class EtchDisplay:
             title = f"[{AMBER}]- stopped (max iterations)[/{AMBER}]"
         elif reason == "no_changes":
             title = f"[{GREEN}]+ clean — fixer found nothing[/{GREEN}]"
+        elif reason == "build_failed":
+            title = f"[{RED}]x build failed[/{RED}]"
         else:
             title = f"[{FG}]done[/{FG}]"
 

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

@@ -66,58 +66,11 @@ def run(
     }
     last_breaker_signal: str | None = None
     last_breaker_output: str | None = None
-    last_runner_output: str | None = None
     iteration_log: list[dict] = []
+    final_runner_entry: 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
@@ -169,12 +122,6 @@ 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")
@@ -264,19 +211,9 @@ def run(
                                   detail=breaker_detail or "no issues found",
                                   duration=breaker_duration, success=True)
                 iter_entry["breaker"] = {"status": "all clear", "detail": breaker_detail}
-                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
+                stats["reason"] = "clear"
+                iteration_log.append(iter_entry)
+                break
             else:
                 disp.record_issue()
                 stats["issues"] += 1
@@ -290,6 +227,38 @@ def run(
         else:
             stats["reason"] = "max_iterations"
 
+        # ── Runner — final step, only when loop ended cleanly ─────────────────
+        if run_text and stats["reason"] in ("clear", "no_changes"):
+            disp.start_phase("runner")
+            runner_start = time.monotonic()
+            try:
+                runner_output = agent.run(run_text, verbose=verbose)
+                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)
+                    final_runner_entry = {"status": "all clear", "detail": runner_detail}
+                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)
+                    final_runner_entry = {"status": "build failed", "detail": runner_detail}
+                    stats["reason"] = "build_failed"
+            except AgentError as exc:
+                disp.finish_phase("runner", status="error",
+                                  detail=str(exc),
+                                  duration=time.monotonic() - runner_start, success=False)
+                final_runner_entry = {"status": "error", "detail": str(exc)}
+                stats["reason"] = "agent_error"
+
         stats["elapsed"] = time.monotonic() - start_time
 
     # Live panel is fully closed before printing anything below
@@ -297,6 +266,8 @@ def run(
 
     # ── Write report ──────────────────────────────────────────────────────────
     try:
+        if final_runner_entry:
+            iteration_log.append({"n": "runner", "runner": final_runner_entry})
         report_path = report.write(stats, iteration_log, output_dir=prompt_path.parent)
         if not no_git and not no_commit and stats["fixes"] > 0:
             try:

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

@@ -87,6 +87,7 @@ def _reason_label(reason: str) -> str:
         "interrupted": "interrupted",
         "agent_error": "stopped — agent error",
         "git_error": "stopped — git error",
+        "build_failed": "stopped — build/tests failed",
     }.get(reason, reason)
 
 

{etch_loop-0.4.2 → etch_loop-0.4.4}/src/etch/signals.py

@@ -6,36 +6,30 @@ _PUNCTUATION_ONLY = set("-=*_`~><|")
 
 
 def parse(output: str) -> str:
-    """Parse breaker agent output for control tokens.
+    """Parse agent output for control tokens.
 
-    Returns the signal corresponding to whichever token appears first.
-    If both appear, the earlier one wins. If neither appears, returns
-    "issues" as a fail-safe.
+    Tokens must appear alone on their own line (after stripping whitespace
+    and backtick wrappers). This prevents false matches when agents quote the
+    token strings in explanations like `ETCH_ALL_CLEAR`.
+
+    The first matching line wins. If neither token is found, returns "issues"
+    as a fail-safe.
 
     Returns:
-        "clear"  — ETCH_ALL_CLEAR found (and appears before ETCH_ISSUES_FOUND)
-        "issues" — ETCH_ISSUES_FOUND found, appears first, or neither found
+        "clear"  — ETCH_ALL_CLEAR found on its own line first
+        "issues" — ETCH_ISSUES_FOUND found on its own line first, or no token found
     """
     if not isinstance(output, str):
         return "issues"
 
-    clear_pos = output.find(_TOKEN_CLEAR)
-    issues_pos = output.find(_TOKEN_ISSUES)
-
-    if clear_pos == -1 and issues_pos == -1:
-        # Fail-safe: no token found → assume issues
-        return "issues"
-
-    if clear_pos == -1:
-        return "issues"
-
-    if issues_pos == -1:
-        return "clear"
+    for line in output.splitlines():
+        stripped = line.strip().strip("`").strip()
+        if stripped == _TOKEN_CLEAR:
+            return "clear"
+        if stripped == _TOKEN_ISSUES:
+            return "issues"
 
-    # Both found — whichever appears first wins
-    if clear_pos < issues_pos:
-        return "clear"
-    return "issues"
+    return "issues"  # fail-safe: no token found
 
 
 def extract_commit_message(output: str, fallback: str) -> str:
@@ -93,35 +87,23 @@ def extract_summary(output: str) -> str:
 
 
 def extract_finding(output: str) -> str:
-    """Extract first meaningful line before the signal token.
+    """Extract the last meaningful line before the signal token line.
 
-    Returns the first non-empty, non-header line that appears before
-    the signal token, or an empty string if nothing useful is found.
+    Scans line by line, stops at the first line that IS a token (exact match).
+    Returns the last non-empty, non-header line before that point.
     """
     if not isinstance(output, str) or not output.strip():
         return ""
 
-    # Find the position of either token
-    clear_pos = output.find(_TOKEN_CLEAR)
-    issues_pos = output.find(_TOKEN_ISSUES)
-
-    # Determine the cutoff point (use whichever token appears first)
-    cutoff = len(output)
-    if clear_pos >= 0 and issues_pos >= 0:
-        cutoff = min(clear_pos, issues_pos)
-    elif clear_pos >= 0:
-        cutoff = clear_pos
-    elif issues_pos >= 0:
-        cutoff = issues_pos
-
-    text_before = output[:cutoff].strip()
-    if not text_before:
-        return ""
+    lines_before: list[str] = []
+    for line in output.splitlines():
+        stripped = line.strip().strip("`").strip()
+        if stripped in (_TOKEN_CLEAR, _TOKEN_ISSUES):
+            break
+        lines_before.append(line)
 
-    lines = text_before.splitlines()
-    for line in reversed(lines):
+    for line in reversed(lines_before):
         stripped = line.strip().strip("`").strip()
-        # Skip empty lines, markdown headers, separator lines, and bare punctuation
         if not stripped:
             continue
         if stripped.startswith("#"):

etch_loop-0.4.2/src/etch/__init__.py

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