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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.13
+Version: 0.4.15
 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.13 → claude_code_generator-0.4.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-code-generator"
-version = "0.4.13"
+version = "0.4.15"
 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.13 → claude_code_generator-0.4.15/src/claude_code_generator.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.13
+Version: 0.4.15
 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.13 → claude_code_generator-0.4.15}/src/code_generator/commands/_dispatch.py

@@ -106,6 +106,7 @@ async def _apply_delta_plan(
     delta_hash: str,
     state_path: Path,
     logger: logging.Logger,
+    effective_model: str | None = None,
 ) -> int | None:
     """Run Phase 0 and merge new cycles into state for multi-cycle delta planning.
 
@@ -135,6 +136,7 @@ async def _apply_delta_plan(
         project_dir,
         runner_module=runner_module,  # type: ignore[arg-type]
         logger=logger,
+        effective_model=effective_model,
     )
 
     if raw_cycles is None:
@@ -214,6 +216,7 @@ async def dispatch_async(
             delta_hash=delta_hash,
             state_path=state_path,
             logger=logger,
+            effective_model=ollama_model,
         )
         if first_new_id is None:
             return  # No new cycles — nothing to run.

{claude_code_generator-0.4.13 → claude_code_generator-0.4.15}/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.13 → claude_code_generator-0.4.15}/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.13 → claude_code_generator-0.4.15}/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.13 → claude_code_generator-0.4.15}/src/code_generator/orchestrator/phase0_complexity.py

@@ -125,12 +125,14 @@ def _parse_json(text: str) -> dict[str, Any] | None:
         return None
 
 
-def _apply_result(state: State, output: Phase0Output) -> None:
+def _apply_result(state: State, output: Phase0Output, effective_model: str | None = None) -> None:
     """Write validated phase-0 output into *state* in place.
 
     Args:
         state: The state object to mutate.
         output: Validated :class:`Phase0Output` instance.
+        effective_model: Ollama model tag to stamp on new cycles (``None``
+            on the Anthropic Max path).
     """
     state.mode = output.mode  # type: ignore[assignment]
 
@@ -154,6 +156,7 @@ def _apply_result(state: State, output: Phase0Output) -> None:
                     )
                     for h in cycle.effort_hints
                 ],
+                ollama_model=effective_model,
             )
             for cycle in output.cycles
         ]
@@ -283,7 +286,7 @@ async def run(
 
     if data is not None:
         output = parse_phase0_output(data)
-        _apply_result(state, output)
+        _apply_result(state, output, effective_model=effective_model)
         logger.info("Phase 0: mode=%s, cycles=%d", state.mode, len(state.cycles))
         _state.save_state(state_path, state)
         if state.mode == "multi-cycle" and state.cycles:

{claude_code_generator-0.4.13 → claude_code_generator-0.4.15}/src/code_generator/orchestrator/phase1_plan.py

@@ -280,7 +280,7 @@ async def run(
             issue_labels=[],
             retry_count=0,
         )
-        _effort.validate_effort(effort_level, "claude-opus-4-7")
+        _effort.validate_effort(effort_level, effective_model or _PHASE1_DEFAULT_MODEL)
 
         options = make_agent_options(
             model=effective_model or _PHASE1_DEFAULT_MODEL,

{claude_code_generator-0.4.13 → claude_code_generator-0.4.15}/src/code_generator/orchestrator/phase2_review.py

@@ -272,7 +272,7 @@ async def run_batch(
                 REPO_MAP=repo_map,
             )
             params = {
-                "model": "claude-opus-4-7",
+                "model": effective_model or _PHASE2_DEFAULT_MODEL,
                 "max_tokens": 8192,
                 "messages": [{"role": "user", "content": prompt}],
             }

{claude_code_generator-0.4.13 → claude_code_generator-0.4.15}/src/code_generator/orchestrator/phase3_4_implement.py

@@ -108,6 +108,7 @@ def _resolve_issue_effort(
     effort_hints: list[_state.EffortHint],
     attempt: int,
     complexity: str,
+    effective_model: str | None = None,
 ) -> _effort.EffortLevel | None:
     """Resolve and validate the effort level for an issue attempt.
 
@@ -134,7 +135,7 @@ def _resolve_issue_effort(
         retry_count=attempt,
         effort_hint=effort_hint,
     )
-    _effort.validate_effort(effort_level, "claude-sonnet-4-6")
+    _effort.validate_effort(effort_level, effective_model or _PHASE3_4_DEFAULT_MODEL)
     return effort_level
 
 
@@ -243,7 +244,7 @@ async def _implement_single_issue(
         # a failure stay within the same issue; no fresh reset needed.
         if attempt == 0 and boundary_prefix:
             prompt = boundary_prefix + prompt
-        effort_level = _resolve_issue_effort(issue, effort_hints, attempt, complexity=state.mode)
+        effort_level = _resolve_issue_effort(issue, effort_hints, attempt, complexity=state.mode, effective_model=effective_model)
         options = make_agent_options(
             model=effective_model or _PHASE3_4_DEFAULT_MODEL,
             effort=effort_level,

{claude_code_generator-0.4.13 → claude_code_generator-0.4.15}/src/code_generator/orchestrator/phase5_closure.py

@@ -338,7 +338,7 @@ async def run(
     mcp_tools = mcp_tool_wildcards(mcp_servers)
 
     effort_level = _effort.resolve_effort(phase=5, complexity="", issue_labels=[], retry_count=0)
-    _effort.validate_effort(effort_level, "claude-opus-4-7")
+    _effort.validate_effort(effort_level, effective_model or _PHASE5_DEFAULT_MODEL)
 
     options = make_agent_options(
         model=effective_model or _PHASE5_DEFAULT_MODEL,

{claude_code_generator-0.4.13 → claude_code_generator-0.4.15}/src/code_generator/orchestrator/phase7_commit.py

@@ -266,7 +266,7 @@ async def run(
         issue_labels=[],
         retry_count=0,
     )
-    _effort.validate_effort(effort_level, "claude-opus-4-7")
+    _effort.validate_effort(effort_level, effective_model or _PHASE7_DEFAULT_MODEL)
 
     options = make_agent_options(
         model=effective_model or _PHASE7_DEFAULT_MODEL,

{claude_code_generator-0.4.13 → claude_code_generator-0.4.15}/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] = {