@mbe24/99problems 0.2.0 → 0.3.1

package/src/main.rs

@@ -1,179 +1,266 @@
+mod cmd;
 mod config;
+mod error;
 mod format;
+mod logging;
 mod model;
 mod source;
 
-use anyhow::{Result, anyhow};
-use clap::{Parser, ValueEnum};
+use clap::{ArgAction, CommandFactory, Parser, Subcommand, ValueEnum};
+use clap_complete::{Generator, Shell, generate};
 use std::io::Write;
+use tracing::error;
 
-use config::Config;
-use format::{Formatter, json::JsonFormatter, yaml::YamlFormatter};
-use source::{Query, Source, github_issues::GitHubIssues};
+use crate::error::{AppError, classify_anyhow_error};
 
 #[derive(Debug, Clone, ValueEnum)]
-enum OutputFormat {
-    Json,
-    Yaml,
-}
-
-#[derive(Debug, Clone, ValueEnum, PartialEq)]
-enum Platform {
-    Github,
-    Gitlab,
-    Bitbucket,
+enum CompletionShell {
+    Bash,
+    Zsh,
+    Fish,
+    Powershell,
+    Elvish,
 }
 
-impl Platform {
-    fn as_str(&self) -> &str {
+impl CompletionShell {
+    fn as_clap_shell(&self) -> Shell {
         match self {
-            Platform::Github => "github",
-            Platform::Gitlab => "gitlab",
-            Platform::Bitbucket => "bitbucket",
+            CompletionShell::Bash => Shell::Bash,
+            CompletionShell::Zsh => Shell::Zsh,
+            CompletionShell::Fish => Shell::Fish,
+            CompletionShell::Powershell => Shell::PowerShell,
+            CompletionShell::Elvish => Shell::Elvish,
         }
     }
 }
 
-#[derive(Debug, Clone, ValueEnum)]
-enum ContentType {
-    Issue,
-    Pr,
-}
-
-impl ContentType {
-    fn as_str(&self) -> &str {
-        match self {
-            ContentType::Issue => "issue",
-            ContentType::Pr => "pr",
-        }
-    }
+#[derive(Debug, Clone, Copy, ValueEnum)]
+enum ErrorFormat {
+    Text,
+    Json,
 }
 
 #[derive(Parser, Debug)]
 #[command(
     name = "99problems",
-    about = "Fetch GitHub issue conversations",
+    about = "Fetch issue and pull request conversations",
+    long_about = "Fetch issue and pull request conversations from GitHub, GitLab, and Jira.",
+    subcommand_required = true,
+    arg_required_else_help = true,
+    next_line_help = true,
+    after_help = "Examples:\n  99problems get --repo schemaorg/schemaorg --id 1842\n  99problems get -q \"repo:github/gitignore is:pr 2402\" --include-review-comments\n  99problems man --output docs/man",
     version
 )]
 struct Cli {
-    /// Full search query (same syntax as the platform's web UI search bar)
-    /// e.g. "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>,
-
-    /// Filter by issue/PR author
-    #[arg(long)]
-    author: Option<String>,
-
-    /// Only include items created on or after this date (YYYY-MM-DD), e.g. "2024-01-01"
-    #[arg(long)]
-    since: Option<String>,
-
-    /// Filter by milestone title or number
-    #[arg(long)]
-    milestone: Option<String>,
-
-    /// Fetch a single issue by number (bypasses search)
-    #[arg(long)]
-    issue: Option<u64>,
-
-    /// Platform to fetch from [default: github]
-    #[arg(long, value_enum)]
-    platform: Option<Platform>,
-
-    /// Content type to fetch [default: issue]
-    #[arg(long = "type", value_enum)]
-    kind: Option<ContentType>,
-
-    /// 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>,
-
-    /// Personal access token (overrides env var and dotfile)
-    #[arg(long)]
-    token: Option<String>,
+    /// Increase diagnostic verbosity (-v, -vv, -vvv)
+    #[arg(short = 'v', long = "verbose", action = ArgAction::Count, global = true, conflicts_with = "quiet")]
+    verbose: u8,
+
+    /// Suppress non-error diagnostics
+    #[arg(short = 'Q', long = "quiet", global = true)]
+    quiet: bool,
+
+    /// Error output format
+    #[arg(long, value_enum, default_value = "text", global = true)]
+    error_format: ErrorFormat,
+
+    #[command(subcommand)]
+    command: Commands,
 }
 
-fn main() -> Result<()> {
-    let cli = Cli::parse();
-    let mut cfg = Config::load()?;
+#[derive(Subcommand, Debug)]
+enum Commands {
+    /// Fetch issue and pull request conversations
+    #[command(visible_alias = "got")]
+    Get(Box<cmd::get::GetArgs>),
 
-    // CLI flags override config values
-    if let Some(p) = &cli.platform {
-        cfg.platform = p.as_str().to_owned();
+    /// Inspect and edit .99problems configuration
+    Config(cmd::config::ConfigArgs),
+
+    /// Generate shell completion script and print it to stdout
+    Completions {
+        #[arg(value_enum)]
+        shell: CompletionShell,
+    },
+
+    /// Generate and print/write man pages
+    Man(cmd::man::ManArgs),
+}
+
+fn main() {
+    let cli = Cli::parse();
+    if let Err(err) = logging::init(cli.verbose, cli.quiet) {
+        let app_err = classify_anyhow_error(&err);
+        render_and_exit(&app_err, cli.error_format);
     }
-    if let Some(k) = &cli.kind {
-        cfg.kind = k.as_str().to_owned();
+
+    let result = match cli.command {
+        Commands::Get(args) => cmd::get::run(&args),
+        Commands::Config(args) => cmd::config::run(&args),
+        Commands::Completions { shell } => {
+            print_completions(shell.as_clap_shell(), &mut std::io::stdout());
+            Ok(())
+        }
+        Commands::Man(args) => cmd::man::run(Cli::command(), &args),
+    };
+
+    if let Err(err) = result {
+        let app_err = classify_anyhow_error(&err);
+        render_and_exit(&app_err, cli.error_format);
     }
-    if let Some(t) = cli.token {
-        cfg.token = Some(t);
+}
+
+fn print_completions<G: Generator>(generator: G, out: &mut dyn Write) {
+    let mut cmd = Cli::command();
+    let name = cmd.get_name().to_string();
+    generate(generator, &mut cmd, name, out);
+}
+
+fn render_and_exit(app_err: &AppError, format: ErrorFormat) -> ! {
+    match format {
+        ErrorFormat::Text => eprintln!("Error: {}", app_err.render_text()),
+        ErrorFormat::Json => eprintln!("{}", app_err.render_json()),
     }
+    error!(
+        category = app_err.category().code(),
+        exit_code = app_err.exit_code(),
+        "command failed"
+    );
+    std::process::exit(app_err.exit_code());
+}
 
-    let repo = cli.repo.or(cfg.repo.clone());
-    let state = cli.state.or(cfg.state.clone());
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    let formatter: Box<dyn Formatter> = match cli.format {
-        OutputFormat::Json => Box::new(JsonFormatter),
-        OutputFormat::Yaml => Box::new(YamlFormatter),
-    };
+    #[test]
+    fn parses_get_subcommand() {
+        let cli = Cli::try_parse_from(["99problems", "get", "--repo", "owner/repo", "--id", "1"])
+            .expect("expected get subcommand to parse");
+        match cli.command {
+            Commands::Get(args) => {
+                assert_eq!(args.repo.as_deref(), Some("owner/repo"));
+                assert_eq!(args.id.as_deref(), Some("1"));
+            }
+            Commands::Config(_) | Commands::Completions { .. } | Commands::Man(_) => {
+                panic!("expected get command")
+            }
+        }
+    }
 
-    let source: Box<dyn Source> = match cfg.platform.as_str() {
-        "github" => Box::new(GitHubIssues::new()?),
-        other => return Err(anyhow!("Platform '{other}' is not yet supported")),
-    };
+    #[test]
+    fn parses_got_alias_to_get_subcommand() {
+        let cli = Cli::try_parse_from(["99problems", "got", "--repo", "owner/repo", "--id", "2"])
+            .expect("expected got alias to parse");
+        match cli.command {
+            Commands::Get(args) => {
+                assert_eq!(args.repo.as_deref(), Some("owner/repo"));
+                assert_eq!(args.id.as_deref(), Some("2"));
+            }
+            Commands::Config(_) | Commands::Completions { .. } | Commands::Man(_) => {
+                panic!("expected get command")
+            }
+        }
+    }
 
-    let conversations = if let Some(issue_id) = cli.issue {
-        let r = repo
-            .as_deref()
-            .ok_or_else(|| anyhow!("--repo is required when using --issue"))?;
-        vec![source.fetch_one(r, issue_id)?]
-    } else {
-        let query = Query::build(
-            cli.query,
-            &cfg.kind,
-            repo,
-            state,
-            cli.labels,
-            cli.author,
-            cli.since,
-            cli.milestone,
-            cfg.per_page,
-            cfg.token,
-        );
-        if query.raw.trim().is_empty() {
-            return Err(anyhow!(
-                "No query specified. Use -q or provide --repo/--state/--labels."
-            ));
+    #[test]
+    fn parses_config_subcommand() {
+        let cli = Cli::try_parse_from([
+            "99problems",
+            "config",
+            "set",
+            "instances.work.platform",
+            "gitlab",
+        ])
+        .expect("expected config command to parse");
+        match cli.command {
+            Commands::Config(_) => {}
+            Commands::Get(_) | Commands::Completions { .. } | Commands::Man(_) => {
+                panic!("expected config command")
+            }
         }
-        source.fetch(&query)?
-    };
+    }
 
-    let output = formatter.format(&conversations)?;
+    #[test]
+    fn parses_completions_subcommand() {
+        let cli = Cli::try_parse_from(["99problems", "completions", "bash"])
+            .expect("expected completions command to parse");
+        match cli.command {
+            Commands::Completions { shell } => match shell {
+                CompletionShell::Bash => {}
+                CompletionShell::Zsh
+                | CompletionShell::Fish
+                | CompletionShell::Powershell
+                | CompletionShell::Elvish => panic!("expected bash shell"),
+            },
+            Commands::Get(_) | Commands::Config(_) | Commands::Man(_) => {
+                panic!("expected completions command")
+            }
+        }
+    }
 
-    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());
+    #[test]
+    fn parses_repeated_verbose_flag() {
+        let cli = Cli::try_parse_from([
+            "99problems",
+            "-vv",
+            "get",
+            "--repo",
+            "owner/repo",
+            "--id",
+            "1",
+        ])
+        .expect("expected repeated verbosity flags to parse");
+        assert_eq!(cli.verbose, 2);
+        assert!(!cli.quiet);
+    }
+
+    #[test]
+    fn rejects_quiet_and_verbose_together() {
+        let err = Cli::try_parse_from([
+            "99problems",
+            "--quiet",
+            "-v",
+            "get",
+            "--repo",
+            "owner/repo",
+            "--id",
+            "1",
+        ])
+        .expect_err("expected conflict between --quiet and -v");
+        let message = err.to_string();
+        assert!(message.contains("--quiet"));
+        assert!(message.contains("--verbose"));
+    }
+
+    #[test]
+    fn parses_error_format_json() {
+        let cli = Cli::try_parse_from([
+            "99problems",
+            "--error-format",
+            "json",
+            "get",
+            "--repo",
+            "owner/repo",
+            "--id",
+            "1",
+        ])
+        .expect("expected --error-format json to parse");
+        match cli.error_format {
+            ErrorFormat::Json => {}
+            ErrorFormat::Text => panic!("expected json error format"),
         }
-        None => println!("{output}"),
     }
 
-    Ok(())
+    #[test]
+    fn parses_man_subcommand() {
+        let cli = Cli::try_parse_from(["99problems", "man", "--output", "docs/man"])
+            .expect("expected man command to parse");
+        match cli.command {
+            Commands::Man(_) => {}
+            Commands::Get(_) | Commands::Config(_) | Commands::Completions { .. } => {
+                panic!("expected man command")
+            }
+        }
+    }
 }

package/src/model.rs

@@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Conversation {
-    pub id: u64,
+    pub id: String,
     pub title: String,
     pub state: String,
     pub body: Option<String>,
@@ -14,4 +14,12 @@ pub struct Comment {
     pub author: Option<String>,
     pub created_at: String,
     pub body: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub kind: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub review_path: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub review_line: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub review_side: Option<String>,
 }

package/src/source/bitbucket/cloud/api.rs

@@ -0,0 +1,67 @@
+use anyhow::Result;
+use reqwest::StatusCode;
+use serde::de::DeserializeOwned;
+use tracing::{debug, trace};
+
+use super::super::shared::{apply_auth, parse_bitbucket_json, send};
+use super::super::{BitbucketSource, PAGE_SIZE};
+use super::model::BitbucketPage;
+
+impl BitbucketSource {
+    pub(super) fn bounded_per_page(per_page: u32) -> u32 {
+        per_page.clamp(1, PAGE_SIZE)
+    }
+
+    pub(super) fn cloud_get_one<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        token: Option<&str>,
+        operation: &str,
+    ) -> Result<Option<T>> {
+        let request = apply_auth(self.client.get(url), token).header("Accept", "application/json");
+        let response = send(request, operation)?;
+        if response.status() == StatusCode::NOT_FOUND {
+            return Ok(None);
+        }
+        let item = parse_bitbucket_json(response, token, operation)?;
+        Ok(Some(item))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn cloud_get_pages_stream<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        params: &[(String, String)],
+        token: Option<&str>,
+        per_page: u32,
+        emit: &mut dyn FnMut(T) -> Result<()>,
+    ) -> Result<usize> {
+        let per_page = Self::bounded_per_page(per_page);
+        let mut emitted = 0usize;
+        let mut next_url = Some(url.to_string());
+        let mut first = true;
+
+        while let Some(current_url) = next_url {
+            debug!(url = %current_url, per_page, "fetching Bitbucket cloud page");
+            let mut request = apply_auth(self.client.get(&current_url), token)
+                .header("Accept", "application/json");
+            if first {
+                let mut merged_params = params.to_vec();
+                merged_params.push(("pagelen".to_string(), per_page.to_string()));
+                request = request.query(&merged_params);
+                first = false;
+            }
+
+            let response = send(request, "page fetch")?;
+            let page: BitbucketPage<T> = parse_bitbucket_json(response, token, "page fetch")?;
+            trace!(count = page.values.len(), "decoded Bitbucket cloud page");
+            for item in page.values {
+                emit(item)?;
+                emitted += 1;
+            }
+            next_url = page.next;
+        }
+
+        Ok(emitted)
+    }
+}

package/src/source/bitbucket/cloud/mod.rs

@@ -0,0 +1,178 @@
+use anyhow::Result;
+
+use self::model::{
+    BitbucketCommentItem, BitbucketPullRequestItem, map_pr_comment, matches_pr_filters,
+};
+use super::BitbucketSource;
+use super::query::{BitbucketFilters, parse_bitbucket_query, parse_workspace_repo};
+use crate::error::AppError;
+use crate::model::Conversation;
+use crate::source::{ContentKind, FetchRequest, FetchTarget};
+
+mod api;
+mod model;
+
+impl BitbucketSource {
+    pub(super) fn fetch_cloud_stream(
+        &self,
+        req: &FetchRequest,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        match &req.target {
+            FetchTarget::Search { raw_query } => self.search_stream(req, raw_query, emit),
+            FetchTarget::Id {
+                repo,
+                id,
+                kind,
+                allow_fallback_to_pr: _,
+            } => self.fetch_by_id_stream(req, repo, id, *kind, emit),
+        }
+    }
+
+    fn search_stream(
+        &self,
+        req: &FetchRequest,
+        raw_query: &str,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        let filters = parse_bitbucket_query(raw_query);
+        if matches!(filters.kind, ContentKind::Issue) {
+            return Err(AppError::usage(
+                "Bitbucket Cloud supports pull requests only. Use --type pr or omit --type.",
+            )
+            .into());
+        }
+        let (workspace, repo_slug) = parse_workspace_repo(filters.repo.as_deref())?;
+        let repo = format!("{workspace}/{repo_slug}");
+
+        self.search_prs_stream(req, &repo, &filters, emit)
+    }
+
+    fn search_prs_stream(
+        &self,
+        req: &FetchRequest,
+        repo: &str,
+        filters: &BitbucketFilters,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        let url = format!("{}/repositories/{repo}/pullrequests", self.base_url);
+        let params = vec![
+            ("sort".to_string(), "-updated_on".to_string()),
+            ("state".to_string(), "ALL".to_string()),
+        ];
+        let mut emitted = 0usize;
+        self.cloud_get_pages_stream(
+            &url,
+            &params,
+            req.token.as_deref(),
+            req.per_page,
+            &mut |item: BitbucketPullRequestItem| {
+                if !matches_pr_filters(&item, filters) {
+                    return Ok(());
+                }
+                let conversation = self.fetch_pr_conversation(repo, item, req)?;
+                emit(conversation)?;
+                emitted += 1;
+                Ok(())
+            },
+        )?;
+        Ok(emitted)
+    }
+
+    fn fetch_by_id_stream(
+        &self,
+        req: &FetchRequest,
+        repo: &str,
+        id: &str,
+        kind: ContentKind,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        let (workspace, repo_slug) = parse_workspace_repo(Some(repo))?;
+        let repo = format!("{workspace}/{repo_slug}");
+        let id = id.parse::<u64>().map_err(|_| {
+            AppError::usage(format!(
+                "Bitbucket Cloud expects a numeric pull request id, got '{id}'."
+            ))
+        })?;
+        match kind {
+            ContentKind::Issue => Err(AppError::usage(
+                "Bitbucket Cloud supports pull requests only. Use --type pr or omit --type.",
+            )
+            .into()),
+            ContentKind::Pr => {
+                if let Some(pr) = self.fetch_pr_by_id(&repo, id, req)? {
+                    emit(self.fetch_pr_conversation(&repo, pr, req)?)?;
+                    return Ok(1);
+                }
+                Err(
+                    AppError::not_found(format!("Pull request #{id} not found in repo {repo}."))
+                        .into(),
+                )
+            }
+        }
+    }
+
+    fn fetch_pr_by_id(
+        &self,
+        repo: &str,
+        id: u64,
+        req: &FetchRequest,
+    ) -> Result<Option<BitbucketPullRequestItem>> {
+        let url = format!("{}/repositories/{repo}/pullrequests/{id}", self.base_url);
+        self.cloud_get_one(&url, req.token.as_deref(), "pull request fetch")
+    }
+
+    fn fetch_pr_conversation(
+        &self,
+        repo: &str,
+        item: BitbucketPullRequestItem,
+        req: &FetchRequest,
+    ) -> Result<Conversation> {
+        let comments = if req.include_comments {
+            self.fetch_pr_comments(repo, item.id, req)?
+        } else {
+            Vec::new()
+        };
+        let body = item
+            .description
+            .or_else(|| item.summary.and_then(|s| s.raw))
+            .filter(|b| !b.is_empty());
+        Ok(Conversation {
+            id: item.id.to_string(),
+            title: item.title,
+            state: item.state,
+            body,
+            comments,
+        })
+    }
+
+    fn fetch_pr_comments(
+        &self,
+        repo: &str,
+        id: u64,
+        req: &FetchRequest,
+    ) -> Result<Vec<crate::model::Comment>> {
+        let url = format!(
+            "{}/repositories/{repo}/pullrequests/{id}/comments",
+            self.base_url
+        );
+        let mut comments = Vec::new();
+        self.cloud_get_pages_stream(
+            &url,
+            &[],
+            req.token.as_deref(),
+            req.per_page,
+            &mut |item: BitbucketCommentItem| {
+                if item.deleted.unwrap_or(false) {
+                    return Ok(());
+                }
+                if let Some(mapped) = map_pr_comment(item, req.include_review_comments) {
+                    comments.push(mapped);
+                }
+                Ok(())
+            },
+        )?;
+        comments.sort_by(|a, b| a.created_at.cmp(&b.created_at));
+        Ok(comments)
+    }
+}