opencode-gbk-tools 0.1.14 → 0.1.15

package/dist/plugin/index.js

@@ -16306,6 +16306,14 @@ async function assertPathAllowed(filePath, context, allowExternal = false) {
 
 // src/lib/gbk-file.ts
 var STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
+var STREAM_READ_CHUNK_SIZE_BYTES = 1024 * 1024;
+var gbkLineIndexCache = /* @__PURE__ */ new Map();
+function toSafeNumber(value) {
+  return typeof value === "bigint" ? Number(value) : value;
+}
+function invalidateGbkLineIndex(filePath) {
+  gbkLineIndexCache.delete(filePath);
+}
 function assertStringArgument(value, name) {
   if (typeof value !== "string") {
     throw createGbkError("GBK_INVALID_ARGUMENT", `${name} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
@@ -16469,6 +16477,16 @@ function finalizeNewlineStyle(crlfCount, lfCount) {
   }
   return "none";
 }
+function formatLineWindowContent(text, startLine, expectedLineCount) {
+  const lines = text.length === 0 ? [""] : text.split(/\r?\n/);
+  while (lines.length > expectedLineCount && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  while (lines.length < expectedLineCount) {
+    lines.push("");
+  }
+  return lines.slice(0, expectedLineCount).map((line, index) => `${startLine + index}: ${line}`).join("\n");
+}
 function applyLineRange(text, startLine, endLine) {
   if (startLine === void 0 && endLine === void 0) {
     return {
@@ -16594,6 +16612,29 @@ function hasLineNumberPrefixes(lines) {
 function stripLineNumberPrefixes(lines) {
   return lines.map((l) => l.replace(/^\d+: /, ""));
 }
+function parseLineNumberPrefixedBlock(text) {
+  const lines = splitNormalizedLines(text);
+  if (!hasLineNumberPrefixes(lines)) {
+    return null;
+  }
+  const lineNumbers = [];
+  const strippedLines = [];
+  for (const line of lines) {
+    const match = /^(\d+): ?(.*)$/.exec(line);
+    if (!match) {
+      return null;
+    }
+    lineNumbers.push(Number(match[1]));
+    strippedLines.push(match[2]);
+  }
+  return {
+    lineNumbers,
+    strippedText: strippedLines.join("\n"),
+    isContiguous: lineNumbers.every((lineNumber, index) => index === 0 || lineNumber === lineNumbers[index - 1] + 1),
+    startLine: lineNumbers[0],
+    endLine: lineNumbers[lineNumbers.length - 1]
+  };
+}
 function matchLooseBlock(contentLines, oldLines, newLines, newlineStyle, content) {
   for (let start = 0; start < contentLines.length; start += 1) {
     let contentIndex = start;
@@ -16710,7 +16751,7 @@ async function readWholeGbkTextFile(input) {
 }
 async function visitDecodedTextChunks(input, visitor) {
   const decoder = import_iconv_lite.default.getDecoder(input.encoding);
-  const stream = createReadStream(input.filePath);
+  const stream = createReadStream(input.filePath, { highWaterMark: STREAM_READ_CHUNK_SIZE_BYTES });
   try {
     for await (const chunk of stream) {
       const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
@@ -16733,109 +16774,89 @@ async function visitDecodedTextChunks(input, visitor) {
     stream.destroy();
   }
 }
-function createLineCollector(offset, limit) {
-  const lines = [];
-  let pending = "";
-  let totalLines = 0;
+async function getGbkLineIndex(input) {
+  const cached2 = gbkLineIndexCache.get(input.filePath);
+  if (cached2 && cached2.fileSize === toSafeNumber(input.stat.size) && cached2.mtimeMs === toSafeNumber(input.stat.mtimeMs)) {
+    return cached2;
+  }
+  const lineStartOffsets = [0];
+  let byteOffset = 0;
+  let previousByteWasCR = false;
   let crlfCount = 0;
   let lfCount = 0;
-  const emitLine = (line) => {
-    totalLines += 1;
-    if (totalLines >= offset && lines.length < limit) {
-      lines.push(`${totalLines}: ${line}`);
-    }
-  };
-  return {
-    push(text) {
-      if (text.length === 0) {
-        return;
-      }
-      const combined = pending + text;
-      let start = 0;
-      while (true) {
-        const newlineIndex = combined.indexOf("\n", start);
-        if (newlineIndex === -1) {
-          break;
-        }
-        let line = combined.slice(start, newlineIndex);
-        if (line.endsWith("\r")) {
-          line = line.slice(0, -1);
-          crlfCount += 1;
-        } else {
-          lfCount += 1;
+  const stream = createReadStream(input.filePath, { highWaterMark: STREAM_READ_CHUNK_SIZE_BYTES });
+  try {
+    for await (const chunk of stream) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      assertNotBinary(buffer);
+      for (let index = 0; index < buffer.length; index += 1) {
+        const byte = buffer[index];
+        if (byte === 10) {
+          if (previousByteWasCR) {
+            crlfCount += 1;
+          } else {
+            lfCount += 1;
+          }
+          lineStartOffsets.push(byteOffset + index + 1);
+          previousByteWasCR = false;
+          continue;
         }
-        emitLine(line);
-        start = newlineIndex + 1;
+        previousByteWasCR = byte === 13;
       }
-      pending = combined.slice(start);
-    },
-    finish() {
-      emitLine(pending);
-      const endLine = lines.length === 0 ? totalLines : offset + lines.length - 1;
-      return {
-        startLine: offset,
-        endLine,
-        totalLines,
-        content: lines.join("\n"),
-        tail: false,
-        truncated: endLine < totalLines,
-        newlineStyle: finalizeNewlineStyle(crlfCount, lfCount)
-      };
+      byteOffset += buffer.length;
     }
-  };
-}
-function createTailCollector(limit) {
-  assertPositiveInteger(limit, "limit");
-  const lines = [];
-  let pending = "";
-  let totalLines = 0;
-  let crlfCount = 0;
-  let lfCount = 0;
-  const emitLine = (line) => {
-    totalLines += 1;
-    lines.push(line);
-    if (lines.length > limit) {
-      lines.shift();
+  } 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();
+  }
+  const result = {
+    filePath: input.filePath,
+    fileSize: toSafeNumber(input.stat.size),
+    mtimeMs: toSafeNumber(input.stat.mtimeMs),
+    lineStartOffsets,
+    totalLines: lineStartOffsets.length,
+    newlineStyle: finalizeNewlineStyle(crlfCount, lfCount)
   };
-  return {
-    push(text) {
-      if (text.length === 0) {
-        return;
-      }
-      const combined = pending + text;
-      let start = 0;
-      while (true) {
-        const newlineIndex = combined.indexOf("\n", start);
-        if (newlineIndex === -1) {
-          break;
-        }
-        let line = combined.slice(start, newlineIndex);
-        if (line.endsWith("\r")) {
-          line = line.slice(0, -1);
-          crlfCount += 1;
-        } else {
-          lfCount += 1;
-        }
-        emitLine(line);
-        start = newlineIndex + 1;
+  gbkLineIndexCache.set(input.filePath, result);
+  return result;
+}
+async function readDecodedGbkByteRange(input, start, endExclusive) {
+  if (endExclusive <= start) {
+    return "";
+  }
+  const decoder = import_iconv_lite.default.getDecoder(input.encoding);
+  const stream = createReadStream(input.filePath, {
+    start,
+    end: endExclusive - 1,
+    highWaterMark: STREAM_READ_CHUNK_SIZE_BYTES
+  });
+  const parts = [];
+  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) {
+        parts.push(text);
       }
-      pending = combined.slice(start);
-    },
-    finish() {
-      emitLine(pending);
-      const startLine = Math.max(1, totalLines - lines.length + 1);
-      return {
-        startLine,
-        endLine: totalLines,
-        totalLines,
-        content: lines.map((line, index) => `${startLine + index}: ${line}`).join("\n"),
-        truncated: startLine > 1,
-        tail: true,
-        newlineStyle: finalizeNewlineStyle(crlfCount, lfCount)
-      };
     }
-  };
+    const trailingText = decoder.end() ?? "";
+    if (trailingText.length > 0) {
+      parts.push(trailingText);
+    }
+    return parts.join("");
+  } 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;
@@ -16852,6 +16873,257 @@ async function writeEncodedText(handle, encoding, text) {
   await writeAll(handle, buffer);
   return buffer.byteLength;
 }
+async function appendEncodedText(filePath, encoding, text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  const buffer = import_iconv_lite.default.encode(text, encoding);
+  await fs2.appendFile(filePath, buffer);
+  return buffer.byteLength;
+}
+async function copyFileByteRangeToHandle(sourcePath, handle, start, endExclusive) {
+  if (endExclusive <= start) {
+    return 0;
+  }
+  const stream = createReadStream(sourcePath, {
+    start,
+    end: endExclusive - 1,
+    highWaterMark: STREAM_READ_CHUNK_SIZE_BYTES
+  });
+  let bytesWritten = 0;
+  try {
+    for await (const chunk of stream) {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      await writeAll(handle, buffer);
+      bytesWritten += buffer.byteLength;
+    }
+    return bytesWritten;
+  } catch (error45) {
+    if (error45 instanceof Error && "code" in error45) {
+      throw error45;
+    }
+    throw createGbkError("GBK_IO_ERROR", `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${sourcePath}`, error45);
+  } finally {
+    stream.destroy();
+  }
+}
+function alignTextToNewlineStyle(text, newlineStyle) {
+  return newlineStyle === "crlf" ? text.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n") : newlineStyle === "lf" ? text.replace(/\r\n/g, "\n") : text;
+}
+function replaceScopedTextContent(scopeText, oldString, newString, replaceAll, newlineStyle) {
+  const occurrencesBefore = countOccurrences(scopeText, oldString);
+  if (!replaceAll && occurrencesBefore === 0) {
+    const loose = tryLooseBlockReplace(scopeText, oldString, newString);
+    if (loose !== null) {
+      return {
+        replacedText: loose.content,
+        replacements: 1,
+        occurrencesBefore: loose.occurrencesBefore
+      };
+    }
+  }
+  if (replaceAll) {
+    if (occurrencesBefore === 0) {
+      throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scopeText, oldString));
+    }
+  } 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\u9879: ${oldString}`);
+  }
+  const alignedNewString = alignTextToNewlineStyle(newString, newlineStyle);
+  return {
+    replacedText: replaceAll ? scopeText.split(oldString).join(alignedNewString) : scopeText.replace(oldString, alignedNewString),
+    replacements: replaceAll ? occurrencesBefore : 1,
+    occurrencesBefore
+  };
+}
+async function replaceLargeGbkFileTextInLineRange(input) {
+  const lineIndex = await getGbkLineIndex(input);
+  const requestedStartLine = input.startLine ?? 1;
+  const requestedEndLine = input.endLine ?? lineIndex.totalLines;
+  if (requestedEndLine < requestedStartLine) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "endLine \u4E0D\u80FD\u5C0F\u4E8E startLine");
+  }
+  const actualStartLine = Math.min(requestedStartLine, lineIndex.totalLines);
+  const actualEndLine = Math.min(requestedEndLine, lineIndex.totalLines);
+  const rangeStart = lineIndex.lineStartOffsets[Math.max(0, actualStartLine - 1)] ?? toSafeNumber(input.stat.size);
+  const rangeEnd = actualEndLine < lineIndex.totalLines ? lineIndex.lineStartOffsets[actualEndLine] : toSafeNumber(input.stat.size);
+  const scopeText = await readDecodedGbkByteRange(input, rangeStart, rangeEnd);
+  const replaced = replaceScopedTextContent(
+    scopeText,
+    input.oldString,
+    input.newString,
+    input.replaceAll,
+    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");
+  let bytesWritten = 0;
+  try {
+    bytesWritten += await copyFileByteRangeToHandle(input.filePath, handle, 0, rangeStart);
+    bytesWritten += await writeEncodedText(handle, input.encoding, replaced.replacedText);
+    bytesWritten += await copyFileByteRangeToHandle(input.filePath, handle, rangeEnd, toSafeNumber(input.stat.size));
+    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 {
+      mode: "replace",
+      filePath: input.filePath,
+      encoding: input.encoding,
+      replacements: replaced.replacements,
+      occurrencesBefore: replaced.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 replaceLargeGbkFileByAnchor(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 alignedContent = input.content.replace(/\r\n/g, "\n");
+  const anchorLength = input.anchor.length;
+  const carryLength = Math.max(anchorLength + alignedContent.length, 1);
+  let decoded = "";
+  let scanFrom = 0;
+  let totalMatches = 0;
+  let inserted = false;
+  let skipped = false;
+  let bytesWritten = 0;
+  const flushPrefix = async (preserveTailLength) => {
+    const flushLength = Math.max(0, decoded.length - preserveTailLength);
+    if (flushLength === 0) {
+      return;
+    }
+    bytesWritten += await writeEncodedText(handle, input.encoding, decoded.slice(0, flushLength));
+    decoded = decoded.slice(flushLength);
+    scanFrom = Math.max(0, scanFrom - flushLength);
+  };
+  const finalizeInserted = async () => {
+    bytesWritten += await writeEncodedText(handle, input.encoding, decoded);
+    decoded = "";
+  };
+  try {
+    await visitDecodedTextChunks(input, async (text) => {
+      decoded += text;
+      while (!inserted) {
+        const foundAt = decoded.indexOf(input.anchor, scanFrom);
+        if (foundAt === -1) {
+          break;
+        }
+        totalMatches += 1;
+        const afterAnchor = foundAt + anchorLength;
+        if (totalMatches !== input.occurrence) {
+          scanFrom = afterAnchor;
+          continue;
+        }
+        const before = decoded.slice(0, foundAt);
+        const after = decoded.slice(afterAnchor);
+        const anchorAndAfter = decoded.slice(foundAt);
+        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\u5BB9");
+          }
+          if (input.ifExists === "skip") {
+            skipped = true;
+            inserted = true;
+            bytesWritten += await writeEncodedText(handle, input.encoding, decoded);
+            decoded = "";
+            return;
+          }
+        }
+        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, alignedContent);
+          bytesWritten += await writeEncodedText(handle, input.encoding, after);
+        } else {
+          bytesWritten += await writeEncodedText(handle, input.encoding, before);
+          bytesWritten += await writeEncodedText(handle, input.encoding, alignedContent);
+          bytesWritten += await writeEncodedText(handle, input.encoding, anchorAndAfter);
+        }
+        decoded = "";
+        scanFrom = 0;
+        inserted = true;
+        return;
+      }
+      if (!inserted) {
+        await flushPrefix(carryLength);
+      }
+    });
+    if (!inserted) {
+      while (true) {
+        const foundAt = decoded.indexOf(input.anchor, scanFrom);
+        if (foundAt === -1) {
+          break;
+        }
+        totalMatches += 1;
+        const afterAnchor = foundAt + anchorLength;
+        if (totalMatches !== input.occurrence) {
+          scanFrom = afterAnchor;
+          continue;
+        }
+        const before = decoded.slice(0, foundAt);
+        const after = decoded.slice(afterAnchor);
+        const anchorAndAfter = decoded.slice(foundAt);
+        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\u5BB9");
+          }
+          if (input.ifExists === "skip") {
+            skipped = true;
+            inserted = true;
+            break;
+          }
+        }
+        decoded = input.mode === "insertAfter" ? `${before}${input.anchor}${alignedContent}${after}` : `${before}${alignedContent}${anchorAndAfter}`;
+        inserted = true;
+        break;
+      }
+    }
+    if (!inserted && totalMatches === 0) {
+      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\u5230 ${totalMatches} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7B2C ${input.occurrence} \u5904`);
+    }
+    await finalizeInserted();
+    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);
+    invalidateGbkLineIndex(input.filePath);
+    return {
+      mode: input.mode,
+      filePath: input.filePath,
+      encoding: input.encoding,
+      anchor: input.anchor,
+      occurrence: input.occurrence,
+      anchorMatches: totalMatches,
+      inserted: !skipped,
+      skipped,
+      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 replaceLargeGbkFileText(input) {
   const tempPath = path2.join(
     path2.dirname(input.filePath),
@@ -16898,6 +17170,7 @@ async function replaceLargeGbkFileText(input) {
     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);
+    invalidateGbkLineIndex(input.filePath);
     return {
       filePath: input.filePath,
       encoding: input.encoding,
@@ -16912,22 +17185,6 @@ async function replaceLargeGbkFileText(input) {
     throw error45;
   }
 }
-async function loadGbkTextFile(input) {
-  const resolved = await resolveReadableGbkFile(input);
-  if (resolved.stat.size < STREAMING_FILE_SIZE_THRESHOLD_BYTES) {
-    return await readWholeGbkTextFile(resolved);
-  }
-  const chunks = [];
-  await visitDecodedTextChunks(resolved, (text) => {
-    chunks.push(text);
-  });
-  return {
-    filePath: resolved.filePath,
-    encoding: resolved.encoding,
-    content: chunks.join(""),
-    bytesRead: resolved.stat.size
-  };
-}
 async function readGbkFile(input) {
   const offset = normalizeOptionalPositiveInteger(input.offset, "offset") ?? 1;
   const limit = normalizeOptionalPositiveInteger(input.limit, "limit") ?? 2e3;
@@ -16953,11 +17210,49 @@ async function readGbkFile(input) {
       ...lineWindow2
     };
   }
-  const collector = tail ? createTailCollector(limit) : createLineCollector(offset, limit);
-  await visitDecodedTextChunks(resolved, (text) => {
-    collector.push(text);
-  });
-  const lineWindow = collector.finish();
+  const lineIndex = await getGbkLineIndex(resolved);
+  const totalLines = lineIndex.totalLines;
+  let lineWindow;
+  if (tail) {
+    const startLine = Math.max(1, totalLines - limit + 1);
+    const expectedLineCount = totalLines - startLine + 1;
+    const startOffset = lineIndex.lineStartOffsets[startLine - 1] ?? 0;
+    const text = await readDecodedGbkByteRange(resolved, startOffset, toSafeNumber(resolved.stat.size));
+    lineWindow = {
+      startLine,
+      endLine: totalLines,
+      totalLines,
+      content: formatLineWindowContent(text, startLine, expectedLineCount),
+      truncated: startLine > 1,
+      tail: true,
+      newlineStyle: lineIndex.newlineStyle
+    };
+  } else if (offset > totalLines) {
+    lineWindow = {
+      startLine: offset,
+      endLine: totalLines,
+      totalLines,
+      content: "",
+      tail: false,
+      truncated: false,
+      newlineStyle: lineIndex.newlineStyle
+    };
+  } else {
+    const endLine = Math.min(offset + limit - 1, totalLines);
+    const expectedLineCount = endLine - offset + 1;
+    const startOffset = lineIndex.lineStartOffsets[offset - 1] ?? 0;
+    const endOffset = endLine < totalLines ? lineIndex.lineStartOffsets[endLine] : toSafeNumber(resolved.stat.size);
+    const text = await readDecodedGbkByteRange(resolved, startOffset, endOffset);
+    lineWindow = {
+      startLine: offset,
+      endLine,
+      totalLines,
+      content: formatLineWindowContent(text, offset, expectedLineCount),
+      tail: false,
+      truncated: endLine < totalLines,
+      newlineStyle: lineIndex.newlineStyle
+    };
+  }
   return {
     filePath: resolved.filePath,
     encoding: resolved.encoding,
@@ -16977,8 +17272,18 @@ async function replaceGbkFileText(input) {
   if (mode === "insertAfter" || mode === "insertBefore") {
     assertInsertArguments(input);
     const resolved2 = await resolveReadableGbkFile(normalizedInput);
-    const current2 = await readWholeGbkTextFile(resolved2);
     const occurrence = normalizeOptionalPositiveInteger(input.occurrence, "occurrence") ?? 1;
+    if (resolved2.stat.size >= STREAMING_FILE_SIZE_THRESHOLD_BYTES) {
+      return await replaceLargeGbkFileByAnchor({
+        ...resolved2,
+        mode,
+        anchor: input.anchor,
+        content: input.content,
+        occurrence,
+        ifExists: input.ifExists ?? "skip"
+      });
+    }
+    const current2 = await readWholeGbkTextFile(resolved2);
     const insertResult = insertByAnchor(
       current2.content,
       mode,
@@ -17023,24 +17328,47 @@ async function replaceGbkFileText(input) {
   }
   const replaceAll = normalizedInput.replaceAll ?? false;
   const resolved = await resolveReadableGbkFile(normalizedInput);
-  const hasScopedRange = normalizedInput.startLine !== void 0 || normalizedInput.endLine !== void 0 || normalizedInput.startAnchor !== void 0 || normalizedInput.endAnchor !== void 0;
+  const prefixedBlock = parseLineNumberPrefixedBlock(input.oldString);
+  const derivedScopedRange = prefixedBlock?.isContiguous ? {
+    startLine: normalizedInput.startLine ?? prefixedBlock.startLine,
+    endLine: normalizedInput.endLine ?? prefixedBlock.endLine,
+    oldString: prefixedBlock.strippedText
+  } : null;
+  const effectiveOldString = derivedScopedRange?.oldString ?? input.oldString;
+  const hasScopedRange = normalizedInput.startLine !== void 0 || normalizedInput.endLine !== void 0 || normalizedInput.startAnchor !== void 0 || normalizedInput.endAnchor !== void 0 || derivedScopedRange !== null;
   if (resolved.stat.size >= STREAMING_FILE_SIZE_THRESHOLD_BYTES && !hasScopedRange) {
     return await replaceLargeGbkFileText({
       ...resolved,
-      oldString: input.oldString,
+      oldString: effectiveOldString,
       newString: input.newString,
       replaceAll
     });
   }
+  if (resolved.stat.size >= STREAMING_FILE_SIZE_THRESHOLD_BYTES && normalizedInput.startAnchor === void 0 && normalizedInput.endAnchor === void 0 && (normalizedInput.startLine !== void 0 || normalizedInput.endLine !== void 0 || derivedScopedRange !== null)) {
+    return await replaceLargeGbkFileTextInLineRange({
+      ...resolved,
+      oldString: effectiveOldString,
+      newString: input.newString,
+      replaceAll,
+      startLine: derivedScopedRange?.startLine ?? normalizedInput.startLine,
+      endLine: derivedScopedRange?.endLine ?? normalizedInput.endLine
+    });
+  }
   const current = await readWholeGbkTextFile(resolved);
-  const scope = resolveEditScope(current.content, normalizedInput);
-  const occurrencesBefore = countOccurrences(scope.selectedText, input.oldString);
+  const scopedInput = derivedScopedRange === null ? normalizedInput : {
+    ...normalizedInput,
+    startLine: derivedScopedRange.startLine,
+    endLine: derivedScopedRange.endLine
+  };
+  const scope = resolveEditScope(current.content, scopedInput);
+  const occurrencesBefore = countOccurrences(scope.selectedText, effectiveOldString);
   if (!replaceAll && occurrencesBefore === 0) {
-    const loose = tryLooseBlockReplace(scope.selectedText, input.oldString, input.newString);
+    const loose = tryLooseBlockReplace(scope.selectedText, effectiveOldString, 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);
+      invalidateGbkLineIndex(current.filePath);
       return {
         mode: "replace",
         filePath: current.filePath,
@@ -17054,19 +17382,20 @@ async function replaceGbkFileText(input) {
   }
   if (replaceAll) {
     if (occurrencesBefore === 0) {
-      throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
+      throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, effectiveOldString));
     }
   } else if (occurrencesBefore === 0) {
-    throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
+    throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, effectiveOldString));
   } else if (occurrencesBefore > 1) {
-    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
+    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;
-  const replaced = replaceAll ? scope.selectedText.split(input.oldString).join(alignedNewString) : scope.selectedText.replace(input.oldString, alignedNewString);
+  const replaced = replaceAll ? scope.selectedText.split(effectiveOldString).join(alignedNewString) : scope.selectedText.replace(effectiveOldString, 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);
+  invalidateGbkLineIndex(current.filePath);
   return {
     mode: "replace",
     filePath: current.filePath,
@@ -17083,25 +17412,58 @@ async function searchGbkFile(input) {
   }
   const contextLines = Math.max(0, input.contextLines ?? 3);
   const resolved = await resolveReadableGbkFile(input);
-  const loaded = await loadGbkTextFile({
-    filePath: resolved.filePath,
-    encoding: resolved.encoding,
-    allowExternal: input.allowExternal,
-    context: input.context
-  });
-  const lines = loaded.content.split(/\r?\n/);
-  const totalLines = lines.length;
   const matches = [];
-  for (let i = 0; i < lines.length; i += 1) {
-    if (lines[i].includes(input.pattern)) {
-      matches.push({
-        lineNumber: i + 1,
-        line: lines[i],
-        contextBefore: lines.slice(Math.max(0, i - contextLines), i),
-        contextAfter: lines.slice(i + 1, Math.min(totalLines, i + 1 + contextLines))
-      });
+  const beforeBuffer = [];
+  const activeAfterCollectors = [];
+  let pending = "";
+  let totalLines = 0;
+  const emitLine = (line) => {
+    totalLines += 1;
+    for (let index = activeAfterCollectors.length - 1; index >= 0; index -= 1) {
+      const collector = activeAfterCollectors[index];
+      if (collector.remaining > 0) {
+        collector.match.contextAfter.push(line);
+        collector.remaining -= 1;
+      }
+      if (collector.remaining === 0) {
+        activeAfterCollectors.splice(index, 1);
+      }
+    }
+    if (line.includes(input.pattern)) {
+      const match = {
+        lineNumber: totalLines,
+        line,
+        contextBefore: beforeBuffer.slice(Math.max(0, beforeBuffer.length - contextLines)),
+        contextAfter: []
+      };
+      matches.push(match);
+      if (contextLines > 0) {
+        activeAfterCollectors.push({ match, remaining: contextLines });
+      }
     }
-  }
+    beforeBuffer.push(line);
+    if (beforeBuffer.length > contextLines) {
+      beforeBuffer.shift();
+    }
+  };
+  await visitDecodedTextChunks(resolved, (text) => {
+    const combined = pending + text;
+    let start = 0;
+    while (true) {
+      const newlineIndex = combined.indexOf("\n", start);
+      if (newlineIndex === -1) {
+        break;
+      }
+      let line = combined.slice(start, newlineIndex);
+      if (line.endsWith("\r")) {
+        line = line.slice(0, -1);
+      }
+      emitLine(line);
+      start = newlineIndex + 1;
+    }
+    pending = combined.slice(start);
+  });
+  emitLine(pending);
   return {
     filePath: resolved.filePath,
     encoding: resolved.encoding,
@@ -17134,24 +17496,21 @@ async function writeGbkFile(input) {
         throw error45;
       }
     }
-    let existingContent = "";
     let existed = false;
     try {
-      const existingBuffer = await fs2.readFile(candidatePath);
-      existingContent = import_iconv_lite.default.decode(existingBuffer, encoding);
+      await fs2.stat(candidatePath);
       existed = true;
     } catch (error45) {
       if (!(error45 instanceof Error && "code" in error45 && error45.code === "ENOENT")) {
         throw createGbkError("GBK_IO_ERROR", `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${candidatePath}`, error45);
       }
     }
-    const combined = existingContent + input.content;
-    const buffer = import_iconv_lite.default.encode(combined, encoding);
-    await fs2.writeFile(candidatePath, buffer);
+    const bytesWritten = await appendEncodedText(candidatePath, encoding, input.content);
+    invalidateGbkLineIndex(candidatePath);
     return {
       filePath: candidatePath,
       encoding,
-      bytesWritten: buffer.byteLength,
+      bytesWritten,
       created: !existed,
       overwritten: false,
       appended: true
@@ -17193,6 +17552,7 @@ async function writeGbkFile(input) {
     const existed = await fs2.stat(candidatePath).then(() => true).catch(() => false);
     const buffer = import_iconv_lite.default.encode(input.content, encoding);
     await fs2.writeFile(candidatePath, buffer);
+    invalidateGbkLineIndex(candidatePath);
     return {
       filePath: candidatePath,
       encoding,
@@ -17212,7 +17572,8 @@ async function writeGbkFile(input) {
 var gbk_edit_default = tool({
   description: `Edit GBK/GB18030 encoded text files with exact string replacement.
 
-Reads the FULL file content regardless of file size \u2014 not limited by gbk_read's line window.
+For whole-file replace, large files use a streaming path.
+For line-scoped replace, large files use a cached line-byte index and only decode the selected line window.
 Safe to use on files with more than 2000 lines.
 
 CRITICAL \u2014 do NOT include line number prefixes in oldString or newString:
@@ -17256,7 +17617,7 @@ Insert mode:
   },
   async execute(args, context) {
     const result = await replaceGbkFileText({ ...args, context });
-    const isReplace = !("mode" in result) || result.mode === "replace";
+    const isReplace = "replacements" in result;
     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,
@@ -17284,6 +17645,7 @@ var gbk_read_default = tool({
   description: `Read GBK/GB18030 encoded text files with line numbers.
 
 Returns up to 'limit' lines (default 2000) starting from 'offset'.
+Large files use a cached line-byte index so reading a small window does not require decoding the whole file each time.
 When the file has more lines than the window, 'truncated' is true and 'totalLines' shows the full count.
 
 IMPORTANT \u2014 line number format: each output line is prefixed with "N: " (e.g. "3787: content").
@@ -17367,7 +17729,7 @@ var gbk_write_default = tool({
   description: `Write GBK encoded text files.
 
 **append=true** (recommended for adding content to existing files):
-- Reads the existing file content and appends new content at the end.
+- Appends encoded content directly to the end of the file without re-reading the whole file.
 - Works whether the file exists or not (creates it if missing).
 - Use this whenever you want to add lines/content to an existing GBK file.
 - Example: gbk_write(filePath=..., content="\\r\\n\u65B0\u5185\u5BB9", append=true)
@@ -17680,7 +18042,7 @@ function buildLineDiffPreview(filePath, encoding, beforeText, afterText) {
   return lines.join("\n");
 }
 function buildInsertOutput(text, mode, anchor, content, occurrence, ifExists, newlineStyle) {
-  const alignedContent = alignTextToNewlineStyle(content, newlineStyle);
+  const alignedContent = alignTextToNewlineStyle2(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;
@@ -17804,7 +18166,7 @@ async function detectReadableTextFile(input) {
     hasBom: detected.hasBom
   };
 }
-function createLineCollector2(offset, limit) {
+function createLineCollector(offset, limit) {
   const lines = [];
   let pending = "";
   let totalLines = 0;
@@ -17854,7 +18216,7 @@ function createLineCollector2(offset, limit) {
     }
   };
 }
-function createTailCollector2(limit) {
+function createTailCollector(limit) {
   assertPositiveInteger(limit, "limit");
   const lines = [];
   let pending = "";
@@ -18068,7 +18430,7 @@ function resolveEditScope2(text, input) {
     rangeEnd: anchored.rangeStart + lineRanged.rangeEnd
   };
 }
-function alignTextToNewlineStyle(text, newlineStyle) {
+function alignTextToNewlineStyle2(text, newlineStyle) {
   assertStringArgument2(text, "text");
   const normalized = text.replace(/\r\n/g, "\n");
   if (newlineStyle === "crlf") {
@@ -18133,7 +18495,7 @@ async function readTextFile(input) {
       ...lineWindow2
     };
   }
-  const collector = tail ? createTailCollector2(limit) : createLineCollector2(offset, limit);
+  const collector = tail ? createTailCollector(limit) : createLineCollector(offset, limit);
   await visitDecodedTextChunks2(resolved, (text) => {
     collector.push(text);
   });
@@ -18186,7 +18548,7 @@ async function writeTextFile(input) {
   const targetHasBom = targetEncoding === "utf8-bom" ? true : existing && preserveEncoding ? existing.hasBom : targetEncoding === "utf16le" || targetEncoding === "utf16be" ? true : false;
   const baseContent = append ? existing?.content ?? "" : "";
   const rawContent = `${baseContent}${input.content}`;
-  const outputContent = existing && preserveNewlineStyle ? alignTextToNewlineStyle(rawContent, existing.newlineStyle) : rawContent;
+  const outputContent = existing && preserveNewlineStyle ? alignTextToNewlineStyle2(rawContent, existing.newlineStyle) : rawContent;
   ensureLossless(outputContent, targetEncoding, targetHasBom);
   const buffer = encodeText(outputContent, targetEncoding, targetHasBom);
   await fs3.writeFile(candidatePath, buffer);
@@ -18303,7 +18665,7 @@ async function replaceTextFileText(input) {
   } else if (occurrencesBefore > 1) {
     throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
   }
-  const alignedNewString = normalizedInput.preserveNewlineStyle === false ? input.newString : alignTextToNewlineStyle(input.newString, loaded.newlineStyle);
+  const alignedNewString = normalizedInput.preserveNewlineStyle === false ? input.newString : alignTextToNewlineStyle2(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 : resolveExplicitTextEncoding(requestedEncoding, loaded.encoding);