claude-code-generator 0.4.6__tar.gz → 0.4.8__tar.gz

{claude_code_generator-0.4.6/src/claude_code_generator.egg-info → claude_code_generator-0.4.8}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.6
+Version: 0.4.8
 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.6 → claude_code_generator-0.4.8}/src/code_generator/__init__.py

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

{claude_code_generator-0.4.6 → claude_code_generator-0.4.8}/src/code_generator/commands/generate.py

@@ -396,19 +396,20 @@ def generate_ollama_command(
 
     state_path = cg_dir / "state.json"
 
-    # (1) Strip any stray ANTHROPIC_* vars from the parent process env so the
-    # Ollama bypass runs without forcing the operator to `unset` them in their
-    # shell. Safe here because the scoped env pins ANTHROPIC_BASE_URL to
-    # localhost — no traffic can reach Anthropic.
+    # (1) Strip any stray ANTHROPIC_* vars from the parent process env AND
+    # install the scoped Ollama routing (ANTHROPIC_AUTH_TOKEN + BASE_URL +
+    # empty API_KEY) into os.environ so every in-process SDK session and
+    # every subprocess Claude Code spawns inherits the localhost daemon.
+    # Without this install step Claude Code rejects non-Claude model tags
+    # (e.g. ``glm-5.1:cloud``) — see the 0.4.8 fix.
     env.assert_safe_environment_ollama()
 
     # (2) Ollama preflight — cheap env-var checks then live-daemon probe.
     _run_ollama_preflight_or_exit()
 
-    # (3) Build the scoped Ollama env — validates the #215 preconditions.
-    # We don't pass the dict further; we just confirm the env builds without
-    # raising. The orchestrator reads OLLAMA_API_KEY / ANTHROPIC_BASE_URL
-    # when it actually spawns SDK sessions.
+    # (3) Re-validate the #215 preconditions defensively. The returned dict is
+    # intentionally discarded — the SDK and subprocess runners now inherit the
+    # Ollama routing from os.environ (installed above in step 1).
     env.build_agent_env(provider="ollama")
 
     # (3) Resolve the effective model. --model wins; on --continue without it,

{claude_code_generator-0.4.6 → claude_code_generator-0.4.8}/src/code_generator/effort.py

@@ -101,10 +101,14 @@ _OPUS_ONLY_EFFORTS: frozenset[str] = frozenset({"xhigh", "max"})
 
 
 def validate_effort(effort: str | None, model: str) -> None:
-    """Raise ValueError when an Opus-only effort is paired with a non-Opus model.
+    """Raise ValueError when an Opus-only effort is paired with a non-Opus Claude model.
 
     ``xhigh`` and ``max`` are gated to Opus 4.7+ (introduced in 4.7); Sonnet
-    and Haiku do not expose them.
+    and Haiku do not expose them. The constraint only applies to Anthropic
+    Claude models (IDs prefixed with ``"claude-"``); for other model families
+    — notably the Ollama single-model codepath (#218), which accepts tags like
+    ``"glm-5.1:cloud"`` or ``"llama3.2:3b"`` — the effort flag is advisory and
+    validation is skipped.
 
     Parameters
     ----------
@@ -112,8 +116,11 @@ def validate_effort(effort: str | None, model: str) -> None:
         Effort level string (``"low"`` / ``"medium"`` / ``"high"`` / ``"xhigh"``
         / ``"max"``), or ``None`` (no-op).
     model:
-        Anthropic model ID (e.g. ``"claude-opus-4-7"``).
+        Anthropic Claude model ID (e.g. ``"claude-opus-4-7"``) or a non-Claude
+        tag (Ollama, etc.). Non-Claude tags are not validated.
     """
+    if not model.startswith("claude-"):
+        return
     if effort in _OPUS_ONLY_EFFORTS and model != _OPUS_MODEL:
         raise ValueError(f"effort={effort!r} is only allowed with {_OPUS_MODEL!r}, got {model!r}.")
 

{claude_code_generator-0.4.6 → claude_code_generator-0.4.8}/src/code_generator/env.py

@@ -39,8 +39,19 @@ OLLAMA_BASE_URL = "http://localhost:11434"
 
 
 def strip_dangerous_env() -> None:
-    """Remove every dangerous variable from the current process environment."""
+    """Remove every dangerous variable from the current process environment.
+
+    When ``ANTHROPIC_BASE_URL`` points at a ``http://localhost:*`` endpoint
+    (the Ollama single-model codepath — see #218), ``ANTHROPIC_AUTH_TOKEN`` is
+    preserved so the scoped Ollama routing installed by
+    :func:`assert_safe_environment_ollama` survives per-SDK-run strip calls
+    (``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()
     for var in DANGEROUS_VARS:
+        if var in protected:
+            continue
         os.environ.pop(var, None)
 
 
@@ -71,8 +82,17 @@ def build_agent_env(provider: Provider = "anthropic-max") -> dict[str, str]:
 
 
 def _build_anthropic_max_env() -> dict[str, str]:
-    """Strip DANGEROUS_VARS — the default Anthropic Max subscription path."""
-    return {k: v for k, v in os.environ.items() if k not in DANGEROUS_VARS}
+    """Strip DANGEROUS_VARS — the default Anthropic Max subscription path.
+
+    When ``ANTHROPIC_BASE_URL`` in the parent env points at ``http://localhost:*``
+    (the Ollama single-model codepath, #218), ``ANTHROPIC_AUTH_TOKEN`` is
+    preserved in the returned dict so the subprocess inherits the Ollama
+    auth token. This keeps the default subprocess-runner codepath usable for
+    Ollama without threading a ``provider`` argument through every runner.
+    """
+    ollama_mode = _is_localhost_base_url(os.environ.get("ANTHROPIC_BASE_URL"))
+    protected = {"ANTHROPIC_AUTH_TOKEN"} if ollama_mode else set()
+    return {k: v for k, v in os.environ.items() if k not in DANGEROUS_VARS or k in protected}
 
 
 def _build_ollama_env() -> dict[str, str]:
@@ -247,24 +267,44 @@ def assert_safe_environment() -> None:
 
 
 def assert_safe_environment_ollama() -> None:
-    """Strip Anthropic env vars before the Ollama bypass runs.
+    """Strip Anthropic env vars and install the scoped Ollama routing in place.
 
     Mirrors :func:`assert_safe_environment` for the Ollama codepath: the user
     does not have to ``unset ANTHROPIC_API_KEY`` in their shell. An Anthropic
     credential in the parent env is not a safety hazard here — the scoped
     Ollama env pins ``ANTHROPIC_BASE_URL`` to ``http://localhost:11434`` and
     re-authenticates with ``OLLAMA_API_KEY``, so no traffic reaches Anthropic.
-    The in-place strip is defensive: any incidental subprocess that does not
-    route through :func:`build_agent_env` still inherits a clean env.
+
+    When ``OLLAMA_API_KEY`` is already present and ``ANTHROPIC_BASE_URL`` is
+    unset (or already pinned to localhost), ``ANTHROPIC_AUTH_TOKEN``,
+    ``ANTHROPIC_BASE_URL``, and ``ANTHROPIC_API_KEY=""`` are written back
+    into ``os.environ`` so every in-process SDK session and every subprocess
+    Claude Code spawns inherits the Ollama routing. Without this install
+    step, the SDK rejects non-Claude model tags (e.g. ``glm-5.1:cloud``)
+    with *"There's an issue with the selected model"* — see the 0.4.8 fix.
+
+    Missing or mismatched preconditions are **not** raised here; the
+    downstream :func:`~code_generator.preflight.run_ollama_preflight` +
+    :func:`build_agent_env` pair produce the user-facing error messages
+    (with ``fix_command`` hints). Raising from this function would bypass
+    those surfaces.
     """
     offenders = [var for var in DANGEROUS_VARS if var in os.environ]
-    if not offenders:
+    if offenders:
+        listed = ", ".join(offenders)
+        print(
+            f"Using Ollama daemon at {OLLAMA_BASE_URL} (ignoring {listed} for this process).",
+            file=sys.stderr,
+        )
+        strip_dangerous_env()
+
+    token = os.environ.get("OLLAMA_API_KEY", "")
+    preset_base = os.environ.get("ANTHROPIC_BASE_URL")
+    if not token:
+        return
+    if preset_base and preset_base != OLLAMA_BASE_URL:
         return
 
-    listed = ", ".join(offenders)
-    print(
-        f"Using Ollama daemon at {OLLAMA_BASE_URL} "
-        f"(ignoring {listed} for this process).",
-        file=sys.stderr,
-    )
-    strip_dangerous_env()
+    os.environ["ANTHROPIC_AUTH_TOKEN"] = token
+    os.environ["ANTHROPIC_BASE_URL"] = OLLAMA_BASE_URL
+    os.environ["ANTHROPIC_API_KEY"] = ""

{claude_code_generator-0.4.6 → claude_code_generator-0.4.8}/tests/test_effort.py

@@ -205,6 +205,25 @@ def test_validate_effort_none_always_passes(model: str) -> None:
     validate_effort(None, model)  # must not raise
 
 
+@pytest.mark.parametrize(
+    ("effort", "model"),
+    [
+        ("xhigh", "glm-5.1:cloud"),
+        ("max", "llama3.2:3b"),
+        ("xhigh", "qwen2.5:7b"),
+        ("max", "mistral:latest"),
+    ],
+)
+def test_validate_effort_non_claude_models_skip_validation(effort: str, model: str) -> None:
+    """Opus-only effort levels are no-ops for non-Claude models (Ollama path, #218).
+
+    The XHIGH / MAX ceiling only makes sense against Anthropic Claude models;
+    Ollama tags like ``glm-5.1:cloud`` do not expose the effort concept, so
+    ``validate_effort`` must not raise for them.
+    """
+    validate_effort(effort, model)  # must not raise
+
+
 # ---------------------------------------------------------------------------
 # InvalidEffortInput guard — empty complexity in phases that depend on Phase 0
 # ---------------------------------------------------------------------------

{claude_code_generator-0.4.6 → claude_code_generator-0.4.8}/tests/test_env.py

@@ -35,12 +35,29 @@ class TestStripDangerousEnv:
         """strip_dangerous_env removes every DANGEROUS_VAR that is present."""
         for var in DANGEROUS_VARS:
             monkeypatch.setenv(var, "value")
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
 
         strip_dangerous_env()
 
         for var in DANGEROUS_VARS:
             assert var not in os.environ
 
+    def test_preserves_auth_token_on_localhost_base_url(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """ANTHROPIC_AUTH_TOKEN survives strip when BASE_URL points at localhost (Ollama)."""
+        for var in DANGEROUS_VARS:
+            monkeypatch.delenv(var, raising=False)
+        monkeypatch.setenv("ANTHROPIC_AUTH_TOKEN", "ollama-token")
+        monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-evil")
+        monkeypatch.setenv("ANTHROPIC_BASE_URL", "http://localhost:11434")
+
+        strip_dangerous_env()
+
+        # AUTH_TOKEN preserved; API_KEY still stripped.
+        assert os.environ.get("ANTHROPIC_AUTH_TOKEN") == "ollama-token"
+        assert "ANTHROPIC_API_KEY" not in os.environ
+
     def test_no_error_when_vars_absent(self, monkeypatch: pytest.MonkeyPatch) -> None:
         """strip_dangerous_env must not raise when vars are not present."""
         for var in DANGEROUS_VARS:
@@ -64,6 +81,7 @@ class TestBuildAgentEnv:
         """build_agent_env returns a copy with no dangerous vars."""
         for var in DANGEROUS_VARS:
             monkeypatch.setenv(var, "should-be-stripped")
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
 
         env = build_agent_env()
 
@@ -134,6 +152,7 @@ class TestAssertSafeEnvironment:
 
     def test_strips_each_dangerous_var(self, monkeypatch: pytest.MonkeyPatch) -> None:
         """assert_safe_environment strips any individual dangerous var."""
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
         for dangerous_var in DANGEROUS_VARS:
             for v in DANGEROUS_VARS:
                 monkeypatch.delenv(v, raising=False)
@@ -144,25 +163,34 @@ class TestAssertSafeEnvironment:
 
 
 class TestAssertSafeEnvironmentOllama:
-    """The Ollama bypass auto-strips parent ANTHROPIC_* vars instead of refusing."""
+    """The Ollama bypass auto-strips parent ANTHROPIC_* vars then installs scoped routing."""
 
-    def test_passes_when_no_dangerous_vars(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        """assert_safe_environment_ollama is silent when env is already clean."""
+    def test_installs_auth_token_and_base_url(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        """assert_safe_environment_ollama installs the Ollama routing into os.environ."""
         for var in DANGEROUS_VARS:
             monkeypatch.delenv(var, raising=False)
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
+        monkeypatch.setenv("OLLAMA_API_KEY", "ollama-token-xyz")
 
-        assert_safe_environment_ollama()  # must not raise
+        assert_safe_environment_ollama()
+
+        assert os.environ["ANTHROPIC_AUTH_TOKEN"] == "ollama-token-xyz"
+        assert os.environ["ANTHROPIC_BASE_URL"] == OLLAMA_BASE_URL
+        assert os.environ["ANTHROPIC_API_KEY"] == ""
 
     def test_strips_anthropic_api_key(self, monkeypatch: pytest.MonkeyPatch) -> None:
         """A stray ANTHROPIC_API_KEY is stripped from os.environ instead of aborting."""
         monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-real-key")
+        monkeypatch.setenv("OLLAMA_API_KEY", "ollama-token")
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
         for var in DANGEROUS_VARS:
             if var != "ANTHROPIC_API_KEY":
                 monkeypatch.delenv(var, raising=False)
 
         assert_safe_environment_ollama()
 
-        assert "ANTHROPIC_API_KEY" not in os.environ
+        # API_KEY is rewritten to "", not preserved as "sk-real-key".
+        assert os.environ.get("ANTHROPIC_API_KEY") == ""
 
     def test_warning_mentions_localhost_daemon(
         self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
@@ -170,6 +198,8 @@ class TestAssertSafeEnvironmentOllama:
         """The printed warning names the Ollama daemon and the offending vars."""
         monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-abc")
         monkeypatch.setenv("ANTHROPIC_AUTH_TOKEN", "tok")
+        monkeypatch.setenv("OLLAMA_API_KEY", "ollama-token")
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
         for var in DANGEROUS_VARS:
             if var not in ("ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"):
                 monkeypatch.delenv(var, raising=False)
@@ -181,15 +211,32 @@ class TestAssertSafeEnvironmentOllama:
         assert "ANTHROPIC_API_KEY" in captured.err
         assert "ANTHROPIC_AUTH_TOKEN" in captured.err
 
-    def test_strips_every_dangerous_var(self, monkeypatch: pytest.MonkeyPatch) -> None:
-        """assert_safe_environment_ollama strips any individual dangerous var."""
-        for dangerous_var in DANGEROUS_VARS:
-            for v in DANGEROUS_VARS:
-                monkeypatch.delenv(v, raising=False)
+    def test_skips_install_when_ollama_api_key_missing(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Without OLLAMA_API_KEY the installer silently skips — preflight surfaces the error."""
+        for var in DANGEROUS_VARS:
+            monkeypatch.delenv(var, raising=False)
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
+        monkeypatch.delenv("OLLAMA_API_KEY", raising=False)
 
-            monkeypatch.setenv(dangerous_var, "present")
-            assert_safe_environment_ollama()
-            assert dangerous_var not in os.environ
+        assert_safe_environment_ollama()  # must not raise
+
+        assert "ANTHROPIC_AUTH_TOKEN" not in os.environ
+
+    def test_skips_install_when_base_url_points_off_host(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Off-host ANTHROPIC_BASE_URL is left alone — preflight raises the user-facing error."""
+        for var in DANGEROUS_VARS:
+            monkeypatch.delenv(var, raising=False)
+        monkeypatch.setenv("OLLAMA_API_KEY", "ollama-token")
+        monkeypatch.setenv("ANTHROPIC_BASE_URL", "http://evil.example.com")
+
+        assert_safe_environment_ollama()  # must not raise
+
+        assert os.environ["ANTHROPIC_BASE_URL"] == "http://evil.example.com"
+        assert "ANTHROPIC_AUTH_TOKEN" not in os.environ
 
 
 class TestAssertSingleWorkspace:
@@ -201,8 +248,11 @@ class TestAssertSingleWorkspace:
 
         assert_single_workspace(probe=probe)  # must not raise
 
-    def test_two_workspace_mock_raises_workspace_mismatch_error(self) -> None:
+    def test_two_workspace_mock_raises_workspace_mismatch_error(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
         """Two-workspace probe must raise WorkspaceMismatchError with workspace names."""
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
 
         def probe() -> frozenset[str]:
             return frozenset({"ws-a", "ws-b"})
@@ -215,9 +265,10 @@ class TestAssertSingleWorkspace:
         assert issubclass(WorkspaceMismatchError, RuntimeError)
 
     def test_sdk_without_probe_logs_info_exactly_once(
-        self, caplog: pytest.LogCaptureFixture
+        self, caplog: pytest.LogCaptureFixture, monkeypatch: pytest.MonkeyPatch
     ) -> None:
         """When probe returns None (SDK lacks workspace probe), logs INFO exactly once."""
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
 
         def probe() -> None:
             return None
@@ -261,6 +312,7 @@ class TestBuildAgentEnvAnthropicMaxProvider:
         """build_agent_env() without provider kwarg uses anthropic-max."""
         for var in DANGEROUS_VARS:
             monkeypatch.setenv(var, "value")
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
 
         env = build_agent_env()  # no kwarg
 
@@ -271,12 +323,27 @@ class TestBuildAgentEnvAnthropicMaxProvider:
         """Explicit provider="anthropic-max" behaves identically to the default."""
         for var in DANGEROUS_VARS:
             monkeypatch.setenv(var, "value")
+        monkeypatch.delenv("ANTHROPIC_BASE_URL", raising=False)
 
         env = build_agent_env(provider="anthropic-max")
 
         for var in DANGEROUS_VARS:
             assert var not in env
 
+    def test_anthropic_max_preserves_auth_token_on_localhost_base_url(
+        self, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """When BASE_URL points at localhost (Ollama codepath), AUTH_TOKEN survives."""
+        for var in DANGEROUS_VARS:
+            monkeypatch.delenv(var, raising=False)
+        monkeypatch.setenv("ANTHROPIC_AUTH_TOKEN", "ollama-token")
+        monkeypatch.setenv("ANTHROPIC_BASE_URL", "http://localhost:11434")
+
+        env = build_agent_env(provider="anthropic-max")
+
+        assert env.get("ANTHROPIC_AUTH_TOKEN") == "ollama-token"
+        assert env.get("ANTHROPIC_BASE_URL") == "http://localhost:11434"
+
     def test_anthropic_max_preserves_unrelated_vars(self, monkeypatch: pytest.MonkeyPatch) -> None:
         """anthropic-max path leaves unrelated env vars intact."""
         monkeypatch.setenv("PATH", "/usr/bin")
@@ -338,9 +405,7 @@ class TestBuildAgentEnvOllamaProvider:
 
         assert env["ANTHROPIC_AUTH_TOKEN"] == "ollama-wins"
 
-    def test_ollama_ignores_parent_anthropic_api_key(
-        self, monkeypatch: pytest.MonkeyPatch
-    ) -> None:
+    def test_ollama_ignores_parent_anthropic_api_key(self, monkeypatch: pytest.MonkeyPatch) -> None:
         """provider=ollama rewrites ANTHROPIC_API_KEY="" regardless of parent value.
 
         The builder strips every ANTHROPIC_* var from the returned dict and pins