Add PR range mode and bump version to 0.1.4 (#13)

Author: hdcodedev

.gitignore

@@ -1,2 +1,3 @@
 /target
 dist/
+.DS_Store

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "gh-context"
-version = "0.1.3"
+version = "0.1.4"
 edition = "2024"
 repository = "https://github.com/hdcodedev/gh-context"
 description = "A CLI tool for fetching GitHub Issue and Pull Request context."

Cargo.toml

@@ -58,6 +58,12 @@ Fetch context for a PR (creates `repo-issue-123/repo-issue-123.md` context by de
 gh-context owner/repo#123
 ```
 
+Fetch a PR range (inclusive, one file per PR in `repo-prs/` by default):
+```bash
+gh-context owner/repo --from 244 --to 276
+```
+If any PR in the range fails to fetch, the command continues and prints a failure summary.
+
 Bulk fetch open issues for a repo (one file per issue, first page by default):
 ```bash
 gh-context https://github.com/openai/codex/issues --bulk
@@ -94,3 +100,5 @@ cargo run -- https://github.com/hdcodedev/resume256/issues/48
 - `--state <open|closed|all>`: Issue state filter for bulk mode (default: open)
 - `--per-page <n>`: Items per page for bulk mode (default: 30)
 - `--pages <n>`: Number of pages to fetch in bulk mode (default: 1)
+- `--from <n>`: Start PR number for range mode (inclusive, requires `--to`)
+- `--to <n>`: End PR number for range mode (inclusive, requires `--from`)

README.md

@@ -1,5 +1,7 @@
 use crate::args::{Cli, IssueState, OutputFormat};
-use crate::bulk::{resolve_bulk_out_dir, validate_bulk_args};
+use crate::bulk::{
+    resolve_bulk_out_dir, resolve_pr_range_out_dir, validate_bulk_args, validate_pr_range_args,
+};
 use std::fs;
 use std::path::PathBuf;
 
@@ -15,6 +17,8 @@ fn make_cli() -> Cli {
         state: IssueState::Open,
         per_page: 30,
         pages: 1,
+        from: None,
+        to: None,
     }
 }
 
@@ -93,3 +97,53 @@ fn test_resolve_bulk_out_dir_rejects_file() {
 
     let _ = fs::remove_file(&tmp_file);
 }
+
+#[test]
+fn test_validate_pr_range_args_ok() {
+    let mut cli = make_cli();
+    cli.bulk = false;
+    cli.from = Some(10);
+    cli.to = Some(12);
+    assert_eq!(validate_pr_range_args(&cli).unwrap(), (10, 12));
+}
+
+#[test]
+fn test_validate_pr_range_args_requires_both_bounds() {
+    let mut cli = make_cli();
+    cli.bulk = false;
+    cli.from = Some(10);
+    let err = validate_pr_range_args(&cli).unwrap_err();
+    assert!(err.to_string().contains("provided together"));
+}
+
+#[test]
+fn test_validate_pr_range_args_rejects_descending_range() {
+    let mut cli = make_cli();
+    cli.bulk = false;
+    cli.from = Some(12);
+    cli.to = Some(10);
+    let err = validate_pr_range_args(&cli).unwrap_err();
+    assert!(err.to_string().contains("less than or equal"));
+}
+
+#[test]
+fn test_validate_pr_range_args_rejects_issue_flag() {
+    let mut cli = make_cli();
+    cli.bulk = false;
+    cli.issue = true;
+    cli.from = Some(1);
+    cli.to = Some(2);
+    let err = validate_pr_range_args(&cli).unwrap_err();
+    assert!(err.to_string().contains("PRs only"));
+}
+
+#[test]
+fn test_resolve_pr_range_out_dir_default() {
+    let mut cli = make_cli();
+    cli.bulk = false;
+    cli.out = None;
+    let dir = resolve_pr_range_out_dir(&cli, "repo").unwrap();
+    assert_eq!(dir, PathBuf::from("repo-prs"));
+    assert!(dir.is_dir());
+    let _ = fs::remove_dir_all(&dir);
+}

src/__tests__/bulk_test.rs

@@ -66,4 +66,12 @@ pub struct Cli {
     /// Number of pages to fetch in bulk mode
     #[arg(long, default_value_t = 1)]
     pub pages: u32,
+
+    /// Start PR number for range mode (inclusive)
+    #[arg(long)]
+    pub from: Option<u64>,
+
+    /// End PR number for range mode (inclusive)
+    #[arg(long)]
+    pub to: Option<u64>,
 }

src/args.rs

@@ -20,13 +20,47 @@ pub fn validate_bulk_args(cli: &Cli) -> Result<()> {
 }
 
 pub fn resolve_bulk_out_dir(cli: &Cli, repo: &str) -> Result<PathBuf> {
+    resolve_out_dir(cli, format!("{}-issues", repo), "bulk mode")
+}
+
+pub fn validate_pr_range_args(cli: &Cli) -> Result<(u64, u64)> {
+    if cli.bulk {
+        return Err(anyhow!("--from/--to cannot be used with --bulk"));
+    }
+    if cli.issue {
+        return Err(anyhow!("--from/--to supports PRs only; remove --issue"));
+    }
+    if cli.clip {
+        return Err(anyhow!("--clip is not supported with --from/--to"));
+    }
+
+    let (from, to) = match (cli.from, cli.to) {
+        (Some(from), Some(to)) => (from, to),
+        (Some(_), None) | (None, Some(_)) => {
+            return Err(anyhow!("--from and --to must be provided together"));
+        }
+        (None, None) => return Err(anyhow!("--from and --to are required for PR range mode")),
+    };
+
+    if from > to {
+        return Err(anyhow!("--from must be less than or equal to --to"));
+    }
+
+    Ok((from, to))
+}
+
+pub fn resolve_pr_range_out_dir(cli: &Cli, repo: &str) -> Result<PathBuf> {
+    resolve_out_dir(cli, format!("{}-prs", repo), "PR range mode")
+}
+
+fn resolve_out_dir(cli: &Cli, default_name: String, mode_label: &str) -> Result<PathBuf> {
     let dir = if let Some(path) = &cli.out {
         if path.exists() && path.is_file() {
-            return Err(anyhow!("--out must be a directory in bulk mode"));
+            return Err(anyhow!("--out must be a directory in {}", mode_label));
         }
         path.clone()
     } else {
-        PathBuf::from(format!("{}-issues", repo))
+        PathBuf::from(default_name)
     };
 
     if !dir.exists() {

src/bulk.rs

@@ -7,9 +7,11 @@ mod types;
 #[cfg(test)]
 mod __tests__;
 
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 use args::{Cli, OutputFormat};
-use bulk::{resolve_bulk_out_dir, validate_bulk_args};
+use bulk::{
+    resolve_bulk_out_dir, resolve_pr_range_out_dir, validate_bulk_args, validate_pr_range_args,
+};
 use clap::Parser;
 use std::fs;
 use std::io::Write;
@@ -19,6 +21,65 @@ use types::Context as GhContext;
 fn main() -> Result<()> {
     let cli = Cli::parse();
 
+    if cli.from.is_some() || cli.to.is_some() {
+        let (from, to) = validate_pr_range_args(&cli)?;
+        let (owner, repo) = gh::parse_repo(&cli.input)?;
+        let out_dir = resolve_pr_range_out_dir(&cli, &repo)?;
+        let file_extension = output_extension(&cli.format);
+        let mut failures: Vec<(u64, String)> = Vec::new();
+        let mut generated_count = 0_u64;
+
+        for number in from..=to {
+            let target = gh::Target {
+                owner: owner.clone(),
+                repo: repo.clone(),
+                number,
+                kind: gh::TargetType::Pr,
+            };
+
+            let context = match gh::fetch_context(&target) {
+                Ok(context) => context,
+                Err(err) => {
+                    failures.push((number, err.to_string()));
+                    continue;
+                }
+            };
+            let formatted_output = format_output(&context, &cli.format)?;
+            let base = format!(
+                "{}-{}-{}",
+                repo, context.metadata.r#type, context.metadata.number
+            );
+            let file_path = out_dir.join(format!("{}.{}", base, file_extension));
+            fs::write(&file_path, &formatted_output).with_context(|| {
+                format!("Failed to write output to file: {:?}", file_path)
+            })?;
+            println!("Generated context in {}", file_path.display());
+            generated_count += 1;
+        }
+
+        if !failures.is_empty() {
+            eprintln!(
+                "Completed with {} failed PR(s) in range {}..={}",
+                failures.len(),
+                from,
+                to
+            );
+            for (number, err) in &failures {
+                eprintln!(" - PR #{}: {}", number, err);
+            }
+        }
+
+        if generated_count == 0 {
+            return Err(anyhow!(
+                "No PR context files were generated for range {}..={}",
+                from,
+                to
+            ));
+        }
+
+        return Ok(());
+    }
+
     if cli.bulk {
         validate_bulk_args(&cli)?;