opencode-fast-apply 2.1.6 → 2.2.0

package/README.md

@@ -1,170 +1,114 @@
 # opencode-fast-apply
 
-OpenCode plugin for Fast Apply - High-performance code editing with OpenAI-compatible APIs (LM Studio, Ollama).
+OpenCode plugin for Fast Apply - High-performance code editing with OpenAI-compatible APIs.
 
 ## Features
 
-- **High-speed code editing** via OpenAI-compatible Fast Apply API (speed depends on your hardware and model)
-- **Lazy edit markers** (`// ... existing code ...`) - no exact string matching needed
-- **Unified diff output** with context for easy review
-- **Graceful fallback** - suggests native `edit` tool on API failure
-- **Multi-backend support** - LM Studio, Ollama, OpenAI, and any OpenAI-compatible endpoint
-- **Robust XML tag handling** - safely handles code containing `<updated-code>` tags
-- **Special character support** - preserves all string literals, regex patterns, and escape sequences
+- **Partial file editing** - Only send relevant sections (50-500 lines), not entire files
+- **Smart context matching** - Automatically finds and replaces code sections
+- **Token efficient** - Save 80-98% tokens compared to full-file edits
+- **Lazy edit markers** - Use `// ... existing code ...` for unchanged sections
+- **Multi-backend support** - LM Studio, Ollama, OpenAI, any OpenAI-compatible endpoint
+- **Robust XML handling** - Safely handles special characters and XML tags in code
 
 ## Installation
 
-### 1. Install from npm (Recommended)
-
 ```bash
 npm install -g opencode-fast-apply
 ```
 
-### 2. Configure your API endpoint
+Configure your API endpoint:
 
-For **LM Studio** (default):
 ```bash
+# LM Studio (default)
 export FAST_APPLY_URL="http://localhost:1234"
 export FAST_APPLY_MODEL="fastapply-1.5b"
 export FAST_APPLY_API_KEY="optional-api-key"
-```
 
-For **Ollama**:
-```bash
+# Ollama
 export FAST_APPLY_URL="http://localhost:11434"
 export FAST_APPLY_MODEL="codellama:7b"
-export FAST_APPLY_API_KEY="optional-api-key"
-```
 
-For **OpenAI**:
-```bash
+# OpenAI
 export FAST_APPLY_URL="https://api.openai.com"
 export FAST_APPLY_MODEL="gpt-4"
-export FAST_APPLY_API_KEY="sk-your-openai-key"
+export FAST_APPLY_API_KEY="sk-your-key"
 ```
 
-**Note:** The plugin automatically handles URLs with or without `/v1` suffix.
-
-### 3. Add the plugin to your OpenCode config
-
-Add to your global config (`~/.config/opencode/opencode.json` or `opencode.jsonc`):
+Add to OpenCode config (`~/.config/opencode/opencode.json`):
 
 ```json
 {
-  "plugin": [
-    "opencode-fast-apply"
-  ]
+  "plugin": ["opencode-fast-apply"]
 }
 ```
 
-**That's it!** The plugin automatically embeds all instructions - no additional configuration needed.
-
-### 4. Restart OpenCode
-
-The `fast_apply_edit` tool will now be available and configured as the default editing tool.
+Restart OpenCode. The `fast_apply_edit` tool is now available.
 
 ## Usage
 
-The LLM can use `fast_apply_edit` for efficient partial file edits:
+```typescript
+// 1. Read relevant section (not entire file)
+const content = await read("src/app.ts", { offset: 100, limit: 50 })
 
-```
+// 2. Edit with partial context
 fast_apply_edit({
-  target_filepath: "sth.ts",
-  instructions: "Add error handling for invalid tokens",
+  target_filepath: "src/app.ts",
+  original_code: content,  // Just 50 lines!
   code_edit: `// ... existing code ...
-function validateToken(token) {
-  if (!token) {
-    throw new Error("Token is required");
-  }
-  // ... existing code ...
+function updated() {
+  return "modified";
 }
 // ... existing code ...`
 })
 ```
 
-### When to use `fast_apply_edit` vs `edit`
-
-| Situation | Tool | Reason |
-|-----------|------|--------|
-| Small, exact replacement | `edit` | Fast, no API call |
-| Large file (500+ lines) | `fast_apply_edit` | Handles partial snippets |
-| Multiple scattered changes | `fast_apply_edit` | Batch efficiently |
-| Whitespace-sensitive | `fast_apply_edit` | Forgiving with formatting |
+**Key points:**
+- Provide 50-500 lines of context around the area you want to change
+- Include 2-5 lines before/after the target section
+- Tool automatically finds and replaces that section in the full file
+- No need to send entire file (saves tokens and improves speed)
 
 ## Configuration
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `FAST_APPLY_API_KEY` | `optional-api-key` | API key (optional for local servers) |
-| `FAST_APPLY_URL` | `http://localhost:1234/v1` | OpenAI-compatible API endpoint |
+| `FAST_APPLY_API_KEY` | `optional-api-key` | API key (optional for local) |
+| `FAST_APPLY_URL` | `http://localhost:1234` | API endpoint |
 | `FAST_APPLY_MODEL` | `fastapply-1.5b` | Model name |
-| `FAST_APPLY_TEMPERATURE` | `0.05` | Temperature (0.0-2.0) |
 
 ## How It Works
 
-1. Reads the original file content
-2. Escapes XML tags in code to prevent conflicts
-3. Sends system prompt + user prompt with `<instruction>`, `<code>`, and `<update>` to OpenAI-compatible API
-4. API intelligently merges the lazy edit markers with original code
-5. Extracts result from `<updated-code>` tags and unescapes XML
-6. Writes the merged result back to the file
-7. Returns a unified diff showing what changed
-
-## Performance
-
-Performance varies based on your setup:
-
-| Setup | Estimated Speed | Hardware Requirement |
-|-------|----------------|---------------------|
-| fastapply-1.5b (Q4) + RTX 4090 | 10,000-15,000 tok/s | High-end GPU |
-| codellama:7b (Q4) + RTX 3060 | 3,000-5,000 tok/s | Mid-range GPU |
-| codellama:7b (Q4) + CPU only | 50-200 tok/s | Modern CPU |
-| OpenAI GPT-4 API | 100-500 tok/s | Network dependent |
-
-**Factors affecting performance:**
-- Model size (1.5B vs 7B vs 13B+ parameters)
-- Quantization level (Q4 vs Q5 vs Q8 vs FP16)
-- Hardware (GPU VRAM, CPU cores, RAM)
-- Backend optimization (LM Studio vs Ollama)
-
-## Supported Backends
-
-- **LM Studio** - Local inference server with GPU acceleration
-- **Ollama** - Local LLM runtime with easy model management
-- **OpenAI** - Cloud API with high reliability
-- **Any OpenAI-compatible endpoint** - Custom servers and providers
-
-## Edge Cases Handled
-
-- ✅ String literals containing `<updated-code>` tags
-- ✅ Multiple XML-like tags in regex patterns
-- ✅ Special characters (quotes, backslashes, unicode, SQL, HTML entities)
-- ✅ Large files (500+ lines)
-- ✅ Multiple scattered changes in single edit
-- ✅ Complex nested structures
-- ✅ Template strings with `${variable}`
-- ✅ Whitespace and indentation preservation
+1. AI reads relevant file section (50-500 lines)
+2. AI provides `original_code` (partial context) and `code_edit`
+3. Tool sends to Fast Apply API for merging
+4. Tool finds where `original_code` appears in full file
+5. Tool replaces that section with merged code
+6. Tool writes full file back and shows diff
+
+## Token Savings
+
+| File Size | Before (Full) | After (Partial) | Savings |
+|-----------|--------------|-----------------|---------|
+| 100 lines | 2,500 tokens | 500 tokens | -80% |
+| 500 lines | 12,500 tokens | 1,000 tokens | -92% |
+| 1000 lines | 25,000 tokens | 1,500 tokens | -94% |
+| 5000 lines | 125,000 tokens | 2,000 tokens | -98% |
 
 ## Troubleshooting
 
-### API Connection Issues
+**"Cannot locate original_code in file"**
+- File was modified since you read it - re-read and try again
+- Whitespace differs - tool tries normalized matching automatically
+- Wrong section provided - verify you extracted the correct lines
+
+**API connection issues**
 ```bash
-# Test your endpoint
 curl -X POST http://localhost:1234/v1/chat/completions \
   -H "Content-Type: application/json" \
   -d '{"model":"fastapply-1.5b","messages":[{"role":"user","content":"test"}]}'
 ```
 
-### Slow Performance
-- Use smaller models (1.5B-3B parameters)
-- Enable GPU acceleration in LM Studio/Ollama
-- Use Q4 quantization for faster inference
-- Increase `FAST_APPLY_MAX_TOKENS` if responses are truncated
-
-## Contributing
-
-Contributions welcome! This plugin could potentially be integrated into OpenCode core.
-
 ## License
 
-[MIT](LICENSE)
+MIT

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,qBAAqB,CAAA;AA0avD,eAAO,MAAM,eAAe,EAAE,MA4J7B,CAAA;AAGD,eAAe,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,qBAAqB,CAAA;AAshBvD,eAAO,MAAM,eAAe,EAAE,MAgL7B,CAAA;AAGD,eAAe,eAAe,CAAA"}

package/dist/index.js

@@ -16,140 +16,127 @@ const sessionParamsCache = new Map();
 const FAST_APPLY_API_KEY = process.env.FAST_APPLY_API_KEY || "optional-api-key";
 const FAST_APPLY_URL = (process.env.FAST_APPLY_URL || "http://localhost:1234/v1").replace(/\/v1\/?$/, "");
 const FAST_APPLY_MODEL = process.env.FAST_APPLY_MODEL || "fastapply-1.5b";
-const FAST_APPLY_TEMPERATURE = parseFloat(process.env.FAST_APPLY_TEMPERATURE || "0.05");
-const FAST_APPLY_SYSTEM_PROMPT = "You are a coding assistant that helps merge code updates, ensuring every modification is fully integrated.";
-const FAST_APPLY_USER_PROMPT = `Merge all changes from the <update> snippet into the <code> below.
-- Preserve the code's structure, order, comments, and indentation exactly.
-- Output only the updated code, enclosed within <updated-code> and </updated-code> tags.
-- Do not include any additional text, explanations, placeholders, ellipses, or code fences.
+const FAST_APPLY_SYSTEM_PROMPT = `You are a precise code merging assistant. Your role:
+1. Merge updates while preserving all original structure and formatting
+2. Output ONLY valid code within specified XML tags
+3. Never add explanations or text outside tags
+4. Preserve all escaped XML entities exactly as provided
+5. Ensure output is syntactically valid and complete`;
+const FAST_APPLY_USER_PROMPT = `Merge <update> into <code> and output the complete merged file.
+
+RULES:
+- Preserve: structure, order, comments, indentation, escaped entities
+- Output: entire file within <updated-code></updated-code> tags only
+- Forbidden: explanations, placeholders, ellipses, code fences, nested tags
+- Validation: ensure syntactically valid, complete code
 
 <code>{original_code}</code>
 
 <update>{update_snippet}</update>
 
-Provide the complete updated code.`;
-const UPDATED_CODE_START = "<updated-code>";
-const UPDATED_CODE_END = "</updated-code>";
-const TOOL_INSTRUCTIONS = `**DEFAULT tool for editing existing files. Use INSTEAD of native 'edit' tool.**
+Output complete merged code:`;
+const TOOL_INSTRUCTIONS = `DEFAULT tool for editing existing files. Use INSTEAD of native 'edit' tool.
 
 CRITICAL: For EXISTING files ONLY. Use 'write' for new files.
 
-## Priority
-1. \`fast_apply_edit\` - ALL file edits (default)
-2. \`edit\` - Fallback if API fails
-3. \`write\` - NEW files only
+WORKFLOW:
+1. Read the file to understand current content
+2. Extract relevant section (50-500 lines with context)
+3. Call fast_apply_edit with original_code (partial) and code_edit
 
-## Format
-Use \`// ... existing code ...\` for unchanged sections:
+PARTIAL EDITING:
+- You DON'T need to provide the entire file
+- Provide 50-500 lines of context around the area you want to change
+- Include 2-5 lines before and after the target section
+- Tool will automatically find and replace that section in the file
 
-\`\`\`
-// ... existing code ...
-function updated() {
-  return "modified";
-}
-// ... existing code ...
-\`\`\`
-
-## Rules
-- MANDATORY: Use \`// ... existing code ...\` markers
-- Include 2-3 lines context before/after edits
-- Preserve exact indentation
-- ONE edit block per call (multiple blocks = suboptimal results)
-- Deletions: show context, omit deleted lines
-- NEVER for new files
+PRIORITY:
+1. fast_apply_edit - ALL file edits (default, 10x faster)
+2. edit - Fallback if API fails
+3. write - NEW files only
 
-## Examples
-
-**Add function:**
+FORMAT:
+Use \`// ... existing code ...\` markers for unchanged sections:
 \`\`\`
 // ... existing code ...
-import { newDep } from './newDep';
-// ... existing code ...
-
-function newFeature() {
-  return newDep.process();
-}
+function updated() { return "modified"; }
 // ... existing code ...
 \`\`\`
 
-**Modify:**
-\`\`\`
-// ... existing code ...
-function existingFunc(param) {
-  const result = param * 2;
-  return result;
-}
-// ... existing code ...
-\`\`\`
+RULES:
+- MANDATORY: Read file first to get original_code
+- Provide 50-500 lines of context (not entire file unless small)
+- Use \`// ... existing code ...\` markers in code_edit
+- Include 2-5 lines context before/after edits
+- Preserve exact indentation and whitespace
+- ONE edit block per call (multiple blocks = suboptimal)
 
-**Delete:**
-\`\`\`
-// ... existing code ...
-function keepThis() {
-  return "stays";
-}
+EXAMPLE:
+\`\`\`typescript
+// 1. Read file
+const content = await read("src/app.ts", { offset: 100, limit: 50 })
 
-function alsoKeepThis() {
-  return "stays";
-}
-// ... existing code ...
+// 2. Call fast_apply_edit with partial context
+fast_apply_edit({
+  target_filepath: "src/app.ts",
+  original_code: content,  // Just 50 lines, not entire file!
+  code_edit: "... updated code ..."
+})
 \`\`\`
 
-## Fallback
-If API fails, use native \`edit\` tool with exact string matching.`;
+FALLBACK: If API fails, use native 'edit' tool.`;
 function escapeXmlTags(text) {
     return text
-        .replace(/<updated-code>/g, "&lt;updated-code&gt;")
-        .replace(/<\/updated-code>/g, "&lt;/updated-code&gt;");
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
 }
 function unescapeXmlTags(text) {
     return text
-        .replace(/&lt;updated-code&gt;/g, "<updated-code>")
-        .replace(/&lt;\/updated-code&gt;/g, "</updated-code>");
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, "&");
 }
-function extractUpdatedCode(raw) {
-    const stripped = raw.trim();
-    const startTag = UPDATED_CODE_START;
-    const endTag = UPDATED_CODE_END;
-    let startIdx = stripped.indexOf(startTag);
-    if (startIdx === -1) {
-        startIdx = stripped.indexOf("<updated-code");
-        if (startIdx !== -1) {
-            const closeTagIdx = stripped.indexOf(">", startIdx);
-            if (closeTagIdx !== -1) {
-                startIdx = closeTagIdx + 1;
-            }
-        }
+function validateNoNestedTags(content) {
+    const unescaped = content
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">");
+    if (unescaped.includes("<updated-code>") || unescaped.includes("</updated-code>")) {
+        throw new Error("Content contains unescaped tag-like sequences that could break parsing");
     }
-    else {
-        startIdx += startTag.length;
+    if (unescaped.includes("<code>") || unescaped.includes("</code>")) {
+        throw new Error("Content contains unescaped <code> tags that could break prompt structure");
     }
-    if (startIdx === -1 || startIdx === startTag.length - 1) {
-        if (stripped.startsWith("```") && stripped.endsWith("```")) {
-            const lines = stripped.split("\n");
-            if (lines.length >= 2) {
-                return unescapeXmlTags(lines.slice(1, -1).join("\n"));
-            }
-        }
-        return unescapeXmlTags(stripped);
+    if (unescaped.includes("<update>") || unescaped.includes("</update>")) {
+        throw new Error("Content contains unescaped <update> tags that could break prompt structure");
     }
-    let endIdx = stripped.indexOf(endTag, startIdx);
-    if (endIdx === -1) {
-        endIdx = stripped.indexOf("</updated-code", startIdx);
+}
+function extractUpdatedCode(raw) {
+    const stripped = raw.trim();
+    const startRegex = /<updated-code\s*>/i;
+    const endRegex = /<\/updated-code\s*>/i;
+    const startMatch = stripped.match(startRegex);
+    if (!startMatch || startMatch.index === undefined) {
+        throw new Error("Missing or malformed <updated-code> start tag in AI response");
     }
-    if (endIdx === -1) {
-        const extracted = stripped.slice(startIdx).trim();
-        const lastCloseTag = extracted.lastIndexOf("</");
-        if (lastCloseTag !== -1 && extracted.slice(lastCloseTag).toLowerCase().includes("update")) {
-            return unescapeXmlTags(extracted.slice(0, lastCloseTag).trim());
-        }
-        return unescapeXmlTags(extracted);
+    const startIdx = startMatch.index + startMatch[0].length;
+    const remaining = stripped.slice(startIdx);
+    const endMatch = remaining.match(endRegex);
+    if (!endMatch || endMatch.index === undefined) {
+        throw new Error("Missing or malformed </updated-code> end tag in AI response");
     }
-    const inner = stripped.substring(startIdx, endIdx);
-    if (!inner || inner.trim().length === 0) {
-        throw new Error("Empty updated-code block");
+    const endIdx = endMatch.index;
+    const inner = remaining.slice(0, endIdx);
+    if (!inner.trim()) {
+        throw new Error("Empty updated-code block in AI response");
     }
-    return unescapeXmlTags(inner);
+    const unescaped = unescapeXmlTags(inner);
+    validateNoNestedTags(unescaped);
+    return unescaped;
 }
 function generateUnifiedDiff(filepath, original, modified) {
     const patch = createTwoFilesPatch(`a/${filepath}`, `b/${filepath}`, original, modified, "", "", { context: 3 });
@@ -193,6 +180,94 @@ function shortenPath(filePath, workingDir) {
 function estimateTokens(text) {
     return Math.ceil(text.length / 4);
 }
+function normalizeWhitespace(text) {
+    return text
+        .split('\n')
+        .map(line => line.trimEnd())
+        .join('\n')
+        .replace(/\r\n/g, '\n')
+        .trim();
+}
+function findExactMatch(haystack, needle) {
+    return haystack.indexOf(needle);
+}
+function findNormalizedMatch(haystack, needle) {
+    const normalizedHaystack = normalizeWhitespace(haystack);
+    const normalizedNeedle = normalizeWhitespace(needle);
+    const index = normalizedHaystack.indexOf(normalizedNeedle);
+    if (index === -1)
+        return -1;
+    let actualIndex = 0;
+    let normalizedIndex = 0;
+    while (normalizedIndex < index && actualIndex < haystack.length) {
+        const char = haystack[actualIndex];
+        const normalizedChar = normalizedHaystack[normalizedIndex];
+        if (char === '\r' && haystack[actualIndex + 1] === '\n') {
+            actualIndex += 2;
+            normalizedIndex += 1;
+        }
+        else if (char === normalizedChar) {
+            actualIndex++;
+            normalizedIndex++;
+        }
+        else {
+            actualIndex++;
+        }
+    }
+    return actualIndex;
+}
+async function applyPartialEdit(filepath, original_code, merged_code) {
+    const currentFile = await readFile(filepath, "utf-8");
+    if (currentFile.includes('\0')) {
+        return {
+            success: false,
+            error: "Cannot edit binary files"
+        };
+    }
+    let index = findExactMatch(currentFile, original_code);
+    let matchType = "exact";
+    if (index === -1) {
+        index = findNormalizedMatch(currentFile, original_code);
+        matchType = "normalized";
+    }
+    if (index === -1) {
+        return {
+            success: false,
+            error: `Cannot locate original_code in ${filepath}.
+
+The content you provided doesn't match the current file.
+
+POSSIBLE CAUSES:
+- File was modified since you read it
+- Whitespace or indentation differs
+- Wrong section provided
+- File encoding issues
+
+SOLUTIONS:
+1. Re-read the file to get current content
+2. Verify exact whitespace and indentation
+3. Provide more context (more surrounding lines)
+4. Use native 'edit' tool for exact string matching`
+        };
+    }
+    const occurrences = currentFile.split(original_code).length - 1;
+    if (occurrences > 1) {
+        return {
+            success: false,
+            error: `original_code appears ${occurrences} times in ${filepath}.
+
+Please provide more context (more surrounding lines) to uniquely identify the section you want to edit.`
+        };
+    }
+    const newFileContent = currentFile.substring(0, index) +
+        merged_code +
+        currentFile.substring(index + original_code.length);
+    console.log(`[fast-apply] Applied ${matchType} match at position ${index}`);
+    return {
+        success: true,
+        newFileContent
+    };
+}
 function formatFastApplyResult(filePath, workingDir, insertions, deletions, diffPreview, modifiedTokens) {
     const shortPath = shortenPath(filePath, workingDir);
     const tokenStr = formatTokenCount(modifiedTokens);
@@ -221,7 +296,7 @@ function formatErrorOutput(error, filePath, workingDir) {
 /**
  * Call OpenAI's Fast Apply API to merge code edits
  */
-async function callFastApply(originalCode, codeEdit, instructions) {
+async function callFastApply(originalCode, codeEdit) {
     if (!FAST_APPLY_API_KEY) {
         return {
             success: false,
@@ -252,7 +327,7 @@ async function callFastApply(originalCode, codeEdit, instructions) {
                         content: userContent,
                     },
                 ],
-                temperature: FAST_APPLY_TEMPERATURE,
+                temperature: 0,
             }),
         });
         if (!response.ok) {
@@ -270,11 +345,20 @@ async function callFastApply(originalCode, codeEdit, instructions) {
                 error: "Fast Apply API returned empty response",
             };
         }
-        const mergedCode = extractUpdatedCode(rawResponse);
-        return {
-            success: true,
-            content: mergedCode,
-        };
+        try {
+            const mergedCode = extractUpdatedCode(rawResponse);
+            return {
+                success: true,
+                content: mergedCode,
+            };
+        }
+        catch (parseError) {
+            const error = parseError;
+            return {
+                success: false,
+                error: `Failed to parse AI response: ${error.message}`,
+            };
+        }
     }
     catch (err) {
         const error = err;
@@ -361,15 +445,26 @@ export const FastApplyPlugin = async ({ directory, client }) => {
                     target_filepath: tool.schema
                         .string()
                         .describe("Path of the file to modify (relative to project root)"),
-                    instructions: tool.schema
+                    original_code: tool.schema
                         .string()
-                        .describe("Brief first-person description of what you're changing (helps disambiguate)"),
+                        .describe(`The original code section to be modified. 
+
+IMPORTANT:
+- Provide 50-500 lines of context around the area you want to change
+- Include 2-5 lines before and after the target section
+- Must match the current file content exactly (whitespace matters)
+- Can be partial (doesn't need to be entire file)
+
+WORKFLOW:
+1. Read the file first to get current content
+2. Extract the relevant section with context
+3. Provide that section as original_code`),
                     code_edit: tool.schema
                         .string()
-                        .describe('The code changes with "// ... existing code ..." markers for unchanged sections'),
+                        .describe('The updated code with changes applied. Use "// ... existing code ..." markers for unchanged sections within this context.'),
                 },
                 async execute(args, toolCtx) {
-                    const { target_filepath, instructions, code_edit } = args;
+                    const { target_filepath, original_code, code_edit } = args;
                     const params = sessionParamsCache.get(toolCtx.sessionID) || {};
                     // Resolve file path relative to project directory
                     const filepath = target_filepath.startsWith("/")
@@ -384,16 +479,12 @@ Get your API key at: https://openai.com/api
 
 Alternatively, use the native 'edit' tool for this change.`;
                     }
-                    // Read the original file
-                    let originalCode;
+                    // Check if file exists and is writable
                     try {
-                        await access(filepath, constants.R_OK);
-                        originalCode = await readFile(filepath, "utf-8");
+                        await access(filepath, constants.R_OK | constants.W_OK);
                     }
                     catch (err) {
-                        const error = err;
-                        if (error.message.includes("ENOENT") || error.message.includes("no such file")) {
-                            return `Error: File not found: ${target_filepath}
+                        return `Error: File not found or not writable: ${target_filepath}
 
 This tool is for EDITING EXISTING FILES ONLY.
 For new file creation, use the 'write' tool instead.
@@ -403,26 +494,33 @@ write({
   filePath: "${target_filepath}",
   content: "your file content here"
 })`;
-                        }
-                        return `Error reading file ${target_filepath}: ${error.message}`;
                     }
-                    // Call OpenAI API to merge the edit
-                    const result = await callFastApply(originalCode, code_edit, instructions);
+                    // Call Fast Apply API to merge the edit
+                    const result = await callFastApply(original_code, code_edit);
                     if (!result.success || !result.content) {
                         const errorMsg = result.error || "Unknown error";
                         await sendTUIErrorNotification(client, toolCtx.sessionID, target_filepath, directory, errorMsg, params);
                         return formatErrorOutput(errorMsg, target_filepath, directory);
                     }
                     const mergedCode = result.content;
+                    // Apply partial edit with smart matching
+                    const applyResult = await applyPartialEdit(filepath, original_code, mergedCode);
+                    if (!applyResult.success) {
+                        await sendTUIErrorNotification(client, toolCtx.sessionID, target_filepath, directory, applyResult.error, params);
+                        return formatErrorOutput(applyResult.error, target_filepath, directory);
+                    }
+                    // Write merged file back
                     try {
-                        await writeFile(filepath, mergedCode, "utf-8");
+                        await writeFile(filepath, applyResult.newFileContent, "utf-8");
                     }
                     catch (err) {
                         const error = err;
                         await sendTUIErrorNotification(client, toolCtx.sessionID, target_filepath, directory, error.message, params);
                         return formatErrorOutput(error.message, target_filepath, directory);
                     }
-                    const diff = generateUnifiedDiff(target_filepath, originalCode, mergedCode);
+                    // Read origfile for diff comparison
+                    const originalFileContent = await readFile(filepath, "utf-8");
+                    const diff = generateUnifiedDiff(target_filepath, originalFileContent, applyResult.newFileContent);
                     const { added, removed } = countChanges(diff);
                     const modifiedTokens = estimateTokens(diff);
                     await sendTUINotification(client, toolCtx.sessionID, target_filepath, directory, added, removed, modifiedTokens, params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-fast-apply",
-  "version": "2.1.6",
+  "version": "2.2.0",
   "description": "OpenCode plugin for Fast Apply - High-performance code editing with OpenAI-compatible APIs (LM Studio, Ollama)",
   "type": "module",
   "main": "dist/index.js",