Unify Benchify resilience and batched str_replace refactors; simplify validation and streaming integration

Consolidates recent improvements to Benchify post-processing and batched str_replace execution. Reworks validateBenchifyResponse to use structural pattern match with clear business logic checks (no nested matches/continues), simplifies stream-parser integration, and expands tests for reliability.

🤖 Generated with Codebuff
Co-Authored-By: Codebuff <noreply@codebuff.com>

Author: brandonkachen

backend/src/__tests__/process-str-replace.test.ts

@@ -1,7 +1,13 @@
-import { describe, expect, it } from 'bun:test'
+import * as envModule from '@codebuff/internal/env'
+import { describe, expect, it, spyOn } from 'bun:test'
 import { applyPatch } from 'diff'
 
 import { processStrReplace } from '../process-str-replace'
+import { mockFileContext } from './test-utils'
+import {
+  executeBatchStrReplaces,
+  benchifyCanFixLanguage,
+} from '../tools/batch-str-replace'
 
 describe('processStrReplace', () => {
   it('should replace exact string matches', async () => {
@@ -213,6 +219,25 @@ describe('processStrReplace', () => {
     }
   })
 
+  it('should handle replacement where old string equals new string', async () => {
+    const initialContent = 'const x = 1;\nconst y = 2;\n'
+    const oldStr = 'const y = 2;'
+    const newStr = 'const y = 2;' // Same as old string
+
+    const result = await processStrReplace(
+      'test.ts',
+      [{ old: oldStr, new: newStr, allowMultiple: false }],
+      Promise.resolve(initialContent),
+    )
+
+    expect(result).not.toBeNull()
+    expect('content' in result).toBe(true)
+    if ('content' in result) {
+      expect(result.content).toBe('const x = 1;\nconst y = 2;\n')
+      expect(result.messages).toEqual([])
+    }
+  })
+
   // New comprehensive tests for allowMultiple functionality
   describe('allowMultiple functionality', () => {
     it('should error when multiple occurrences exist and allowMultiple is false', async () => {
@@ -417,3 +442,142 @@ function test3() {
     )
   })
 })
+
+// Tests for Benchify resilience
+describe('Benchify resilience', () => {
+  describe('happy path', () => {
+    it('should identify Benchify-supported file types correctly', () => {
+      const testCases = [
+        { path: 'component.tsx', expected: true },
+        { path: 'utils.ts', expected: true },
+        { path: 'script.js', expected: true },
+        { path: 'styles.jsx', expected: true },
+        { path: 'README.md', expected: false },
+        { path: 'config.json', expected: false },
+        { path: 'styles.css', expected: false },
+        { path: 'index.html', expected: false },
+        { path: 'test.py', expected: false },
+      ]
+
+      for (const { path, expected } of testCases) {
+        const result = benchifyCanFixLanguage(path)
+        expect(result).toBe(expected)
+      }
+    })
+
+    it('should handle file extensions case sensitivity', () => {
+      expect(benchifyCanFixLanguage('Component.TSX')).toBe(false) // Wrong case
+      expect(benchifyCanFixLanguage('component.tsx')).toBe(true) // Correct case
+      expect(benchifyCanFixLanguage('utils.TS')).toBe(false) // Wrong case
+      expect(benchifyCanFixLanguage('utils.ts')).toBe(true) // Correct case
+    })
+
+    it('should handle file paths with multiple dots', () => {
+      expect(benchifyCanFixLanguage('component.test.tsx')).toBe(true)
+      expect(benchifyCanFixLanguage('utils.spec.ts')).toBe(true)
+      expect(benchifyCanFixLanguage('config.local.js')).toBe(true)
+      expect(benchifyCanFixLanguage('styles.module.css')).toBe(false)
+    })
+
+    it('should handle files without extensions', () => {
+      expect(benchifyCanFixLanguage('Dockerfile')).toBe(false)
+      expect(benchifyCanFixLanguage('Makefile')).toBe(false)
+      expect(benchifyCanFixLanguage('README')).toBe(false)
+    })
+  })
+
+  it('should fall back gracefully when Benchify is disabled', async () => {
+    // Test with no API key - spy on the env object directly
+    spyOn(envModule, 'env', 'get').mockReturnValue({
+      // Empty object simulates no BENCHIFY_API_KEY
+    } as any)
+
+    const result = await executeBatchStrReplaces({
+      deferredStrReplaces: [
+        {
+          toolCall: {
+            toolName: 'str_replace' as const,
+            toolCallId: 'test-call',
+            input: {
+              path: 'test.ts',
+              replacements: [{ old: 'old', new: 'new', allowMultiple: false }],
+            },
+          },
+        },
+      ],
+      toolCalls: [],
+      toolResults: [],
+      ws: {} as any,
+      fileContext: mockFileContext,
+      agentStepId: 'test-step',
+      clientSessionId: 'test-session',
+      userInputId: 'test-input',
+      onResponseChunk: () => {},
+      state: { messages: [] },
+      userId: 'test-user',
+    })
+
+    // Should complete without error even when Benchify is unavailable
+    expect(result).toBeUndefined() // Function returns void
+  })
+
+  describe('Batch str_replace integration tests', () => {
+    it('should handle empty deferred list without error', async () => {
+      // Simple test that doesn't require complex mocking
+      expect(
+        executeBatchStrReplaces({
+          deferredStrReplaces: [],
+          toolCalls: [],
+          toolResults: [],
+          ws: {} as any,
+          fileContext: mockFileContext,
+          agentStepId: 'test-step',
+          clientSessionId: 'test-session',
+          userInputId: 'test-input',
+          onResponseChunk: () => {},
+          state: { messages: [] },
+          userId: 'test-user',
+        }),
+      ).resolves.toBeUndefined() // Should complete without throwing
+    })
+  })
+
+  it('should identify Benchify-supported file types correctly', () => {
+    const testCases = [
+      { path: 'component.tsx', expected: true },
+      { path: 'utils.ts', expected: true },
+      { path: 'script.js', expected: true },
+      { path: 'styles.jsx', expected: true },
+      { path: 'README.md', expected: false },
+      { path: 'config.json', expected: false },
+      { path: 'styles.css', expected: false },
+      { path: 'index.html', expected: false },
+      { path: 'test.py', expected: false },
+    ]
+
+    for (const { path, expected } of testCases) {
+      const result = benchifyCanFixLanguage(path)
+      expect(result).toBe(expected)
+    }
+  })
+
+  it('should handle executeBatchStrReplaces with empty list', async () => {
+    // Simple test that doesn't require complex mocking
+    const result = await executeBatchStrReplaces({
+      deferredStrReplaces: [],
+      toolCalls: [],
+      toolResults: [],
+      ws: {} as any,
+      fileContext: mockFileContext,
+      agentStepId: 'test-step',
+      clientSessionId: 'test-session',
+      userInputId: 'test-input',
+      onResponseChunk: () => {},
+      state: { messages: [] },
+      userId: 'test-user',
+    })
+
+    // Should complete without throwing an error
+    expect(result).toBeUndefined() // Function returns void
+  })
+})

backend/src/process-str-replace.ts

@@ -35,6 +35,7 @@ export async function processStrReplace(
   let currentContent = initialContent
   let messages: string[] = []
   const lineEnding = currentContent.includes('\r\n') ? '\r\n' : '\n'
+  let anyReplacementSuccessful = false
 
   for (const { old: oldStr, new: newStr, allowMultiple } of replacements) {
     // Regular case: require oldStr for replacements
@@ -59,6 +60,7 @@ export async function processStrReplace(
 
     if (match.success) {
       updatedOldStr = match.oldStr
+      anyReplacementSuccessful = true
     } else {
       messages.push(match.error)
       updatedOldStr = null
@@ -72,15 +74,15 @@ export async function processStrReplace(
 
   currentContent = currentContent.replaceAll('\n', lineEnding)
 
-  if (initialContent === currentContent) {
+  // If no successful replacements occurred, return error
+  if (!anyReplacementSuccessful) {
     logger.debug(
       {
         path,
         initialContent,
       },
-      `processStrReplace: No change to ${path}`,
+      `processStrReplace: No successful replacements for ${path}`,
     )
-    messages.push('No change to the file.')
     return {
       tool: 'str_replace' as const,
       path,