feat(search_replace): support empty SEARCH block as insert operation

- `parse_blocks` and `apply` now treat empty SEARCH sections as "insert at cursor" operations
- Added insert logic, warnings, and error cases for missing cursor row
- Updates to quick_chat instructions for insert at cursor
- tests for insert/empty SEARCH now included in search_replace_spec

Author: sudo-tee

lua/opencode/quick_chat.lua

@@ -91,7 +91,7 @@ local function process_response(session_info, messages)
     return false
   end
 
-  local success, errors, applied_count = search_replace.apply(session_info.buf, replacements)
+  local success, errors, applied_count = search_replace.apply(session_info.buf, replacements, session_info.row)
 
   -- Provide detailed feedback
   if applied_count > 0 then
@@ -286,8 +286,18 @@ local function generate_search_replace_instructions(context_instance)
     '>>>>>>> REPLACE',
     '```',
     '',
+    '**Insert new code at cursor (empty SEARCH):**',
+    'When the cursor is on an empty line or you need to insert without replacing, use an empty SEARCH section:',
+    '```',
+    '<<<<<<< SEARCH',
+    '=======',
+    'local new_variable = "inserted at cursor"',
+    '>>>>>>> REPLACE',
+    '```',
+    '',
     '# FINAL REMINDER',
     'Output ONLY the SEARCH/REPLACE blocks. The SEARCH section must match the original code exactly.',
+    'Use an empty SEARCH section to insert new code at the cursor position.',
   }
 
   for _, line in ipairs(examples) do

lua/opencode/quick_chat/search_replace.lua

@@ -4,8 +4,9 @@ local M = {}
 --- Supports both raw and code-fenced formats:
 ---   <<<<<<< SEARCH ... ======= ... >>>>>>> REPLACE
 ---   ```\n<<<<<<< SEARCH ... ======= ... >>>>>>> REPLACE\n```
+--- Empty SEARCH sections are valid and indicate "insert at cursor position"
 ---@param response_text string Response text containing SEARCH/REPLACE blocks
----@return table[] replacements Array of {search=string, replace=string, block_number=number}
+---@return table[] replacements Array of {search=string, replace=string, block_number=number, is_insert=boolean}
 ---@return string[] warnings Array of warning messages for malformed blocks
 function M.parse_blocks(response_text)
   local replacements = {}
@@ -48,17 +49,14 @@ function M.parse_blocks(response_text)
         -- Extract replace content (everything between separator and end marker)
         local replace_content = text:sub(replace_start, end_marker_start - 1)
 
-        if search_content:match('^%s*$') then
-          table.insert(warnings, string.format('Block %d: Empty SEARCH section', block_number))
-          pos = end_marker_end + 1
-        else
-          table.insert(replacements, {
-            search = search_content,
-            replace = replace_content,
-            block_number = block_number,
-          })
-          pos = end_marker_end + 1
-        end
+        local is_insert = search_content:match('^%s*$') ~= nil
+        table.insert(replacements, {
+          search = is_insert and '' or search_content,
+          replace = replace_content,
+          block_number = block_number,
+          is_insert = is_insert,
+        })
+        pos = end_marker_end + 1
       end
     end
   end
@@ -67,12 +65,14 @@ function M.parse_blocks(response_text)
 end
 
 --- Applies SEARCH/REPLACE blocks to buffer content using exact matching
+--- Empty SEARCH sections (is_insert=true) will insert at the specified cursor row
 ---@param buf integer Buffer handle
----@param replacements table[] Array of {search=string, replace=string, block_number=number}
+---@param replacements table[] Array of {search=string, replace=string, block_number=number, is_insert=boolean}
+---@param cursor_row? integer Optional cursor row (0-indexed) for insert operations
 ---@return boolean success Whether any replacements were applied
 ---@return string[] errors List of error messages for failed replacements
 ---@return number applied_count Number of successfully applied replacements
-function M.apply(buf, replacements)
+function M.apply(buf, replacements, cursor_row)
   if not vim.api.nvim_buf_is_valid(buf) then
     return false, { 'Buffer is not valid' }, 0
   end
@@ -87,22 +87,39 @@ function M.apply(buf, replacements)
     local search = replacement.search
     local replace = replacement.replace
     local block_num = replacement.block_number or '?'
+    local is_insert = replacement.is_insert
 
-    -- Exact match only
-    local start_pos, end_pos = content:find(search, 1, true)
-
-    if start_pos and end_pos then
-      content = content:sub(1, start_pos - 1) .. replace .. content:sub(end_pos + 1)
-      applied_count = applied_count + 1
+    if is_insert then
+      -- Empty SEARCH: insert at cursor row
+      if not cursor_row then
+        table.insert(errors, string.format('Block %d: Insert operation requires cursor position', block_num))
+      else
+        -- Split replace content into lines and insert at cursor row
+        local replace_lines = vim.split(replace, '\n', { plain = true })
+        vim.api.nvim_buf_set_lines(buf, cursor_row, cursor_row, false, replace_lines)
+        applied_count = applied_count + 1
+        -- Refresh lines and content after direct buffer modification
+        lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
+        content = table.concat(lines, '\n')
+      end
     else
-      local search_preview = search:sub(1, 60):gsub('\n', '\\n')
-      if #search > 60 then
-        search_preview = search_preview .. '...'
+      -- Exact match only
+      local start_pos, end_pos = content:find(search, 1, true)
+
+      if start_pos and end_pos then
+        content = content:sub(1, start_pos - 1) .. replace .. content:sub(end_pos + 1)
+        applied_count = applied_count + 1
+      else
+        local search_preview = search:sub(1, 60):gsub('\n', '\\n')
+        if #search > 60 then
+          search_preview = search_preview .. '...'
+        end
+        table.insert(errors, string.format('Block %d: No exact match for: "%s"', block_num, search_preview))
       end
-      table.insert(errors, string.format('Block %d: No exact match for: "%s"', block_num, search_preview))
     end
   end
 
+  -- Apply remaining content changes (for non-insert replacements)
   if applied_count > 0 then
     local new_lines = vim.split(content, '\n', { plain = true })
     vim.api.nvim_buf_set_lines(buf, 0, -1, false, new_lines)

tests/unit/search_replace_spec.lua

@@ -108,7 +108,25 @@ local x = 2
     assert.matches('Missing end marker', warnings[1])
   end)
 
-  it('warns on empty SEARCH section', function()
+  it('parses empty SEARCH section as insert operation', function()
+    -- Empty search means "insert at cursor position"
+    local input = [[
+<<<<<<< SEARCH
+
+=======
+local x = 2
+>>>>>>> REPLACE
+]]
+    local replacements, warnings = search_replace.parse_blocks(input)
+
+    assert.equals(1, #replacements)
+    assert.equals(0, #warnings)
+    assert.equals('', replacements[1].search)
+    assert.equals('local x = 2', replacements[1].replace)
+    assert.is_true(replacements[1].is_insert)
+  end)
+
+  it('parses whitespace-only SEARCH section as insert operation', function()
     -- Note: Empty search with content on same line as separator
     -- The parser requires \n======= so whitespace-only search still needs proper structure
     local input = [[
@@ -120,9 +138,10 @@ local x = 2
 ]]
     local replacements, warnings = search_replace.parse_blocks(input)
 
-    assert.equals(0, #replacements)
-    assert.equals(1, #warnings)
-    assert.matches('Empty SEARCH section', warnings[1])
+    assert.equals(1, #replacements)
+    assert.equals(0, #warnings)
+    assert.equals('', replacements[1].search)
+    assert.is_true(replacements[1].is_insert)
   end)
 
   it('handles empty REPLACE section (deletion)', function()
@@ -277,4 +296,86 @@ describe('search_replace.apply', function()
 
     vim.api.nvim_buf_delete(buf, { force = true })
   end)
+
+  it('inserts at cursor row when is_insert is true', function()
+    local buf = vim.api.nvim_create_buf(false, true)
+    vim.api.nvim_buf_set_lines(buf, 0, -1, false, { 'line 1', 'line 2', 'line 3' })
+
+    local replacements = {
+      { search = '', replace = 'inserted text', block_number = 1, is_insert = true },
+    }
+
+    -- Insert before row 1 (0-indexed), so inserts before "line 2"
+    local success, errors, count = search_replace.apply(buf, replacements, 1)
+
+    assert.is_true(success)
+    assert.equals(0, #errors)
+    assert.equals(1, count)
+
+    local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
+    assert.are.same({ 'line 1', 'inserted text', 'line 2', 'line 3' }, lines)
+
+    vim.api.nvim_buf_delete(buf, { force = true })
+  end)
+
+  it('inserts at empty line cursor position', function()
+    local buf = vim.api.nvim_create_buf(false, true)
+    vim.api.nvim_buf_set_lines(buf, 0, -1, false, { 'line 1', '', 'line 3' })
+
+    local replacements = {
+      { search = '', replace = 'new content', block_number = 1, is_insert = true },
+    }
+
+    -- Insert before row 1 (0-indexed), the empty line
+    local success, errors, count = search_replace.apply(buf, replacements, 1)
+
+    assert.is_true(success)
+    assert.equals(0, #errors)
+    assert.equals(1, count)
+
+    local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
+    assert.are.same({ 'line 1', 'new content', '', 'line 3' }, lines)
+
+    vim.api.nvim_buf_delete(buf, { force = true })
+  end)
+
+  it('inserts multiline content at cursor row', function()
+    local buf = vim.api.nvim_create_buf(false, true)
+    vim.api.nvim_buf_set_lines(buf, 0, -1, false, { 'line 1', '', 'line 3' })
+
+    local replacements = {
+      { search = '', replace = 'first\nsecond\nthird', block_number = 1, is_insert = true },
+    }
+
+    -- Insert before row 1 (0-indexed)
+    local success, errors, count = search_replace.apply(buf, replacements, 1)
+
+    assert.is_true(success)
+    assert.equals(0, #errors)
+    assert.equals(1, count)
+
+    local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
+    assert.are.same({ 'line 1', 'first', 'second', 'third', '', 'line 3' }, lines)
+
+    vim.api.nvim_buf_delete(buf, { force = true })
+  end)
+
+  it('returns error for insert without cursor_row', function()
+    local buf = vim.api.nvim_create_buf(false, true)
+    vim.api.nvim_buf_set_lines(buf, 0, -1, false, { 'line 1' })
+
+    local replacements = {
+      { search = '', replace = 'inserted text', block_number = 1, is_insert = true },
+    }
+
+    -- No cursor_row provided
+    local success, errors, count = search_replace.apply(buf, replacements)
+
+    assert.is_false(success)
+    assert.equals(1, #errors)
+    assert.matches('Insert operation requires cursor position', errors[1])
+    assert.equals(0, count)
+
+    vim.api.nvim_buf_delete(buf, { force = true })
+  end)
 end)