claude-code-generator 0.1.0__py3-none-any.whl

code_generator/orchestrator/phase2_review.py

@@ -0,0 +1,126 @@
+"""Phase 2 — Per-issue review with circuit breaker.
+
+Each open issue is reviewed by Opus 4.6 in its own invocation.
+If the circuit breaker trips for a specific issue, a ``needs-manual-review``
+label is added and processing continues with the next issue.
+
+Non-negotiable #8: model is hard-coded to ``claude-opus-4-6``.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from code_generator import gh
+from code_generator.logging_setup import setup_phase_logger
+from code_generator.prompts import load_prompt
+from code_generator.runner import rate_limit, retry
+
+if TYPE_CHECKING:
+    import logging
+    from pathlib import Path
+
+    from code_generator.state import CycleState, IssueState, State
+
+
+def _get_issues(state: State, cycle: CycleState | None) -> list[IssueState]:
+    """Return the list of issues for the active scope.
+
+    Args:
+        state: Root state.
+        cycle: Active cycle or ``None`` for single mode.
+
+    Returns:
+        List of IssueState objects from the cycle or the root state.
+    """
+    if cycle is not None:
+        return cycle.issues
+    return state.issues
+
+
+async def run(
+    state: State,
+    cycle: CycleState | None,
+    project_dir: Path,
+    *,
+    runner_module: Any,
+    logger: logging.Logger | None = None,
+) -> None:
+    """Execute phase 2: per-issue review.
+
+    Iterates open issues and reviews each with a fresh Opus 4.6 session.
+    A :class:`~code_generator.runner.retry.CircuitBreaker` with
+    ``max_failures=3`` wraps each issue. When the breaker trips, the issue
+    is tagged ``needs-manual-review`` and skipped.
+
+    Args:
+        state: Root state object.
+        cycle: Active cycle (multi-cycle) or ``None`` (single mode).
+        project_dir: Project root directory.
+        runner_module: Runner module from ``get_runner()``.
+        logger: Optional phase logger.
+    """
+    if logger is None:
+        logger = setup_phase_logger("phase2", project_dir)
+
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    try:
+        from claude_agent_sdk import ClaudeAgentOptions  # type: ignore[import-not-found]
+    except ImportError:  # pragma: no cover
+        ClaudeAgentOptions = type(  # type: ignore[assignment,misc]
+            "ClaudeAgentOptions",
+            (),
+            {"__init__": lambda self, **kw: self.__dict__.update(kw)},
+        )
+
+    issues = _get_issues(state, cycle)
+
+    for issue in issues:
+        if issue.status != "open":
+            continue
+
+        logger.info("Phase 2: reviewing issue #%d (agent=%s).", issue.number, issue.agent)
+
+        prompt = load_prompt(
+            "prompt-phase-2-issue-review.md",
+            ISSUE_NUMBER=str(issue.number),
+            PRIMARY_AGENT=issue.agent,
+        )
+
+        options = ClaudeAgentOptions(
+            model="claude-opus-4-6",
+            allowed_tools=["Read", "Bash", "Glob", "Grep"],
+            cwd=str(project_dir),
+            max_turns=15,
+        )
+
+        breaker = retry.CircuitBreaker(max_failures=3)
+
+        try:
+            await retry.with_backoff(
+                lambda p=prompt, o=options: rate_limit.main_loop(
+                    runner_module,
+                    p,
+                    o,
+                    state_path=state_path,
+                    logger=logger,
+                ),
+                breaker=breaker,
+            )
+        except retry.CircuitOpen:
+            logger.error(
+                "Phase 2: circuit breaker opened for issue #%d — tagging for manual review.",
+                issue.number,
+            )
+            try:
+                gh.add_label(issue.number, "needs-manual-review")
+            except gh.GhError as exc:
+                logger.warning(
+                    "Could not add needs-manual-review label to #%d: %s",
+                    issue.number,
+                    exc,
+                )
+            continue
+
+        logger.info("Phase 2: issue #%d reviewed.", issue.number)

code_generator/orchestrator/phase3_4_implement.py

@@ -0,0 +1,164 @@
+"""Phases 3 & 4 — Implementation loop (TDD, fresh session per issue).
+
+Each open issue gets its own SDK session (non-negotiable #6: no ``resume``).
+The issue agent is taken from state; skills default to ``solid-principles``
+augmented by whatever ``agents.detect()`` returns for the requirements file.
+
+Non-negotiable #8: model is hard-coded to ``claude-sonnet-4-6``.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from code_generator import agents as _agents
+from code_generator import state as _state
+from code_generator.logging_setup import setup_phase_logger
+from code_generator.prompts import load_prompt
+from code_generator.runner import rate_limit
+
+if TYPE_CHECKING:
+    import logging
+    from pathlib import Path
+
+    from code_generator.state import CycleState, IssueState, State
+
+
+def _get_issues(state: State, cycle: CycleState | None) -> list[IssueState]:
+    if cycle is not None:
+        return cycle.issues
+    return state.issues
+
+
+def _default_skills(project_dir: Path) -> str:
+    """Derive skill names from the requirements file (or use generic fallback).
+
+    Args:
+        project_dir: Project root; the requirements file lives at
+            ``<project_dir>/.code-generator/requirements.md``.
+
+    Returns:
+        Comma-joined skill names string.
+    """
+    req_path = project_dir / ".code-generator" / "requirements.md"
+    selection = _agents.detect(req_path)
+    skills = selection.skills or ("solid-principles",)
+    return ",".join(skills)
+
+
+async def run(
+    state: State,
+    cycle: CycleState | None,
+    project_dir: Path,
+    *,
+    runner_module: Any,
+    logger: logging.Logger | None = None,
+    max_retries: int = 3,
+) -> None:
+    """Execute phases 3 and 4: implementation loop.
+
+    For each open issue:
+
+    1. Builds a fresh set of options (no ``resume`` — non-negotiable #6).
+    2. Loads ``prompt-phase-3-implementation.md`` with the issue number,
+       agent, and skills.
+    3. Runs via ``rate_limit.main_loop``.
+    4. On success: marks the issue ``closed`` in state and persists.
+    5. On failure: retries up to *max_retries* times with an escalating
+       error context appended to the prompt.  After all retries the issue
+       is left open and an ERROR is logged.
+
+    Args:
+        state: Root state object (mutated in place).
+        cycle: Active cycle (multi-cycle) or ``None`` (single mode).
+        project_dir: Project root directory.
+        runner_module: Runner module from ``get_runner()``.
+        logger: Optional phase logger.
+        max_retries: Maximum implementation retries per issue (default 3).
+    """
+    if logger is None:
+        logger = setup_phase_logger("phase3_4", project_dir)
+
+    state_path = project_dir / ".code-generator" / "state.json"
+    skills = _default_skills(project_dir)
+
+    try:
+        from claude_agent_sdk import ClaudeAgentOptions  # type: ignore[import-not-found]
+    except ImportError:  # pragma: no cover
+        ClaudeAgentOptions = type(  # type: ignore[assignment,misc]
+            "ClaudeAgentOptions",
+            (),
+            {"__init__": lambda self, **kw: self.__dict__.update(kw)},
+        )
+
+    issues = _get_issues(state, cycle)
+
+    for issue in issues:
+        if issue.status != "open":
+            continue
+
+        agent = issue.agent or "python-pro"
+        logger.info("Phase 3/4: implementing issue #%d (agent=%s).", issue.number, agent)
+
+        base_prompt = load_prompt(
+            "prompt-phase-3-implementation.md",
+            ISSUE_NUMBER=str(issue.number),
+            PRIMARY_AGENT=agent,
+            SKILLS=skills,
+        )
+
+        success = False
+        last_err: str = ""
+
+        for attempt in range(max_retries):
+            # Non-negotiable #6: fresh session per issue — never set resume.
+            # Clear session_id before each attempt.
+            state.session_id = None
+            _state.save_state(state_path, state)
+
+            prompt = base_prompt
+            if attempt > 0:
+                prompt = (
+                    f"{base_prompt}\n\nPrevious attempt failed: {last_err}. "
+                    "Be more explicit this time."
+                )
+
+            options = ClaudeAgentOptions(
+                model="claude-sonnet-4-6",
+                allowed_tools=["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
+                cwd=str(project_dir),
+                max_turns=80,
+            )
+
+            try:
+                await rate_limit.main_loop(
+                    runner_module,
+                    prompt,
+                    options,
+                    state_path=state_path,
+                    logger=logger,
+                )
+                success = True
+                break
+            except Exception as exc:  # noqa: BLE001
+                last_err = str(exc)
+                logger.warning(
+                    "Phase 3/4: attempt %d/%d failed for issue #%d: %s",
+                    attempt + 1,
+                    max_retries,
+                    issue.number,
+                    last_err,
+                )
+
+        if success:
+            issue.status = "closed"
+            # Non-negotiable #6: clear session_id after each issue.
+            state.session_id = None
+            _state.save_state(state_path, state)
+            logger.info("Phase 3/4: issue #%d closed.", issue.number)
+        else:
+            logger.error(
+                "Phase 3/4: issue #%d could not be implemented after %d retries.",
+                issue.number,
+                max_retries,
+            )

code_generator/orchestrator/phase5_closure.py

@@ -0,0 +1,154 @@
+"""Phase 5 — Closure and cross-module review.
+
+Runs Opus 4.6 to review the full codebase, close any straggling issues,
+and optionally create new ``fix:`` issues.  After the session, re-fetches
+open issues and returns a :class:`FixResult` so the orchestrator can
+re-enter phases 3/4 for any newly-created fix issues.
+
+Non-negotiable #8: model is hard-coded to ``claude-opus-4-6``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from code_generator import gh
+from code_generator import state as _state
+from code_generator.logging_setup import setup_phase_logger
+from code_generator.prompts import load_prompt
+from code_generator.runner import rate_limit
+
+if TYPE_CHECKING:
+    import logging
+    from pathlib import Path
+
+    from code_generator.state import CycleState, IssueState, State
+
+
+@dataclass
+class FixResult:
+    """Returned by :func:`run` to signal new fix issues to the orchestrator.
+
+    Attributes:
+        new_issues: List of IssueState objects for issues created during
+            phase 5 (identified by the ``fix:`` title prefix).
+    """
+
+    new_issues: list[IssueState] = field(default_factory=list)
+
+
+def _known_numbers(state: State, cycle: CycleState | None) -> set[int]:
+    """Return the set of issue numbers already in state/cycle.
+
+    Args:
+        state: Root state.
+        cycle: Active cycle or ``None``.
+
+    Returns:
+        Set of known issue numbers.
+    """
+    issues = cycle.issues if cycle is not None else state.issues
+    return {i.number for i in issues}
+
+
+def _agent_from_labels(labels: list[dict[str, Any]]) -> str:  # type: ignore[type-arg]
+    for lbl in labels:
+        name: str = lbl.get("name", "")
+        if name.startswith("agent:"):
+            return name[len("agent:"):]
+    return "python-pro"
+
+
+async def run(
+    state: State,
+    cycle: CycleState | None,
+    project_dir: Path,
+    *,
+    runner_module: Any,
+    logger: logging.Logger | None = None,
+) -> FixResult:
+    """Execute phase 5: overall review and closure.
+
+    Args:
+        state: Root state object (mutated in place).
+        cycle: Active cycle (multi-cycle) or ``None`` (single mode).
+        project_dir: Project root directory.
+        runner_module: Runner module from ``get_runner()``.
+        logger: Optional phase logger.
+
+    Returns:
+        :class:`FixResult` listing any new fix issues discovered after the
+        session.  An empty list means no re-entry into phases 3/4 is needed.
+    """
+    if logger is None:
+        logger = setup_phase_logger("phase5", project_dir)
+
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    prompt = load_prompt(
+        "prompt-phase-5-final-review.md",
+        CYCLE_SCOPE=(
+            cycle.scope
+            if cycle is not None
+            else "single-cycle — implement all features from requirements.md"
+        ),
+        MILESTONE_TITLE=cycle.milestone_title if cycle is not None else "",
+    )
+
+    try:
+        from claude_agent_sdk import ClaudeAgentOptions  # type: ignore[import-not-found]
+    except ImportError:  # pragma: no cover
+        ClaudeAgentOptions = type(  # type: ignore[assignment,misc]
+            "ClaudeAgentOptions",
+            (),
+            {"__init__": lambda self, **kw: self.__dict__.update(kw)},
+        )
+
+    options = ClaudeAgentOptions(
+        model="claude-opus-4-6",
+        allowed_tools=["Read", "Bash", "Glob", "Grep"],
+        cwd=str(project_dir),
+        max_turns=30,
+    )
+
+    await rate_limit.main_loop(
+        runner_module,
+        prompt,
+        options,
+        state_path=state_path,
+        logger=logger,
+    )
+
+    # Re-fetch open issues to detect any new fix: issues.
+    known = _known_numbers(state, cycle)
+    milestone_title = cycle.milestone_title if cycle is not None else None
+
+    try:
+        open_issues = gh.list_issues(milestone=milestone_title, state="open")
+    except gh.GhError as exc:
+        logger.warning("Phase 5: could not list issues after session: %s", exc)
+        return FixResult()
+
+    new_issue_states: list[_state.IssueState] = []
+    for raw in open_issues:
+        num = raw["number"]
+        if num in known:
+            continue
+        # Only pick up new issues — they may be fix: issues created by the session.
+        new_state = _state.IssueState(
+            number=num,
+            status="open",
+            agent=_agent_from_labels(raw.get("labels", [])),
+        )
+        new_issue_states.append(new_state)
+
+    if new_issue_states:
+        if cycle is not None:
+            cycle.issues.extend(new_issue_states)
+        else:
+            state.issues.extend(new_issue_states)
+        _state.save_state(state_path, state)
+        logger.info("Phase 5: %d new fix issues detected.", len(new_issue_states))
+
+    return FixResult(new_issues=new_issue_states)

code_generator/orchestrator/phase6_test.py

@@ -0,0 +1,98 @@
+"""Phase 6 — Test suite runner.
+
+Runs Sonnet 4.6 to execute the test suite and fix failures iteratively
+(max 3 attempts, controlled by the prompt). Raises :class:`TestsFailed`
+if the session text contains the sentinel string ``"TESTS FAILED"``.
+
+Non-negotiable #8: model is hard-coded to ``claude-sonnet-4-6``.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from code_generator.logging_setup import setup_phase_logger
+from code_generator.prompts import load_prompt
+from code_generator.runner import rate_limit
+
+if TYPE_CHECKING:
+    import logging
+    from pathlib import Path
+
+    from code_generator.state import CycleState, State
+
+
+# Sentinel emitted by the prompt when all retries are exhausted.
+_FAIL_SENTINEL = "TESTS FAILED"
+
+
+class TestsFailed(RuntimeError):  # noqa: N818
+    """Raised when the test-runner session reports persistent test failures.
+
+    The orchestrator should skip phase 7 (commit) when this is raised.
+    """
+
+    __test__ = False  # pytest: not a test class
+
+
+async def run(
+    state: State,
+    cycle: CycleState | None,
+    project_dir: Path,
+    *,
+    runner_module: Any,
+    logger: logging.Logger | None = None,
+) -> None:
+    """Execute phase 6: test suite runner.
+
+    Loads the phase-6 prompt (with ``MAX_RETRIES="3"``), runs it via
+    the rate-limit loop, and inspects the result text for the sentinel.
+
+    Args:
+        state: Root state object.
+        cycle: Active cycle (multi-cycle) or ``None`` (single mode).
+        project_dir: Project root directory.
+        runner_module: Runner module from ``get_runner()``.
+        logger: Optional phase logger.
+
+    Raises:
+        TestsFailed: When the result text contains ``"TESTS FAILED"``.
+    """
+    if logger is None:
+        logger = setup_phase_logger("phase6", project_dir)
+
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    prompt = load_prompt("prompt-phase-6-test.md", MAX_RETRIES="3")
+
+    try:
+        from claude_agent_sdk import ClaudeAgentOptions  # type: ignore[import-not-found]
+    except ImportError:  # pragma: no cover
+        ClaudeAgentOptions = type(  # type: ignore[assignment,misc]
+            "ClaudeAgentOptions",
+            (),
+            {"__init__": lambda self, **kw: self.__dict__.update(kw)},
+        )
+
+    options = ClaudeAgentOptions(
+        model="claude-sonnet-4-6",
+        allowed_tools=["Read", "Edit", "Bash"],
+        cwd=str(project_dir),
+        max_turns=40,
+    )
+
+    result = await rate_limit.main_loop(
+        runner_module,
+        prompt,
+        options,
+        state_path=state_path,
+        logger=logger,
+    )
+
+    if _FAIL_SENTINEL in result.text:
+        logger.error("Phase 6: test runner reported persistent failures.")
+        raise TestsFailed(
+            "Test suite failed after all retries. Inspect the output above and fix manually."
+        )
+
+    logger.info("Phase 6 complete: all tests passed.")

code_generator/orchestrator/phase7_commit.py

@@ -0,0 +1,167 @@
+"""Phase 7 — Commit message generation and git push.
+
+Uses Haiku 4.5 to generate a commit message, then performs
+``git add . → git commit -m <msg> → git push origin <branch>``
+with one rebase-and-retry on push rejection.
+
+Non-negotiable #8: model is hard-coded to ``claude-haiku-4-5``.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from typing import TYPE_CHECKING, Any
+
+from code_generator.logging_setup import setup_phase_logger
+from code_generator.prompts import load_prompt
+from code_generator.runner import rate_limit
+
+if TYPE_CHECKING:
+    import logging
+    from pathlib import Path
+
+    from code_generator.state import CycleState, IssueState, State
+
+
+def _current_branch(project_dir: Path) -> str:
+    """Return the current git branch name.
+
+    Args:
+        project_dir: Directory to run git in.
+
+    Returns:
+        Branch name string.
+    """
+    result = subprocess.run(
+        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        cwd=project_dir,
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    return result.stdout.strip()
+
+
+def _has_staged_changes(project_dir: Path) -> bool:
+    """Return True when the git index has staged changes.
+
+    Args:
+        project_dir: Directory to run git in.
+
+    Returns:
+        ``True`` if there are staged changes, ``False`` otherwise.
+    """
+    result = subprocess.run(
+        ["git", "diff", "--cached", "--quiet"],
+        cwd=project_dir,
+        check=False,
+    )
+    # Exit code 0 means no diff (nothing staged); 1 means there are changes.
+    return result.returncode != 0
+
+
+def _closed_issue_numbers(state: State, cycle: CycleState | None) -> list[int]:
+    """Collect issue numbers marked as closed in the current scope.
+
+    Args:
+        state: Root state.
+        cycle: Active cycle or ``None`` for single mode.
+
+    Returns:
+        Sorted list of closed issue numbers.
+    """
+    issues: list[IssueState] = cycle.issues if cycle is not None else state.issues
+    return sorted(i.number for i in issues if i.status == "closed")
+
+
+async def run(
+    state: State,
+    cycle: CycleState | None,
+    project_dir: Path,
+    *,
+    runner_module: Any,
+    logger: logging.Logger | None = None,
+) -> None:
+    """Execute phase 7: commit and push.
+
+    Steps:
+    1. ``git add .``
+    2. ``git diff --cached --quiet`` — skip when nothing staged.
+    3. Run Haiku 4.5 via the rate-limit loop to generate a commit message.
+    4. ``git commit -m <msg>``
+    5. ``git push origin <branch>``; on non-zero exit: ``git pull --rebase
+       && git push origin <branch>`` (one retry).
+
+    Args:
+        state: Root state object.
+        cycle: Active cycle (multi-cycle) or ``None`` (single mode).
+        project_dir: Project root directory.
+        runner_module: Runner module from ``get_runner()``.
+        logger: Optional phase logger.
+    """
+    if logger is None:
+        logger = setup_phase_logger("phase7", project_dir)
+
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    # Stage everything.
+    subprocess.run(["git", "add", "."], cwd=project_dir, check=True)
+
+    # Skip commit when there is nothing staged.
+    if not _has_staged_changes(project_dir):
+        logger.info("Phase 7: nothing staged — skipping commit and push.")
+        return
+
+    closed_numbers = _closed_issue_numbers(state, cycle)
+    issues_closed = ", ".join(f"#{n}" for n in closed_numbers) if closed_numbers else "none"
+    cycle_name = cycle.name if cycle is not None else ""
+
+    prompt = load_prompt(
+        "prompt-phase-7-commit.md",
+        CYCLE_NAME=cycle_name,
+        ISSUES_CLOSED=issues_closed,
+    )
+
+    try:
+        from claude_agent_sdk import ClaudeAgentOptions  # type: ignore[import-not-found]
+    except ImportError:  # pragma: no cover
+        ClaudeAgentOptions = type(  # type: ignore[assignment,misc]
+            "ClaudeAgentOptions",
+            (),
+            {"__init__": lambda self, **kw: self.__dict__.update(kw)},
+        )
+
+    options = ClaudeAgentOptions(
+        model="claude-haiku-4-5",
+        allowed_tools=["Read", "Bash"],
+        cwd=str(project_dir),
+        max_turns=5,
+    )
+
+    result = await rate_limit.main_loop(
+        runner_module,
+        prompt,
+        options,
+        state_path=state_path,
+        logger=logger,
+    )
+
+    commit_msg = result.text.strip()
+    if not commit_msg:
+        commit_msg = f"chore: cycle {cycle_name or 'single'} complete"
+
+    subprocess.run(["git", "commit", "-m", commit_msg], cwd=project_dir, check=True)
+
+    branch = _current_branch(project_dir)
+
+    push_result = subprocess.run(
+        ["git", "push", "origin", branch],
+        cwd=project_dir,
+        check=False,
+    )
+    if push_result.returncode != 0:
+        logger.warning("Phase 7: push rejected — attempting rebase and retry.")
+        subprocess.run(["git", "pull", "--rebase"], cwd=project_dir, check=True)
+        subprocess.run(["git", "push", "origin", branch], cwd=project_dir, check=True)
+
+    logger.info("Phase 7 complete: committed and pushed to %s.", branch)