@mbe24/99problems 0.2.0 → 0.3.1

package/src/source/gitlab/query.rs

@@ -0,0 +1,177 @@
+use std::fmt::Write as _;
+
+use crate::source::ContentKind;
+
+#[derive(Debug)]
+pub(super) struct GitLabFilters {
+    pub(super) repo: Option<String>,
+    pub(super) kind: ContentKind,
+    pub(super) state: Option<String>,
+    pub(super) labels: Vec<String>,
+    pub(super) author: Option<String>,
+    pub(super) since: Option<String>,
+    pub(super) milestone: Option<String>,
+    pub(super) search_terms: Vec<String>,
+}
+
+impl Default for GitLabFilters {
+    fn default() -> Self {
+        Self {
+            repo: None,
+            kind: ContentKind::Issue,
+            state: None,
+            labels: vec![],
+            author: None,
+            since: None,
+            milestone: None,
+            search_terms: vec![],
+        }
+    }
+}
+
+pub(super) fn parse_gitlab_query(raw_query: &str) -> GitLabFilters {
+    let mut filters = GitLabFilters::default();
+
+    for token in raw_query.split_whitespace() {
+        if token == "is:issue" {
+            filters.kind = ContentKind::Issue;
+            continue;
+        }
+        if token == "is:pr" {
+            filters.kind = ContentKind::Pr;
+            continue;
+        }
+        if let Some(kind) = token.strip_prefix("type:") {
+            if kind == "pr" {
+                filters.kind = ContentKind::Pr;
+                continue;
+            }
+            if kind == "issue" {
+                filters.kind = ContentKind::Issue;
+                continue;
+            }
+        }
+        if let Some(repo) = token.strip_prefix("repo:") {
+            filters.repo = Some(repo.to_string());
+            continue;
+        }
+        if let Some(state) = token.strip_prefix("state:") {
+            filters.state = Some(state.to_string());
+            continue;
+        }
+        if let Some(label) = token.strip_prefix("label:") {
+            filters.labels.push(label.to_string());
+            continue;
+        }
+        if let Some(author) = token.strip_prefix("author:") {
+            filters.author = Some(author.to_string());
+            continue;
+        }
+        if let Some(since) = token.strip_prefix("created:>=") {
+            filters.since = Some(since.to_string());
+            continue;
+        }
+        if let Some(milestone) = token.strip_prefix("milestone:") {
+            filters.milestone = Some(milestone.to_string());
+            continue;
+        }
+
+        filters.search_terms.push(token.to_string());
+    }
+
+    filters
+}
+
+pub(super) fn build_search_params(filters: &GitLabFilters) -> Vec<(String, String)> {
+    let mut params = Vec::new();
+
+    if let Some(state) = normalize_state(filters.kind, filters.state.as_deref()) {
+        params.push(("state".into(), state.to_string()));
+    }
+    if !filters.labels.is_empty() {
+        params.push(("labels".into(), filters.labels.join(",")));
+    }
+    if let Some(author) = &filters.author {
+        params.push(("author_username".into(), author.clone()));
+    }
+    if let Some(since) = &filters.since {
+        params.push(("created_after".into(), since.clone()));
+    }
+    if let Some(milestone) = &filters.milestone {
+        params.push(("milestone".into(), milestone.clone()));
+    }
+    if !filters.search_terms.is_empty() {
+        params.push(("search".into(), filters.search_terms.join(" ")));
+    }
+
+    params
+}
+
+fn normalize_state(kind: ContentKind, state: Option<&str>) -> Option<&'static str> {
+    let s = state?.to_ascii_lowercase();
+    match kind {
+        ContentKind::Issue => match s.as_str() {
+            "open" | "opened" => Some("opened"),
+            "closed" => Some("closed"),
+            "all" => Some("all"),
+            _ => None,
+        },
+        ContentKind::Pr => match s.as_str() {
+            "open" | "opened" => Some("opened"),
+            "closed" => Some("closed"),
+            "merged" => Some("merged"),
+            "locked" => Some("locked"),
+            "all" => Some("all"),
+            _ => None,
+        },
+    }
+}
+
+pub(super) fn encode_project_path(path: &str) -> String {
+    let mut out = String::new();
+    for b in path.as_bytes() {
+        if b.is_ascii_alphanumeric() || matches!(*b, b'-' | b'.' | b'_' | b'~') {
+            out.push(*b as char);
+        } else {
+            write!(out, "%{b:02X}").expect("writing to String should never fail");
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_gitlab_query_extracts_filters() {
+        let q = parse_gitlab_query(
+            "is:pr repo:group/project state:closed label:bug author:alice created:>=2024-01-01 milestone:v1 text",
+        );
+        assert!(matches!(q.kind, ContentKind::Pr));
+        assert_eq!(q.repo.as_deref(), Some("group/project"));
+        assert_eq!(q.state.as_deref(), Some("closed"));
+        assert_eq!(q.labels, vec!["bug"]);
+        assert_eq!(q.author.as_deref(), Some("alice"));
+        assert_eq!(q.since.as_deref(), Some("2024-01-01"));
+        assert_eq!(q.milestone.as_deref(), Some("v1"));
+        assert_eq!(q.search_terms, vec!["text"]);
+    }
+
+    #[test]
+    fn normalize_state_maps_open_to_opened() {
+        assert_eq!(
+            normalize_state(ContentKind::Issue, Some("open")),
+            Some("opened")
+        );
+        assert_eq!(
+            normalize_state(ContentKind::Pr, Some("open")),
+            Some("opened")
+        );
+    }
+
+    #[test]
+    fn encode_project_path_encodes_slash() {
+        assert_eq!(encode_project_path("group/project"), "group%2Fproject");
+    }
+}

package/src/source/jira/api.rs

@@ -0,0 +1,222 @@
+use anyhow::Result;
+use reqwest::StatusCode;
+use reqwest::blocking::{RequestBuilder, Response};
+use reqwest::header::CONTENT_TYPE;
+use serde::Deserialize;
+use tracing::{debug, trace};
+
+use super::model::{JiraCommentsPage, JiraIssueItem, extract_adf_text};
+use super::{JiraSource, PAGE_SIZE};
+use crate::error::{AppError, app_error_from_decode, app_error_from_reqwest};
+use crate::model::{Comment, Conversation};
+use crate::source::FetchRequest;
+
+impl JiraSource {
+    pub(super) fn apply_auth(
+        req: RequestBuilder,
+        token: Option<&str>,
+        account_email: Option<&str>,
+    ) -> RequestBuilder {
+        let req = req.header("Accept", "application/json");
+        match token {
+            Some(t) if t.contains(':') => {
+                let (user, api_token) = t.split_once(':').unwrap_or_default();
+                req.basic_auth(user, Some(api_token))
+            }
+            Some(t) => match account_email {
+                Some(email) => req.basic_auth(email, Some(t)),
+                None => req.bearer_auth(t),
+            },
+            None => req,
+        }
+    }
+
+    pub(super) fn bounded_per_page(per_page: u32) -> u32 {
+        per_page.clamp(1, PAGE_SIZE)
+    }
+
+    pub(super) fn send(req: RequestBuilder, operation: &str) -> Result<Response> {
+        req.send()
+            .map_err(|err| app_error_from_reqwest("Jira", operation, &err).into())
+    }
+
+    pub(super) fn fetch_issue(&self, id_or_key: &str, req: &FetchRequest) -> Result<Conversation> {
+        let fields = "summary,description,status";
+        let url = format!("{}/rest/api/3/issue/{}", self.base_url, id_or_key);
+        let http = Self::apply_auth(
+            self.client.get(&url),
+            req.token.as_deref(),
+            req.account_email.as_deref(),
+        )
+        .query(&[("fields", fields)]);
+        let resp = Self::send(http, "issue fetch")?;
+        if resp.status() == StatusCode::NOT_FOUND {
+            let body = resp.text().unwrap_or_default();
+            let auth_hint = if req.token.is_some() {
+                if req.account_email.is_none() {
+                    " Check Jira permissions or configure account_email for API-token auth."
+                } else {
+                    " Check Jira permissions for this issue."
+                }
+            } else {
+                " Jira often returns 404 for unauthorized issues. Set --token, JIRA_TOKEN, or [instances.<alias>].token."
+            };
+            return Err(AppError::not_found(format!(
+                "Jira issue '{}' was not found or is not accessible.{} Response: {}",
+                id_or_key,
+                auth_hint,
+                body_snippet(&body)
+            ))
+            .with_provider("jira")
+            .with_http_status(StatusCode::NOT_FOUND)
+            .into());
+        }
+        let issue: JiraIssueItem = Self::parse_jira_json(
+            resp,
+            req.token.as_deref(),
+            req.account_email.as_deref(),
+            "issue fetch",
+        )?;
+        let comments = if req.include_comments {
+            self.fetch_comments(&issue.key, req)?
+        } else {
+            vec![]
+        };
+        Ok(Conversation {
+            id: issue.key,
+            title: issue.fields.summary,
+            state: issue.fields.status.name,
+            body: issue
+                .fields
+                .description
+                .as_ref()
+                .map(extract_adf_text)
+                .filter(|s| !s.is_empty()),
+            comments,
+        })
+    }
+
+    pub(super) fn fetch_comments(
+        &self,
+        issue_key: &str,
+        req: &FetchRequest,
+    ) -> Result<Vec<Comment>> {
+        let mut start_at = 0u32;
+        let per_page = Self::bounded_per_page(req.per_page);
+        let mut out = vec![];
+
+        loop {
+            let url = format!("{}/rest/api/3/issue/{issue_key}/comment", self.base_url);
+            debug!(issue_key, start_at, per_page, "fetching Jira comment page");
+            let http = Self::apply_auth(
+                self.client.get(&url),
+                req.token.as_deref(),
+                req.account_email.as_deref(),
+            )
+            .query(&[
+                ("startAt", start_at.to_string()),
+                ("maxResults", per_page.to_string()),
+            ]);
+            let resp = Self::send(http, "comment fetch")?;
+            let page: JiraCommentsPage = Self::parse_jira_json(
+                resp,
+                req.token.as_deref(),
+                req.account_email.as_deref(),
+                "comment fetch",
+            )?;
+            trace!(
+                count = page.comments.len(),
+                start_at = page.start_at,
+                "decoded Jira comments page"
+            );
+
+            for c in page.comments {
+                let body = extract_adf_text(&c.body);
+                out.push(Comment {
+                    author: c.author.map(|a| a.display_name),
+                    created_at: c.created,
+                    body: if body.is_empty() { None } else { Some(body) },
+                    kind: Some("issue_comment".into()),
+                    review_path: None,
+                    review_line: None,
+                    review_side: None,
+                });
+            }
+
+            let next = page.start_at + page.max_results;
+            if next >= page.total {
+                break;
+            }
+            start_at = next;
+        }
+
+        Ok(out)
+    }
+
+    pub(super) fn parse_jira_json<T: for<'de> Deserialize<'de>>(
+        resp: Response,
+        token: Option<&str>,
+        account_email: Option<&str>,
+        operation: &str,
+    ) -> Result<T> {
+        let status = resp.status();
+        let content_type = resp
+            .headers()
+            .get(CONTENT_TYPE)
+            .and_then(|v| v.to_str().ok())
+            .unwrap_or("")
+            .to_string();
+        let body = resp.text()?;
+
+        if !status.is_success() {
+            let auth_hint = if status == StatusCode::UNAUTHORIZED || status == StatusCode::FORBIDDEN
+            {
+                if token.is_some() {
+                    if account_email.is_some() {
+                        " Jira auth failed. Check token format/scope (email:api_token for Atlassian Cloud)."
+                    } else {
+                        " Jira auth failed. If this is an Atlassian API token, also set account email (--account-email, JIRA_ACCOUNT_EMAIL, or [instances.<alias>].account_email), or pass --token as email:api_token."
+                    }
+                } else {
+                    " No Jira token detected. Set --token, JIRA_TOKEN, or [instances.<alias>].token."
+                }
+            } else {
+                ""
+            };
+            let mut err =
+                AppError::from_http("Jira", operation, status, &body).with_provider("jira");
+            if !auth_hint.is_empty() {
+                err = err.with_hint(auth_hint.trim());
+            }
+            return Err(err.into());
+        }
+
+        if !content_type.contains("application/json") {
+            return Err(AppError::provider(format!(
+                "Jira API {} returned non-JSON content-type '{}' (body starts with: {}). This often means an auth/login page.",
+                operation,
+                content_type,
+                body_snippet(&body)
+            ))
+            .with_provider("jira")
+            .with_http_status(status)
+            .into());
+        }
+
+        serde_json::from_str(&body).map_err(|e| {
+            app_error_from_decode(
+                "Jira",
+                operation,
+                format!("{e} (body starts with: {})", body_snippet(&body)),
+            )
+            .into()
+        })
+    }
+}
+
+fn body_snippet(body: &str) -> String {
+    body.chars()
+        .take(200)
+        .collect::<String>()
+        .replace('\n', " ")
+}

package/src/source/jira/mod.rs

@@ -0,0 +1,161 @@
+use anyhow::Result;
+use reqwest::blocking::Client;
+use tracing::{debug, trace};
+
+use super::{ContentKind, FetchRequest, FetchTarget, Source};
+use crate::error::AppError;
+use crate::model::Conversation;
+
+mod api;
+mod model;
+mod query;
+
+use model::{JiraSearchResponse, extract_adf_text};
+use query::{build_jql, parse_jira_query};
+
+pub(super) const JIRA_DEFAULT_BASE_URL: &str = "https://jira.atlassian.com";
+pub(super) const PAGE_SIZE: u32 = 100;
+
+pub struct JiraSource {
+    client: Client,
+    base_url: String,
+}
+
+impl JiraSource {
+    /// Create a Jira source client.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the HTTP client cannot be constructed.
+    pub fn new(base_url: Option<String>) -> Result<Self> {
+        let client = Client::builder()
+            .user_agent(concat!("99problems-cli/", env!("CARGO_PKG_VERSION")))
+            .build()?;
+        let base_url = base_url
+            .unwrap_or_else(|| JIRA_DEFAULT_BASE_URL.to_string())
+            .trim_end_matches('/')
+            .to_string();
+        Ok(Self { client, base_url })
+    }
+
+    fn search_stream(
+        &self,
+        req: &FetchRequest,
+        raw_query: &str,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        let filters = parse_jira_query(raw_query);
+        if matches!(filters.kind, ContentKind::Pr) {
+            return Err(AppError::usage(
+                "Platform 'jira' does not support pull requests. Use --type issue.",
+            )
+            .into());
+        }
+        let jql = build_jql(&filters)?;
+        let per_page = Self::bounded_per_page(req.per_page);
+        let mut start_at = 0u32;
+        let mut next_page_token: Option<String> = None;
+        let mut emitted = 0usize;
+
+        loop {
+            let url = format!("{}/rest/api/3/search/jql", self.base_url);
+            debug!(
+                start_at,
+                per_page,
+                has_next_page_token = next_page_token.is_some(),
+                "fetching Jira search page"
+            );
+            let mut query_params: Vec<(String, String)> = vec![
+                ("jql".into(), jql.clone()),
+                ("maxResults".into(), per_page.to_string()),
+                ("fields".into(), "summary,description,status".into()),
+            ];
+            if let Some(token) = &next_page_token {
+                query_params.push(("nextPageToken".into(), token.clone()));
+            } else {
+                query_params.push(("startAt".into(), start_at.to_string()));
+            }
+
+            let http = Self::apply_auth(
+                self.client.get(&url),
+                req.token.as_deref(),
+                req.account_email.as_deref(),
+            )
+            .query(&query_params);
+            let resp = Self::send(http, "search")?;
+            let page: JiraSearchResponse = Self::parse_jira_json(
+                resp,
+                req.token.as_deref(),
+                req.account_email.as_deref(),
+                "search",
+            )?;
+            trace!(count = page.issues.len(), "decoded Jira search page");
+            for issue in page.issues {
+                let comments = if req.include_comments {
+                    self.fetch_comments(&issue.key, req)?
+                } else {
+                    vec![]
+                };
+                emit(Conversation {
+                    id: issue.key,
+                    title: issue.fields.summary,
+                    state: issue.fields.status.name,
+                    body: issue
+                        .fields
+                        .description
+                        .as_ref()
+                        .map(extract_adf_text)
+                        .filter(|s| !s.is_empty()),
+                    comments,
+                })?;
+                emitted += 1;
+            }
+
+            if let Some(token) = page.next_page_token {
+                next_page_token = Some(token);
+                continue;
+            }
+            if let (Some(s), Some(m), Some(t)) = (page.start_at, page.max_results, page.total) {
+                let next = s + m;
+                if next < t {
+                    start_at = next;
+                    next_page_token = None;
+                    continue;
+                }
+                break;
+            }
+            if page.is_last == Some(false) {
+                return Err(AppError::provider(
+                    "Jira API search response indicated more pages but provided no pagination cursor.",
+                )
+                .with_provider("jira")
+                .into());
+            }
+            break;
+        }
+
+        Ok(emitted)
+    }
+}
+
+impl Source for JiraSource {
+    fn fetch_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 { id, kind, .. } => {
+                if matches!(kind, ContentKind::Pr) {
+                    return Err(AppError::usage(
+                        "Platform 'jira' does not support pull requests. Use --type issue.",
+                    )
+                    .into());
+                }
+                emit(self.fetch_issue(id, req)?)?;
+                Ok(1)
+            }
+        }
+    }
+}

package/src/source/jira/model.rs

@@ -0,0 +1,99 @@
+use serde::Deserialize;
+use serde_json::Value;
+
+#[derive(Deserialize)]
+pub(super) struct JiraSearchResponse {
+    #[serde(rename = "startAt")]
+    pub(super) start_at: Option<u32>,
+    #[serde(rename = "maxResults")]
+    pub(super) max_results: Option<u32>,
+    pub(super) total: Option<u32>,
+    #[serde(rename = "isLast")]
+    pub(super) is_last: Option<bool>,
+    #[serde(rename = "nextPageToken")]
+    pub(super) next_page_token: Option<String>,
+    pub(super) issues: Vec<JiraIssueItem>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct JiraIssueItem {
+    pub(super) key: String,
+    pub(super) fields: JiraIssueFields,
+}
+
+#[derive(Deserialize)]
+pub(super) struct JiraIssueFields {
+    pub(super) summary: String,
+    pub(super) description: Option<Value>,
+    pub(super) status: JiraStatus,
+}
+
+#[derive(Deserialize)]
+pub(super) struct JiraStatus {
+    pub(super) name: String,
+}
+
+#[derive(Deserialize)]
+pub(super) struct JiraCommentsPage {
+    #[serde(rename = "startAt")]
+    pub(super) start_at: u32,
+    #[serde(rename = "maxResults")]
+    pub(super) max_results: u32,
+    pub(super) total: u32,
+    pub(super) comments: Vec<JiraCommentItem>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct JiraCommentItem {
+    pub(super) author: Option<JiraAuthor>,
+    pub(super) created: String,
+    pub(super) body: Value,
+}
+
+#[derive(Deserialize)]
+pub(super) struct JiraAuthor {
+    #[serde(rename = "displayName")]
+    pub(super) display_name: String,
+}
+
+pub(super) fn extract_adf_text(value: &Value) -> String {
+    fn walk(v: &Value, out: &mut Vec<String>) {
+        match v {
+            Value::Object(map) => {
+                if let Some(Value::String(text)) = map.get("text") {
+                    out.push(text.clone());
+                }
+                if let Some(content) = map.get("content") {
+                    walk(content, out);
+                }
+            }
+            Value::Array(items) => {
+                for item in items {
+                    walk(item, out);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    let mut chunks = Vec::new();
+    walk(value, &mut chunks);
+    chunks.join(" ").trim().to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn extract_adf_text_reads_nested_nodes() {
+        let value: Value = serde_json::json!({
+            "type": "doc",
+            "content": [
+                {"type": "paragraph", "content": [{"type": "text", "text": "Hello"}]},
+                {"type": "paragraph", "content": [{"type": "text", "text": "world"}]}
+            ]
+        });
+        assert_eq!(extract_adf_text(&value), "Hello world");
+    }
+}