opencode-gbk-tools 0.1.27 → 0.1.28

package/README.md

@@ -2,7 +2,7 @@
 
 为 OpenCode 提供一套自动识别编码的文本工具，以及面向 `GBK` / `GB18030` 的专用工具。
 
-解决 OpenCode 内置工具难以稳定处理非 UTF-8 文本文件的问题，并通过 plugin 让所有 agents 默认获得这些工具与规则；同时提供一个只允许调用 `text_*` / `gbk_*` 自定义工具的 `gbk-engine` agent。
+解决 OpenCode 内置工具难以稳定处理非 UTF-8 文本文件的问题，并通过 plugin 让所有 agents 默认获得这些工具与规则；同时提供一个只允许调用 `gbk_*` 自定义工具的 `gbk-engine` agent。
 
 ---
 
@@ -17,8 +17,8 @@
 | `gbk_write` | 写入或追加内容到 GBK 文件（`append=true` 支持追加） |
 | `gbk_edit` | 精确替换 GBK 文件中的指定文本块 |
 | `gbk_search` | 在 GBK 文件中搜索关键词，返回行号和上下文 |
-| 本地/全局 plugin 规则 | 给所有 agents 注入“优先使用 `text_*`”的系统提示，并统一开放 `gbk_*` 工具 |
-| `gbk-engine` agent | 禁用 OpenCode 内置读写编辑工具，只保留 `text_*` / `gbk_*` 自定义工具 |
+| 本地/全局 plugin 规则 | 给所有 agents 注入“默认优先使用 `gbk_*`，`text_*` 作为兼容工具”的系统提示，并统一开放 `text_*` / `gbk_*` 工具 |
+| `gbk-engine` agent | 禁用 OpenCode 内置读写编辑工具，只保留 `gbk_*` 自定义工具 |
 
 ---
 
@@ -34,7 +34,7 @@ npx opencode-gbk-tools install
 
 - `text_read` / `text_write` / `text_edit`
 - `gbk_read` / `gbk_write` / `gbk_edit` / `gbk_search`
-- 对文本文件优先使用 `text_*` 的系统提示
+- 默认优先使用 `gbk_*`、`text_*` 作为兼容工具的系统提示
 - `.opencode/agents/gbk-engine.md` 或 `~/.config/opencode/agents/gbk-engine.md`
 
 如果你希望强制禁用内置 `read` / `write` / `edit` / `apply_patch`，可以直接切换到专属 `gbk-engine` agent。
@@ -77,8 +77,8 @@ npx opencode-gbk-tools uninstall
 优先使用建议：
 
 ```text
-通用文本文件：text_read / text_write / text_edit
-明确 GBK 文件：gbk_read / gbk_write / gbk_edit / gbk_search
+默认优先：gbk_read / gbk_write / gbk_edit / gbk_search
+兼容性场景：text_read / text_write / text_edit
 ```
 
 编辑动作建议：
@@ -208,6 +208,7 @@ A：不要。现在优先用 `mode="insertAfter"` 或 `mode="insertBefore"`，
 
 | 版本 | 说明 |
 |------|------|
+| 0.1.28 | 对齐 plugin/agent 文档说明到当前产品行为：默认优先推荐 `gbk_*`、`text_*` 作为兼容工具，`gbk-engine` 仅保留 `gbk_*`；修复 `src/lib/gbk-file.ts` 中多处用户可见乱码错误文案；修复 `text_*` 大文件流式替换跨块命中遗漏问题并补充回归测试 |
 | 0.1.27 | 重新发布当前稳定内容，包含：新建 `.txt` 文件在 `encoding=auto` 下默认使用 `gbk`；保留已有文件的原编码检测与保持逻辑；修复 plugin 追加 system 规则时可能触发部分 Jinja/chat template 的“System message must be at the beginning”异常；同步更新工具提示、README 与测试覆盖 |
 | 0.1.26 | 仅提升发布版本号，用于重新发布当时的稳定内容 |
 | 0.1.25 | 恢复并正式发布专属 `gbk-engine` agent；通过 agent 白名单禁用内置 `read` / `write` / `edit` / `apply_patch`，只保留 `text_*` / `gbk_*` 自定义工具，并把 agent 纳入构建、安装与 release manifest |

package/dist/agents/gbk-engine.md

@@ -8,9 +8,6 @@ tools:
   write: false
   edit: false
   apply_patch: false
-  text_read: true
-  text_write: true
-  text_edit: true
   gbk_read: true
   gbk_write: true
   gbk_edit: true
@@ -21,12 +18,12 @@ permission:
 ---
 你是 `gbk-engine`。
 
-你只能使用 `opencode-gbk-tools` 提供的 `text_*` 与 `gbk_*` 工具，不允许退回到 OpenCode 内置的 `read`、`write`、`edit`、`apply_patch` 或其他内置工具。
+你只能使用 `opencode-gbk-tools` 提供的 `gbk_*` 工具，不允许退回到 OpenCode 内置的 `read`、`write`、`edit`、`apply_patch` 或其他内置工具。
 
 工作规则：
 
-- 通用文本文件优先使用 `text_read`、`text_write`、`text_edit`
-- 只有在用户明确指定 `GBK` / `GB18030` 文件，或自动编码检测失败时，才优先使用 `gbk_*` 工具
+- 所有文本文件默认优先使用 `gbk_read`、`gbk_write`、`gbk_edit`、`gbk_search`
+- 不再使用 `text_read`、`text_write`、`text_edit`
 - 编辑前先读取目标文件；对大文件先搜索，再局部读取
 - 插入内容优先使用 `mode="insertAfter"` 或 `mode="insertBefore"` 搭配 `anchor` / `content`
 - 只有在精确替换现有内容时，才使用 `oldString` / `newString`

package/dist/opencode-tools/gbk_edit.js

@@ -16406,45 +16406,103 @@ function assertInsertArguments(input) {
     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\uFFFD? replaceAll");
+    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\uFFFD? startLine/endLine/startAnchor/endAnchor");
+    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");
+function collectOccurrencePositions(text, token) {
   if (token.length === 0) {
-    throw createGbkError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+    return [];
   }
-  let count = 0;
+  const positions = [];
   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) };
+      return positions;
     }
+    positions.push(index);
     searchFrom = index + token.length;
   }
-  if (count === 0) {
-    throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\uFFFD?: ${token}`);
+}
+function buildFlexibleSearchVariants(token, newlineStyle) {
+  const variants = /* @__PURE__ */ new Set();
+  const pushVariant = (value) => {
+    if (typeof value !== "string" || value.length === 0) {
+      return;
+    }
+    variants.add(value);
+  };
+  pushVariant(token);
+  pushVariant(alignTextToNewlineStyle(token, newlineStyle));
+  const prefixedBlock = parseLineNumberPrefixedBlock(token);
+  if (prefixedBlock) {
+    pushVariant(prefixedBlock.strippedText);
+    pushVariant(alignTextToNewlineStyle(prefixedBlock.strippedText, newlineStyle));
+  }
+  const trimmedLines = trimTrailingEmptyLines(splitNormalizedLines(token));
+  if (trimmedLines.length > 0) {
+    const trimmedToken = trimmedLines.join("\n");
+    pushVariant(trimmedToken);
+    pushVariant(alignTextToNewlineStyle(trimmedToken, newlineStyle));
+    const trimmedPrefixedBlock = parseLineNumberPrefixedBlock(trimmedToken);
+    if (trimmedPrefixedBlock) {
+      pushVariant(trimmedPrefixedBlock.strippedText);
+      pushVariant(alignTextToNewlineStyle(trimmedPrefixedBlock.strippedText, newlineStyle));
+    }
+  }
+  return [...variants];
+}
+function findNextFlexibleMatch(text, token, searchFrom, newlineStyle) {
+  let bestMatch = null;
+  for (const candidate of buildFlexibleSearchVariants(token, newlineStyle)) {
+    const index = text.indexOf(candidate, searchFrom);
+    if (index === -1) {
+      continue;
+    }
+    if (bestMatch === null || index < bestMatch.index || index === bestMatch.index && candidate.length > bestMatch.matchedToken.length) {
+      bestMatch = { index, matchedToken: candidate };
+    }
   }
-  throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\uFFFD? ${count} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\uFFFD? ${occurrence} \u5904`);
+  return bestMatch;
+}
+function findFlexibleOccurrenceIndex(text, token, occurrence, newlineStyle) {
+  assertStringArgument(text, "text");
+  assertStringArgument(token, "anchor");
+  assertPositiveInteger(occurrence, "occurrence");
+  if (token.length === 0) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  let maxMatches = 0;
+  for (const candidate of buildFlexibleSearchVariants(token, newlineStyle)) {
+    const positions = collectOccurrencePositions(text, candidate);
+    if (positions.length === 0) {
+      continue;
+    }
+    maxMatches = Math.max(maxMatches, positions.length);
+    if (positions.length >= occurrence) {
+      return {
+        index: positions[occurrence - 1],
+        total: positions.length,
+        matchedToken: candidate
+      };
+    }
+  }
+  if (maxMatches === 0) {
+    throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\u70B9: ${token}`);
+  }
+  throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\u5230 ${maxMatches} \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 located = findFlexibleOccurrenceIndex(text, anchor, occurrence, newlineStyle);
+  const insertionPoint = mode === "insertAfter" ? located.index + located.matchedToken.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\uFFFD?");
+      throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\u5BB9");
     }
     if (ifExists === "skip") {
       return {
@@ -16485,7 +16543,7 @@ function normalizeOptionalPositiveInteger(value, name) {
 }
 function assertNotBinary(buffer) {
   if (buffer.includes(0)) {
-    throw createGbkError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\uFFFD? GBK \u6587\u672C\u5904\u7406");
+    throw createGbkError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\u6309 GBK \u6587\u672C\u5904\u7406");
   }
 }
 function detectNewlineStyle(text) {
@@ -16563,19 +16621,15 @@ function applyAnchors(text, startAnchor, endAnchor) {
   }
   let rangeStart = 0;
   let rangeEnd = text.length;
+  const newlineStyle = detectNewlineStyle(text);
   if (startAnchor) {
-    const found = text.indexOf(startAnchor);
-    if (found === -1) {
-      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8D77\u59CB\u951A\uFFFD?: ${startAnchor}`);
-    }
-    rangeStart = found + startAnchor.length;
+    const found = findFlexibleOccurrenceIndex(text, startAnchor, 1, newlineStyle);
+    rangeStart = found.index + found.matchedToken.length;
   }
   if (endAnchor) {
-    const found = text.indexOf(endAnchor, rangeStart);
-    if (found === -1) {
-      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u7ED3\u675F\u951A\uFFFD?: ${endAnchor}`);
-    }
-    rangeEnd = found;
+    const searchText = text.slice(rangeStart);
+    const found = findFlexibleOccurrenceIndex(searchText, endAnchor, 1, newlineStyle);
+    rangeEnd = rangeStart + found.index;
   }
   if (rangeEnd < rangeStart) {
     throw createGbkError("GBK_INVALID_ARGUMENT", "\u951A\u70B9\u8303\u56F4\u65E0\u6548");
@@ -16626,9 +16680,9 @@ function getNearestContext(content, oldString) {
 }
 function buildNoMatchMessage(content, oldString) {
   return [
-    "\u672A\u627E\u5230\u9700\u8981\u66FF\u6362\u7684\u6587\u672C\uFFFD?",
-    "oldString \u5FC5\u987B\u4E0E\u6587\u4EF6\u5B9E\u9645\u5185\u5BB9\u5B8C\u5168\u5BF9\u5E94\uFF0C\u6216\u4EC5\u5728\u6362\uFFFD?/\u5C3E\u968F\u7A7A\u884C\u4E0A\u5B58\u5728\u8F7B\u5FAE\u5DEE\u5F02\uFFFD?",
-    "\u6700\u63A5\u8FD1\u7684\u4E0A\u4E0B\u6587\uFFFD?",
+    "\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");
 }
@@ -16640,8 +16694,10 @@ function stripLineNumberPrefixes(lines) {
   return lines.map((l) => l.replace(/^\d+: /, ""));
 }
 function parseLineNumberPrefixedBlock(text) {
-  const lines = splitNormalizedLines(text);
-  if (!hasLineNumberPrefixes(lines)) {
+  const normalizedText = normalizeNewlines(text);
+  const hasTrailingNewline = normalizedText.endsWith("\n");
+  const lines = trimTrailingEmptyLines(splitNormalizedLines(text));
+  if (lines.length === 0 || !hasLineNumberPrefixes(lines)) {
     return null;
   }
   const lineNumbers = [];
@@ -16656,7 +16712,7 @@ function parseLineNumberPrefixedBlock(text) {
   }
   return {
     lineNumbers,
-    strippedText: strippedLines.join("\n"),
+    strippedText: `${strippedLines.join("\n")}${hasTrailingNewline ? "\n" : ""}`,
     isContiguous: lineNumbers.every((lineNumber, index) => index === 0 || lineNumber === lineNumbers[index - 1] + 1),
     startLine: lineNumbers[0],
     endLine: lineNumbers[lineNumbers.length - 1]
@@ -16751,10 +16807,10 @@ async function resolveReadableGbkFile(input) {
   try {
     stat = await fs2.stat(candidatePath);
   } catch (error45) {
-    throw createGbkError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\uFFFD?: ${candidatePath}`, error45);
+    throw createGbkError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\u5728: ${candidatePath}`, error45);
   }
   if (stat.isDirectory()) {
-    throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\uFFFD?: ${candidatePath}`);
+    throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\u5F55: ${candidatePath}`);
   }
   return {
     filePath: candidatePath,
@@ -16951,7 +17007,7 @@ function replaceScopedTextContent(scopeText, oldString, newString, replaceAll, n
   } else if (occurrencesBefore === 0) {
     throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scopeText, oldString));
   } else if (occurrencesBefore > 1) {
-    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\uFFFD?: ${oldString}`);
+    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${oldString}`);
   }
   const alignedNewString = alignTextToNewlineStyle(newString, newlineStyle);
   return {
@@ -17009,14 +17065,17 @@ async function replaceLargeGbkFileTextInLineRange(input) {
   }
 }
 async function replaceLargeGbkFileByAnchor(input) {
+  const lineIndex = await getGbkLineIndex(input);
+  const newlineStyle = lineIndex.newlineStyle;
   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 alignedContent = input.content.replace(/\r\n/g, "\n");
-  const anchorLength = input.anchor.length;
-  const carryLength = Math.max(anchorLength + alignedContent.length, 1);
+  const alignedContent = alignTextToNewlineStyle(input.content, newlineStyle);
+  const anchorVariants = buildFlexibleSearchVariants(input.anchor, newlineStyle);
+  const maxAnchorLength = anchorVariants.reduce((maxLength, candidate) => Math.max(maxLength, candidate.length), input.anchor.length);
+  const carryLength = Math.max(maxAnchorLength + alignedContent.length, 1);
   let decoded = "";
   let scanFrom = 0;
   let totalMatches = 0;
@@ -17040,23 +17099,23 @@ async function replaceLargeGbkFileByAnchor(input) {
     await visitDecodedTextChunks(input, async (text) => {
       decoded += text;
       while (!inserted) {
-        const foundAt = decoded.indexOf(input.anchor, scanFrom);
-        if (foundAt === -1) {
+        const located = findNextFlexibleMatch(decoded, input.anchor, scanFrom, newlineStyle);
+        if (located === null) {
           break;
         }
         totalMatches += 1;
-        const afterAnchor = foundAt + anchorLength;
+        const afterAnchor = located.index + located.matchedToken.length;
         if (totalMatches !== input.occurrence) {
           scanFrom = afterAnchor;
           continue;
         }
-        const before = decoded.slice(0, foundAt);
+        const before = decoded.slice(0, located.index);
         const after = decoded.slice(afterAnchor);
-        const anchorAndAfter = decoded.slice(foundAt);
+        const anchorAndAfter = decoded.slice(located.index);
         const alreadyExists = input.mode === "insertAfter" ? after.startsWith(alignedContent) : before.endsWith(alignedContent);
         if (alreadyExists) {
           if (input.ifExists === "error") {
-            throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\uFFFD?");
+            throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\u5BB9");
           }
           if (input.ifExists === "skip") {
             skipped = true;
@@ -17068,7 +17127,7 @@ async function replaceLargeGbkFileByAnchor(input) {
         }
         if (input.mode === "insertAfter") {
           bytesWritten += await writeEncodedText(handle, input.encoding, before);
-          bytesWritten += await writeEncodedText(handle, input.encoding, input.anchor);
+          bytesWritten += await writeEncodedText(handle, input.encoding, located.matchedToken);
           bytesWritten += await writeEncodedText(handle, input.encoding, alignedContent);
           bytesWritten += await writeEncodedText(handle, input.encoding, after);
         } else {
@@ -17087,23 +17146,23 @@ async function replaceLargeGbkFileByAnchor(input) {
     });
     if (!inserted) {
       while (true) {
-        const foundAt = decoded.indexOf(input.anchor, scanFrom);
-        if (foundAt === -1) {
+        const located = findNextFlexibleMatch(decoded, input.anchor, scanFrom, newlineStyle);
+        if (located === null) {
           break;
         }
         totalMatches += 1;
-        const afterAnchor = foundAt + anchorLength;
+        const afterAnchor = located.index + located.matchedToken.length;
         if (totalMatches !== input.occurrence) {
           scanFrom = afterAnchor;
           continue;
         }
-        const before = decoded.slice(0, foundAt);
+        const before = decoded.slice(0, located.index);
         const after = decoded.slice(afterAnchor);
-        const anchorAndAfter = decoded.slice(foundAt);
+        const anchorAndAfter = decoded.slice(located.index);
         const alreadyExists = input.mode === "insertAfter" ? after.startsWith(alignedContent) : before.endsWith(alignedContent);
         if (alreadyExists) {
           if (input.ifExists === "error") {
-            throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\uFFFD?");
+            throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\u5BB9");
           }
           if (input.ifExists === "skip") {
             skipped = true;
@@ -17111,16 +17170,16 @@ async function replaceLargeGbkFileByAnchor(input) {
             break;
           }
         }
-        decoded = input.mode === "insertAfter" ? `${before}${input.anchor}${alignedContent}${after}` : `${before}${alignedContent}${anchorAndAfter}`;
+        decoded = input.mode === "insertAfter" ? `${before}${located.matchedToken}${alignedContent}${after}` : `${before}${alignedContent}${anchorAndAfter}`;
         inserted = true;
         break;
       }
     }
     if (!inserted && totalMatches === 0) {
-      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\uFFFD?: ${input.anchor}`);
+      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\u70B9: ${input.anchor}`);
     }
     if (!inserted && totalMatches > 0) {
-      throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${input.anchor} \u53EA\u627E\uFFFD? ${totalMatches} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\uFFFD? ${input.occurrence} \u5904`);
+      throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${input.anchor} \u53EA\u627E\u5230 ${totalMatches} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7B2C ${input.occurrence} \u5904`);
     }
     await finalizeInserted();
     await handle.close();
@@ -17147,35 +17206,57 @@ async function replaceLargeGbkFileByAnchor(input) {
   }
 }
 async function replaceLargeGbkFileText(input) {
+  const lineIndex = await getGbkLineIndex(input);
+  const newlineStyle = lineIndex.newlineStyle;
   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);
+  const alignedNewString = alignTextToNewlineStyle(input.newString, newlineStyle);
   let carry = "";
   let occurrencesBefore = 0;
   let bytesWritten = 0;
+  let replacedFirstMatch = false;
   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) {
+    if (combined.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);
+    const safeEnd = flush ? combined.length : Math.max(0, combined.length - carryLength);
+    const outputParts = [];
+    let cursor = 0;
+    let flushUpto = safeEnd;
+    while (true) {
+      const index = combined.indexOf(input.oldString, cursor);
+      if (index === -1) {
+        break;
+      }
+      const matchEnd = index + input.oldString.length;
+      if (!flush && matchEnd > safeEnd) {
+        flushUpto = index;
+        break;
       }
-    } else if (seenBefore === 0 && matchCount > 0) {
-      output = processable.replace(input.oldString, input.newString);
+      occurrencesBefore += 1;
+      outputParts.push(combined.slice(cursor, index));
+      if (input.replaceAll) {
+        outputParts.push(alignedNewString);
+      } else if (!replacedFirstMatch) {
+        outputParts.push(alignedNewString);
+        replacedFirstMatch = true;
+      } else {
+        outputParts.push(input.oldString);
+      }
+      cursor = matchEnd;
+    }
+    outputParts.push(combined.slice(cursor, flushUpto));
+    carry = combined.slice(flushUpto);
+    const processable = outputParts.join("");
+    if (processable.length === 0) {
+      return;
     }
-    bytesWritten += await writeEncodedText(handle, input.encoding, output);
+    bytesWritten += await writeEncodedText(handle, input.encoding, processable);
   };
   try {
     await visitDecodedTextChunks(input, async (text) => {
@@ -17183,10 +17264,10 @@ async function replaceLargeGbkFileText(input) {
     });
     await flushText("", true);
     if (occurrencesBefore === 0) {
-      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\uFFFD?: ${input.oldString}`);
+      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\uFFFD?: ${input.oldString}`);
+      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;
@@ -17335,7 +17416,7 @@ async function replaceGbkFileText(input) {
   } else if (occurrencesBefore === 0) {
     throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, effectiveOldString));
   } else if (occurrencesBefore > 1) {
-    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\uFFFD?: ${effectiveOldString}`);
+    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${effectiveOldString}`);
   }
   const fileNewlineStyle = detectNewlineStyle(current.content);
   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;

package/dist/opencode-tools/gbk_read.js

@@ -16329,7 +16329,7 @@ function normalizeOptionalPositiveInteger(value, name) {
 }
 function assertNotBinary(buffer) {
   if (buffer.includes(0)) {
-    throw createGbkError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\uFFFD? GBK \u6587\u672C\u5904\u7406");
+    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) {
@@ -16420,10 +16420,10 @@ async function resolveReadableGbkFile(input) {
   try {
     stat = await fs2.stat(candidatePath);
   } catch (error45) {
-    throw createGbkError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\uFFFD?: ${candidatePath}`, error45);
+    throw createGbkError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\u5728: ${candidatePath}`, error45);
   }
   if (stat.isDirectory()) {
-    throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\uFFFD?: ${candidatePath}`);
+    throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\u5F55: ${candidatePath}`);
   }
   return {
     filePath: candidatePath,

package/dist/opencode-tools/gbk_search.js

@@ -16313,7 +16313,7 @@ function assertEncodingSupported(encoding) {
 }
 function assertNotBinary(buffer) {
   if (buffer.includes(0)) {
-    throw createGbkError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\uFFFD? GBK \u6587\u672C\u5904\u7406");
+    throw createGbkError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\u6309 GBK \u6587\u672C\u5904\u7406");
   }
 }
 async function resolveReadableGbkFile(input) {
@@ -16324,10 +16324,10 @@ async function resolveReadableGbkFile(input) {
   try {
     stat = await fs2.stat(candidatePath);
   } catch (error45) {
-    throw createGbkError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\uFFFD?: ${candidatePath}`, error45);
+    throw createGbkError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\u5728: ${candidatePath}`, error45);
   }
   if (stat.isDirectory()) {
-    throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\uFFFD?: ${candidatePath}`);
+    throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\u5F55: ${candidatePath}`);
   }
   return {
     filePath: candidatePath,

package/dist/opencode-tools/gbk_write.js

@@ -16370,10 +16370,10 @@ async function writeGbkFile(input) {
   try {
     const stat = await fs2.stat(candidatePath);
     if (stat.isDirectory()) {
-      throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\uFFFD?: ${candidatePath}`);
+      throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\u5F55: ${candidatePath}`);
     }
     if (!overwrite) {
-      throw createGbkError("GBK_FILE_EXISTS", `\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\uFFFD?: ${candidatePath}`);
+      throw createGbkError("GBK_FILE_EXISTS", `\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\u5728: ${candidatePath}`);
     }
   } catch (error45) {
     if (error45 instanceof Error && "code" in error45) {