gh-load-pull-request 0.4.0

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <https://unlicense.org>

package/README.md

@@ -0,0 +1,233 @@
+# gh-download-pull-request
+
+[![npm version](https://img.shields.io/npm/v/gh-download-pull-request)](https://www.npmjs.com/package/gh-download-pull-request)
+
+Download GitHub pull request and convert it to markdown - perfect for AI review and analysis.
+
+## Features
+
+- Download any GitHub pull request as markdown
+- Includes PR metadata, commits, files, reviews, and comments
+- Support for both public and private repositories
+- Multiple input formats for convenience
+- GitHub CLI integration for seamless authentication
+- Output to file or stdout
+
+## Quick Start
+
+```bash
+# Download a PR and display as markdown
+gh-download-pull-request https://github.com/owner/repo/pull/123
+
+# Using shorthand format
+gh-download-pull-request owner/repo#123
+
+# Save to file
+gh-download-pull-request owner/repo#123 -o pr.md
+
+# Download private PR (uses gh CLI auth automatically)
+gh-download-pull-request owner/private-repo#456
+```
+
+## Installation
+
+### Global Installation (Recommended)
+
+Install globally for system-wide access:
+
+```bash
+# Using bun
+bun install -g gh-download-pull-request
+
+# Using npm
+npm install -g gh-download-pull-request
+
+# After installation, use anywhere:
+gh-download-pull-request --help
+```
+
+### Uninstall
+
+Remove the global installation:
+
+```bash
+# Using bun
+bun uninstall -g gh-download-pull-request
+
+# Using npm
+npm uninstall -g gh-download-pull-request
+```
+
+### Local Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/link-foundation/gh-download-pull-request.git
+cd gh-download-pull-request
+
+# Install dependencies
+npm install
+
+# Make the script executable
+chmod +x gh-download-pull-request.mjs
+
+# Run it
+./gh-download-pull-request.mjs --help
+```
+
+## Usage
+
+```
+Usage: gh-download-pull-request <pr-url> [options]
+
+Options:
+  -t, --token    GitHub personal access token (optional for public PRs)
+  -o, --output   Output file path (default: stdout)
+  -h, --help     Show help
+  --version      Show version number
+```
+
+## Input Formats
+
+The tool supports multiple formats for specifying a pull request:
+
+1. **Full URL**: `https://github.com/owner/repo/pull/123`
+2. **Shorthand with #**: `owner/repo#123`
+3. **Shorthand with /**: `owner/repo/123`
+
+## Authentication
+
+The tool supports multiple authentication methods for accessing private repositories:
+
+### 1. GitHub CLI (Recommended)
+
+If you have [GitHub CLI](https://cli.github.com/) installed and authenticated, the tool will automatically use your credentials:
+
+```bash
+# Authenticate with GitHub CLI (one-time setup)
+gh auth login
+
+# Tool automatically detects and uses gh CLI authentication
+gh-download-pull-request owner/private-repo#123
+```
+
+### 2. Environment Variable
+
+Set the `GITHUB_TOKEN` environment variable:
+
+```bash
+export GITHUB_TOKEN=ghp_your_token_here
+gh-download-pull-request owner/repo#123
+```
+
+### 3. Command Line Token
+
+Pass the token directly with `--token`:
+
+```bash
+gh-download-pull-request owner/repo#123 --token ghp_your_token_here
+```
+
+### Authentication Priority
+
+The tool uses this fallback chain:
+
+1. `--token` command line argument (highest priority)
+2. `GITHUB_TOKEN` environment variable
+3. GitHub CLI authentication (if `gh` is installed and authenticated)
+4. No authentication (public PRs only)
+
+## Output Format
+
+The markdown output includes:
+
+- **Header**: PR title
+- **Metadata**: PR number, author, status, dates, branch info, stats
+- **Description**: Full PR description/body
+- **Commits**: List of all commits with links and authors
+- **Files Changed**: All modified files with change stats
+- **Reviews**: All PR reviews with approval status
+- **Review Comments**: Inline code review comments with diff context
+- **Comments**: General discussion comments
+
+## Examples
+
+```bash
+# Basic usage - download and display PR
+gh-download-pull-request https://github.com/facebook/react/pull/28000
+
+# Using shorthand format
+gh-download-pull-request facebook/react#28000
+
+# Save to file
+gh-download-pull-request facebook/react#28000 -o react-pr-28000.md
+
+# Download private PR using gh CLI auth
+gh-download-pull-request myorg/private-repo#42
+
+# Download with explicit token
+gh-download-pull-request myorg/repo#123 --token ghp_your_token_here
+
+# Pipe to other tools (e.g., AI for review)
+gh-download-pull-request owner/repo#123 | claude-analyze
+```
+
+## Requirements
+
+- [Bun](https://bun.sh/) (>=1.2.0) or [Node.js](https://nodejs.org/) (>=22.17.0) runtime
+- For private repositories (optional):
+  - [GitHub CLI](https://cli.github.com/) (recommended) OR
+  - GitHub personal access token (via `--token` or `GITHUB_TOKEN` env var)
+
+## Use Cases
+
+- **AI Code Review**: Download PRs as markdown for analysis by AI assistants
+- **Documentation**: Archive important PRs for future reference
+- **Offline Review**: Review PRs without internet connection
+- **Custom Analysis**: Process PR data with custom scripts
+- **Team Workflows**: Integrate PR data into custom review processes
+
+## Testing
+
+```bash
+# Run all tests
+npm test
+
+# Or run test files directly
+node tests/all.test.mjs
+node tests/cli.test.mjs
+```
+
+## Development
+
+```bash
+# Clone the repository
+git clone https://github.com/link-foundation/gh-download-pull-request.git
+cd gh-download-pull-request
+
+# Install dependencies
+npm install
+
+# Make executable
+chmod +x gh-download-pull-request.mjs
+
+# Test locally
+./gh-download-pull-request.mjs owner/repo#123
+
+# Run tests
+npm test
+
+# Run linting
+npm run lint
+
+# Bump version
+./version.mjs patch  # or minor, major
+```
+
+## Related Projects
+
+- [gh-pull-all](https://github.com/link-foundation/gh-pull-all) - Efficiently sync all repositories from a GitHub organization or user
+
+## License
+
+This project is released into the public domain under The Unlicense - see [LICENSE](LICENSE) file for details.

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "gh-load-pull-request",
+  "version": "0.4.0",
+  "description": "Download GitHub pull request and convert it to markdown",
+  "type": "module",
+  "main": "src/gh-download-pull-request.mjs",
+  "bin": {
+    "gh-download-pull-request": "./src/gh-download-pull-request.mjs"
+  },
+  "scripts": {
+    "test": "node --test tests/",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "check:file-size": "node scripts/check-file-size.mjs",
+    "check": "npm run lint && npm run format:check && npm run check:file-size",
+    "prepare": "husky",
+    "changeset": "changeset",
+    "changeset:version": "node scripts/changeset-version.mjs",
+    "changeset:publish": "changeset publish",
+    "changeset:status": "changeset status --since=origin/main",
+    "version:patch": "./src/version.mjs patch",
+    "version:minor": "./src/version.mjs minor",
+    "version:major": "./src/version.mjs major"
+  },
+  "keywords": [
+    "github",
+    "pull-request",
+    "markdown",
+    "cli",
+    "tool",
+    "pr",
+    "download"
+  ],
+  "author": "Link.Foundation",
+  "license": "Unlicense",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/link-foundation/gh-download-pull-request.git"
+  },
+  "bugs": {
+    "url": "https://github.com/link-foundation/gh-download-pull-request/issues"
+  },
+  "homepage": "https://github.com/link-foundation/gh-download-pull-request#readme",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@octokit/rest": "^22.0.0",
+    "fs-extra": "^11.3.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.29.7",
+    "eslint": "^9.38.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.6",
+    "prettier": "^3.6.2",
+    "test-anywhere": "^0.8.48"
+  },
+  "lint-staged": {
+    "*.{js,mjs,cjs}": [
+      "eslint --fix --max-warnings 0",
+      "prettier --write",
+      "prettier --check"
+    ],
+    "*.md": [
+      "prettier --write",
+      "prettier --check"
+    ]
+  }
+}

package/src/gh-download-pull-request.mjs

@@ -0,0 +1,924 @@
+#!/usr/bin/env sh
+':'; // # ; exec "$(command -v bun || command -v node)" "$0" "$@"
+
+// Import built-in Node.js modules
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import https from 'node:https';
+import http from 'node:http';
+
+// Get __dirname equivalent for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Import npm dependencies
+import { Octokit } from '@octokit/rest';
+import fs from 'fs-extra';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+// Get version from package.json or fallback
+let version = '0.1.0'; // Fallback version
+
+try {
+  const packagePath = path.join(__dirname, 'package.json');
+  // Use node:fs for Deno compatibility (fs-extra has issues with Deno)
+  const { readFileSync, existsSync } = await import('node:fs');
+  if (existsSync(packagePath)) {
+    const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+    version = packageJson.version;
+  }
+} catch (_error) {
+  // Use fallback version if package.json can't be read
+}
+
+// Colors for console output
+const colors = {
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  reset: '\x1b[0m',
+};
+
+// Verbose logging flag (set by CLI option)
+let verboseMode = false;
+
+const log = (color, message) =>
+  console.error(`${colors[color]}${message}${colors.reset}`);
+
+const verboseLog = (color, message) => {
+  if (verboseMode) {
+    log(color, message);
+  }
+};
+
+// Helper function to check if gh CLI is installed
+async function isGhInstalled() {
+  try {
+    const { execSync } = await import('node:child_process');
+    execSync('gh --version', { stdio: 'pipe' });
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+
+// Helper function to get GitHub token from gh CLI if available
+async function getGhToken() {
+  try {
+    if (!(await isGhInstalled())) {
+      return null;
+    }
+
+    const { execSync } = await import('node:child_process');
+    const token = execSync('gh auth token', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    }).trim();
+    return token;
+  } catch (_error) {
+    return null;
+  }
+}
+
+// Parse PR URL to extract owner, repo, and PR number
+function parsePrUrl(url) {
+  // Support multiple formats:
+  // https://github.com/owner/repo/pull/123
+  // owner/repo#123
+  // owner/repo/123
+
+  // Try full URL format
+  const urlMatch = url.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
+  if (urlMatch) {
+    return {
+      owner: urlMatch[1],
+      repo: urlMatch[2],
+      prNumber: parseInt(urlMatch[3], 10),
+    };
+  }
+
+  // Try shorthand format: owner/repo#123
+  const shortMatch = url.match(/^([^/]+)\/([^#/]+)#(\d+)$/);
+  if (shortMatch) {
+    return {
+      owner: shortMatch[1],
+      repo: shortMatch[2],
+      prNumber: parseInt(shortMatch[3], 10),
+    };
+  }
+
+  // Try alternative format: owner/repo/123
+  const altMatch = url.match(/^([^/]+)\/([^/]+)\/(\d+)$/);
+  if (altMatch) {
+    return {
+      owner: altMatch[1],
+      repo: altMatch[2],
+      prNumber: parseInt(altMatch[3], 10),
+    };
+  }
+
+  return null;
+}
+
+// Image magic bytes for validation
+const imageMagicBytes = {
+  png: [0x89, 0x50, 0x4e, 0x47],
+  jpg: [0xff, 0xd8, 0xff],
+  gif: [0x47, 0x49, 0x46, 0x38],
+  webp: [0x52, 0x49, 0x46, 0x46], // RIFF header for WebP
+  bmp: [0x42, 0x4d],
+  ico: [0x00, 0x00, 0x01, 0x00],
+  svg: [0x3c, 0x3f, 0x78, 0x6d, 0x6c], // <?xml for SVG (though SVG can also start with <svg)
+};
+
+// Validate image by checking magic bytes
+function validateImageBuffer(buffer, url) {
+  if (!buffer || buffer.length < 4) {
+    return { valid: false, reason: 'Buffer too small' };
+  }
+
+  const bytes = [...buffer.slice(0, 8)];
+
+  // Check for HTML error page (starts with <!DOCTYPE or <html or <!)
+  const htmlMarkers = [
+    [0x3c, 0x21], // <!
+    [0x3c, 0x68, 0x74, 0x6d, 0x6c], // <html
+    [0x3c, 0x48, 0x54, 0x4d, 0x4c], // <HTML
+  ];
+
+  for (const marker of htmlMarkers) {
+    if (marker.every((byte, i) => bytes[i] === byte)) {
+      return {
+        valid: false,
+        reason: 'Downloaded file is HTML (likely error page)',
+      };
+    }
+  }
+
+  // Check for valid image formats
+  for (const [format, magic] of Object.entries(imageMagicBytes)) {
+    if (magic.every((byte, i) => bytes[i] === byte)) {
+      return { valid: true, format };
+    }
+  }
+
+  // Special check for SVG (can start with <svg directly)
+  const svgMarker = [0x3c, 0x73, 0x76, 0x67]; // <svg
+  if (svgMarker.every((byte, i) => bytes[i] === byte)) {
+    return { valid: true, format: 'svg' };
+  }
+
+  // If we can't identify it but it's not HTML, give it the benefit of the doubt
+  // Some images might have unusual headers
+  verboseLog(
+    'yellow',
+    `⚠️ Unknown image format for ${url}, bytes: [${bytes
+      .slice(0, 8)
+      .map((b) => `0x${b.toString(16)}`)
+      .join(', ')}]`
+  );
+  return { valid: true, format: 'unknown' };
+}
+
+// Get file extension from format or URL
+function getExtensionFromFormat(format, url) {
+  const formatExtensions = {
+    png: '.png',
+    jpg: '.jpg',
+    gif: '.gif',
+    webp: '.webp',
+    bmp: '.bmp',
+    ico: '.ico',
+    svg: '.svg',
+  };
+
+  if (format && formatExtensions[format]) {
+    return formatExtensions[format];
+  }
+
+  // Try to get from URL
+  try {
+    const urlPath = new globalThis.URL(url).pathname;
+    const ext = path.extname(urlPath).toLowerCase();
+    if (
+      ext &&
+      [
+        '.png',
+        '.jpg',
+        '.jpeg',
+        '.gif',
+        '.webp',
+        '.bmp',
+        '.ico',
+        '.svg',
+      ].includes(ext)
+    ) {
+      return ext === '.jpeg' ? '.jpg' : ext;
+    }
+  } catch (_e) {
+    // Ignore URL parsing errors
+  }
+
+  return '.png'; // Default fallback
+}
+
+// Download a file with redirect support
+function downloadFile(url, token, maxRedirects = 5) {
+  return new Promise((resolve, reject) => {
+    if (maxRedirects <= 0) {
+      reject(new Error('Too many redirects'));
+      return;
+    }
+
+    const parsedUrl = new globalThis.URL(url);
+    const protocol = parsedUrl.protocol === 'https:' ? https : http;
+
+    const headers = {
+      'User-Agent': 'gh-download-pull-request',
+    };
+
+    // Add auth for GitHub URLs
+    if (token && parsedUrl.hostname.includes('github')) {
+      headers['Authorization'] = `token ${token}`;
+    }
+
+    const req = protocol.get(url, { headers }, (res) => {
+      // Handle redirects
+      if (
+        res.statusCode >= 300 &&
+        res.statusCode < 400 &&
+        res.headers.location
+      ) {
+        verboseLog(
+          'dim',
+          `  ↳ Redirecting to: ${res.headers.location.substring(0, 80)}...`
+        );
+        resolve(downloadFile(res.headers.location, token, maxRedirects - 1));
+        return;
+      }
+
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode}`));
+        return;
+      }
+
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+      res.on('error', reject);
+    });
+
+    req.on('error', reject);
+    req.setTimeout(30000, () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+  });
+}
+
+// Extract image URLs from markdown content
+function extractMarkdownImageUrls(content) {
+  if (!content) {
+    return [];
+  }
+
+  const urls = [];
+
+  // Match markdown images: ![alt](url) or ![alt](url "title")
+  const mdImageRegex = /!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+  let match;
+  while ((match = mdImageRegex.exec(content)) !== null) {
+    urls.push({ url: match[2], alt: match[1] });
+  }
+
+  // Match HTML images: <img src="url" /> or <img src='url'>
+  const htmlImageRegex = /<img[^>]+src=["']([^"']+)["'][^>]*>/gi;
+  while ((match = htmlImageRegex.exec(content)) !== null) {
+    urls.push({ url: match[1], alt: '' });
+  }
+
+  return urls;
+}
+
+// Download all images from content and update the markdown
+async function downloadImages(content, imagesDir, token, _prNumber) {
+  if (!content) {
+    return { content, downloadedImages: [] };
+  }
+
+  const images = extractMarkdownImageUrls(content);
+  if (images.length === 0) {
+    return { content, downloadedImages: [] };
+  }
+
+  const downloadedImages = [];
+  let updatedContent = content;
+  let imageCounter = 1;
+
+  // Ensure images directory exists
+  await fs.ensureDir(imagesDir);
+
+  for (const { url } of images) {
+    try {
+      verboseLog('dim', `  📥 Downloading: ${url.substring(0, 60)}...`);
+
+      const buffer = await downloadFile(url, token);
+      const validation = validateImageBuffer(buffer, url);
+
+      if (!validation.valid) {
+        log('yellow', `  ⚠️ Skipping invalid image: ${validation.reason}`);
+        continue;
+      }
+
+      const ext = getExtensionFromFormat(validation.format, url);
+      const filename = `image-${imageCounter}${ext}`;
+      const localPath = path.join(imagesDir, filename);
+      const relativePath = `./${path.basename(imagesDir)}/${filename}`;
+
+      await fs.writeFile(localPath, buffer);
+      downloadedImages.push({
+        originalUrl: url,
+        localPath,
+        relativePath,
+        format: validation.format,
+      });
+
+      // Replace URL in content
+      updatedContent = updatedContent.split(url).join(relativePath);
+      imageCounter++;
+
+      verboseLog('green', `  ✅ Saved: ${filename} (${validation.format})`);
+    } catch (error) {
+      log('yellow', `  ⚠️ Failed to download image: ${error.message}`);
+      verboseLog('dim', `     URL: ${url}`);
+    }
+  }
+
+  return { content: updatedContent, downloadedImages };
+}
+
+// Fetch pull request data from GitHub API
+async function fetchPullRequest(owner, repo, prNumber, token, options = {}) {
+  try {
+    log('blue', `🔍 Fetching pull request ${owner}/${repo}#${prNumber}...`);
+
+    const octokit = new Octokit({
+      auth: token,
+      baseUrl: 'https://api.github.com',
+    });
+
+    // Fetch PR data
+    const { data: pr } = await octokit.rest.pulls.get({
+      owner,
+      repo,
+      pull_number: prNumber,
+    });
+
+    // Fetch PR files
+    const { data: files } = await octokit.rest.pulls.listFiles({
+      owner,
+      repo,
+      pull_number: prNumber,
+    });
+
+    // Fetch PR comments
+    const { data: comments } = await octokit.rest.issues.listComments({
+      owner,
+      repo,
+      issue_number: prNumber,
+    });
+
+    // Fetch PR review comments
+    const { data: reviewComments } =
+      await octokit.rest.pulls.listReviewComments({
+        owner,
+        repo,
+        pull_number: prNumber,
+      });
+
+    // Fetch PR reviews (only if includeReviews is true)
+    let reviews = [];
+    if (options.includeReviews !== false) {
+      const { data: reviewsData } = await octokit.rest.pulls.listReviews({
+        owner,
+        repo,
+        pull_number: prNumber,
+      });
+      reviews = reviewsData;
+    }
+
+    // Fetch PR commits
+    const { data: commits } = await octokit.rest.pulls.listCommits({
+      owner,
+      repo,
+      pull_number: prNumber,
+    });
+
+    log('green', `✅ Successfully fetched PR data`);
+
+    return {
+      pr,
+      files,
+      comments,
+      reviewComments,
+      reviews,
+      commits,
+    };
+  } catch (error) {
+    if (error.status === 404) {
+      log('red', `❌ Pull request not found: ${owner}/${repo}#${prNumber}`);
+    } else if (error.status === 401) {
+      log(
+        'red',
+        `❌ Authentication failed. Please provide a valid GitHub token`
+      );
+    } else {
+      log('red', `❌ Failed to fetch pull request: ${error.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+// Process content and download images if enabled
+function processContent(
+  content,
+  imagesDir,
+  token,
+  prNumber,
+  downloadImagesFlag
+) {
+  if (!downloadImagesFlag) {
+    return Promise.resolve({ content, downloadedImages: [] });
+  }
+  return downloadImages(content, imagesDir, token, prNumber);
+}
+
+// Convert PR data to markdown
+async function convertToMarkdown(data, options = {}) {
+  const { pr, files, comments, reviewComments, reviews, commits } = data;
+  const {
+    downloadImagesFlag = true,
+    imagesDir = '',
+    token = '',
+    prNumber = 0,
+  } = options;
+
+  let markdown = '';
+  let allDownloadedImages = [];
+
+  // Process PR body for images
+  let prBody = pr.body || '';
+  if (downloadImagesFlag && prBody) {
+    log('blue', '🖼️ Processing images in PR description...');
+    const result = await processContent(
+      prBody,
+      imagesDir,
+      token,
+      prNumber,
+      downloadImagesFlag
+    );
+    prBody = result.content;
+    allDownloadedImages = [...allDownloadedImages, ...result.downloadedImages];
+  }
+
+  // Header
+  markdown += `# ${pr.title}\n\n`;
+
+  // Metadata
+  markdown += `**Author:** @${pr.user.login}\n`;
+  markdown += `**Created:** ${pr.created_at}\n`;
+  markdown += `**State:** ${pr.state}\n`;
+  markdown += `**Branch:** ${pr.head.ref} → ${pr.base.ref}\n`;
+
+  // Labels
+  if (pr.labels && pr.labels.length > 0) {
+    markdown += `**Labels:** ${pr.labels.map((l) => l.name).join(', ')}\n`;
+  }
+
+  markdown += '\n## Description\n\n';
+  markdown += prBody ? `${prBody}\n\n` : '_No description provided._\n\n';
+
+  markdown += '---\n\n';
+
+  // Comments
+  if (comments.length > 0) {
+    markdown += `## Comments\n\n`;
+    for (const comment of comments) {
+      let commentBody = comment.body || '';
+      if (downloadImagesFlag && commentBody) {
+        verboseLog(
+          'blue',
+          `Processing images in comment by @${comment.user.login}...`
+        );
+        const result = await processContent(
+          commentBody,
+          imagesDir,
+          token,
+          prNumber,
+          downloadImagesFlag
+        );
+        commentBody = result.content;
+        allDownloadedImages = [
+          ...allDownloadedImages,
+          ...result.downloadedImages,
+        ];
+      }
+
+      markdown += `### Comment by @${comment.user.login} (${comment.created_at})\n\n`;
+      markdown += `${commentBody}\n\n`;
+      markdown += '---\n\n';
+    }
+  }
+
+  // Reviews
+  if (reviews.length > 0) {
+    markdown += `## Reviews\n\n`;
+    for (const review of reviews) {
+      let reviewBody = review.body || '';
+      if (downloadImagesFlag && reviewBody) {
+        verboseLog(
+          'blue',
+          `Processing images in review by @${review.user.login}...`
+        );
+        const result = await processContent(
+          reviewBody,
+          imagesDir,
+          token,
+          prNumber,
+          downloadImagesFlag
+        );
+        reviewBody = result.content;
+        allDownloadedImages = [
+          ...allDownloadedImages,
+          ...result.downloadedImages,
+        ];
+      }
+
+      markdown += `### Review by @${review.user.login} (${review.submitted_at})\n`;
+      markdown += `**State:** ${review.state}\n\n`;
+
+      if (reviewBody) {
+        markdown += `${reviewBody}\n\n`;
+      }
+
+      // Add review comments for this review
+      const reviewReviewComments = reviewComments.filter(
+        (rc) => rc.pull_request_review_id === review.id
+      );
+      if (reviewReviewComments.length > 0) {
+        markdown += `#### Review Comments\n\n`;
+        for (const rc of reviewReviewComments) {
+          let rcBody = rc.body || '';
+          if (downloadImagesFlag && rcBody) {
+            const result = await processContent(
+              rcBody,
+              imagesDir,
+              token,
+              prNumber,
+              downloadImagesFlag
+            );
+            rcBody = result.content;
+            allDownloadedImages = [
+              ...allDownloadedImages,
+              ...result.downloadedImages,
+            ];
+          }
+
+          const lineInfo = rc.line ? `:${rc.line}` : '';
+          markdown += `**File:** ${rc.path}${lineInfo}\n`;
+          markdown += `${rcBody}\n\n`;
+        }
+      }
+
+      markdown += '---\n\n';
+    }
+  }
+
+  // Standalone review comments (not associated with a review)
+  const standaloneReviewComments = reviewComments.filter(
+    (rc) => !rc.pull_request_review_id
+  );
+  if (standaloneReviewComments.length > 0) {
+    markdown += `## Review Comments\n\n`;
+    for (const comment of standaloneReviewComments) {
+      let commentBody = comment.body || '';
+      if (downloadImagesFlag && commentBody) {
+        const result = await processContent(
+          commentBody,
+          imagesDir,
+          token,
+          prNumber,
+          downloadImagesFlag
+        );
+        commentBody = result.content;
+        allDownloadedImages = [
+          ...allDownloadedImages,
+          ...result.downloadedImages,
+        ];
+      }
+
+      markdown += `**@${comment.user.login}** commented on \`${comment.path}\``;
+      if (comment.line) {
+        markdown += ` (line ${comment.line})`;
+      }
+      markdown += `:\n`;
+      markdown += `*${comment.created_at}*\n\n`;
+      markdown += `${commentBody}\n\n`;
+      if (comment.diff_hunk) {
+        markdown += '```diff\n';
+        markdown += `${comment.diff_hunk}\n`;
+        markdown += '```\n\n';
+      }
+    }
+  }
+
+  // Commits
+  if (commits.length > 0) {
+    markdown += `## Commits (${commits.length})\n\n`;
+    for (const commit of commits) {
+      const message = commit.commit.message.split('\n')[0]; // First line only
+      const sha = commit.sha.substring(0, 7);
+      markdown += `- [\`${sha}\`](${commit.html_url}) ${message} - @${commit.author?.login || 'unknown'}\n`;
+    }
+    markdown += '\n';
+  }
+
+  // Files changed
+  if (files.length > 0) {
+    markdown += `## Files Changed (${files.length})\n\n`;
+    for (const file of files) {
+      const statusIcon =
+        file.status === 'added'
+          ? '🆕'
+          : file.status === 'removed'
+            ? '🗑️'
+            : file.status === 'modified'
+              ? '✏️'
+              : file.status === 'renamed'
+                ? '📝'
+                : '📄';
+      markdown += `${statusIcon} **${file.filename}** (+${file.additions} -${file.deletions})\n`;
+      if (file.status === 'renamed') {
+        markdown += `  - Renamed from: \`${file.previous_filename}\`\n`;
+      }
+    }
+    markdown += '\n';
+  }
+
+  return { markdown, downloadedImages: allDownloadedImages };
+}
+
+// Convert PR data to JSON format
+function convertToJson(data, downloadedImages = []) {
+  const { pr, files, comments, reviewComments, reviews, commits } = data;
+
+  return JSON.stringify(
+    {
+      pullRequest: {
+        number: pr.number,
+        title: pr.title,
+        state: pr.state,
+        url: pr.html_url,
+        author: pr.user.login,
+        createdAt: pr.created_at,
+        updatedAt: pr.updated_at,
+        mergedAt: pr.merged_at,
+        closedAt: pr.closed_at,
+        base: pr.base.ref,
+        head: pr.head.ref,
+        additions: pr.additions,
+        deletions: pr.deletions,
+        changedFiles: pr.changed_files,
+        labels: pr.labels?.map((l) => l.name) || [],
+        body: pr.body,
+      },
+      commits: commits.map((c) => ({
+        sha: c.sha,
+        message: c.commit.message,
+        author: c.author?.login || 'unknown',
+        url: c.html_url,
+      })),
+      files: files.map((f) => ({
+        filename: f.filename,
+        status: f.status,
+        additions: f.additions,
+        deletions: f.deletions,
+        previousFilename: f.previous_filename,
+      })),
+      reviews: reviews.map((r) => ({
+        id: r.id,
+        author: r.user.login,
+        state: r.state,
+        body: r.body,
+        submittedAt: r.submitted_at,
+      })),
+      reviewComments: reviewComments.map((c) => ({
+        id: c.id,
+        author: c.user.login,
+        body: c.body,
+        path: c.path,
+        line: c.line,
+        createdAt: c.created_at,
+        diffHunk: c.diff_hunk,
+        reviewId: c.pull_request_review_id,
+      })),
+      comments: comments.map((c) => ({
+        id: c.id,
+        author: c.user.login,
+        body: c.body,
+        createdAt: c.created_at,
+      })),
+      downloadedImages: downloadedImages.map((img) => ({
+        originalUrl: img.originalUrl,
+        localPath: img.relativePath,
+        format: img.format,
+      })),
+    },
+    null,
+    2
+  );
+}
+
+// Configure CLI arguments
+const scriptName = path.basename(process.argv[1]);
+const argv = yargs(hideBin(process.argv))
+  .scriptName(scriptName)
+  .version(version)
+  .usage('Usage: $0 <pr-url> [options]')
+  .command(
+    '$0 <pr>',
+    'Download a GitHub pull request and convert it to markdown',
+    (yargs) => {
+      yargs.positional('pr', {
+        describe:
+          'Pull request URL or shorthand (e.g., https://github.com/owner/repo/pull/123 or owner/repo#123)',
+        type: 'string',
+      });
+    }
+  )
+  .option('token', {
+    alias: 't',
+    type: 'string',
+    describe: 'GitHub personal access token (optional for public PRs)',
+    default: process.env.GITHUB_TOKEN,
+  })
+  .option('output', {
+    alias: 'o',
+    type: 'string',
+    describe: 'Output directory (default: current directory)',
+  })
+  .option('download-images', {
+    type: 'boolean',
+    describe: 'Download embedded images',
+    default: true,
+  })
+  .option('include-reviews', {
+    type: 'boolean',
+    describe: 'Include PR reviews',
+    default: true,
+  })
+  .option('format', {
+    type: 'string',
+    describe: 'Output format: markdown, json',
+    default: 'markdown',
+    choices: ['markdown', 'json'],
+  })
+  .option('verbose', {
+    alias: 'v',
+    type: 'boolean',
+    describe: 'Enable verbose logging',
+    default: false,
+  })
+  .help('h')
+  .alias('h', 'help')
+  .example('$0 https://github.com/owner/repo/pull/123', 'Download PR #123')
+  .example('$0 owner/repo#123', 'Download PR using shorthand format')
+  .example('$0 owner/repo#123 -o ./output', 'Save to output directory')
+  .example('$0 owner/repo#123 --format json', 'Output as JSON')
+  .example('$0 owner/repo#123 --no-download-images', 'Skip image download')
+  .example(
+    '$0 https://github.com/owner/repo/pull/123 --token ghp_xxx',
+    'Download private PR'
+  ).argv;
+
+async function main() {
+  const {
+    pr: prInput,
+    token: tokenArg,
+    output,
+    'download-images': downloadImagesFlag,
+    'include-reviews': includeReviews,
+    format,
+    verbose,
+  } = argv;
+
+  // Set verbose mode
+  verboseMode = verbose;
+
+  let token = tokenArg;
+
+  // If no token provided, try to get it from gh CLI
+  if (!token || token === undefined) {
+    const ghToken = await getGhToken();
+    if (ghToken) {
+      token = ghToken;
+      log('cyan', '🔑 Using GitHub token from gh CLI');
+    }
+  }
+
+  // Parse PR input
+  const prInfo = parsePrUrl(prInput);
+  if (!prInfo) {
+    log('red', `❌ Invalid PR URL or format: ${prInput}`);
+    log('yellow', '💡 Supported formats:');
+    log('yellow', '   - https://github.com/owner/repo/pull/123');
+    log('yellow', '   - owner/repo#123');
+    log('yellow', '   - owner/repo/123');
+    process.exit(1);
+  }
+
+  const { owner, repo, prNumber } = prInfo;
+
+  // Fetch PR data
+  const data = await fetchPullRequest(owner, repo, prNumber, token, {
+    includeReviews,
+  });
+
+  // Determine output paths
+  const outputDir = output || process.cwd();
+  const imagesDir = path.join(outputDir, `pr-${prNumber}-images`);
+  const mdOutputPath = path.join(outputDir, `pr-${prNumber}.md`);
+  const jsonOutputPath = path.join(outputDir, `pr-${prNumber}.json`);
+
+  // Convert to appropriate format
+  log('blue', `📝 Converting to ${format}...`);
+
+  let outputContent;
+  let downloadedImages = [];
+
+  if (format === 'json') {
+    // For JSON, we might still want to download images
+    if (downloadImagesFlag) {
+      log('blue', '🖼️ Processing images...');
+      // Process all content for images
+      const allContent = [
+        data.pr.body || '',
+        ...data.comments.map((c) => c.body || ''),
+        ...data.reviews.map((r) => r.body || ''),
+        ...data.reviewComments.map((rc) => rc.body || ''),
+      ].join('\n\n');
+
+      const result = await downloadImages(
+        allContent,
+        imagesDir,
+        token,
+        prNumber
+      );
+      downloadedImages = result.downloadedImages;
+    }
+    outputContent = convertToJson(data, downloadedImages);
+  } else {
+    // Markdown format with image processing
+    const result = await convertToMarkdown(data, {
+      downloadImagesFlag,
+      imagesDir,
+      token,
+      prNumber,
+    });
+    outputContent = result.markdown;
+    downloadedImages = result.downloadedImages;
+  }
+
+  // Output
+  if (output) {
+    await fs.ensureDir(outputDir);
+    const outputPath = format === 'json' ? jsonOutputPath : mdOutputPath;
+    await fs.writeFile(outputPath, outputContent, 'utf8');
+    log('green', `✅ Saved to ${outputPath}`);
+
+    if (downloadedImages.length > 0) {
+      log(
+        'green',
+        `📁 Downloaded ${downloadedImages.length} image(s) to ${imagesDir}`
+      );
+    }
+  } else {
+    console.log(outputContent);
+  }
+
+  log('blue', '🎉 Done!');
+}
+
+main().catch((error) => {
+  log('red', `💥 Script failed: ${error.message}`);
+  if (verboseMode) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});

package/src/version.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env sh
+':'; // # ; exec "$(command -v bun || command -v node)" "$0" "$@"
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Download use-m dynamically
+const { use } = eval(
+  await (await fetch('https://unpkg.com/use-m/use.js')).text()
+);
+
+// Import semver for version management
+const semver = await use('semver@7.7.2');
+
+function updatePackageJson(newVersion) {
+  const packagePath = path.join(__dirname, 'package.json');
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  packageJson.version = newVersion;
+  fs.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+
+function updateMainScript(newVersion) {
+  const scriptPath = path.join(__dirname, 'gh-download-pull-request.mjs');
+  const content = fs.readFileSync(scriptPath, 'utf8');
+  const updatedContent = content.replace(
+    /let version = '[^']+'/,
+    `let version = '${newVersion}'`
+  );
+  fs.writeFileSync(scriptPath, updatedContent);
+}
+
+function runGitCommand(command, description) {
+  try {
+    console.log(`🔄 ${description}...`);
+    execSync(command, { stdio: 'inherit', cwd: __dirname });
+    console.log(`✅ ${description} completed`);
+  } catch (error) {
+    console.error(
+      `❌ Failed to ${description.toLowerCase()}: ${error.message}`
+    );
+    process.exit(1);
+  }
+}
+
+function main() {
+  const versionType = process.argv[2];
+
+  if (!versionType || !['patch', 'minor', 'major'].includes(versionType)) {
+    console.error('Usage: ./version.mjs <patch|minor|major>');
+    console.error('Examples:');
+    console.error('  ./version.mjs patch   # 0.1.0 → 0.1.1');
+    console.error('  ./version.mjs minor   # 0.1.0 → 0.2.0');
+    console.error('  ./version.mjs major   # 0.1.0 → 1.0.0');
+    process.exit(1);
+  }
+
+  // Read current version from package.json
+  const packagePath = path.join(__dirname, 'package.json');
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  const currentVersion = packageJson.version;
+
+  // Calculate new version using semver
+  const newVersion = semver.inc(currentVersion, versionType);
+
+  if (!newVersion) {
+    console.error(
+      `❌ Failed to calculate new ${versionType} version from ${currentVersion}`
+    );
+    process.exit(1);
+  }
+
+  console.log(`📦 Bumping version from ${currentVersion} to ${newVersion}`);
+
+  try {
+    // Update both files
+    updatePackageJson(newVersion);
+    updateMainScript(newVersion);
+
+    console.log('✅ Version updated successfully!');
+    console.log(`   📄 package.json: ${newVersion}`);
+    console.log(`   📄 gh-download-pull-request.mjs: ${newVersion}`);
+    console.log('');
+
+    // Automatically commit and push changes
+    runGitCommand('git add .', 'Adding changes to git');
+    runGitCommand(`git commit -m "${newVersion}"`, 'Committing changes');
+    runGitCommand('git push', 'Pushing to remote repository');
+
+    console.log('🎉 Version bump completed and pushed!');
+  } catch (error) {
+    console.error('❌ Error updating files:', error.message);
+    process.exit(1);
+  }
+}
+
+main();