@mbe24/99problems 0.1.0

package/src/main.rs

@@ -0,0 +1,127 @@
+mod config;
+mod format;
+mod model;
+mod source;
+
+use anyhow::{Result, anyhow};
+use clap::{Parser, ValueEnum};
+use std::io::Write;
+
+use config::Config;
+use format::{Formatter, json::JsonFormatter, yaml::YamlFormatter};
+use source::{Query, Source, github_issues::GitHubIssues};
+
+#[derive(Debug, Clone, ValueEnum)]
+enum OutputFormat {
+    Json,
+    Yaml,
+}
+
+#[derive(Debug, Clone, ValueEnum)]
+enum SourceKind {
+    GithubIssues,
+    GithubPrs,
+}
+
+#[derive(Parser, Debug)]
+#[command(
+    name = "99problems",
+    about = "Fetch GitHub issue conversations",
+    version
+)]
+struct Cli {
+    /// Full GitHub search query (same syntax as the web UI search bar)
+    /// e.g. "is:issue state:closed Event repo:owner/repo"
+    #[arg(short = 'q', long)]
+    query: Option<String>,
+
+    /// Shorthand for adding "repo:owner/repo" to the query
+    #[arg(long)]
+    repo: Option<String>,
+
+    /// Shorthand for adding "state:open|closed" to the query
+    #[arg(long)]
+    state: Option<String>,
+
+    /// Shorthand for comma-separated labels, e.g. "bug,enhancement"
+    #[arg(long)]
+    labels: Option<String>,
+
+    /// Fetch a single issue by number (bypasses search)
+    #[arg(long)]
+    issue: Option<u64>,
+
+    /// Data source to use
+    #[arg(long, value_enum, default_value = "github-issues")]
+    source: SourceKind,
+
+    /// Output format
+    #[arg(long, value_enum, default_value = "json")]
+    format: OutputFormat,
+
+    /// Write output to a file (default: stdout)
+    #[arg(short = 'o', long)]
+    output: Option<String>,
+
+    /// GitHub personal access token (overrides GITHUB_TOKEN and dotfile)
+    #[arg(long)]
+    token: Option<String>,
+}
+
+fn main() -> Result<()> {
+    let cli = Cli::parse();
+    let mut cfg = Config::load()?;
+
+    // CLI token overrides everything
+    if let Some(t) = cli.token {
+        cfg.token = Some(t);
+    }
+
+    // Override repo/state from CLI if provided
+    let repo = cli.repo.or(cfg.repo.clone());
+    let state = cli.state.or(cfg.state.clone());
+
+    // Build the formatter
+    let formatter: Box<dyn Formatter> = match cli.format {
+        OutputFormat::Json => Box::new(JsonFormatter),
+        OutputFormat::Yaml => Box::new(YamlFormatter),
+    };
+
+    // Build the source
+    let source: Box<dyn Source> = match cli.source {
+        SourceKind::GithubIssues => Box::new(GitHubIssues::new()?),
+        SourceKind::GithubPrs => {
+            return Err(anyhow!("github-prs source is not yet implemented"));
+        }
+    };
+
+    let conversations = if let Some(issue_id) = cli.issue {
+        // Single-issue mode
+        let r = repo
+            .as_deref()
+            .ok_or_else(|| anyhow!("--repo is required when using --issue"))?;
+        vec![source.fetch_one(r, issue_id)?]
+    } else {
+        // Search mode
+        let query = Query::build(cli.query, repo, state, cli.labels, cfg.per_page, cfg.token);
+        if query.raw.trim().is_empty() {
+            return Err(anyhow!(
+                "No query specified. Use -q or provide --repo/--state/--labels."
+            ));
+        }
+        source.fetch(&query)?
+    };
+
+    let output = formatter.format(&conversations)?;
+
+    match cli.output {
+        Some(path) => {
+            let mut file = std::fs::File::create(&path)?;
+            file.write_all(output.as_bytes())?;
+            eprintln!("Wrote {} conversations to {path}", conversations.len());
+        }
+        None => println!("{output}"),
+    }
+
+    Ok(())
+}

package/src/model.rs

@@ -0,0 +1,17 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Conversation {
+    pub id: u64,
+    pub title: String,
+    pub state: String,
+    pub body: Option<String>,
+    pub comments: Vec<Comment>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Comment {
+    pub author: Option<String>,
+    pub created_at: String,
+    pub body: Option<String>,
+}

package/src/source/github_issues.rs

@@ -0,0 +1,232 @@
+use anyhow::{Result, anyhow};
+use reqwest::blocking::Client;
+use serde::Deserialize;
+
+use super::{Query, Source};
+use crate::model::{Comment, Conversation};
+
+pub struct GitHubIssues {
+    client: Client,
+}
+
+impl GitHubIssues {
+    pub fn new() -> Result<Self> {
+        let client = Client::builder()
+            .user_agent("99problems-cli/0.1.0")
+            .build()?;
+        Ok(Self { client })
+    }
+
+    fn auth_header(token: &Option<String>) -> Option<String> {
+        token.as_ref().map(|t| format!("Bearer {t}"))
+    }
+
+    fn get_pages<T: for<'de> Deserialize<'de>>(
+        &self,
+        url: &str,
+        token: &Option<String>,
+        per_page: u32,
+    ) -> Result<Vec<T>> {
+        let mut results = vec![];
+        let mut page = 1u32;
+
+        loop {
+            let mut req = self.client.get(url).query(&[
+                ("per_page", per_page.to_string()),
+                ("page", page.to_string()),
+            ]);
+
+            if let Some(auth) = Self::auth_header(token) {
+                req = req
+                    .header("Authorization", auth)
+                    .header("X-GitHub-Api-Version", "2022-11-28");
+            }
+
+            let resp = req.send()?;
+
+            if !resp.status().is_success() {
+                return Err(anyhow!(
+                    "GitHub API error {}: {}",
+                    resp.status(),
+                    resp.text()?
+                ));
+            }
+
+            let has_next = resp
+                .headers()
+                .get("link")
+                .and_then(|v| v.to_str().ok())
+                .map(|l| l.contains(r#"rel="next""#))
+                .unwrap_or(false);
+
+            let items: Vec<T> = resp.json()?;
+            let done = items.is_empty() || !has_next;
+            results.extend(items);
+            if done {
+                break;
+            }
+            page += 1;
+        }
+
+        Ok(results)
+    }
+}
+
+// --- GitHub API response shapes ---
+
+#[derive(Deserialize)]
+struct SearchResponse {
+    items: Vec<IssueItem>,
+}
+
+#[derive(Deserialize)]
+struct IssueItem {
+    number: u64,
+    title: String,
+    state: String,
+    body: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct CommentItem {
+    user: Option<UserItem>,
+    created_at: String,
+    body: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct UserItem {
+    login: String,
+}
+
+impl Source for GitHubIssues {
+    fn fetch(&self, query: &Query) -> Result<Vec<Conversation>> {
+        let search_url = "https://api.github.com/search/issues";
+        let mut page = 1u32;
+        let mut all_issues: Vec<IssueItem> = vec![];
+
+        loop {
+            let mut req = self.client.get(search_url).query(&[
+                ("q", query.raw.as_str()),
+                ("per_page", "100"),
+                ("page", &page.to_string()),
+            ]);
+
+            if let Some(auth) = Self::auth_header(&query.token) {
+                req = req
+                    .header("Authorization", auth)
+                    .header("X-GitHub-Api-Version", "2022-11-28");
+            }
+
+            let resp = req.send()?;
+            if !resp.status().is_success() {
+                return Err(anyhow!(
+                    "GitHub search error {}: {}",
+                    resp.status(),
+                    resp.text()?
+                ));
+            }
+
+            let search: SearchResponse = resp.json()?;
+            let done = search.items.len() < 100;
+            all_issues.extend(search.items);
+            if done {
+                break;
+            }
+            page += 1;
+        }
+
+        // Determine repo from query for comment fetching
+        let repo = extract_repo(&query.raw).ok_or_else(|| {
+            anyhow!("No repo: found in query. Use --repo or include 'repo:owner/name' in -q")
+        })?;
+
+        let mut conversations = vec![];
+        for issue in all_issues {
+            let comments_url = format!(
+                "https://api.github.com/repos/{repo}/issues/{}/comments",
+                issue.number
+            );
+            let raw_comments: Vec<CommentItem> =
+                self.get_pages(&comments_url, &query.token, 100)?;
+
+            conversations.push(Conversation {
+                id: issue.number,
+                title: issue.title,
+                state: issue.state,
+                body: issue.body,
+                comments: raw_comments
+                    .into_iter()
+                    .map(|c| Comment {
+                        author: c.user.map(|u| u.login),
+                        created_at: c.created_at,
+                        body: c.body,
+                    })
+                    .collect(),
+            });
+        }
+
+        Ok(conversations)
+    }
+
+    fn fetch_one(&self, repo: &str, issue_id: u64) -> Result<Conversation> {
+        let issue_url = format!("https://api.github.com/repos/{repo}/issues/{issue_id}");
+        let req = self.client.get(&issue_url);
+        // token is not stored on struct, so we pass None here — callers set it via Query
+        // For fetch_one we skip auth (public repos). Callers who need auth should use fetch().
+        let resp = req.send()?;
+        if !resp.status().is_success() {
+            return Err(anyhow!(
+                "GitHub issue error {}: {}",
+                resp.status(),
+                resp.text()?
+            ));
+        }
+        let issue: IssueItem = resp.json()?;
+
+        let comments_url =
+            format!("https://api.github.com/repos/{repo}/issues/{issue_id}/comments");
+        let raw_comments: Vec<CommentItem> = self.get_pages(&comments_url, &None, 100)?;
+
+        Ok(Conversation {
+            id: issue.number,
+            title: issue.title,
+            state: issue.state,
+            body: issue.body,
+            comments: raw_comments
+                .into_iter()
+                .map(|c| Comment {
+                    author: c.user.map(|u| u.login),
+                    created_at: c.created_at,
+                    body: c.body,
+                })
+                .collect(),
+        })
+    }
+}
+
+/// Extract `owner/repo` from a query string containing `repo:owner/repo`.
+pub fn extract_repo(query: &str) -> Option<String> {
+    query
+        .split_whitespace()
+        .find(|t| t.starts_with("repo:"))
+        .map(|t| t.trim_start_matches("repo:").to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn extract_repo_finds_token() {
+        assert_eq!(
+            extract_repo("is:issue state:closed repo:owner/repo Event"),
+            Some("owner/repo".into())
+        );
+    }
+
+    #[test]
+    fn extract_repo_returns_none_when_absent() {
+        assert_eq!(extract_repo("is:issue state:closed Event"), None);
+    }
+}

package/src/source/mod.rs

@@ -0,0 +1,110 @@
+use crate::model::Conversation;
+use anyhow::Result;
+
+pub mod github_issues;
+
+/// A pluggable data source that fetches issue conversations.
+pub trait Source {
+    fn fetch(&self, query: &Query) -> Result<Vec<Conversation>>;
+    fn fetch_one(&self, repo: &str, issue_id: u64) -> Result<Conversation>;
+}
+
+/// Parsed search parameters passed to a Source.
+#[derive(Debug, Default, Clone)]
+#[allow(dead_code)]
+pub struct Query {
+    /// Full raw query string (GitHub search syntax), e.g. "is:issue state:closed Event repo:owner/repo"
+    pub raw: String,
+    pub per_page: u32,
+    pub token: Option<String>,
+}
+
+impl Query {
+    /// Build a query by merging a raw string with convenience shorthands.
+    /// Shorthands are only appended if their qualifier isn't already present.
+    pub fn build(
+        raw: Option<String>,
+        repo: Option<String>,
+        state: Option<String>,
+        labels: Option<String>,
+        per_page: u32,
+        token: Option<String>,
+    ) -> Self {
+        let mut parts: Vec<String> = vec![];
+
+        if let Some(r) = raw {
+            parts.push(r);
+        }
+
+        if let Some(repo) = repo
+            && !parts.iter().any(|p| p.contains("repo:"))
+        {
+            parts.push(format!("repo:{repo}"));
+        }
+        if let Some(state) = state
+            && !parts.iter().any(|p| p.contains("state:"))
+        {
+            parts.push(format!("state:{state}"));
+        }
+        if let Some(labels) = labels {
+            for label in labels.split(',') {
+                let label = label.trim();
+                if !label.is_empty() {
+                    parts.push(format!("label:{label}"));
+                }
+            }
+        }
+
+        Query {
+            raw: parts.join(" "),
+            per_page,
+            token,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn build_query_appends_repo_and_state() {
+        let q = Query::build(
+            Some("is:issue Event".into()),
+            Some("owner/repo".into()),
+            Some("closed".into()),
+            None,
+            100,
+            None,
+        );
+        assert!(q.raw.contains("repo:owner/repo"));
+        assert!(q.raw.contains("state:closed"));
+        assert!(q.raw.contains("is:issue Event"));
+    }
+
+    #[test]
+    fn build_query_does_not_duplicate_repo() {
+        let q = Query::build(
+            Some("is:issue repo:owner/repo".into()),
+            Some("other/repo".into()),
+            None,
+            None,
+            100,
+            None,
+        );
+        assert_eq!(q.raw.matches("repo:").count(), 1);
+    }
+
+    #[test]
+    fn build_query_handles_multiple_labels() {
+        let q = Query::build(None, None, None, Some("bug,enhancement".into()), 100, None);
+        assert!(q.raw.contains("label:bug"));
+        assert!(q.raw.contains("label:enhancement"));
+    }
+
+    #[test]
+    fn build_query_empty_produces_empty_raw() {
+        let q = Query::build(None, None, None, None, 100, None);
+        assert_eq!(q.raw.trim(), "");
+    }
+}

package/tests/integration.rs

@@ -0,0 +1,58 @@
+/// Integration tests — require a live GitHub API token.
+/// Run with: GITHUB_TOKEN=ghp_... cargo test -- --include-ignored
+///
+/// These tests use schemaorg/schemaorg#1842 as a known stable fixture.
+
+#[cfg(test)]
+mod tests {
+    use problems99::source::{Query, Source, github_issues::GitHubIssues};
+
+    fn token() -> Option<String> {
+        std::env::var("GITHUB_TOKEN").ok()
+    }
+
+    #[test]
+    #[ignore = "requires GITHUB_TOKEN and live network"]
+    fn fetch_known_issue_1842() {
+        let source = GitHubIssues::new().unwrap();
+        let conv = source.fetch_one("schemaorg/schemaorg", 1842).unwrap();
+        assert_eq!(conv.id, 1842);
+        assert_eq!(conv.title, "Online-only events");
+        assert_eq!(conv.state, "closed");
+        assert!(conv.body.is_some());
+        assert!(!conv.comments.is_empty());
+    }
+
+    #[test]
+    #[ignore = "requires GITHUB_TOKEN and live network"]
+    fn search_returns_results() {
+        let source = GitHubIssues::new().unwrap();
+        let query = Query::build(
+            Some("is:issue state:closed EventSeries repo:schemaorg/schemaorg".into()),
+            None,
+            None,
+            None,
+            10,
+            token(),
+        );
+        let results = source.fetch(&query).unwrap();
+        assert!(!results.is_empty());
+        for conv in &results {
+            assert!(!conv.title.is_empty());
+            assert_eq!(conv.state, "closed");
+        }
+    }
+
+    #[test]
+    #[ignore = "requires GITHUB_TOKEN and live network"]
+    fn fetch_one_comment_has_author_and_body() {
+        let source = GitHubIssues::new().unwrap();
+        let conv = source.fetch_one("schemaorg/schemaorg", 1842).unwrap();
+        let first = conv
+            .comments
+            .first()
+            .expect("expected at least one comment");
+        assert!(first.author.is_some());
+        assert!(!first.created_at.is_empty());
+    }
+}