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

code_generator/commands/generate.py

@@ -0,0 +1,252 @@
+"""generate command — orchestrate a full project generation pipeline."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from code_generator import env
+from code_generator import state as state_module
+
+# ---------------------------------------------------------------------------
+# Pause guard
+# ---------------------------------------------------------------------------
+
+
+def _check_paused(st: state_module.State) -> bool:
+    """Return True and print a message when the state is paused for rate limit.
+
+    Args:
+        st: Root state to inspect.
+
+    Returns:
+        True when the state indicates an active rate-limit pause.
+    """
+    if st.paused_until is not None and st.paused_until > time.time():
+        remaining_s = st.paused_until - time.time()
+        remaining_m = remaining_s / 60
+        typer.echo(
+            f"Rate-limit pause active — {remaining_m:.1f} minutes remaining. "
+            "Re-run after the reset window expires.",
+            err=False,
+        )
+        return True
+    return False
+
+
+# ---------------------------------------------------------------------------
+# Orchestration dispatchers
+# ---------------------------------------------------------------------------
+
+
+async def _dispatch_async(
+    st: state_module.State,
+    project_dir: Path,
+    *,
+    dry_run: bool,
+    start_phase: int,
+    start_cycle: int | None,
+    mode: str,
+) -> None:
+    """Async entry point for the orchestration pipeline.
+
+    Args:
+        st: Root state object.
+        project_dir: Project root directory.
+        dry_run: When True, only phases 0 and 1 run.
+        start_phase: Resume from this phase (1 = full run).
+        start_cycle: Resume from this cycle (multi-cycle only).
+        mode: ``"auto"``, ``"single"``, or ``"multi-cycle"``.
+    """
+    from code_generator.logging_setup import setup_phase_logger
+    from code_generator.orchestrator import cycle_loop, phase0_complexity
+    from code_generator.runner import get_runner
+
+    runner_module = get_runner()
+    logger = setup_phase_logger("generate", project_dir)
+
+    # Phase 0: determine mode when not already known.
+    needs_phase0 = mode == "auto" and st.mode not in ("single", "multi-cycle")
+    if mode == "auto":
+        needs_phase0 = st.mode not in ("single", "multi-cycle")
+    else:
+        needs_phase0 = False
+        # Force the mode from the flag.
+        st.mode = mode  # type: ignore[assignment]
+
+    if needs_phase0:
+        await phase0_complexity.run(
+            st, project_dir, runner_module=runner_module, logger=logger
+        )
+
+    # Dry-run: planning only (phase 0 + phase 1).
+    if dry_run:
+        from code_generator.orchestrator import phase1_plan
+
+        logger.info("--dry-run: running phase 1 (planning only).")
+        await phase1_plan.run(
+            st, None, project_dir, runner_module=runner_module, logger=logger
+        )
+        return
+
+    # Dispatch to cycle loop.
+    if st.mode == "multi-cycle":
+        await cycle_loop.run_multi_cycle(
+            st,
+            project_dir,
+            runner_module=runner_module,
+            logger=logger,
+            start_cycle=start_cycle,
+            start_phase=start_phase,
+        )
+    else:
+        await cycle_loop.run_single_mode(
+            st,
+            project_dir,
+            runner_module=runner_module,
+            logger=logger,
+            start_phase=start_phase,
+        )
+
+
+def _dispatch_orchestrator(
+    st: state_module.State,
+    project_dir: Path,
+    *,
+    dry_run: bool,
+    phase: int | None,
+    continue_: bool,
+    mode: str,
+    cycle: int | None,
+) -> None:
+    """Resolve resume parameters and dispatch the async orchestrator.
+
+    Args:
+        st: Root state.
+        project_dir: Project root directory.
+        dry_run: When True, only phase 0/1 planning runs.
+        phase: Resume from this explicit phase number.
+        continue_: Resume from the last completed phase/cycle in state.
+        mode: ``"auto"``, ``"single"``, or ``"multi-cycle"``.
+        cycle: Resume from this specific cycle (multi-cycle only).
+    """
+    # Resolve effective mode (honor existing state when --mode auto).
+    effective_mode = mode
+    if mode == "auto" and st.mode in ("single", "multi-cycle"):
+        effective_mode = st.mode
+
+    # Resolve start_phase and start_cycle.
+    start_phase = 1
+    start_cycle: int | None = None
+
+    if continue_:
+        # Resume from where the previous run left off.
+        if effective_mode == "multi-cycle":
+            start_cycle = st.current_cycle
+            start_phase = st.phase or 1
+        else:
+            start_phase = st.phase or 1
+
+    elif phase is not None:
+        start_phase = phase
+
+    if cycle is not None:
+        # --cycle N overrides any continue-derived start_cycle.
+        start_cycle = cycle
+        start_phase = phase or 1
+
+    asyncio.run(
+        _dispatch_async(
+            st,
+            project_dir,
+            dry_run=dry_run,
+            start_phase=start_phase,
+            start_cycle=start_cycle,
+            mode=effective_mode,
+        )
+    )
+
+
+# ---------------------------------------------------------------------------
+# Typer command
+# ---------------------------------------------------------------------------
+
+
+def generate_command(
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run/--no-dry-run", help="Print what would happen without doing it."),
+    ] = False,
+    phase: Annotated[
+        int | None,
+        typer.Option("--phase", help="Run only a specific phase number."),
+    ] = None,
+    continue_: Annotated[
+        bool,
+        typer.Option("--continue/--no-continue", help="Resume a paused generation run."),
+    ] = False,
+    mode: Annotated[
+        str,
+        typer.Option("--mode", help="Generation mode: auto, single, or multi-cycle."),
+    ] = "auto",
+    cycle: Annotated[
+        int | None,
+        typer.Option("--cycle", help="Target a specific cycle (multi-cycle mode only)."),
+    ] = None,
+) -> None:
+    """Run the full code-generation pipeline."""
+    env.assert_safe_environment()
+
+    if phase is not None and continue_:
+        typer.echo(
+            "ERROR: --phase and --continue are mutually exclusive.",
+            err=True,
+        )
+        raise typer.Exit(code=2)
+
+    if cycle is not None and mode not in ("multi-cycle",) and not continue_:
+        typer.echo(
+            "ERROR: --cycle is only valid with --mode multi-cycle or --continue.",
+            err=True,
+        )
+        raise typer.Exit(code=2)
+
+    project_dir = Path.cwd()
+    cg_dir = project_dir / ".code-generator"
+
+    if not cg_dir.exists():
+        typer.echo(
+            "ERROR: .code-generator/ not found. Run `code-generator init` first.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    st = state_module.load_state(cg_dir / "state.json")
+
+    # Rate-limit pause guard: inform user and exit cleanly.
+    if _check_paused(st):
+        raise typer.Exit(code=0)
+
+    try:
+        _dispatch_orchestrator(
+            st,
+            project_dir,
+            dry_run=dry_run,
+            phase=phase,
+            continue_=continue_,
+            mode=mode,
+            cycle=cycle,
+        )
+    except NotImplementedError as exc:
+        typer.echo(f"ERROR: {exc}", err=True)
+        raise typer.Exit(code=1) from exc
+    except Exception as exc:  # noqa: BLE001
+        from rich.console import Console
+        from rich.traceback import Traceback
+
+        Console(stderr=True).print(Traceback())
+        raise typer.Exit(code=1) from exc

code_generator/commands/init.py

@@ -0,0 +1,72 @@
+"""init command — scaffold .code-generator/ with a requirements.md template."""
+
+import importlib.resources
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from code_generator import state as state_module
+
+_VALID_TEMPLATES = frozenset(
+    {"fastapi", "angular", "nestjs", "fullstack", "python-cli", "finance"}
+)
+
+
+def _read_template(name: str) -> str:
+    return (
+        importlib.resources.files("code_generator.templates")
+        .joinpath(name + ".md")
+        .read_text(encoding="utf-8")
+    )
+
+
+def init_command(
+    template: Annotated[
+        str | None,
+        typer.Option(
+            "--template",
+            help=(
+                "Append a variant section. One of: "
+                "fastapi, angular, nestjs, fullstack, python-cli, finance."
+            ),
+        ),
+    ] = None,
+    force: Annotated[
+        bool,
+        typer.Option("--force", help="Overwrite an existing .code-generator/ directory."),
+    ] = False,
+) -> None:
+    """Scaffold .code-generator/ with a ready-to-fill requirements.md."""
+    if template is not None and template not in _VALID_TEMPLATES:
+        typer.echo(
+            f"ERROR: unknown template {template!r}. "
+            f"Valid values: {', '.join(sorted(_VALID_TEMPLATES))}",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    project_dir = Path.cwd()
+    cg_dir = project_dir / ".code-generator"
+
+    if cg_dir.exists() and not force:
+        typer.echo(
+            "ERROR: .code-generator/ already exists. Use --force to overwrite.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    cg_dir.mkdir(parents=True, exist_ok=True)
+
+    content = _read_template("base")
+    if template is not None:
+        content += _read_template(template)
+
+    (cg_dir / "requirements.md").write_text(content, encoding="utf-8")
+
+    fresh_state = state_module.load_state(cg_dir / "state.json.missing")
+    state_module.save_state(cg_dir / "state.json", fresh_state)
+
+    typer.echo(f"Initialized .code-generator/ in {project_dir}")
+    if template:
+        typer.echo(f"Template applied: {template}")

code_generator/commands/review.py

@@ -0,0 +1,117 @@
+"""review command — run a standalone code-review session via Claude."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from code_generator import env
+from code_generator.logging_setup import setup_phase_logger
+from code_generator.prompts import load_prompt
+from code_generator.runner import get_runner, rate_limit
+from code_generator.runner.retry import CircuitOpen
+from code_generator.runner.sdk_runner import OverageAbort, RunResult
+
+try:
+    from claude_agent_sdk import ClaudeAgentOptions
+
+    _SDK_AVAILABLE = True
+except ImportError:
+    _SDK_AVAILABLE = False
+    ClaudeAgentOptions = None  # type: ignore[assignment,misc]
+
+
+def _build_options() -> object:
+    """Build ClaudeAgentOptions for the review session.
+
+    Returns:
+        ClaudeAgentOptions if the SDK is available, else a duck-typed fallback.
+    """
+    if _SDK_AVAILABLE and ClaudeAgentOptions is not None:
+        return ClaudeAgentOptions(
+            model="claude-opus-4-6",
+            allowed_tools=["Read", "Grep", "Glob", "Bash"],
+            max_turns=30,
+            cwd=str(Path.cwd()),
+        )
+
+    # Fallback duck-typed options for when SDK is absent (subprocess runner).
+    class _FallbackOptions:
+        model = "claude-opus-4-6"
+        allowed_tools = ["Read", "Grep", "Glob", "Bash"]
+        max_turns = 30
+        cwd = str(Path.cwd())
+        permission_mode: str | None = None
+        resume: str | None = None
+
+    return _FallbackOptions()
+
+
+async def _run_review_session(prompt: str, project_dir: Path) -> RunResult:
+    """Execute the review session via the main runner loop.
+
+    Args:
+        prompt: The fully rendered review prompt.
+        project_dir: Root of the project being reviewed (used for state + logs).
+
+    Returns:
+        RunResult from the completed session.
+
+    Raises:
+        OverageAbort: When overage billing is detected.
+        CircuitOpen: When the circuit breaker trips on transient failures.
+    """
+    runner = get_runner()
+    logger = setup_phase_logger("review", project_dir)
+    options = _build_options()
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    return await rate_limit.main_loop(
+        runner,
+        prompt,
+        options,
+        state_path=state_path,
+        logger=logger,
+    )
+
+
+def review_command(
+    create_issues: Annotated[
+        bool,
+        typer.Option(
+            "--create-issues/--no-create-issues",
+            help="Automatically create GitHub issues for findings.",
+        ),
+    ] = False,
+    severity: Annotated[
+        str,
+        typer.Option(
+            "--severity",
+            help="Minimum severity to report: low, medium, high, or critical.",
+        ),
+    ] = "low",
+) -> None:
+    """Run a standalone code review against the current repository."""
+    env.assert_safe_environment()
+
+    prompt = load_prompt(
+        "prompt-review.md",
+        CREATE_ISSUES=str(create_issues).lower(),
+        SEVERITY_FILTER=severity,
+    )
+
+    project_dir = Path.cwd()
+
+    try:
+        result = asyncio.run(_run_review_session(prompt, project_dir))
+        typer.echo(result.text)
+        raise typer.Exit(code=0)
+    except OverageAbort as exc:
+        typer.echo(f"ERROR: {exc}", err=True)
+        raise typer.Exit(code=2) from exc
+    except CircuitOpen as exc:
+        typer.echo(f"ERROR: {exc}", err=True)
+        raise typer.Exit(code=1) from exc

code_generator/commands/status.py

@@ -0,0 +1,83 @@
+"""status command — display current project generation state."""
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from code_generator import state as state_module
+
+
+def status_command() -> None:
+    """Show the current generation state for this project."""
+    project_dir = Path.cwd()
+    state_path = project_dir / ".code-generator" / "state.json"
+
+    if not state_path.exists():
+        typer.echo(
+            "no .code-generator/state.json in this directory — "
+            "run `code-generator init` first"
+        )
+        raise typer.Exit(code=0)
+
+    st = state_module.load_state(state_path)
+    console = Console(file=typer.get_text_stream("stdout"))
+
+    _render_summary_table(console, st)
+
+    if st.mode == "multi-cycle" and st.cycles:
+        _render_cycles_table(console, st)
+
+
+def _pause_remaining(state: state_module.State) -> str:
+    import time
+
+    if state.paused_until is None:
+        return "-"
+    remaining = state.paused_until - time.time()
+    if remaining <= 0:
+        return "-"
+    minutes = remaining / 60
+    return f"{minutes:.1f} minutes remaining"
+
+
+def _render_summary_table(console: Console, st: state_module.State) -> None:
+    table = Table(title="code-generator status")
+    table.add_column("Field", style="bold")
+    table.add_column("Value")
+
+    open_issues = sum(1 for i in st.issues if i.status == "open")
+    closed_issues = sum(1 for i in st.issues if i.status == "closed")
+
+    table.add_row("mode", st.mode)
+    table.add_row("current cycle", str(st.current_cycle) if st.current_cycle is not None else "-")
+    table.add_row("current phase", str(st.phase) if st.phase is not None else "-")
+    table.add_row("open issues", str(open_issues))
+    table.add_row("closed issues", str(closed_issues))
+    table.add_row("rate-limit pause", _pause_remaining(st))
+    table.add_row("last error", st.last_error if st.last_error else "-")
+
+    console.print(table)
+
+
+def _render_cycles_table(console: Console, st: state_module.State) -> None:
+    table = Table(title="cycles")
+    table.add_column("id")
+    table.add_column("name")
+    table.add_column("status")
+    table.add_column("phase")
+    table.add_column("closed/total")
+
+    for cycle in st.cycles:
+        closed = sum(1 for i in cycle.issues if i.status == "closed")
+        total = len(cycle.issues)
+        table.add_row(
+            str(cycle.id),
+            cycle.name,
+            cycle.status,
+            str(cycle.phase),
+            f"{closed}/{total}",
+        )
+
+    console.print(table)

code_generator/env.py

@@ -0,0 +1,55 @@
+"""Environment safety module.
+
+Strips dangerous environment variables before any Claude Code invocation
+to guarantee zero API credit usage (Max subscription only).
+
+Non-negotiable constraint #1: no API keys must reach the Claude CLI.
+Reference: ITAL-IA/kb/run-deep-research.py build_agent_env().
+"""
+
+import os
+import sys
+
+DANGEROUS_VARS: tuple[str, ...] = (
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_BEDROCK_API_KEY",
+    "ANTHROPIC_VERTEX_PROJECT_ID",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+)
+
+
+def strip_dangerous_env() -> None:
+    """Remove every dangerous variable from the current process environment."""
+    for var in DANGEROUS_VARS:
+        os.environ.pop(var, None)
+
+
+def build_agent_env() -> dict[str, str]:
+    """Return a sanitized copy of the environment suitable for subprocess.run(env=...).
+
+    The returned dict contains every variable except those in DANGEROUS_VARS.
+    The calling process's os.environ is not mutated.
+    """
+    return {k: v for k, v in os.environ.items() if k not in DANGEROUS_VARS}
+
+
+def assert_safe_environment() -> None:
+    """Strip dangerous env vars from the current process, warning about each.
+
+    The process environment is mutated in place so every downstream SDK and
+    subprocess call inherits a clean environment — matching the pattern from
+    ITAL-IA/kb/run-deep-research.py build_agent_env(). The user does not need
+    to unset these variables in their shell.
+    """
+    offenders = [var for var in DANGEROUS_VARS if var in os.environ]
+    if not offenders:
+        return
+
+    listed = ", ".join(offenders)
+    print(
+        f"Using Max subscription (ignoring {listed} for this process).",
+        file=sys.stderr,
+    )
+    strip_dangerous_env()