TDD: fix non-deterministic markdown output, empty-string dedup, and escaped backslash parsing

- format.rs: use BTreeMap instead of HashMap for file grouping to ensure
  deterministic file section ordering in markdown output
- multi_pass.rs: return similarity 1.0 when both comment texts are empty
  (identical empty strings were incorrectly treated as dissimilar)
- function_chunker.rs: properly track escaped state for backslash handling
  in string literals (escaped backslash "\\" was leaving in_string=true)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: haasonsaas

src/core/function_chunker.rs

@@ -257,9 +257,13 @@ fn find_function_end(lines: &[&str], start: usize, language: &str) -> usize {
             let mut found_open = false;
             for (i, line) in lines.iter().enumerate().skip(start) {
                 let mut in_string = false;
-                let mut prev_char = '\0';
+                let mut escaped = false;
                 for ch in line.chars() {
-                    if ch == '"' && prev_char != '\\' {
+                    if escaped {
+                        escaped = false;
+                    } else if in_string && ch == '\\' {
+                        escaped = true;
+                    } else if ch == '"' {
                         in_string = !in_string;
                     } else if !in_string {
                         if ch == '{' {
@@ -269,7 +273,6 @@ fn find_function_end(lines: &[&str], start: usize, language: &str) -> usize {
                             depth -= 1;
                         }
                     }
-                    prev_char = ch;
                 }
                 if found_open && depth <= 0 {
                     return i;
@@ -837,4 +840,17 @@ fn next_func() {
         // Line 12: matches "valid" (1-20). Should NOT panic even if "broken" passes filter.
         assert!(result.is_some());
     }
+
+    #[test]
+    fn test_find_function_end_escaped_backslash_in_string() {
+        // A string containing "\\" (escaped backslash) on the same line as braces.
+        // The closing quote after "\\" terminates the string, so the closing brace
+        // on the same line should be counted.
+        let lines: Vec<&str> = vec![
+            r#"function foo() { let s = "\\"; }"#,  // line 0: open+close on same line
+            "function next() {",                      // line 1: next function
+        ];
+        let end = find_function_end(&lines, 0, "js");
+        assert_eq!(end, 0, "Function should end at line 0 (braces balanced on same line with escaped backslash)");
+    }
 }

src/core/multi_pass.rs

@@ -312,6 +312,9 @@ fn content_similarity(a: &str, b: &str) -> f32 {
     let words_a: std::collections::HashSet<&str> = a.split_whitespace().collect();
     let words_b: std::collections::HashSet<&str> = b.split_whitespace().collect();
 
+    if words_a.is_empty() && words_b.is_empty() {
+        return 1.0;
+    }
     if words_a.is_empty() || words_b.is_empty() {
         return 0.0;
     }
@@ -528,7 +531,7 @@ mod tests {
     fn test_content_similarity() {
         assert!(content_similarity("the cat sat on mat", "the cat sat on mat") > 0.99);
         assert!(content_similarity("the cat sat", "completely different words") < 0.2);
-        assert!(content_similarity("", "") < 0.01);
+        assert!(content_similarity("", "") > 0.99); // identical empty strings
         assert!(content_similarity("hello", "") < 0.01);
     }
 
@@ -614,13 +617,12 @@ mod tests {
     }
 
     #[test]
-    fn test_merge_empty_comments() {
+    fn test_merge_keeps_nonempty_different_comments() {
         let review = MultiPassReview::with_defaults();
-        let existing = vec![make_comment("test.rs", 1, "")];
-        let deep = vec![make_comment("test.rs", 1, "")];
-        // Empty comments have similarity 0.0, so both should be kept
+        let existing = vec![make_comment("test.rs", 1, "first issue")];
+        let deep = vec![make_comment("test.rs", 1, "completely different issue")];
         let merged = review.merge_results(existing, deep);
-        assert_eq!(merged.len(), 2);
+        assert_eq!(merged.len(), 2, "Different comments should both be kept");
     }
 
     #[test]
@@ -745,4 +747,22 @@ mod tests {
         assert!((config.hotspot_threshold - 0.5).abs() < 0.01);
         assert_eq!(config.max_deep_files, 5);
     }
+
+    #[test]
+    fn test_content_similarity_both_empty() {
+        // Two empty strings are identical — similarity should be 1.0, not 0.0
+        assert_eq!(content_similarity("", ""), 1.0);
+        assert_eq!(content_similarity("   ", "   "), 1.0);
+        assert_eq!(content_similarity("  \n\t  ", ""), 1.0);
+    }
+
+    #[test]
+    fn test_merge_deduplicates_empty_comments() {
+        let review = MultiPassReview::with_defaults();
+        let existing = vec![make_comment("test.rs", 1, "")];
+        let deep = vec![make_comment("test.rs", 1, "")];
+        // Two identical empty comments at the same location should be deduped
+        let merged = review.merge_results(existing, deep);
+        assert_eq!(merged.len(), 1, "Empty duplicate comments should be deduped");
+    }
 }

src/output/format.rs

@@ -155,7 +155,7 @@ pub fn format_as_markdown(comments: &[core::Comment], rule_priority: &[String])
     output.push_str("---\n\n## Detailed Issues\n\n");
 
     // Group comments by file
-    let mut comments_by_file = std::collections::HashMap::new();
+    let mut comments_by_file = std::collections::BTreeMap::new();
     for comment in comments {
         comments_by_file
             .entry(&comment.file_path)
@@ -841,4 +841,50 @@ mod tests {
         assert!(output.contains("Critical Issues"));
         assert!(output.contains("Fix bugs"));
     }
+
+    #[test]
+    fn format_markdown_file_sections_are_deterministic() {
+        // Comments across multiple files should produce deterministic file section ordering
+        let mut c1 = build_test_comment(
+            "c1",
+            core::comment::Category::Bug,
+            core::comment::Severity::Error,
+            0.9,
+        );
+        c1.file_path = PathBuf::from("src/z_last.rs");
+
+        let mut c2 = build_test_comment(
+            "c2",
+            core::comment::Category::Bug,
+            core::comment::Severity::Warning,
+            0.8,
+        );
+        c2.file_path = PathBuf::from("src/a_first.rs");
+
+        let mut c3 = build_test_comment(
+            "c3",
+            core::comment::Category::Security,
+            core::comment::Severity::Info,
+            0.7,
+        );
+        c3.file_path = PathBuf::from("src/m_middle.rs");
+
+        let comments = vec![c1, c2, c3];
+        let output = format_as_markdown(&comments, &[]);
+
+        // Run multiple times — should always produce the same output
+        for _ in 0..5 {
+            let output2 = format_as_markdown(&comments, &[]);
+            assert_eq!(output, output2, "Markdown output should be deterministic across runs");
+        }
+
+        // File sections should appear in sorted order
+        let z_pos = output.find("src/z_last.rs").expect("should contain z_last.rs");
+        let a_pos = output.find("src/a_first.rs").expect("should contain a_first.rs");
+        let m_pos = output.find("src/m_middle.rs").expect("should contain m_middle.rs");
+        assert!(
+            a_pos < m_pos && m_pos < z_pos,
+            "Files should appear in sorted order: a_first({a_pos}) < m_middle({m_pos}) < z_last({z_pos})"
+        );
+    }
 }