ghreview 1.0.0

package/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run lint)",
+      "Bash(npm test)",
+      "Bash(npm run lint:*)"
+    ],
+    "deny": []
+  }
+}

package/.github/dependabot.yml

@@ -0,0 +1,16 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    commit-message:
+      prefix: "chore"
+      include: "scope"
+  - package-ecosystem: "npm"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    commit-message:
+      prefix: "chore"
+      include: "scope"

package/.github/workflows/test-and-release.yml

@@ -0,0 +1,50 @@
+name: Test & Maybe Release
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        node: [22.x, lts/*, current]
+        os: [macos-latest, ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4.2.2
+      - name: Use Node.js ${{ matrix.node }}
+        uses: actions/setup-node@v4.4.0
+        with:
+          node-version: ${{ matrix.node }}
+      - name: Install Dependencies
+        run: |
+          npm install --no-progress
+      - name: Run tests
+        run: |
+          npm config set script-shell bash
+          npm run test
+  release:
+    name: Release
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4.2.2
+        with:
+          fetch-depth: 0
+      - name: Setup Node.js
+        uses: actions/setup-node@v4.4.0
+        with:
+          node-version: lts/*
+      - name: Install dependencies
+        run: |
+          npm install --no-progress --no-save
+      - name: Build
+        run: |
+          npm run build
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npx semantic-release
+

package/AGENTS.md

@@ -0,0 +1,40 @@
+# ghreview
+
+GitHub PR-based code review workflow for AI agents.
+
+## IMPORTANT INSTRUCTIONS FOR AI AGENTS
+- NEVER perform destructive/write git commands unless explicitly asked (commit, reset, etc.)
+- The user manages their git commits - do not commit for them
+- ALWAYS run `npm run lint:fix` and `npm test` before considering changes complete
+
+## Commands
+- `ghreview init` - Push HEAD + unstaged changes as PR
+- `ghreview collect <PR>` - Output formatted review feedback (PR can be number or full URL)
+
+## Key Files
+- lib/index.js - Core logic (init, collect)
+- lib/github.js - GitHub API (Octokit)
+- lib/git.js - Git operations (simple-git)
+- lib/config.js - Config management
+
+## Architecture
+- Uses review remote to avoid polluting project
+- Creates base/timestamp and review/timestamp branches
+- Resets local changes after push
+- Formats PR comments for AI consumption
+
+## Testing
+`npm test` - Run vitest tests
+
+## Config
+~/.ghreview/config.json:
+```json
+{
+  "reviewRepo": "owner/repo",
+  "githubToken": "github_pat_...",
+  "author": {"name": "AI", "email": "ai@example.com"}
+}
+```
+
+## Environment
+- Node.js >= 22 (ES modules)

package/LICENSE

@@ -0,0 +1,174 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.

package/README.md

@@ -0,0 +1,185 @@
+# ghreview
+
+GitHub PR-based code review workflow for AI-assisted development.
+
+## Overview
+
+`ghreview` enables you to use GitHub's pull request review interface to review uncommitted code changes, particularly useful when working with AI coding assistants. It pushes your current state and uncommitted changes as a PR, lets you review and comment, then collects that feedback in a format suitable for AI consumption.
+
+## Quick Start
+
+### Without Installation (Recommended)
+
+```bash
+# Create review PR
+npx ghreview init
+
+# Collect feedback after reviewing on GitHub
+npx ghreview collect <PR-number>
+```
+
+### With Global Installation
+
+```bash
+# Install globally
+npm install -g ghreview
+
+# Use commands
+ghreview init
+ghreview collect <PR-number>
+```
+
+## Setup
+
+### 1. Create a GitHub Personal Access Token
+
+1. Go to https://github.com/settings/tokens/new (or navigate to Settings → Developer settings → Personal access tokens → Tokens (classic))
+2. Give your token a descriptive name (e.g., "ghreview")
+3. Set an expiration (or select "No expiration" for permanent access)
+4. Select the **`repo`** scope - this grants full control of private repositories
+   - ✓ repo (Full control of private repositories)
+     - ✓ repo:status
+     - ✓ repo_deployment
+     - ✓ public_repo
+     - ✓ repo:invite
+     - ✓ security_events
+5. Click "Generate token"
+6. **Important**: Copy the token immediately - you won't be able to see it again!
+
+### 2. Configure ghreview
+
+Create a configuration file at `~/.ghreview/config.json`:
+
+```json
+{
+  "reviewRepo": "yourusername/ai-code-reviews",
+  "githubToken": "ghp_xxxxxxxxxxxxxxxxxxxx"
+}
+```
+
+Replace `yourusername` with your GitHub username and paste your token in place of `ghp_xxxxxxxxxxxxxxxxxxxx`.
+
+**Security Note**: Keep your token secure! The config file contains sensitive credentials. You may want to:
+- Set appropriate file permissions: `chmod 600 ~/.ghreview/config.json`
+- Never commit this file to version control
+- Consider using a token with an expiration date
+
+The review repository will be created automatically as a private repo if it doesn't exist.
+
+## Configuration Options
+
+### Basic Configuration
+
+```json
+{
+  "reviewRepo": "yourusername/ai-code-reviews",
+  "githubToken": "ghp_xxxxxxxxxxxxxxxxxxxx"
+}
+```
+
+### With Custom Author
+
+```json
+{
+  "reviewRepo": "yourusername/ai-code-reviews",
+  "githubToken": "ghp_xxxxxxxxxxxxxxxxxxxx",
+  "author": {
+    "name": "AI Assistant",
+    "email": "ai@example.com"
+  }
+}
+```
+
+The `author` configuration makes commits appear as if they were created by the AI, making it clearer that you're reviewing the AI's proposed changes.
+
+## Workflow
+
+1. **Make changes to your code** (but don't commit them)
+
+2. **Create a review PR**:
+   ```bash
+   npx ghreview init
+   ```
+   This will:
+   - Push your current commit as a base branch
+   - Push your uncommitted changes as a review branch
+   - Create a PR comparing the two
+   - Output a URL to review the changes
+
+3. **Review on GitHub**:
+   - Click the provided URL
+   - Review the changes using GitHub's PR interface
+   - Leave inline comments on specific lines
+   - Add general comments about architecture or approach
+
+4. **Collect feedback**:
+   ```bash
+   # Using PR number (defaults to review repo)
+   npx ghreview collect 42
+
+   # Using full PR URL (works with any GitHub repo)
+   npx ghreview collect https://github.com/owner/repo/pull/123
+   ```
+   This outputs formatted feedback that you can copy and paste into your AI assistant.
+
+5. **Iterate**: Your local changes remain uncommitted, so you can continue working and create new review PRs as needed.
+
+## Example Output
+
+```markdown
+## Code Review Feedback
+
+### File: src/auth/login.js
+
+#### Line 45
+Variable 'username' could be undefined here. Add null check.
+
+#### Lines 67-70
+Use consistent async/await instead of mixing with .then()
+
+### File: src/utils/validation.js
+
+#### Line 12
+Regex for email validation is too permissive
+
+#### Lines 23-28
+**Comment 1:** This validation logic is duplicated in register.js
+**Comment 2:** Consider extracting to a shared validation utility
+
+### General Comments
+
+---
+
+Consider adding rate limiting to login attempts
+
+---
+
+The session token storage in localStorage is insecure
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run linter
+npm run lint
+
+# Fix linting issues automatically
+npm run lint:fix
+
+# Run tests
+npm test
+```
+
+## Requirements
+
+- Node.js >= 22
+- Git
+- GitHub personal access token (configured in `~/.ghreview/config.json`)
+- SSH access to GitHub (the tool uses `git@github.com:` URLs for pushing)
+
+## License
+
+Apache-2.0

package/bin/ghreview.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import yargs from 'yargs'
+import { hideBin } from 'yargs/helpers'
+import { init, collect } from '../lib/index.js'
+import chalk from 'chalk'
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\n' + chalk.yellow('Operation cancelled by user'))
+  process.exit(1)
+})
+
+process.on('SIGTERM', () => {
+  process.exit(1)
+})
+
+yargs(hideBin(process.argv))
+  .scriptName('ghreview')
+  .usage('$0 <command> [args]')
+  .command('init', 'Create a PR for review', {}, async () => {
+    try {
+      await init()
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message)
+      process.exit(1)
+    }
+  })
+  .command('collect <pr>', 'Collect feedback from PR',
+    (yargs) => {
+      return yargs.positional('pr', {
+        describe: 'PR number or full GitHub PR URL',
+        type: 'string'
+      })
+    },
+    async (argv) => {
+      try {
+        await collect(argv.pr)
+      } catch (error) {
+        console.error(chalk.red('Error:'), error.message)
+        process.exit(1)
+      }
+    }
+  )
+  .demandCommand(1, 'You need to specify a command')
+  .help()
+  .alias('help', 'h')
+  .version()
+  .alias('version', 'v')
+  .parse()

package/lib/config.js

@@ -0,0 +1,42 @@
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+
+const CONFIG_DIR = path.join(os.homedir(), '.ghreview')
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+
+export async function loadConfig () {
+  try {
+    const configData = await fs.readFile(CONFIG_FILE, 'utf8')
+    const config = JSON.parse(configData)
+
+    // Validate required fields
+    if (!config.reviewRepo) {
+      throw new Error('Missing required config field: reviewRepo')
+    }
+
+    if (!config.githubToken) {
+      throw new Error('Missing required config field: githubToken\n\nTo create a GitHub token:\n1. Go to https://github.com/settings/tokens/new\n2. Give it a name (e.g., "ghreview")\n3. Select scopes: "repo" (Full control of private repositories)\n4. Click "Generate token"\n5. Copy the token and add it to your config file')
+    }
+
+    // Validate repo format
+    if (!config.reviewRepo.includes('/')) {
+      throw new Error('Invalid reviewRepo format. Expected: owner/repo')
+    }
+
+    return config
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new Error(`Config file not found at ${CONFIG_FILE}\nCreate it with: {"reviewRepo": "owner/repo", "githubToken": "your_github_token"}`)
+    }
+    throw error
+  }
+}
+
+export async function ensureConfigDir () {
+  try {
+    await fs.mkdir(CONFIG_DIR, { recursive: true })
+  } catch (error) {
+    // Directory might already exist, that's fine
+  }
+}

package/lib/git.js

@@ -0,0 +1,73 @@
+import simpleGit from 'simple-git'
+
+export async function getCurrentBranch () {
+  const git = simpleGit()
+  try {
+    const status = await git.status()
+    return status.current
+  } catch (error) {
+    throw new Error(`Failed to get current branch: ${error.message}`)
+  }
+}
+
+export async function hasUnstagedChanges () {
+  const git = simpleGit()
+  const status = await git.status()
+  return status.files.length > 0
+}
+
+export async function createReviewCommit (message, authorConfig) {
+  const git = simpleGit()
+
+  // Add all changes
+  await git.add('.')
+
+  // Set up environment for custom author if provided
+  const env = {}
+  if (authorConfig?.name && authorConfig?.email) {
+    env.GIT_AUTHOR_NAME = authorConfig.name
+    env.GIT_AUTHOR_EMAIL = authorConfig.email
+    env.GIT_COMMITTER_NAME = authorConfig.name
+    env.GIT_COMMITTER_EMAIL = authorConfig.email
+  }
+
+  // Create commit with optional custom author
+  await git.env(env).commit(message)
+}
+
+export async function pushBranch (remote, branch) {
+  const git = simpleGit()
+  try {
+    await git.push(remote, branch)
+  } catch (error) {
+    throw new Error(`Failed to push to ${remote} ${branch}: ${error.message}`)
+  }
+}
+
+export async function resetLastCommit () {
+  const git = simpleGit()
+  await git.reset(['HEAD~1'])
+}
+
+export async function getCurrentCommitHash () {
+  const git = simpleGit()
+  const log = await git.log(['-1'])
+  return log.latest.hash
+}
+
+export async function ensureReviewRemote (repoUrl) {
+  const git = simpleGit()
+  const remotes = await git.getRemotes(true) // Get verbose info with URLs
+
+  const reviewRemote = remotes.find(r => r.name === 'review')
+
+  if (!reviewRemote) {
+    await git.addRemote('review', repoUrl)
+  } else if (reviewRemote.refs.push !== repoUrl) {
+    // Update if URL changed (e.g., user switched review repos)
+    await git.removeRemote('review')
+    await git.addRemote('review', repoUrl)
+  }
+
+  return 'review'
+}

package/lib/github.js

@@ -0,0 +1,163 @@
+import { Octokit } from '@octokit/rest'
+import chalk from 'chalk'
+
+export function createOctokit (token) {
+  if (!token) {
+    throw new Error('GitHub token is required in config file.\n\nTo create a token:\n1. Go to https://github.com/settings/tokens/new\n2. Give it a name (e.g., "ghreview")\n3. Select scopes: "repo" (Full control of private repositories)\n4. Click "Generate token"\n5. Copy the token and add it to ~/.ghreview/config.json')
+  }
+
+  return new Octokit({
+    auth: token
+  })
+}
+
+export async function ensureRepoExists (owner, repo, token) {
+  const octokit = createOctokit(token)
+
+  try {
+    await octokit.rest.repos.get({ owner, repo })
+    return true
+  } catch (error) {
+    if (error.status === 404) {
+      console.log(chalk.yellow(`Creating review repository: ${owner}/${repo}`))
+      await octokit.rest.repos.createForAuthenticatedUser({
+        name: repo,
+        private: true,
+        description: 'AI code review workspace',
+        auto_init: true
+      })
+      return true
+    }
+    throw error
+  }
+}
+
+export async function createPullRequest (owner, repo, head, base, title, token) {
+  const octokit = createOctokit(token)
+
+  const { data: pr } = await octokit.rest.pulls.create({
+    owner,
+    repo,
+    title,
+    head,
+    base,
+    body: `Review checkpoint for AI-assisted development
+
+This PR contains uncommitted changes for review.
+
+## How to Review
+
+1. **Inline Comments**: Click on specific lines and add comments. Use the "Add a suggestion" feature to propose specific code changes.
+2. **Line Ranges**: You can select multiple lines by clicking and dragging to comment on blocks of code.
+3. **General Comments**: Use the main PR comment box at the bottom for architectural or high-level feedback.
+
+All comments will be collected with line numbers and context for AI consumption.`
+  })
+
+  return pr
+}
+
+export async function fetchReviewComments (owner, repo, prNumber, token) {
+  const octokit = createOctokit(token)
+
+  // Fetch inline comments
+  const { data: comments } = await octokit.rest.pulls.listReviewComments({
+    owner,
+    repo,
+    pull_number: prNumber
+  })
+
+  // Fetch PR reviews (general comments)
+  const { data: reviews } = await octokit.rest.pulls.listReviews({
+    owner,
+    repo,
+    pull_number: prNumber
+  })
+
+  // Fetch issue comments (PR discussion)
+  const { data: issueComments } = await octokit.rest.issues.listComments({
+    owner,
+    repo,
+    issue_number: prNumber
+  })
+
+  return {
+    inline: comments,
+    reviews: reviews.filter(r => r.body), // Only reviews with comments
+    discussion: issueComments
+  }
+}
+
+export function formatFeedback (comments, filterBots = true) {
+  let output = '## Code Review Feedback\n\n'
+
+  // Filter out bot comments if requested
+  const isBot = (comment) => {
+    return filterBots && (
+      comment.user?.type === 'Bot' ||
+      comment.user?.login?.includes('[bot]') ||
+      comment.user?.login?.includes('-bot')
+    )
+  }
+
+  // Group inline comments by file and line range
+  const byFile = {}
+  // First, collect all comments without grouping
+  const allComments = comments.inline
+    .filter(comment => !isBot(comment))
+    .map(comment => ({
+      file: comment.path,
+      line: comment.line || comment.original_line,
+      startLine: comment.start_line || comment.original_start_line,
+      position: comment.position,
+      body: comment.body,
+      id: comment.id
+    }))
+
+  // Group by file
+  allComments.forEach(comment => {
+    if (!byFile[comment.file]) {
+      byFile[comment.file] = []
+    }
+    byFile[comment.file].push(comment)
+  })
+
+  // Format inline comments with better structure
+  if (Object.keys(byFile).length > 0) {
+    Object.entries(byFile).forEach(([file, fileComments]) => {
+      output += `### File: ${file}\n\n`
+
+      // Sort by position (or line number as fallback)
+      const sortedComments = fileComments.sort((a, b) => {
+        // Try position first, then line number
+        if (a.position && b.position) return a.position - b.position
+        return a.line - b.line
+      })
+
+      // Don't group comments - treat each as individual
+      sortedComments.forEach(comment => {
+        const lineRange = comment.startLine && comment.startLine !== comment.line
+          ? `Lines ${comment.startLine}-${comment.line}`
+          : `Line ${comment.line}`
+
+        output += `#### ${lineRange}\n`
+        output += `${comment.body}\n\n`
+      })
+    })
+  }
+
+  // Format general review comments (filter bots)
+  const generalComments = [
+    ...comments.reviews.filter(r => !isBot(r)).map(r => r.body),
+    ...comments.discussion.filter(c => !isBot(c)).map(c => c.body)
+  ].filter(Boolean)
+
+  if (generalComments.length > 0) {
+    output += '### General Comments\n\n'
+    generalComments.forEach((comment, index) => {
+      output += `---\n\n${comment}\n\n`
+    })
+  }
+
+  return output
+}

package/lib/index.js

@@ -0,0 +1,149 @@
+import chalk from 'chalk'
+import ora from 'ora'
+import { loadConfig } from './config.js'
+import {
+  getCurrentBranch,
+  hasUnstagedChanges,
+  createReviewCommit,
+  pushBranch,
+  resetLastCommit,
+  ensureReviewRemote
+} from './git.js'
+import {
+  ensureRepoExists,
+  createPullRequest,
+  fetchReviewComments,
+  formatFeedback
+} from './github.js'
+
+export async function init () {
+  const spinner = ora('Initializing review').start()
+  let commitCreated = false
+
+  try {
+    // Check if we're in a git repository
+    try {
+      await getCurrentBranch()
+    } catch (error) {
+      spinner.fail('Not in a git repository')
+      console.error(chalk.red('Please run this command from within a git repository'))
+      console.error(chalk.yellow('\nTo initialize a new repository with minimal setup:'))
+      console.error(chalk.gray('  git init'))
+      console.error(chalk.gray('  echo "# Project" > README.md'))
+      console.error(chalk.gray('  git add README.md'))
+      console.error(chalk.gray('  git commit -m "Initial commit"'))
+      return
+    }
+
+    // Load config
+    const config = await loadConfig()
+    const [owner, repo] = config.reviewRepo.split('/')
+
+    // Check for unstaged changes
+    if (!await hasUnstagedChanges()) {
+      spinner.fail('No unstaged changes to review')
+      return
+    }
+
+    // Ensure review repo exists
+    spinner.text = 'Checking review repository'
+    await ensureRepoExists(owner, repo, config.githubToken)
+
+    // Set up review remote (using SSH for authentication)
+    const repoUrl = `git@github.com:${config.reviewRepo}.git`
+    await ensureReviewRemote(repoUrl)
+
+    // Generate timestamp for branch names
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5)
+    const baseBranch = `base/${timestamp}`
+    const reviewBranch = `review/${timestamp}`
+
+    // Push current HEAD as base branch
+    spinner.text = 'Pushing base branch'
+    const currentBranch = await getCurrentBranch()
+    await pushBranch('review', `${currentBranch}:${baseBranch}`)
+
+    // Create temporary commit with changes
+    spinner.text = 'Creating review commit'
+    await createReviewCommit(
+      `Review checkpoint ${timestamp}`,
+      config.author
+    )
+    commitCreated = true
+
+    // Push review branch
+    spinner.text = 'Pushing review branch'
+    await pushBranch('review', `HEAD:${reviewBranch}`)
+
+    // Create PR
+    spinner.text = 'Creating pull request'
+    const pr = await createPullRequest(
+      owner,
+      repo,
+      reviewBranch,
+      baseBranch,
+      `AI Code Review - ${timestamp}`,
+      config.githubToken
+    )
+
+    spinner.succeed('Review created successfully')
+    console.log(chalk.green('✓'), 'Created PR #' + pr.number)
+    console.log(chalk.blue('🔗'), pr.html_url)
+  } catch (error) {
+    spinner.fail('Failed to create review')
+    throw error
+  } finally {
+    // Always reset the commit if we created one
+    if (commitCreated) {
+      try {
+        await resetLastCommit()
+      } catch (resetError) {
+        console.error(chalk.yellow('Warning: Failed to reset temporary commit'))
+      }
+    }
+  }
+}
+
+export async function collect (prInput) {
+  const spinner = ora('Collecting feedback').start()
+
+  try {
+    // Load config
+    const config = await loadConfig()
+
+    let owner, repo, prNumber
+
+    // Check if input is a URL or just a number
+    if (prInput.toString().includes('github.com')) {
+      // Parse GitHub PR URL
+      const urlMatch = prInput.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/)
+      if (!urlMatch) {
+        throw new Error('Invalid GitHub PR URL format')
+      }
+      [, owner, repo, prNumber] = urlMatch
+      prNumber = parseInt(prNumber, 10)
+    } else {
+      // Use default review repo
+      [owner, repo] = config.reviewRepo.split('/')
+      prNumber = parseInt(prInput, 10)
+
+      // Validate the PR number
+      if (isNaN(prNumber) || prNumber <= 0) {
+        throw new Error(`Invalid PR number: ${prInput}`)
+      }
+    }
+
+    // Fetch all comments
+    spinner.text = `Fetching review comments from ${owner}/${repo}#${prNumber}`
+    const comments = await fetchReviewComments(owner, repo, prNumber, config.githubToken)
+
+    // Format feedback
+    const feedback = formatFeedback(comments)
+
+    spinner.succeed('Feedback collected')
+    console.log('\n' + feedback)
+  } catch (error) {
+    spinner.fail('Failed to collect feedback')
+    throw error
+  }
+}

package/package.json

@@ -0,0 +1,130 @@
+{
+  "name": "ghreview",
+  "version": "1.0.0",
+  "description": "GitHub PR-based code review workflow for AI-assisted development",
+  "type": "module",
+  "main": "lib/index.js",
+  "bin": {
+    "ghreview": "bin/ghreview.js"
+  },
+  "scripts": {
+    "test": "npm run lint && vitest run",
+    "test:watch": "npm run lint && vitest",
+    "lint": "standard",
+    "lint:fix": "standard --fix",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "github",
+    "code-review",
+    "ai",
+    "cli",
+    "pull-request"
+  ],
+  "author": "Rod <rod@vagg.org> (http://r.va.gg/)",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@octokit/rest": "^22.0.0",
+    "chalk": "^5.4.1",
+    "ora": "^8.2.0",
+    "simple-git": "^3.28.0",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.3",
+    "@semantic-release/npm": "^12.0.2",
+    "@semantic-release/release-notes-generator": "^14.0.3",
+    "conventional-changelog-conventionalcommits": "^9.0.0",
+    "nock": "^14.0.7",
+    "standard": "^17.1.2",
+    "vitest": "^3.2.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rvagg/ghreview.git"
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      [
+        "@semantic-release/commit-analyzer",
+        {
+          "preset": "conventionalcommits",
+          "releaseRules": [
+            {
+              "breaking": true,
+              "release": "major"
+            },
+            {
+              "revert": true,
+              "release": "patch"
+            },
+            {
+              "type": "feat",
+              "release": "minor"
+            },
+            {
+              "type": "fix",
+              "release": "patch"
+            },
+            {
+              "type": "chore",
+              "release": "patch"
+            },
+            {
+              "type": "docs",
+              "release": "patch"
+            },
+            {
+              "type": "test",
+              "release": "patch"
+            },
+            {
+              "scope": "no-release",
+              "release": false
+            }
+          ]
+        }
+      ],
+      [
+        "@semantic-release/release-notes-generator",
+        {
+          "preset": "conventionalcommits",
+          "presetConfig": {
+            "types": [
+              {
+                "type": "feat",
+                "section": "Features"
+              },
+              {
+                "type": "fix",
+                "section": "Bug Fixes"
+              },
+              {
+                "type": "chore",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "docs",
+                "section": "Trivial Changes"
+              },
+              {
+                "type": "test",
+                "section": "Tests"
+              }
+            ]
+          }
+        }
+      ],
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      "@semantic-release/git"
+    ]
+  }
+}

package/test/ghreview.test.js

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { init, collect } from '../lib/index.js'
+import * as config from '../lib/config.js'
+import * as git from '../lib/git.js'
+import * as github from '../lib/github.js'
+
+vi.mock('../lib/config.js')
+vi.mock('../lib/git.js')
+vi.mock('../lib/github.js')
+
+describe('ghreview', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('init', () => {
+    it('should create a PR when there are unstaged changes', async () => {
+      // Mock config
+      vi.mocked(config.loadConfig).mockResolvedValue({
+        reviewRepo: 'owner/repo',
+        githubToken: 'test-token',
+        author: { name: 'AI', email: 'ai@example.com' }
+      })
+
+      // Mock git operations
+      vi.mocked(git.hasUnstagedChanges).mockResolvedValue(true)
+      vi.mocked(git.getCurrentBranch).mockResolvedValue('main')
+      vi.mocked(git.ensureReviewRemote).mockResolvedValue('review')
+      vi.mocked(git.createReviewCommit).mockResolvedValue()
+      vi.mocked(git.pushBranch).mockResolvedValue()
+      vi.mocked(git.resetLastCommit).mockResolvedValue()
+
+      // Mock GitHub operations
+      vi.mocked(github.ensureRepoExists).mockResolvedValue(true)
+      vi.mocked(github.createPullRequest).mockResolvedValue({
+        number: 42,
+        html_url: 'https://github.com/owner/repo/pull/42'
+      })
+
+      // Run init
+      await init()
+
+      // Verify calls
+      expect(git.hasUnstagedChanges).toHaveBeenCalled()
+      expect(git.createReviewCommit).toHaveBeenCalled()
+      expect(git.pushBranch).toHaveBeenCalledTimes(2) // base and review
+      expect(git.resetLastCommit).toHaveBeenCalled()
+      expect(github.createPullRequest).toHaveBeenCalled()
+    })
+
+    it('should exit early when no unstaged changes', async () => {
+      vi.mocked(config.loadConfig).mockResolvedValue({
+        reviewRepo: 'owner/repo',
+        githubToken: 'test-token'
+      })
+      vi.mocked(git.hasUnstagedChanges).mockResolvedValue(false)
+
+      await init()
+
+      expect(git.createReviewCommit).not.toHaveBeenCalled()
+      expect(github.createPullRequest).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('collect', () => {
+    it('should collect and format feedback', async () => {
+      vi.mocked(config.loadConfig).mockResolvedValue({
+        reviewRepo: 'owner/repo',
+        githubToken: 'test-token'
+      })
+
+      const mockComments = {
+        inline: [{
+          path: 'src/main.js',
+          line: 10,
+          body: 'Fix this'
+        }],
+        reviews: [{
+          body: 'General comment'
+        }],
+        discussion: []
+      }
+
+      vi.mocked(github.fetchReviewComments).mockResolvedValue(mockComments)
+      vi.mocked(github.formatFeedback).mockReturnValue('## Formatted feedback')
+
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+      await collect(42)
+
+      expect(github.fetchReviewComments).toHaveBeenCalledWith('owner', 'repo', 42, 'test-token')
+      expect(github.formatFeedback).toHaveBeenCalledWith(mockComments)
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Formatted feedback'))
+    })
+  })
+})