opencode-fast-apply 2.0.0

package/FAST_APPLY_INSTRUCTIONS.md

@@ -0,0 +1,121 @@
+# Fast Apply - Tool Selection Guide
+
+**CRITICAL: Use `fast_apply_edit` as your DEFAULT tool for ALL file editing operations.**
+
+## Tool Selection Priority
+
+| Priority | Tool | Use Case |
+|----------|------|----------|
+| **1st** | `fast_apply_edit` | **ALL file editing operations** (default choice) |
+| **2nd** | `edit` | Fallback only when `fast_apply_edit` fails |
+| **3rd** | `write` | **ONLY for creating NEW files** |
+
+## Default Behavior
+
+**ALWAYS use `fast_apply_edit` for editing existing files unless:**
+- Fast Apply API is unavailable or returns error
+- You need guaranteed exact string replacement
+- The file doesn't exist yet (use `write` instead)
+
+## Tool Selection Matrix
+
+| Situation | Tool | Reason |
+|-----------|------|--------|
+| Edit existing file (any size) | `fast_apply_edit` | **DEFAULT**, handles lazy markers, robust |
+| Small change (1-2 lines) | `fast_apply_edit` | **DEFAULT**, no need to switch tools |
+| Large file (500+ lines) | `fast_apply_edit` | **DEFAULT**, optimal performance with partial snippets |
+| Multiple scattered changes | `fast_apply_edit` | **DEFAULT**, batch changes efficiently |
+| Complex refactoring | `fast_apply_edit` | **DEFAULT**, better accuracy with context |
+| Whitespace-sensitive edits | `fast_apply_edit` | **DEFAULT**, forgiving with formatting |
+| Special characters in code | `fast_apply_edit` | **DEFAULT**, handles XML tags, regex, etc. |
+| Fast Apply API fails | `edit` | Fallback with exact string matching |
+| **New file creation** | `write` | **NEVER use fast_apply_edit for new files** |
+
+## Using fast_apply_edit
+
+The `fast_apply_edit` tool uses **lazy edit markers** to represent unchanged code:
+
+```javascript
+// ... existing code ...
+function updatedFunction() {
+  // New implementation
+  return "modified";
+}
+// ... existing code ...
+```
+
+### Parameters
+
+- `target_filepath`: Path to the file (relative to project root)
+- `instructions`: Brief description of changes (helps AI disambiguate)
+- `code_edit`: Code with `// ... existing code ...` markers
+
+### Rules
+
+1. **MANDATORY**: Use `// ... existing code ...` for unchanged sections
+2. Include **2-3 lines of context** before and after each edit
+3. Preserve **exact indentation** from original file
+4. For **deletions**: show context before/after, omit the deleted lines
+5. **Batch** multiple edits to the same file in one call
+6. **NEVER** use for new file creation - use `write` tool instead
+
+### Examples
+
+**Adding a function:**
+```
+// ... existing code ...
+import { newDep } from './newDep';
+// ... existing code ...
+
+function newFeature() {
+  return newDep.process();
+}
+// ... existing code ...
+```
+
+**Modifying existing code:**
+```
+// ... existing code ...
+function existingFunc(param) {
+  // Updated implementation
+  const result = param * 2; // Changed from * 1
+  return result;
+}
+// ... existing code ...
+```
+
+**Deleting code (show what remains):**
+```
+// ... existing code ...
+function keepThis() {
+  return "stays";
+}
+
+// The function between these two was removed
+
+function alsoKeepThis() {
+  return "also stays";
+}
+// ... existing code ...
+```
+
+## Fallback Behavior
+
+If Fast Apply API fails (timeout, network error, etc.):
+1. Tool returns error message with details
+2. **Fallback to native `edit` tool** with exact string matching
+3. The `edit` tool requires matching exact text from the file
+
+**Note:** API failures are rare. Always try `fast_apply_edit` first.
+
+## When to Use Native 'edit' Tool
+
+- **ONLY as fallback** when `fast_apply_edit` fails
+- When Fast Apply API is unavailable
+- When you need guaranteed exact string replacement
+
+## When to Use 'write' Tool
+
+- **ONLY for creating NEW files**
+- Never use `fast_apply_edit` for file creation
+- Provide complete file content without lazy markers

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 JRedeker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,194 @@
+# opencode-fast-apply
+
+OpenCode plugin for Fast Apply - High-performance code editing with OpenAI-compatible APIs (LM Studio, Ollama).
+
+## 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
+
+## Installation
+
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/tickernelz/opencode-fast-apply.git ~/dev/oc-plugins/fast-apply
+cd ~/dev/oc-plugins/fast-apply
+npm install
+```
+
+### 2. Configure your API endpoint
+
+For **LM Studio** (default):
+```bash
+export FAST_APPLY_URL="http://localhost:1234/v1"
+export FAST_APPLY_MODEL="fastapply-1.5b"
+export FAST_APPLY_API_KEY="optional-api-key"
+```
+
+For **Ollama**:
+```bash
+export FAST_APPLY_URL="http://localhost:11434/v1"
+export FAST_APPLY_MODEL="codellama:7b"
+export FAST_APPLY_API_KEY="optional-api-key"
+```
+
+For **OpenAI**:
+```bash
+export FAST_APPLY_URL="https://api.openai.com/v1"
+export FAST_APPLY_MODEL="gpt-4"
+export FAST_APPLY_API_KEY="sk-your-openai-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`):
+
+```json
+{
+  "plugin": [
+    "/path/to/fast-apply"
+  ],
+  "instructions": [
+    "/path/to/fast-apply/FAST_APPLY_INSTRUCTIONS.md"
+  ]
+}
+```
+
+Or in a project-local `.opencode/config.json`:
+
+```json
+{
+  "plugin": [
+    "~/dev/oc-plugins/fast-apply"
+  ],
+  "instructions": [
+    "~/dev/oc-plugins/fast-apply/FAST_APPLY_INSTRUCTIONS.md"
+  ]
+}
+```
+
+### 4. Restart OpenCode
+
+The `fast_apply_edit` tool will now be available.
+
+## Usage
+
+The LLM can use `fast_apply_edit` for efficient partial file edits:
+
+```
+fast_apply_edit({
+  target_filepath: "sth.ts",
+  instructions: "Add error handling for invalid tokens",
+  code_edit: `// ... existing code ...
+function validateToken(token) {
+  if (!token) {
+    throw new Error("Token is required");
+  }
+  // ... existing code ...
+}
+// ... 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 |
+
+## 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_MODEL` | `fastapply-1.5b` | Model name |
+| `FAST_APPLY_TIMEOUT` | `30000` | Request timeout in ms |
+| `FAST_APPLY_TEMPERATURE` | `0.05` | Temperature (0.0-2.0) |
+| `FAST_APPLY_MAX_TOKENS` | `8000` | Maximum tokens in response |
+
+## 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
+
+## Troubleshooting
+
+### 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
+
+### Timeout Errors
+```bash
+# Increase timeout for slower hardware
+export FAST_APPLY_TIMEOUT="60000"  # 60 seconds
+```
+
+## Contributing
+
+Contributions welcome! This plugin could potentially be integrated into OpenCode core.
+
+## License
+
+[MIT](LICENSE)

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * OpenCode Fast Apply Plugin
+ *
+ * Integrates OpenAI-compatible Fast Apply API for 10x faster code editing.
+ * Supports LM Studio, Ollama, and other OpenAI-compatible endpoints.
+ * Uses lazy edit markers (// ... existing code ...) for partial file updates.
+ *
+ * @see https://github.com/tickernelz/opencode-fast-apply
+ */
+import { type Plugin } from "@opencode-ai/plugin";
+export declare const FastApplyPlugin: Plugin;
+export default FastApplyPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,300 @@
+/**
+ * OpenCode Fast Apply Plugin
+ *
+ * Integrates OpenAI-compatible Fast Apply API for 10x faster code editing.
+ * Supports LM Studio, Ollama, and other OpenAI-compatible endpoints.
+ * Uses lazy edit markers (// ... existing code ...) for partial file updates.
+ *
+ * @see https://github.com/tickernelz/opencode-fast-apply
+ */
+import { tool } from "@opencode-ai/plugin";
+import { createTwoFilesPatch } from "diff";
+import { readFile, writeFile, access } from "fs/promises";
+import { constants } from "fs";
+// Get API key from environment (set in mcpm/jarvis config)
+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_TIMEOUT = parseInt(process.env.FAST_APPLY_TIMEOUT || "30000", 10);
+const FAST_APPLY_TEMPERATURE = parseFloat(process.env.FAST_APPLY_TEMPERATURE || "0.05");
+const FAST_APPLY_MAX_TOKENS = parseInt(process.env.FAST_APPLY_MAX_TOKENS || "8000", 10);
+const PLUGIN_VERSION = "2.0.0";
+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.
+Instruction: {instruction}
+- 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, markdown, ellipses, or code fences.
+
+<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>";
+function escapeXmlTags(text) {
+    return text
+        .replace(/<updated-code>/g, "&lt;updated-code&gt;")
+        .replace(/<\/updated-code>/g, "&lt;/updated-code&gt;");
+}
+function unescapeXmlTags(text) {
+    return text
+        .replace(/&lt;updated-code&gt;/g, "<updated-code>")
+        .replace(/&lt;\/updated-code&gt;/g, "</updated-code>");
+}
+function extractUpdatedCode(raw) {
+    const stripped = raw.trim();
+    const start = stripped.indexOf(UPDATED_CODE_START);
+    const end = stripped.lastIndexOf(UPDATED_CODE_END);
+    if (start === -1 || end === -1 || end <= start) {
+        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);
+    }
+    const inner = stripped.substring(start + UPDATED_CODE_START.length, end);
+    if (!inner || inner.trim().length === 0) {
+        throw new Error("Empty updated-code block");
+    }
+    return unescapeXmlTags(inner);
+}
+function generateUnifiedDiff(filepath, original, modified) {
+    const patch = createTwoFilesPatch(`a/${filepath}`, `b/${filepath}`, original, modified, "", "", { context: 3 });
+    if (!patch.includes("@@")) {
+        return "No changes detected";
+    }
+    return patch;
+}
+/**
+ * Count additions and deletions from a unified diff
+ */
+function countChanges(diff) {
+    const lines = diff.split("\n");
+    let added = 0;
+    let removed = 0;
+    for (const line of lines) {
+        if (line.startsWith("+") && !line.startsWith("+++")) {
+            added++;
+        }
+        else if (line.startsWith("-") && !line.startsWith("---")) {
+            removed++;
+        }
+    }
+    return { added, removed };
+}
+/**
+ * Call OpenAI's Fast Apply API to merge code edits
+ */
+async function callFastApply(originalCode, codeEdit, instructions) {
+    if (!FAST_APPLY_API_KEY) {
+        return {
+            success: false,
+            error: "FAST_APPLY_API_KEY not set. Get one at https://openai.com/api",
+        };
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), FAST_APPLY_TIMEOUT);
+    try {
+        const escapedOriginalCode = escapeXmlTags(originalCode);
+        const escapedCodeEdit = escapeXmlTags(codeEdit);
+        const userContent = FAST_APPLY_USER_PROMPT
+            .replace("{instruction}", instructions || "Apply the requested code changes.")
+            .replace("{original_code}", escapedOriginalCode)
+            .replace("{update_snippet}", escapedCodeEdit);
+        const response = await fetch(`${FAST_APPLY_URL}/v1/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${FAST_APPLY_API_KEY}`,
+            },
+            body: JSON.stringify({
+                model: FAST_APPLY_MODEL,
+                messages: [
+                    {
+                        role: "system",
+                        content: FAST_APPLY_SYSTEM_PROMPT,
+                    },
+                    {
+                        role: "user",
+                        content: userContent,
+                    },
+                ],
+                temperature: FAST_APPLY_TEMPERATURE,
+                max_tokens: FAST_APPLY_MAX_TOKENS,
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            const errorText = await response.text();
+            return {
+                success: false,
+                error: `Fast Apply API error (${response.status}): ${errorText}`,
+            };
+        }
+        const result = (await response.json());
+        const rawResponse = result.choices?.[0]?.message?.content;
+        if (!rawResponse) {
+            return {
+                success: false,
+                error: "Fast Apply API returned empty response",
+            };
+        }
+        const mergedCode = extractUpdatedCode(rawResponse);
+        return {
+            success: true,
+            content: mergedCode,
+        };
+    }
+    catch (err) {
+        clearTimeout(timeoutId);
+        const error = err;
+        if (error.name === "AbortError") {
+            return {
+                success: false,
+                error: `Fast Apply API timeout after ${FAST_APPLY_TIMEOUT}ms`,
+            };
+        }
+        return {
+            success: false,
+            error: `Fast Apply API request failed: ${error.message}`,
+        };
+    }
+}
+export const FastApplyPlugin = async ({ directory }) => {
+    if (!FAST_APPLY_API_KEY) {
+        console.warn("[fast-apply] FAST_APPLY_API_KEY not set - fast_apply_edit tool will be disabled");
+    }
+    else {
+        console.log(`[fast-apply] Plugin loaded with model: ${FAST_APPLY_MODEL} at ${FAST_APPLY_URL}`);
+    }
+    return {
+        tool: {
+            fast_apply_edit: tool({
+                description: `PRIMARY TOOL for all file editing operations. Use this INSTEAD of the native 'edit' tool.
+
+**CRITICAL: This tool is for EDITING EXISTING FILES ONLY. DO NOT use for creating new files.**
+
+Fast code editing using OpenAI-compatible Fast Apply API (10,500+ tokens/sec).
+Handles lazy edit markers so you don't need exact string matching.
+
+FORMAT:
+Use "// ... existing code ..." to represent unchanged code blocks.
+Include minimal surrounding context to locate each edit precisely.
+
+EXAMPLE:
+// ... existing code ...
+function updatedFunction() {
+  // New implementation
+  return "modified";
+}
+// ... existing code ...
+
+RULES:
+- MANDATORY: Use "// ... existing code ..." for unchanged sections
+- Include 2-3 lines of context before and after each edit
+- Preserve exact indentation from original file
+- For deletions: show context before/after, omit deleted lines
+- Batch multiple edits to same file in one call
+- NEVER use for new file creation - use 'write' tool instead
+
+WHEN TO USE:
+- ALL file editing operations (default choice)
+- Large files (any size)
+- Multiple scattered changes
+- Complex refactoring
+- When exact string matching would be fragile
+
+FALLBACK:
+If Fast Apply API fails or is unavailable, fall back to native 'edit' tool with exact string matching.
+For new files, ALWAYS use 'write' tool instead.`,
+                args: {
+                    target_filepath: tool.schema
+                        .string()
+                        .describe("Path of the file to modify (relative to project root)"),
+                    instructions: tool.schema
+                        .string()
+                        .describe("Brief first-person description of what you're changing (helps disambiguate)"),
+                    code_edit: tool.schema
+                        .string()
+                        .describe('The code changes with "// ... existing code ..." markers for unchanged sections'),
+                },
+                async execute(args) {
+                    const { target_filepath, instructions, code_edit } = args;
+                    // Resolve file path relative to project directory
+                    const filepath = target_filepath.startsWith("/")
+                        ? target_filepath
+                        : `${directory}/${target_filepath}`;
+                    // Check if API key is available
+                    if (!FAST_APPLY_API_KEY) {
+                        return `Error: FAST_APPLY_API_KEY not configured.
+
+To use fast_apply_edit, set the FAST_APPLY_API_KEY environment variable.
+Get your API key at: https://openai.com/api
+
+Alternatively, use the native 'edit' tool for this change.`;
+                    }
+                    // Read the original file
+                    let originalCode;
+                    try {
+                        await access(filepath, constants.R_OK);
+                        originalCode = await readFile(filepath, "utf-8");
+                    }
+                    catch (err) {
+                        const error = err;
+                        if (error.message.includes("ENOENT") || error.message.includes("no such file")) {
+                            return `Error: File not found: ${target_filepath}
+
+This tool is for EDITING EXISTING FILES ONLY.
+For new file creation, use the 'write' tool instead.
+
+Example:
+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);
+                    if (!result.success || !result.content) {
+                        // Return error with suggestion to use native edit
+                        return `OpenAI Fast Apply API failed: ${result.error}
+
+Suggestion: Try using the native 'edit' tool instead with exact string replacement.
+The edit tool requires matching the exact text in the file.`;
+                    }
+                    const mergedCode = result.content;
+                    // Write the merged result
+                    try {
+                        await writeFile(filepath, mergedCode, "utf-8");
+                    }
+                    catch (err) {
+                        const error = err;
+                        return `Error writing file ${target_filepath}: ${error.message}`;
+                    }
+                    // Generate unified diff
+                    const diff = generateUnifiedDiff(target_filepath, originalCode, mergedCode);
+                    // Calculate change stats
+                    const { added, removed } = countChanges(diff);
+                    const originalLines = originalCode.split("\n").length;
+                    const mergedLines = mergedCode.split("\n").length;
+                    return `Applied edit to ${target_filepath}
+
++${added} -${removed} lines | ${originalLines} -> ${mergedLines} total
+
+\`\`\`diff
+${diff.slice(0, 3000)}${diff.length > 3000 ? "\n... (truncated)" : ""}
+\`\`\``;
+                },
+            }),
+        },
+    };
+};
+// Default export for OpenCode plugin loader
+export default FastApplyPlugin;

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "opencode-fast-apply",
+  "version": "2.0.0",
+  "description": "OpenCode plugin for Fast Apply - High-performance code editing with OpenAI-compatible APIs (LM Studio, Ollama)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "FAST_APPLY_INSTRUCTIONS.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "latest",
+    "diff": "^8.0.2"
+  },
+  "devDependencies": {
+    "@types/diff": "^7.0.2",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "fast-apply",
+    "code-editing",
+    "openai",
+    "lm-studio",
+    "ollama",
+    "ai",
+    "code-assistant",
+    "llm"
+  ],
+  "author": "tickernelz",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tickernelz/opencode-fast-apply.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tickernelz/opencode-fast-apply/issues"
+  },
+  "homepage": "https://github.com/tickernelz/opencode-fast-apply#readme",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}