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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.12
+Version: 0.4.14
 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.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.4.12"
+version = "0.4.14"
 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.14/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.14
 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.14}/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.14}/src/code_generator/env.py

@@ -48,7 +48,17 @@ def strip_dangerous_env() -> None:
     (``sdk_runner.run``, ``run_with_shared_client``).
     """
     ollama_mode = _is_localhost_base_url(os.environ.get("ANTHROPIC_BASE_URL"))
-    protected = {"ANTHROPIC_AUTH_TOKEN"} if ollama_mode else set()
+    # On the Ollama codepath, ANTHROPIC_AUTH_TOKEN carries the daemon token
+    # and must survive stripping. ANTHROPIC_API_KEY is also protected when it
+    # has been set to "" by assert_safe_environment_ollama() — the empty-string
+    # sentinel tells the SDK to accept non-Claude model tags. A non-empty
+    # ANTHROPIC_API_KEY (e.g. "sk-evil") is still stripped because it would
+    # route traffic to Anthropic's real API, defeating the localhost redirect.
+    protected: set[str] = set()
+    if ollama_mode:
+        protected.add("ANTHROPIC_AUTH_TOKEN")
+        if os.environ.get("ANTHROPIC_API_KEY") == "":
+            protected.add("ANTHROPIC_API_KEY")
     for var in DANGEROUS_VARS:
         if var in protected:
             continue
@@ -116,7 +126,7 @@ def _require_ollama_preconditions() -> str:
 
     Refuses the bypass when:
       * ``OLLAMA_API_KEY`` is unset or empty.
-      * ``ANTHROPIC_BASE_URL`` is pre-set to anything other than the pinned URL.
+      * ``ANTHROPIC_BASE_URL`` is pre-set to a non-localhost value.
 
     A non-empty ``ANTHROPIC_API_KEY`` in the parent env is **not** a refusal:
     ``_build_ollama_env`` strips every ``ANTHROPIC_*`` var from the returned
@@ -132,10 +142,10 @@ def _require_ollama_preconditions() -> str:
             "before running with provider='ollama'."
         )
     preset_base = os.environ.get("ANTHROPIC_BASE_URL")
-    if preset_base and preset_base != OLLAMA_BASE_URL:
+    if preset_base and not _is_localhost_base_url(preset_base):
         raise RuntimeError(
-            f"ANTHROPIC_BASE_URL={preset_base!r} does not match the pinned "
-            f"{OLLAMA_BASE_URL!r}. Unset it or point it at the local daemon."
+            f"ANTHROPIC_BASE_URL={preset_base!r} does not point at a local "
+            f"daemon. Unset it or point it at localhost/127.0.0.1."
         )
     return token
 
@@ -222,14 +232,24 @@ def assert_single_workspace(
         )
 
 
+_LOCALHOST_PREFIXES: tuple[str, ...] = (
+    "http://localhost:",
+    "http://127.0.0.1:",
+    "http://[::1]:",
+)
+
+
 def _is_localhost_base_url(base_url: str | None) -> bool:
     """Return True when the ANTHROPIC_BASE_URL points at any localhost port.
 
-    Deliberately lenient — any ``http://localhost:*`` prefix matches — because
-    the workspace invariant is \"local endpoint\", not the strict :11434 the
-    Ollama preflight refusal gate enforces.
+    Deliberately lenient — ``http://localhost:*``, ``http://127.0.0.1:*``,
+    and ``http://[::1]:*`` all match — because the workspace invariant is
+    \"local endpoint\", not the strict :11434 the Ollama preflight refusal
+    gate enforces.
     """
-    return base_url is not None and base_url.startswith("http://localhost:")
+    if base_url is None:
+        return False
+    return any(base_url.startswith(prefix) for prefix in _LOCALHOST_PREFIXES)
 
 
 def _log_localhost_short_circuit_once(state: dict[str, object]) -> None:
@@ -302,7 +322,7 @@ def assert_safe_environment_ollama() -> None:
     preset_base = os.environ.get("ANTHROPIC_BASE_URL")
     if not token:
         return
-    if preset_base and preset_base != OLLAMA_BASE_URL:
+    if preset_base and not _is_localhost_base_url(preset_base):
         return
 
     os.environ["ANTHROPIC_AUTH_TOKEN"] = token

{claude_code_generator-0.4.12 → claude_code_generator-0.4.14}/src/code_generator/orchestrator/_client_lifecycle.py

@@ -92,12 +92,15 @@ def _open_cycle_client(options_template: Any) -> Any:
     return ClaudeSDKClient(options=options_template)
 
 
-def _build_cycle_options(project_dir: Path) -> Any:
+def _build_cycle_options(project_dir: Path, effective_model: str | None = None) -> Any:
     """Return cycle-scoped options for the shared ``ClaudeSDKClient``.
 
     ``ClaudeSDKClient`` locks options at open-time — per-query changes do not
     apply. The shared client therefore opens with:
 
+    - ``model``: the effective Ollama model tag (when on the Ollama codepath),
+      or ``None`` to let the SDK default (Anthropic Max path). Must be set at
+      open-time because per-query overrides are silently ignored.
     - ``system_prompt``: canonical ``claude_code`` preset with
       ``exclude_dynamic_sections=True`` (§2 cache-safe prefix).
     - ``extra_headers``: default betas (extended-cache-ttl + token-efficient-tools).
@@ -114,6 +117,9 @@ def _build_cycle_options(project_dir: Path) -> Any:
 
     Args:
         project_dir: Project root; used to resolve MCP servers.
+        effective_model: Ollama model tag to lock into the shared client
+            (threaded from cycle_loop). When ``None``, the SDK default
+            (Anthropic Max path) is used.
 
     Returns:
         A ``ClaudeAgentOptions`` instance (or duck-typed fallback) suitable
@@ -121,15 +127,18 @@ def _build_cycle_options(project_dir: Path) -> Any:
     """
     mcp_servers = build_mcp_servers(project_dir)
     allowed_tools: list[str] = list(_SHARED_CLIENT_ALLOWED_TOOLS) + mcp_tool_wildcards(mcp_servers)
-    return make_agent_options(
+    kwargs: dict[str, Any] = dict(
         allowed_tools=allowed_tools,
         permission_mode="bypassPermissions",
         mcp_servers=mcp_servers,
     )
+    if effective_model is not None:
+        kwargs["model"] = effective_model
+    return make_agent_options(**kwargs)
 
 
 @contextlib.asynccontextmanager
-async def managed_shared_client(state: State, state_path: Path):  # type: ignore[return]
+async def managed_shared_client(state: State, state_path: Path, effective_model: str | None = None):  # type: ignore[return]
     """Async context manager owning the full shared-client lifecycle.
 
     On entry: strips dangerous env vars (non-negotiable #1), opens one
@@ -151,6 +160,8 @@ async def managed_shared_client(state: State, state_path: Path):  # type: ignore
     Args:
         state: Root state (mutated by mark/clear helpers).
         state_path: Path to ``state.json`` for atomic persistence.
+        effective_model: Ollama model tag to lock into the shared client.
+            When ``None``, the SDK default (Anthropic Max path) is used.
 
     Yields:
         The open ``ClaudeSDKClient`` instance.
@@ -158,7 +169,7 @@ async def managed_shared_client(state: State, state_path: Path):  # type: ignore
     _env.strip_dangerous_env()
     # state.json lives at {project_dir}/.code-generator/state.json.
     project_dir = state_path.parent.parent
-    options = _build_cycle_options(project_dir)
+    options = _build_cycle_options(project_dir, effective_model=effective_model)
     async with _open_cycle_client(options) as client:
         _state.mark_client_alive(state, state_path)
         try:

{claude_code_generator-0.4.12 → claude_code_generator-0.4.14}/src/code_generator/orchestrator/cycle_loop.py

@@ -435,7 +435,9 @@ async def run_single_mode(
     state_path = project_dir / ".code-generator" / "state.json"
 
     if state.session_mode in ("shared", "batch"):
-        async with managed_shared_client(state, state_path) as client:
+        async with managed_shared_client(
+            state, state_path, effective_model=effective_model
+        ) as client:
             await _run_phases(
                 state,
                 None,
@@ -665,7 +667,9 @@ async def _run_cycle_phases(
     log_prefix = f"cycle{cycle.id}_"
 
     if state.session_mode in ("shared", "batch"):
-        async with managed_shared_client(state, state_path) as client:
+        async with managed_shared_client(
+            state, state_path, effective_model=effective_model
+        ) as client:
             await _run_phases(
                 state,
                 cycle,

{claude_code_generator-0.4.12 → claude_code_generator-0.4.14}/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.14}/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.14}/src/code_generator/runner/subprocess_runner.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import json
+import os
 import subprocess
 import time
 from typing import TYPE_CHECKING, Any
@@ -313,7 +314,16 @@ async def run(
         "CLI session starting (model=%s effort=%s max_turns=%s).", model, effort_display, max_turns
     )
 
-    safe_env = _env.build_agent_env()
+    # Detect Ollama mode so build_agent_env() preserves the scoped localhost
+    # routing (ANTHROPIC_API_KEY="" + pinned BASE_URL). Without provider="ollama"
+    # the default "anthropic-max" path omits ANTHROPIC_API_KEY, which causes
+    # the CLI to reject non-Claude model tags or fall back to real credentials.
+    _provider: _env.Provider = (
+        "ollama"
+        if _env._is_localhost_base_url(os.environ.get("ANTHROPIC_BASE_URL"))
+        else "anthropic-max"
+    )
+    safe_env = _env.build_agent_env(provider=_provider)
 
     text_parts: list[str] = []
     result_holder: dict[str, Any] = {

{claude_code_generator-0.4.12 → claude_code_generator-0.4.14}/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 == []
 
 
 # ---------------------------------------------------------------------------