@mbe24/99problems 0.1.1 → 0.2.0

package/Cargo.lock

@@ -653,7 +653,7 @@ dependencies = [
 
 [[package]]
 name = "problems99"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "anyhow",
  "clap",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "problems99"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2024"
 description = "GitHub issue conversation fetcher CLI"
 license = "Apache-2.0"

package/README.md

@@ -8,9 +8,9 @@
 
 > AI-friendly access to GitHub issues.
 
-Fetch GitHub issue conversations as structured JSON or YAML — ready for LLM pipelines, RAG, and bulk analysis. Uses the same search syntax as the GitHub web UI.
-
+`99problems` is a command-line tool that fetches GitHub issue conversations — including all comments — and exports them as structured **JSON** or **YAML**. It uses the same search syntax as the GitHub web UI, making it easy to export, analyse, or feed GitHub issues into LLM pipelines, RAG systems, vector stores, and data analysis workflows.
 
+Built in Rust. Distributed as a single binary via npm and crates.io. No runtime dependencies.
 
 ## Installation
 
@@ -24,27 +24,27 @@ Or via cargo:
 cargo install problems99
 ```
 
-Pre-built binaries are available for Windows x64, Linux x64, Linux ARM64, macOS Intel, and macOS Apple Silicon. No runtime dependencies.
+Pre-built binaries are available for Windows x64, Linux x64, Linux ARM64, macOS Intel, and macOS Apple Silicon.
 
 ## Usage
 
 ```bash
-# Fetch all closed issues mentioning "Event" from a repo
+# Export all closed issues mentioning "Event" to JSON
 99problems -q "is:issue state:closed Event repo:schemaorg/schemaorg" -o output.json
 
-# Fetch a single issue
+# Fetch a single issue with all its comments
 99problems --repo schemaorg/schemaorg --issue 1842
 
-# YAML output
+# Export open bug issues as YAML
 99problems -q "state:open label:bug repo:owner/repo" --format yaml
 
-# Pipe into jq
+# Pipe into jq for further processing
 99problems -q "state:closed repo:owner/repo" | jq '.[].title'
 ```
 
 ## Output
 
-Each result is a conversation object with the issue body and all comments:
+Each result is a conversation object containing the issue body and all comments:
 
 ```json
 [
@@ -78,6 +78,7 @@ Each result is a conversation object with the issue body and all comments:
 Example `~/.99problems`:
 
 ```toml
+[github]
 token = "ghp_your_personal_access_token"
 ```
 
@@ -88,31 +89,46 @@ repo  = "owner/my-repo"
 state = "closed"
 ```
 
-Token is resolved in this order: `--token` flag → `GITHUB_TOKEN` env var → `./.99problems` → `~/.99problems`. Without a token the GitHub API rate limit is 60 requests/hour; with one it's 5,000/hour.
+For self-hosted GitLab:
+
+```toml
+platform = "gitlab"
+
+[gitlab]
+token = "glpat_your_token"
+url   = "https://gitlab.mycompany.com"
+```
+
+Token is resolved in this order: `--token` flag → `GITHUB_TOKEN`/`GITLAB_TOKEN`/`BITBUCKET_TOKEN` env var → `./.99problems` → `~/.99problems`. Without a token the GitHub API rate limit is 60 requests/hour; with one it's 5,000/hour.
 
 ## Options
 
 ```
 Options:
-  -q, --query <QUERY>      Full GitHub search query (web UI syntax)
-      --repo <REPO>        Shorthand for "repo:owner/name"
-      --state <STATE>      Shorthand for "state:open|closed"
-      --labels <LABELS>    Comma-separated labels, e.g. "bug,help wanted"
-      --issue <ISSUE>      Fetch a single issue by number (requires --repo)
-      --source <SOURCE>    Data source [default: github-issues]
-      --format <FORMAT>    Output format: json | yaml [default: json]
-  -o, --output <FILE>      Write to file instead of stdout
-      --token <TOKEN>      GitHub personal access token
-  -h, --help               Print help
-  -V, --version            Print version
+  -q, --query <QUERY>        Full search query (platform web UI syntax)
+      --repo <REPO>          Shorthand for "repo:owner/name"
+      --state <STATE>        Shorthand for "state:open|closed"
+      --labels <LABELS>      Comma-separated labels, e.g. "bug,help wanted"
+      --author <AUTHOR>      Filter by issue/PR author
+      --since <DATE>         Only items created on or after YYYY-MM-DD
+      --milestone <NAME>     Filter by milestone title or number
+      --issue <ISSUE>        Fetch a single issue by number (requires --repo)
+      --platform <PLATFORM>  Platform: github | gitlab | bitbucket [default: github]
+      --type <TYPE>          Content type: issue | pr [default: issue]
+      --format <FORMAT>      Output format: json | yaml [default: json]
+  -o, --output <FILE>        Write to file instead of stdout
+      --token <TOKEN>        Personal access token
+  -h, --help                 Print help
+  -V, --version              Print version
 ```
 
 ## Use cases
 
-- **LLM context / RAG** — load issue history into a vector store or prompt
-- **Issue triage** — process closed issues in bulk with Python or JavaScript
-- **Dataset generation** — build labelled datasets from GitHub discussions
-- **Changelog automation** — extract closed issues for release notes
+- **LLM context / RAG** — export issue history into a vector store or use as prompt context
+- **Issue triage and analysis** — bulk-process GitHub issues with Python, JavaScript, or any data tool
+- **Training data generation** — build labelled datasets from GitHub discussions and bug reports
+- **Changelog and release notes** — extract closed issues for automated release documentation
+- **Knowledge base indexing** — crawl project issue trackers for search and retrieval systems
 
 ## Contributing
 
@@ -121,4 +137,3 @@ See [CONTRIBUTING.md](CONTRIBUTING.md).
 ## License
 
 See [LICENSE](LICENSE).
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mbe24/99problems",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "GitHub issue conversation fetcher CLI",
   "bin": {
     "99problems": "./npm/bin/99problems.js"
@@ -9,11 +9,11 @@
     "postinstall": "node npm/install.js"
   },
   "optionalDependencies": {
-    "@mbe24/99problems-win32-x64": "0.1.1",
-    "@mbe24/99problems-linux-x64": "0.1.1",
-    "@mbe24/99problems-darwin-x64": "0.1.1",
-    "@mbe24/99problems-darwin-arm64": "0.1.1",
-    "@mbe24/99problems-linux-arm64": "0.1.1"
+    "@mbe24/99problems-win32-x64": "0.2.0",
+    "@mbe24/99problems-linux-x64": "0.2.0",
+    "@mbe24/99problems-darwin-x64": "0.2.0",
+    "@mbe24/99problems-darwin-arm64": "0.2.0",
+    "@mbe24/99problems-linux-arm64": "0.2.0"
   },
   "license": "MIT",
   "repository": {

package/src/config.rs

@@ -2,50 +2,120 @@ use anyhow::Result;
 use serde::Deserialize;
 use std::path::PathBuf;
 
-/// Represents values that can be set in a .99problems TOML dotfile.
+/// Per-platform credentials and settings.
+#[derive(Debug, Default, Deserialize, Clone)]
+pub struct PlatformConfig {
+    pub token: Option<String>,
+    /// Base URL override for self-hosted instances (e.g. GitLab)
+    pub url: Option<String>,
+}
+
+/// Top-level dotfile structure (.99problems).
 #[derive(Debug, Default, Deserialize)]
 pub struct DotfileConfig {
-    pub token: Option<String>,
+    /// Default platform (overridden by --platform flag)
+    pub platform: Option<String>,
+    /// Default type: "issue" or "pr" (overridden by --type flag)
+    #[serde(rename = "type")]
+    pub kind: Option<String>,
     pub repo: Option<String>,
     pub state: Option<String>,
     pub per_page: Option<u32>,
+    pub github: Option<PlatformConfig>,
+    pub gitlab: Option<PlatformConfig>,
+    pub bitbucket: Option<PlatformConfig>,
 }
 
-/// Fully resolved config after merging home + local dotfiles + env var.
+/// Fully resolved config after merging home + local dotfiles + env vars.
 #[derive(Debug, Default)]
 pub struct Config {
+    pub platform: String,
+    pub kind: String,
     pub token: Option<String>,
     pub repo: Option<String>,
     pub state: Option<String>,
     pub per_page: u32,
+    /// Base URL for the active platform (for self-hosted instances)
+    #[allow(dead_code)]
+    pub platform_url: Option<String>,
 }
 
 impl Config {
-    /// Load and merge: home dotfile (base) → local dotfile (override) → env var.
-    /// CLI flags are merged later in main.rs on top of this.
+    /// Load and merge: home dotfile (base) → local dotfile (override) → env vars.
+    /// CLI flags are applied on top in main.rs.
     pub fn load() -> Result<Self> {
         let home = load_dotfile(home_dotfile_path())?;
         let local = load_dotfile(local_dotfile_path())?;
 
-        // Merge: local wins over home
-        let token = std::env::var("GITHUB_TOKEN")
-            .ok()
-            .or_else(|| local.token.clone())
-            .or_else(|| home.token.clone());
+        let platform = local
+            .platform
+            .clone()
+            .or_else(|| home.platform.clone())
+            .unwrap_or_else(|| "github".into());
 
-        let repo = local.repo.or(home.repo);
-        let state = local.state.or(home.state);
+        let kind = local
+            .kind
+            .clone()
+            .or_else(|| home.kind.clone())
+            .unwrap_or_else(|| "issue".into());
+
+        let repo = local.repo.clone().or(home.repo.clone());
+        let state = local.state.clone().or(home.state.clone());
         let per_page = local.per_page.or(home.per_page).unwrap_or(100);
 
+        // Resolve token: env var → local dotfile → home dotfile
+        let env_var = match platform.as_str() {
+            "github" => "GITHUB_TOKEN",
+            "gitlab" => "GITLAB_TOKEN",
+            "bitbucket" => "BITBUCKET_TOKEN",
+            _ => "GITHUB_TOKEN",
+        };
+        let (dotfile_token, platform_url) = resolve_platform_token(&platform, &local, &home);
+        let token = std::env::var(env_var).ok().or(dotfile_token);
+
         Ok(Self {
+            platform,
+            kind,
             token,
             repo,
             state,
             per_page,
+            platform_url,
         })
     }
 }
 
+/// Resolve token and optional URL for the given platform from dotfiles only.
+fn resolve_platform_token(
+    platform: &str,
+    local: &DotfileConfig,
+    home: &DotfileConfig,
+) -> (Option<String>, Option<String>) {
+    let local_platform = platform_section(platform, local);
+    let home_platform = platform_section(platform, home);
+
+    let token = local_platform
+        .as_ref()
+        .and_then(|p| p.token.clone())
+        .or_else(|| home_platform.as_ref().and_then(|p| p.token.clone()));
+
+    let url = local_platform
+        .as_ref()
+        .and_then(|p| p.url.clone())
+        .or_else(|| home_platform.as_ref().and_then(|p| p.url.clone()));
+
+    (token, url)
+}
+
+fn platform_section<'a>(platform: &str, cfg: &'a DotfileConfig) -> Option<&'a PlatformConfig> {
+    match platform {
+        "github" => cfg.github.as_ref(),
+        "gitlab" => cfg.gitlab.as_ref(),
+        "bitbucket" => cfg.bitbucket.as_ref(),
+        _ => None,
+    }
+}
+
 fn home_dotfile_path() -> Option<PathBuf> {
     dirs::home_dir().map(|h| h.join(".99problems"))
 }
@@ -71,7 +141,7 @@ mod tests {
     #[test]
     fn dotfile_config_defaults_when_missing() {
         let cfg = load_dotfile(None).unwrap();
-        assert!(cfg.token.is_none());
+        assert!(cfg.github.is_none());
         assert!(cfg.repo.is_none());
         assert!(cfg.per_page.is_none());
     }
@@ -79,23 +149,52 @@ mod tests {
     #[test]
     fn dotfile_config_parses_toml() {
         let toml = r#"
-            token = "ghp_test"
             repo = "owner/repo"
             state = "closed"
             per_page = 50
+
+            [github]
+            token = "ghp_test"
         "#;
         let cfg: DotfileConfig = toml::from_str(toml).unwrap();
-        assert_eq!(cfg.token.as_deref(), Some("ghp_test"));
         assert_eq!(cfg.repo.as_deref(), Some("owner/repo"));
         assert_eq!(cfg.per_page, Some(50));
+        assert_eq!(
+            cfg.github.as_ref().and_then(|g| g.token.as_deref()),
+            Some("ghp_test")
+        );
     }
 
     #[test]
     fn config_per_page_defaults_to_100() {
-        // Simulate both dotfiles missing, no env var
         let home = DotfileConfig::default();
         let local = DotfileConfig::default();
         let per_page = local.per_page.or(home.per_page).unwrap_or(100);
         assert_eq!(per_page, 100);
     }
+
+    #[test]
+    fn config_platform_defaults_to_github() {
+        let home = DotfileConfig::default();
+        let local = DotfileConfig::default();
+        let platform = local
+            .platform
+            .or(home.platform)
+            .unwrap_or_else(|| "github".into());
+        assert_eq!(platform, "github");
+    }
+
+    #[test]
+    fn resolve_token_uses_platform_section() {
+        let home = DotfileConfig::default();
+        let local = DotfileConfig {
+            github: Some(PlatformConfig {
+                token: Some("ghp_section".into()),
+                url: None,
+            }),
+            ..Default::default()
+        };
+        let (token, _) = resolve_platform_token("github", &local, &home);
+        assert_eq!(token.as_deref(), Some("ghp_section"));
+    }
 }

package/src/main.rs

@@ -17,10 +17,36 @@ enum OutputFormat {
     Yaml,
 }
 
+#[derive(Debug, Clone, ValueEnum, PartialEq)]
+enum Platform {
+    Github,
+    Gitlab,
+    Bitbucket,
+}
+
+impl Platform {
+    fn as_str(&self) -> &str {
+        match self {
+            Platform::Github => "github",
+            Platform::Gitlab => "gitlab",
+            Platform::Bitbucket => "bitbucket",
+        }
+    }
+}
+
 #[derive(Debug, Clone, ValueEnum)]
-enum SourceKind {
-    GithubIssues,
-    GithubPrs,
+enum ContentType {
+    Issue,
+    Pr,
+}
+
+impl ContentType {
+    fn as_str(&self) -> &str {
+        match self {
+            ContentType::Issue => "issue",
+            ContentType::Pr => "pr",
+        }
+    }
 }
 
 #[derive(Parser, Debug)]
@@ -30,8 +56,8 @@ enum SourceKind {
     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"
+    /// 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>,
 
@@ -47,13 +73,29 @@ struct Cli {
     #[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>,
 
-    /// Data source to use
-    #[arg(long, value_enum, default_value = "github-issues")]
-    source: SourceKind,
+    /// 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")]
@@ -63,7 +105,7 @@ struct Cli {
     #[arg(short = 'o', long)]
     output: Option<String>,
 
-    /// GitHub personal access token (overrides GITHUB_TOKEN and dotfile)
+    /// Personal access token (overrides env var and dotfile)
     #[arg(long)]
     token: Option<String>,
 }
@@ -72,38 +114,48 @@ fn main() -> Result<()> {
     let cli = Cli::parse();
     let mut cfg = Config::load()?;
 
-    // CLI token overrides everything
+    // CLI flags override config values
+    if let Some(p) = &cli.platform {
+        cfg.platform = p.as_str().to_owned();
+    }
+    if let Some(k) = &cli.kind {
+        cfg.kind = k.as_str().to_owned();
+    }
     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 source: Box<dyn Source> = match cfg.platform.as_str() {
+        "github" => Box::new(GitHubIssues::new()?),
+        other => return Err(anyhow!("Platform '{other}' is not yet supported")),
     };
 
     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);
+        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."

package/src/source/github_issues.rs

@@ -1,10 +1,14 @@
 use anyhow::{Result, anyhow};
-use reqwest::blocking::Client;
+use reqwest::blocking::{Client, RequestBuilder};
 use serde::Deserialize;
 
 use super::{Query, Source};
 use crate::model::{Comment, Conversation};
 
+const GITHUB_API_BASE: &str = "https://api.github.com";
+const GITHUB_API_VERSION: &str = "2022-11-28";
+const PAGE_SIZE: u32 = 100;
+
 pub struct GitHubIssues {
     client: Client,
 }
@@ -12,13 +16,19 @@ pub struct GitHubIssues {
 impl GitHubIssues {
     pub fn new() -> Result<Self> {
         let client = Client::builder()
-            .user_agent("99problems-cli/0.1.0")
+            .user_agent(concat!("99problems-cli/", env!("CARGO_PKG_VERSION")))
             .build()?;
         Ok(Self { client })
     }
 
-    fn auth_header(token: &Option<String>) -> Option<String> {
-        token.as_ref().map(|t| format!("Bearer {t}"))
+    /// Adds Authorization + API version headers when a token is present.
+    fn apply_auth(req: RequestBuilder, token: &Option<String>) -> RequestBuilder {
+        match token.as_ref() {
+            Some(t) => req
+                .header("Authorization", format!("Bearer {t}"))
+                .header("X-GitHub-Api-Version", GITHUB_API_VERSION),
+            None => req,
+        }
     }
 
     fn get_pages<T: for<'de> Deserialize<'de>>(
@@ -31,17 +41,11 @@ impl GitHubIssues {
         let mut page = 1u32;
 
         loop {
-            let mut req = self.client.get(url).query(&[
+            let 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 req = Self::apply_auth(req, token);
             let resp = req.send()?;
 
             if !resp.status().is_success() {
@@ -101,24 +105,19 @@ struct UserItem {
 
 impl Source for GitHubIssues {
     fn fetch(&self, query: &Query) -> Result<Vec<Conversation>> {
-        let search_url = "https://api.github.com/search/issues";
+        let search_url = format!("{GITHUB_API_BASE}/search/issues");
         let mut page = 1u32;
         let mut all_issues: Vec<IssueItem> = vec![];
 
         loop {
-            let mut req = self.client.get(search_url).query(&[
+            let 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 req = Self::apply_auth(req, &query.token);
             let resp = req.send()?;
+
             if !resp.status().is_success() {
                 return Err(anyhow!(
                     "GitHub search error {}: {}",
@@ -128,7 +127,7 @@ impl Source for GitHubIssues {
             }
 
             let search: SearchResponse = resp.json()?;
-            let done = search.items.len() < 100;
+            let done = search.items.len() < PAGE_SIZE as usize;
             all_issues.extend(search.items);
             if done {
                 break;
@@ -144,11 +143,11 @@ impl Source for GitHubIssues {
         let mut conversations = vec![];
         for issue in all_issues {
             let comments_url = format!(
-                "https://api.github.com/repos/{repo}/issues/{}/comments",
+                "{GITHUB_API_BASE}/repos/{repo}/issues/{}/comments",
                 issue.number
             );
             let raw_comments: Vec<CommentItem> =
-                self.get_pages(&comments_url, &query.token, 100)?;
+                self.get_pages(&comments_url, &query.token, PAGE_SIZE)?;
 
             conversations.push(Conversation {
                 id: issue.number,
@@ -170,11 +169,8 @@ impl Source for GitHubIssues {
     }
 
     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()?;
+        let issue_url = format!("{GITHUB_API_BASE}/repos/{repo}/issues/{issue_id}");
+        let resp = self.client.get(&issue_url).send()?;
         if !resp.status().is_success() {
             return Err(anyhow!(
                 "GitHub issue error {}: {}",
@@ -184,9 +180,8 @@ impl Source for GitHubIssues {
         }
         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)?;
+        let comments_url = format!("{GITHUB_API_BASE}/repos/{repo}/issues/{issue_id}/comments");
+        let raw_comments: Vec<CommentItem> = self.get_pages(&comments_url, &None, PAGE_SIZE)?;
 
         Ok(Conversation {
             id: issue.number,

package/src/source/mod.rs

@@ -13,7 +13,7 @@ pub trait 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"
+    /// Full raw query string (platform search syntax), e.g. "state:closed Event repo:owner/repo"
     pub raw: String,
     pub per_page: u32,
     pub token: Option<String>,
@@ -21,12 +21,17 @@ pub struct Query {
 
 impl Query {
     /// Build a query by merging a raw string with convenience shorthands.
-    /// Shorthands are only appended if their qualifier isn't already present.
+    /// Shorthands are only appended if their qualifier isn't already present in the raw string.
+    #[allow(clippy::too_many_arguments)]
     pub fn build(
         raw: Option<String>,
+        kind: &str,
         repo: Option<String>,
         state: Option<String>,
         labels: Option<String>,
+        author: Option<String>,
+        since: Option<String>,
+        milestone: Option<String>,
         per_page: u32,
         token: Option<String>,
     ) -> Self {
@@ -36,6 +41,17 @@ impl Query {
             parts.push(r);
         }
 
+        // Inject type qualifier unless already present
+        if !parts
+            .iter()
+            .any(|p| p.contains("is:issue") || p.contains("is:pr") || p.contains("type:"))
+        {
+            match kind {
+                "pr" => parts.push("is:pr".into()),
+                _ => parts.push("is:issue".into()),
+            }
+        }
+
         if let Some(repo) = repo
             && !parts.iter().any(|p| p.contains("repo:"))
         {
@@ -54,6 +70,21 @@ impl Query {
                 }
             }
         }
+        if let Some(author) = author
+            && !parts.iter().any(|p| p.contains("author:"))
+        {
+            parts.push(format!("author:{author}"));
+        }
+        if let Some(since) = since
+            && !parts.iter().any(|p| p.contains("created:"))
+        {
+            parts.push(format!("created:>={since}"));
+        }
+        if let Some(milestone) = milestone
+            && !parts.iter().any(|p| p.contains("milestone:"))
+        {
+            parts.push(format!("milestone:{milestone}"));
+        }
 
         Query {
             raw: parts.join(" "),
@@ -67,29 +98,36 @@ impl Query {
 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()),
+    fn build(raw: Option<&str>, kind: &str, repo: Option<&str>, state: Option<&str>) -> Query {
+        Query::build(
+            raw.map(|s| s.into()),
+            kind,
+            repo.map(|s| s.into()),
+            state.map(|s| s.into()),
+            None,
+            None,
+            None,
             None,
             100,
             None,
-        );
+        )
+    }
+
+    #[test]
+    fn build_query_appends_repo_and_state() {
+        let q = build(Some("Event"), "issue", Some("owner/repo"), Some("closed"));
         assert!(q.raw.contains("repo:owner/repo"));
         assert!(q.raw.contains("state:closed"));
-        assert!(q.raw.contains("is:issue Event"));
+        assert!(q.raw.contains("Event"));
+        assert!(q.raw.contains("is:issue"));
     }
 
     #[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,
+        let q = build(
+            Some("is:issue repo:owner/repo"),
+            "issue",
+            Some("other/repo"),
             None,
         );
         assert_eq!(q.raw.matches("repo:").count(), 1);
@@ -97,14 +135,73 @@ mod tests {
 
     #[test]
     fn build_query_handles_multiple_labels() {
-        let q = Query::build(None, None, None, Some("bug,enhancement".into()), 100, None);
+        let q = Query::build(
+            None,
+            "issue",
+            None,
+            None,
+            Some("bug,enhancement".into()),
+            None,
+            None,
+            None,
+            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(), "");
+    fn build_query_empty_produces_type_qualifier() {
+        let q = build(None, "issue", None, None);
+        assert!(q.raw.contains("is:issue"));
+    }
+
+    #[test]
+    fn build_query_pr_type_injects_is_pr() {
+        let q = build(None, "pr", Some("owner/repo"), None);
+        assert!(q.raw.contains("is:pr"));
+        assert!(!q.raw.contains("is:issue"));
+    }
+
+    #[test]
+    fn build_query_does_not_duplicate_type() {
+        let q = build(Some("is:pr repo:owner/repo"), "pr", None, None);
+        assert_eq!(q.raw.matches("is:pr").count(), 1);
+    }
+
+    #[test]
+    fn build_query_author_and_since() {
+        let q = Query::build(
+            None,
+            "issue",
+            None,
+            None,
+            None,
+            Some("octocat".into()),
+            Some("2024-01-01".into()),
+            None,
+            100,
+            None,
+        );
+        assert!(q.raw.contains("author:octocat"));
+        assert!(q.raw.contains("created:>=2024-01-01"));
+    }
+
+    #[test]
+    fn build_query_milestone() {
+        let q = Query::build(
+            None,
+            "issue",
+            None,
+            None,
+            None,
+            None,
+            None,
+            Some("v1.0".into()),
+            100,
+            None,
+        );
+        assert!(q.raw.contains("milestone:v1.0"));
     }
 }

package/tests/integration.rs

@@ -8,7 +8,12 @@ mod tests {
     use problems99::source::{Query, Source, github_issues::GitHubIssues};
 
     fn token() -> Option<String> {
-        std::env::var("GITHUB_TOKEN").ok()
+        // Prefer env var, fall back to dotfile config (same resolution as the binary)
+        std::env::var("GITHUB_TOKEN").ok().or_else(|| {
+            problems99::config::Config::load()
+                .ok()
+                .and_then(|c| c.token)
+        })
     }
 
     #[test]
@@ -29,6 +34,10 @@ mod tests {
         let source = GitHubIssues::new().unwrap();
         let query = Query::build(
             Some("is:issue state:closed EventSeries repo:schemaorg/schemaorg".into()),
+            "issue",
+            None,
+            None,
+            None,
             None,
             None,
             None,