feat: add miette diagnostic error reporting

Replace console::style error formatting in main.rs with miette's rich
diagnostics. All error variants now carry diagnostic codes and help
text guiding users to resolution steps.

Author: Sephyi

src/error.rs

@@ -2,47 +2,80 @@
 //
 // SPDX-License-Identifier: GPL-3.0-only
 
+// miette's Diagnostic derive generates code that triggers this false positive
+#![allow(unused_assignments)]
+
+use miette::Diagnostic;
 use thiserror::Error;
 
-#[derive(Error, Debug)]
+#[derive(Error, Diagnostic, Debug)]
 pub enum Error {
-    #[error("No staged changes found. Use `git add` to stage files.")]
+    #[error("No staged changes found")]
+    #[diagnostic(code(commitbee::git::no_staged), help("Stage files with: git add <files>"))]
     NoStagedChanges,
 
-    #[error("Not a git repository. Run from a git project directory.")]
+    #[error("Not a git repository")]
+    #[diagnostic(
+        code(commitbee::git::not_repo),
+        help("Run this command inside a git repository")
+    )]
     NotAGitRepo,
 
-    #[error("Merge conflicts detected. Resolve conflicts before committing.")]
+    #[error("Merge conflicts detected")]
+    #[diagnostic(
+        code(commitbee::git::conflicts),
+        help("Resolve conflicts before committing")
+    )]
     MergeConflicts,
 
-    #[error("Merge in progress. Complete or abort the merge first.")]
+    #[error("Merge in progress")]
+    #[diagnostic(
+        code(commitbee::git::merge),
+        help("Complete or abort the merge: git merge --abort")
+    )]
     MergeInProgress,
 
-    #[error("Operation cancelled by user.")]
+    #[error("Operation cancelled by user")]
     Cancelled,
 
-    #[error("Potential secrets detected: {patterns:?}. Use --allow-secrets to proceed.")]
+    #[error("Potential secrets detected: {patterns:?}")]
+    #[diagnostic(
+        code(commitbee::safety::secrets),
+        help("Use --allow-secrets with local Ollama only")
+    )]
     SecretsDetected { patterns: Vec<String> },
 
-    #[error("Cannot connect to Ollama at {host}. Is it running?")]
+    #[error("Cannot connect to Ollama at {host}")]
+    #[diagnostic(
+        code(commitbee::ollama::not_running),
+        help("Start Ollama with: ollama serve")
+    )]
     OllamaNotRunning { host: String },
 
     #[error("Model '{model}' not found. Available: {}", available.join(", "))]
+    #[diagnostic(
+        code(commitbee::ollama::model_not_found),
+        help("Pull the model with: ollama pull {model}")
+    )]
     ModelNotFound {
         model: String,
         available: Vec<String>,
     },
 
     #[error("Provider '{provider}' error: {message}")]
+    #[diagnostic(code(commitbee::provider::error))]
     Provider { provider: String, message: String },
 
     #[error("Invalid commit message: {0}")]
+    #[diagnostic(code(commitbee::commit::invalid))]
     InvalidCommitMessage(String),
 
     #[error("Configuration error: {0}")]
+    #[diagnostic(code(commitbee::config::error))]
     Config(String),
 
     #[error("Git error: {0}")]
+    #[diagnostic(code(commitbee::git::error))]
     Git(String),
 
     #[error(transparent)]

src/main.rs

@@ -3,7 +3,6 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use clap::Parser;
-use console::style;
 
 mod app;
 mod cli;
@@ -17,24 +16,34 @@ use cli::Cli;
 
 #[tokio::main]
 async fn main() {
+    miette::set_hook(Box::new(|_| {
+        Box::new(
+            miette::MietteHandlerOpts::new()
+                .terminal_links(true)
+                .context_lines(2)
+                .build(),
+        )
+    }))
+    .ok();
+
     let cli = Cli::parse();
 
     let mut app = match App::new(cli) {
         Ok(app) => app,
         Err(e) => {
-            eprintln!("{} {}", style("error:").red().bold(), e);
+            eprintln!("{:?}", miette::Report::new(e));
             std::process::exit(1);
         }
     };
 
     if let Err(e) = app.run().await {
         match e {
             error::Error::Cancelled => {
-                eprintln!("{}", style("Aborted.").dim());
+                eprintln!("Aborted.");
                 std::process::exit(0);
             }
             _ => {
-                eprintln!("{} {}", style("error:").red().bold(), e);
+                eprintln!("{:?}", miette::Report::new(e));
                 std::process::exit(1);
             }
         }