Add diff metadata and prompt truncation limits

Author: haasonsaas

.diffscope.yml.example

@@ -5,6 +5,8 @@
 model: gpt-4o
 temperature: 0.2
 max_tokens: 4000
+max_context_chars: 20000  # 0 disables context truncation
+max_diff_chars: 40000     # 0 disables diff truncation
 
 # API configuration (optional - can use environment variables)
 # api_key: your-api-key-here

README.md

@@ -190,6 +190,10 @@ 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
 system_prompt: "Focus on security vulnerabilities, performance issues, and best practices"
 openai_use_responses: true  # Use OpenAI Responses API (recommended) instead of chat completions
 
@@ -421,8 +425,8 @@ exclude_patterns:
   - "**/*.generated.*"
 
 # Review configuration
-max_diff_size: 10000
-context_lines: 3
+max_context_chars: 20000
+max_diff_chars: 40000
 ```
 
 ### Integration with Other CI Tools

src/config.rs

@@ -14,6 +14,12 @@ pub struct Config {
     #[serde(default = "default_max_tokens")]
     pub max_tokens: usize,
 
+    #[serde(default = "default_max_context_chars")]
+    pub max_context_chars: usize,
+
+    #[serde(default = "default_max_diff_chars")]
+    pub max_diff_chars: usize,
+
     pub system_prompt: Option<String>,
     pub api_key: Option<String>,
     pub base_url: Option<String>,
@@ -78,6 +84,8 @@ impl Default for Config {
             model: default_model(),
             temperature: default_temperature(),
             max_tokens: default_max_tokens(),
+            max_context_chars: default_max_context_chars(),
+            max_diff_chars: default_max_diff_chars(),
             system_prompt: None,
             api_key: None,
             base_url: None,
@@ -230,6 +238,14 @@ fn default_max_tokens() -> usize {
     4000
 }
 
+fn default_max_context_chars() -> usize {
+    20000
+}
+
+fn default_max_diff_chars() -> usize {
+    40000
+}
+
 fn default_true() -> bool {
     true
 }

src/core/diff_parser.rs

@@ -10,6 +10,8 @@ pub struct UnifiedDiff {
     pub new_content: Option<String>,
     pub hunks: Vec<DiffHunk>,
     pub is_binary: bool,
+    pub is_deleted: bool,
+    pub is_new: bool,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -179,6 +181,8 @@ impl DiffParser {
             new_content: Some(new_content.to_string()),
             hunks,
             is_binary: false,
+            is_deleted: false,
+            is_new: false,
         })
     }
 
@@ -188,13 +192,36 @@ impl DiffParser {
         *i += 1;
 
         let mut is_binary = false;
+        let mut is_deleted = false;
+        let mut is_new = false;
         while *i < lines.len()
             && !lines[*i].starts_with("@@")
             && !lines[*i].starts_with("diff --git")
         {
-            if lines[*i].starts_with("Binary files") || lines[*i].starts_with("GIT binary patch") {
+            let line = lines[*i];
+            if line.starts_with("Binary files") || line.starts_with("GIT binary patch") {
                 is_binary = true;
             }
+            if line.starts_with("deleted file mode") {
+                is_deleted = true;
+            }
+            if line.starts_with("new file mode") {
+                is_new = true;
+            }
+            if line.starts_with("--- ") {
+                if let Ok(path) = Self::extract_path_from_header(line, "--- ") {
+                    if path == "/dev/null" {
+                        is_new = true;
+                    }
+                }
+            }
+            if line.starts_with("+++ ") {
+                if let Ok(path) = Self::extract_path_from_header(line, "+++ ") {
+                    if path == "/dev/null" {
+                        is_deleted = true;
+                    }
+                }
+            }
             *i += 1;
         }
 
@@ -211,6 +238,8 @@ impl DiffParser {
             new_content: None,
             hunks,
             is_binary,
+            is_deleted,
+            is_new,
         })
     }
 
@@ -221,6 +250,8 @@ impl DiffParser {
         let old_path = Self::extract_path_from_header(old_line, "--- ")?;
         let new_path = Self::extract_path_from_header(new_line, "+++ ")?;
 
+        let is_new = old_path == "/dev/null";
+        let is_deleted = new_path == "/dev/null";
         let file_path = if new_path != "/dev/null" {
             new_path
         } else {
@@ -255,6 +286,8 @@ impl DiffParser {
             new_content: None,
             hunks,
             is_binary,
+            is_deleted,
+            is_new,
         })
     }
 
@@ -473,4 +506,38 @@ index 83db48f..f735c20 100644\n\
         assert_eq!(diffs.len(), 1);
         assert_eq!(diffs[0].hunks.len(), 1);
     }
+
+    #[test]
+    fn test_parse_deleted_file() {
+        let diff_text = "\
+diff --git a/foo.txt b/foo.txt\n\
+deleted file mode 100644\n\
+index 83db48f..0000000\n\
+--- a/foo.txt\n\
++++ /dev/null\n\
+@@ -1,1 +0,0 @@\n\
+-hello\n";
+
+        let diffs = DiffParser::parse_unified_diff(diff_text).unwrap();
+        assert_eq!(diffs.len(), 1);
+        assert!(diffs[0].is_deleted);
+        assert!(!diffs[0].is_new);
+    }
+
+    #[test]
+    fn test_parse_new_file() {
+        let diff_text = "\
+diff --git a/foo.txt b/foo.txt\n\
+new file mode 100644\n\
+index 0000000..f735c20\n\
+--- /dev/null\n\
++++ b/foo.txt\n\
+@@ -0,0 +1,1 @@\n\
++hello\n";
+
+        let diffs = DiffParser::parse_unified_diff(diff_text).unwrap();
+        assert_eq!(diffs.len(), 1);
+        assert!(diffs[0].is_new);
+        assert!(!diffs[0].is_deleted);
+    }
 }

src/core/prompt.rs

@@ -9,6 +9,7 @@ pub struct PromptConfig {
     pub max_tokens: usize,
     pub include_context: bool,
     pub max_context_chars: usize,
+    pub max_diff_chars: usize,
 }
 
 impl Default for PromptConfig {
@@ -52,6 +53,7 @@ Line 28: Performance - O(n²) algorithm for large dataset. Will be slow with man
             max_tokens: 2000,
             include_context: true,
             max_context_chars: 20000,
+            max_diff_chars: 40000,
         }
     }
 }
@@ -88,21 +90,40 @@ impl PromptBuilder {
 
     fn format_diff(&self, diff: &UnifiedDiff) -> Result<String> {
         let mut output = String::new();
+        let mut truncated = false;
         output.push_str(&format!("File: {}\n", diff.file_path.display()));
 
-        for hunk in &diff.hunks {
-            output.push_str(&format!("{}\n", hunk.context));
+        'hunks: for hunk in &diff.hunks {
+            let header = format!("{}\n", hunk.context);
+            if self.config.max_diff_chars > 0
+                && output.len().saturating_add(header.len()) > self.config.max_diff_chars
+            {
+                truncated = true;
+                break;
+            }
+            output.push_str(&header);
 
             for change in &hunk.changes {
                 let prefix = match change.change_type {
                     crate::core::diff_parser::ChangeType::Added => "+",
                     crate::core::diff_parser::ChangeType::Removed => "-",
                     crate::core::diff_parser::ChangeType::Context => " ",
                 };
-                output.push_str(&format!("{}{}\n", prefix, change.content));
+                let line = format!("{}{}\n", prefix, change.content);
+                if self.config.max_diff_chars > 0
+                    && output.len().saturating_add(line.len()) > self.config.max_diff_chars
+                {
+                    truncated = true;
+                    break 'hunks;
+                }
+                output.push_str(&line);
             }
         }
 
+        if truncated {
+            output.push_str("[Diff truncated]\n");
+        }
+
         Ok(output)
     }
 

src/core/smart_review_prompt.rs

@@ -7,9 +7,16 @@ impl SmartReviewPromptBuilder {
     pub fn build_enhanced_review_prompt(
         diff: &UnifiedDiff,
         context_chunks: &[LLMContextChunk],
+        max_context_chars: usize,
+        max_diff_chars: usize,
     ) -> Result<(String, String)> {
         let system_prompt = Self::build_smart_review_system_prompt();
-        let user_prompt = Self::build_smart_review_user_prompt(diff, context_chunks)?;
+        let user_prompt = Self::build_smart_review_user_prompt(
+            diff,
+            context_chunks,
+            max_context_chars,
+            max_diff_chars,
+        )?;
 
         Ok((system_prompt, user_prompt))
     }
@@ -72,10 +79,13 @@ TAGS: [comma-separated relevant tags]
     fn build_smart_review_user_prompt(
         diff: &UnifiedDiff,
         context_chunks: &[LLMContextChunk],
+        max_context_chars: usize,
+        max_diff_chars: usize,
     ) -> Result<String> {
         let mut prompt = String::new();
         let mut context_chars = 0usize;
-        const MAX_CONTEXT_CHARS: usize = 20000;
+        let mut diff_chars = 0usize;
+        let mut diff_truncated = false;
 
         prompt.push_str(&format!(
             "Please review the following code changes in file: {}\n\n",
@@ -104,7 +114,9 @@ TAGS: [comma-separated relevant tags]
                         .collect::<Vec<_>>()
                         .join("\n")
                 );
-                if context_chars.saturating_add(block.len()) > MAX_CONTEXT_CHARS {
+                if max_context_chars > 0
+                    && context_chars.saturating_add(block.len()) > max_context_chars
+                {
                     prompt.push_str("[Context truncated]\n\n");
                     break;
                 }
@@ -117,15 +129,26 @@ TAGS: [comma-separated relevant tags]
 
         // Format the diff with line numbers and change indicators
         for hunk in &diff.hunks {
-            prompt.push_str(&format!(
+            let hunk_header = format!(
                 "### Hunk: Lines {}-{} (was {}-{})\n\n",
                 hunk.new_start,
                 hunk.new_start + hunk.new_lines,
                 hunk.old_start,
                 hunk.old_start + hunk.old_lines
-            ));
+            );
+            if max_diff_chars > 0 && diff_chars.saturating_add(hunk_header.len()) > max_diff_chars {
+                diff_truncated = true;
+                break;
+            }
+            prompt.push_str(&hunk_header);
+            diff_chars = diff_chars.saturating_add(hunk_header.len());
 
+            if max_diff_chars > 0 && diff_chars.saturating_add("```diff\n".len()) > max_diff_chars {
+                diff_truncated = true;
+                break;
+            }
             prompt.push_str("```diff\n");
+            diff_chars = diff_chars.saturating_add("```diff\n".len());
             let mut line_num = hunk.new_start;
 
             for line in &hunk.changes {
@@ -135,7 +158,14 @@ TAGS: [comma-separated relevant tags]
                     crate::core::diff_parser::ChangeType::Context => " ",
                 };
 
-                prompt.push_str(&format!("{}{:4} {}\n", prefix, line_num, line.content));
+                let rendered = format!("{}{:4} {}\n", prefix, line_num, line.content);
+                if max_diff_chars > 0 && diff_chars.saturating_add(rendered.len()) > max_diff_chars
+                {
+                    diff_truncated = true;
+                    break;
+                }
+                prompt.push_str(&rendered);
+                diff_chars = diff_chars.saturating_add(rendered.len());
 
                 if !matches!(
                     line.change_type,
@@ -146,6 +176,15 @@ TAGS: [comma-separated relevant tags]
             }
 
             prompt.push_str("```\n\n");
+            diff_chars = diff_chars.saturating_add("```\n\n".len());
+
+            if diff_truncated {
+                break;
+            }
+        }
+
+        if diff_truncated {
+            prompt.push_str("[Diff truncated]\n\n");
         }
 
         prompt.push_str("## Review Instructions\n\n");