opencode-gbk-tools 0.1.9 → 0.1.11

package/dist/plugin/index.js

@@ -182,7 +182,7 @@ var require_internal = __commonJS({
       // Codec.
       _internal: InternalCodec
     };
-    function InternalCodec(codecOptions, iconv2) {
+    function InternalCodec(codecOptions, iconv3) {
       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 = iconv2.defaultCharUnicode;
+          this.defaultCharUnicode = iconv3.defaultCharUnicode;
         }
       }
     }
@@ -351,8 +351,8 @@ var require_utf32 = __commonJS({
     "use strict";
     var Buffer2 = require_safer().Buffer;
     exports._utf32 = Utf32Codec;
-    function Utf32Codec(codecOptions, iconv2) {
-      this.iconv = iconv2;
+    function Utf32Codec(codecOptions, iconv3) {
+      this.iconv = iconv3;
       this.bomAware = true;
       this.isLE = codecOptions.isLE;
     }
@@ -476,8 +476,8 @@ var require_utf32 = __commonJS({
     };
     exports.utf32 = Utf32AutoCodec;
     exports.ucs4 = "utf32";
-    function Utf32AutoCodec(options, iconv2) {
-      this.iconv = iconv2;
+    function Utf32AutoCodec(options, iconv3) {
+      this.iconv = iconv3;
     }
     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, iconv2) {
-      this.iconv = iconv2;
+    function Utf16Codec(codecOptions, iconv3) {
+      this.iconv = iconv3;
     }
     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, iconv2) {
-      this.iconv = iconv2;
+    function Utf7Codec(codecOptions, iconv3) {
+      this.iconv = iconv3;
     }
     Utf7Codec.prototype.encoder = Utf7Encoder;
     Utf7Codec.prototype.decoder = Utf7Decoder;
@@ -809,8 +809,8 @@ var require_utf7 = __commonJS({
       return res;
     };
     exports.utf7imap = Utf7IMAPCodec;
-    function Utf7IMAPCodec(codecOptions, iconv2) {
-      this.iconv = iconv2;
+    function Utf7IMAPCodec(codecOptions, iconv3) {
+      this.iconv = iconv3;
     }
     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, iconv2) {
+    function SBCSCodec(codecOptions, iconv3) {
       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, iconv2.defaultCharSingleByte.charCodeAt(0));
+      var encodeBuf = Buffer2.alloc(65536, iconv3.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, iconv2) {
+    function DBCSCodec(codecOptions, iconv3) {
       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 = iconv2.defaultCharUnicode;
+      this.defaultCharUnicode = iconv3.defaultCharUnicode;
       this.encodeTable = [];
       this.encodeTableSeq = [];
       var skipEncodeChars = {};
@@ -1696,7 +1696,7 @@ var require_dbcs_codec = __commonJS({
           }
         }
       }
-      this.defCharSB = this.encodeTable[0][iconv2.defaultCharSingleByte.charCodeAt(0)];
+      this.defCharSB = this.encodeTable[0][iconv3.defaultCharSingleByte.charCodeAt(0)];
       if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]["?"];
       if (this.defCharSB === UNASSIGNED) this.defCharSB = "?".charCodeAt(0);
     }
@@ -4547,10 +4547,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4911,11 +4911,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -5083,7 +5083,7 @@ function treeifyError(error45, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error46, path3 = []) => {
+  const processError = (error46, path4 = []) => {
     var _a, _b;
     for (const issue2 of error46.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -5093,7 +5093,7 @@ function treeifyError(error45, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path3, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -5125,8 +5125,8 @@ function treeifyError(error45, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path3 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path3) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -16259,6 +16259,7 @@ var GbkToolError = class extends Error {
 function createGbkError(code, message, cause) {
   return new GbkToolError(code, message, cause);
 }
+var createTextError = createGbkError;
 
 // src/lib/path-sandbox.ts
 import fs from "fs/promises";
@@ -16305,6 +16306,82 @@ async function assertPathAllowed(filePath, context, allowExternal = false) {
 
 // src/lib/gbk-file.ts
 var STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
+function assertStringArgument(value, name) {
+  if (typeof value !== "string") {
+    throw createGbkError("GBK_INVALID_ARGUMENT", `${name} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  }
+}
+function assertReplaceArguments(input) {
+  assertStringArgument(input.oldString, "oldString");
+  assertStringArgument(input.newString, "newString");
+}
+function assertInsertArguments(input) {
+  assertStringArgument(input.anchor, "anchor");
+  assertStringArgument(input.content, "content");
+  if (input.content.length === 0) {
+    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\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\u6301 startLine/endLine/startAnchor/endAnchor");
+  }
+}
+function findOccurrenceIndex(text, token, occurrence) {
+  assertStringArgument(text, "text");
+  assertStringArgument(token, "anchor");
+  assertPositiveInteger(occurrence, "occurrence");
+  if (token.length === 0) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  let count = 0;
+  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) };
+    }
+    searchFrom = index + token.length;
+  }
+  if (count === 0) {
+    throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\u70B9: ${token}`);
+  }
+  throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\u5230 ${count} \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 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\u5BB9");
+    }
+    if (ifExists === "skip") {
+      return {
+        outputText: text,
+        inserted: false,
+        skipped: true,
+        anchorMatches: located.total,
+        occurrence,
+        anchor
+      };
+    }
+  }
+  return {
+    outputText: `${text.slice(0, insertionPoint)}${alignedContent}${text.slice(insertionPoint)}`,
+    inserted: true,
+    skipped: false,
+    anchorMatches: located.total,
+    occurrence,
+    anchor
+  };
+}
 function assertEncodingSupported(encoding) {
   if (encoding !== "gbk" && encoding !== "gb18030") {
     throw createGbkError("GBK_INVALID_ENCODING", `\u4E0D\u652F\u6301\u7684\u7F16\u7801: ${encoding}`);
@@ -16474,9 +16551,11 @@ function resolveEditScope(text, input) {
   };
 }
 function normalizeNewlines(text) {
+  assertStringArgument(text, "text");
   return text.replace(/\r\n/g, "\n");
 }
 function trimRightSpaces(text) {
+  assertStringArgument(text, "text");
   return text.replace(/[ \t]+$/g, "");
 }
 function splitNormalizedLines(text) {
@@ -16572,6 +16651,8 @@ function tryLooseBlockReplace(content, oldString, newString) {
   return null;
 }
 function countOccurrences(text, target) {
+  assertStringArgument(text, "text");
+  assertStringArgument(target, "oldString");
   if (target.length === 0) {
     throw createGbkError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
   }
@@ -16887,11 +16968,56 @@ async function readGbkFile(input) {
   };
 }
 async function replaceGbkFileText(input) {
+  const mode = input.mode ?? "replace";
   const normalizedInput = {
     ...input,
     startLine: normalizeOptionalPositiveInteger(input.startLine, "startLine"),
     endLine: normalizeOptionalPositiveInteger(input.endLine, "endLine")
   };
+  if (mode === "insertAfter" || mode === "insertBefore") {
+    assertInsertArguments(input);
+    const resolved2 = await resolveReadableGbkFile(normalizedInput);
+    const current2 = await readWholeGbkTextFile(resolved2);
+    const occurrence = normalizeOptionalPositiveInteger(input.occurrence, "occurrence") ?? 1;
+    const insertResult = insertByAnchor(
+      current2.content,
+      mode,
+      input.anchor,
+      input.content,
+      occurrence,
+      input.ifExists ?? "skip",
+      detectNewlineStyle(current2.content)
+    );
+    if (insertResult.skipped) {
+      return {
+        mode,
+        filePath: current2.filePath,
+        encoding: current2.encoding,
+        anchor: insertResult.anchor,
+        occurrence: insertResult.occurrence,
+        anchorMatches: insertResult.anchorMatches,
+        inserted: false,
+        skipped: true,
+        bytesRead: current2.bytesRead,
+        bytesWritten: 0
+      };
+    }
+    const buffer2 = import_iconv_lite.default.encode(insertResult.outputText, current2.encoding);
+    await fs2.writeFile(current2.filePath, buffer2);
+    return {
+      mode,
+      filePath: current2.filePath,
+      encoding: current2.encoding,
+      anchor: insertResult.anchor,
+      occurrence: insertResult.occurrence,
+      anchorMatches: insertResult.anchorMatches,
+      inserted: true,
+      skipped: false,
+      bytesRead: current2.bytesRead,
+      bytesWritten: buffer2.byteLength
+    };
+  }
+  assertReplaceArguments(input);
   if (input.oldString.length === 0) {
     throw createGbkError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
   }
@@ -16908,14 +17034,15 @@ async function replaceGbkFileText(input) {
   }
   const current = await readWholeGbkTextFile(resolved);
   const scope = resolveEditScope(current.content, normalizedInput);
-  const occurrencesBefore = countOccurrences(scope.selectedText, normalizedInput.oldString);
+  const occurrencesBefore = countOccurrences(scope.selectedText, input.oldString);
   if (!replaceAll && occurrencesBefore === 0) {
-    const loose = tryLooseBlockReplace(scope.selectedText, normalizedInput.oldString, normalizedInput.newString);
+    const loose = tryLooseBlockReplace(scope.selectedText, input.oldString, input.newString);
     if (loose !== null) {
       const outputText2 = `${current.content.slice(0, scope.rangeStart)}${loose.content}${current.content.slice(scope.rangeEnd)}`;
       const buffer2 = import_iconv_lite.default.encode(outputText2, current.encoding);
       await fs2.writeFile(current.filePath, buffer2);
       return {
+        mode: "replace",
         filePath: current.filePath,
         encoding: current.encoding,
         replacements: 1,
@@ -16927,20 +17054,21 @@ async function replaceGbkFileText(input) {
   }
   if (replaceAll) {
     if (occurrencesBefore === 0) {
-      throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, normalizedInput.oldString));
+      throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
     }
   } else if (occurrencesBefore === 0) {
-    throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, normalizedInput.oldString));
+    throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
   } else if (occurrencesBefore > 1) {
-    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${normalizedInput.oldString}`);
+    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
   }
   const fileNewlineStyle = detectNewlineStyle(current.content);
-  const alignedNewString = fileNewlineStyle === "crlf" ? normalizedInput.newString.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n") : fileNewlineStyle === "lf" ? normalizedInput.newString.replace(/\r\n/g, "\n") : normalizedInput.newString;
-  const replaced = replaceAll ? scope.selectedText.split(normalizedInput.oldString).join(alignedNewString) : scope.selectedText.replace(normalizedInput.oldString, alignedNewString);
+  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 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 {
+    mode: "replace",
     filePath: current.filePath,
     encoding: current.encoding,
     replacements: replaceAll ? occurrencesBefore : 1,
@@ -17104,11 +17232,20 @@ Recommended workflow for large files (when gbk_read returned truncated=true):
 3. gbk_edit(oldString=<content without prefixes>, newString=<new content>)
 
 For large files, use 'startLine'/'endLine' or 'startAnchor'/'endAnchor' to narrow the search scope
-and avoid false matches. Scoped edits also improve performance on very large files.`,
+and avoid false matches. Scoped edits also improve performance on very large files.
+
+Insert mode:
+- Use mode=insertAfter or mode=insertBefore with anchor/content
+- This is recommended when the intent is "insert after label" instead of exact replacement.`,
   args: {
     filePath: tool.schema.string().describe("Target file path"),
-    oldString: tool.schema.string().describe("Exact text to replace \u2014 raw file content only, no 'N: ' line number prefixes from gbk_read output"),
-    newString: tool.schema.string().describe("Replacement text \u2014 raw content only, no line number prefixes"),
+    mode: tool.schema.enum(["replace", "insertAfter", "insertBefore"]).optional().describe("Edit mode, default replace"),
+    oldString: tool.schema.string().optional().describe("Exact text to replace in replace mode"),
+    newString: tool.schema.string().optional().describe("Replacement text in replace mode"),
+    anchor: tool.schema.string().optional().describe("Anchor text used by insertAfter/insertBefore"),
+    content: tool.schema.string().optional().describe("Inserted content used by insertAfter/insertBefore"),
+    occurrence: tool.schema.number().int().positive().optional().describe("1-based anchor occurrence for insert mode"),
+    ifExists: tool.schema.enum(["allow", "skip", "error"]).optional().describe("What to do when inserted content already exists at target position"),
     replaceAll: tool.schema.boolean().optional().describe("Replace all occurrences (default: false, requires unique match)"),
     startLine: tool.schema.union([tool.schema.number().int().positive(), tool.schema.literal(-1)]).optional().describe("Restrict edit scope to 1-based start line (inclusive)"),
     endLine: tool.schema.union([tool.schema.number().int().positive(), tool.schema.literal(-1)]).optional().describe("Restrict edit scope to 1-based end line (inclusive)"),
@@ -17119,6 +17256,25 @@ and avoid false matches. Scoped edits also improve performance on very large fil
   },
   async execute(args, context) {
     const result = await replaceGbkFileText({ ...args, context });
+    const isReplace = !("mode" in result) || result.mode === "replace";
+    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,
+      metadata: {
+        filePath: result.filePath,
+        encoding: result.encoding,
+        mode: isReplace ? "replace" : result.mode,
+        replacements: isReplace ? result.replacements : void 0,
+        occurrencesBefore: isReplace ? result.occurrencesBefore : void 0,
+        anchor: isReplace ? void 0 : result.anchor,
+        occurrence: isReplace ? void 0 : result.occurrence,
+        anchorMatches: isReplace ? void 0 : result.anchorMatches,
+        inserted: isReplace ? void 0 : result.inserted,
+        skipped: isReplace ? void 0 : result.skipped,
+        bytesRead: result.bytesRead,
+        bytesWritten: result.bytesWritten
+      }
+    });
     return JSON.stringify(result, null, 2);
   }
 });
@@ -17153,6 +17309,19 @@ Workflow when truncated=true:
   },
   async execute(args, context) {
     const result = await readGbkFile({ ...args, context });
+    const lineRange = `${result.startLine}-${result.endLine}`;
+    context.metadata({
+      title: `GBK \u8BFB\u53D6 ${result.encoding.toUpperCase()} ${lineRange}`,
+      metadata: {
+        filePath: result.filePath,
+        encoding: result.encoding,
+        lineRange,
+        totalLines: result.totalLines,
+        newlineStyle: result.newlineStyle,
+        truncated: result.truncated,
+        tail: result.tail
+      }
+    });
     return JSON.stringify(result, null, 2);
   }
 });
@@ -17180,6 +17349,15 @@ Workflow for large files:
   },
   async execute(args, context) {
     const result = await searchGbkFile({ ...args, context });
+    context.metadata({
+      title: `GBK \u641C\u7D22 ${result.encoding.toUpperCase()} ${result.matchCount} \u547D\u4E2D`,
+      metadata: {
+        filePath: result.filePath,
+        encoding: result.encoding,
+        totalLines: result.totalLines,
+        matchCount: result.matchCount
+      }
+    });
     return JSON.stringify(result, null, 2);
   }
 });
@@ -17208,6 +17386,879 @@ var gbk_write_default = tool({
   },
   async execute(args, context) {
     const result = await writeGbkFile({ ...args, context });
+    const action = result.appended ? "\u8FFD\u52A0" : result.overwritten ? "\u8986\u76D6" : "\u5199\u5165";
+    context.metadata({
+      title: `GBK ${action} ${result.encoding.toUpperCase()}`,
+      metadata: {
+        filePath: result.filePath,
+        encoding: result.encoding,
+        created: result.created,
+        overwritten: result.overwritten,
+        appended: result.appended ?? false,
+        bytesWritten: result.bytesWritten
+      }
+    });
+    return JSON.stringify(result, null, 2);
+  }
+});
+
+// src/plugin/text-guidance.ts
+var TEXT_TOOL_SYSTEM_MARKER = "[opencode-gbk-tools:text-rules]";
+var TEXT_TOOL_SYSTEM_PROMPT = [
+  TEXT_TOOL_SYSTEM_MARKER,
+  "\u6587\u672C\u6587\u4EF6\u5904\u7406\u89C4\u5219\uFF1A",
+  "- \u5904\u7406\u6587\u672C\u6587\u4EF6\u65F6\uFF0C\u4F18\u5148\u4F7F\u7528 text_read\u3001text_write\u3001text_edit\u3002",
+  "- text_* \u9ED8\u8BA4\u4F1A\u81EA\u52A8\u8BC6\u522B\u73B0\u6709\u6587\u4EF6\u7F16\u7801\uFF0C\u5E76\u5728\u4FEE\u6539\u65F6\u5C3D\u91CF\u4FDD\u6301\u539F\u7F16\u7801\u3001BOM \u548C\u6362\u884C\u98CE\u683C\u3002",
+  "- \u5982\u679C\u610F\u56FE\u662F\u2018\u5728\u67D0\u6807\u7B7E\u524D\u540E\u63D2\u5165\u5185\u5BB9\u2019\uFF0C\u4F18\u5148\u4F7F\u7528 mode=insertAfter \u6216 mode=insertBefore\uFF0C\u5E76\u4F20 anchor/content\u3002",
+  "- \u53EA\u6709\u5728\u660E\u786E\u505A\u7CBE\u786E\u66FF\u6362\u65F6\uFF0C\u624D\u4F7F\u7528 oldString/newString\u3002",
+  "- \u82E5\u68C0\u6D4B\u7F6E\u4FE1\u5EA6\u4E0D\u8DB3\u6216\u51FA\u73B0 TEXT_UNKNOWN_ENCODING\uFF0C\u8BF7\u663E\u5F0F\u6307\u5B9A encoding \u540E\u91CD\u8BD5\u3002",
+  "- \u5904\u7406\u660E\u786E\u7684 GBK/GB18030 \u6587\u4EF6\u65F6\uFF0C\u4E5F\u53EF\u7EE7\u7EED\u4F7F\u7528 gbk_read\u3001gbk_write\u3001gbk_edit\u3001gbk_search\u3002"
+].join("\n");
+function appendTextToolSystemPrompt(system) {
+  if (system.some((item) => item.includes(TEXT_TOOL_SYSTEM_MARKER))) {
+    return;
+  }
+  system.push(TEXT_TOOL_SYSTEM_PROMPT);
+}
+
+// src/lib/text-file.ts
+var import_iconv_lite2 = __toESM(require_lib(), 1);
+import fs3 from "fs/promises";
+import path3 from "path";
+var TEXT_STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
+var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+function assertStringArgument2(value, name) {
+  if (typeof value !== "string") {
+    throw createTextError("GBK_INVALID_ARGUMENT", `${name} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  }
+}
+function assertReplaceArguments2(input) {
+  assertStringArgument2(input.oldString, "oldString");
+  assertStringArgument2(input.newString, "newString");
+}
+function resolveEditMode(mode) {
+  return mode ?? "replace";
+}
+function resolveInsertIfExists(value) {
+  return value ?? "skip";
+}
+function resolveExplicitTextEncoding(value, fallback) {
+  const requested = value ?? "auto";
+  return requested === "auto" ? fallback : requested;
+}
+function isSupportedEncoding(value) {
+  return value === "utf8" || value === "utf8-bom" || value === "utf16le" || value === "utf16be" || value === "gbk" || value === "gb18030";
+}
+function assertTextEncodingSupported(encoding) {
+  if (encoding !== "auto" && !isSupportedEncoding(encoding)) {
+    throw createTextError("GBK_INVALID_ENCODING", `\u4E0D\u652F\u6301\u7684\u7F16\u7801: ${encoding}`);
+  }
+}
+function decodeUtf16be(buffer) {
+  return import_iconv_lite2.default.decode(buffer, "utf16be");
+}
+function encodeText(content, encoding, hasBom = encoding === "utf8-bom") {
+  if (encoding === "utf8") {
+    return Buffer.from(content, "utf8");
+  }
+  if (encoding === "utf8-bom") {
+    return Buffer.concat([Buffer.from([239, 187, 191]), Buffer.from(content, "utf8")]);
+  }
+  if (encoding === "utf16le") {
+    const body = Buffer.from(content, "utf16le");
+    return hasBom ? Buffer.concat([Buffer.from([255, 254]), body]) : body;
+  }
+  if (encoding === "utf16be") {
+    const body = import_iconv_lite2.default.encode(content, "utf16be");
+    return hasBom ? Buffer.concat([Buffer.from([254, 255]), body]) : body;
+  }
+  return import_iconv_lite2.default.encode(content, encoding);
+}
+function decodeText(buffer, encoding) {
+  if (encoding === "utf8") {
+    return buffer.toString("utf8");
+  }
+  if (encoding === "utf8-bom") {
+    return buffer.subarray(3).toString("utf8");
+  }
+  if (encoding === "utf16le") {
+    const withoutBom = buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 254 ? buffer.subarray(2) : buffer;
+    return withoutBom.toString("utf16le");
+  }
+  if (encoding === "utf16be") {
+    const withoutBom = buffer.length >= 2 && buffer[0] === 254 && buffer[1] === 255 ? buffer.subarray(2) : buffer;
+    return decodeUtf16be(withoutBom);
+  }
+  return import_iconv_lite2.default.decode(buffer, encoding);
+}
+function detectBom(buffer) {
+  if (buffer.length >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
+    return {
+      requestedEncoding: "auto",
+      detectedEncoding: "utf8-bom",
+      confidence: "high",
+      hasBom: true
+    };
+  }
+  if (buffer.length >= 2 && buffer[0] === 255 && buffer[1] === 254) {
+    return {
+      requestedEncoding: "auto",
+      detectedEncoding: "utf16le",
+      confidence: "high",
+      hasBom: true
+    };
+  }
+  if (buffer.length >= 2 && buffer[0] === 254 && buffer[1] === 255) {
+    return {
+      requestedEncoding: "auto",
+      detectedEncoding: "utf16be",
+      confidence: "high",
+      hasBom: true
+    };
+  }
+  return null;
+}
+function isValidUtf8(buffer) {
+  try {
+    UTF8_DECODER.decode(buffer);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasUtf16Pattern(buffer) {
+  const sample = buffer.subarray(0, Math.min(buffer.length, 512));
+  let evenZeros = 0;
+  let oddZeros = 0;
+  for (let index = 0; index < sample.length; index += 1) {
+    if (sample[index] === 0) {
+      if (index % 2 === 0) {
+        evenZeros += 1;
+      } else {
+        oddZeros += 1;
+      }
+    }
+  }
+  return {
+    utf16be: evenZeros >= 2 && evenZeros >= oddZeros * 2,
+    utf16le: oddZeros >= 2 && oddZeros >= evenZeros * 2
+  };
+}
+function looksLossyRoundTrip(buffer, encoding) {
+  const decoded = decodeText(buffer, encoding);
+  const reencoded = encodeText(decoded, encoding, false);
+  return !buffer.equals(reencoded);
+}
+function assertLikelyTextBuffer(buffer) {
+  if (!buffer.includes(0)) {
+    return;
+  }
+  const bom = detectBom(buffer);
+  if (bom?.detectedEncoding === "utf16le" || bom?.detectedEncoding === "utf16be") {
+    return;
+  }
+  const utf16Pattern = hasUtf16Pattern(buffer);
+  if (utf16Pattern.utf16be || utf16Pattern.utf16le) {
+    return;
+  }
+  throw createTextError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\u6309\u6587\u672C\u5904\u7406");
+}
+function getNearestContext2(content, oldString) {
+  assertStringArgument2(content, "content");
+  assertStringArgument2(oldString, "oldString");
+  const lines = content.split(/\r?\n/);
+  const oldLines = oldString.replace(/\r\n/g, "\n").split("\n").filter(Boolean);
+  const firstToken = oldLines[0] || oldString.trim();
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index].includes(firstToken)) {
+      return lines.slice(index, index + 4).join("\n");
+    }
+  }
+  return lines.slice(0, 4).join("\n");
+}
+function buildNoMatchMessage2(content, oldString) {
+  assertStringArgument2(content, "content");
+  assertStringArgument2(oldString, "oldString");
+  return [
+    "\u672A\u627E\u5230\u9700\u8981\u66FF\u6362\u7684\u6587\u672C\u3002",
+    "oldString \u5FC5\u987B\u4E0E\u6587\u4EF6\u5B9E\u9645\u5185\u5BB9\u5B8C\u5168\u5BF9\u5E94\u3002",
+    "\u6700\u63A5\u8FD1\u7684\u4E0A\u4E0B\u6587\uFF1A",
+    getNearestContext2(content, oldString)
+  ].join("\n");
+}
+function findOccurrenceIndex2(text, token, occurrence) {
+  assertStringArgument2(text, "text");
+  assertStringArgument2(token, "anchor");
+  assertPositiveInteger(occurrence, "occurrence");
+  if (token.length === 0) {
+    throw createTextError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  let count = 0;
+  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) };
+    }
+    searchFrom = index + token.length;
+  }
+  if (count === 0) {
+    throw createTextError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\u70B9: ${token}`);
+  }
+  throw createTextError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\u5230 ${count} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7B2C ${occurrence} \u5904`);
+}
+function assertInsertArguments2(input) {
+  assertStringArgument2(input.anchor, "anchor");
+  assertStringArgument2(input.content, "content");
+  if (input.content.length === 0) {
+    throw createTextError("GBK_INVALID_ARGUMENT", "content \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (input.replaceAll !== void 0) {
+    throw createTextError("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 createTextError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u6A21\u5F0F\u4E0D\u652F\u6301 startLine/endLine/startAnchor/endAnchor");
+  }
+}
+function buildLineDiffPreview(filePath, encoding, beforeText, afterText) {
+  const beforeLines = normalizeNewlines2(beforeText).split("\n");
+  const afterLines = normalizeNewlines2(afterText).split("\n");
+  const maxLines = Math.max(beforeLines.length, afterLines.length);
+  const lines = [
+    `--- ${path3.basename(filePath)} (${encoding})`,
+    `+++ ${path3.basename(filePath)} (${encoding})`
+  ];
+  for (let index = 0; index < maxLines; index += 1) {
+    const before = beforeLines[index];
+    const after = afterLines[index];
+    if (before !== void 0 && after !== void 0 && before === after) {
+      lines.push(` ${before}`);
+      continue;
+    }
+    if (before !== void 0) {
+      lines.push(`-${before}`);
+    }
+    if (after !== void 0) {
+      lines.push(`+${after}`);
+    }
+  }
+  return lines.join("\n");
+}
+function buildInsertOutput(text, mode, anchor, content, occurrence, ifExists, newlineStyle) {
+  const alignedContent = alignTextToNewlineStyle(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;
+  if (alreadyExists) {
+    if (ifExists === "error") {
+      throw createTextError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\u5BB9");
+    }
+    if (ifExists === "skip") {
+      return {
+        outputText: text,
+        inserted: false,
+        skipped: true,
+        anchorMatches: located.total,
+        occurrence,
+        anchor,
+        previewBefore: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + anchor.length + 80)),
+        previewAfter: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + anchor.length + 80))
+      };
+    }
+  }
+  const outputText = `${text.slice(0, insertionPoint)}${alignedContent}${text.slice(insertionPoint)}`;
+  const previewStart = Math.max(0, insertionPoint - 80);
+  const previewBeforeEnd = Math.min(text.length, insertionPoint + 80);
+  const previewAfterEnd = Math.min(outputText.length, insertionPoint + alignedContent.length + 80);
+  return {
+    outputText,
+    inserted: true,
+    skipped: false,
+    anchorMatches: located.total,
+    occurrence,
+    anchor,
+    previewBefore: text.slice(previewStart, previewBeforeEnd),
+    previewAfter: outputText.slice(previewStart, previewAfterEnd)
+  };
+}
+function detectTextEncodingFromBuffer(buffer, requestedEncoding = "auto") {
+  if (requestedEncoding !== "auto") {
+    assertTextEncodingSupported(requestedEncoding);
+    return {
+      requestedEncoding,
+      detectedEncoding: requestedEncoding,
+      confidence: "high",
+      hasBom: requestedEncoding === "utf8-bom" || requestedEncoding === "utf16le" || requestedEncoding === "utf16be"
+    };
+  }
+  const bom = detectBom(buffer);
+  if (bom) {
+    return bom;
+  }
+  const utf16Pattern = hasUtf16Pattern(buffer);
+  if (utf16Pattern.utf16be) {
+    return {
+      requestedEncoding,
+      detectedEncoding: "utf16be",
+      confidence: "medium",
+      hasBom: false
+    };
+  }
+  if (utf16Pattern.utf16le) {
+    return {
+      requestedEncoding,
+      detectedEncoding: "utf16le",
+      confidence: "medium",
+      hasBom: false
+    };
+  }
+  if (isValidUtf8(buffer)) {
+    return {
+      requestedEncoding,
+      detectedEncoding: "utf8",
+      confidence: "high",
+      hasBom: false
+    };
+  }
+  const gbkLossy = looksLossyRoundTrip(buffer, "gbk");
+  const gb18030Lossy = looksLossyRoundTrip(buffer, "gb18030");
+  if (gb18030Lossy && gbkLossy) {
+    throw createTextError("TEXT_UNKNOWN_ENCODING", "\u65E0\u6CD5\u53EF\u9760\u8BC6\u522B\u6587\u4EF6\u7F16\u7801\uFF0C\u8BF7\u663E\u5F0F\u6307\u5B9A encoding");
+  }
+  return {
+    requestedEncoding,
+    detectedEncoding: gbkLossy ? "gb18030" : "gbk",
+    confidence: gbkLossy || gb18030Lossy ? "medium" : "low",
+    hasBom: false
+  };
+}
+async function resolveReadableTextFile(input) {
+  const { candidatePath } = await assertPathAllowed(input.filePath, input.context, input.allowExternal ?? false);
+  let stat;
+  try {
+    stat = await fs3.stat(candidatePath);
+  } catch (error45) {
+    throw createTextError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\u5728: ${candidatePath}`, error45);
+  }
+  if (stat.isDirectory()) {
+    throw createTextError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\u5F55: ${candidatePath}`);
+  }
+  return { filePath: candidatePath, stat };
+}
+async function readWholeTextFile(input) {
+  const resolved = await resolveReadableTextFile(input);
+  try {
+    const buffer = await fs3.readFile(resolved.filePath);
+    assertLikelyTextBuffer(buffer);
+    const detected = detectTextEncodingFromBuffer(buffer, input.encoding ?? "auto");
+    const content = decodeText(buffer, detected.detectedEncoding);
+    return {
+      filePath: resolved.filePath,
+      bytesRead: buffer.byteLength,
+      fileSize: buffer.byteLength,
+      content,
+      encoding: detected.detectedEncoding,
+      requestedEncoding: detected.requestedEncoding,
+      detectedEncoding: detected.detectedEncoding,
+      confidence: detected.confidence,
+      hasBom: detected.hasBom,
+      newlineStyle: detectNewlineStyle(content)
+    };
+  } catch (error45) {
+    if (error45 instanceof Error && "code" in error45) {
+      throw error45;
+    }
+    throw createTextError("GBK_IO_ERROR", `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${resolved.filePath}`, error45);
+  }
+}
+function collectTailLines2(text, limit) {
+  assertPositiveInteger(limit, "limit");
+  const lines = text.split(/\r?\n/);
+  const totalLines = lines.length;
+  const startLine = Math.max(1, totalLines - limit + 1);
+  const selected = lines.slice(startLine - 1);
+  return {
+    startLine,
+    endLine: totalLines,
+    totalLines,
+    content: selected.map((line, index) => `${startLine + index}: ${line}`).join("\n"),
+    truncated: startLine > 1,
+    tail: true
+  };
+}
+function normalizeNewlines2(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function applyLineRange2(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 actualStartLine = startLine ?? 1;
+  const actualEndLine = endLine ?? lines.length;
+  assertPositiveInteger(actualStartLine, "startLine");
+  assertPositiveInteger(actualEndLine, "endLine");
+  if (actualEndLine < actualStartLine) {
+    throw createTextError("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 applyAnchors2(text, startAnchor, endAnchor) {
+  if (!startAnchor && !endAnchor) {
+    return {
+      selectedText: text,
+      rangeStart: 0,
+      rangeEnd: text.length
+    };
+  }
+  let rangeStart = 0;
+  let rangeEnd = text.length;
+  if (startAnchor) {
+    const found = text.indexOf(startAnchor);
+    if (found === -1) {
+      throw createTextError("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 createTextError("GBK_NO_MATCH", `\u672A\u627E\u5230\u7ED3\u675F\u951A\u70B9: ${endAnchor}`);
+    }
+    rangeEnd = found;
+  }
+  if (rangeEnd < rangeStart) {
+    throw createTextError("GBK_INVALID_ARGUMENT", "\u951A\u70B9\u8303\u56F4\u65E0\u6548");
+  }
+  return {
+    selectedText: text.slice(rangeStart, rangeEnd),
+    rangeStart,
+    rangeEnd
+  };
+}
+function resolveEditScope2(text, input) {
+  const anchored = applyAnchors2(text, input.startAnchor, input.endAnchor);
+  const lineRanged = applyLineRange2(anchored.selectedText, input.startLine, input.endLine);
+  return {
+    selectedText: lineRanged.selectedText,
+    rangeStart: anchored.rangeStart + lineRanged.rangeStart,
+    rangeEnd: anchored.rangeStart + lineRanged.rangeEnd
+  };
+}
+function alignTextToNewlineStyle(text, newlineStyle) {
+  assertStringArgument2(text, "text");
+  const normalized = text.replace(/\r\n/g, "\n");
+  if (newlineStyle === "crlf") {
+    return normalized.replace(/\n/g, "\r\n");
+  }
+  if (newlineStyle === "lf") {
+    return normalized;
+  }
+  return text;
+}
+function ensureLossless(input, encoding, hasBom = encoding === "utf8-bom") {
+  assertStringArgument2(input, "content");
+  const buffer = encodeText(input, encoding, hasBom);
+  const roundTrip = decodeText(buffer, encoding);
+  if (roundTrip !== input) {
+    throw createTextError("TEXT_ENCODING_LOSSY", `\u5185\u5BB9\u65E0\u6CD5\u65E0\u635F\u5199\u5165\u7F16\u7801 ${encoding}`);
+  }
+}
+async function ensureParentDirectory(parent, createDirectories) {
+  try {
+    const parentStat = await fs3.stat(parent);
+    if (!parentStat.isDirectory()) {
+      throw createTextError("GBK_PARENT_DIRECTORY_MISSING", `\u7236\u76EE\u5F55\u4E0D\u5B58\u5728: ${parent}`);
+    }
+  } catch (error45) {
+    if (error45 instanceof Error && "code" in error45 && error45.code === "ENOENT") {
+      if (!createDirectories) {
+        throw createTextError("GBK_PARENT_DIRECTORY_MISSING", `\u7236\u76EE\u5F55\u4E0D\u5B58\u5728: ${parent}`);
+      }
+      await fs3.mkdir(parent, { recursive: true });
+      return;
+    }
+    throw error45;
+  }
+}
+async function readTextFile(input) {
+  const offset = normalizeOptionalPositiveInteger(input.offset, "offset") ?? 1;
+  const limit = normalizeOptionalPositiveInteger(input.limit, "limit") ?? 2e3;
+  const tail = input.tail ?? false;
+  const loaded = await readWholeTextFile(input);
+  const lineWindow = tail ? collectTailLines2(loaded.content, limit) : {
+    ...splitLinesWithNumbers(loaded.content, offset, limit),
+    tail: false,
+    truncated: false
+  };
+  if (!tail) {
+    lineWindow.truncated = lineWindow.endLine < lineWindow.totalLines;
+  }
+  return {
+    filePath: loaded.filePath,
+    encoding: loaded.encoding,
+    requestedEncoding: loaded.requestedEncoding,
+    detectedEncoding: loaded.detectedEncoding,
+    confidence: loaded.confidence,
+    hasBom: loaded.hasBom,
+    bytesRead: loaded.bytesRead,
+    fileSize: loaded.fileSize,
+    streamed: false,
+    newlineStyle: loaded.newlineStyle,
+    ...lineWindow
+  };
+}
+async function writeTextFile(input) {
+  assertStringArgument2(input.content, "content");
+  const requestedEncoding = input.encoding ?? "auto";
+  assertTextEncodingSupported(requestedEncoding);
+  const preserveEncoding = input.preserveEncoding ?? true;
+  const preserveNewlineStyle = input.preserveNewlineStyle ?? true;
+  const createDirectories = input.createDirectories ?? true;
+  const overwrite = input.overwrite ?? false;
+  const append = input.append ?? false;
+  const { candidatePath } = await assertPathAllowed(input.filePath, input.context, input.allowExternal ?? false);
+  const parent = path3.dirname(candidatePath);
+  await ensureParentDirectory(parent, createDirectories);
+  let existing = null;
+  try {
+    existing = await readWholeTextFile({
+      filePath: candidatePath,
+      encoding: requestedEncoding,
+      allowExternal: input.allowExternal,
+      context: input.context
+    });
+  } catch (error45) {
+    if (!(error45 instanceof Error && "code" in error45 && error45.code === "GBK_FILE_NOT_FOUND")) {
+      throw error45;
+    }
+  }
+  if (existing && !append && !overwrite) {
+    throw createTextError("GBK_FILE_EXISTS", `\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\u5728: ${candidatePath}`);
+  }
+  const targetEncoding = existing && preserveEncoding ? existing.encoding : requestedEncoding === "auto" ? "utf8" : requestedEncoding;
+  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;
+  ensureLossless(outputContent, targetEncoding, targetHasBom);
+  const buffer = encodeText(outputContent, targetEncoding, targetHasBom);
+  await fs3.writeFile(candidatePath, buffer);
+  return {
+    filePath: candidatePath,
+    encoding: targetEncoding,
+    requestedEncoding,
+    detectedEncoding: existing?.encoding ?? null,
+    confidence: existing?.confidence ?? null,
+    hasBom: targetHasBom,
+    bytesWritten: buffer.byteLength,
+    created: !existing,
+    overwritten: Boolean(existing) && !append,
+    appended: append,
+    newlineStyle: detectNewlineStyle(outputContent)
+  };
+}
+async function replaceTextFileText(input) {
+  const mode = resolveEditMode(input.mode);
+  const normalizedInput = {
+    ...input,
+    startLine: normalizeOptionalPositiveInteger(input.startLine, "startLine"),
+    endLine: normalizeOptionalPositiveInteger(input.endLine, "endLine")
+  };
+  const loaded = await readWholeTextFile({
+    filePath: input.filePath,
+    encoding: input.encoding ?? "auto",
+    allowExternal: input.allowExternal,
+    context: input.context
+  });
+  if (mode === "insertAfter" || mode === "insertBefore") {
+    assertInsertArguments2(normalizedInput);
+    const occurrence = normalizeOptionalPositiveInteger(normalizedInput.occurrence, "occurrence") ?? 1;
+    const insertResult = buildInsertOutput(
+      loaded.content,
+      mode,
+      normalizedInput.anchor,
+      normalizedInput.content,
+      occurrence,
+      resolveInsertIfExists(normalizedInput.ifExists),
+      loaded.newlineStyle
+    );
+    if (insertResult.skipped) {
+      return {
+        mode,
+        filePath: loaded.filePath,
+        encoding: loaded.encoding,
+        requestedEncoding: loaded.requestedEncoding,
+        detectedEncoding: loaded.detectedEncoding,
+        confidence: loaded.confidence,
+        hasBom: loaded.hasBom,
+        anchor: insertResult.anchor,
+        occurrence: insertResult.occurrence,
+        anchorMatches: insertResult.anchorMatches,
+        inserted: false,
+        skipped: true,
+        bytesRead: loaded.bytesRead,
+        bytesWritten: 0,
+        newlineStyle: loaded.newlineStyle
+      };
+    }
+    const targetEncoding2 = (normalizedInput.preserveEncoding ?? true) || (normalizedInput.encoding ?? "auto") === "auto" ? loaded.encoding : resolveExplicitTextEncoding(normalizedInput.encoding, loaded.encoding);
+    const targetHasBom2 = normalizedInput.preserveEncoding === false ? targetEncoding2 === "utf8-bom" || targetEncoding2 === "utf16le" || targetEncoding2 === "utf16be" : loaded.hasBom;
+    ensureLossless(insertResult.outputText, targetEncoding2, targetHasBom2);
+    const buffer2 = encodeText(insertResult.outputText, targetEncoding2, targetHasBom2);
+    await fs3.writeFile(loaded.filePath, buffer2);
+    return {
+      mode,
+      filePath: loaded.filePath,
+      encoding: targetEncoding2,
+      requestedEncoding: loaded.requestedEncoding,
+      detectedEncoding: loaded.detectedEncoding,
+      confidence: loaded.confidence,
+      hasBom: targetHasBom2,
+      anchor: insertResult.anchor,
+      occurrence: insertResult.occurrence,
+      anchorMatches: insertResult.anchorMatches,
+      inserted: true,
+      skipped: false,
+      bytesRead: loaded.bytesRead,
+      bytesWritten: buffer2.byteLength,
+      newlineStyle: detectNewlineStyle(insertResult.outputText)
+    };
+  }
+  assertReplaceArguments2(input);
+  if (input.oldString.length === 0) {
+    throw createTextError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const scope = resolveEditScope2(loaded.content, normalizedInput);
+  const replaceAll = normalizedInput.replaceAll ?? false;
+  const preserveEncoding = normalizedInput.preserveEncoding ?? true;
+  const requestedEncoding = normalizedInput.encoding ?? "auto";
+  const occurrencesBefore = countOccurrences(scope.selectedText, input.oldString);
+  if (replaceAll) {
+    if (occurrencesBefore === 0) {
+      throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, input.oldString));
+    }
+  } else if (occurrencesBefore === 0) {
+    throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, input.oldString));
+  } 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 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);
+  const targetHasBom = preserveEncoding ? loaded.hasBom : targetEncoding === "utf8-bom" || targetEncoding === "utf16le" || targetEncoding === "utf16be";
+  ensureLossless(outputText, targetEncoding, targetHasBom);
+  const buffer = encodeText(outputText, targetEncoding, targetHasBom);
+  await fs3.writeFile(loaded.filePath, buffer);
+  return {
+    mode: "replace",
+    filePath: loaded.filePath,
+    encoding: targetEncoding,
+    requestedEncoding: loaded.requestedEncoding,
+    detectedEncoding: loaded.detectedEncoding,
+    confidence: loaded.confidence,
+    hasBom: targetHasBom,
+    replacements: replaceAll ? occurrencesBefore : 1,
+    occurrencesBefore,
+    bytesRead: loaded.bytesRead,
+    bytesWritten: buffer.byteLength,
+    newlineStyle: detectNewlineStyle(outputText)
+  };
+}
+async function createTextDiffPreview(input) {
+  const mode = resolveEditMode(input.mode);
+  const loaded = await readWholeTextFile({
+    filePath: input.filePath,
+    encoding: input.encoding ?? "auto",
+    allowExternal: input.allowExternal,
+    context: input.context
+  });
+  if (mode === "insertAfter" || mode === "insertBefore") {
+    assertInsertArguments2(input);
+    const occurrence = normalizeOptionalPositiveInteger(input.occurrence, "occurrence") ?? 1;
+    const insertResult = buildInsertOutput(
+      loaded.content,
+      mode,
+      input.anchor,
+      input.content,
+      occurrence,
+      resolveInsertIfExists(input.ifExists),
+      loaded.newlineStyle
+    );
+    return {
+      filePath: loaded.filePath,
+      encoding: loaded.encoding,
+      preview: buildLineDiffPreview(loaded.filePath, loaded.encoding, insertResult.previewBefore, insertResult.previewAfter)
+    };
+  }
+  assertReplaceArguments2(input);
+  const scope = resolveEditScope2(loaded.content, input);
+  const alignedNewString = alignTextToNewlineStyle(input.newString, loaded.newlineStyle);
+  const replaced = input.replaceAll ?? false ? scope.selectedText.split(input.oldString).join(alignedNewString) : scope.selectedText.replace(input.oldString, alignedNewString);
+  return {
+    filePath: loaded.filePath,
+    encoding: loaded.encoding,
+    preview: buildLineDiffPreview(loaded.filePath, loaded.encoding, scope.selectedText, replaced)
+  };
+}
+
+// src/tools/text_edit.ts
+var text_edit_default = tool({
+  description: `Edit text files with automatic encoding detection and preservation.
+
+- Existing files keep their original encoding and BOM by default.
+- Existing newline style is preserved by default.
+- Replace mode uses oldString/newString.
+- Insert mode uses mode=insertAfter or insertBefore with anchor/content.`,
+  args: {
+    filePath: tool.schema.string().describe("Target file path"),
+    mode: tool.schema.enum(["replace", "insertAfter", "insertBefore"]).optional().describe("Edit mode, default replace"),
+    oldString: tool.schema.string().optional().describe("Exact text to replace when mode=replace"),
+    newString: tool.schema.string().optional().describe("Replacement text when mode=replace"),
+    anchor: tool.schema.string().optional().describe("Anchor text used by insertAfter/insertBefore"),
+    content: tool.schema.string().optional().describe("Inserted content used by insertAfter/insertBefore"),
+    occurrence: tool.schema.number().int().positive().optional().describe("1-based anchor occurrence for insert mode"),
+    ifExists: tool.schema.enum(["allow", "skip", "error"]).optional().describe("What to do when inserted content already exists at target position"),
+    replaceAll: tool.schema.boolean().optional().describe("Replace all occurrences"),
+    startLine: tool.schema.number().int().positive().optional().describe("Start line for scoped edit"),
+    endLine: tool.schema.number().int().positive().optional().describe("End line for scoped edit"),
+    startAnchor: tool.schema.string().optional().describe("Start anchor for scoped edit"),
+    endAnchor: tool.schema.string().optional().describe("End anchor for scoped edit"),
+    encoding: tool.schema.enum(["auto", "utf8", "utf8-bom", "utf16le", "utf16be", "gbk", "gb18030"]).optional().describe("Encoding override, default auto"),
+    preserveEncoding: tool.schema.boolean().optional().describe("Preserve detected file encoding"),
+    preserveNewlineStyle: tool.schema.boolean().optional().describe("Preserve detected file newline style"),
+    allowExternal: tool.schema.boolean().optional().describe("Allow paths outside workspace root")
+  },
+  async execute(args, context) {
+    const result = await replaceTextFileText({ ...args, context });
+    const preview = await createTextDiffPreview({ ...args, context });
+    const title = result.mode === "replace" ? `\u6587\u672C\u7F16\u8F91 ${result.encoding.toUpperCase()} x${result.replacements}` : result.inserted ? `\u6587\u672C\u63D2\u5165 ${result.encoding.toUpperCase()} #${result.occurrence}` : `\u6587\u672C\u8DF3\u8FC7 ${result.encoding.toUpperCase()} #${result.occurrence}`;
+    context.metadata({
+      title,
+      metadata: {
+        filePath: result.filePath,
+        encoding: result.encoding,
+        requestedEncoding: result.requestedEncoding,
+        confidence: result.confidence,
+        hasBom: result.hasBom,
+        mode: result.mode,
+        replacements: result.mode === "replace" ? result.replacements : void 0,
+        occurrencesBefore: result.mode === "replace" ? result.occurrencesBefore : void 0,
+        anchor: result.mode === "replace" ? void 0 : result.anchor,
+        occurrence: result.mode === "replace" ? void 0 : result.occurrence,
+        anchorMatches: result.mode === "replace" ? void 0 : result.anchorMatches,
+        inserted: result.mode === "replace" ? void 0 : result.inserted,
+        skipped: result.mode === "replace" ? void 0 : result.skipped,
+        newlineStyle: result.newlineStyle,
+        diffPreview: preview.preview
+      }
+    });
+    return JSON.stringify(result, null, 2);
+  }
+});
+
+// src/tools/text_read.ts
+var text_read_default = tool({
+  description: `Read text files with automatic encoding detection and preservation.
+
+- Default encoding=auto detects the existing file encoding.
+- Supported encodings: utf8, utf8-bom, utf16le, utf16be, gbk, gb18030.
+- Returns line-numbered content and detected encoding metadata.`,
+  args: {
+    filePath: tool.schema.string().describe("Target file path"),
+    offset: tool.schema.number().int().positive().optional().describe("1-based start line"),
+    limit: tool.schema.number().int().positive().optional().describe("Maximum lines to return"),
+    tail: tool.schema.boolean().optional().describe("Read from file end instead of start"),
+    encoding: tool.schema.enum(["auto", "utf8", "utf8-bom", "utf16le", "utf16be", "gbk", "gb18030"]).optional().describe("Encoding override, default auto"),
+    allowExternal: tool.schema.boolean().optional().describe("Allow paths outside workspace root")
+  },
+  async execute(args, context) {
+    const result = await readTextFile({ ...args, context });
+    const lineRange = `${result.startLine}-${result.endLine}`;
+    context.metadata({
+      title: `\u6587\u672C\u8BFB\u53D6 ${result.encoding.toUpperCase()} ${lineRange}`,
+      metadata: {
+        filePath: result.filePath,
+        encoding: result.encoding,
+        requestedEncoding: result.requestedEncoding,
+        confidence: result.confidence,
+        hasBom: result.hasBom,
+        lineRange,
+        totalLines: result.totalLines,
+        newlineStyle: result.newlineStyle,
+        truncated: result.truncated
+      }
+    });
+    return JSON.stringify(result, null, 2);
+  }
+});
+
+// src/tools/text_write.ts
+var text_write_default = tool({
+  description: `Write text files while preserving detected encoding and newline style by default.
+
+- Existing files keep their original encoding when encoding=auto.
+- New files default to utf8 unless encoding is specified.
+- Supports append and overwrite modes.`,
+  args: {
+    filePath: tool.schema.string().describe("Target file path"),
+    content: tool.schema.string().describe("Text content to write or append"),
+    encoding: tool.schema.enum(["auto", "utf8", "utf8-bom", "utf16le", "utf16be", "gbk", "gb18030"]).optional().describe("Encoding override, default auto"),
+    createDirectories: tool.schema.boolean().optional().describe("Create parent directories"),
+    overwrite: tool.schema.boolean().optional().describe("Overwrite existing file"),
+    append: tool.schema.boolean().optional().describe("Append content to existing file"),
+    preserveEncoding: tool.schema.boolean().optional().describe("Preserve detected file encoding when file exists"),
+    preserveNewlineStyle: tool.schema.boolean().optional().describe("Preserve detected file newline style when file exists"),
+    allowExternal: tool.schema.boolean().optional().describe("Allow paths outside workspace root")
+  },
+  async execute(args, context) {
+    const result = await writeTextFile({ ...args, context });
+    const action = result.appended ? "\u8FFD\u52A0" : result.overwritten ? "\u8986\u76D6" : "\u5199\u5165";
+    context.metadata({
+      title: `\u6587\u672C${action} ${result.encoding.toUpperCase()}`,
+      metadata: {
+        filePath: result.filePath,
+        encoding: result.encoding,
+        requestedEncoding: result.requestedEncoding,
+        detectedEncoding: result.detectedEncoding,
+        confidence: result.confidence,
+        hasBom: result.hasBom,
+        created: result.created,
+        overwritten: result.overwritten,
+        appended: result.appended,
+        newlineStyle: result.newlineStyle
+      }
+    });
     return JSON.stringify(result, null, 2);
   }
 });
@@ -17221,7 +18272,13 @@ var pluginModule = {
         gbk_read: gbk_read_default,
         gbk_write: gbk_write_default,
         gbk_edit: gbk_edit_default,
-        gbk_search: gbk_search_default
+        gbk_search: gbk_search_default,
+        text_read: text_read_default,
+        text_write: text_write_default,
+        text_edit: text_edit_default
+      },
+      async "experimental.chat.system.transform"(_input, output) {
+        appendTextToolSystemPrompt(output.system);
       }
     };
   }