opencode-gbk-tools 0.1.13 → 0.1.15

package/dist/opencode-tools/gbk_read.js

@@ -16305,6 +16305,11 @@ 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 assertEncodingSupported(encoding) {
   if (encoding !== "gbk" && encoding !== "gb18030") {
     throw createGbkError("GBK_INVALID_ENCODING", `\u4E0D\u652F\u6301\u7684\u7F16\u7801: ${encoding}`);
@@ -16392,6 +16397,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");
+}
 async function readBufferAsText(buffer, encoding) {
   assertEncodingSupported(encoding);
   assertNotBinary(buffer);
@@ -16433,21 +16448,36 @@ async function readWholeGbkTextFile(input) {
     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);
+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 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);
-      const text = decoder.write(buffer);
-      if (text.length > 0) {
-        await visitor(text);
+      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;
+        }
+        previousByteWasCR = byte === 13;
       }
-    }
-    const trailingText = decoder.end();
-    if (trailingText && trailingText.length > 0) {
-      await visitor(trailingText);
+      byteOffset += buffer.length;
     }
   } catch (error45) {
     if (error45 instanceof Error && "code" in error45) {
@@ -16457,110 +16487,50 @@ async function visitDecodedTextChunks(input, visitor) {
   } 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)
+  };
+  gbkLineIndexCache.set(input.filePath, result);
+  return result;
 }
-function createLineCollector(offset, limit) {
-  const lines = [];
-  let pending = "";
-  let totalLines = 0;
-  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;
-        }
-        emitLine(line);
-        start = newlineIndex + 1;
+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 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)
-      };
     }
-  };
-}
-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();
+    const trailingText = decoder.end() ?? "";
+    if (trailingText.length > 0) {
+      parts.push(trailingText);
     }
-  };
-  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;
-      }
-      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)
-      };
+    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 readGbkFile(input) {
   const offset = normalizeOptionalPositiveInteger(input.offset, "offset") ?? 1;
@@ -16587,11 +16557,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,
@@ -16607,6 +16615,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").

package/dist/opencode-tools/gbk_search.js

@@ -16305,6 +16305,7 @@ 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;
 function assertEncodingSupported(encoding) {
   if (encoding !== "gbk" && encoding !== "gb18030") {
     throw createGbkError("GBK_INVALID_ENCODING", `\u4E0D\u652F\u6301\u7684\u7F16\u7801: ${encoding}`);
@@ -16315,11 +16316,6 @@ function assertNotBinary(buffer) {
     throw createGbkError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\u6309 GBK \u6587\u672C\u5904\u7406");
   }
 }
-async function readBufferAsText(buffer, encoding) {
-  assertEncodingSupported(encoding);
-  assertNotBinary(buffer);
-  return import_iconv_lite.default.decode(buffer, encoding);
-}
 async function resolveReadableGbkFile(input) {
   const encoding = input.encoding ?? "gbk";
   assertEncodingSupported(encoding);
@@ -16339,26 +16335,9 @@ async function resolveReadableGbkFile(input) {
     stat
   };
 }
-async function readWholeGbkTextFile(input) {
-  try {
-    const buffer = await fs2.readFile(input.filePath);
-    const content = await readBufferAsText(buffer, input.encoding);
-    return {
-      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: ${input.filePath}`, error45);
-  }
-}
 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);
@@ -16381,47 +16360,64 @@ async function visitDecodedTextChunks(input, visitor) {
     stream.destroy();
   }
 }
-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 searchGbkFile(input) {
   if (input.pattern.length === 0) {
     throw createGbkError("GBK_INVALID_ARGUMENT", "pattern \u4E0D\u80FD\u4E3A\u7A7A");
   }
   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,

package/dist/opencode-tools/gbk_write.js

@@ -16305,11 +16305,24 @@ 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 invalidateGbkLineIndex(filePath) {
+  gbkLineIndexCache.delete(filePath);
+}
 function assertEncodingSupported(encoding) {
   if (encoding !== "gbk" && encoding !== "gb18030") {
     throw createGbkError("GBK_INVALID_ENCODING", `\u4E0D\u652F\u6301\u7684\u7F16\u7801: ${encoding}`);
   }
 }
+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 writeGbkFile(input) {
   const encoding = input.encoding ?? "gbk";
   const createDirectories = input.createDirectories ?? true;
@@ -16334,24 +16347,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
@@ -16393,6 +16403,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,
@@ -16413,7 +16424,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)

package/dist/opencode-tools/text_edit.js

@@ -16311,6 +16311,7 @@ import { createReadStream } from "fs";
 import fs2 from "fs/promises";
 import path2 from "path";
 var STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
+var STREAM_READ_CHUNK_SIZE_BYTES = 1024 * 1024;
 function assertStringArgument(value, name) {
   if (typeof value !== "string") {
     throw createGbkError("GBK_INVALID_ARGUMENT", `${name} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);

package/dist/opencode-tools/text_read.js

@@ -16311,6 +16311,7 @@ import { createReadStream } from "fs";
 import fs2 from "fs/promises";
 import path2 from "path";
 var STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
+var STREAM_READ_CHUNK_SIZE_BYTES = 1024 * 1024;
 function assertPositiveInteger(value, name) {
   if (!Number.isInteger(value) || Number(value) <= 0) {
     throw createGbkError("GBK_INVALID_ARGUMENT", `${name} \u5FC5\u987B\u662F\u6B63\u6574\u6570`);

package/dist/opencode-tools/text_write.js

@@ -16311,6 +16311,7 @@ import { createReadStream } from "fs";
 import fs2 from "fs/promises";
 import path2 from "path";
 var STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
+var STREAM_READ_CHUNK_SIZE_BYTES = 1024 * 1024;
 function detectNewlineStyle(text) {
   const crlfCount = (text.match(/\r\n/g) ?? []).length;
   const lfCount = (text.match(/(^|[^\r])\n/g) ?? []).length;