opencode-gbk-tools 0.1.1 → 0.1.2

package/README.md

@@ -13,6 +13,24 @@
 
 推荐方式：直接作为 OpenCode npm plugin 加载工具。
 
+最方便的一键接入：
+
+```bash
+npx opencode-gbk-tools setup --project
+```
+
+这条命令会自动：
+
+- 在当前项目写入或更新 `opencode.json`
+- 自动加入 `plugin: ["opencode-gbk-tools"]`
+- 安装 `.opencode/agents/gbk-engine.md`
+
+如果你想装到用户全局 OpenCode 配置：
+
+```bash
+npx opencode-gbk-tools setup
+```
+
 `opencode.json`:
 
 ```json
@@ -30,6 +48,8 @@
 
 如果你还需要预置 `gbk-engine` agent，请继续使用下面的 CLI 安装方式把 agent 文件写入本地配置目录。
 
+推荐优先使用 `setup`，`install` 更适合手动拆分安装流程。
+
 一次性使用：
 
 ```bash
@@ -41,6 +61,7 @@ npx opencode-gbk-tools install
 ```bash
 npm install -g opencode-gbk-tools
 opencode-gbk install
+opencode-gbk setup
 ```
 
 安装到当前项目：
@@ -57,6 +78,9 @@ opencode-gbk install --project
 ## CLI
 
 ```bash
+opencode-gbk setup
+opencode-gbk setup --project
+
 opencode-gbk install
 opencode-gbk install --project
 opencode-gbk install --force
@@ -75,6 +99,7 @@ opencode-gbk doctor --project
 说明：
 
 - npm `plugin` 方式负责注册 `gbk_read`、`gbk_write`、`gbk_edit`
+- `setup` 会自动写入 `plugin` 配置并安装 `gbk-engine`
 - `gbk-engine` 仍通过 CLI 安装到 `.opencode/agents/` 或 `~/.config/opencode/agents/`
 - 如果你只需要工具，不需要 agent，只配置 `plugin` 即可
 
@@ -93,6 +118,14 @@ opencode-gbk doctor --project
 - `edit: deny` 在 OpenCode 中会一起限制内置 `write`、`patch`、`multiedit`
 - 对无法映射的字符沿用 `iconv-lite` 默认替代行为
 
+## 大文件建议
+
+- `gbk_read` 支持 `tail` 预览最后 N 行
+- `gbk_read` 返回 `fileSize`、`newlineStyle`、`streamed`、`truncated`
+- `gbk_edit` 支持 `startLine/endLine`
+- `gbk_edit` 支持 `startAnchor/endAnchor`
+- 大文件会自动走更省内存的流式路径
+
 ## 发布
 
 ```bash

package/dist/agents/gbk-engine.md

@@ -18,6 +18,8 @@ permission:
 - 读取文件时优先使用 `gbk_read`
 - 创建或覆盖文件时优先使用 `gbk_write`
 - 修改已有文件时优先使用 `gbk_edit`
+- 大文件读取优先使用 `gbk_read` 的分页或 `tail` 能力，避免一次读取过多内容
+- 修改时优先缩小编辑范围：能用 `startLine/endLine` 或 `startAnchor/endAnchor` 就不要全文替换
 - 文件发现可使用 `glob`，但文件内容读取必须使用 `gbk_read`
 - 禁止依赖内置 `read`、`grep`、`write`、`edit`、`patch`
 - `edit: deny` 同时覆盖内置 `write`、`patch`、`multiedit`

package/dist/cli/index.js

@@ -1,5 +1,5 @@
 // src/cli/index.ts
-import path6 from "path";
+import path7 from "path";
 import { fileURLToPath } from "url";
 
 // src/cli/install.ts
@@ -60,9 +60,11 @@ function resolveTargetBase(target, cwd) {
 // src/cli/install.ts
 async function installCommand(args) {
   const targetBase = resolveTargetBase(args.target, args.cwd);
+  const allowedArtifacts = new Set(args.artifacts ?? ["tool", "agent"]);
   const releaseManifest = JSON.parse(await fs3.readFile(path3.join(args.packageRoot, "dist", "release-manifest.json"), "utf8"));
+  const selectedArtifacts = releaseManifest.artifacts.filter((artifact) => allowedArtifacts.has(artifact.kind));
   const existingManifest = await loadInstalledManifest(targetBase);
-  for (const artifact of releaseManifest.artifacts) {
+  for (const artifact of selectedArtifacts) {
     const targetPath = path3.join(targetBase, artifact.relativePath);
     if (await pathExists(targetPath) && !existingManifest && !args.force) {
       throw new Error(`\u68C0\u6D4B\u5230\u672A\u53D7\u7BA1\u6587\u4EF6\u51B2\u7A81: ${targetPath}`);
@@ -78,13 +80,13 @@ async function installCommand(args) {
     targetType: args.target,
     targetBase,
     installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    files: releaseManifest.artifacts.map((artifact) => ({
+    files: selectedArtifacts.map((artifact) => ({
       ...artifact,
       installedByVersion: releaseManifest.packageVersion
     }))
   };
   await writeInstalledManifest(targetBase, installedManifest);
-  return { targetBase };
+  return { targetBase, installedFiles: selectedArtifacts.length };
 }
 
 // src/cli/uninstall.ts
@@ -131,13 +133,68 @@ async function doctorCommand(args) {
   return { ok: issues.length === 0, issues };
 }
 
+// src/cli/setup.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+import os2 from "os";
+import { applyEdits, modify, parse } from "jsonc-parser";
+async function resolveConfigFile(baseDir) {
+  const jsoncPath = path6.join(baseDir, "opencode.jsonc");
+  const jsonPath = path6.join(baseDir, "opencode.json");
+  try {
+    await fs6.access(jsoncPath);
+    return jsoncPath;
+  } catch {
+    try {
+      await fs6.access(jsonPath);
+      return jsonPath;
+    } catch {
+      return jsonPath;
+    }
+  }
+}
+async function ensurePluginConfigured(configPath, pluginName) {
+  let content = '{\n  "$schema": "https://opencode.ai/config.json"\n}\n';
+  try {
+    content = await fs6.readFile(configPath, "utf8");
+  } catch {
+  }
+  const parsed = parse(content);
+  const plugins = parsed?.plugin ?? [];
+  if (plugins.includes(pluginName)) {
+    return configPath;
+  }
+  const edits = modify(content, ["plugin"], [...plugins, pluginName], {
+    formattingOptions: {
+      insertSpaces: true,
+      tabSize: 2,
+      eol: "\n"
+    }
+  });
+  const updated = applyEdits(content, edits);
+  await fs6.writeFile(configPath, updated, "utf8");
+  return configPath;
+}
+async function setupCommand(args) {
+  const pluginName = "opencode-gbk-tools";
+  const configBase = args.target === "project" ? args.cwd : path6.join(os2.homedir(), ".config", "opencode");
+  await fs6.mkdir(configBase, { recursive: true });
+  const configPath = await resolveConfigFile(configBase);
+  await ensurePluginConfigured(configPath, pluginName);
+  const installResult = await installCommand({ ...args, force: true, artifacts: ["agent"] });
+  return {
+    configPath,
+    targetBase: installResult.targetBase
+  };
+}
+
 // src/cli/index.ts
 function resolvePackageRoot(env = process.env, moduleUrl = import.meta.url) {
   if (env.OPENCODE_GBK_PACKAGE_ROOT) {
     return env.OPENCODE_GBK_PACKAGE_ROOT;
   }
   const modulePath = fileURLToPath(moduleUrl);
-  return path6.resolve(path6.dirname(modulePath), "..", "..");
+  return path7.resolve(path7.dirname(modulePath), "..", "..");
 }
 async function main(argv, env = process.env) {
   const [command, ...rest] = argv;
@@ -148,6 +205,9 @@ async function main(argv, env = process.env) {
   if (command === "install") {
     return await installCommand({ packageRoot, target, cwd, force });
   }
+  if (command === "setup") {
+    return await setupCommand({ packageRoot, target, cwd });
+  }
   if (command === "uninstall") {
     return await uninstallCommand({ target, cwd });
   }

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,27 +16320,85 @@ 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 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 countOccurrences(text, target) {
@@ -16366,10 +16421,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 +16434,169 @@ 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) {
+    if (occurrencesBefore === 0) {
+      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\u5BB9: ${input.oldString}`);
+    }
+  } else if (occurrencesBefore === 0) {
+    throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\u5BB9: ${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 +16606,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 {