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

code_generator/orchestrator/cycle_loop.py

@@ -0,0 +1,371 @@
+"""Multi-cycle driver: single-mode and multi-cycle orchestration loops.
+
+Implements the phase 1→7 execution in dependency order for multi-cycle mode.
+Each cycle gets a fresh SDK session (non-negotiable #6: no ``options.resume``
+across cycle boundaries).
+
+Topological iteration:
+    A cycle is eligible when all its ``depends_on`` cycle IDs have
+    ``status == "completed"``. The loop iterates until no further eligible
+    cycles remain. Cycles with unmet dependencies after all eligible ones are
+    exhausted remain as ``"open"``.
+"""
+
+from __future__ import annotations
+
+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.orchestrator import (
+    phase1_plan,
+    phase2_review,
+    phase3_4_implement,
+    phase5_closure,
+    phase6_test,
+    phase7_commit,
+)
+
+if TYPE_CHECKING:
+    import logging
+    from pathlib import Path
+
+    from code_generator.state import CycleState, State
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _eligible_cycles(state: State, completed_ids: set[int]) -> list[CycleState]:
+    """Return cycles whose dependencies are all completed and which are open.
+
+    Args:
+        state: Root state with ``cycles`` list.
+        completed_ids: Set of cycle IDs already completed this run.
+
+    Returns:
+        List of :class:`~code_generator.state.CycleState` objects that are
+        eligible to run (open + all deps satisfied).
+    """
+    return [
+        c
+        for c in state.cycles
+        if c.status == "open" and all(dep in completed_ids for dep in c.depends_on)
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Single-mode driver
+# ---------------------------------------------------------------------------
+
+
+async def run_single_mode(
+    state: State,
+    project_dir: Path,
+    *,
+    runner_module: Any,
+    logger: logging.Logger | None = None,
+    start_phase: int = 1,
+) -> State:
+    """Execute the single-mode pipeline: phases 1→7.
+
+    Non-negotiable #6 is respected by phase 3/4, which clears ``session_id``
+    before each issue. This function itself does not set ``options.resume``.
+
+    Args:
+        state: Root state object (mutated in place and returned).
+        project_dir: Project root directory.
+        runner_module: Runner module returned by ``get_runner()``.
+        logger: Optional phase logger; one is created when omitted.
+        start_phase: First phase to execute. Phases below this number are
+            skipped. Defaults to 1 (full run).
+
+    Returns:
+        The mutated state.
+
+    Raises:
+        OverageAbort: Propagated unchanged from any phase.
+        RateLimitHit: Propagated unchanged from any phase.
+        TestsFailed: When phase 6 reports persistent test failures.
+        CircuitOpen: When phase 2's circuit breaker trips.
+    """
+    log = logger or setup_phase_logger("cycle_loop", project_dir)
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    log.info("run_single_mode: start_phase=%d", start_phase)
+
+    if start_phase <= 1:
+        await phase1_plan.run(
+            state, None, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger("phase1", project_dir),
+        )
+        state.phase = 1
+        _state.save_state(state_path, state)
+
+    if start_phase <= 2:
+        await phase2_review.run(
+            state, None, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger("phase2", project_dir),
+        )
+        state.phase = 2
+        _state.save_state(state_path, state)
+
+    if start_phase <= 3:
+        await phase3_4_implement.run(
+            state, None, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger("phase3_4", project_dir),
+        )
+        state.phase = 3
+        _state.save_state(state_path, state)
+
+    if start_phase <= 4:
+        fix_result = await phase5_closure.run(
+            state, None, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger("phase5", project_dir),
+        )
+        state.phase = 4
+        _state.save_state(state_path, state)
+        # Re-enter implementation for any fix issues detected by phase 5.
+        if fix_result.new_issues:
+            await phase3_4_implement.run(
+                state, None, project_dir, runner_module=runner_module,
+                logger=setup_phase_logger("phase3_4", project_dir),
+            )
+            _state.save_state(state_path, state)
+
+    if start_phase <= 5:
+        await phase6_test.run(
+            state, None, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger("phase6", project_dir),
+        )
+        state.phase = 5
+        _state.save_state(state_path, state)
+
+    if start_phase <= 6:
+        await phase7_commit.run(
+            state, None, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger("phase7", project_dir),
+        )
+        state.phase = 7
+        _state.save_state(state_path, state)
+
+    log.info("run_single_mode: complete")
+    return state
+
+
+# ---------------------------------------------------------------------------
+# Multi-cycle driver
+# ---------------------------------------------------------------------------
+
+
+async def run_multi_cycle(
+    state: State,
+    project_dir: Path,
+    *,
+    runner_module: Any,
+    logger: logging.Logger | None = None,
+    start_cycle: int | None = None,
+    start_phase: int = 1,
+) -> State:
+    """Execute cycles in dependency order, each with a fresh SDK session.
+
+    Eligible cycles are those whose ``depends_on`` cycle IDs are all
+    ``"completed"``. The loop keeps running until no further eligible
+    cycles remain.
+
+    Non-negotiable #6: ``state.session_id`` is set to ``None`` at the entry
+    of every cycle and persisted before any phase runs.
+
+    Args:
+        state: Root state object (mutated in place and returned).
+        project_dir: Project root directory.
+        runner_module: Runner module returned by ``get_runner()``.
+        logger: Optional phase logger; one is created when omitted.
+        start_cycle: When set, cycles with ``id < start_cycle`` are skipped
+            even if their dependencies are not completed. The phase resume
+            applies only to the *first* eligible cycle visited.
+        start_phase: Resume from this phase in the first eligible cycle.
+            Subsequent cycles always start at phase 1.
+
+    Returns:
+        The mutated state.
+
+    Raises:
+        OverageAbort: Propagated unchanged — stops all cycles.
+        RateLimitHit: Propagated unchanged — stops all cycles.
+        TestsFailed: When phase 6 fails — stops remaining cycles.
+        CircuitOpen: Propagated unchanged — stops all cycles.
+    """
+    log = logger or setup_phase_logger("cycle_loop", project_dir)
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    log.info(
+        "run_multi_cycle: start_cycle=%s start_phase=%d total_cycles=%d",
+        start_cycle,
+        start_phase,
+        len(state.cycles),
+    )
+
+    # Track which cycles have been completed during this run.
+    completed_ids: set[int] = {
+        c.id for c in state.cycles if c.status == "completed"
+    }
+
+    is_first_eligible = True
+
+    while True:
+        eligible = _eligible_cycles(state, completed_ids)
+        if not eligible:
+            break
+
+        for cycle in eligible:
+            # Honor --cycle N: skip cycles below the requested start.
+            if start_cycle is not None and cycle.id < start_cycle:
+                log.info("Skipping cycle %d (below start_cycle=%d).", cycle.id, start_cycle)
+                # Mark as completed so dependent cycles can run.
+                cycle.status = "completed"
+                completed_ids.add(cycle.id)
+                continue
+
+            # Non-negotiable #6: fresh session at every cycle entry.
+            state.session_id = None
+            state.current_cycle = cycle.id
+            _state.save_state(state_path, state)
+
+            log.info("Starting cycle %d (%s).", cycle.id, cycle.name)
+
+            # start_phase applies only to the first cycle we actually run.
+            effective_start_phase = start_phase if is_first_eligible else 1
+            is_first_eligible = False
+
+            try:
+                await _run_cycle_phases(
+                    state=state,
+                    cycle=cycle,
+                    project_dir=project_dir,
+                    runner_module=runner_module,
+                    log=log,
+                    start_phase=effective_start_phase,
+                )
+            except Exception as exc:
+                cycle.status = "failed"
+                state.last_error = str(exc)
+                _state.save_state(state_path, state)
+                log.error(
+                    "Cycle %d (%s) failed: %s. Aborting further cycles.",
+                    cycle.id,
+                    cycle.name,
+                    exc,
+                )
+                raise
+
+            # Cycle succeeded.
+            cycle.status = "completed"
+            completed_ids.add(cycle.id)
+
+            # Close the milestone for this cycle.
+            if cycle.milestone_number is not None:
+                try:
+                    gh.close_milestone(cycle.milestone_number)
+                    log.info(
+                        "Closed milestone #%d for cycle %d.",
+                        cycle.milestone_number,
+                        cycle.id,
+                    )
+                except gh.GhError as exc:
+                    log.warning(
+                        "Could not close milestone #%d: %s",
+                        cycle.milestone_number,
+                        exc,
+                    )
+
+            _state.save_state(state_path, state)
+            log.info("Cycle %d (%s) completed.", cycle.id, cycle.name)
+
+    log.info("run_multi_cycle: all eligible cycles complete.")
+    return state
+
+
+# ---------------------------------------------------------------------------
+# Per-cycle phase runner
+# ---------------------------------------------------------------------------
+
+
+async def _run_cycle_phases(
+    state: State,
+    cycle: CycleState,
+    project_dir: Path,
+    runner_module: Any,
+    log: logging.Logger,
+    start_phase: int,
+) -> None:
+    """Run phases 1→7 for a single cycle.
+
+    Args:
+        state: Root state (mutated in place).
+        cycle: The active cycle being executed.
+        project_dir: Project root directory.
+        runner_module: Runner module.
+        log: Logger for this cycle run.
+        start_phase: First phase to execute (1 = full, higher = resume).
+    """
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    if start_phase <= 1:
+        await phase1_plan.run(
+            state, cycle, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger(f"cycle{cycle.id}_phase1", project_dir),
+        )
+        cycle.phase = 1
+        _state.save_state(state_path, state)
+
+    if start_phase <= 2:
+        await phase2_review.run(
+            state, cycle, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger(f"cycle{cycle.id}_phase2", project_dir),
+        )
+        cycle.phase = 2
+        _state.save_state(state_path, state)
+
+    if start_phase <= 3:
+        await phase3_4_implement.run(
+            state, cycle, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger(f"cycle{cycle.id}_phase3_4", project_dir),
+        )
+        cycle.phase = 3
+        _state.save_state(state_path, state)
+
+    if start_phase <= 4:
+        fix_result = await phase5_closure.run(
+            state, cycle, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger(f"cycle{cycle.id}_phase5", project_dir),
+        )
+        cycle.phase = 4
+        _state.save_state(state_path, state)
+        if fix_result.new_issues:
+            await phase3_4_implement.run(
+                state, cycle, project_dir, runner_module=runner_module,
+                logger=setup_phase_logger(f"cycle{cycle.id}_phase3_4_fix", project_dir),
+            )
+            _state.save_state(state_path, state)
+
+    if start_phase <= 5:
+        await phase6_test.run(
+            state, cycle, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger(f"cycle{cycle.id}_phase6", project_dir),
+        )
+        cycle.phase = 5
+        _state.save_state(state_path, state)
+
+    if start_phase <= 6:
+        await phase7_commit.run(
+            state, cycle, project_dir, runner_module=runner_module,
+            logger=setup_phase_logger(f"cycle{cycle.id}_phase7", project_dir),
+        )
+        cycle.phase = 7
+        _state.save_state(state_path, state)
+
+    log.info("Cycle %d phases 1-7 complete.", cycle.id)

code_generator/orchestrator/phase0_complexity.py

@@ -0,0 +1,159 @@
+"""Phase 0 — Complexity analysis and single vs. multi-cycle decision.
+
+Uses Opus 4.6 to analyse the requirements file and populate
+``state.mode`` and ``state.cycles``.
+
+Non-negotiable #8: model is hard-coded to ``claude-opus-4-6``.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import TYPE_CHECKING, Any
+
+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:
+    from pathlib import Path
+
+    from code_generator.state import State
+
+_LOG = logging.getLogger(__name__)
+
+# How many times to re-prompt when JSON is unparseable before falling back.
+_MAX_JSON_RETRIES = 2
+
+
+def _parse_json(text: str) -> dict[str, Any] | None:
+    """Extract and parse the first JSON object from *text*.
+
+    Args:
+        text: Raw text that may contain prose around a JSON object.
+
+    Returns:
+        Parsed dict or ``None`` when no valid JSON object is found.
+    """
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end < start:
+        return None
+    try:
+        return json.loads(text[start : end + 1])  # type: ignore[no-any-return]
+    except json.JSONDecodeError:
+        return None
+
+
+def _apply_result(state: State, data: dict[str, Any]) -> None:
+    """Write parsed phase-0 data into *state* in place.
+
+    Args:
+        state: The state object to mutate.
+        data: Dict with ``"mode"`` and optional ``"cycles"`` keys.
+    """
+    mode = data.get("mode", "single")
+    if mode not in ("single", "multi-cycle"):
+        mode = "single"
+    state.mode = mode  # type: ignore[assignment]
+
+    raw_cycles = data.get("cycles", [])
+    if isinstance(raw_cycles, list) and raw_cycles:
+        state.cycles = [
+            _state.CycleState(
+                id=c.get("id", idx + 1),
+                name=c.get("name", f"Cycle {idx + 1}"),
+                milestone_number=None,
+                milestone_title=c.get("milestone_title", f"Cycle {idx + 1}"),
+                status="open",
+                phase=0,
+                issues=[],
+                commit_sha=None,
+                depends_on=c.get("depends_on", []),
+                scope=c.get("scope", ""),
+            )
+            for idx, c in enumerate(raw_cycles)
+        ]
+
+
+async def run(
+    state: State,
+    project_dir: Path,
+    *,
+    runner_module: Any,
+    logger: logging.Logger | None = None,
+) -> State:
+    """Execute phase 0: complexity analysis.
+
+    Loads the phase-0 prompt, runs it via the rate-limit main loop,
+    parses JSON from the response, and writes ``mode`` and ``cycles``
+    into *state*.
+
+    If JSON parsing fails twice the response is re-prompted. After
+    ``_MAX_JSON_RETRIES`` failures the mode falls back to ``"single"``
+    and an ERROR is logged.
+
+    Args:
+        state: Current state (mutated in place and returned).
+        project_dir: The project root directory (cwd for the SDK).
+        runner_module: The runner module returned by ``get_runner()``.
+        logger: Optional phase logger; one is created when omitted.
+
+    Returns:
+        The mutated state with ``mode`` and ``cycles`` populated.
+    """
+    if logger is None:
+        logger = setup_phase_logger("phase0", project_dir)
+
+    state_path = project_dir / ".code-generator" / "state.json"
+    prompt = load_prompt("prompt-phase-0-complexity.md")
+
+    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", "Glob", "Grep"],
+        cwd=str(project_dir),
+        max_turns=30,
+    )
+
+    for attempt in range(_MAX_JSON_RETRIES + 1):
+        result = await rate_limit.main_loop(
+            runner_module,
+            prompt,
+            options,
+            state_path=state_path,
+            logger=logger,
+        )
+
+        data = _parse_json(result.text)
+        if data is not None:
+            _apply_result(state, data)
+            logger.info("Phase 0 complete: mode=%s, cycles=%d", state.mode, len(state.cycles))
+            return state
+
+        logger.warning(
+            "Phase 0: JSON parse failed (attempt %d/%d). Text: %.200s",
+            attempt + 1,
+            _MAX_JSON_RETRIES + 1,
+            result.text,
+        )
+        if attempt < _MAX_JSON_RETRIES:
+            prompt = "Return ONLY valid JSON, no prose. " + prompt
+
+    # All retries exhausted — safe fallback.
+    logger.error(
+        "Phase 0: JSON parsing failed after %d retries. Falling back to single mode.",
+        _MAX_JSON_RETRIES,
+    )
+    state.mode = "single"  # type: ignore[assignment]
+    return state

code_generator/orchestrator/phase1_plan.py

@@ -0,0 +1,170 @@
+"""Phase 1 — Planning: milestone creation and issue seeding.
+
+Uses Opus 4.6 to read the requirements and create GitHub Issues
+(via Bash tool calls inside the SDK session).
+
+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 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, State
+
+
+class Phase1NoIssuesError(RuntimeError):
+    """Phase 1 completed but created zero GitHub issues — abort the pipeline."""
+
+
+def _agent_from_labels(labels: list[dict[str, Any]]) -> str:  # type: ignore[type-arg]
+    """Extract the agent name from a list of label dicts returned by gh.
+
+    Args:
+        labels: List of dicts with at least a ``"name"`` key.
+
+    Returns:
+        The agent name (without ``"agent:"`` prefix) or ``"python-pro"``
+        when no ``agent:`` label is present.
+    """
+    for lbl in labels:
+        name: str = lbl.get("name", "")
+        if name.startswith("agent:"):
+            return name[len("agent:"):]
+    return "python-pro"
+
+
+def _build_issue_states(raw_issues: list[dict[str, Any]]) -> list[_state.IssueState]:  # type: ignore[type-arg]
+    """Convert raw gh issue dicts into IssueState objects.
+
+    Args:
+        raw_issues: List of dicts as returned by ``gh.list_issues()``.
+
+    Returns:
+        List of :class:`~code_generator.state.IssueState` instances.
+    """
+    return [
+        _state.IssueState(
+            number=issue["number"],
+            status="open",
+            agent=_agent_from_labels(issue.get("labels", [])),
+        )
+        for issue in raw_issues
+    ]
+
+
+async def run(
+    state: State,
+    cycle: CycleState | None,
+    project_dir: Path,
+    *,
+    runner_module: Any,
+    logger: logging.Logger | None = None,
+) -> None:
+    """Execute phase 1: planning.
+
+    Seeds standard labels, optionally creates a milestone (multi-cycle),
+    runs the planning prompt, then populates ``state.issues`` or
+    ``cycle.issues`` from the newly-created GitHub issues.
+
+    Args:
+        state: Root state object (mutated in place).
+        cycle: Active cycle (multi-cycle mode) 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("phase1", project_dir)
+
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    # Seed standard label taxonomy — idempotent.
+    gh.ensure_standard_labels()
+
+    # Multi-cycle: create the milestone if not yet done.
+    milestone_title: str | None = None
+    if cycle is not None:
+        milestone_title = cycle.milestone_title
+        if cycle.milestone_number is None:
+            cycle.milestone_number = gh.create_milestone(
+                cycle.milestone_title,
+                cycle.scope,
+            )
+            logger.info("Created milestone %r → #%d", cycle.milestone_title, cycle.milestone_number)
+
+    # Determine completed cycle names for the prompt.
+    completed_cycles: str = "none"
+    if state.cycles:
+        closed = [c.name for c in state.cycles if c.status == "closed"]
+        if closed:
+            completed_cycles = ", ".join(closed)
+
+    prompt = load_prompt(
+        "prompt-phase-1-planning.md",
+        REQUIREMENTS_PATH=".code-generator/requirements.md",
+        CYCLE_SCOPE=(
+            cycle.scope
+            if cycle is not None
+            else "single-cycle — implement all features from requirements.md"
+        ),
+        MILESTONE_TITLE=milestone_title if milestone_title is not None else "",
+        COMPLETED_CYCLES=completed_cycles,
+    )
+
+    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=60,
+    )
+
+    await rate_limit.main_loop(
+        runner_module,
+        prompt,
+        options,
+        state_path=state_path,
+        logger=logger,
+    )
+
+    # Fetch the issues that were created by the planning session.
+    raw_issues = gh.list_issues(
+        milestone=milestone_title,
+        state="open",
+    )
+    issue_states = _build_issue_states(raw_issues)
+
+    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."
+        )
+
+    if cycle is not None:
+        cycle.issues = issue_states
+    else:
+        state.issues = issue_states
+
+    _state.save_state(state_path, state)
+    logger.info("Phase 1 complete: %d issues created.", len(issue_states))