opencode-fast-apply 2.0.0 → 2.1.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 JRedeker
+Copyright (c) 2025 tickernelz
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -14,33 +14,41 @@ OpenCode plugin for Fast Apply - High-performance code editing with OpenAI-compa
 
 ## Installation
 
-### 1. Clone the repository
+### 1. Install from npm (Recommended)
 
 ```bash
-git clone https://github.com/tickernelz/opencode-fast-apply.git ~/dev/oc-plugins/fast-apply
-cd ~/dev/oc-plugins/fast-apply
-npm install
+npm install -g opencode-fast-apply
+```
+
+Or add to your OpenCode config to auto-install:
+
+```json
+{
+  "plugin": [
+    "opencode-fast-apply"
+  ]
+}
 ```
 
 ### 2. Configure your API endpoint
 
 For **LM Studio** (default):
 ```bash
-export FAST_APPLY_URL="http://localhost:1234/v1"
+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
-export FAST_APPLY_URL="http://localhost:11434/v1"
+export FAST_APPLY_URL="http://localhost:11434"
 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_URL="https://api.openai.com"
 export FAST_APPLY_MODEL="gpt-4"
 export FAST_APPLY_API_KEY="sk-your-openai-key"
 ```
@@ -49,35 +57,22 @@ export FAST_APPLY_API_KEY="sk-your-openai-key"
 
 ### 3. Add the plugin to your OpenCode config
 
-Add to your global config (`~/.config/opencode/opencode.json`):
+Add to your global config (`~/.config/opencode/opencode.json` or `opencode.jsonc`):
 
 ```json
 {
   "plugin": [
-    "/path/to/fast-apply"
-  ],
-  "instructions": [
-    "/path/to/fast-apply/FAST_APPLY_INSTRUCTIONS.md"
+    "opencode-pty",
+    "opencode-fast-apply"
   ]
 }
 ```
 
-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"
-  ]
-}
-```
+**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.
+The `fast_apply_edit` tool will now be available and configured as the default editing tool.
 
 ## Usage
 

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;AA0MvD,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;AA0YvD,eAAO,MAAM,eAAe,EAAE,MA2H7B,CAAA;AAGD,eAAe,eAAe,CAAA"}

package/dist/index.js

@@ -18,13 +18,11 @@ 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.
+- Do not include any additional text, explanations, placeholders, ellipses, or code fences.
 
 <code>{original_code}</code>
 
@@ -33,6 +31,73 @@ Instruction: {instruction}
 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.**
+
+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
+
+## Format
+Use \`// ... existing code ...\` for unchanged sections:
+
+\`\`\`
+// ... 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
+
+## Examples
+
+**Add function:**
+\`\`\`
+// ... existing code ...
+import { newDep } from './newDep';
+// ... existing code ...
+
+function newFeature() {
+  return newDep.process();
+}
+// ... existing code ...
+\`\`\`
+
+**Modify:**
+\`\`\`
+// ... existing code ...
+function existingFunc(param) {
+  const result = param * 2;
+  return result;
+}
+// ... existing code ...
+\`\`\`
+
+**Delete:**
+\`\`\`
+// ... existing code ...
+function keepThis() {
+  return "stays";
+}
+
+function alsoKeepThis() {
+  return "stays";
+}
+// ... existing code ...
+\`\`\`
+
+## Fallback
+If API fails, use native \`edit\` tool with exact string matching.`;
 function escapeXmlTags(text) {
     return text
         .replace(/<updated-code>/g, "&lt;updated-code&gt;")
@@ -45,9 +110,22 @@ function unescapeXmlTags(text) {
 }
 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) {
+    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;
+            }
+        }
+    }
+    else {
+        startIdx += startTag.length;
+    }
+    if (startIdx === -1 || startIdx === startTag.length - 1) {
         if (stripped.startsWith("```") && stripped.endsWith("```")) {
             const lines = stripped.split("\n");
             if (lines.length >= 2) {
@@ -56,7 +134,19 @@ function extractUpdatedCode(raw) {
         }
         return unescapeXmlTags(stripped);
     }
-    const inner = stripped.substring(start + UPDATED_CODE_START.length, end);
+    let endIdx = stripped.indexOf(endTag, startIdx);
+    if (endIdx === -1) {
+        endIdx = stripped.indexOf("</updated-code", startIdx);
+    }
+    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 inner = stripped.substring(startIdx, endIdx);
     if (!inner || inner.trim().length === 0) {
         throw new Error("Empty updated-code block");
     }
@@ -86,6 +176,54 @@ function countChanges(diff) {
     }
     return { added, removed };
 }
+function formatTokenCount(tokens) {
+    if (tokens >= 1000) {
+        return `${(tokens / 1000).toFixed(1)}K`.replace(".0K", "K");
+    }
+    return tokens.toString();
+}
+function shortenPath(filePath, workingDir) {
+    if (filePath.startsWith(workingDir + "/")) {
+        return filePath.slice(workingDir.length + 1);
+    }
+    if (filePath === workingDir) {
+        return ".";
+    }
+    return filePath;
+}
+function truncate(str, maxLen = 80) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 3) + "...";
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+function formatFastApplyResult(filePath, workingDir, insertions, deletions, diffPreview, modifiedTokens) {
+    const shortPath = shortenPath(filePath, workingDir);
+    const tokenStr = formatTokenCount(modifiedTokens);
+    const lines = [
+        "✓ Fast Apply complete",
+        "",
+        `File: ${shortPath}`,
+        `Changes: +${insertions} -${deletions} (~${tokenStr} tokens)`,
+        "",
+        "Unified diff:",
+        diffPreview
+    ];
+    return lines.join("\n");
+}
+function formatErrorOutput(error, filePath, workingDir) {
+    const shortPath = shortenPath(filePath, workingDir);
+    return [
+        "✗ Fast Apply failed",
+        "",
+        `File: ${shortPath}`,
+        `Error: ${error}`,
+        "",
+        "Fallback: Use native 'edit' tool with exact string matching"
+    ].join("\n");
+}
 /**
  * Call OpenAI's Fast Apply API to merge code edits
  */
@@ -102,7 +240,6 @@ async function callFastApply(originalCode, codeEdit, instructions) {
         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`, {
@@ -165,7 +302,35 @@ async function callFastApply(originalCode, codeEdit, instructions) {
         };
     }
 }
-export const FastApplyPlugin = async ({ directory }) => {
+async function sendTUINotification(client, sessionID, filePath, workingDir, insertions, deletions, modifiedTokens) {
+    const shortPath = shortenPath(filePath, workingDir);
+    const tokenStr = formatTokenCount(modifiedTokens);
+    const message = [
+        `▣ Fast Apply | ~${tokenStr} tokens modified`,
+        "",
+        "Applied changes:",
+        `→ ${shortPath}: +${insertions} -${deletions}`
+    ].join("\n");
+    try {
+        await client.session.prompt({
+            path: { id: sessionID },
+            body: {
+                noReply: true,
+                parts: [
+                    {
+                        type: "text",
+                        text: message,
+                        ignored: true,
+                    },
+                ],
+            },
+        });
+    }
+    catch (error) {
+        console.error("[fast-apply] Failed to send TUI notification:", error.message);
+    }
+}
+export const FastApplyPlugin = async ({ directory, client }) => {
     if (!FAST_APPLY_API_KEY) {
         console.warn("[fast-apply] FAST_APPLY_API_KEY not set - fast_apply_edit tool will be disabled");
     }
@@ -175,43 +340,7 @@ export const FastApplyPlugin = async ({ directory }) => {
     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.`,
+                description: TOOL_INSTRUCTIONS,
                 args: {
                     target_filepath: tool.schema
                         .string()
@@ -223,7 +352,7 @@ For new files, ALWAYS use 'write' tool instead.`,
                         .string()
                         .describe('The code changes with "// ... existing code ..." markers for unchanged sections'),
                 },
-                async execute(args) {
+                async execute(args, toolCtx) {
                     const { target_filepath, instructions, code_edit } = args;
                     // Resolve file path relative to project directory
                     const filepath = target_filepath.startsWith("/")
@@ -263,34 +392,21 @@ write({
                     // 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.`;
+                        return formatErrorOutput(result.error || "Unknown error", target_filepath, directory);
                     }
                     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}`;
+                        return formatErrorOutput(error.message, target_filepath, directory);
                     }
-                    // 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)" : ""}
-\`\`\``;
+                    const modifiedTokens = estimateTokens(diff);
+                    await sendTUINotification(client, toolCtx.sessionID, target_filepath, directory, added, removed, modifiedTokens);
+                    return formatFastApplyResult(target_filepath, directory, added, removed, diff, modifiedTokens);
                 },
             }),
         },

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "opencode-fast-apply",
-  "version": "2.0.0",
+  "version": "2.1.2",
   "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"
   ],
@@ -40,7 +39,7 @@
   "author": "tickernelz",
   "repository": {
     "type": "git",
-    "url": "https://github.com/tickernelz/opencode-fast-apply.git"
+    "url": "git+https://github.com/tickernelz/opencode-fast-apply.git"
   },
   "bugs": {
     "url": "https://github.com/tickernelz/opencode-fast-apply/issues"
@@ -50,4 +49,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}

package/FAST_APPLY_INSTRUCTIONS.md

@@ -1,121 +0,0 @@
-# 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