fix: improve search/replace matching with fuzzy fallbacks

- Try exact match → whitespace-normalized → stripped
- Pipeline now fetches files for ALL processed findings, not just top 5
- Increase file content limit from 4000→6000 chars in prompt
- Better debug logging for search text mismatches

Author: tang-vu

contribai/generator/engine.py

@@ -166,7 +166,7 @@ def _build_generation_prompt(self, finding: Finding, context: RepoContext) -> st
         if current_content:
             prompt += (
                 f"\n## Current File Content ({finding.file_path})\n"
-                f"```\n{current_content[:4000]}\n```\n"
+                f"```\n{current_content[:6000]}\n```\n"
             )
 
         prompt += "\n## Output Format\nReturn your changes as a JSON object.\n\n"
@@ -256,35 +256,84 @@ def _parse_changes(self, response: str, context: RepoContext) -> list[FileChange
                     # Search/replace mode — apply edits to original content
                     original = context.relevant_files.get(path, "")
                     if not original:
-                        logger.warning("No original content for %s, skipping edits", path)
+                        logger.warning(
+                            "No original content for %s (finding file not fetched), skipping edits",
+                            path,
+                        )
                         continue
 
                     new_content = original
                     edits_applied = 0
+                    edits_total = len(item["edits"])
                     for edit in item["edits"]:
                         search = edit.get("search", "")
                         replace = edit.get("replace", "")
                         if not search:
                             continue
+
+                        matched = False
+
+                        # Try 1: Exact match
                         if search in new_content:
                             new_content = new_content.replace(search, replace, 1)
+                            matched = True
+
+                        # Try 2: Normalize trailing whitespace per line
+                        if not matched:
+                            norm_search = "\n".join(line.rstrip() for line in search.split("\n"))
+                            norm_content = "\n".join(
+                                line.rstrip() for line in new_content.split("\n")
+                            )
+                            if norm_search in norm_content:
+                                # Find position in normalized, apply to original
+                                idx = norm_content.index(norm_search)
+                                # Map back: count newlines to find line range
+                                start_line = norm_content[:idx].count("\n")
+                                end_line = start_line + norm_search.count("\n")
+                                lines = new_content.split("\n")
+                                lines[start_line : end_line + 1] = replace.split("\n")
+                                new_content = "\n".join(lines)
+                                matched = True
+                                logger.debug(
+                                    "Fuzzy match (whitespace normalized) for %s",
+                                    path,
+                                )
+
+                        # Try 3: Strip all leading/trailing whitespace
+                        if not matched:
+                            stripped_search = search.strip()
+                            if len(stripped_search) > 20 and stripped_search in new_content:
+                                new_content = new_content.replace(
+                                    stripped_search, replace.strip(), 1
+                                )
+                                matched = True
+                                logger.debug(
+                                    "Fuzzy match (stripped) for %s",
+                                    path,
+                                )
+
+                        if matched:
                             edits_applied += 1
                         else:
                             logger.warning(
-                                "Search text not found in %s: %s...",
+                                "Search text not found in %s (tried exact + fuzzy). "
+                                "Search[:%d]: %.80s...",
                                 path,
-                                search[:60],
+                                len(search),
+                                search.replace("\n", "\\n"),
                             )
 
-                    if edits_applied == 0:
-                        logger.warning("No edits applied to %s", path)
-                        continue
-
                     logger.info(
-                        "Applied %d search/replace edits to %s",
-                        edits_applied,
+                        "Edits for %s: %d/%d applied",
                         path,
+                        edits_applied,
+                        edits_total,
                     )
+
+                    if edits_applied == 0:
+                        logger.warning("No edits applied to %s, skipping file", path)
+                        continue
+
                     changes.append(
                         FileChange(
                             path=path,

contribai/orchestrator/pipeline.py

@@ -291,18 +291,27 @@ async def _process_repo(
             analysis.analysis_duration_sec,
         )
 
-        # Build context for generation
+        # Build context for generation — fetch files for ALL findings we'll process
         file_tree = await self._github.get_file_tree(repo.owner, repo.name)
         relevant_files: dict[str, str] = {}
-        for finding in analysis.top_findings[:5]:
+        # Deduplicate file paths across all findings we'll process
+        file_paths_to_fetch = []
+        for finding in analysis.top_findings[:max_prs]:
             if finding.file_path and finding.file_path not in relevant_files:
-                try:
-                    content = await self._github.get_file_content(
-                        repo.owner, repo.name, finding.file_path
-                    )
-                    relevant_files[finding.file_path] = content
-                except Exception:
-                    pass
+                file_paths_to_fetch.append(finding.file_path)
+
+        for fpath in file_paths_to_fetch:
+            try:
+                content = await self._github.get_file_content(repo.owner, repo.name, fpath)
+                relevant_files[fpath] = content
+            except Exception:
+                logger.debug("Could not fetch %s", fpath)
+
+        logger.info(
+            "Fetched %d/%d unique files for code gen",
+            len(relevant_files),
+            len(file_paths_to_fetch),
+        )
 
         from contribai.core.models import RepoContext