opencode-gbk-tools 0.1.10 → 0.1.12

package/dist/opencode-tools/text_edit.js

@@ -16309,6 +16309,11 @@ import { createReadStream } from "fs";
 import fs2 from "fs/promises";
 import path2 from "path";
 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 assertPositiveInteger(value, name) {
   if (!Number.isInteger(value) || Number(value) <= 0) {
     throw createGbkError("GBK_INVALID_ARGUMENT", `${name} \u5FC5\u987B\u662F\u6B63\u6574\u6570`);
@@ -16336,6 +16341,8 @@ function detectNewlineStyle(text) {
   return "none";
 }
 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");
   }
@@ -16354,6 +16361,25 @@ function countOccurrences(text, target) {
 // src/lib/text-file.ts
 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 assertReplaceArguments(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";
 }
@@ -16472,6 +16498,8 @@ function assertLikelyTextBuffer(buffer) {
   throw createTextError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\u6309\u6587\u672C\u5904\u7406");
 }
 function getNearestContext(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();
@@ -16483,6 +16511,8 @@ function getNearestContext(content, oldString) {
   return lines.slice(0, 4).join("\n");
 }
 function buildNoMatchMessage(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",
@@ -16490,6 +16520,105 @@ function buildNoMatchMessage(content, oldString) {
     getNearestContext(content, oldString)
   ].join("\n");
 }
+function findOccurrenceIndex(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 assertInsertArguments(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 = normalizeNewlines(beforeText).split("\n");
+  const afterLines = normalizeNewlines(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 = 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 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);
@@ -16665,6 +16794,7 @@ function resolveEditScope(text, input) {
   };
 }
 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");
@@ -16675,6 +16805,7 @@ function alignTextToNewlineStyle(text, newlineStyle) {
   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) {
@@ -16682,43 +16813,100 @@ function ensureLossless(input, encoding, hasBom = encoding === "utf8-bom") {
   }
 }
 async function replaceTextFileText(input) {
+  const mode = resolveEditMode(input.mode);
   const normalizedInput = {
     ...input,
     startLine: normalizeOptionalPositiveInteger(input.startLine, "startLine"),
     endLine: normalizeOptionalPositiveInteger(input.endLine, "endLine")
   };
-  if (input.oldString.length === 0) {
-    throw createTextError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
-  }
   const loaded = await readWholeTextFile({
     filePath: input.filePath,
     encoding: input.encoding ?? "auto",
     allowExternal: input.allowExternal,
     context: input.context
   });
+  if (mode === "insertAfter" || mode === "insertBefore") {
+    assertInsertArguments(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)
+    };
+  }
+  assertReplaceArguments(input);
+  if (input.oldString.length === 0) {
+    throw createTextError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
+  }
   const scope = resolveEditScope(loaded.content, normalizedInput);
   const replaceAll = normalizedInput.replaceAll ?? false;
   const preserveEncoding = normalizedInput.preserveEncoding ?? true;
   const requestedEncoding = normalizedInput.encoding ?? "auto";
-  const occurrencesBefore = countOccurrences(scope.selectedText, normalizedInput.oldString);
+  const occurrencesBefore = countOccurrences(scope.selectedText, input.oldString);
   if (replaceAll) {
     if (occurrencesBefore === 0) {
-      throw createTextError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, normalizedInput.oldString));
+      throw createTextError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
     }
   } else if (occurrencesBefore === 0) {
-    throw createTextError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, normalizedInput.oldString));
+    throw createTextError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, input.oldString));
   } else if (occurrencesBefore > 1) {
-    throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${normalizedInput.oldString}`);
+    throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
   }
-  const alignedNewString = normalizedInput.preserveNewlineStyle === false ? normalizedInput.newString : alignTextToNewlineStyle(normalizedInput.newString, loaded.newlineStyle);
-  const replaced = replaceAll ? scope.selectedText.split(normalizedInput.oldString).join(alignedNewString) : scope.selectedText.replace(normalizedInput.oldString, alignedNewString);
+  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 : requestedEncoding;
+  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,
@@ -16733,40 +16921,39 @@ async function replaceTextFileText(input) {
   };
 }
 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") {
+    assertInsertArguments(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)
+    };
+  }
+  assertReplaceArguments(input);
   const scope = resolveEditScope(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);
-  const beforeLines = normalizeNewlines(scope.selectedText).split("\n");
-  const afterLines = normalizeNewlines(replaced).split("\n");
-  const maxLines = Math.max(beforeLines.length, afterLines.length);
-  const lines = [
-    `--- ${path3.basename(loaded.filePath)} (${loaded.encoding})`,
-    `+++ ${path3.basename(loaded.filePath)} (${loaded.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 {
     filePath: loaded.filePath,
     encoding: loaded.encoding,
-    preview: lines.join("\n")
+    preview: buildLineDiffPreview(loaded.filePath, loaded.encoding, scope.selectedText, replaced)
   };
 }
 
@@ -16776,11 +16963,17 @@ var text_edit_default = tool({
 
 - Existing files keep their original encoding and BOM by default.
 - Existing newline style is preserved by default.
-- Use startLine/endLine or anchors to narrow the edit scope.`,
+- Replace mode uses oldString/newString.
+- Insert mode uses mode=insertAfter or insertBefore with anchor/content.`,
   args: {
     filePath: tool.schema.string().describe("Target file path"),
-    oldString: tool.schema.string().describe("Exact text to replace"),
-    newString: tool.schema.string().describe("Replacement text"),
+    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"),
@@ -16794,16 +16987,23 @@ var text_edit_default = tool({
   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: `\u6587\u672C\u7F16\u8F91 ${result.encoding.toUpperCase()} x${result.replacements}`,
+      title,
       metadata: {
         filePath: result.filePath,
         encoding: result.encoding,
         requestedEncoding: result.requestedEncoding,
         confidence: result.confidence,
         hasBom: result.hasBom,
-        replacements: result.replacements,
-        occurrencesBefore: result.occurrencesBefore,
+        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
       }

package/dist/opencode-tools/text_write.js

@@ -16327,6 +16327,11 @@ function detectNewlineStyle(text) {
 // src/lib/text-file.ts
 var TEXT_STREAMING_FILE_SIZE_THRESHOLD_BYTES = 1024 * 1024;
 var UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+function assertStringArgument(value, name) {
+  if (typeof value !== "string") {
+    throw createTextError("GBK_INVALID_ARGUMENT", `${name} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+  }
+}
 function isSupportedEncoding(value) {
   return value === "utf8" || value === "utf8-bom" || value === "utf16le" || value === "utf16be" || value === "gbk" || value === "gb18030";
 }
@@ -16535,6 +16540,7 @@ async function readWholeTextFile(input) {
   }
 }
 function alignTextToNewlineStyle(text, newlineStyle) {
+  assertStringArgument(text, "text");
   const normalized = text.replace(/\r\n/g, "\n");
   if (newlineStyle === "crlf") {
     return normalized.replace(/\n/g, "\r\n");
@@ -16545,6 +16551,7 @@ function alignTextToNewlineStyle(text, newlineStyle) {
   return text;
 }
 function ensureLossless(input, encoding, hasBom = encoding === "utf8-bom") {
+  assertStringArgument(input, "content");
   const buffer = encodeText(input, encoding, hasBom);
   const roundTrip = decodeText(buffer, encoding);
   if (roundTrip !== input) {
@@ -16569,6 +16576,7 @@ async function ensureParentDirectory(parent, createDirectories) {
   }
 }
 async function writeTextFile(input) {
+  assertStringArgument(input.content, "content");
   const requestedEncoding = input.encoding ?? "auto";
   assertTextEncodingSupported(requestedEncoding);
   const preserveEncoding = input.preserveEncoding ?? true;