opencode-gbk-tools 0.1.1 → 0.1.3

package/dist/opencode-tools/gbk_edit.js

@@ -182,7 +182,7 @@ var require_internal = __commonJS({
       // Codec.
       _internal: InternalCodec
     };
-    function InternalCodec(codecOptions, iconv3) {
+    function InternalCodec(codecOptions, iconv2) {
       this.enc = codecOptions.encodingName;
       this.bomAware = codecOptions.bomAware;
       if (this.enc === "base64") {
@@ -194,7 +194,7 @@ var require_internal = __commonJS({
         this.encoder = InternalEncoderCesu8;
         if (Buffer2.from("eda0bdedb2a9", "hex").toString() !== "\u{1F4A9}") {
           this.decoder = InternalDecoderCesu8;
-          this.defaultCharUnicode = iconv3.defaultCharUnicode;
+          this.defaultCharUnicode = iconv2.defaultCharUnicode;
         }
       }
     }
@@ -351,8 +351,8 @@ var require_utf32 = __commonJS({
     "use strict";
     var Buffer2 = require_safer().Buffer;
     exports._utf32 = Utf32Codec;
-    function Utf32Codec(codecOptions, iconv3) {
-      this.iconv = iconv3;
+    function Utf32Codec(codecOptions, iconv2) {
+      this.iconv = iconv2;
       this.bomAware = true;
       this.isLE = codecOptions.isLE;
     }
@@ -476,8 +476,8 @@ var require_utf32 = __commonJS({
     };
     exports.utf32 = Utf32AutoCodec;
     exports.ucs4 = "utf32";
-    function Utf32AutoCodec(options, iconv3) {
-      this.iconv = iconv3;
+    function Utf32AutoCodec(options, iconv2) {
+      this.iconv = iconv2;
     }
     Utf32AutoCodec.prototype.encoder = Utf32AutoEncoder;
     Utf32AutoCodec.prototype.decoder = Utf32AutoDecoder;
@@ -627,8 +627,8 @@ var require_utf16 = __commonJS({
       this.overflowByte = -1;
     };
     exports.utf16 = Utf16Codec;
-    function Utf16Codec(codecOptions, iconv3) {
-      this.iconv = iconv3;
+    function Utf16Codec(codecOptions, iconv2) {
+      this.iconv = iconv2;
     }
     Utf16Codec.prototype.encoder = Utf16Encoder;
     Utf16Codec.prototype.decoder = Utf16Decoder;
@@ -726,8 +726,8 @@ var require_utf7 = __commonJS({
     var Buffer2 = require_safer().Buffer;
     exports.utf7 = Utf7Codec;
     exports.unicode11utf7 = "utf7";
-    function Utf7Codec(codecOptions, iconv3) {
-      this.iconv = iconv3;
+    function Utf7Codec(codecOptions, iconv2) {
+      this.iconv = iconv2;
     }
     Utf7Codec.prototype.encoder = Utf7Encoder;
     Utf7Codec.prototype.decoder = Utf7Decoder;
@@ -809,8 +809,8 @@ var require_utf7 = __commonJS({
       return res;
     };
     exports.utf7imap = Utf7IMAPCodec;
-    function Utf7IMAPCodec(codecOptions, iconv3) {
-      this.iconv = iconv3;
+    function Utf7IMAPCodec(codecOptions, iconv2) {
+      this.iconv = iconv2;
     }
     Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;
     Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;
@@ -943,7 +943,7 @@ var require_sbcs_codec = __commonJS({
     "use strict";
     var Buffer2 = require_safer().Buffer;
     exports._sbcs = SBCSCodec;
-    function SBCSCodec(codecOptions, iconv3) {
+    function SBCSCodec(codecOptions, iconv2) {
       if (!codecOptions) {
         throw new Error("SBCS codec is called without the data.");
       }
@@ -958,7 +958,7 @@ var require_sbcs_codec = __commonJS({
         codecOptions.chars = asciiString + codecOptions.chars;
       }
       this.decodeBuf = Buffer2.from(codecOptions.chars, "ucs2");
-      var encodeBuf = Buffer2.alloc(65536, iconv3.defaultCharSingleByte.charCodeAt(0));
+      var encodeBuf = Buffer2.alloc(65536, iconv2.defaultCharSingleByte.charCodeAt(0));
       for (var i = 0; i < codecOptions.chars.length; i++) {
         encodeBuf[codecOptions.chars.charCodeAt(i)] = i;
       }
@@ -1623,7 +1623,7 @@ var require_dbcs_codec = __commonJS({
       UNASSIGNED_NODE[i] = UNASSIGNED;
     }
     var i;
-    function DBCSCodec(codecOptions, iconv3) {
+    function DBCSCodec(codecOptions, iconv2) {
       this.encodingName = codecOptions.encodingName;
       if (!codecOptions) {
         throw new Error("DBCS codec is called without the data.");
@@ -1672,7 +1672,7 @@ var require_dbcs_codec = __commonJS({
           }
         }
       }
-      this.defaultCharUnicode = iconv3.defaultCharUnicode;
+      this.defaultCharUnicode = iconv2.defaultCharUnicode;
       this.encodeTable = [];
       this.encodeTableSeq = [];
       var skipEncodeChars = {};
@@ -1696,7 +1696,7 @@ var require_dbcs_codec = __commonJS({
           }
         }
       }
-      this.defCharSB = this.encodeTable[0][iconv3.defaultCharSingleByte.charCodeAt(0)];
+      this.defCharSB = this.encodeTable[0][iconv2.defaultCharSingleByte.charCodeAt(0)];
       if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]["?"];
       if (this.defCharSB === UNASSIGNED) this.defCharSB = "?".charCodeAt(0);
     }
@@ -3816,9 +3816,6 @@ var require_lib = __commonJS({
   }
 });
 
-// src/tools/gbk_edit.ts
-import fs3 from "fs/promises";
-
 // node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -16241,11 +16238,10 @@ function tool(input) {
 }
 tool.schema = external_exports;
 
-// src/tools/gbk_edit.ts
-var import_iconv_lite2 = __toESM(require_lib(), 1);
-
 // src/lib/gbk-file.ts
 var import_iconv_lite = __toESM(require_lib(), 1);
+import crypto from "crypto";
+import { createReadStream } from "fs";
 import fs2 from "fs/promises";
 import path2 from "path";
 
@@ -16308,6 +16304,7 @@ async function assertPathAllowed(filePath, context, allowExternal = false) {
 }
 
 // src/lib/gbk-file.ts
+var STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
 function assertEncodingSupported(encoding) {
   if (encoding !== "gbk" && encoding !== "gb18030") {
     throw createGbkError("GBK_INVALID_ENCODING", `\u4E0D\u652F\u6301\u7684\u7F16\u7801: ${encoding}`);
@@ -16323,29 +16320,179 @@ function assertNotBinary(buffer) {
     throw createGbkError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\u6309 GBK \u6587\u672C\u5904\u7406");
   }
 }
-function splitLinesWithNumbers(text, offset = 1, limit = 2e3) {
-  assertPositiveInteger(offset, "offset");
-  assertPositiveInteger(limit, "limit");
+function detectNewlineStyle(text) {
+  const crlfCount = (text.match(/\r\n/g) ?? []).length;
+  const lfCount = (text.match(/(^|[^\r])\n/g) ?? []).length;
+  if (crlfCount > 0 && lfCount === 0) {
+    return "crlf";
+  }
+  if (lfCount > 0 && crlfCount === 0) {
+    return "lf";
+  }
+  if (crlfCount > 0 && lfCount > 0) {
+    return "mixed";
+  }
+  return "none";
+}
+function applyLineRange(text, startLine, endLine) {
+  if (startLine === void 0 && endLine === void 0) {
+    return {
+      selectedText: text,
+      rangeStart: 0,
+      rangeEnd: text.length
+    };
+  }
   const lines = text.split(/\r?\n/);
-  const totalLines = lines.length;
-  if (offset > totalLines) {
+  const actualStartLine = startLine ?? 1;
+  const actualEndLine = endLine ?? lines.length;
+  assertPositiveInteger(actualStartLine, "startLine");
+  assertPositiveInteger(actualEndLine, "endLine");
+  if (actualEndLine < actualStartLine) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "endLine \u4E0D\u80FD\u5C0F\u4E8E startLine");
+  }
+  let cursor = 0;
+  let rangeStart = 0;
+  let rangeEnd = text.length;
+  for (let lineNumber = 1; lineNumber <= lines.length; lineNumber += 1) {
+    if (lineNumber === actualStartLine) {
+      rangeStart = cursor;
+    }
+    cursor += lines[lineNumber - 1].length;
+    if (lineNumber < lines.length) {
+      const newlineLength = text.startsWith("\r\n", cursor) ? 2 : 1;
+      cursor += newlineLength;
+    }
+    if (lineNumber === actualEndLine) {
+      rangeEnd = cursor;
+      break;
+    }
+  }
+  return {
+    selectedText: text.slice(rangeStart, rangeEnd),
+    rangeStart,
+    rangeEnd
+  };
+}
+function applyAnchors(text, startAnchor, endAnchor) {
+  if (!startAnchor && !endAnchor) {
     return {
-      startLine: offset,
-      endLine: totalLines,
-      totalLines,
-      content: ""
+      selectedText: text,
+      rangeStart: 0,
+      rangeEnd: text.length
     };
   }
-  const startIndex = offset - 1;
-  const endIndex = Math.min(startIndex + limit, totalLines);
-  const content = lines.slice(startIndex, endIndex).map((line, index) => `${offset + index}: ${line}`).join("\n");
+  let rangeStart = 0;
+  let rangeEnd = text.length;
+  if (startAnchor) {
+    const found = text.indexOf(startAnchor);
+    if (found === -1) {
+      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8D77\u59CB\u951A\u70B9: ${startAnchor}`);
+    }
+    rangeStart = found + startAnchor.length;
+  }
+  if (endAnchor) {
+    const found = text.indexOf(endAnchor, rangeStart);
+    if (found === -1) {
+      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u7ED3\u675F\u951A\u70B9: ${endAnchor}`);
+    }
+    rangeEnd = found;
+  }
+  if (rangeEnd < rangeStart) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "\u951A\u70B9\u8303\u56F4\u65E0\u6548");
+  }
+  return {
+    selectedText: text.slice(rangeStart, rangeEnd),
+    rangeStart,
+    rangeEnd
+  };
+}
+function resolveEditScope(text, input) {
+  const anchored = applyAnchors(text, input.startAnchor, input.endAnchor);
+  const lineRanged = applyLineRange(anchored.selectedText, input.startLine, input.endLine);
   return {
-    startLine: offset,
-    endLine: offset + (endIndex - startIndex) - 1,
-    totalLines,
-    content
+    selectedText: lineRanged.selectedText,
+    rangeStart: anchored.rangeStart + lineRanged.rangeStart,
+    rangeEnd: anchored.rangeStart + lineRanged.rangeEnd
   };
 }
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function trimRightSpaces(text) {
+  return text.replace(/[ \t]+$/g, "");
+}
+function splitNormalizedLines(text) {
+  return normalizeNewlines(text).split("\n");
+}
+function trimTrailingEmptyLines(lines) {
+  const result = [...lines];
+  while (result.length > 0 && trimRightSpaces(result[result.length - 1]) === "") {
+    result.pop();
+  }
+  return result;
+}
+function getNearestContext(content, oldString) {
+  const lines = content.split(/\r?\n/);
+  const oldLines = normalizeNewlines(oldString).split("\n").filter(Boolean);
+  const firstToken = oldLines[0] || oldString.trim();
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index].includes(firstToken)) {
+      return lines.slice(index, index + 4).join("\n");
+    }
+  }
+  return lines.slice(0, 4).join("\n");
+}
+function buildNoMatchMessage(content, 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\uFF0C\u6216\u4EC5\u5728\u6362\u884C/\u5C3E\u968F\u7A7A\u884C\u4E0A\u5B58\u5728\u8F7B\u5FAE\u5DEE\u5F02\u3002",
+    "\u6700\u63A5\u8FD1\u7684\u4E0A\u4E0B\u6587\uFF1A",
+    getNearestContext(content, oldString)
+  ].join("\n");
+}
+function tryLooseBlockReplace(content, oldString, newString) {
+  const normalizedContent = normalizeNewlines(content);
+  const contentLines = splitNormalizedLines(content);
+  const oldLines = trimTrailingEmptyLines(splitNormalizedLines(oldString));
+  const newLines = splitNormalizedLines(newString);
+  if (oldLines.length === 0) {
+    return null;
+  }
+  for (let start = 0; start < contentLines.length; start += 1) {
+    let contentIndex = start;
+    let oldIndex = 0;
+    while (oldIndex < oldLines.length && contentIndex < contentLines.length) {
+      const expected = trimRightSpaces(oldLines[oldIndex]);
+      const actual = trimRightSpaces(contentLines[contentIndex]);
+      if (expected === actual) {
+        oldIndex += 1;
+        contentIndex += 1;
+        continue;
+      }
+      if (actual === "") {
+        contentIndex += 1;
+        continue;
+      }
+      if (expected === "") {
+        oldIndex += 1;
+        continue;
+      }
+      break;
+    }
+    if (oldIndex === oldLines.length) {
+      const replacedNormalized = [
+        ...contentLines.slice(0, start),
+        ...newLines,
+        ...contentLines.slice(contentIndex)
+      ].join("\n");
+      return {
+        occurrencesBefore: 1,
+        content: detectNewlineStyle(content) === "crlf" ? replacedNormalized.replace(/\n/g, "\r\n") : replacedNormalized
+      };
+    }
+  }
+  return null;
+}
 function countOccurrences(text, target) {
   if (target.length === 0) {
     throw createGbkError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
@@ -16366,10 +16513,9 @@ async function readBufferAsText(buffer, encoding) {
   assertNotBinary(buffer);
   return import_iconv_lite.default.decode(buffer, encoding);
 }
-async function readGbkFile(input) {
+async function resolveReadableGbkFile(input) {
   const encoding = input.encoding ?? "gbk";
-  const offset = input.offset ?? 1;
-  const limit = input.limit ?? 2e3;
+  assertEncodingSupported(encoding);
   const { candidatePath } = await assertPathAllowed(input.filePath, input.context, input.allowExternal ?? false);
   let stat;
   try {
@@ -16380,21 +16526,185 @@ async function readGbkFile(input) {
   if (stat.isDirectory()) {
     throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\u5F55: ${candidatePath}`);
   }
+  return {
+    filePath: candidatePath,
+    encoding,
+    stat
+  };
+}
+async function readWholeGbkTextFile(input) {
   try {
-    const buffer = await fs2.readFile(candidatePath);
-    const text = await readBufferAsText(buffer, encoding);
+    const buffer = await fs2.readFile(input.filePath);
+    const content = await readBufferAsText(buffer, input.encoding);
     return {
-      filePath: candidatePath,
-      encoding,
-      ...splitLinesWithNumbers(text, offset, limit)
+      filePath: input.filePath,
+      encoding: input.encoding,
+      content,
+      bytesRead: buffer.byteLength
     };
   } catch (error45) {
     if (error45 instanceof Error && "code" in error45) {
       throw error45;
     }
-    throw createGbkError("GBK_IO_ERROR", `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${candidatePath}`, error45);
+    throw createGbkError("GBK_IO_ERROR", `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${input.filePath}`, error45);
   }
 }
+async function visitDecodedTextChunks(input, visitor) {
+  const decoder = import_iconv_lite.default.getDecoder(input.encoding);
+  const stream = createReadStream(input.filePath);
+  try {
+    for await (const chunk of stream) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      assertNotBinary(buffer);
+      const text = decoder.write(buffer);
+      if (text.length > 0) {
+        await visitor(text);
+      }
+    }
+    const trailingText = decoder.end();
+    if (trailingText && trailingText.length > 0) {
+      await visitor(trailingText);
+    }
+  } catch (error45) {
+    if (error45 instanceof Error && "code" in error45) {
+      throw error45;
+    }
+    throw createGbkError("GBK_IO_ERROR", `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${input.filePath}`, error45);
+  } finally {
+    stream.destroy();
+  }
+}
+async function writeAll(handle, buffer) {
+  let offset = 0;
+  while (offset < buffer.length) {
+    const { bytesWritten } = await handle.write(buffer, offset, buffer.length - offset);
+    offset += bytesWritten;
+  }
+}
+async function writeEncodedText(handle, encoding, text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  const buffer = import_iconv_lite.default.encode(text, encoding);
+  await writeAll(handle, buffer);
+  return buffer.byteLength;
+}
+async function replaceLargeGbkFileText(input) {
+  const tempPath = path2.join(
+    path2.dirname(input.filePath),
+    `${path2.basename(input.filePath)}.opencode-gbk-${crypto.randomUUID()}.tmp`
+  );
+  const handle = await fs2.open(tempPath, "w");
+  const carryLength = Math.max(input.oldString.length - 1, 0);
+  let carry = "";
+  let occurrencesBefore = 0;
+  let bytesWritten = 0;
+  const flushText = async (text, flush = false) => {
+    const combined = carry + text;
+    const splitAt = flush ? combined.length : Math.max(0, combined.length - carryLength);
+    const processable = combined.slice(0, splitAt);
+    carry = combined.slice(splitAt);
+    if (processable.length === 0) {
+      return;
+    }
+    const matchCount = countOccurrences(processable, input.oldString);
+    const seenBefore = occurrencesBefore;
+    occurrencesBefore += matchCount;
+    let output = processable;
+    if (input.replaceAll) {
+      if (matchCount > 0) {
+        output = processable.split(input.oldString).join(input.newString);
+      }
+    } else if (seenBefore === 0 && matchCount > 0) {
+      output = processable.replace(input.oldString, input.newString);
+    }
+    bytesWritten += await writeEncodedText(handle, input.encoding, output);
+  };
+  try {
+    await visitDecodedTextChunks(input, async (text) => {
+      await flushText(text);
+    });
+    await flushText("", true);
+    if (occurrencesBefore === 0) {
+      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\u5BB9: ${input.oldString}`);
+    }
+    if (!input.replaceAll && occurrencesBefore > 1) {
+      throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
+    }
+    await handle.close();
+    const mode = typeof input.stat.mode === "bigint" ? Number(input.stat.mode) : input.stat.mode;
+    await fs2.chmod(tempPath, mode);
+    await fs2.rename(tempPath, input.filePath);
+    return {
+      filePath: input.filePath,
+      encoding: input.encoding,
+      replacements: input.replaceAll ? occurrencesBefore : 1,
+      occurrencesBefore,
+      bytesRead: input.stat.size,
+      bytesWritten
+    };
+  } catch (error45) {
+    await handle.close().catch(() => void 0);
+    await fs2.rm(tempPath, { force: true }).catch(() => void 0);
+    throw error45;
+  }
+}
+async function replaceGbkFileText(input) {
+  if (input.oldString.length === 0) {
+    throw createGbkError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const replaceAll = input.replaceAll ?? false;
+  const resolved = await resolveReadableGbkFile(input);
+  const hasScopedRange = input.startLine !== void 0 || input.endLine !== void 0 || input.startAnchor !== void 0 || input.endAnchor !== void 0;
+  if (resolved.stat.size >= STREAMING_FILE_SIZE_THRESHOLD_BYTES && !hasScopedRange) {
+    return await replaceLargeGbkFileText({
+      ...resolved,
+      oldString: input.oldString,
+      newString: input.newString,
+      replaceAll
+    });
+  }
+  const current = await readWholeGbkTextFile(resolved);
+  const scope = resolveEditScope(current.content, input);
+  const occurrencesBefore = countOccurrences(scope.selectedText, input.oldString);
+  if (!replaceAll && occurrencesBefore === 0) {
+    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 {
+        filePath: current.filePath,
+        encoding: current.encoding,
+        replacements: 1,
+        occurrencesBefore: loose.occurrencesBefore,
+        bytesRead: current.bytesRead,
+        bytesWritten: buffer2.byteLength
+      };
+    }
+  }
+  if (replaceAll) {
+    if (occurrencesBefore === 0) {
+      throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
+    }
+  } else if (occurrencesBefore === 0) {
+    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: ${input.oldString}`);
+  }
+  const replaced = replaceAll ? scope.selectedText.split(input.oldString).join(input.newString) : scope.selectedText.replace(input.oldString, input.newString);
+  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 {
+    filePath: current.filePath,
+    encoding: current.encoding,
+    replacements: replaceAll ? occurrencesBefore : 1,
+    occurrencesBefore,
+    bytesRead: current.bytesRead,
+    bytesWritten: buffer.byteLength
+  };
+}
 
 // src/tools/gbk_edit.ts
 var gbk_edit_default = tool({
@@ -16404,43 +16714,16 @@ var gbk_edit_default = tool({
     oldString: tool.schema.string().describe("Text to replace"),
     newString: tool.schema.string().describe("Replacement text"),
     replaceAll: tool.schema.boolean().optional().describe("Replace all occurrences"),
+    startLine: tool.schema.number().int().positive().optional().describe("Restrict edit to 1-based start line"),
+    endLine: tool.schema.number().int().positive().optional().describe("Restrict edit to 1-based end line"),
+    startAnchor: tool.schema.string().optional().describe("Restrict edit to content after this anchor"),
+    endAnchor: tool.schema.string().optional().describe("Restrict edit to content before this anchor"),
     encoding: tool.schema.enum(["gbk", "gb18030"]).optional().describe("Text encoding"),
     allowExternal: tool.schema.boolean().optional().describe("Allow paths outside workspace root")
   },
   async execute(args, context) {
-    if (args.oldString.length === 0) {
-      throw createGbkError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
-    }
-    const encoding = args.encoding ?? "gbk";
-    const replaceAll = args.replaceAll ?? false;
-    const { candidatePath } = await assertPathAllowed(args.filePath, context, args.allowExternal ?? false);
-    const current = await readGbkFile({
-      filePath: candidatePath,
-      encoding,
-      context,
-      allowExternal: args.allowExternal
-    });
-    const sourceText = current.content.split("\n").map((line) => line.replace(/^\d+: /, "")).join("\n");
-    const occurrencesBefore = countOccurrences(sourceText, args.oldString);
-    if (replaceAll) {
-      if (occurrencesBefore === 0) {
-        throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\u5BB9: ${args.oldString}`);
-      }
-    } else if (occurrencesBefore === 0) {
-      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\u5BB9: ${args.oldString}`);
-    } else if (occurrencesBefore > 1) {
-      throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${args.oldString}`);
-    }
-    const replaced = replaceAll ? sourceText.split(args.oldString).join(args.newString) : sourceText.replace(args.oldString, args.newString);
-    const buffer = import_iconv_lite2.default.encode(replaced, encoding);
-    await fs3.writeFile(candidatePath, buffer);
-    return JSON.stringify({
-      filePath: candidatePath,
-      encoding,
-      replacements: replaceAll ? occurrencesBefore : 1,
-      occurrencesBefore,
-      bytesWritten: buffer.byteLength
-    }, null, 2);
+    const result = await replaceGbkFileText({ ...args, context });
+    return JSON.stringify(result, null, 2);
   }
 });
 export {