claude-code-generator 0.4.12__tar.gz → 0.4.13__tar.gz

{claude_code_generator-0.4.12/src/claude_code_generator.egg-info → claude_code_generator-0.4.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.12
+Version: 0.4.13
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.4.12 → claude_code_generator-0.4.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.4.12"
+version = "0.4.13"
 description = "Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file."
 readme = "README.md"
 license = { text = "MIT" }

{claude_code_generator-0.4.12 → claude_code_generator-0.4.13/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.12
+Version: 0.4.13
 Summary: Orchestrator CLI that drives Claude Code end-to-end to generate whole projects from a requirements.md file.
 Author: Silvio Baratto
 License: MIT

{claude_code_generator-0.4.12 → claude_code_generator-0.4.13}/src/code_generator/__init__.py

@@ -1,3 +1,3 @@
 """code-generator: orchestrator CLI for end-to-end project generation."""
 
-__version__ = "0.4.12"
+__version__ = "0.4.13"

{claude_code_generator-0.4.12 → claude_code_generator-0.4.13}/src/code_generator/orchestrator/ollama_budget.py

@@ -1,10 +1,8 @@
 """Per-cycle safety backstop for the Ollama codepath.
 
-The pre-0.4.11 design treated ``OLLAMA_TURN_BUDGET`` as a hard abort trigger
-— cycles were aborted after exactly 200 turns regardless of whether the
-model was making progress. That is the wrong layer: actual fault-detection
-already lives in two places and triggers on real malfunctions, not on an
-arbitrary counter:
+The pre-0.4.11 design aborted cycles on two arbitrary counters — 200 turns
+and 1 h wall-clock. That's the wrong layer: fault-detection already lives
+in two places that trigger on real malfunctions, not on counters:
 
   * :class:`~code_generator.runner.retry.CircuitBreaker` — trips after ``N``
     consecutive failures on a single phase call. Already wrapped around
@@ -13,29 +11,27 @@ arbitrary counter:
   * :func:`~code_generator.runner.rate_limit.handle_ollama_429` —
     wait-and-resume on 429s returned by the Ollama daemon.
 
-This module therefore degrades to a **non-blocking adaptive** backstop:
+Starting with 0.4.13 both thresholds are **soft warnings** — the module
+never aborts the pipeline. Weak open models are slow AND chatty; letting
+them run is the right call. The operator can always Ctrl-C a runaway.
 
-  * The turn counter now emits a single **WARNING** when the cycle crosses
-    the soft threshold (default 500). The pipeline is **never** aborted on
-    the turn count alone. Weak open models are chatty by design; letting
-    them run is the right call.
-  * The wall-clock cap remains a **hard abort**, but the default is raised
-    to 4 hours. It exists purely to catch a stuck daemon or a model trapped
-    in a pathological loop the CircuitBreaker cannot see (e.g. infinite
-    ``end_turn``→``continue`` cycle producing no tool calls).
+  * ``OLLAMA_SOFT_TURN_WARN``  (int, positive; default 500). Emitted once
+    per cycle when cumulative ``num_turns`` crosses the threshold.
+  * ``OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS``  (int, positive; default 14400).
+    Emitted once per cycle when elapsed wall-clock crosses the threshold.
 
-Both thresholds are env-overridable:
+Backwards-compatible shims: the legacy env names ``OLLAMA_TURN_BUDGET`` and
+``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` remain honoured and map onto the new
+soft-warn thresholds. Scripts that previously relied on the abort now see
+a WARNING instead; the 0.4.11 changelog entry called this out for the turn
+budget, and 0.4.13 extends the same semantics to wall-clock.
 
-  * ``OLLAMA_SOFT_TURN_WARN``  (int, positive; default 500)
-  * ``OLLAMA_WALLCLOCK_BUDGET_SECONDS``  (int, positive; default 14400)
-
-Backwards-compatible shim: the old ``OLLAMA_TURN_BUDGET`` env variable is
-still honoured and maps onto the soft-warn threshold, so operators with
-existing scripts see no behaviour change beyond the abort becoming a
-warning.
+:class:`OllamaBudgetExceeded` is retained only as a concrete exception
+type for backwards compatibility with callers that ``except`` it — it is
+no longer raised by this module.
 
 Nothing is persisted in ``state.json`` — the tracker is per-run and
-discarded on abort or clean completion.
+discarded on clean completion.
 """
 
 from __future__ import annotations
@@ -57,7 +53,7 @@ _logger = logging.getLogger(__name__)
 # ---------------------------------------------------------------------------
 
 _DEFAULT_SOFT_TURN_WARN = 500
-_DEFAULT_WALLCLOCK_BUDGET_SECONDS = 14400  # 4 h
+_DEFAULT_WALLCLOCK_SOFT_WARN_SECONDS = 14400  # 4 h
 
 
 def _read_int_env(name: str, default: int) -> int:
@@ -100,17 +96,31 @@ aborts.
 OLLAMA_TURN_BUDGET = OLLAMA_SOFT_TURN_WARN
 """Backwards-compatible alias for :data:`OLLAMA_SOFT_TURN_WARN`."""
 
-OLLAMA_WALLCLOCK_BUDGET_SECONDS = _read_int_env(
-    "OLLAMA_WALLCLOCK_BUDGET_SECONDS", _DEFAULT_WALLCLOCK_BUDGET_SECONDS
-)
-"""Hard wall-clock abort threshold (seconds) per cycle on the Ollama codepath.
+def _resolve_wallclock_soft_warn() -> int:
+    """Honour legacy ``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` env var for backwards compat."""
+    legacy = _read_int_env("OLLAMA_WALLCLOCK_BUDGET_SECONDS", 0)
+    if legacy:
+        return legacy
+    return _read_int_env(
+        "OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS", _DEFAULT_WALLCLOCK_SOFT_WARN_SECONDS
+    )
+
+
+OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS = _resolve_wallclock_soft_warn()
+"""Soft warning threshold on per-cycle wall-clock elapsed (seconds).
 
-Defaults to 14400 (4 h); override via ``OLLAMA_WALLCLOCK_BUDGET_SECONDS``.
-This is the only hard abort enforced by this module — it exists to catch a
-stuck daemon or a pathological loop the per-phase
-:class:`~code_generator.runner.retry.CircuitBreaker` cannot see.
+Defaults to 14400 (4 h). Override via ``OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS``
+(new name) or the legacy ``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` (preserved for
+backwards compatibility). The value is **non-blocking**: the pipeline only
+logs a WARNING once per cycle when elapsed first crosses this threshold.
+It never aborts.
 """
 
+# Kept as a module-level alias so existing importers (tests, scripts) keep
+# working. The semantics are now "soft warning threshold", not "abort".
+OLLAMA_WALLCLOCK_BUDGET_SECONDS = OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS
+"""Backwards-compatible alias for :data:`OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS`."""
+
 
 # ---------------------------------------------------------------------------
 # Exception
@@ -118,11 +128,12 @@ stuck daemon or a pathological loop the per-phase
 
 
 class OllamaBudgetExceeded(RuntimeError):
-    """Raised when the Ollama per-cycle wall-clock backstop is exceeded.
+    """Retained only for backwards compatibility with ``except`` clauses.
 
-    Only fires on the wall-clock path. The turn counter now emits a WARNING
-    instead; real per-call failures are handled by the ``CircuitBreaker``
-    in :mod:`code_generator.runner.retry`.
+    As of 0.4.13 this module never raises ``OllamaBudgetExceeded``. Both the
+    turn counter and the wall-clock are non-blocking soft WARNINGs. Real
+    per-call failures are handled by the ``CircuitBreaker`` in
+    :mod:`code_generator.runner.retry`.
 
     Subclasses ``RuntimeError`` to match the existing safety-abort hierarchy
     (e.g. :class:`~code_generator.runner.types.OverageAbort`).
@@ -137,9 +148,8 @@ class OllamaBudgetExceeded(RuntimeError):
 class OllamaBudgetTracker:
     """Adaptive per-cycle safety backstop; a no-op on the Anthropic Max path.
 
-    Emits one WARNING when the cycle crosses the soft turn threshold; aborts
-    only on the wall-clock backstop. Does **not** block the pipeline on the
-    turn count — real failures are the responsibility of
+    Emits at most one WARNING per threshold (turn count, wall-clock). **Never
+    aborts**. Real failures are the responsibility of
     :class:`~code_generator.runner.retry.CircuitBreaker` and the rate-limit
     handlers in :mod:`code_generator.runner.rate_limit`.
     """
@@ -162,6 +172,7 @@ class OllamaBudgetTracker:
         self._clock = clock or time.monotonic
         self._start_time: float | None = None
         self._turn_warning_emitted = False
+        self._wallclock_warning_emitted = False
 
     def start(self) -> None:
         """Record the cycle start time. Idempotent; only the first call matters."""
@@ -169,11 +180,11 @@ class OllamaBudgetTracker:
             self._start_time = self._clock()
 
     def check(self, state: State, cycle: CycleState | None) -> None:
-        """Warn on soft-turn threshold; raise only on wall-clock overflow."""
+        """Warn on either threshold; never raise."""
         if not self._active:
             return
         self._check_turn_soft_warn(state, cycle)
-        self._check_wallclock_budget()
+        self._check_wallclock_soft_warn()
 
     def _check_turn_soft_warn(self, state: State, cycle: CycleState | None) -> None:
         """Emit one WARNING the first time the cycle crosses the soft threshold.
@@ -196,17 +207,29 @@ class OllamaBudgetTracker:
             )
             self._turn_warning_emitted = True
 
-    def _check_wallclock_budget(self) -> None:
-        if self._start_time is None:
+    def _check_wallclock_soft_warn(self) -> None:
+        """Emit one WARNING the first time the cycle crosses the wall-clock threshold.
+
+        Never raises. As of 0.4.13 the wall-clock ceiling is advisory: a
+        genuinely stuck daemon will be caught by the per-phase
+        CircuitBreaker or by the operator's Ctrl-C; aborting a live session
+        on a counter wastes hours of work.
+        """
+        if self._wallclock_warning_emitted or self._start_time is None:
             return
         elapsed = self._clock() - self._start_time
-        if elapsed > OLLAMA_WALLCLOCK_BUDGET_SECONDS:
-            raise OllamaBudgetExceeded(
-                f"Ollama wall-clock budget exceeded: {elapsed:.0f}s > "
-                f"{OLLAMA_WALLCLOCK_BUDGET_SECONDS}s. "
-                "Raise OLLAMA_WALLCLOCK_BUDGET_SECONDS (env var) if real "
-                "workloads legitimately need more than 4 hours per cycle."
+        if elapsed > OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS:
+            _logger.warning(
+                "Ollama cycle has been running for %.0fs (soft threshold: "
+                "%ds). Letting it run — real stalls are caught by the "
+                "per-phase CircuitBreaker in runner/retry.py. Raise the "
+                "threshold via OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS or the "
+                "legacy OLLAMA_WALLCLOCK_BUDGET_SECONDS env var to silence "
+                "this warning. Use Ctrl-C to stop a truly runaway cycle.",
+                elapsed,
+                OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS,
             )
+            self._wallclock_warning_emitted = True
 
 
 def _sum_num_turns(state: State, cycle: CycleState | None) -> int:

{claude_code_generator-0.4.12 → claude_code_generator-0.4.13}/src/code_generator/prompts/prompt-phase-6-test.md

@@ -18,16 +18,22 @@ You are a senior engineer specialized in testing. Your task is to run the projec
    - `Cargo.toml` → Rust/cargo test
    - `go.mod` → Go test
 
-2. **Run the full test suite:**
+2. **Run the full test suite with concise output** (see Constraints):
    ```bash
-   # Adapt to the detected framework
-   pytest -xvs                    # Python
-   npm test -- --run              # Vitest
+   # Adapt to the detected framework.
+   pytest -q --tb=line            # Python — quiet, one-line tracebacks
+   npm test -- --run --reporter=default  # Vitest
    npm test                       # Jest/Angular
-   cargo test --all               # Rust
-   go test ./...                  # Go
+   cargo test --all --quiet       # Rust
+   go test ./... 2>&1 | tail -200 # Go — only the last 200 lines
    ```
 
+   **Do not use `-v`, `-vv`, `-s`, or any other verbose/stream flag.** A
+   tool result returned to the model cannot exceed roughly 1 MB — verbose
+   pytest output on a medium-sized project blows past that limit and
+   crashes the SDK stream reader mid-cycle. Start quiet; escalate only the
+   individual failing test with `-v` after you have the list of failures.
+
 3. **If all tests pass on the first attempt:**
    - Also run any available linters/type checkers (`mypy`, `ruff`, `eslint`, `tsc --noEmit`)
    - Collect test coverage if the framework supports it
@@ -98,6 +104,7 @@ You are a senior engineer specialized in testing. Your task is to run the projec
 - **Do not ask the user for confirmation**: act autonomously in YOLO mode.
 - **If you find flakiness** (a test that passes/fails non-deterministically), do not ignore it: document the flaky behavior in the bug issue.
 - **Environment variables already available globally**: `GITHUB_TOKEN`, `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, `GOOGLE_API_KEY`, `OLLAMA_API_KEY`, `OLLAMA_BASE_URL`. If a test fails because "an API key is missing" among these, the cause is **not** the missing key — check the variable name, the `.env` loading, or an explicit override in the test. Do not add dummy keys as a fix. For tests that make real calls and are slow/expensive, use mocking/VCR cassettes instead of disabling them.
+- **Tool-result size ceiling.** Bash tool-results larger than ~1 MB crash the SDK stream reader. Always prefer `-q`/`--tb=line`/`--quiet` over `-v`/`-vv`/`-s`. If a command genuinely produces more than 1 MB of output, tee it to a file (`cmd > /tmp/out.log 2>&1 || true`) and then `Read` or `Grep` the file — never let the full output flow back through a single tool result.
 
 ---
 

{claude_code_generator-0.4.12 → claude_code_generator-0.4.13}/tests/test_ollama_budget.py

@@ -1,30 +1,35 @@
-"""Tests for the Ollama per-cycle adaptive safety backstop (issue #220, 0.4.11).
+"""Tests for the Ollama per-cycle adaptive safety backstop (0.4.13).
 
-As of 0.4.11 the turn counter is a **non-blocking soft warning** — the
-pipeline is never aborted on turn count alone. Real per-call failures are
-the job of :class:`~code_generator.runner.retry.CircuitBreaker` and the
-rate-limit handlers. The wall-clock remains a hard abort (default 4 h).
+Both the turn counter and the wall-clock are **non-blocking soft warnings**
+— the pipeline is never aborted on either threshold alone. Real per-call
+failures are the job of :class:`~code_generator.runner.retry.CircuitBreaker`
+and the rate-limit handlers.
 
-Backwards compatibility: ``OLLAMA_TURN_BUDGET`` is preserved as an alias
-for :data:`OLLAMA_SOFT_TURN_WARN` so existing scripts keep importing.
+Backwards compatibility: ``OLLAMA_TURN_BUDGET`` and
+``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` are preserved as aliases for
+:data:`OLLAMA_SOFT_TURN_WARN` and :data:`OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS`
+respectively, so existing scripts keep importing.
 """
 
 from __future__ import annotations
 
 import logging
-
-import pytest
+from typing import TYPE_CHECKING
 
 from code_generator import state as _state
 from code_generator.orchestrator.ollama_budget import (
     OLLAMA_SOFT_TURN_WARN,
     OLLAMA_TURN_BUDGET,
     OLLAMA_WALLCLOCK_BUDGET_SECONDS,
+    OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS,
     OllamaBudgetExceeded,
     OllamaBudgetTracker,
 )
 from code_generator.runner.types import TokenUsage
 
+if TYPE_CHECKING:
+    import pytest
+
 # ---------------------------------------------------------------------------
 # Constants
 # ---------------------------------------------------------------------------
@@ -38,8 +43,12 @@ class TestThresholdConstants:
         """Legacy ``OLLAMA_TURN_BUDGET`` must alias the new soft-warn constant."""
         assert OLLAMA_TURN_BUDGET == OLLAMA_SOFT_TURN_WARN
 
-    def test_wallclock_budget_default_is_4_hours(self) -> None:
-        assert OLLAMA_WALLCLOCK_BUDGET_SECONDS == 14400
+    def test_wallclock_soft_warn_default_is_4_hours(self) -> None:
+        assert OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS == 14400
+
+    def test_wallclock_budget_alias_matches_soft_warn(self) -> None:
+        """Legacy ``OLLAMA_WALLCLOCK_BUDGET_SECONDS`` must alias the soft-warn constant."""
+        assert OLLAMA_WALLCLOCK_BUDGET_SECONDS == OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS
 
 
 # ---------------------------------------------------------------------------
@@ -149,9 +158,9 @@ class TestTurnSoftWarning:
 # ---------------------------------------------------------------------------
 
 
-class TestWallclockBudget:
-    def test_under_budget_does_not_raise(self) -> None:
-        """Elapsed < budget → no raise."""
+class TestWallclockSoftWarning:
+    def test_under_threshold_does_not_warn(self, caplog: pytest.LogCaptureFixture) -> None:
+        """Elapsed < threshold → no WARNING emitted, no raise."""
         st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
         now = 1_000_000.0
         tracker = OllamaBudgetTracker(
@@ -159,12 +168,18 @@ class TestWallclockBudget:
             clock=lambda: now,
         )
         tracker.start()
-        now += OLLAMA_WALLCLOCK_BUDGET_SECONDS - 10
+        now += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS - 10
 
-        tracker.check(st, cycle)  # must not raise
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)
+
+        wallclock_warnings = [r for r in caplog.records if "running for" in r.message.lower()]
+        assert wallclock_warnings == []
 
-    def test_over_budget_raises_with_exact_message(self) -> None:
-        """Elapsed > budget → OllamaBudgetExceeded naming wall-clock."""
+    def test_over_threshold_warns_without_raising(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Crossing the threshold logs a WARNING; the pipeline continues."""
         st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
         t = [1_000_000.0]
 
@@ -173,14 +188,32 @@ class TestWallclockBudget:
 
         tracker = OllamaBudgetTracker(provider_is_ollama=True, clock=_clock)
         tracker.start()
-        t[0] += OLLAMA_WALLCLOCK_BUDGET_SECONDS + 1
+        t[0] += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS + 1
+
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)  # must not raise
+
+        wallclock_warnings = [r for r in caplog.records if "running for" in r.message.lower()]
+        assert len(wallclock_warnings) == 1
+        assert str(OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS) in wallclock_warnings[0].message
+
+    def test_warning_is_emitted_only_once_per_cycle(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """Subsequent checks after the first wall-clock warning must stay silent."""
+        st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
+        t = [1_000_000.0]
+        tracker = OllamaBudgetTracker(provider_is_ollama=True, clock=lambda: t[0])
+        tracker.start()
+        t[0] += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS + 1
 
-        with pytest.raises(OllamaBudgetExceeded) as excinfo:
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)
+            tracker.check(st, cycle)
             tracker.check(st, cycle)
 
-        msg = str(excinfo.value)
-        assert "wall" in msg.lower() or "clock" in msg.lower()
-        assert str(OLLAMA_WALLCLOCK_BUDGET_SECONDS) in msg
+        wallclock_warnings = [r for r in caplog.records if "running for" in r.message.lower()]
+        assert len(wallclock_warnings) == 1
 
     def test_start_is_required_before_check(self) -> None:
         """check() without start() returns immediately on wall-clock (None start)."""
@@ -190,7 +223,7 @@ class TestWallclockBudget:
         tracker.check(st, cycle)  # must not raise
 
     def test_extreme_turn_count_does_not_raise(self) -> None:
-        """No amount of turns should raise on its own — only wall-clock hard-aborts."""
+        """Neither counter should raise on its own — both are soft warnings now."""
         st, cycle = _make_state_with_usage(
             {}, cycle_turns={"phase3_4": OLLAMA_SOFT_TURN_WARN * 100}
         )
@@ -198,6 +231,16 @@ class TestWallclockBudget:
 
         tracker.check(st, cycle)  # must not raise
 
+    def test_extreme_wallclock_does_not_raise(self) -> None:
+        """Wall-clock far past threshold must not raise either (0.4.13)."""
+        st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
+        t = [1_000_000.0]
+        tracker = OllamaBudgetTracker(provider_is_ollama=True, clock=lambda: t[0])
+        tracker.start()
+        t[0] += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS * 10  # 40 h
+
+        tracker.check(st, cycle)  # must not raise
+
 
 # ---------------------------------------------------------------------------
 # Anthropic Max path — thresholds do not fire
@@ -218,15 +261,21 @@ class TestAnthropicMaxUntouched:
         turn_warnings = [r for r in caplog.records if "consumed" in r.message.lower()]
         assert turn_warnings == []
 
-    def test_anthropic_max_mode_skips_wallclock_budget(self) -> None:
-        """provider_is_ollama=False → wall-clock breach does not raise."""
+    def test_anthropic_max_mode_skips_wallclock_warning(
+        self, caplog: pytest.LogCaptureFixture
+    ) -> None:
+        """provider_is_ollama=False → no WARNING, no raise."""
         st, cycle = _make_state_with_usage({}, cycle_turns={"phase0": 1})
         t = [1_000_000.0]
         tracker = OllamaBudgetTracker(provider_is_ollama=False, clock=lambda: t[0])
         tracker.start()
-        t[0] += OLLAMA_WALLCLOCK_BUDGET_SECONDS + 100
+        t[0] += OLLAMA_WALLCLOCK_SOFT_WARN_SECONDS + 100
 
-        tracker.check(st, cycle)  # must not raise
+        with caplog.at_level(logging.WARNING):
+            tracker.check(st, cycle)
+
+        wallclock_warnings = [r for r in caplog.records if "running for" in r.message.lower()]
+        assert wallclock_warnings == []
 
 
 # ---------------------------------------------------------------------------