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

{claude_code_generator-0.4.13/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.13
+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.13 → 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.13"
+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.13 → 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.13
+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.13 → 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.13 → 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.13 → 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.13 → 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] = {