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

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

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

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

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

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

{claude_code_generator-0.4.11 → claude_code_generator-0.4.12}/src/code_generator/orchestrator/phase1_plan.py

@@ -116,6 +116,47 @@ _PHASE1_DEFAULT_MODEL = "claude-opus-4-7"
 # CLAUDE.md invariant #8; overridden via ``effective_model`` on Ollama — #219.
 
 
+_PHASE1_MAX_ATTEMPTS = 3
+"""Max planning attempts before surfacing ``Phase1NoIssuesError`` (0.4.12).
+
+Weak open models on the Ollama codepath often respond with prose describing
+the plan instead of invoking ``gh issue create`` via the Bash tool. A single
+stricter re-prompt is usually enough to unblock them without operator
+intervention.
+"""
+
+
+_PHASE1_RETRY_NUDGE = (
+    "Your previous attempt finished without creating any GitHub issues. "
+    "This is a CRITICAL failure. You MUST use the Bash tool to invoke "
+    "`gh issue create` for each issue right now. Do NOT output markdown "
+    "or prose describing the plan — every planned issue must become a "
+    "real GitHub issue via `gh issue create ... --milestone "
+    '"{MILESTONE}" --assignee @me --label "..."`. Once you have called '
+    "`gh issue create` for every planned issue, print a one-line summary "
+    "per issue and stop.\n\n"
+    "The original instructions follow.\n\n"
+)
+
+
+def _accumulate_usage(
+    total: _state.TokenUsage | None,
+    delta: _state.TokenUsage,
+) -> _state.TokenUsage:
+    """Sum two TokenUsage records field-by-field across Phase 1 attempts."""
+    from code_generator.runner.types import TokenUsage
+
+    if total is None:
+        return delta
+    return TokenUsage(
+        input=total.input + delta.input,
+        output=total.output + delta.output,
+        cache_read=total.cache_read + delta.cache_read,
+        cache_write=total.cache_write + delta.cache_write,
+        num_turns=total.num_turns + delta.num_turns,
+    )
+
+
 def _load_specialized_prompt(
     project_dir: Path,
     state: State,
@@ -249,28 +290,56 @@ async def run(
             **max_turns_kwargs(max_turns),
         )
 
-        result = await rate_limit.main_loop(
-            runner_module,
-            prompt,
-            options,
-            state_path=state_path,
-            logger=logger,
-        )
+        # Up to _PHASE1_MAX_ATTEMPTS attempts: the first with the normal
+        # prompt, subsequent attempts prefixed with a stricter nudge that
+        # tells the model to use the Bash tool to call ``gh issue create``
+        # right now. Weak open models on the Ollama codepath commonly
+        # respond with prose on the first turn; the nudge recovers most
+        # of those cases without operator intervention (0.4.12).
+        issue_states: list[_state.IssueState] = []
+        total_usage = result = None  # type: ignore[assignment]
+        attempt_prompt = prompt
+        effective_model_name = effective_model or _PHASE1_DEFAULT_MODEL
+        for attempt in range(1, _PHASE1_MAX_ATTEMPTS + 1):
+            result = await rate_limit.main_loop(
+                runner_module,
+                attempt_prompt,
+                options,
+                state_path=state_path,
+                logger=logger,
+            )
+            total_usage = _accumulate_usage(total_usage, result.usage)
 
-        # Fetch all issues in the milestone (open + closed) to support deduplication.
-        raw_issues = gh.list_issues(
-            repo,
-            milestone=milestone_title,
-            state="all",
-        )
-        issue_states = _build_issue_states(raw_issues)
+            raw_issues = gh.list_issues(
+                repo,
+                milestone=milestone_title,
+                state="all",
+            )
+            issue_states = _build_issue_states(raw_issues)
+            if issue_states:
+                break
+
+            if attempt >= _PHASE1_MAX_ATTEMPTS:
+                break
+
+            logger.warning(
+                "Phase 1 attempt %d/%d: model returned without creating any "
+                "GitHub issues. Re-prompting with a stricter nudge.",
+                attempt,
+                _PHASE1_MAX_ATTEMPTS,
+            )
+            nudge = _PHASE1_RETRY_NUDGE.replace("{MILESTONE}", milestone_title or "")
+            attempt_prompt = nudge + prompt
 
         if not issue_states:
             raise Phase1NoIssuesError(
-                "Phase 1 finished without creating any GitHub issues. "
-                "Opus likely misread the task (e.g. audited existing code instead "
-                "of planning new work). Inspect .code-generator/logs/phase1.log, "
-                "adjust prompt-phase-1-planning.md if needed, and re-run."
+                f"Phase 1 finished without creating any GitHub issues after "
+                f"{_PHASE1_MAX_ATTEMPTS} attempts (model={effective_model_name!r}). "
+                "The model likely responded with prose instead of invoking "
+                "`gh issue create` via the Bash tool. Inspect "
+                ".code-generator/logs/phase1.log for the tool-call trace, "
+                "try a stronger model, or simplify the cycle scope in "
+                "requirements.md and re-run."
             )
 
         target = cycle if cycle is not None else state
@@ -278,12 +347,17 @@ async def run(
             cycle.issues = issue_states
         else:
             state.issues = issue_states
-        target.token_usage["phase1"] = result.usage
+        # Persist the accumulated usage across all attempts (not just the last).
+        target.token_usage["phase1"] = total_usage if total_usage is not None else result.usage
         if hasattr(target, "cache_telemetry"):
-            accumulate_telemetry(target.cache_telemetry, result.usage, result.wall_seconds)
+            accumulate_telemetry(
+                target.cache_telemetry,
+                target.token_usage["phase1"],
+                result.wall_seconds,
+            )
 
         _state.save_state(state_path, state)
-        log_phase_usage(logger, 1, result.usage)
+        log_phase_usage(logger, 1, target.token_usage["phase1"])
         logger.info("Phase 1: %d issues created.", len(issue_states))
 
     except Exception:

{claude_code_generator-0.4.11 → claude_code_generator-0.4.12}/tests/test_phase1.py

@@ -414,9 +414,71 @@ class TestBuildIssueStates:
 class TestPhase1NoIssuesError:
     @pytest.mark.asyncio
     async def test_raises_when_list_issues_returns_empty(self, tmp_path: Path) -> None:
+        """Three consecutive empty listings → Phase1NoIssuesError with model name."""
         state = _make_state(tmp_path)
+        call_count = 0
 
         async def fake_main_loop(runner, prompt, options, *, state_path, logger, **kw):
+            nonlocal call_count
+            call_count += 1
+            return _make_run_result()
+
+        with (
+            patch.object(phase1_plan.rate_limit, "main_loop", side_effect=fake_main_loop),
+            patch.object(phase1_plan.gh, "ensure_standard_labels"),
+            patch.object(phase1_plan.gh, "list_issues", return_value=[]),
+        ):
+            with pytest.raises(phase1_plan.Phase1NoIssuesError, match="3 attempts"):
+                await phase1_plan.run(
+                    state,
+                    None,
+                    tmp_path,
+                    runner_module=MagicMock(),
+                    logger=logging.getLogger("test"),
+                )
+
+        assert call_count == phase1_plan._PHASE1_MAX_ATTEMPTS
+
+    @pytest.mark.asyncio
+    async def test_retry_succeeds_after_first_empty_attempt(self, tmp_path: Path) -> None:
+        """If the first attempt created 0 issues but the second populates them, no raise."""
+        state = _make_state(tmp_path)
+        call_count = 0
+        # First call → empty list; second call → real issues.
+        listings = [[], _raw_issues([1, 2])]
+
+        async def fake_main_loop(runner, prompt, options, *, state_path, logger, **kw):
+            nonlocal call_count
+            call_count += 1
+            return _make_run_result()
+
+        def fake_list_issues(*_a, **_kw):
+            return listings[min(call_count - 1, len(listings) - 1)]
+
+        with (
+            patch.object(phase1_plan.rate_limit, "main_loop", side_effect=fake_main_loop),
+            patch.object(phase1_plan.gh, "ensure_standard_labels"),
+            patch.object(phase1_plan.gh, "list_issues", side_effect=fake_list_issues),
+        ):
+            await phase1_plan.run(
+                state,
+                None,
+                tmp_path,
+                runner_module=MagicMock(),
+                logger=logging.getLogger("test"),
+            )
+
+        assert call_count == 2
+        assert len(state.issues) == 2
+
+    @pytest.mark.asyncio
+    async def test_retry_prompt_includes_strict_nudge(self, tmp_path: Path) -> None:
+        """Second attempt's prompt must be prefixed with the stricter nudge."""
+        state = _make_state(tmp_path)
+        captured_prompts: list[str] = []
+
+        async def fake_main_loop(runner, prompt, options, *, state_path, logger, **kw):
+            captured_prompts.append(prompt)
             return _make_run_result()
 
         with (
@@ -433,6 +495,41 @@ class TestPhase1NoIssuesError:
                     logger=logging.getLogger("test"),
                 )
 
+        assert len(captured_prompts) == phase1_plan._PHASE1_MAX_ATTEMPTS
+        # First prompt is the plain Phase 1 prompt.
+        assert (
+            "Your previous attempt finished without creating any GitHub issues"
+            not in (captured_prompts[0])
+        )
+        # Subsequent prompts carry the stricter nudge prefix.
+        for retry_prompt in captured_prompts[1:]:
+            assert retry_prompt.startswith(
+                "Your previous attempt finished without creating any GitHub issues"
+            )
+
+    @pytest.mark.asyncio
+    async def test_error_message_names_effective_model(self, tmp_path: Path) -> None:
+        """Ollama path: final error text must reference the operator-supplied tag."""
+        state = _make_state(tmp_path)
+
+        async def fake_main_loop(runner, prompt, options, *, state_path, logger, **kw):
+            return _make_run_result()
+
+        with (
+            patch.object(phase1_plan.rate_limit, "main_loop", side_effect=fake_main_loop),
+            patch.object(phase1_plan.gh, "ensure_standard_labels"),
+            patch.object(phase1_plan.gh, "list_issues", return_value=[]),
+        ):
+            with pytest.raises(phase1_plan.Phase1NoIssuesError, match="glm-5.1:cloud"):
+                await phase1_plan.run(
+                    state,
+                    None,
+                    tmp_path,
+                    runner_module=MagicMock(),
+                    logger=logging.getLogger("test"),
+                    effective_model="glm-5.1:cloud",
+                )
+
 
 # ---------------------------------------------------------------------------
 # Phase 1 idempotency — AC from issue #134