update instructions

Author: christso

instructions.txt

@@ -3,6 +3,7 @@ use fnmatch_regex::glob_to_regex;
 use crate::utils::config_manager::FilterRule;
 use crate::utils::diff_parser::Hunk;
 use crate::filters::csharp_parser::{CSharpParser, CSharpMethod};
+use serde_json;
 
 /// Manages file pattern filters for controlling context lines in git diffs
 pub struct FilterManager {
@@ -295,4 +296,26 @@ impl FilterManager {
         }
         content
     }
+
+    /// Get the include_method_body value from the first filter rule
+    /// 
+    /// Returns None if there are no filter rules
+    pub fn get_include_method_body(&self) -> Option<bool> {
+        if self.filters.is_empty() {
+            return None;
+        }
+        // Return true if any filter has include_method_body set to true
+        let result = self.filters.iter().any(|rule| rule.include_method_body);
+        Some(result)
+    }
+
+    /// Get the filters as a JSON string
+    /// 
+    /// Returns None if there are no filter rules
+    pub fn get_filters_json(&self) -> Option<String> {
+        if self.filters.is_empty() {
+            return None;
+        }
+        serde_json::to_string_pretty(&self.filters).ok()
+    }
 } 

src/filters/filter_manager.rs

@@ -55,7 +55,14 @@ impl RepoDiff {
         // Parse and process the diff
         let patch_dict = DiffParser::parse_unified_diff(&raw_diff)?;
         let processed_dict = self.filter_manager.post_process_files(&patch_dict);
-        let final_output = DiffParser::reconstruct_patch(&processed_dict);
+        
+        // Get filters as JSON if available
+        let filters_json = self.filter_manager.get_filters_json();
+        
+        let final_output = DiffParser::reconstruct_patch(
+            &processed_dict,
+            filters_json.as_deref()
+        );
 
         // Create output directory if it doesn't exist
         if let Some(parent) = Path::new(output_file).parent() {

src/repodiff.rs

@@ -129,19 +129,19 @@ impl DiffParser {
     }
 
     /// Get the instructions for interpreting git diff output
-    fn get_diff_instructions() -> Vec<String> {
-        let instructions = r#"**Instructions for Interpreting Git Diff Output**
-
-This document provides a guide to understanding the diff output generated by RepoDiff.
-
-**Important Note:** The diff output in `repodiff_output.txt` has been sanitized to focus what's relevant for understanding the diffs.
-Real-world Git diff output may contain more details.
+    ///
+    /// # Arguments
+    ///
+    /// * `filters_json` - JSON string containing the file filters configuration
+    pub fn get_diff_instructions(filters_json: Option<&str>) -> Vec<String> {
+        let mut instructions = String::from("This file provides a guide to understanding the diff output generated by RepoDiff, a simplified and context-aware unified diff designed for code reviews.
+RepoDiff processes a single `git diff` output and applies user-defined rules to tailor the content, with special handling for C# files.
 
-**1. Basic Structure:**
+# 1. Basic Structure:
 
 A Git diff file describes the *differences* between two versions of a file. It's structured into *hunks*, which represent contiguous regions of change.
 
-*   `diff --git a/<path> b/<path>`:  Indicates the file being compared. `a/` refers to the "old" version, and `b/` refers to the "new" version. (Note that paths always use forward slashes in Git diff output, even on Windows systems.)
+*   `diff --git a/<path> b/<path>`:  Indicates the file being compared. `a/` refers to the \"old\" version, and `b/` refers to the \"new\" version. (Note that paths always use forward slashes in Git diff output, even on Windows systems.)
 *   `--- a/<path>`:  Marks the beginning of the original file content.
 *   `+++ b/<path>`: Marks the beginning of the modified file content.
 *   `@@ -<start_line_old>,<num_lines_old> +<start_line_new>,<num_lines_new> @@ <section_header>`: This is the *hunk header*. (Optional in simplified output, but common in real diffs).
@@ -153,49 +153,64 @@ A Git diff file describes the *differences* between two versions of a file. It's
     *   `-`: Line removed from the old version.
     *   `+`: Line added to the new version.
 
-**2. Simplified Example:**
+## Simplified Example:
 
-```
+```diff
 diff --git a/MyFile.cs b/MyFile.cs
 --- a/MyFile.cs
 +++ b/MyFile.cs 
  // Some code
- string oldValue = "old";
+ string oldValue = \"old\";
 -// Removed line
-+string newValue = "new";
++string newValue = \"new\";
  // More code
 ```
 
 **Explanation of the Example:**
-
 *   The file being changed is `MyFile.cs`.
-*   `" string oldValue = "old";"`:  This line is present in both versions.
+*   `\" string oldValue = \"old\";\"`:  This line is present in both versions.
 *   `-// Removed line`: This line was removed from the old version.
-*   `+string newValue = "new";`: This line was added to the new version.
-*   `" // More code"`: This line is present in both versions.
+*   `+string newValue = \"new\";`: This line was added to the new version.
+*   `\" // More code\"`: This line is present in both versions.
 
-**3. Key LLM Considerations:**
+# 2. Special Handling in RepoDiff
 
-*   **Focus on Content Lines:** The most important part for understanding changes is the content prefixed with ` `, `-`, or `+`.
-*   **Context is Crucial:** Use the surrounding unchanged lines to understand the *purpose* of the change.
-*   **File Paths:**  Pay attention to the file paths (`a/<path>`, `b/<path>`) to understand which files are being modified.
+RepoDiff customizes the diff output using user-defined filters, with enhanced control for C# files (*.cs).
 
-**4. Application to your File:**
+The following JSON filters are applied to the diff output:
 
-*   **".cs" Files:**  Changes to C# source code.  Focus on the addition (`+`) and removal (`-`) of code lines to understand logic changes.
-*   **"Test*.cs" Files:** Changes to unit test files.  These are often important for understanding how the functionality is being tested and whether the changes are robust.
-*   **".xml" Files:**  Changes to configuration or data files. Look for added, removed, or modified XML elements and attributes. Focus is usually on changes to properties.
+");
+        
+        if let Some(filters) = filters_json {
+            instructions.push_str(filters);
+        }
+        
+        instructions.push_str("
+
+Each filter defines:
 
-**5. Special Instructions for File Types based on the given filters:**
+*   *`file_pattern`*: A glob pattern matching file names (e.g., \"*.cs\" for C# files).
+*   *`context_lines`*: Number of unchanged lines shown before and after each change or hunk.
+*   **For C# files only:**
+    *   *`include_method_body`*: If true, includes the entire body of methods with changes.
+    *   *`include_signatures`*: If true, includes signatures of methods within the context range of changes, with partial or full bodies based on size. It will always include namespace/class declarations enclosing changed methods. The placeholder `⋮----`* is used to omit code inside the hunk that is outside of the context range
 
-* `.cs` code is assumed to not contain test code
-* `*Test*.cs` contain test code, which should be helpful for understanding functionality.
-* `*.xml` contains configuration.
+# 4. Usage Guidelines
+
+*   Focus on Content: Lines with  ` `, `-`, or `+` show the actual changes.
+*   Use Context: Unchanged lines provide purpose and structure.
+*   Interpret Placeholders: `⋮----` signals omitted code; infer its presence simplifies analysis. Consider the context around the placeholder to understand what might have been omitted (e.g., method body, part of a method, etc.).
+*   File Paths: Track `a/<path>` and `b/<path>` to identify modified files.
+*   C# Specifics: Note method bodies and signatures in *.cs files are tailored by filters.
 
 By focusing on these key elements, you can effectively extract meaningful information from Git diff output and summarize the changes made in a software project.
 
----
-"#;
+================================================================
+Diff Output
+================================================================
+
+");
+        
         instructions.lines().map(|s| s.to_string()).collect()
     }
 
@@ -204,12 +219,13 @@ By focusing on these key elements, you can effectively extract meaningful inform
     /// # Arguments
     ///
     /// * `patch_dict` - Dictionary mapping filenames to lists of hunks
-    pub fn reconstruct_patch(patch_dict: &HashMap<String, Vec<Hunk>>) -> String {
+    /// * `filters_json` - JSON string containing the file filters configuration
+    pub fn reconstruct_patch(patch_dict: &HashMap<String, Vec<Hunk>>, filters_json: Option<&str>) -> String {
         let mut output = Vec::new();
 
         // Only add instructions if the patch dictionary is not empty
         if !patch_dict.is_empty() {
-            output.extend(Self::get_diff_instructions());
+            output.extend(Self::get_diff_instructions(filters_json));
         }
 
         for (filename, hunks) in patch_dict {
@@ -250,4 +266,4 @@ By focusing on these key elements, you can effectively extract meaningful inform
 
         output.join("\n")
     }
-} 
+}

src/utils/diff_parser.rs

@@ -133,7 +133,7 @@ rename to new_file.txt
 fn test_reconstruct_patch_empty() {
     // Test reconstructing an empty patch
     let patch_dict = std::collections::HashMap::new();
-    let result = DiffParser::reconstruct_patch(&patch_dict);
+    let result = DiffParser::reconstruct_patch(&patch_dict, None);
     assert_eq!(result, "");
 }
 
@@ -195,4 +195,36 @@ fn test_filter_hunk_context_lines() {
         " line5".to_string(),
         " line6".to_string(),
     ]);
+}
+
+#[test]
+fn test_get_diff_instructions() {
+    // Test case 1: No filters
+    let result = DiffParser::get_diff_instructions(None);
+    let result_str = result.join("\n");
+    assert!(result_str.contains("This file provides a guide to understanding the diff output generated by RepoDiff"));
+
+    // Test case 2: With filters
+    let filters_json = r#"[
+        {
+            "file_pattern": "*.cs",
+            "context_lines": 3,
+            "include_method_body": true,
+            "include_signatures": false
+        },
+        {
+            "file_pattern": "*.xml",
+            "context_lines": 2,
+            "include_method_body": false,
+            "include_signatures": false
+        }
+    ]"#;
+    
+    let result = DiffParser::get_diff_instructions(Some(filters_json));
+    let result_str = result.join("\n");
+    assert!(result_str.contains("The following JSON filters are applied to the diff output:"));
+    assert!(result_str.contains("*.cs"));
+    assert!(result_str.contains("*.xml"));
+    assert!(result_str.contains("include_method_body"));
+    assert!(result_str.contains("include_signatures"));
 }