Improve review config handling and smart parsing

Author: haasonsaas

src/core/comment.rs

@@ -36,15 +36,15 @@ pub struct ReviewSummary {
     pub recommendations: Vec<String>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum Severity {
     Error,
     Warning,
     Info,
     Suggestion,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum Category {
     Bug,
     Security,
@@ -57,7 +57,7 @@ pub enum Category {
     Architecture,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub enum FixEffort {
     Low,    // < 5 minutes
     Medium, // 5-30 minutes
@@ -117,11 +117,27 @@ impl CommentSynthesizer {
     }
 
     fn process_raw_comment(raw: RawComment) -> Result<Option<Comment>> {
-        let severity = Self::determine_severity(&raw.content);
-        let category = Self::determine_category(&raw.content);
-        let confidence = Self::calculate_confidence(&raw.content, &severity, &category);
-        let tags = Self::extract_tags(&raw.content, &category);
-        let fix_effort = Self::determine_fix_effort(&raw.content, &category);
+        let severity = raw
+            .severity
+            .clone()
+            .unwrap_or_else(|| Self::determine_severity(&raw.content));
+        let category = raw
+            .category
+            .clone()
+            .unwrap_or_else(|| Self::determine_category(&raw.content));
+        let confidence = raw.confidence.unwrap_or_else(|| {
+            Self::calculate_confidence(&raw.content, &severity, &category)
+        });
+        let confidence = confidence.max(0.0).min(1.0);
+        let tags = if raw.tags.is_empty() {
+            Self::extract_tags(&raw.content, &category)
+        } else {
+            raw.tags.clone()
+        };
+        let fix_effort = raw
+            .fix_effort
+            .clone()
+            .unwrap_or_else(|| Self::determine_fix_effort(&raw.content, &category));
         let code_suggestion = Self::generate_code_suggestion(&raw);
 
         Ok(Some(Comment {
@@ -357,4 +373,9 @@ pub struct RawComment {
     pub line_number: usize,
     pub content: String,
     pub suggestion: Option<String>,
-}
+    pub severity: Option<Severity>,
+    pub category: Option<Category>,
+    pub confidence: Option<f32>,
+    pub fix_effort: Option<FixEffort>,
+    pub tags: Vec<String>,
+}

src/core/context.rs

@@ -1,5 +1,8 @@
 use anyhow::Result;
+use glob::glob;
 use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
+use std::path::Path;
 use std::path::PathBuf;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -33,9 +36,9 @@ impl ContextFetcher {
         let full_path = self.repo_path.join(file_path);
         if full_path.exists() {
             let content = tokio::fs::read_to_string(&full_path).await?;
+            let file_lines: Vec<&str> = content.lines().collect();
 
             for (start, end) in lines {
-                let file_lines: Vec<&str> = content.lines().collect();
                 let start_idx = start.saturating_sub(1);
                 let end_idx = (*end).min(file_lines.len());
 
@@ -54,6 +57,53 @@ impl ContextFetcher {
         Ok(chunks)
     }
 
+    pub async fn fetch_additional_context(&self, patterns: &[String]) -> Result<Vec<LLMContextChunk>> {
+        let mut chunks = Vec::new();
+        if patterns.is_empty() {
+            return Ok(chunks);
+        }
+
+        let mut matched_paths = HashSet::new();
+        for pattern in patterns {
+            let pattern_path = if Path::new(pattern).is_absolute() {
+                pattern.clone()
+            } else {
+                self.repo_path.join(pattern).to_string_lossy().to_string()
+            };
+
+            if let Ok(entries) = glob(&pattern_path) {
+                for entry in entries {
+                    if let Ok(path) = entry {
+                        if path.is_file() {
+                            matched_paths.insert(path);
+                        }
+                    }
+                }
+            }
+        }
+
+        let max_files = 10usize;
+        let max_lines = 200usize;
+
+        for path in matched_paths.into_iter().take(max_files) {
+            let relative_path = path.strip_prefix(&self.repo_path).unwrap_or(&path);
+            let content = tokio::fs::read_to_string(&path).await?;
+            let snippet = content.lines().take(max_lines).collect::<Vec<_>>().join("\n");
+            if snippet.trim().is_empty() {
+                continue;
+            }
+
+            chunks.push(LLMContextChunk {
+                file_path: relative_path.to_path_buf(),
+                content: snippet,
+                context_type: ContextType::Reference,
+                line_range: None,
+            });
+        }
+
+        Ok(chunks)
+    }
+
     pub async fn fetch_related_definitions(&self, file_path: &PathBuf, symbols: &[String]) -> Result<Vec<LLMContextChunk>> {
         let mut chunks = Vec::new();
 
@@ -98,4 +148,4 @@ impl ContextFetcher {
 
         Ok(chunks)
     }
-}
+}

src/core/git.rs

@@ -1,6 +1,6 @@
 use anyhow::{Context, Result};
-use git2::{Repository, DiffOptions, DiffFormat};
-use std::path::Path;
+use git2::{BranchType, DiffFormat, DiffOptions, Repository};
+use std::path::{Path, PathBuf};
 
 pub struct GitIntegration {
     repo: Repository,
@@ -108,4 +108,27 @@ impl GitIntegration {
 
         Ok(commits)
     }
-}
+
+    pub fn workdir(&self) -> Option<PathBuf> {
+        self.repo.workdir().map(|path| path.to_path_buf())
+    }
+
+    pub fn get_default_branch(&self) -> Result<String> {
+        if let Ok(reference) = self.repo.find_reference("refs/remotes/origin/HEAD") {
+            if let Some(target) = reference.symbolic_target() {
+                if let Some(branch) = target.rsplit('/').next() {
+                    return Ok(branch.to_string());
+                }
+            }
+        }
+
+        if self.repo.find_branch("main", BranchType::Local).is_ok() {
+            return Ok("main".to_string());
+        }
+        if self.repo.find_branch("master", BranchType::Local).is_ok() {
+            return Ok("master".to_string());
+        }
+
+        Ok("main".to_string())
+    }
+}