claude-code-generator 0.2.1__tar.gz → 0.2.3__tar.gz

{claude_code_generator-0.2.1/src/claude_code_generator.egg-info → claude_code_generator-0.2.3}/PKG-INFO

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

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

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

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

{claude_code_generator-0.2.1 → claude_code_generator-0.2.3}/src/code_generator/commands/_dispatch.py

@@ -25,6 +25,56 @@ _logger = logging.getLogger(__name__)
 __all__ = ["dispatch_async", "dispatch_orchestrator"]
 
 
+def _reset_failed_cycles_for_continue(
+    st: state_module.State,
+    *,
+    target_cycle: int | None,
+    state_path: Path,
+) -> None:
+    """Reset ``failed`` cycles back to ``open`` on ``--continue``.
+
+    When a cycle crashes mid-run, ``cycle_loop.run_multi_cycle`` marks it as
+    ``status="failed"`` and persists the exception in ``state.last_error``.
+    The next ``--continue`` must treat these as retryable, otherwise the user
+    has to hand-edit ``state.json`` every time a cycle crashes — which
+    defeats the whole point of ``--continue``.
+
+    When ``target_cycle`` is set (``--cycle N``), only that cycle is reset.
+    Otherwise every failed cycle is reset. ``state.last_error`` and
+    ``state.rate_limit_type`` are cleared on any successful reset so the
+    status line stops showing red for a resolved failure.
+
+    Args:
+        st: Root state (mutated in place).
+        target_cycle: When set, only reset this cycle id; otherwise reset all.
+        state_path: Path to ``state.json`` for atomic persistence.
+    """
+    from code_generator import state as _state_module
+
+    reset_ids: list[int] = []
+    for c in st.cycles:
+        if c.status != "failed":
+            continue
+        if target_cycle is not None and c.id != target_cycle:
+            continue
+        c.status = "open"
+        reset_ids.append(c.id)
+
+    if not reset_ids:
+        return
+
+    if getattr(st, "last_error", None):
+        st.last_error = None
+    if getattr(st, "rate_limit_type", None):
+        st.rate_limit_type = None
+
+    _state_module.save_state(state_path, st)
+    _logger.info(
+        "--continue: reset failed cycles to open: %s",
+        ", ".join(str(i) for i in reset_ids),
+    )
+
+
 async def _apply_delta_plan(
     st: state_module.State,
     project_dir: Path,
@@ -250,6 +300,14 @@ def dispatch_orchestrator(
     start_cycle: int | None = None
 
     if continue_:
+        # A cycle that crashed mid-run is marked "failed" by the exception
+        # handler in cycle_loop.run_multi_cycle. Without this reset, `--continue`
+        # would skip it forever because `_eligible_cycles` only returns "open"
+        # cycles. Semantically, `--continue` means "retry from where we
+        # crashed", so flip any failed cycle back to "open" and clear the
+        # stale error. Explicit --cycle N also benefits: reset just the target.
+        _reset_failed_cycles_for_continue(st, target_cycle=cycle, state_path=state_path)
+
         # Resume from the *next* phase/cycle after the last completed one.
         if effective_mode == "multi-cycle":
             start_cycle, start_phase = resolve_continue_multi_cycle(st)

{claude_code_generator-0.2.1 → claude_code_generator-0.2.3}/src/code_generator/orchestrator/phase2_review.py

@@ -63,6 +63,14 @@ async def run(
         if issue.status != "open":
             continue
 
+        # Skip issues already reviewed in a prior run. Phase 2 never closes
+        # the issue (only Phase 3/4 does), so status alone cannot tell us
+        # whether the review already ran. Without this check, --continue
+        # re-reviews every open issue from scratch on every resume.
+        if issue.reviewed:
+            logger.info("Phase 2: issue #%d already reviewed — skipping.", issue.number)
+            continue
+
         logger.info("Phase 2: reviewing issue #%d (agent=%s).", issue.number, issue.agent)
 
         comments_section = fetch_formatted_comments(issue.number, logger)
@@ -137,6 +145,11 @@ async def run(
         phase_total += issue_usage
 
         if reviewed:
+            # Persist the per-issue reviewed flag immediately so a crash (or
+            # --continue after a rate-limit pause) does not re-review work
+            # that already succeeded.
+            issue.reviewed = True
+            save_state(state_path, state)
             logger.info("Phase 2: issue #%d reviewed.", issue.number)
 
     target = cycle if cycle is not None else state

{claude_code_generator-0.2.1 → claude_code_generator-0.2.3}/src/code_generator/state.py

@@ -27,6 +27,7 @@ class IssueState:
     status: Literal["open", "closed"]
     agent: str
     labels: list[str] = field(default_factory=list)
+    reviewed: bool = False
 
 
 @dataclass
@@ -112,6 +113,7 @@ def _issue_from_dict(d: dict) -> IssueState:  # type: ignore[type-arg]
         status=d["status"],
         agent=d["agent"],
         labels=d.get("labels", []),
+        reviewed=d.get("reviewed", False),
     )
 
 

{claude_code_generator-0.2.1 → claude_code_generator-0.2.3}/tests/test_generate_resume.py

@@ -1337,3 +1337,129 @@ class TestNoOpDetection:
 
         st_after = state_module.load_state(cg / "state.json")
         assert st_after.requirements_hash == new_hash
+
+
+# ---------------------------------------------------------------------------
+# --continue resets failed cycles back to open (retry-on-continue)
+# ---------------------------------------------------------------------------
+
+
+class TestContinueResetsFailedCycles:
+    """Regression guard: `--continue` must retry cycles marked `status=failed`.
+
+    When a cycle crashes mid-run, `cycle_loop.run_multi_cycle` sets
+    `cycle.status = "failed"` and persists `state.last_error`. Without the
+    reset, `_eligible_cycles` filters out failed cycles and `--continue`
+    prints "all eligible cycles complete" without actually running anything.
+    """
+
+    def test_continue_resets_failed_cycle_to_open(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """--continue flips cycles[0].status from 'failed' back to 'open' and clears last_error."""
+        monkeypatch.chdir(tmp_path)
+
+        cg = tmp_path / ".code-generator"
+        cg.mkdir(parents=True, exist_ok=True)
+        st = state_module.State(
+            mode="multi-cycle",  # type: ignore[arg-type]
+            started_at="2026-01-01T00:00:00Z",
+            updated_at="2026-01-01T00:00:00Z",
+            current_cycle=1,
+            phase=None,
+            cycles=[
+                _make_cycle(cycle_id=1, phase=1, status="failed"),
+                _make_cycle(cycle_id=2, phase=0, status="open"),
+            ],
+        )
+        st.last_error = "SDK session exhausted max_turns budget"
+        state_module.save_state(cg / "state.json", st)
+
+        captured: list[dict] = []
+
+        async def mock_multi(state, *_args, start_cycle=None, start_phase=1, **_kwargs):
+            captured.append({"start_cycle": start_cycle, "start_phase": start_phase})
+            return state
+
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.setattr(cycle_loop, "run_multi_cycle", mock_multi)
+        _mock_phase0_single(monkeypatch)
+
+        result = runner.invoke(app, ["generate", "--continue"])
+        assert result.exit_code == 0, result.output
+
+        st_after = state_module.load_state(cg / "state.json")
+        assert st_after.cycles[0].status == "open"
+        assert st_after.last_error is None
+        assert captured == [{"start_cycle": 1, "start_phase": 2}]
+
+    def test_continue_resets_only_target_cycle_when_cycle_flag_set(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """--continue --cycle 2 resets cycle 2 only, leaves cycle 1 failed."""
+        monkeypatch.chdir(tmp_path)
+
+        cg = tmp_path / ".code-generator"
+        cg.mkdir(parents=True, exist_ok=True)
+        st = state_module.State(
+            mode="multi-cycle",  # type: ignore[arg-type]
+            started_at="2026-01-01T00:00:00Z",
+            updated_at="2026-01-01T00:00:00Z",
+            current_cycle=2,
+            phase=None,
+            cycles=[
+                _make_cycle(cycle_id=1, phase=3, status="failed"),
+                _make_cycle(cycle_id=2, phase=4, status="failed"),
+            ],
+        )
+        state_module.save_state(cg / "state.json", st)
+
+        async def mock_multi(*_args, **_kwargs):
+            return None
+
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.setattr(cycle_loop, "run_multi_cycle", mock_multi)
+        _mock_phase0_single(monkeypatch)
+
+        result = runner.invoke(
+            app, ["generate", "--continue", "--cycle", "2", "--mode", "multi-cycle"]
+        )
+        assert result.exit_code == 0, result.output
+
+        st_after = state_module.load_state(cg / "state.json")
+        assert st_after.cycles[0].status == "failed"
+        assert st_after.cycles[1].status == "open"
+
+    def test_continue_without_failed_cycles_is_noop_on_reset(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """--continue on a state with no failed cycles does not mutate status."""
+        monkeypatch.chdir(tmp_path)
+
+        cg = tmp_path / ".code-generator"
+        cg.mkdir(parents=True, exist_ok=True)
+        st = state_module.State(
+            mode="multi-cycle",  # type: ignore[arg-type]
+            started_at="2026-01-01T00:00:00Z",
+            updated_at="2026-01-01T00:00:00Z",
+            current_cycle=1,
+            phase=None,
+            cycles=[_make_cycle(cycle_id=1, phase=3, status="open")],
+        )
+        state_module.save_state(cg / "state.json", st)
+
+        async def mock_multi(*_args, **_kwargs):
+            return None
+
+        from code_generator.orchestrator import cycle_loop
+
+        monkeypatch.setattr(cycle_loop, "run_multi_cycle", mock_multi)
+        _mock_phase0_single(monkeypatch)
+
+        result = runner.invoke(app, ["generate", "--continue"])
+        assert result.exit_code == 0, result.output
+
+        st_after = state_module.load_state(cg / "state.json")
+        assert st_after.cycles[0].status == "open"

{claude_code_generator-0.2.1 → claude_code_generator-0.2.3}/tests/test_phase2.py

@@ -504,3 +504,77 @@ class TestPhase2TokenAccumulation:
 
         assert cycle.token_usage.get("phase2") == issue_usage
         assert "phase2" not in st.token_usage
+
+    @pytest.mark.asyncio
+    async def test_skips_already_reviewed_issues(self, tmp_path: Path) -> None:
+        """Issues with reviewed=True from a prior --continue run must be skipped."""
+        state_dir = tmp_path / ".code-generator"
+        state_dir.mkdir(parents=True, exist_ok=True)
+        st = _state.load_state(state_dir / "missing.json")
+        st.issues = [
+            _state.IssueState(number=1, status="open", agent="python-pro", reviewed=True),
+            _state.IssueState(number=2, status="open", agent="python-pro", reviewed=False),
+            _state.IssueState(number=3, status="open", agent="python-pro", reviewed=True),
+        ]
+        _state.save_state(state_dir / "state.json", st)
+
+        reviewed_numbers: list[int] = []
+
+        async def fake_with_backoff(factory, *, breaker, **kw):
+            await factory()
+
+        async def fake_main_loop(runner, prompt, options, *, state_path, logger, **kw):
+            return _make_run_result()
+
+        with (
+            patch.object(phase2_review.rate_limit, "main_loop", side_effect=fake_main_loop),
+            patch.object(phase2_review.retry, "with_backoff", side_effect=fake_with_backoff),
+            patch.object(phase2_review.gh, "view_issue", return_value={"comments": []}),
+            patch.object(phase2_review, "load_prompt", side_effect=lambda *a, **k: "prompt"),
+            patch.object(
+                phase2_review,
+                "fetch_formatted_comments",
+                side_effect=lambda n, logger: reviewed_numbers.append(n) or "",
+            ),
+        ):
+            await phase2_review.run(
+                st,
+                None,
+                tmp_path,
+                runner_module=MagicMock(),
+                logger=logging.getLogger("test"),
+            )
+
+        # Only issue #2 is actually reviewed; #1 and #3 are skipped.
+        assert reviewed_numbers == [2]
+        # Issue #2 is now marked reviewed; #1 and #3 stay reviewed.
+        assert all(i.reviewed for i in st.issues)
+
+    @pytest.mark.asyncio
+    async def test_successful_review_persists_reviewed_flag(self, tmp_path: Path) -> None:
+        """A successful Phase 2 review must persist reviewed=True to state.json."""
+        state = _make_state_with_issues(tmp_path, [42])
+        state_path = tmp_path / ".code-generator" / "state.json"
+
+        async def fake_with_backoff(factory, *, breaker, **kw):
+            await factory()
+
+        async def fake_main_loop(runner, prompt, options, *, state_path, logger, **kw):
+            return _make_run_result()
+
+        with (
+            patch.object(phase2_review.rate_limit, "main_loop", side_effect=fake_main_loop),
+            patch.object(phase2_review.retry, "with_backoff", side_effect=fake_with_backoff),
+            patch.object(phase2_review.gh, "view_issue", return_value={"comments": []}),
+        ):
+            await phase2_review.run(
+                state,
+                None,
+                tmp_path,
+                runner_module=MagicMock(),
+                logger=logging.getLogger("test"),
+            )
+
+        # Reloaded state must show reviewed=True so a subsequent --continue skips it.
+        reloaded = _state.load_state(state_path)
+        assert reloaded.issues[0].reviewed is True