claude-code-generator 0.4.5__tar.gz → 0.4.7__tar.gz

{claude_code_generator-0.4.5/src/claude_code_generator.egg-info → claude_code_generator-0.4.7}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-generator
-Version: 0.4.5
+Version: 0.4.7
 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.5 → claude_code_generator-0.4.7}/src/claude_code_generator.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ src/code_generator/orchestrator/_comments.py
 src/code_generator/orchestrator/_memory_writers.py
 src/code_generator/orchestrator/_phase5_precommit.py
 src/code_generator/orchestrator/cycle_loop.py
+src/code_generator/orchestrator/cycle_prompts.py
 src/code_generator/orchestrator/ollama_budget.py
 src/code_generator/orchestrator/phase0_complexity.py
 src/code_generator/orchestrator/phase1_plan.py
@@ -57,9 +58,11 @@ src/code_generator/orchestrator/phase6_test.py
 src/code_generator/orchestrator/phase7_commit.py
 src/code_generator/prompts/__init__.py
 src/code_generator/prompts/hashes.py
+src/code_generator/prompts/prompt-cycle-specializer.md
 src/code_generator/prompts/prompt-optimize-requirements.md
 src/code_generator/prompts/prompt-phase-0-complexity.md
 src/code_generator/prompts/prompt-phase-1-planning.md
+src/code_generator/prompts/prompt-phase-2-batch-review.md
 src/code_generator/prompts/prompt-phase-2-issue-review.md
 src/code_generator/prompts/prompt-phase-3-implementation.md
 src/code_generator/prompts/prompt-phase-5-final-review.md
@@ -105,6 +108,7 @@ tests/test_crash_recovery.py
 tests/test_cycle_loop.py
 tests/test_cycle_loop_multicycle.py
 tests/test_cycle_ollama_model.py
+tests/test_cycle_prompts.py
 tests/test_delta_planning.py
 tests/test_dependencies.py
 tests/test_detect.py

{claude_code_generator-0.4.5 → claude_code_generator-0.4.7}/src/code_generator/__init__.py

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

{claude_code_generator-0.4.5 → claude_code_generator-0.4.7}/src/code_generator/commands/generate.py

@@ -396,10 +396,16 @@ def generate_ollama_command(
 
     state_path = cg_dir / "state.json"
 
-    # (1) Ollama preflight — cheap env-var checks then live-daemon probe.
+    # (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.
+    env.assert_safe_environment_ollama()
+
+    # (2) Ollama preflight — cheap env-var checks then live-daemon probe.
     _run_ollama_preflight_or_exit()
 
-    # (2) Build the scoped Ollama env — validates the #215 preconditions.
+    # (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.

{claude_code_generator-0.4.5 → claude_code_generator-0.4.7}/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.5 → claude_code_generator-0.4.7}/src/code_generator/env.py

@@ -96,8 +96,14 @@ def _require_ollama_preconditions() -> str:
 
     Refuses the bypass when:
       * ``OLLAMA_API_KEY`` is unset or empty.
-      * ``ANTHROPIC_API_KEY`` is non-empty in the parent env.
       * ``ANTHROPIC_BASE_URL`` is pre-set to anything other than the pinned URL.
+
+    A non-empty ``ANTHROPIC_API_KEY`` in the parent env is **not** a refusal:
+    ``_build_ollama_env`` strips every ``ANTHROPIC_*`` var from the returned
+    dict and re-pins ``ANTHROPIC_BASE_URL`` to localhost, so no traffic can
+    leak to Anthropic. Callers that want a clean parent ``os.environ`` for
+    incidental subprocesses should invoke :func:`assert_safe_environment_ollama`
+    before :func:`build_agent_env`.
     """
     token = os.environ.get("OLLAMA_API_KEY", "")
     if not token:
@@ -105,12 +111,6 @@ def _require_ollama_preconditions() -> str:
             "OLLAMA_API_KEY is unset or empty. Set it to the Ollama Pro token "
             "before running with provider='ollama'."
         )
-    if os.environ.get("ANTHROPIC_API_KEY", ""):
-        raise RuntimeError(
-            "ANTHROPIC_API_KEY is set in the parent env. The Ollama bypass "
-            "refuses to run when Anthropic credentials are present to prevent "
-            "accidental API-credit spend."
-        )
     preset_base = os.environ.get("ANTHROPIC_BASE_URL")
     if preset_base and preset_base != OLLAMA_BASE_URL:
         raise RuntimeError(
@@ -244,3 +244,27 @@ def assert_safe_environment() -> None:
         file=sys.stderr,
     )
     strip_dangerous_env()
+
+
+def assert_safe_environment_ollama() -> None:
+    """Strip Anthropic env vars before the Ollama bypass runs.
+
+    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.
+    """
+    offenders = [var for var in DANGEROUS_VARS if var in os.environ]
+    if not offenders:
+        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()

{claude_code_generator-0.4.5 → claude_code_generator-0.4.7}/src/code_generator/gh/__init__.py

@@ -24,6 +24,7 @@ from code_generator.gh.issues import (
     agent_from_labels,
     issue_state,
     list_issues,
+    post_comment,
     view_issue,
 )
 from code_generator.gh.labels import add_label, ensure_label, ensure_standard_labels
@@ -39,6 +40,7 @@ __all__ = [
     "agent_from_labels",
     "issue_state",
     "list_issues",
+    "post_comment",
     "view_issue",
     "add_label",
     "ensure_label",

{claude_code_generator-0.4.5 → claude_code_generator-0.4.7}/src/code_generator/gh/issues.py

@@ -79,6 +79,23 @@ def list_issues(
     return json.loads(raw)  # type: ignore[no-any-return]
 
 
+def post_comment(repo: RepoInfo, number: int, body: str) -> None:
+    """Post a comment on an issue via the ``gh`` CLI.
+
+    Args:
+        repo: Repository to target (provides ``--repo`` flag and ``GH_HOST`` env).
+        number: Issue number.
+        body: Markdown comment body.
+
+    Raises:
+        GhError: When the underlying ``gh issue comment`` invocation fails.
+    """
+    _run(
+        ["gh", "issue", "comment", str(number), "--repo", repo.full, "--body", body],
+        env={"GH_HOST": repo.host},
+    )
+
+
 def issue_state(repo: RepoInfo, number: int) -> str:
     """Return the issue state as a lowercase string (``"open"`` or ``"closed"``)."""
     raw = _run(

claude_code_generator-0.4.7/src/code_generator/orchestrator/cycle_prompts.py

@@ -0,0 +1,267 @@
+"""Per-cycle specialized prompt generation.
+
+After Phase 0 populates ``state.cycles`` the orchestrator calls
+:func:`generate_cycle_prompts` once to materialise one specialized markdown
+prompt per cycle under ``.code-generator/cycles_prompts/<requirements_hash>/``.
+
+Each per-cycle file gives the downstream planning session (Phase 1) the
+cycle's concrete objective together with the overall project vision and
+pointers to preceding/following cycles, so milestones do not become
+context-free silos.
+
+The generator is idempotent: when every ``cycle_<id>.md`` file already
+exists for the current hash, the function is a no-op, which makes
+``--continue`` safe.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from code_generator.prompts import load_prompt
+from code_generator.runner import rate_limit
+from code_generator.runner.options import make_agent_options, max_turns_kwargs
+from code_generator.state import CycleState
+
+if TYPE_CHECKING:
+    import logging
+
+    from code_generator.runner.protocol import RunnerProtocol
+    from code_generator.state import State
+
+
+_SPECIALIZER_DEFAULT_MODEL = "claude-opus-4-7"
+# CLAUDE.md invariant #8; overridden via ``effective_model`` on Ollama — #219.
+
+
+class CyclePromptGenerationError(RuntimeError):
+    """Raised when the cycle-specializer prompt cannot produce a valid output.
+
+    The caller (Phase 0) catches this and falls back to inlining the raw
+    requirements into Phase 1's volatile context.
+    """
+
+
+def cycles_prompts_dir(project_dir: Path, requirements_hash: str) -> Path:
+    """Return the directory that holds per-cycle specialized prompts.
+
+    Args:
+        project_dir: Project root (the same path used for ``state.json``).
+        requirements_hash: SHA-256 hex digest of the canonical requirements.
+
+    Returns:
+        ``<project_dir>/.code-generator/cycles_prompts/<requirements_hash>/``.
+    """
+    return project_dir / ".code-generator" / "cycles_prompts" / requirements_hash
+
+
+def _cycle_file(project_dir: Path, requirements_hash: str, cycle_id: int) -> Path:
+    return cycles_prompts_dir(project_dir, requirements_hash) / f"cycle_{cycle_id}.md"
+
+
+def is_generated(
+    project_dir: Path,
+    requirements_hash: str,
+    cycle_ids: list[int],
+) -> bool:
+    """Return True when every ``cycle_<id>.md`` already exists for this hash.
+
+    An empty ``cycle_ids`` list returns ``True`` — there is nothing to generate.
+
+    Args:
+        project_dir: Project root directory.
+        requirements_hash: SHA-256 hex digest of the canonical requirements.
+        cycle_ids: IDs of the cycles that must have a generated prompt.
+    """
+    folder = cycles_prompts_dir(project_dir, requirements_hash)
+    if not folder.is_dir():
+        return False
+    return all(_cycle_file(project_dir, requirements_hash, cid).is_file() for cid in cycle_ids)
+
+
+def load_cycle_prompt(project_dir: Path, requirements_hash: str, cycle_id: int) -> str:
+    """Read a previously-generated per-cycle prompt.
+
+    Args:
+        project_dir: Project root directory.
+        requirements_hash: SHA-256 hex digest of the canonical requirements.
+        cycle_id: Cycle id whose specialized prompt is requested.
+
+    Returns:
+        The raw markdown contents, suitable for verbatim injection into the
+        Phase 1 prompt's volatile-context block.
+
+    Raises:
+        FileNotFoundError: When the file is missing (the caller must handle
+            the fallback path — typically inlining the raw requirements).
+    """
+    path = _cycle_file(project_dir, requirements_hash, cycle_id)
+    return path.read_text(encoding="utf-8")
+
+
+def _cycles_as_json(state: State) -> str:
+    """Serialize full cycles in *state* to a JSON string for prompt injection."""
+    cycles: list[dict[str, Any]] = []
+    for cycle in state.cycles:
+        if not isinstance(cycle, CycleState):
+            continue
+        cycles.append(
+            {
+                "id": cycle.id,
+                "name": cycle.name,
+                "milestone_title": cycle.milestone_title,
+                "scope": cycle.scope,
+                "depends_on": list(cycle.depends_on),
+            }
+        )
+    return json.dumps(cycles, indent=2)
+
+
+def _atomic_write(path: Path, content: str) -> None:
+    """Write *content* to *path* via a sibling ``.tmp`` file + os.replace.
+
+    Mirrors the pattern used by :func:`code_generator.state.save_state`.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = Path(str(path) + ".tmp")
+    tmp.write_text(content, encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def _parse_specializer_output(text: str, expected_ids: list[int]) -> dict[int, str]:
+    """Extract the ``{"cycle_N": "..."}`` JSON object from *text*.
+
+    Tolerates prose wrapping the JSON (the model occasionally adds a fenced
+    code block even under strict instructions). The first ``{`` and last
+    ``}`` delimit the candidate JSON object.
+
+    Args:
+        text: Raw text returned by the specializer call.
+        expected_ids: The cycle IDs that must appear as ``cycle_<id>`` keys.
+
+    Returns:
+        Mapping of cycle id → markdown briefing.
+
+    Raises:
+        CyclePromptGenerationError: On parse failure, on missing keys, or on
+            non-string values.
+    """
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end < start:
+        raise CyclePromptGenerationError("no JSON object found in specializer output")
+    try:
+        raw = json.loads(text[start : end + 1])
+    except json.JSONDecodeError as exc:
+        raise CyclePromptGenerationError(f"specializer output is not valid JSON: {exc}") from exc
+    if not isinstance(raw, dict):
+        raise CyclePromptGenerationError(
+            f"specializer output is not a JSON object (got {type(raw).__name__})"
+        )
+
+    out: dict[int, str] = {}
+    for cid in expected_ids:
+        key = f"cycle_{cid}"
+        value = raw.get(key)
+        if not isinstance(value, str) or not value.strip():
+            raise CyclePromptGenerationError(f"specializer output missing or empty key {key!r}")
+        out[cid] = value
+    return out
+
+
+async def generate_cycle_prompts(
+    project_dir: Path,
+    state: State,
+    *,
+    runner_module: RunnerProtocol,
+    logger: logging.Logger,
+    max_turns: int | None = None,
+    effective_model: str | None = None,
+) -> None:
+    """Generate one specialized markdown prompt per cycle in *state*.
+
+    Single Opus 4.7 call emits ``{"cycle_1": "...", ...}``; each value is
+    written atomically to ``.code-generator/cycles_prompts/<hash>/cycle_<id>.md``.
+
+    The call is skipped entirely when every target file already exists for
+    the current ``state.requirements_hash`` — this is what makes
+    ``--continue`` a no-op on the second run.
+
+    Args:
+        project_dir: Project root directory.
+        state: Root state (must have ``requirements_hash`` set and
+            ``cycles`` populated by Phase 0).
+        runner_module: Runner module from ``get_runner()``.
+        logger: Phase logger (typically the Phase 0 logger).
+        max_turns: Optional debugging override; production callers leave ``None``.
+        effective_model: Optional Ollama tag override. When ``None`` the call
+            uses ``claude-opus-4-7``.
+
+    Raises:
+        CyclePromptGenerationError: On any failure — no partial files are left
+            behind (each file is written via ``tmp → os.replace`` only after
+            the JSON has been fully parsed).
+    """
+    if state.requirements_hash is None:
+        raise CyclePromptGenerationError(
+            "state.requirements_hash is unset — cannot generate specialized prompts"
+        )
+
+    cycle_ids = [c.id for c in state.cycles if isinstance(c, CycleState)]
+    if not cycle_ids:
+        logger.info("cycle-prompts: no cycles to specialize — skipping.")
+        return
+
+    if is_generated(project_dir, state.requirements_hash, cycle_ids):
+        logger.info(
+            "cycle-prompts: %d per-cycle prompts already exist at %s — skipping generation.",
+            len(cycle_ids),
+            cycles_prompts_dir(project_dir, state.requirements_hash),
+        )
+        return
+
+    requirements_path = project_dir / ".code-generator" / "requirements.md"
+    requirements_content = requirements_path.read_text(encoding="utf-8")
+    cycles_json = _cycles_as_json(state)
+
+    prompt = load_prompt(
+        "prompt-cycle-specializer.md",
+        REQUIREMENTS_CONTENT=requirements_content,
+        CYCLES_JSON=cycles_json,
+    )
+
+    model = effective_model or _SPECIALIZER_DEFAULT_MODEL
+    options = make_agent_options(
+        model=model,
+        allowed_tools=[],
+        cwd=str(project_dir),
+        **max_turns_kwargs(max_turns),
+    )
+
+    state_path = project_dir / ".code-generator" / "state.json"
+    logger.info(
+        "cycle-prompts: generating %d specialized prompts (model=%s).", len(cycle_ids), model
+    )
+    result = await rate_limit.main_loop(
+        runner_module,
+        prompt,
+        options,
+        state_path=state_path,
+        logger=logger,
+    )
+
+    briefings = _parse_specializer_output(result.text, cycle_ids)
+
+    for cid in cycle_ids:
+        _atomic_write(
+            _cycle_file(project_dir, state.requirements_hash, cid),
+            briefings[cid],
+        )
+    logger.info(
+        "cycle-prompts: wrote %d files under %s.",
+        len(cycle_ids),
+        cycles_prompts_dir(project_dir, state.requirements_hash),
+    )

{claude_code_generator-0.4.5 → claude_code_generator-0.4.7}/src/code_generator/orchestrator/phase0_complexity.py

@@ -17,6 +17,7 @@ from code_generator import effort as _effort
 from code_generator import memory as _memory
 from code_generator import state as _state
 from code_generator.logging_setup import log_phase_usage, setup_phase_logger
+from code_generator.orchestrator import cycle_prompts as _cycle_prompts
 from code_generator.prompts import load_prompt
 from code_generator.runner import rate_limit
 from code_generator.runner.options import make_agent_options, max_turns_kwargs
@@ -285,6 +286,22 @@ async def run(
         _apply_result(state, output)
         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:
+            try:
+                await _cycle_prompts.generate_cycle_prompts(
+                    project_dir,
+                    state,
+                    runner_module=runner_module,
+                    logger=logger,
+                    max_turns=max_turns,
+                    effective_model=effective_model,
+                )
+            except _cycle_prompts.CyclePromptGenerationError as exc:
+                logger.warning(
+                    "cycle-prompts: generation failed (%s); "
+                    "Phase 1 will fall back to raw requirements.",
+                    exc,
+                )
         return state
 
     # All retries exhausted — safe fallback.

{claude_code_generator-0.4.5 → claude_code_generator-0.4.7}/src/code_generator/orchestrator/phase1_plan.py

@@ -15,6 +15,7 @@ from code_generator import gh
 from code_generator import memory as _memory
 from code_generator import state as _state
 from code_generator.logging_setup import log_phase_usage, setup_phase_logger
+from code_generator.orchestrator import cycle_prompts as _cycle_prompts
 from code_generator.prompts import load_prompt
 from code_generator.runner import rate_limit
 from code_generator.runner._telemetry import accumulate_telemetry
@@ -115,6 +116,46 @@ _PHASE1_DEFAULT_MODEL = "claude-opus-4-7"
 # CLAUDE.md invariant #8; overridden via ``effective_model`` on Ollama — #219.
 
 
+def _load_specialized_prompt(
+    project_dir: Path,
+    state: State,
+    cycle: CycleState | None,
+) -> str:
+    """Return the cycle-specialized briefing, or a raw-requirements fallback.
+
+    The preferred path reads
+    ``.code-generator/cycles_prompts/<requirements_hash>/cycle_<id>.md`` —
+    materialised by :mod:`code_generator.orchestrator.cycle_prompts` at the
+    end of Phase 0 for multi-cycle runs.
+
+    The fallback wraps ``.code-generator/requirements.md`` in a ``## Requirements``
+    section so the downstream prompt never collapses into an empty volatile
+    context block. The fallback fires in three cases:
+
+    - Single-cycle mode (no ``cycle`` object is in scope).
+    - Multi-cycle mode where ``requirements_hash`` is unset (should not happen
+      in production but is handled defensively).
+    - The specialized file is missing — e.g. the specializer call raised
+      :class:`~code_generator.orchestrator.cycle_prompts.CyclePromptGenerationError`
+      and Phase 0 swallowed the error.
+    """
+    requirements_path = project_dir / ".code-generator" / "requirements.md"
+
+    if state.mode == "multi-cycle" and cycle is not None and state.requirements_hash is not None:
+        try:
+            return _cycle_prompts.load_cycle_prompt(project_dir, state.requirements_hash, cycle.id)
+        except FileNotFoundError:
+            pass
+
+    try:
+        requirements_content = requirements_path.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        # In production the file always exists (optimize/init guarantee it); this
+        # branch keeps unit tests green when they do not stage the file on disk.
+        return f"- **Requirements path:** {requirements_path}"
+    return f"## Requirements\n\n{requirements_content}"
+
+
 async def run(
     state: State,
     cycle: CycleState | None,
@@ -180,7 +221,7 @@ async def run(
         repo_map = _memory.read_cycle_repomap(memories_dir)
         prompt = load_prompt(
             "prompt-phase-1-planning.md",
-            REQUIREMENTS_PATH=".code-generator/requirements.md",
+            CYCLE_SPECIALIZED_PROMPT=_load_specialized_prompt(project_dir, state, cycle),
             CYCLE_SCOPE=(
                 cycle.scope
                 if cycle is not None