reviewloop 0.1.0__py3-none-any.whl

reviewloop-0.1.0.dist-info/METADATA

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: reviewloop
+Version: 0.1.0
+Summary: Autonomous review loop - automates the review-fix-push cycle
+Project-URL: Homepage, https://github.com/fabianboth/autonomous-review-loop
+Project-URL: Repository, https://github.com/fabianboth/autonomous-review-loop.git
+Project-URL: Issues, https://github.com/fabianboth/autonomous-review-loop/issues
+Author: Fabian Both
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,automation,cli,code-review,developer-tools
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Requires-Dist: readchar
+Requires-Dist: rich
+Requires-Dist: typer
+Description-Content-Type: text/markdown
+
+# Autonomous Review Loop
+
+![Autonomous Review Loop](assets/review_loop.webp)
+
+A workflow tool that automates the review-fix-push cycle by delegating to your coding agent.
+
+## Why
+
+When you create a PR, code review (human or automated) generates comments you need to triage: reading each one, deciding what to fix vs. reject, discussing with your coding agent, then resolving threads one by one. The whole cycle is tedious and distracting.
+
+The solution: delegate the entire review loop to your coding agent. It waits for CI to complete, fetches all comments, decides which are valid, fixes the issues, resolves threads, pushes, and repeats until clean. You only get pulled in when there's an actual decision that needs human judgment.
+
+## Features
+
+- **Batched decision-making** - Get aggregate review requests instead of triaging individual comments one by one
+- **Parallel work** - Continue other tasks while the review loop runs autonomously in the background
+- **Multi-pass resolution** - Iterates automatically until no unresolved comments remain
+- **Agent-agnostic** - Works with any coding agent (Claude Code, Cursor, etc.) and any review tool
+
+## Prerequisites
+
+- [Claude Code](https://claude.com/code) - Anthropic's CLI for Claude
+- [GitHub CLI](https://cli.github.com/) (`gh`) - Authenticated with your account
+- [jq](https://jqlang.org/) - JSON processor
+
+## Installation
+
+```bash
+uv tool install reviewloop
+```
+
+Then initialize in your project:
+
+```bash
+reviewloop init
+```
+
+## Usage
+
+### With Claude Code Skill
+
+From your project directory with an open PR, invoke the skill:
+
+```text
+/reviewloop
+```
+
+The agent will autonomously:
+1. Wait for CI to complete
+2. Fetch and analyze review comments
+3. Fix valid issues, ask you about ambiguous ones
+4. Resolve threads and push
+5. Repeat until no comments remain
+
+### With Standalone Scripts
+
+If you initialized with `--mode script`, prompt your coding agent with the contents of `scripts/reviewloop/reviewPrompt.txt`.
+
+## Troubleshooting
+
+### "No PR found for current branch"
+
+Ensure you're on a branch with an open PR:
+
+```bash
+gh pr view
+```
+
+### "gh CLI is not authenticated"
+
+Run:
+
+```bash
+gh auth login
+```
+
+### Skill not appearing in Claude Code
+
+1. Check the skill file exists: `.claude/skills/reviewloop/SKILL.md`
+2. Verify the frontmatter is valid YAML
+3. Restart Claude Code
+
+### CI timeout
+
+The default timeout is 10 minutes. If your CI takes longer, the script will inform you and you can re-run with a longer timeout:
+
+```bash
+scripts/reviewloop/review-wait.sh --timeout=1200
+```
+
+## Status
+
+Currently in active development.

reviewloop-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+reviewloop_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reviewloop_cli/cli.py,sha256=SriV0i2otzsTOdCuNRsxlM3iGH6MT7RUaGMJS8XDHPY,898
+reviewloop_cli/init.py,sha256=4nmUpSutt-TZTmiaPQvn0IF0ppsBn-Pl2PabjKFR9YQ,7573
+reviewloop_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reviewloop_cli/templates/SKILL.md,sha256=zjcrJRefH8jX33GNC2kEjJGZ25tZZcVFbDNVrJ-K7Yw,1843
+reviewloop_cli/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reviewloop_cli/templates/scripts/review-comments.sh,sha256=GpC7ohA1aj9hTS2lpllYZLOzdwDw5sx237wpJ2gtrpA,5440
+reviewloop_cli/templates/scripts/review-wait.sh,sha256=Bb5Mhi3cCF7bdKqfZ5POVutfxly9eorGD44dKZsq9bo,3192
+reviewloop-0.1.0.dist-info/METADATA,sha256=hN24KqjxL9C8gPUNiaulwoHTz81IMK6rNSC6HrVrL3Q,3621
+reviewloop-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+reviewloop-0.1.0.dist-info/entry_points.txt,sha256=B_r1tUnWUf9C49-VdWUq2TEnELVs-s1tj3dxHy4_9LQ,55
+reviewloop-0.1.0.dist-info/licenses/LICENSE,sha256=mJJa1KbX5RMg_a-5T-2XkeytdkS2g1WwxkoikmxG8nw,1068
+reviewloop-0.1.0.dist-info/RECORD,,

reviewloop-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

reviewloop-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+reviewloop = reviewloop_cli.cli:main

reviewloop-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fabian Both
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

reviewloop_cli/cli.py

@@ -0,0 +1,37 @@
+from importlib.metadata import version
+from typing import Annotated
+
+import typer
+
+from reviewloop_cli.init import init as init_command
+
+app = typer.Typer(
+    name="reviewloop",
+    help="Autonomous review loop - automates the review-fix-push cycle.",
+    add_completion=False,
+    invoke_without_command=True,
+)
+app.command(name="init", help="Initialize reviewloop in a project.")(init_command)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        print(f"reviewloop v{version('reviewloop')}")
+        raise typer.Exit
+
+
+@app.callback()
+def callback(
+    ctx: typer.Context,
+    _version: Annotated[
+        bool | None,
+        typer.Option("--version", callback=_version_callback, is_eager=True, help="Show version and exit."),
+    ] = None,
+) -> None:
+    if ctx.invoked_subcommand is None:
+        print(ctx.get_help())
+        raise typer.Exit
+
+
+def main() -> None:
+    app()

reviewloop_cli/init.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import os
+import shutil
+import stat
+from enum import StrEnum
+from importlib.resources import files
+from pathlib import Path
+from typing import Annotated
+
+import readchar
+import typer
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.table import Table
+
+console = Console()
+
+
+class InitMode(StrEnum):
+    CLAUDE_CODE = "claude-code"
+    SCRIPT = "script"
+
+
+def _templates_path() -> Path:
+    source = files("reviewloop_cli.templates")
+    path = Path(str(source))
+    if not path.is_dir():
+        print("Error: template files not found. The reviewloop package may be corrupted — try reinstalling.")
+        raise typer.Exit(code=1)
+    return path
+
+
+def _strip_frontmatter(content: str) -> str:
+    lines = content.split("\n")
+    if not lines or lines[0].strip() != "---":
+        return content
+    for i, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            return "\n".join(lines[i + 1 :]).lstrip("\n")
+    return content
+
+
+def _get_target_files(mode: InitMode) -> list[str]:
+    if mode == InitMode.CLAUDE_CODE:
+        return [
+            ".claude/skills/reviewloop/SKILL.md",
+            ".claude/skills/reviewloop/scripts/review-wait.sh",
+            ".claude/skills/reviewloop/scripts/review-comments.sh",
+        ]
+    return [
+        "scripts/reviewloop/review-wait.sh",
+        "scripts/reviewloop/review-comments.sh",
+        "scripts/reviewloop/reviewPrompt.txt",
+    ]
+
+
+def _check_existing_files(target_dir: Path, mode: InitMode, force: bool) -> bool:
+    existing = [f for f in _get_target_files(mode) if (target_dir / f).exists()]
+    if not existing:
+        return True
+    print("The following files already exist:")
+    for f in existing:
+        print(f"  - {f}")
+    if force:
+        print("Overwriting (--force).")
+        return True
+    return typer.confirm("Overwrite?", default=False)
+
+
+def _make_executable(path: Path) -> None:
+    if os.name == "nt":
+        return
+    current = path.stat().st_mode
+    path.chmod(current | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+
+def _copy_scripts(templates: Path, scripts_dir: Path) -> list[str]:
+    scripts_dir.mkdir(parents=True, exist_ok=True)
+    created: list[str] = []
+    for name in ("review-wait.sh", "review-comments.sh"):
+        src = templates / "scripts" / name
+        dst = scripts_dir / name
+        shutil.copy2(src, dst)
+        _make_executable(dst)
+        created.append(str(dst))
+    return created
+
+
+def _init_claude_code(target_dir: Path, templates: Path) -> list[str]:
+    skill_dir = target_dir / ".claude" / "skills" / "reviewloop"
+    scripts_dir = skill_dir / "scripts"
+    skill_dir.mkdir(parents=True, exist_ok=True)
+
+    skill_src = templates / "SKILL.md"
+    skill_dst = skill_dir / "SKILL.md"
+    shutil.copy2(skill_src, skill_dst)
+
+    created = [str(skill_dst)]
+    created.extend(_copy_scripts(templates, scripts_dir))
+    return created
+
+
+def _init_script(target_dir: Path, templates: Path) -> list[str]:
+    scripts_dir = target_dir / "scripts" / "reviewloop"
+    created = _copy_scripts(templates, scripts_dir)
+
+    skill_content = (templates / "SKILL.md").read_text(encoding="utf-8")
+    prompt_content = _strip_frontmatter(skill_content)
+    prompt_content = prompt_content.replace(".claude/skills/reviewloop/scripts/", "scripts/reviewloop/")
+    prompt_path = scripts_dir / "reviewPrompt.txt"
+    prompt_path.write_text(prompt_content, encoding="utf-8")
+    created.append(str(prompt_path))
+
+    return created
+
+
+def _print_summary(created_files: list[str], target_dir: Path) -> None:
+    print(f"\nInitialized reviewloop in {target_dir}\n")
+    print("Created files:")
+    for f in created_files:
+        print(f"  {f}")
+
+
+def _get_key() -> str:
+    key = readchar.readkey()
+    if key in (readchar.key.UP, readchar.key.CTRL_P):
+        return "up"
+    if key in (readchar.key.DOWN, readchar.key.CTRL_N):
+        return "down"
+    if key == readchar.key.ENTER:
+        return "enter"
+    if key == readchar.key.ESC:
+        return "escape"
+    if key == readchar.key.CTRL_C:
+        raise KeyboardInterrupt
+    return key
+
+
+def _select_with_arrows(options: dict[str, str], title: str, default: str | None = None) -> str:
+    keys = list(options.keys())
+    selected = keys.index(default) if default and default in keys else 0
+
+    def _build_panel() -> Panel:
+        table = Table.grid(padding=(0, 2))
+        table.add_column(width=3)
+        table.add_column()
+        for i, key in enumerate(keys):
+            marker = "[cyan]\u25b6[/cyan]" if i == selected else " "
+            label = f"[bold cyan]{key}[/bold cyan]" if i == selected else f"[dim]{key}[/dim]"
+            table.add_row(marker, f"{label}  [dim]{options[key]}[/dim]")
+        table.add_row("", "")
+        table.add_row("", "[dim]\u2191/\u2193 navigate, Enter select, Esc cancel[/dim]")
+        return Panel(table, title=f"[bold]{title}[/bold]", border_style="cyan", padding=(1, 2))
+
+    console.print()
+    with Live(_build_panel(), console=console, transient=True, auto_refresh=False) as live:
+        while True:
+            try:
+                key = _get_key()
+            except KeyboardInterrupt:
+                console.print("[yellow]Cancelled[/yellow]")
+                raise typer.Exit(code=1) from None
+            if key == "up":
+                selected = (selected - 1) % len(keys)
+            elif key == "down":
+                selected = (selected + 1) % len(keys)
+            elif key == "enter":
+                return keys[selected]
+            elif key == "escape":
+                console.print("[yellow]Cancelled[/yellow]")
+                raise typer.Exit(code=1)
+            live.update(_build_panel(), refresh=True)
+
+
+def _prompt_mode() -> InitMode:
+    choices = {
+        "Claude Code": "installs as a Claude Code skill",
+        "Script based": "creates standalone scripts + prompt file",
+    }
+    selected = _select_with_arrows(choices, "Initialization mode", default="Claude Code")
+    if selected == "Script based":
+        return InitMode.SCRIPT
+    return InitMode.CLAUDE_CODE
+
+
+def _resolve_target_dir(project_name: str | None, here: bool) -> Path:
+    if here:
+        return Path.cwd()
+    if project_name is None:
+        name: str = str(typer.prompt("Project folder name"))
+    else:
+        name = project_name
+    if name == ".":
+        return Path.cwd()
+    target = Path.cwd() / name
+    target.mkdir(parents=True, exist_ok=True)
+    return target
+
+
+def init(
+    project_name: Annotated[str | None, typer.Argument(help="Target directory name for initialization.")] = None,
+    mode: Annotated[InitMode | None, typer.Option("--mode", help="Initialization mode.")] = None,
+    here: Annotated[bool, typer.Option("--here", help="Initialize in the current directory.")] = False,
+    force: Annotated[bool, typer.Option("--force", help="Overwrite existing files without confirmation.")] = False,
+) -> None:
+    if project_name is not None and here:
+        print("Error: cannot specify both a project name and --here.")
+        raise typer.Exit(code=1)
+
+    target_dir = _resolve_target_dir(project_name, here)
+
+    if mode is None:
+        mode = _prompt_mode()
+
+    if not _check_existing_files(target_dir, mode, force):
+        print("Aborted.")
+        raise typer.Exit(code=1)
+
+    templates = _templates_path()
+
+    if mode == InitMode.CLAUDE_CODE:
+        created = _init_claude_code(target_dir, templates)
+    else:
+        created = _init_script(target_dir, templates)
+
+    _print_summary(created, target_dir)

reviewloop_cli/templates/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: reviewloop
+description: Run the autonomous review loop to address PR comments, fix issues, and push changes iteratively until all comments are resolved.
+disable-model-invocation: true
+allowed-tools:
+  - Bash(.claude/skills/reviewloop/scripts/review-wait.sh*)
+  - Bash(.claude/skills/reviewloop/scripts/review-comments.sh*)
+  - Bash(gh *)
+---
+
+## Autonomous Review Loop
+
+This is an automated review loop. Follow these steps:
+
+### 1. Wait for CI to complete
+
+Run `.claude/skills/reviewloop/scripts/review-wait.sh` to poll for CI completion.
+
+- Waits 10s for CI to start (in case called right after push)
+- Polls every 15s until CI completes
+- Times out after 10 minutes (configurable with `--timeout=SECONDS`)
+- Exits immediately if no CI is in progress
+
+### 2. Fetch and address comments
+
+Once CI completes:
+
+1. Run `.claude/skills/reviewloop/scripts/review-comments.sh` to fetch comments into `.reviews/prComments.md`
+2. Review all comments critically - not all may be valid or apply to our codebase
+3. **ASK BACK** the user for decisions if needed before implementing fixes
+4. Address valid issues
+5. For inline threads: resolve via the `gh api graphql` mutation shown in the file (whether addressed or rejected)
+6. For general review comments: react with thumbs-up via the mutation shown in the file to mark as processed (even if no action was needed)
+
+### 3. Verify and commit
+
+1. Run `.claude/skills/reviewloop/scripts/review-comments.sh` again to verify no unresolved comments remain
+2. Run your project's linting and type-checking commands to ensure code quality
+3. Commit and push changes
+
+### 4. Loop
+
+Go back to step 1 - wait for the next review triggered by the push.
+
+**Exit condition**: When `.claude/skills/reviewloop/scripts/review-comments.sh` shows no comments. Give a brief high-level summary of what was addressed.

reviewloop_cli/templates/scripts/review-comments.sh

@@ -0,0 +1,161 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+GRAPHQL_QUERY='query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviews(first: 100) { nodes { id databaseId author { login } body reactions(first: 100) { nodes { user { login } content } } } } reviewThreads(first: 100) { nodes { id isResolved comments(first: 1) { nodes { author { login } path line body } } } } } } }'
+
+die() {
+    echo "Error: $1" >&2
+    exit "${2:-1}"
+}
+
+check_dependencies() {
+    command -v gh &>/dev/null || die "gh CLI is not installed. Install from https://cli.github.com/"
+    command -v jq &>/dev/null || die "jq is not installed. Install from https://stedolan.github.io/jq/download/"
+    gh auth status &>/dev/null || die "gh CLI is not authenticated. Run 'gh auth login' first."
+}
+
+get_pr_number() {
+    local pr_number
+    pr_number=$(gh pr view --json number -q '.number' 2>/dev/null) || die "No PR found for current branch"
+    [[ -n "$pr_number" ]] || die "No PR found for current branch"
+    echo "$pr_number"
+}
+
+get_repo_info() {
+    gh repo view --json owner,name 2>&1 || die "Failed to get repository info"
+}
+
+get_current_user() {
+    gh api user -q '.login' 2>&1 || die "Failed to get current user"
+}
+
+run_graphql() {
+    local owner="$1" repo="$2" pr="$3"
+    gh api graphql -F "owner=$owner" -F "repo=$repo" -F "pr=$pr" -f "query=$GRAPHQL_QUERY" 2>&1 || die "GraphQL query failed"
+}
+
+print_thread() {
+    local thread="$1" is_first="$2"
+
+    [[ "$is_first" == "false" ]] && { echo ""; echo "---"; echo ""; }
+
+    echo "## $(echo "$thread" | jq -r '.comments.nodes[0].path // "unknown"'):$(echo "$thread" | jq -r '.comments.nodes[0].line // "?"')"
+    echo ""
+    echo "**Thread ID:** \`$(echo "$thread" | jq -r '.id')\`"
+    echo "**Author:** $(echo "$thread" | jq -r '.comments.nodes[0].author.login // "unknown"')"
+    echo ""
+    echo "$thread" | jq -r '.comments.nodes[0].body // ""'
+}
+
+print_review() {
+    local review="$1" is_first="$2"
+
+    [[ "$is_first" == "false" ]] && { echo ""; echo "---"; echo ""; }
+
+    echo "**Review ID:** \`$(echo "$review" | jq -r '.id')\`"
+    echo "**Author:** $(echo "$review" | jq -r '.author // "unknown"')"
+    echo ""
+    echo "$review" | jq -r '.body // ""'
+}
+
+main() {
+    check_dependencies
+
+    local repo_info owner repo pr_number current_user
+    repo_info=$(get_repo_info)
+    owner=$(echo "$repo_info" | jq -r '.owner.login')
+    repo=$(echo "$repo_info" | jq -r '.name')
+    pr_number=$(get_pr_number)
+    current_user=$(get_current_user)
+
+    local result pr_data
+    result=$(run_graphql "$owner" "$repo" "$pr_number")
+    pr_data=$(echo "$result" | jq '.data.repository.pullRequest')
+
+    local unresolved_threads review_bodies thread_count review_count
+
+    unresolved_threads=$(echo "$pr_data" | jq '[.reviewThreads.nodes[] | select(.isResolved == false and (.comments.nodes | length) > 0)]')
+
+    # Get reviews user hasn't reacted to, strip HTML comments
+    review_bodies=$(echo "$pr_data" | jq --arg user "$current_user" '
+        [.reviews.nodes[]
+            | select(.body != null and .body != "")
+            | select(([.reactions.nodes[] | select(.user.login == $user and .content == "THUMBS_UP")] | length) == 0)
+            | {id: .id, author: .author.login, body: (.body | gsub("<!--.*?-->"; "") | gsub("^\\s+|\\s+$"; ""))}
+            | select(.body != "")
+        ]')
+
+    thread_count=$(echo "$unresolved_threads" | jq 'length')
+    review_count=$(echo "$review_bodies" | jq 'length')
+
+    mkdir -p .reviews
+
+    if [[ "$thread_count" -eq 0 ]] && [[ "$review_count" -eq 0 ]]; then
+        cat > .reviews/prComments.md << EOF
+# Review Comments
+
+**PR:** #${pr_number}
+
+No unresolved comments.
+EOF
+        echo "No unresolved comments found on this PR"
+        exit 0
+    fi
+
+    local resolve_cmd='gh api graphql -f query='\''mutation { resolveReviewThread(input: {threadId: "THREAD_ID"}) { thread { isResolved } } }'\'''
+    local react_cmd='gh api graphql -f query='\''mutation { addReaction(input: {subjectId: "REVIEW_ID", content: THUMBS_UP}) { reaction { content } } }'\'''
+
+    {
+        cat << EOF
+# Review Comments
+
+**PR:** #${pr_number}
+**Inline threads (unresolved):** ${thread_count}
+**Review comments (unreacted):** ${review_count}
+
+To resolve an inline thread after addressing it:
+\`\`\`bash
+${resolve_cmd}
+\`\`\`
+
+To mark a review as addressed (adds reaction):
+\`\`\`bash
+${react_cmd}
+\`\`\`
+
+EOF
+
+        if [[ "$thread_count" -gt 0 ]]; then
+            echo "---"
+            echo ""
+            echo "# Inline Comments (Unresolved)"
+            echo ""
+
+            local is_first=true
+            while IFS= read -r thread; do
+                print_thread "$thread" "$is_first"
+                is_first=false
+            done < <(echo "$unresolved_threads" | jq -c '.[]')
+        fi
+
+        if [[ "$review_count" -gt 0 ]]; then
+            echo ""
+            echo "---"
+            echo ""
+            echo "# Review Comments (${review_count})"
+            echo ""
+
+            local is_first=true
+            while IFS= read -r review; do
+                print_review "$review" "$is_first"
+                is_first=false
+            done < <(echo "$review_bodies" | jq -c '.[]')
+        fi
+    } > .reviews/prComments.md
+
+    echo "Saved review comments to .reviews/prComments.md:"
+    echo "  - ${thread_count} unresolved inline threads"
+    echo "  - ${review_count} review comments"
+}
+
+main "$@"

reviewloop_cli/templates/scripts/review-wait.sh

@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+# Usage: ./review-wait.sh [--timeout=600]
+set -euo pipefail
+
+INITIAL_DELAY=10
+POLL_INTERVAL=15
+DEFAULT_TIMEOUT=600
+RUNNING_STATES=(pending in_progress queued waiting requested)
+
+die() {
+    echo "Error: $1" >&2
+    exit "${2:-1}"
+}
+
+check_dependencies() {
+    command -v gh &>/dev/null || die "gh CLI is not installed. Install from https://cli.github.com/"
+    command -v jq &>/dev/null || die "jq is not installed. Install from https://stedolan.github.io/jq/download/"
+    gh auth status &>/dev/null || die "gh CLI is not authenticated. Run 'gh auth login' first."
+}
+
+get_pr_number() {
+    local pr_number
+    pr_number=$(gh pr view --json number -q '.number' 2>/dev/null) || die "No PR found for current branch"
+    [[ -n "$pr_number" ]] || die "No PR found for current branch"
+    echo "$pr_number"
+}
+
+# Returns aggregated state: if any check is running, returns that state; otherwise returns the last state
+get_ci_state() {
+    local pr_number="$1"
+    local checks_json states
+    checks_json=$(gh pr checks "$pr_number" --json name,state 2>&1) || die "Failed to fetch PR checks: $checks_json"
+
+    # Get all check states
+    states=$(echo "$checks_json" | jq -r '[.[] | .state] | if length == 0 then "" else .[] end' 2>/dev/null)
+
+    [[ -z "$states" ]] && return
+
+    # If any state is a running state, return it (priority: running > completed)
+    local state
+    while IFS= read -r state; do
+        if is_running_state "$state"; then
+            echo "$state"
+            return
+        fi
+    done <<< "$states"
+
+    # No running states found, return the last state
+    echo "$states" | tail -n1
+}
+
+is_running_state() {
+    local state="${1,,}"
+    local s
+    for s in "${RUNNING_STATES[@]}"; do
+        [[ "$state" == "$s" ]] && return 0
+    done
+    return 1
+}
+
+parse_args() {
+    TIMEOUT=$DEFAULT_TIMEOUT
+    local arg value
+    for arg in "$@"; do
+        if [[ "$arg" == --timeout=* ]]; then
+            value="${arg#--timeout=}"
+            if [[ "$value" =~ ^[0-9]+$ ]] && [[ "$value" -gt 0 ]]; then
+                TIMEOUT="$value"
+            else
+                echo "Invalid timeout value, using default" >&2
+            fi
+        fi
+    done
+}
+
+main() {
+    parse_args "$@"
+    check_dependencies
+
+    local pr_number state start_time current_time elapsed
+    pr_number=$(get_pr_number)
+
+    echo "Waiting ${INITIAL_DELAY}s for CI to start..."
+    sleep "$INITIAL_DELAY"
+
+    state=$(get_ci_state "$pr_number")
+
+    if [[ -z "$state" ]] || ! is_running_state "$state"; then
+        echo "No CI checks in progress"
+        exit 0
+    fi
+
+    echo "Waiting for CI checks on PR #${pr_number}..."
+    start_time=$(date +%s)
+
+    while true; do
+        current_time=$(date +%s)
+        elapsed=$((current_time - start_time))
+
+        if [[ $elapsed -ge $TIMEOUT ]]; then
+            echo ""
+            echo "Timeout after ${TIMEOUT}s"
+            exit 1
+        fi
+
+        state=$(get_ci_state "$pr_number")
+
+        if [[ -z "$state" ]] || ! is_running_state "$state"; then
+            echo ""
+            echo "CI completed${state:+ ($state)}"
+            exit 0
+        fi
+
+        printf "."
+        sleep "$POLL_INTERVAL"
+    done
+}
+
+main "$@"