opencode-gbk-tools 0.1.10 → 0.1.12

package/dist/plugin/index.js

@@ -16306,6 +16306,82 @@ async function assertPathAllowed(filePath, context, allowExternal = false) {
 
 // src/lib/gbk-file.ts
 var STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
+function assertStringArgument(value, name) {
+  if (typeof value !== "string") {
+    throw createGbkError("GBK_INVALID_ARGUMENT", `${name} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  }
+}
+function assertReplaceArguments(input) {
+  assertStringArgument(input.oldString, "oldString");
+  assertStringArgument(input.newString, "newString");
+}
+function assertInsertArguments(input) {
+  assertStringArgument(input.anchor, "anchor");
+  assertStringArgument(input.content, "content");
+  if (input.content.length === 0) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "content \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (input.replaceAll !== void 0) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u6A21\u5F0F\u4E0D\u652F\u6301 replaceAll");
+  }
+  if (input.startLine !== void 0 || input.endLine !== void 0 || input.startAnchor !== void 0 || input.endAnchor !== void 0) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u6A21\u5F0F\u4E0D\u652F\u6301 startLine/endLine/startAnchor/endAnchor");
+  }
+}
+function findOccurrenceIndex(text, token, occurrence) {
+  assertStringArgument(text, "text");
+  assertStringArgument(token, "anchor");
+  assertPositiveInteger(occurrence, "occurrence");
+  if (token.length === 0) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  let count = 0;
+  let searchFrom = 0;
+  while (true) {
+    const index = text.indexOf(token, searchFrom);
+    if (index === -1) {
+      break;
+    }
+    count += 1;
+    if (count === occurrence) {
+      return { index, total: countOccurrences(text, token) };
+    }
+    searchFrom = index + token.length;
+  }
+  if (count === 0) {
+    throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\u70B9: ${token}`);
+  }
+  throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\u5230 ${count} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7B2C ${occurrence} \u5904`);
+}
+function insertByAnchor(text, mode, anchor, content, occurrence, ifExists, newlineStyle) {
+  const alignedContent = newlineStyle === "crlf" ? content.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n") : newlineStyle === "lf" ? content.replace(/\r\n/g, "\n") : content;
+  const located = findOccurrenceIndex(text, anchor, occurrence);
+  const insertionPoint = mode === "insertAfter" ? located.index + anchor.length : located.index;
+  const alreadyExists = mode === "insertAfter" ? text.slice(insertionPoint, insertionPoint + alignedContent.length) === alignedContent : text.slice(Math.max(0, insertionPoint - alignedContent.length), insertionPoint) === alignedContent;
+  if (alreadyExists) {
+    if (ifExists === "error") {
+      throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\u5BB9");
+    }
+    if (ifExists === "skip") {
+      return {
+        outputText: text,
+        inserted: false,
+        skipped: true,
+        anchorMatches: located.total,
+        occurrence,
+        anchor
+      };
+    }
+  }
+  return {
+    outputText: `${text.slice(0, insertionPoint)}${alignedContent}${text.slice(insertionPoint)}`,
+    inserted: true,
+    skipped: false,
+    anchorMatches: located.total,
+    occurrence,
+    anchor
+  };
+}
 function assertEncodingSupported(encoding) {
   if (encoding !== "gbk" && encoding !== "gb18030") {
     throw createGbkError("GBK_INVALID_ENCODING", `\u4E0D\u652F\u6301\u7684\u7F16\u7801: ${encoding}`);
@@ -16475,9 +16551,11 @@ function resolveEditScope(text, input) {
   };
 }
 function normalizeNewlines(text) {
+  assertStringArgument(text, "text");
   return text.replace(/\r\n/g, "\n");
 }
 function trimRightSpaces(text) {
+  assertStringArgument(text, "text");
   return text.replace(/[ \t]+$/g, "");
 }
 function splitNormalizedLines(text) {
@@ -16573,6 +16651,8 @@ function tryLooseBlockReplace(content, oldString, newString) {
   return null;
 }
 function countOccurrences(text, target) {
+  assertStringArgument(text, "text");
+  assertStringArgument(target, "oldString");
   if (target.length === 0) {
     throw createGbkError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
   }
@@ -16888,11 +16968,56 @@ async function readGbkFile(input) {
   };
 }
 async function replaceGbkFileText(input) {
+  const mode = input.mode ?? "replace";
   const normalizedInput = {
     ...input,
     startLine: normalizeOptionalPositiveInteger(input.startLine, "startLine"),
     endLine: normalizeOptionalPositiveInteger(input.endLine, "endLine")
   };
+  if (mode === "insertAfter" || mode === "insertBefore") {
+    assertInsertArguments(input);
+    const resolved2 = await resolveReadableGbkFile(normalizedInput);
+    const current2 = await readWholeGbkTextFile(resolved2);
+    const occurrence = normalizeOptionalPositiveInteger(input.occurrence, "occurrence") ?? 1;
+    const insertResult = insertByAnchor(
+      current2.content,
+      mode,
+      input.anchor,
+      input.content,
+      occurrence,
+      input.ifExists ?? "skip",
+      detectNewlineStyle(current2.content)
+    );
+    if (insertResult.skipped) {
+      return {
+        mode,
+        filePath: current2.filePath,
+        encoding: current2.encoding,
+        anchor: insertResult.anchor,
+        occurrence: insertResult.occurrence,
+        anchorMatches: insertResult.anchorMatches,
+        inserted: false,
+        skipped: true,
+        bytesRead: current2.bytesRead,
+        bytesWritten: 0
+      };
+    }
+    const buffer2 = import_iconv_lite.default.encode(insertResult.outputText, current2.encoding);
+    await fs2.writeFile(current2.filePath, buffer2);
+    return {
+      mode,
+      filePath: current2.filePath,
+      encoding: current2.encoding,
+      anchor: insertResult.anchor,
+      occurrence: insertResult.occurrence,
+      anchorMatches: insertResult.anchorMatches,
+      inserted: true,
+      skipped: false,
+      bytesRead: current2.bytesRead,
+      bytesWritten: buffer2.byteLength
+    };
+  }
+  assertReplaceArguments(input);
   if (input.oldString.length === 0) {
     throw createGbkError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
   }
@@ -16909,14 +17034,15 @@ async function replaceGbkFileText(input) {
   }
   const current = await readWholeGbkTextFile(resolved);
   const scope = resolveEditScope(current.content, normalizedInput);
-  const occurrencesBefore = countOccurrences(scope.selectedText, normalizedInput.oldString);
+  const occurrencesBefore = countOccurrences(scope.selectedText, input.oldString);
   if (!replaceAll && occurrencesBefore === 0) {
-    const loose = tryLooseBlockReplace(scope.selectedText, normalizedInput.oldString, normalizedInput.newString);
+    const loose = tryLooseBlockReplace(scope.selectedText, input.oldString, input.newString);
     if (loose !== null) {
       const outputText2 = `${current.content.slice(0, scope.rangeStart)}${loose.content}${current.content.slice(scope.rangeEnd)}`;
       const buffer2 = import_iconv_lite.default.encode(outputText2, current.encoding);
       await fs2.writeFile(current.filePath, buffer2);
       return {
+        mode: "replace",
         filePath: current.filePath,
         encoding: current.encoding,
         replacements: 1,
@@ -16928,20 +17054,21 @@ async function replaceGbkFileText(input) {
   }
   if (replaceAll) {
     if (occurrencesBefore === 0) {
-      throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, normalizedInput.oldString));
+      throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
     }
   } else if (occurrencesBefore === 0) {
-    throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, normalizedInput.oldString));
+    throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
   } else if (occurrencesBefore > 1) {
-    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${normalizedInput.oldString}`);
+    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
   }
   const fileNewlineStyle = detectNewlineStyle(current.content);
-  const alignedNewString = fileNewlineStyle === "crlf" ? normalizedInput.newString.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n") : fileNewlineStyle === "lf" ? normalizedInput.newString.replace(/\r\n/g, "\n") : normalizedInput.newString;
-  const replaced = replaceAll ? scope.selectedText.split(normalizedInput.oldString).join(alignedNewString) : scope.selectedText.replace(normalizedInput.oldString, alignedNewString);
+  const alignedNewString = fileNewlineStyle === "crlf" ? input.newString.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n") : fileNewlineStyle === "lf" ? input.newString.replace(/\r\n/g, "\n") : input.newString;
+  const replaced = replaceAll ? scope.selectedText.split(input.oldString).join(alignedNewString) : scope.selectedText.replace(input.oldString, alignedNewString);
   const outputText = `${current.content.slice(0, scope.rangeStart)}${replaced}${current.content.slice(scope.rangeEnd)}`;
   const buffer = import_iconv_lite.default.encode(outputText, current.encoding);
   await fs2.writeFile(current.filePath, buffer);
   return {
+    mode: "replace",
     filePath: current.filePath,
     encoding: current.encoding,
     replacements: replaceAll ? occurrencesBefore : 1,
@@ -17105,11 +17232,20 @@ Recommended workflow for large files (when gbk_read returned truncated=true):
 3. gbk_edit(oldString=<content without prefixes>, newString=<new content>)
 
 For large files, use 'startLine'/'endLine' or 'startAnchor'/'endAnchor' to narrow the search scope
-and avoid false matches. Scoped edits also improve performance on very large files.`,
+and avoid false matches. Scoped edits also improve performance on very large files.
+
+Insert mode:
+- Use mode=insertAfter or mode=insertBefore with anchor/content
+- This is recommended when the intent is "insert after label" instead of exact replacement.`,
   args: {
     filePath: tool.schema.string().describe("Target file path"),
-    oldString: tool.schema.string().describe("Exact text to replace \u2014 raw file content only, no 'N: ' line number prefixes from gbk_read output"),
-    newString: tool.schema.string().describe("Replacement text \u2014 raw content only, no line number prefixes"),
+    mode: tool.schema.enum(["replace", "insertAfter", "insertBefore"]).optional().describe("Edit mode, default replace"),
+    oldString: tool.schema.string().optional().describe("Exact text to replace in replace mode"),
+    newString: tool.schema.string().optional().describe("Replacement text in replace mode"),
+    anchor: tool.schema.string().optional().describe("Anchor text used by insertAfter/insertBefore"),
+    content: tool.schema.string().optional().describe("Inserted content used by insertAfter/insertBefore"),
+    occurrence: tool.schema.number().int().positive().optional().describe("1-based anchor occurrence for insert mode"),
+    ifExists: tool.schema.enum(["allow", "skip", "error"]).optional().describe("What to do when inserted content already exists at target position"),
     replaceAll: tool.schema.boolean().optional().describe("Replace all occurrences (default: false, requires unique match)"),
     startLine: tool.schema.union([tool.schema.number().int().positive(), tool.schema.literal(-1)]).optional().describe("Restrict edit scope to 1-based start line (inclusive)"),
     endLine: tool.schema.union([tool.schema.number().int().positive(), tool.schema.literal(-1)]).optional().describe("Restrict edit scope to 1-based end line (inclusive)"),
@@ -17120,13 +17256,21 @@ and avoid false matches. Scoped edits also improve performance on very large fil
   },
   async execute(args, context) {
     const result = await replaceGbkFileText({ ...args, context });
+    const isReplace = !("mode" in result) || result.mode === "replace";
+    const title = isReplace ? `GBK \u7F16\u8F91 ${result.encoding.toUpperCase()} x${result.replacements}` : result.inserted ? `GBK \u63D2\u5165 ${result.encoding.toUpperCase()} #${result.occurrence}` : `GBK \u8DF3\u8FC7 ${result.encoding.toUpperCase()} #${result.occurrence}`;
     context.metadata({
-      title: `GBK \u7F16\u8F91 ${result.encoding.toUpperCase()} x${result.replacements}`,
+      title,
       metadata: {
         filePath: result.filePath,
         encoding: result.encoding,
-        replacements: result.replacements,
-        occurrencesBefore: result.occurrencesBefore,
+        mode: isReplace ? "replace" : result.mode,
+        replacements: isReplace ? result.replacements : void 0,
+        occurrencesBefore: isReplace ? result.occurrencesBefore : void 0,
+        anchor: isReplace ? void 0 : result.anchor,
+        occurrence: isReplace ? void 0 : result.occurrence,
+        anchorMatches: isReplace ? void 0 : result.anchorMatches,
+        inserted: isReplace ? void 0 : result.inserted,
+        skipped: isReplace ? void 0 : result.skipped,
         bytesRead: result.bytesRead,
         bytesWritten: result.bytesWritten
       }
@@ -17265,6 +17409,8 @@ var TEXT_TOOL_SYSTEM_PROMPT = [
   "\u6587\u672C\u6587\u4EF6\u5904\u7406\u89C4\u5219\uFF1A",
   "- \u5904\u7406\u6587\u672C\u6587\u4EF6\u65F6\uFF0C\u4F18\u5148\u4F7F\u7528 text_read\u3001text_write\u3001text_edit\u3002",
   "- text_* \u9ED8\u8BA4\u4F1A\u81EA\u52A8\u8BC6\u522B\u73B0\u6709\u6587\u4EF6\u7F16\u7801\uFF0C\u5E76\u5728\u4FEE\u6539\u65F6\u5C3D\u91CF\u4FDD\u6301\u539F\u7F16\u7801\u3001BOM \u548C\u6362\u884C\u98CE\u683C\u3002",
+  "- \u5982\u679C\u610F\u56FE\u662F\u2018\u5728\u67D0\u6807\u7B7E\u524D\u540E\u63D2\u5165\u5185\u5BB9\u2019\uFF0C\u4F18\u5148\u4F7F\u7528 mode=insertAfter \u6216 mode=insertBefore\uFF0C\u5E76\u4F20 anchor/content\u3002",
+  "- \u53EA\u6709\u5728\u660E\u786E\u505A\u7CBE\u786E\u66FF\u6362\u65F6\uFF0C\u624D\u4F7F\u7528 oldString/newString\u3002",
   "- \u82E5\u68C0\u6D4B\u7F6E\u4FE1\u5EA6\u4E0D\u8DB3\u6216\u51FA\u73B0 TEXT_UNKNOWN_ENCODING\uFF0C\u8BF7\u663E\u5F0F\u6307\u5B9A encoding \u540E\u91CD\u8BD5\u3002",
   "- \u5904\u7406\u660E\u786E\u7684 GBK/GB18030 \u6587\u4EF6\u65F6\uFF0C\u4E5F\u53EF\u7EE7\u7EED\u4F7F\u7528 gbk_read\u3001gbk_write\u3001gbk_edit\u3001gbk_search\u3002"
 ].join("\n");
@@ -17281,6 +17427,25 @@ import fs3 from "fs/promises";
 import path3 from "path";
 var TEXT_STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
 var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+function assertStringArgument2(value, name) {
+  if (typeof value !== "string") {
+    throw createTextError("GBK_INVALID_ARGUMENT", `${name} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  }
+}
+function assertReplaceArguments2(input) {
+  assertStringArgument2(input.oldString, "oldString");
+  assertStringArgument2(input.newString, "newString");
+}
+function resolveEditMode(mode) {
+  return mode ?? "replace";
+}
+function resolveInsertIfExists(value) {
+  return value ?? "skip";
+}
+function resolveExplicitTextEncoding(value, fallback) {
+  const requested = value ?? "auto";
+  return requested === "auto" ? fallback : requested;
+}
 function isSupportedEncoding(value) {
   return value === "utf8" || value === "utf8-bom" || value === "utf16le" || value === "utf16be" || value === "gbk" || value === "gb18030";
 }
@@ -17399,6 +17564,8 @@ function assertLikelyTextBuffer(buffer) {
   throw createTextError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\u6309\u6587\u672C\u5904\u7406");
 }
 function getNearestContext2(content, oldString) {
+  assertStringArgument2(content, "content");
+  assertStringArgument2(oldString, "oldString");
   const lines = content.split(/\r?\n/);
   const oldLines = oldString.replace(/\r\n/g, "\n").split("\n").filter(Boolean);
   const firstToken = oldLines[0] || oldString.trim();
@@ -17410,6 +17577,8 @@ function getNearestContext2(content, oldString) {
   return lines.slice(0, 4).join("\n");
 }
 function buildNoMatchMessage2(content, oldString) {
+  assertStringArgument2(content, "content");
+  assertStringArgument2(oldString, "oldString");
   return [
     "\u672A\u627E\u5230\u9700\u8981\u66FF\u6362\u7684\u6587\u672C\u3002",
     "oldString \u5FC5\u987B\u4E0E\u6587\u4EF6\u5B9E\u9645\u5185\u5BB9\u5B8C\u5168\u5BF9\u5E94\u3002",
@@ -17417,6 +17586,105 @@ function buildNoMatchMessage2(content, oldString) {
     getNearestContext2(content, oldString)
   ].join("\n");
 }
+function findOccurrenceIndex2(text, token, occurrence) {
+  assertStringArgument2(text, "text");
+  assertStringArgument2(token, "anchor");
+  assertPositiveInteger(occurrence, "occurrence");
+  if (token.length === 0) {
+    throw createTextError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  let count = 0;
+  let searchFrom = 0;
+  while (true) {
+    const index = text.indexOf(token, searchFrom);
+    if (index === -1) {
+      break;
+    }
+    count += 1;
+    if (count === occurrence) {
+      return { index, total: countOccurrences(text, token) };
+    }
+    searchFrom = index + token.length;
+  }
+  if (count === 0) {
+    throw createTextError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\u70B9: ${token}`);
+  }
+  throw createTextError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\u5230 ${count} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7B2C ${occurrence} \u5904`);
+}
+function assertInsertArguments2(input) {
+  assertStringArgument2(input.anchor, "anchor");
+  assertStringArgument2(input.content, "content");
+  if (input.content.length === 0) {
+    throw createTextError("GBK_INVALID_ARGUMENT", "content \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (input.replaceAll !== void 0) {
+    throw createTextError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u6A21\u5F0F\u4E0D\u652F\u6301 replaceAll");
+  }
+  if (input.startLine !== void 0 || input.endLine !== void 0 || input.startAnchor !== void 0 || input.endAnchor !== void 0) {
+    throw createTextError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u6A21\u5F0F\u4E0D\u652F\u6301 startLine/endLine/startAnchor/endAnchor");
+  }
+}
+function buildLineDiffPreview(filePath, encoding, beforeText, afterText) {
+  const beforeLines = normalizeNewlines2(beforeText).split("\n");
+  const afterLines = normalizeNewlines2(afterText).split("\n");
+  const maxLines = Math.max(beforeLines.length, afterLines.length);
+  const lines = [
+    `--- ${path3.basename(filePath)} (${encoding})`,
+    `+++ ${path3.basename(filePath)} (${encoding})`
+  ];
+  for (let index = 0; index < maxLines; index += 1) {
+    const before = beforeLines[index];
+    const after = afterLines[index];
+    if (before !== void 0 && after !== void 0 && before === after) {
+      lines.push(` ${before}`);
+      continue;
+    }
+    if (before !== void 0) {
+      lines.push(`-${before}`);
+    }
+    if (after !== void 0) {
+      lines.push(`+${after}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildInsertOutput(text, mode, anchor, content, occurrence, ifExists, newlineStyle) {
+  const alignedContent = alignTextToNewlineStyle(content, newlineStyle);
+  const located = findOccurrenceIndex2(text, anchor, occurrence);
+  const insertionPoint = mode === "insertAfter" ? located.index + anchor.length : located.index;
+  const alreadyExists = mode === "insertAfter" ? text.slice(insertionPoint, insertionPoint + alignedContent.length) === alignedContent : text.slice(Math.max(0, insertionPoint - alignedContent.length), insertionPoint) === alignedContent;
+  if (alreadyExists) {
+    if (ifExists === "error") {
+      throw createTextError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\u5BB9");
+    }
+    if (ifExists === "skip") {
+      return {
+        outputText: text,
+        inserted: false,
+        skipped: true,
+        anchorMatches: located.total,
+        occurrence,
+        anchor,
+        previewBefore: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + anchor.length + 80)),
+        previewAfter: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + anchor.length + 80))
+      };
+    }
+  }
+  const outputText = `${text.slice(0, insertionPoint)}${alignedContent}${text.slice(insertionPoint)}`;
+  const previewStart = Math.max(0, insertionPoint - 80);
+  const previewBeforeEnd = Math.min(text.length, insertionPoint + 80);
+  const previewAfterEnd = Math.min(outputText.length, insertionPoint + alignedContent.length + 80);
+  return {
+    outputText,
+    inserted: true,
+    skipped: false,
+    anchorMatches: located.total,
+    occurrence,
+    anchor,
+    previewBefore: text.slice(previewStart, previewBeforeEnd),
+    previewAfter: outputText.slice(previewStart, previewAfterEnd)
+  };
+}
 function detectTextEncodingFromBuffer(buffer, requestedEncoding = "auto") {
   if (requestedEncoding !== "auto") {
     assertTextEncodingSupported(requestedEncoding);
@@ -17607,6 +17875,7 @@ function resolveEditScope2(text, input) {
   };
 }
 function alignTextToNewlineStyle(text, newlineStyle) {
+  assertStringArgument2(text, "text");
   const normalized = text.replace(/\r\n/g, "\n");
   if (newlineStyle === "crlf") {
     return normalized.replace(/\n/g, "\r\n");
@@ -17617,6 +17886,7 @@ function alignTextToNewlineStyle(text, newlineStyle) {
   return text;
 }
 function ensureLossless(input, encoding, hasBom = encoding === "utf8-bom") {
+  assertStringArgument2(input, "content");
   const buffer = encodeText(input, encoding, hasBom);
   const roundTrip = decodeText(buffer, encoding);
   if (roundTrip !== input) {
@@ -17668,6 +17938,7 @@ async function readTextFile(input) {
   };
 }
 async function writeTextFile(input) {
+  assertStringArgument2(input.content, "content");
   const requestedEncoding = input.encoding ?? "auto";
   assertTextEncodingSupported(requestedEncoding);
   const preserveEncoding = input.preserveEncoding ?? true;
@@ -17717,43 +17988,100 @@ async function writeTextFile(input) {
   };
 }
 async function replaceTextFileText(input) {
+  const mode = resolveEditMode(input.mode);
   const normalizedInput = {
     ...input,
     startLine: normalizeOptionalPositiveInteger(input.startLine, "startLine"),
     endLine: normalizeOptionalPositiveInteger(input.endLine, "endLine")
   };
-  if (input.oldString.length === 0) {
-    throw createTextError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
-  }
   const loaded = await readWholeTextFile({
     filePath: input.filePath,
     encoding: input.encoding ?? "auto",
     allowExternal: input.allowExternal,
     context: input.context
   });
+  if (mode === "insertAfter" || mode === "insertBefore") {
+    assertInsertArguments2(normalizedInput);
+    const occurrence = normalizeOptionalPositiveInteger(normalizedInput.occurrence, "occurrence") ?? 1;
+    const insertResult = buildInsertOutput(
+      loaded.content,
+      mode,
+      normalizedInput.anchor,
+      normalizedInput.content,
+      occurrence,
+      resolveInsertIfExists(normalizedInput.ifExists),
+      loaded.newlineStyle
+    );
+    if (insertResult.skipped) {
+      return {
+        mode,
+        filePath: loaded.filePath,
+        encoding: loaded.encoding,
+        requestedEncoding: loaded.requestedEncoding,
+        detectedEncoding: loaded.detectedEncoding,
+        confidence: loaded.confidence,
+        hasBom: loaded.hasBom,
+        anchor: insertResult.anchor,
+        occurrence: insertResult.occurrence,
+        anchorMatches: insertResult.anchorMatches,
+        inserted: false,
+        skipped: true,
+        bytesRead: loaded.bytesRead,
+        bytesWritten: 0,
+        newlineStyle: loaded.newlineStyle
+      };
+    }
+    const targetEncoding2 = (normalizedInput.preserveEncoding ?? true) || (normalizedInput.encoding ?? "auto") === "auto" ? loaded.encoding : resolveExplicitTextEncoding(normalizedInput.encoding, loaded.encoding);
+    const targetHasBom2 = normalizedInput.preserveEncoding === false ? targetEncoding2 === "utf8-bom" || targetEncoding2 === "utf16le" || targetEncoding2 === "utf16be" : loaded.hasBom;
+    ensureLossless(insertResult.outputText, targetEncoding2, targetHasBom2);
+    const buffer2 = encodeText(insertResult.outputText, targetEncoding2, targetHasBom2);
+    await fs3.writeFile(loaded.filePath, buffer2);
+    return {
+      mode,
+      filePath: loaded.filePath,
+      encoding: targetEncoding2,
+      requestedEncoding: loaded.requestedEncoding,
+      detectedEncoding: loaded.detectedEncoding,
+      confidence: loaded.confidence,
+      hasBom: targetHasBom2,
+      anchor: insertResult.anchor,
+      occurrence: insertResult.occurrence,
+      anchorMatches: insertResult.anchorMatches,
+      inserted: true,
+      skipped: false,
+      bytesRead: loaded.bytesRead,
+      bytesWritten: buffer2.byteLength,
+      newlineStyle: detectNewlineStyle(insertResult.outputText)
+    };
+  }
+  assertReplaceArguments2(input);
+  if (input.oldString.length === 0) {
+    throw createTextError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
+  }
   const scope = resolveEditScope2(loaded.content, normalizedInput);
   const replaceAll = normalizedInput.replaceAll ?? false;
   const preserveEncoding = normalizedInput.preserveEncoding ?? true;
   const requestedEncoding = normalizedInput.encoding ?? "auto";
-  const occurrencesBefore = countOccurrences(scope.selectedText, normalizedInput.oldString);
+  const occurrencesBefore = countOccurrences(scope.selectedText, input.oldString);
   if (replaceAll) {
     if (occurrencesBefore === 0) {
-      throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, normalizedInput.oldString));
+      throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, input.oldString));
     }
   } else if (occurrencesBefore === 0) {
-    throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, normalizedInput.oldString));
+    throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, input.oldString));
   } else if (occurrencesBefore > 1) {
-    throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${normalizedInput.oldString}`);
+    throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
   }
-  const alignedNewString = normalizedInput.preserveNewlineStyle === false ? normalizedInput.newString : alignTextToNewlineStyle(normalizedInput.newString, loaded.newlineStyle);
-  const replaced = replaceAll ? scope.selectedText.split(normalizedInput.oldString).join(alignedNewString) : scope.selectedText.replace(normalizedInput.oldString, alignedNewString);
+  const alignedNewString = normalizedInput.preserveNewlineStyle === false ? input.newString : alignTextToNewlineStyle(input.newString, loaded.newlineStyle);
+  const replaced = replaceAll ? scope.selectedText.split(input.oldString).join(alignedNewString) : scope.selectedText.replace(input.oldString, alignedNewString);
   const outputText = `${loaded.content.slice(0, scope.rangeStart)}${replaced}${loaded.content.slice(scope.rangeEnd)}`;
-  const targetEncoding = preserveEncoding || requestedEncoding === "auto" ? loaded.encoding : requestedEncoding;
+  const targetEncoding = preserveEncoding || requestedEncoding === "auto" ? loaded.encoding : resolveExplicitTextEncoding(requestedEncoding, loaded.encoding);
   const targetHasBom = preserveEncoding ? loaded.hasBom : targetEncoding === "utf8-bom" || targetEncoding === "utf16le" || targetEncoding === "utf16be";
   ensureLossless(outputText, targetEncoding, targetHasBom);
   const buffer = encodeText(outputText, targetEncoding, targetHasBom);
   await fs3.writeFile(loaded.filePath, buffer);
   return {
+    mode: "replace",
     filePath: loaded.filePath,
     encoding: targetEncoding,
     requestedEncoding: loaded.requestedEncoding,
@@ -17768,40 +18096,39 @@ async function replaceTextFileText(input) {
   };
 }
 async function createTextDiffPreview(input) {
+  const mode = resolveEditMode(input.mode);
   const loaded = await readWholeTextFile({
     filePath: input.filePath,
     encoding: input.encoding ?? "auto",
     allowExternal: input.allowExternal,
     context: input.context
   });
+  if (mode === "insertAfter" || mode === "insertBefore") {
+    assertInsertArguments2(input);
+    const occurrence = normalizeOptionalPositiveInteger(input.occurrence, "occurrence") ?? 1;
+    const insertResult = buildInsertOutput(
+      loaded.content,
+      mode,
+      input.anchor,
+      input.content,
+      occurrence,
+      resolveInsertIfExists(input.ifExists),
+      loaded.newlineStyle
+    );
+    return {
+      filePath: loaded.filePath,
+      encoding: loaded.encoding,
+      preview: buildLineDiffPreview(loaded.filePath, loaded.encoding, insertResult.previewBefore, insertResult.previewAfter)
+    };
+  }
+  assertReplaceArguments2(input);
   const scope = resolveEditScope2(loaded.content, input);
   const alignedNewString = alignTextToNewlineStyle(input.newString, loaded.newlineStyle);
   const replaced = input.replaceAll ?? false ? scope.selectedText.split(input.oldString).join(alignedNewString) : scope.selectedText.replace(input.oldString, alignedNewString);
-  const beforeLines = normalizeNewlines2(scope.selectedText).split("\n");
-  const afterLines = normalizeNewlines2(replaced).split("\n");
-  const maxLines = Math.max(beforeLines.length, afterLines.length);
-  const lines = [
-    `--- ${path3.basename(loaded.filePath)} (${loaded.encoding})`,
-    `+++ ${path3.basename(loaded.filePath)} (${loaded.encoding})`
-  ];
-  for (let index = 0; index < maxLines; index += 1) {
-    const before = beforeLines[index];
-    const after = afterLines[index];
-    if (before !== void 0 && after !== void 0 && before === after) {
-      lines.push(` ${before}`);
-      continue;
-    }
-    if (before !== void 0) {
-      lines.push(`-${before}`);
-    }
-    if (after !== void 0) {
-      lines.push(`+${after}`);
-    }
-  }
   return {
     filePath: loaded.filePath,
     encoding: loaded.encoding,
-    preview: lines.join("\n")
+    preview: buildLineDiffPreview(loaded.filePath, loaded.encoding, scope.selectedText, replaced)
   };
 }
 
@@ -17811,11 +18138,17 @@ var text_edit_default = tool({
 
 - Existing files keep their original encoding and BOM by default.
 - Existing newline style is preserved by default.
-- Use startLine/endLine or anchors to narrow the edit scope.`,
+- Replace mode uses oldString/newString.
+- Insert mode uses mode=insertAfter or insertBefore with anchor/content.`,
   args: {
     filePath: tool.schema.string().describe("Target file path"),
-    oldString: tool.schema.string().describe("Exact text to replace"),
-    newString: tool.schema.string().describe("Replacement text"),
+    mode: tool.schema.enum(["replace", "insertAfter", "insertBefore"]).optional().describe("Edit mode, default replace"),
+    oldString: tool.schema.string().optional().describe("Exact text to replace when mode=replace"),
+    newString: tool.schema.string().optional().describe("Replacement text when mode=replace"),
+    anchor: tool.schema.string().optional().describe("Anchor text used by insertAfter/insertBefore"),
+    content: tool.schema.string().optional().describe("Inserted content used by insertAfter/insertBefore"),
+    occurrence: tool.schema.number().int().positive().optional().describe("1-based anchor occurrence for insert mode"),
+    ifExists: tool.schema.enum(["allow", "skip", "error"]).optional().describe("What to do when inserted content already exists at target position"),
     replaceAll: tool.schema.boolean().optional().describe("Replace all occurrences"),
     startLine: tool.schema.number().int().positive().optional().describe("Start line for scoped edit"),
     endLine: tool.schema.number().int().positive().optional().describe("End line for scoped edit"),
@@ -17829,16 +18162,23 @@ var text_edit_default = tool({
   async execute(args, context) {
     const result = await replaceTextFileText({ ...args, context });
     const preview = await createTextDiffPreview({ ...args, context });
+    const title = result.mode === "replace" ? `\u6587\u672C\u7F16\u8F91 ${result.encoding.toUpperCase()} x${result.replacements}` : result.inserted ? `\u6587\u672C\u63D2\u5165 ${result.encoding.toUpperCase()} #${result.occurrence}` : `\u6587\u672C\u8DF3\u8FC7 ${result.encoding.toUpperCase()} #${result.occurrence}`;
     context.metadata({
-      title: `\u6587\u672C\u7F16\u8F91 ${result.encoding.toUpperCase()} x${result.replacements}`,
+      title,
       metadata: {
         filePath: result.filePath,
         encoding: result.encoding,
         requestedEncoding: result.requestedEncoding,
         confidence: result.confidence,
         hasBom: result.hasBom,
-        replacements: result.replacements,
-        occurrencesBefore: result.occurrencesBefore,
+        mode: result.mode,
+        replacements: result.mode === "replace" ? result.replacements : void 0,
+        occurrencesBefore: result.mode === "replace" ? result.occurrencesBefore : void 0,
+        anchor: result.mode === "replace" ? void 0 : result.anchor,
+        occurrence: result.mode === "replace" ? void 0 : result.occurrence,
+        anchorMatches: result.mode === "replace" ? void 0 : result.anchorMatches,
+        inserted: result.mode === "replace" ? void 0 : result.inserted,
+        skipped: result.mode === "replace" ? void 0 : result.skipped,
         newlineStyle: result.newlineStyle,
         diffPreview: preview.preview
       }

package/dist/plugins/opencode-gbk-tools.js

@@ -5,6 +5,8 @@ var TEXT_TOOL_SYSTEM_PROMPT = [
   "\u6587\u672C\u6587\u4EF6\u5904\u7406\u89C4\u5219\uFF1A",
   "- \u5904\u7406\u6587\u672C\u6587\u4EF6\u65F6\uFF0C\u4F18\u5148\u4F7F\u7528 text_read\u3001text_write\u3001text_edit\u3002",
   "- text_* \u9ED8\u8BA4\u4F1A\u81EA\u52A8\u8BC6\u522B\u73B0\u6709\u6587\u4EF6\u7F16\u7801\uFF0C\u5E76\u5728\u4FEE\u6539\u65F6\u5C3D\u91CF\u4FDD\u6301\u539F\u7F16\u7801\u3001BOM \u548C\u6362\u884C\u98CE\u683C\u3002",
+  "- \u5982\u679C\u610F\u56FE\u662F\u2018\u5728\u67D0\u6807\u7B7E\u524D\u540E\u63D2\u5165\u5185\u5BB9\u2019\uFF0C\u4F18\u5148\u4F7F\u7528 mode=insertAfter \u6216 mode=insertBefore\uFF0C\u5E76\u4F20 anchor/content\u3002",
+  "- \u53EA\u6709\u5728\u660E\u786E\u505A\u7CBE\u786E\u66FF\u6362\u65F6\uFF0C\u624D\u4F7F\u7528 oldString/newString\u3002",
   "- \u82E5\u68C0\u6D4B\u7F6E\u4FE1\u5EA6\u4E0D\u8DB3\u6216\u51FA\u73B0 TEXT_UNKNOWN_ENCODING\uFF0C\u8BF7\u663E\u5F0F\u6307\u5B9A encoding \u540E\u91CD\u8BD5\u3002",
   "- \u5904\u7406\u660E\u786E\u7684 GBK/GB18030 \u6587\u4EF6\u65F6\uFF0C\u4E5F\u53EF\u7EE7\u7EED\u4F7F\u7528 gbk_read\u3001gbk_write\u3001gbk_edit\u3001gbk_search\u3002"
 ].join("\n");