@mbe24/99problems 0.2.0 → 0.3.0

package/src/error.rs

@@ -0,0 +1,254 @@
+use reqwest::StatusCode;
+use serde_json::json;
+use std::fmt::{Display, Formatter};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ErrorCategory {
+    Usage,
+    Auth,
+    NotFound,
+    RateLimited,
+    Network,
+    Provider,
+    Internal,
+}
+
+impl ErrorCategory {
+    #[must_use]
+    pub fn code(self) -> &'static str {
+        match self {
+            Self::Usage => "usage",
+            Self::Auth => "auth",
+            Self::NotFound => "not_found",
+            Self::RateLimited => "rate_limited",
+            Self::Network => "network",
+            Self::Provider => "provider",
+            Self::Internal => "internal",
+        }
+    }
+
+    #[must_use]
+    pub fn exit_code(self) -> i32 {
+        match self {
+            Self::Usage => 2,
+            Self::Auth => 3,
+            Self::NotFound => 4,
+            Self::RateLimited => 5,
+            Self::Network => 6,
+            Self::Provider => 7,
+            Self::Internal => 1,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct AppError {
+    category: ErrorCategory,
+    message: String,
+    hint: Option<String>,
+    provider: Option<String>,
+    http_status: Option<u16>,
+}
+
+impl AppError {
+    #[must_use]
+    pub fn usage(message: impl Into<String>) -> Self {
+        Self::new(ErrorCategory::Usage, message)
+    }
+
+    #[must_use]
+    pub fn auth(message: impl Into<String>) -> Self {
+        Self::new(ErrorCategory::Auth, message)
+    }
+
+    #[must_use]
+    pub fn not_found(message: impl Into<String>) -> Self {
+        Self::new(ErrorCategory::NotFound, message)
+    }
+
+    #[must_use]
+    pub fn rate_limited(message: impl Into<String>) -> Self {
+        Self::new(ErrorCategory::RateLimited, message)
+    }
+
+    #[must_use]
+    pub fn network(message: impl Into<String>) -> Self {
+        Self::new(ErrorCategory::Network, message)
+    }
+
+    #[must_use]
+    pub fn provider(message: impl Into<String>) -> Self {
+        Self::new(ErrorCategory::Provider, message)
+    }
+
+    #[must_use]
+    pub fn internal(message: impl Into<String>) -> Self {
+        Self::new(ErrorCategory::Internal, message)
+    }
+
+    #[must_use]
+    pub fn from_http(provider: &str, operation: &str, status: StatusCode, body: &str) -> Self {
+        let mut err = match status.as_u16() {
+            401 | 403 => Self::auth(format!(
+                "{provider} API {operation} error {status}: {}",
+                body_snippet(body)
+            )),
+            404 => Self::not_found(format!(
+                "{provider} API {operation} error {status}: {}",
+                body_snippet(body)
+            )),
+            429 => Self::rate_limited(format!(
+                "{provider} API {operation} error {status}: {}",
+                body_snippet(body)
+            )),
+            _ => Self::provider(format!(
+                "{provider} API {operation} error {status}: {}",
+                body_snippet(body)
+            )),
+        };
+        err.provider = Some(provider.to_string());
+        err.http_status = Some(status.as_u16());
+        err
+    }
+
+    #[must_use]
+    pub fn with_hint(mut self, hint: impl Into<String>) -> Self {
+        self.hint = Some(hint.into());
+        self
+    }
+
+    #[must_use]
+    pub fn with_provider(mut self, provider: impl Into<String>) -> Self {
+        self.provider = Some(provider.into());
+        self
+    }
+
+    #[must_use]
+    pub fn with_http_status(mut self, status: StatusCode) -> Self {
+        self.http_status = Some(status.as_u16());
+        self
+    }
+
+    #[must_use]
+    pub fn exit_code(&self) -> i32 {
+        self.category.exit_code()
+    }
+
+    #[must_use]
+    pub fn render_text(&self) -> String {
+        match &self.hint {
+            Some(hint) => format!("{}\nHint: {hint}", self.message),
+            None => self.message.clone(),
+        }
+    }
+
+    #[must_use]
+    pub fn render_json(&self) -> String {
+        json!({
+            "code": self.category.code(),
+            "exit_code": self.exit_code(),
+            "message": self.message,
+            "hint": self.hint,
+            "provider": self.provider,
+            "http_status": self.http_status,
+        })
+        .to_string()
+    }
+
+    #[must_use]
+    pub fn category(&self) -> ErrorCategory {
+        self.category
+    }
+
+    fn new(category: ErrorCategory, message: impl Into<String>) -> Self {
+        Self {
+            category,
+            message: message.into(),
+            hint: None,
+            provider: None,
+            http_status: None,
+        }
+    }
+}
+
+impl Display for AppError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for AppError {}
+
+#[must_use]
+pub fn classify_anyhow_error(err: &anyhow::Error) -> AppError {
+    if let Some(app_err) = err.downcast_ref::<AppError>() {
+        return app_err.clone();
+    }
+
+    if let Some(req_err) = err.downcast_ref::<reqwest::Error>() {
+        if req_err.is_timeout() || req_err.is_connect() {
+            return AppError::network(format!("Network request failed: {req_err}"));
+        }
+        return AppError::provider(format!("Remote request failed: {req_err}"));
+    }
+
+    if let Some(io_err) = err.downcast_ref::<std::io::Error>() {
+        return AppError::internal(format!("I/O error: {io_err}"));
+    }
+
+    AppError::internal(err.to_string())
+}
+
+#[must_use]
+pub fn app_error_from_reqwest(provider: &str, operation: &str, err: &reqwest::Error) -> AppError {
+    if err.is_timeout() || err.is_connect() {
+        return AppError::network(format!("{provider} {operation} request failed: {err}"))
+            .with_provider(provider);
+    }
+    AppError::provider(format!("{provider} {operation} request failed: {err}"))
+        .with_provider(provider)
+}
+
+#[must_use]
+pub fn app_error_from_decode(provider: &str, operation: &str, err: impl Display) -> AppError {
+    AppError::provider(format!(
+        "{provider} {operation} response decode failed: {err}"
+    ))
+    .with_provider(provider)
+}
+
+fn body_snippet(body: &str) -> String {
+    body.chars()
+        .take(200)
+        .collect::<String>()
+        .replace('\n', " ")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn exit_code_mapping_is_stable() {
+        assert_eq!(ErrorCategory::Usage.exit_code(), 2);
+        assert_eq!(ErrorCategory::Auth.exit_code(), 3);
+        assert_eq!(ErrorCategory::NotFound.exit_code(), 4);
+        assert_eq!(ErrorCategory::RateLimited.exit_code(), 5);
+        assert_eq!(ErrorCategory::Network.exit_code(), 6);
+        assert_eq!(ErrorCategory::Provider.exit_code(), 7);
+        assert_eq!(ErrorCategory::Internal.exit_code(), 1);
+    }
+
+    #[test]
+    fn json_renderer_includes_required_fields() {
+        let rendered = AppError::auth("invalid token")
+            .with_provider("github")
+            .with_http_status(StatusCode::UNAUTHORIZED)
+            .render_json();
+        let value: serde_json::Value = serde_json::from_str(&rendered).unwrap();
+        assert_eq!(value["code"], "auth");
+        assert_eq!(value["exit_code"], 3);
+        assert_eq!(value["provider"], "github");
+        assert_eq!(value["http_status"], 401);
+    }
+}

package/src/format/json.rs

@@ -1,12 +1,43 @@
-use super::Formatter;
+use super::StreamFormatter;
 use crate::model::Conversation;
 use anyhow::Result;
+use std::io::Write;
 
-pub struct JsonFormatter;
+#[derive(Default)]
+pub struct JsonStreamFormatter {
+    wrote_item: bool,
+}
 
-impl Formatter for JsonFormatter {
-    fn format(&self, conversations: &[Conversation]) -> Result<String> {
-        Ok(serde_json::to_string_pretty(conversations)?)
+impl JsonStreamFormatter {
+    #[must_use]
+    pub fn new() -> Self {
+        Self { wrote_item: false }
+    }
+}
+
+impl StreamFormatter for JsonStreamFormatter {
+    fn begin(&mut self, out: &mut dyn Write) -> Result<()> {
+        out.write_all(b"[\n")?;
+        Ok(())
+    }
+
+    fn write_item(&mut self, out: &mut dyn Write, conversation: &Conversation) -> Result<()> {
+        if self.wrote_item {
+            out.write_all(b",\n")?;
+        }
+        let rendered = serde_json::to_string_pretty(conversation)?;
+        out.write_all(rendered.as_bytes())?;
+        self.wrote_item = true;
+        Ok(())
+    }
+
+    fn finish(&mut self, out: &mut dyn Write) -> Result<()> {
+        if self.wrote_item {
+            out.write_all(b"\n]\n")?;
+        } else {
+            out.write_all(b"]\n")?;
+        }
+        Ok(())
     }
 }
 
@@ -15,9 +46,9 @@ mod tests {
     use super::*;
     use crate::model::Comment;
 
-    fn sample() -> Vec<Conversation> {
-        vec![Conversation {
-            id: 42,
+    fn sample() -> Conversation {
+        Conversation {
+            id: "42".into(),
             title: "Test issue".into(),
             state: "closed".into(),
             body: Some("Body text".into()),
@@ -25,22 +56,32 @@ mod tests {
                 author: Some("user1".into()),
                 created_at: "2024-01-01T00:00:00Z".into(),
                 body: Some("A comment".into()),
+                kind: None,
+                review_path: None,
+                review_line: None,
+                review_side: None,
             }],
-        }]
+        }
     }
 
     #[test]
-    fn formats_valid_json() {
-        let out = JsonFormatter.format(&sample()).unwrap();
-        let parsed: serde_json::Value = serde_json::from_str(&out).unwrap();
-        assert_eq!(parsed[0]["id"], 42);
-        assert_eq!(parsed[0]["title"], "Test issue");
-        assert_eq!(parsed[0]["comments"][0]["author"], "user1");
+    fn formats_valid_json_array() {
+        let mut formatter = JsonStreamFormatter::new();
+        let mut out = Vec::new();
+        formatter.begin(&mut out).unwrap();
+        formatter.write_item(&mut out, &sample()).unwrap();
+        formatter.finish(&mut out).unwrap();
+
+        let parsed: serde_json::Value = serde_json::from_slice(&out).unwrap();
+        assert_eq!(parsed[0]["id"], "42");
     }
 
     #[test]
-    fn empty_slice_produces_empty_array() {
-        let out = JsonFormatter.format(&[]).unwrap();
-        assert_eq!(out.trim(), "[]");
+    fn empty_output_is_empty_array() {
+        let mut formatter = JsonStreamFormatter::new();
+        let mut out = Vec::new();
+        formatter.begin(&mut out).unwrap();
+        formatter.finish(&mut out).unwrap();
+        assert_eq!(String::from_utf8(out).unwrap(), "[\n]\n");
     }
 }

package/src/format/jsonl.rs

@@ -0,0 +1,52 @@
+use super::StreamFormatter;
+use crate::model::Conversation;
+use anyhow::Result;
+use std::io::Write;
+
+pub struct JsonLinesFormatter;
+
+impl StreamFormatter for JsonLinesFormatter {
+    fn begin(&mut self, _out: &mut dyn Write) -> Result<()> {
+        Ok(())
+    }
+
+    fn write_item(&mut self, out: &mut dyn Write, conversation: &Conversation) -> Result<()> {
+        serde_json::to_writer(&mut *out, conversation)?;
+        out.write_all(b"\n")?;
+        Ok(())
+    }
+
+    fn finish(&mut self, _out: &mut dyn Write) -> Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Conversation;
+
+    #[test]
+    fn emits_one_json_object_per_line() {
+        let mut formatter = JsonLinesFormatter;
+        let mut out = Vec::new();
+        formatter.begin(&mut out).unwrap();
+        formatter
+            .write_item(
+                &mut out,
+                &Conversation {
+                    id: "1".into(),
+                    title: "t".into(),
+                    state: "open".into(),
+                    body: None,
+                    comments: vec![],
+                },
+            )
+            .unwrap();
+        formatter.finish(&mut out).unwrap();
+        let text = String::from_utf8(out).unwrap();
+        assert_eq!(text.lines().count(), 1);
+        let parsed: serde_json::Value = serde_json::from_str(text.lines().next().unwrap()).unwrap();
+        assert_eq!(parsed["id"], "1");
+    }
+}

package/src/format/mod.rs

@@ -1,10 +1,32 @@
 use crate::model::Conversation;
 use anyhow::Result;
+use std::io::Write;
 
 pub mod json;
+pub mod jsonl;
+pub mod text;
 pub mod yaml;
 
-/// A pluggable output formatter for conversations.
-pub trait Formatter {
-    fn format(&self, conversations: &[Conversation]) -> Result<String>;
+/// A pluggable streaming formatter for conversations.
+pub trait StreamFormatter {
+    /// Write optional format prefix.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if writing fails.
+    fn begin(&mut self, out: &mut dyn Write) -> Result<()>;
+
+    /// Write one conversation item.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if writing fails.
+    fn write_item(&mut self, out: &mut dyn Write, conversation: &Conversation) -> Result<()>;
+
+    /// Write optional format suffix.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if writing fails.
+    fn finish(&mut self, out: &mut dyn Write) -> Result<()>;
 }

package/src/format/text.rs

@@ -0,0 +1,73 @@
+use super::StreamFormatter;
+use crate::model::{Comment, Conversation};
+use anyhow::Result;
+use std::io::Write;
+
+#[derive(Default)]
+pub struct TextFormatter {
+    index: usize,
+}
+
+impl TextFormatter {
+    #[must_use]
+    pub fn new() -> Self {
+        Self { index: 0 }
+    }
+}
+
+impl StreamFormatter for TextFormatter {
+    fn begin(&mut self, _out: &mut dyn Write) -> Result<()> {
+        Ok(())
+    }
+
+    fn write_item(&mut self, out: &mut dyn Write, conversation: &Conversation) -> Result<()> {
+        self.index += 1;
+        writeln!(out, "Conversation {}", self.index)?;
+        writeln!(out, "id: {}", conversation.id)?;
+        writeln!(out, "title: {}", conversation.title)?;
+        writeln!(out, "state: {}", conversation.state)?;
+        writeln!(
+            out,
+            "body: {}",
+            conversation.body.as_deref().unwrap_or("(none)")
+        )?;
+        writeln!(out, "comments: {}", conversation.comments.len())?;
+        for (idx, comment) in conversation.comments.iter().enumerate() {
+            render_comment(out, idx, comment)?;
+        }
+        writeln!(out, "---")?;
+        Ok(())
+    }
+
+    fn finish(&mut self, _out: &mut dyn Write) -> Result<()> {
+        Ok(())
+    }
+}
+
+fn render_comment(out: &mut dyn Write, index: usize, comment: &Comment) -> Result<()> {
+    writeln!(
+        out,
+        "  [{}] {} {}",
+        index + 1,
+        comment.created_at,
+        comment.author.as_deref().unwrap_or("unknown")
+    )?;
+    if let Some(kind) = comment.kind.as_deref() {
+        writeln!(out, "      kind: {kind}")?;
+    }
+    if let Some(path) = comment.review_path.as_deref() {
+        writeln!(out, "      review_path: {path}")?;
+    }
+    if let Some(line) = comment.review_line {
+        writeln!(out, "      review_line: {line}")?;
+    }
+    if let Some(side) = comment.review_side.as_deref() {
+        writeln!(out, "      review_side: {side}")?;
+    }
+    writeln!(
+        out,
+        "      {}",
+        comment.body.as_deref().unwrap_or("(no body)")
+    )?;
+    Ok(())
+}

package/src/format/yaml.rs

@@ -1,12 +1,49 @@
-use super::Formatter;
+use super::StreamFormatter;
 use crate::model::Conversation;
 use anyhow::Result;
+use std::io::Write;
 
-pub struct YamlFormatter;
+#[derive(Default)]
+pub struct YamlStreamFormatter {
+    wrote_item: bool,
+}
 
-impl Formatter for YamlFormatter {
-    fn format(&self, conversations: &[Conversation]) -> Result<String> {
-        Ok(serde_yaml::to_string(conversations)?)
+impl YamlStreamFormatter {
+    #[must_use]
+    pub fn new() -> Self {
+        Self { wrote_item: false }
+    }
+}
+
+impl StreamFormatter for YamlStreamFormatter {
+    fn begin(&mut self, _out: &mut dyn Write) -> Result<()> {
+        Ok(())
+    }
+
+    fn write_item(&mut self, out: &mut dyn Write, conversation: &Conversation) -> Result<()> {
+        let rendered = serde_yaml::to_string(conversation)?;
+        if self.wrote_item {
+            out.write_all(b"\n")?;
+        }
+        for (idx, line) in rendered.lines().enumerate() {
+            if idx == 0 {
+                out.write_all(b"- ")?;
+                out.write_all(line.as_bytes())?;
+            } else {
+                out.write_all(b"\n  ")?;
+                out.write_all(line.as_bytes())?;
+            }
+        }
+        out.write_all(b"\n")?;
+        self.wrote_item = true;
+        Ok(())
+    }
+
+    fn finish(&mut self, out: &mut dyn Write) -> Result<()> {
+        if !self.wrote_item {
+            out.write_all(b"[]\n")?;
+        }
+        Ok(())
     }
 }
 
@@ -15,9 +52,9 @@ mod tests {
     use super::*;
     use crate::model::Comment;
 
-    fn sample() -> Vec<Conversation> {
-        vec![Conversation {
-            id: 7,
+    fn sample() -> Conversation {
+        Conversation {
+            id: "7".into(),
             title: "YAML issue".into(),
             state: "open".into(),
             body: None,
@@ -25,20 +62,32 @@ mod tests {
                 author: None,
                 created_at: "2024-06-01T12:00:00Z".into(),
                 body: Some("comment".into()),
+                kind: None,
+                review_path: None,
+                review_line: None,
+                review_side: None,
             }],
-        }]
+        }
     }
 
     #[test]
     fn formats_valid_yaml() {
-        let out = YamlFormatter.format(&sample()).unwrap();
-        assert!(out.contains("title: YAML issue"));
-        assert!(out.contains("id: 7"));
+        let mut formatter = YamlStreamFormatter::new();
+        let mut out = Vec::new();
+        formatter.begin(&mut out).unwrap();
+        formatter.write_item(&mut out, &sample()).unwrap();
+        formatter.finish(&mut out).unwrap();
+
+        let parsed: serde_yaml::Value = serde_yaml::from_slice(&out).unwrap();
+        assert_eq!(parsed[0]["title"], "YAML issue");
     }
 
     #[test]
-    fn empty_slice_produces_empty_yaml_list() {
-        let out = YamlFormatter.format(&[]).unwrap();
-        assert_eq!(out.trim(), "[]");
+    fn empty_output_is_empty_yaml_list() {
+        let mut formatter = YamlStreamFormatter::new();
+        let mut out = Vec::new();
+        formatter.begin(&mut out).unwrap();
+        formatter.finish(&mut out).unwrap();
+        assert_eq!(String::from_utf8(out).unwrap(), "[]\n");
     }
 }

package/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod config;
+pub mod error;
 pub mod format;
 pub mod model;
 pub mod source;

package/src/logging.rs

@@ -0,0 +1,54 @@
+use anyhow::{Result, anyhow};
+use tracing_subscriber::filter::LevelFilter;
+use tracing_subscriber::fmt;
+
+/// Initialize structured stderr logging for CLI lifecycle events.
+///
+/// # Errors
+///
+/// Returns an error if the global tracing subscriber was already initialized.
+pub fn init(verbose: u8, quiet: bool) -> Result<()> {
+    let level = level_from_flags(verbose, quiet);
+    fmt()
+        .with_writer(std::io::stderr)
+        .without_time()
+        .with_target(false)
+        .with_max_level(level)
+        .try_init()
+        .map_err(|err| anyhow!("failed to initialize logging: {err}"))?;
+    Ok(())
+}
+
+#[must_use]
+fn level_from_flags(verbose: u8, quiet: bool) -> LevelFilter {
+    if quiet {
+        return LevelFilter::ERROR;
+    }
+
+    match verbose {
+        0 => LevelFilter::WARN,
+        1 => LevelFilter::INFO,
+        2 => LevelFilter::DEBUG,
+        _ => LevelFilter::TRACE,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn verbosity_maps_to_expected_levels() {
+        assert_eq!(level_from_flags(0, false), LevelFilter::WARN);
+        assert_eq!(level_from_flags(1, false), LevelFilter::INFO);
+        assert_eq!(level_from_flags(2, false), LevelFilter::DEBUG);
+        assert_eq!(level_from_flags(3, false), LevelFilter::TRACE);
+        assert_eq!(level_from_flags(7, false), LevelFilter::TRACE);
+    }
+
+    #[test]
+    fn quiet_overrides_verbose() {
+        assert_eq!(level_from_flags(0, true), LevelFilter::ERROR);
+        assert_eq!(level_from_flags(3, true), LevelFilter::ERROR);
+    }
+}