Add review guidance profiles and confidence filtering

Author: haasonsaas

.diffscope.yml.example

@@ -7,6 +7,10 @@ temperature: 0.2
 max_tokens: 4000
 max_context_chars: 20000  # 0 disables context truncation
 max_diff_chars: 40000     # 0 disables diff truncation
+min_confidence: 0.0       # Drop comments below this confidence (0.0-1.0)
+review_profile: balanced  # balanced | chill | assertive
+review_instructions: |
+  Prioritize security and correctness issues. Avoid stylistic comments unless they impact maintainability.
 
 # API configuration (optional - can use environment variables)
 # api_key: your-api-key-here
@@ -30,6 +34,8 @@ paths:
       - security
       - validation
       - authentication
+    review_instructions: |
+      Treat auth and input validation as critical. Flag missing rate limits and unsafe defaults.
     severity_overrides:
       security: error  # Elevate all security issues to errors
     system_prompt: |

README.md

@@ -190,10 +190,12 @@ Create a `.diffscope.yml` file in your repository:
 model: gpt-4o
 temperature: 0.2
 max_tokens: 4000
-max_context_chars: 20000
-max_diff_chars: 40000
 max_context_chars: 20000  # 0 disables context truncation
 max_diff_chars: 40000     # 0 disables diff truncation
+min_confidence: 0.0       # Drop comments below this confidence (0.0-1.0)
+review_profile: balanced  # balanced | chill | assertive
+review_instructions: |
+  Prioritize security and correctness issues. Avoid stylistic comments unless they impact maintainability.
 system_prompt: "Focus on security vulnerabilities, performance issues, and best practices"
 openai_use_responses: true  # Use OpenAI Responses API (recommended) instead of chat completions
 
@@ -403,6 +405,8 @@ For a large Python/FastAPI application at a company like Acme Inc:
 model: "claude-3-5-sonnet-20241022"
 temperature: 0.1  # Low for consistent reviews
 max_tokens: 4000
+min_confidence: 0.2
+review_profile: assertive
 
 system_prompt: |
   You are reviewing Python code for a production FastAPI application.
@@ -560,6 +564,8 @@ paths:
       - "**/*.generated.*"
     extra_context:
       - "src/auth/**"
+    review_instructions: |
+      Prioritize auth, validation, and sensitive data handling.
     system_prompt: |
       Focus on SQL injection, auth bypass, and input validation
     severity_overrides:

src/config.rs

@@ -20,6 +20,15 @@ pub struct Config {
     #[serde(default = "default_max_diff_chars")]
     pub max_diff_chars: usize,
 
+    #[serde(default = "default_min_confidence")]
+    pub min_confidence: f32,
+
+    #[serde(default)]
+    pub review_profile: Option<String>,
+
+    #[serde(default)]
+    pub review_instructions: Option<String>,
+
     pub system_prompt: Option<String>,
     pub api_key: Option<String>,
     pub base_url: Option<String>,
@@ -50,6 +59,8 @@ pub struct PathConfig {
 
     pub system_prompt: Option<String>,
 
+    pub review_instructions: Option<String>,
+
     #[serde(default)]
     pub severity_overrides: HashMap<String, String>,
 }
@@ -73,6 +84,7 @@ impl Default for PathConfig {
             ignore_patterns: Vec::new(),
             extra_context: Vec::new(),
             system_prompt: None,
+            review_instructions: None,
             severity_overrides: HashMap::new(),
         }
     }
@@ -86,6 +98,9 @@ impl Default for Config {
             max_tokens: default_max_tokens(),
             max_context_chars: default_max_context_chars(),
             max_diff_chars: default_max_diff_chars(),
+            min_confidence: default_min_confidence(),
+            review_profile: None,
+            review_instructions: None,
             system_prompt: None,
             api_key: None,
             base_url: None,
@@ -150,6 +165,29 @@ impl Config {
         if self.max_tokens == 0 {
             self.max_tokens = default_max_tokens();
         }
+
+        if !self.min_confidence.is_finite() {
+            self.min_confidence = default_min_confidence();
+        } else if !(0.0..=1.0).contains(&self.min_confidence) {
+            self.min_confidence = self.min_confidence.clamp(0.0, 1.0);
+        }
+
+        if let Some(profile) = &self.review_profile {
+            let normalized = profile.trim().to_lowercase();
+            self.review_profile = if normalized.is_empty() {
+                None
+            } else if matches!(normalized.as_str(), "balanced" | "chill" | "assertive") {
+                Some(normalized)
+            } else {
+                None
+            };
+        }
+
+        if let Some(instructions) = &self.review_instructions {
+            if instructions.trim().is_empty() {
+                self.review_instructions = None;
+            }
+        }
     }
 
     pub fn get_path_config(&self, file_path: &PathBuf) -> Option<&PathConfig> {
@@ -217,12 +255,16 @@ mod tests {
         config.model = "   ".to_string();
         config.temperature = 5.0;
         config.max_tokens = 0;
+        config.min_confidence = 2.0;
+        config.review_profile = Some("ASSERTIVE".to_string());
 
         config.normalize();
 
         assert_eq!(config.model, default_model());
         assert_eq!(config.temperature, default_temperature());
         assert_eq!(config.max_tokens, default_max_tokens());
+        assert_eq!(config.min_confidence, 1.0);
+        assert_eq!(config.review_profile.as_deref(), Some("assertive"));
     }
 }
 
@@ -246,6 +288,10 @@ fn default_max_diff_chars() -> usize {
     40000
 }
 
+fn default_min_confidence() -> f32 {
+    0.0
+}
+
 fn default_true() -> bool {
     true
 }

src/core/smart_review_prompt.rs

@@ -9,8 +9,16 @@ impl SmartReviewPromptBuilder {
         context_chunks: &[LLMContextChunk],
         max_context_chars: usize,
         max_diff_chars: usize,
+        system_prompt_suffix: Option<&str>,
     ) -> Result<(String, String)> {
-        let system_prompt = Self::build_smart_review_system_prompt();
+        let mut system_prompt = Self::build_smart_review_system_prompt();
+        if let Some(suffix) = system_prompt_suffix {
+            let trimmed = suffix.trim();
+            if !trimmed.is_empty() {
+                system_prompt.push_str("\n\n");
+                system_prompt.push_str(trimmed);
+            }
+        }
         let user_prompt = Self::build_smart_review_user_prompt(
             diff,
             context_chunks,

src/main.rs

@@ -346,6 +346,11 @@ async fn review_command(
             }
         }
 
+        if let Some(guidance) = build_review_guidance(&config, path_config) {
+            local_prompt_config.system_prompt.push_str("\n\n");
+            local_prompt_config.system_prompt.push_str(&guidance);
+        }
+
         let local_prompt_builder = core::PromptBuilder::new(local_prompt_config);
         let (system_prompt, user_prompt) =
             local_prompt_builder.build_prompt(&diff, &context_chunks)?;
@@ -389,6 +394,7 @@ async fn review_command(
     let processed_comments = plugin_manager
         .run_post_processors(all_comments, &repo_path_str)
         .await?;
+    let processed_comments = apply_confidence_threshold(processed_comments, config.min_confidence);
 
     let effective_format = if patch { OutputFormat::Patch } else { format };
     output_comments(&processed_comments, output_path, effective_format).await?;
@@ -866,6 +872,10 @@ async fn review_diff_content_raw(
                 local_prompt_config.system_prompt = prompt.clone();
             }
         }
+        if let Some(guidance) = build_review_guidance(&config, path_config) {
+            local_prompt_config.system_prompt.push_str("\n\n");
+            local_prompt_config.system_prompt.push_str(&guidance);
+        }
         let local_prompt_builder = core::PromptBuilder::new(local_prompt_config);
         let (system_prompt, user_prompt) =
             local_prompt_builder.build_prompt(&diff, &context_chunks)?;
@@ -910,6 +920,7 @@ async fn review_diff_content_raw(
     let processed_comments = plugin_manager
         .run_post_processors(all_comments, &repo_path_str)
         .await?;
+    let processed_comments = apply_confidence_threshold(processed_comments, config.min_confidence);
 
     Ok(processed_comments)
 }
@@ -1292,12 +1303,14 @@ async fn smart_review_command(
             context_chunks.extend(definition_chunks);
         }
 
+        let guidance = build_review_guidance(&config, path_config);
         let (system_prompt, user_prompt) =
             core::SmartReviewPromptBuilder::build_enhanced_review_prompt(
                 &diff,
                 &context_chunks,
                 config.max_context_chars,
                 config.max_diff_chars,
+                guidance.as_deref(),
             )?;
 
         let request = adapters::llm::LLMRequest {
@@ -1340,6 +1353,7 @@ async fn smart_review_command(
     let processed_comments = plugin_manager
         .run_post_processors(all_comments, &repo_path_str)
         .await?;
+    let processed_comments = apply_confidence_threshold(processed_comments, config.min_confidence);
 
     // Generate summary and output results
     let summary = core::CommentSynthesizer::generate_summary(&processed_comments);
@@ -1825,6 +1839,81 @@ fn filter_comments_for_diff(
     filtered
 }
 
+fn build_review_guidance(
+    config: &config::Config,
+    path_config: Option<&config::PathConfig>,
+) -> Option<String> {
+    let mut sections = Vec::new();
+
+    if let Some(profile) = config.review_profile.as_deref() {
+        let guidance = match profile {
+            "chill" => Some(
+                "Be conservative and only surface high-confidence, high-impact issues. Avoid nitpicks and redundant comments.",
+            ),
+            "assertive" => Some(
+                "Be thorough and proactive. Surface edge cases, latent risks, and maintainability concerns even if they are subtle.",
+            ),
+            _ => None,
+        };
+        if let Some(text) = guidance {
+            sections.push(format!("Review profile ({}): {}", profile, text));
+        }
+    }
+
+    if let Some(instructions) = config.review_instructions.as_deref() {
+        let trimmed = instructions.trim();
+        if !trimmed.is_empty() {
+            sections.push(format!("Global review instructions:\n{}", trimmed));
+        }
+    }
+
+    if let Some(pc) = path_config {
+        if let Some(instructions) = pc.review_instructions.as_deref() {
+            let trimmed = instructions.trim();
+            if !trimmed.is_empty() {
+                sections.push(format!("Path-specific instructions:\n{}", trimmed));
+            }
+        }
+    }
+
+    if sections.is_empty() {
+        None
+    } else {
+        Some(format!(
+            "Additional review guidance:\n{}",
+            sections.join("\n\n")
+        ))
+    }
+}
+
+fn apply_confidence_threshold(
+    comments: Vec<core::Comment>,
+    min_confidence: f32,
+) -> Vec<core::Comment> {
+    if min_confidence <= 0.0 {
+        return comments;
+    }
+
+    let total = comments.len();
+    let mut kept = Vec::with_capacity(total);
+
+    for comment in comments {
+        if comment.confidence >= min_confidence {
+            kept.push(comment);
+        }
+    }
+
+    if kept.len() != total {
+        let dropped = total.saturating_sub(kept.len());
+        info!(
+            "Dropped {} comment(s) below confidence threshold {}",
+            dropped, min_confidence
+        );
+    }
+
+    kept
+}
+
 fn is_line_in_diff(diff: &core::UnifiedDiff, line_number: usize) -> bool {
     if line_number == 0 {
         return false;