opencode-gbk-tools 0.1.26 → 0.1.28

package/dist/plugins/opencode-gbk-tools.js

@@ -16585,45 +16585,103 @@ function assertInsertArguments(input) {
     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\uFFFD? replaceAll");
+    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\uFFFD? startLine/endLine/startAnchor/endAnchor");
+    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");
+function collectOccurrencePositions(text, token) {
   if (token.length === 0) {
-    throw createGbkError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+    return [];
   }
-  let count = 0;
+  const positions = [];
   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) };
+      return positions;
     }
+    positions.push(index);
     searchFrom = index + token.length;
   }
-  if (count === 0) {
-    throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\uFFFD?: ${token}`);
+}
+function buildFlexibleSearchVariants(token, newlineStyle) {
+  const variants = /* @__PURE__ */ new Set();
+  const pushVariant = (value) => {
+    if (typeof value !== "string" || value.length === 0) {
+      return;
+    }
+    variants.add(value);
+  };
+  pushVariant(token);
+  pushVariant(alignTextToNewlineStyle(token, newlineStyle));
+  const prefixedBlock = parseLineNumberPrefixedBlock(token);
+  if (prefixedBlock) {
+    pushVariant(prefixedBlock.strippedText);
+    pushVariant(alignTextToNewlineStyle(prefixedBlock.strippedText, newlineStyle));
+  }
+  const trimmedLines = trimTrailingEmptyLines(splitNormalizedLines(token));
+  if (trimmedLines.length > 0) {
+    const trimmedToken = trimmedLines.join("\n");
+    pushVariant(trimmedToken);
+    pushVariant(alignTextToNewlineStyle(trimmedToken, newlineStyle));
+    const trimmedPrefixedBlock = parseLineNumberPrefixedBlock(trimmedToken);
+    if (trimmedPrefixedBlock) {
+      pushVariant(trimmedPrefixedBlock.strippedText);
+      pushVariant(alignTextToNewlineStyle(trimmedPrefixedBlock.strippedText, newlineStyle));
+    }
+  }
+  return [...variants];
+}
+function findNextFlexibleMatch(text, token, searchFrom, newlineStyle) {
+  let bestMatch = null;
+  for (const candidate of buildFlexibleSearchVariants(token, newlineStyle)) {
+    const index = text.indexOf(candidate, searchFrom);
+    if (index === -1) {
+      continue;
+    }
+    if (bestMatch === null || index < bestMatch.index || index === bestMatch.index && candidate.length > bestMatch.matchedToken.length) {
+      bestMatch = { index, matchedToken: candidate };
+    }
+  }
+  return bestMatch;
+}
+function findFlexibleOccurrenceIndex(text, token, occurrence, newlineStyle) {
+  assertStringArgument(text, "text");
+  assertStringArgument(token, "anchor");
+  assertPositiveInteger(occurrence, "occurrence");
+  if (token.length === 0) {
+    throw createGbkError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  let maxMatches = 0;
+  for (const candidate of buildFlexibleSearchVariants(token, newlineStyle)) {
+    const positions = collectOccurrencePositions(text, candidate);
+    if (positions.length === 0) {
+      continue;
+    }
+    maxMatches = Math.max(maxMatches, positions.length);
+    if (positions.length >= occurrence) {
+      return {
+        index: positions[occurrence - 1],
+        total: positions.length,
+        matchedToken: candidate
+      };
+    }
+  }
+  if (maxMatches === 0) {
+    throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\u70B9: ${token}`);
   }
-  throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\uFFFD? ${count} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\uFFFD? ${occurrence} \u5904`);
+  throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\u5230 ${maxMatches} \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 located = findFlexibleOccurrenceIndex(text, anchor, occurrence, newlineStyle);
+  const insertionPoint = mode === "insertAfter" ? located.index + located.matchedToken.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\uFFFD?");
+      throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\u5BB9");
     }
     if (ifExists === "skip") {
       return {
@@ -16664,7 +16722,7 @@ function normalizeOptionalPositiveInteger(value, name) {
 }
 function assertNotBinary(buffer) {
   if (buffer.includes(0)) {
-    throw createGbkError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\uFFFD? GBK \u6587\u672C\u5904\u7406");
+    throw createGbkError("GBK_BINARY_FILE", "\u7591\u4F3C\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF0C\u65E0\u6CD5\u6309 GBK \u6587\u672C\u5904\u7406");
   }
 }
 function splitLinesWithNumbers(text, offset = 1, limit = 2e3) {
@@ -16791,19 +16849,15 @@ function applyAnchors(text, startAnchor, endAnchor) {
   }
   let rangeStart = 0;
   let rangeEnd = text.length;
+  const newlineStyle = detectNewlineStyle(text);
   if (startAnchor) {
-    const found = text.indexOf(startAnchor);
-    if (found === -1) {
-      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8D77\u59CB\u951A\uFFFD?: ${startAnchor}`);
-    }
-    rangeStart = found + startAnchor.length;
+    const found = findFlexibleOccurrenceIndex(text, startAnchor, 1, newlineStyle);
+    rangeStart = found.index + found.matchedToken.length;
   }
   if (endAnchor) {
-    const found = text.indexOf(endAnchor, rangeStart);
-    if (found === -1) {
-      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u7ED3\u675F\u951A\uFFFD?: ${endAnchor}`);
-    }
-    rangeEnd = found;
+    const searchText = text.slice(rangeStart);
+    const found = findFlexibleOccurrenceIndex(searchText, endAnchor, 1, newlineStyle);
+    rangeEnd = rangeStart + found.index;
   }
   if (rangeEnd < rangeStart) {
     throw createGbkError("GBK_INVALID_ARGUMENT", "\u951A\u70B9\u8303\u56F4\u65E0\u6548");
@@ -16854,9 +16908,9 @@ function getNearestContext(content, oldString) {
 }
 function buildNoMatchMessage(content, oldString) {
   return [
-    "\u672A\u627E\u5230\u9700\u8981\u66FF\u6362\u7684\u6587\u672C\uFFFD?",
-    "oldString \u5FC5\u987B\u4E0E\u6587\u4EF6\u5B9E\u9645\u5185\u5BB9\u5B8C\u5168\u5BF9\u5E94\uFF0C\u6216\u4EC5\u5728\u6362\uFFFD?/\u5C3E\u968F\u7A7A\u884C\u4E0A\u5B58\u5728\u8F7B\u5FAE\u5DEE\u5F02\uFFFD?",
-    "\u6700\u63A5\u8FD1\u7684\u4E0A\u4E0B\u6587\uFFFD?",
+    "\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\uFF0C\u6216\u4EC5\u5728\u6362\u884C/\u5C3E\u968F\u7A7A\u884C\u4E0A\u5B58\u5728\u8F7B\u5FAE\u5DEE\u5F02\u3002",
+    "\u6700\u63A5\u8FD1\u7684\u4E0A\u4E0B\u6587\uFF1A",
     getNearestContext(content, oldString)
   ].join("\n");
 }
@@ -16868,8 +16922,10 @@ function stripLineNumberPrefixes(lines) {
   return lines.map((l) => l.replace(/^\d+: /, ""));
 }
 function parseLineNumberPrefixedBlock(text) {
-  const lines = splitNormalizedLines(text);
-  if (!hasLineNumberPrefixes(lines)) {
+  const normalizedText = normalizeNewlines(text);
+  const hasTrailingNewline = normalizedText.endsWith("\n");
+  const lines = trimTrailingEmptyLines(splitNormalizedLines(text));
+  if (lines.length === 0 || !hasLineNumberPrefixes(lines)) {
     return null;
   }
   const lineNumbers = [];
@@ -16884,7 +16940,7 @@ function parseLineNumberPrefixedBlock(text) {
   }
   return {
     lineNumbers,
-    strippedText: strippedLines.join("\n"),
+    strippedText: `${strippedLines.join("\n")}${hasTrailingNewline ? "\n" : ""}`,
     isContiguous: lineNumbers.every((lineNumber, index) => index === 0 || lineNumber === lineNumbers[index - 1] + 1),
     startLine: lineNumbers[0],
     endLine: lineNumbers[lineNumbers.length - 1]
@@ -16979,10 +17035,10 @@ async function resolveReadableGbkFile(input) {
   try {
     stat = await fs2.stat(candidatePath);
   } catch (error45) {
-    throw createGbkError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\uFFFD?: ${candidatePath}`, error45);
+    throw createGbkError("GBK_FILE_NOT_FOUND", `\u6587\u4EF6\u4E0D\u5B58\u5728: ${candidatePath}`, error45);
   }
   if (stat.isDirectory()) {
-    throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\uFFFD?: ${candidatePath}`);
+    throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\u5F55: ${candidatePath}`);
   }
   return {
     filePath: candidatePath,
@@ -17187,7 +17243,7 @@ function replaceScopedTextContent(scopeText, oldString, newString, replaceAll, n
   } else if (occurrencesBefore === 0) {
     throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scopeText, oldString));
   } else if (occurrencesBefore > 1) {
-    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\uFFFD?: ${oldString}`);
+    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${oldString}`);
   }
   const alignedNewString = alignTextToNewlineStyle(newString, newlineStyle);
   return {
@@ -17245,14 +17301,17 @@ async function replaceLargeGbkFileTextInLineRange(input) {
   }
 }
 async function replaceLargeGbkFileByAnchor(input) {
+  const lineIndex = await getGbkLineIndex(input);
+  const newlineStyle = lineIndex.newlineStyle;
   const tempPath = path2.join(
     path2.dirname(input.filePath),
     `${path2.basename(input.filePath)}.opencode-gbk-${crypto.randomUUID()}.tmp`
   );
   const handle = await fs2.open(tempPath, "w");
-  const alignedContent = input.content.replace(/\r\n/g, "\n");
-  const anchorLength = input.anchor.length;
-  const carryLength = Math.max(anchorLength + alignedContent.length, 1);
+  const alignedContent = alignTextToNewlineStyle(input.content, newlineStyle);
+  const anchorVariants = buildFlexibleSearchVariants(input.anchor, newlineStyle);
+  const maxAnchorLength = anchorVariants.reduce((maxLength, candidate) => Math.max(maxLength, candidate.length), input.anchor.length);
+  const carryLength = Math.max(maxAnchorLength + alignedContent.length, 1);
   let decoded = "";
   let scanFrom = 0;
   let totalMatches = 0;
@@ -17276,23 +17335,23 @@ async function replaceLargeGbkFileByAnchor(input) {
     await visitDecodedTextChunks(input, async (text) => {
       decoded += text;
       while (!inserted) {
-        const foundAt = decoded.indexOf(input.anchor, scanFrom);
-        if (foundAt === -1) {
+        const located = findNextFlexibleMatch(decoded, input.anchor, scanFrom, newlineStyle);
+        if (located === null) {
           break;
         }
         totalMatches += 1;
-        const afterAnchor = foundAt + anchorLength;
+        const afterAnchor = located.index + located.matchedToken.length;
         if (totalMatches !== input.occurrence) {
           scanFrom = afterAnchor;
           continue;
         }
-        const before = decoded.slice(0, foundAt);
+        const before = decoded.slice(0, located.index);
         const after = decoded.slice(afterAnchor);
-        const anchorAndAfter = decoded.slice(foundAt);
+        const anchorAndAfter = decoded.slice(located.index);
         const alreadyExists = input.mode === "insertAfter" ? after.startsWith(alignedContent) : before.endsWith(alignedContent);
         if (alreadyExists) {
           if (input.ifExists === "error") {
-            throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\uFFFD?");
+            throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\u5BB9");
           }
           if (input.ifExists === "skip") {
             skipped = true;
@@ -17304,7 +17363,7 @@ async function replaceLargeGbkFileByAnchor(input) {
         }
         if (input.mode === "insertAfter") {
           bytesWritten += await writeEncodedText(handle, input.encoding, before);
-          bytesWritten += await writeEncodedText(handle, input.encoding, input.anchor);
+          bytesWritten += await writeEncodedText(handle, input.encoding, located.matchedToken);
           bytesWritten += await writeEncodedText(handle, input.encoding, alignedContent);
           bytesWritten += await writeEncodedText(handle, input.encoding, after);
         } else {
@@ -17323,23 +17382,23 @@ async function replaceLargeGbkFileByAnchor(input) {
     });
     if (!inserted) {
       while (true) {
-        const foundAt = decoded.indexOf(input.anchor, scanFrom);
-        if (foundAt === -1) {
+        const located = findNextFlexibleMatch(decoded, input.anchor, scanFrom, newlineStyle);
+        if (located === null) {
           break;
         }
         totalMatches += 1;
-        const afterAnchor = foundAt + anchorLength;
+        const afterAnchor = located.index + located.matchedToken.length;
         if (totalMatches !== input.occurrence) {
           scanFrom = afterAnchor;
           continue;
         }
-        const before = decoded.slice(0, foundAt);
+        const before = decoded.slice(0, located.index);
         const after = decoded.slice(afterAnchor);
-        const anchorAndAfter = decoded.slice(foundAt);
+        const anchorAndAfter = decoded.slice(located.index);
         const alreadyExists = input.mode === "insertAfter" ? after.startsWith(alignedContent) : before.endsWith(alignedContent);
         if (alreadyExists) {
           if (input.ifExists === "error") {
-            throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\uFFFD?");
+            throw createGbkError("GBK_INVALID_ARGUMENT", "\u63D2\u5165\u4F4D\u7F6E\u5DF2\u5B58\u5728\u76F8\u540C\u5185\u5BB9");
           }
           if (input.ifExists === "skip") {
             skipped = true;
@@ -17347,16 +17406,16 @@ async function replaceLargeGbkFileByAnchor(input) {
             break;
           }
         }
-        decoded = input.mode === "insertAfter" ? `${before}${input.anchor}${alignedContent}${after}` : `${before}${alignedContent}${anchorAndAfter}`;
+        decoded = input.mode === "insertAfter" ? `${before}${located.matchedToken}${alignedContent}${after}` : `${before}${alignedContent}${anchorAndAfter}`;
         inserted = true;
         break;
       }
     }
     if (!inserted && totalMatches === 0) {
-      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\uFFFD?: ${input.anchor}`);
+      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u951A\u70B9: ${input.anchor}`);
     }
     if (!inserted && totalMatches > 0) {
-      throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${input.anchor} \u53EA\u627E\uFFFD? ${totalMatches} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\uFFFD? ${input.occurrence} \u5904`);
+      throw createGbkError("GBK_NO_MATCH", `\u951A\u70B9 ${input.anchor} \u53EA\u627E\u5230 ${totalMatches} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7B2C ${input.occurrence} \u5904`);
     }
     await finalizeInserted();
     await handle.close();
@@ -17383,35 +17442,57 @@ async function replaceLargeGbkFileByAnchor(input) {
   }
 }
 async function replaceLargeGbkFileText(input) {
+  const lineIndex = await getGbkLineIndex(input);
+  const newlineStyle = lineIndex.newlineStyle;
   const tempPath = path2.join(
     path2.dirname(input.filePath),
     `${path2.basename(input.filePath)}.opencode-gbk-${crypto.randomUUID()}.tmp`
   );
   const handle = await fs2.open(tempPath, "w");
   const carryLength = Math.max(input.oldString.length - 1, 0);
+  const alignedNewString = alignTextToNewlineStyle(input.newString, newlineStyle);
   let carry = "";
   let occurrencesBefore = 0;
   let bytesWritten = 0;
+  let replacedFirstMatch = false;
   const flushText = async (text, flush = false) => {
     const combined = carry + text;
-    const splitAt = flush ? combined.length : Math.max(0, combined.length - carryLength);
-    const processable = combined.slice(0, splitAt);
-    carry = combined.slice(splitAt);
-    if (processable.length === 0) {
+    if (combined.length === 0) {
       return;
     }
-    const matchCount = countOccurrences(processable, input.oldString);
-    const seenBefore = occurrencesBefore;
-    occurrencesBefore += matchCount;
-    let output = processable;
-    if (input.replaceAll) {
-      if (matchCount > 0) {
-        output = processable.split(input.oldString).join(input.newString);
+    const safeEnd = flush ? combined.length : Math.max(0, combined.length - carryLength);
+    const outputParts = [];
+    let cursor = 0;
+    let flushUpto = safeEnd;
+    while (true) {
+      const index = combined.indexOf(input.oldString, cursor);
+      if (index === -1) {
+        break;
+      }
+      const matchEnd = index + input.oldString.length;
+      if (!flush && matchEnd > safeEnd) {
+        flushUpto = index;
+        break;
       }
-    } else if (seenBefore === 0 && matchCount > 0) {
-      output = processable.replace(input.oldString, input.newString);
+      occurrencesBefore += 1;
+      outputParts.push(combined.slice(cursor, index));
+      if (input.replaceAll) {
+        outputParts.push(alignedNewString);
+      } else if (!replacedFirstMatch) {
+        outputParts.push(alignedNewString);
+        replacedFirstMatch = true;
+      } else {
+        outputParts.push(input.oldString);
+      }
+      cursor = matchEnd;
+    }
+    outputParts.push(combined.slice(cursor, flushUpto));
+    carry = combined.slice(flushUpto);
+    const processable = outputParts.join("");
+    if (processable.length === 0) {
+      return;
     }
-    bytesWritten += await writeEncodedText(handle, input.encoding, output);
+    bytesWritten += await writeEncodedText(handle, input.encoding, processable);
   };
   try {
     await visitDecodedTextChunks(input, async (text) => {
@@ -17419,10 +17500,10 @@ async function replaceLargeGbkFileText(input) {
     });
     await flushText("", true);
     if (occurrencesBefore === 0) {
-      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\uFFFD?: ${input.oldString}`);
+      throw createGbkError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\u5BB9: ${input.oldString}`);
     }
     if (!input.replaceAll && occurrencesBefore > 1) {
-      throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\uFFFD?: ${input.oldString}`);
+      throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
     }
     await handle.close();
     const mode = typeof input.stat.mode === "bigint" ? Number(input.stat.mode) : input.stat.mode;
@@ -17648,7 +17729,7 @@ async function replaceGbkFileText(input) {
   } else if (occurrencesBefore === 0) {
     throw createGbkError("GBK_NO_MATCH", buildNoMatchMessage(scope.selectedText, effectiveOldString));
   } else if (occurrencesBefore > 1) {
-    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\uFFFD?: ${effectiveOldString}`);
+    throw createGbkError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${effectiveOldString}`);
   }
   const fileNewlineStyle = detectNewlineStyle(current.content);
   const alignedNewString = fileNewlineStyle === "crlf" ? input.newString.replace(/\r\n/g, "\n").replace(/\n/g, "\r\n") : fileNewlineStyle === "lf" ? input.newString.replace(/\r\n/g, "\n") : input.newString;
@@ -17781,10 +17862,10 @@ async function writeGbkFile(input) {
   try {
     const stat = await fs2.stat(candidatePath);
     if (stat.isDirectory()) {
-      throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\uFFFD?: ${candidatePath}`);
+      throw createGbkError("GBK_IS_DIRECTORY", `\u76EE\u6807\u8DEF\u5F84\u662F\u76EE\u5F55: ${candidatePath}`);
     }
     if (!overwrite) {
-      throw createGbkError("GBK_FILE_EXISTS", `\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\uFFFD?: ${candidatePath}`);
+      throw createGbkError("GBK_FILE_EXISTS", `\u76EE\u6807\u6587\u4EF6\u5DF2\u5B58\u5728: ${candidatePath}`);
     }
   } catch (error45) {
     if (error45 instanceof Error && "code" in error45) {
@@ -18034,19 +18115,26 @@ 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",
+  "- \u5904\u7406\u6587\u672C\u6587\u4EF6\u65F6\uFF0C\u9ED8\u8BA4\u4F18\u5148\u4F7F\u7528 gbk_read\u3001gbk_write\u3001gbk_edit\u3001gbk_search\u3002",
+  "- gbk_* \u9002\u5408\u5F53\u524D\u4ED3\u5E93\u7684\u81EA\u52A8\u7F16\u7801\u6587\u672C\u4E0E GBK/GB18030 \u6587\u4EF6\uFF1B\u5373\u4F7F\u4E0D\u662F\u660E\u786E\u7684 GBK \u6587\u4EF6\uFF0C\u4E5F\u4F18\u5148\u8D70\u8FD9\u7EC4\u5DE5\u5177\u3002",
   "- \u65B0\u5EFA .txt \u6587\u4EF6\u5728 encoding=auto \u4E0B\u9ED8\u8BA4\u4F7F\u7528 GBK\uFF1B\u5176\u4ED6\u65B0\u6587\u4EF6\u8BF7\u663E\u5F0F\u6307\u5B9A encoding\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"
+  "- anchor\u3001startAnchor\u3001endAnchor\u3001oldString \u82E5\u76F4\u63A5\u590D\u5236\u81EA\u8BFB\u53D6\u7ED3\u679C\uFF0C\u53EF\u4FDD\u7559 LF \u6362\u884C\uFF1B\u5DE5\u5177\u4F1A\u5C3D\u91CF\u6309\u6587\u4EF6\u6362\u884C\u98CE\u683C\u81EA\u52A8\u5BF9\u9F50\u3002",
+  '- \u82E5\u8BFB\u53D6\u7ED3\u679C\u5E26\u6709 "N: " \u884C\u53F7\u524D\u7F00\uFF0Cgbk_edit \u4F1A\u5C3D\u91CF\u81EA\u52A8\u5265\u79BB\u8FD9\u4E9B\u524D\u7F00\u540E\u518D\u5339\u914D\u3002',
+  "- text_read\u3001text_write\u3001text_edit \u4EC5\u4F5C\u4E3A\u517C\u5BB9\u5DE5\u5177\uFF0C\u4E0D\u518D\u4F5C\u4E3A\u9ED8\u8BA4\u63A8\u8350\u8DEF\u5F84\u3002"
 ].join("\n");
 function appendTextToolSystemPrompt(system) {
   if (system.some((item) => item.includes(TEXT_TOOL_SYSTEM_MARKER))) {
     return;
   }
-  system.push(TEXT_TOOL_SYSTEM_PROMPT);
+  if (system.length === 0) {
+    system.push(TEXT_TOOL_SYSTEM_PROMPT);
+    return;
+  }
+  system[0] = `${system[0]}
+
+${TEXT_TOOL_SYSTEM_PROMPT}`;
 }
 
 // src/lib/text-file.ts
@@ -18242,35 +18330,126 @@ function buildNoMatchMessage2(content, oldString) {
   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",
+    "oldString \u5FC5\u987B\u4E0E\u6587\u4EF6\u5B9E\u9645\u5185\u5BB9\u5B8C\u5168\u5BF9\u5E94\uFF0C\u6216\u4EC5\u5728\u6362\u884C/\u5C3E\u968F\u7A7A\u884C\u4E0A\u5B58\u5728\u8F7B\u5FAE\u5DEE\u5F02\u3002",
     "\u6700\u63A5\u8FD1\u7684\u4E0A\u4E0B\u6587\uFF1A",
     getNearestContext2(content, oldString)
   ].join("\n");
 }
-function findOccurrenceIndex2(text, token, occurrence) {
+function trimRightSpaces2(text) {
   assertStringArgument2(text, "text");
-  assertStringArgument2(token, "anchor");
-  assertPositiveInteger(occurrence, "occurrence");
+  return text.replace(/[ \t]+$/g, "");
+}
+function splitNormalizedLines2(text) {
+  return normalizeNewlines2(text).split("\n");
+}
+function trimTrailingEmptyLines2(lines) {
+  const result = [...lines];
+  while (result.length > 0 && trimRightSpaces2(result[result.length - 1]) === "") {
+    result.pop();
+  }
+  return result;
+}
+function hasLineNumberPrefixes2(lines) {
+  const nonEmpty = lines.filter((line) => line.trim().length > 0);
+  return nonEmpty.length > 0 && nonEmpty.every((line) => /^\d+: /.test(line));
+}
+function stripLineNumberPrefixes2(lines) {
+  return lines.map((line) => line.replace(/^\d+: /, ""));
+}
+function parseLineNumberPrefixedBlock2(text) {
+  const normalizedText = normalizeNewlines2(text);
+  const hasTrailingNewline = normalizedText.endsWith("\n");
+  const lines = trimTrailingEmptyLines2(splitNormalizedLines2(text));
+  if (lines.length === 0 || !hasLineNumberPrefixes2(lines)) {
+    return null;
+  }
+  const lineNumbers = [];
+  const strippedLines = [];
+  for (const line of lines) {
+    const match = /^(\d+): ?(.*)$/.exec(line);
+    if (!match) {
+      return null;
+    }
+    lineNumbers.push(Number(match[1]));
+    strippedLines.push(match[2]);
+  }
+  return {
+    lineNumbers,
+    strippedText: `${strippedLines.join("\n")}${hasTrailingNewline ? "\n" : ""}`,
+    isContiguous: lineNumbers.every((lineNumber, index) => index === 0 || lineNumber === lineNumbers[index - 1] + 1),
+    startLine: lineNumbers[0],
+    endLine: lineNumbers[lineNumbers.length - 1]
+  };
+}
+function collectOccurrencePositions2(text, token) {
   if (token.length === 0) {
-    throw createTextError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+    return [];
   }
-  let count = 0;
+  const positions = [];
   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) };
+      return positions;
     }
+    positions.push(index);
     searchFrom = index + token.length;
   }
-  if (count === 0) {
+}
+function buildFlexibleSearchVariants2(token, newlineStyle) {
+  const variants = /* @__PURE__ */ new Set();
+  const pushVariant = (value) => {
+    if (typeof value !== "string" || value.length === 0) {
+      return;
+    }
+    variants.add(value);
+  };
+  pushVariant(token);
+  pushVariant(alignTextToNewlineStyle2(token, newlineStyle));
+  const prefixedBlock = parseLineNumberPrefixedBlock2(token);
+  if (prefixedBlock) {
+    pushVariant(prefixedBlock.strippedText);
+    pushVariant(alignTextToNewlineStyle2(prefixedBlock.strippedText, newlineStyle));
+  }
+  const trimmedLines = trimTrailingEmptyLines2(splitNormalizedLines2(token));
+  if (trimmedLines.length > 0) {
+    const trimmedToken = trimmedLines.join("\n");
+    pushVariant(trimmedToken);
+    pushVariant(alignTextToNewlineStyle2(trimmedToken, newlineStyle));
+    const trimmedPrefixedBlock = parseLineNumberPrefixedBlock2(trimmedToken);
+    if (trimmedPrefixedBlock) {
+      pushVariant(trimmedPrefixedBlock.strippedText);
+      pushVariant(alignTextToNewlineStyle2(trimmedPrefixedBlock.strippedText, newlineStyle));
+    }
+  }
+  return [...variants];
+}
+function findOccurrenceIndex(text, token, occurrence, newlineStyle) {
+  assertStringArgument2(text, "text");
+  assertStringArgument2(token, "anchor");
+  assertPositiveInteger(occurrence, "occurrence");
+  if (token.length === 0) {
+    throw createTextError("GBK_INVALID_ARGUMENT", "anchor \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  let maxMatches = 0;
+  for (const candidate of buildFlexibleSearchVariants2(token, newlineStyle)) {
+    const positions = collectOccurrencePositions2(text, candidate);
+    if (positions.length === 0) {
+      continue;
+    }
+    maxMatches = Math.max(maxMatches, positions.length);
+    if (positions.length >= occurrence) {
+      return {
+        index: positions[occurrence - 1],
+        total: positions.length,
+        matchedToken: candidate
+      };
+    }
+  }
+  if (maxMatches === 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`);
+  throw createTextError("GBK_NO_MATCH", `\u951A\u70B9 ${token} \u53EA\u627E\u5230 ${maxMatches} \u5904\uFF0C\u65E0\u6CD5\u4F7F\u7528\u7B2C ${occurrence} \u5904`);
 }
 function assertInsertArguments2(input) {
   assertStringArgument2(input.anchor, "anchor");
@@ -18322,8 +18501,8 @@ function buildLineDiffPreview(filePath, encoding, beforeText, afterText) {
 }
 function buildInsertOutput(text, mode, anchor, content, occurrence, ifExists, newlineStyle) {
   const alignedContent = alignTextToNewlineStyle2(content, newlineStyle);
-  const located = findOccurrenceIndex2(text, anchor, occurrence);
-  const insertionPoint = mode === "insertAfter" ? located.index + anchor.length : located.index;
+  const located = findOccurrenceIndex(text, anchor, occurrence, newlineStyle);
+  const insertionPoint = mode === "insertAfter" ? located.index + located.matchedToken.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") {
@@ -18337,8 +18516,8 @@ function buildInsertOutput(text, mode, anchor, content, occurrence, ifExists, ne
         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))
+        previewBefore: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + located.matchedToken.length + 80)),
+        previewAfter: text.slice(Math.max(0, located.index - 80), Math.min(text.length, located.index + located.matchedToken.length + 80))
       };
     }
   }
@@ -18584,6 +18763,114 @@ async function visitDecodedTextChunks2(resolved, visitor) {
     stream.destroy();
   }
 }
+async function writeLargeTextFile(filePath, encoding, hasBom, producer) {
+  const tempPath = path3.join(path3.dirname(filePath), `${path3.basename(filePath)}.opencode-text-${crypto2.randomUUID()}.tmp`);
+  const handle = await fs3.open(tempPath, "w");
+  try {
+    if (hasBom) {
+      const bom = getBomPrefix(encoding, hasBom);
+      if (bom.length > 0) {
+        await handle.writeFile(bom);
+      }
+    }
+    const bytesWritten = await producer(handle);
+    await handle.close();
+    await fs3.rename(tempPath, filePath);
+    return bytesWritten + getBomPrefix(encoding, hasBom).length;
+  } catch (error45) {
+    await handle.close().catch(() => void 0);
+    await fs3.rm(tempPath, { force: true }).catch(() => void 0);
+    throw error45;
+  }
+}
+async function writeEncodedTextChunk(handle, encoding, text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  const buffer = encodeTextBody(text, encoding);
+  await handle.writeFile(buffer);
+  return buffer.byteLength;
+}
+async function replaceLargeTextFileText(input) {
+  const carryLength = Math.max(input.oldString.length - 1, 0);
+  const fileNewlineStyle = input.loaded.newlineStyle;
+  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;
+  let carry = "";
+  let occurrencesBefore = 0;
+  let replacedFirstMatch = false;
+  const bytesWritten = await writeLargeTextFile(input.loaded.filePath, input.loaded.encoding, input.loaded.hasBom, async (handle) => {
+    let written = 0;
+    const flushText = async (text, flush = false) => {
+      const combined = carry + text;
+      if (combined.length === 0) {
+        return;
+      }
+      const safeEnd = flush ? combined.length : Math.max(0, combined.length - carryLength);
+      const outputParts = [];
+      let cursor = 0;
+      let flushUpto = safeEnd;
+      while (true) {
+        const index = combined.indexOf(input.oldString, cursor);
+        if (index === -1) {
+          break;
+        }
+        const matchEnd = index + input.oldString.length;
+        if (!flush && matchEnd > safeEnd) {
+          flushUpto = index;
+          break;
+        }
+        occurrencesBefore += 1;
+        outputParts.push(combined.slice(cursor, index));
+        if (input.replaceAll) {
+          outputParts.push(alignedNewString);
+        } else if (!replacedFirstMatch) {
+          outputParts.push(alignedNewString);
+          replacedFirstMatch = true;
+        } else {
+          outputParts.push(input.oldString);
+        }
+        cursor = matchEnd;
+      }
+      outputParts.push(combined.slice(cursor, flushUpto));
+      carry = combined.slice(flushUpto);
+      const processable = outputParts.join("");
+      if (processable.length === 0) {
+        return;
+      }
+      written += await writeEncodedTextChunk(handle, input.loaded.encoding, processable);
+    };
+    await visitDecodedTextChunks2({
+      filePath: input.loaded.filePath,
+      encoding: input.loaded.encoding,
+      hasBom: input.loaded.hasBom
+    }, async (text) => {
+      await flushText(text);
+    });
+    await flushText("", true);
+    if (occurrencesBefore === 0) {
+      throw createTextError("GBK_NO_MATCH", `\u672A\u627E\u5230\u8981\u66FF\u6362\u7684\u5185\u5BB9: ${input.oldString}`);
+    }
+    if (!input.replaceAll && occurrencesBefore > 1) {
+      throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
+    }
+    return written;
+  });
+  return {
+    mode: "replace",
+    filePath: input.loaded.filePath,
+    encoding: input.loaded.encoding,
+    requestedEncoding: input.loaded.requestedEncoding,
+    detectedEncoding: input.loaded.detectedEncoding,
+    confidence: input.loaded.confidence,
+    hasBom: input.loaded.hasBom,
+    replacements: input.replaceAll ? occurrencesBefore : 1,
+    occurrencesBefore,
+    bytesRead: input.loaded.bytesRead,
+    bytesWritten,
+    newlineStyle: input.loaded.newlineStyle,
+    diffPreview: void 0
+  };
+}
 async function readWholeTextFile(input) {
   const resolved = await resolveReadableTextFile(input);
   try {
@@ -18677,19 +18964,14 @@ function applyAnchors2(text, startAnchor, endAnchor) {
   }
   let rangeStart = 0;
   let rangeEnd = text.length;
+  const newlineStyle = detectNewlineStyle(text);
   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;
+    const found = findOccurrenceIndex(text, startAnchor, 1, newlineStyle);
+    rangeStart = found.index + found.matchedToken.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;
+    const found = findOccurrenceIndex(text.slice(rangeStart), endAnchor, 1, newlineStyle);
+    rangeEnd = rangeStart + found.index;
   }
   if (rangeEnd < rangeStart) {
     throw createTextError("GBK_INVALID_ARGUMENT", "\u951A\u70B9\u8303\u56F4\u65E0\u6548");
@@ -18720,6 +19002,64 @@ function alignTextToNewlineStyle2(text, newlineStyle) {
   }
   return text;
 }
+function matchLooseBlock2(contentLines, oldLines, newLines, newlineStyle) {
+  for (let start = 0; start < contentLines.length; start += 1) {
+    let contentIndex = start;
+    let oldIndex = 0;
+    while (oldIndex < oldLines.length && contentIndex < contentLines.length) {
+      const expected = trimRightSpaces2(oldLines[oldIndex]);
+      const actual = trimRightSpaces2(contentLines[contentIndex]);
+      if (expected === actual) {
+        oldIndex += 1;
+        contentIndex += 1;
+        continue;
+      }
+      if (actual === "") {
+        contentIndex += 1;
+        continue;
+      }
+      if (expected === "") {
+        oldIndex += 1;
+        continue;
+      }
+      break;
+    }
+    if (oldIndex === oldLines.length) {
+      const matchedOriginal = contentLines.slice(start, contentIndex).join("\n");
+      const replacedNormalized = [
+        ...contentLines.slice(0, start),
+        ...newLines,
+        ...contentLines.slice(contentIndex)
+      ].join("\n");
+      return {
+        occurrencesBefore: 1,
+        matchedOriginal,
+        content: newlineStyle === "crlf" ? replacedNormalized.replace(/\n/g, "\r\n") : replacedNormalized
+      };
+    }
+  }
+  return null;
+}
+function tryLooseBlockReplace2(content, oldString, newString) {
+  const contentLines = splitNormalizedLines2(content);
+  const oldLines = trimTrailingEmptyLines2(splitNormalizedLines2(oldString));
+  const newLines = splitNormalizedLines2(newString);
+  const newlineStyle = detectNewlineStyle(content);
+  if (oldLines.length === 0) {
+    return null;
+  }
+  const direct = matchLooseBlock2(contentLines, oldLines, newLines, newlineStyle);
+  if (direct !== null) {
+    return direct;
+  }
+  if (hasLineNumberPrefixes2(oldLines)) {
+    const strippedOldLines = trimTrailingEmptyLines2(stripLineNumberPrefixes2(oldLines));
+    if (strippedOldLines.length > 0) {
+      return matchLooseBlock2(contentLines, strippedOldLines, newLines, newlineStyle);
+    }
+  }
+  return null;
+}
 function ensureLossless(input, encoding, hasBom = encoding === "utf8-bom") {
   assertStringArgument2(input, "content");
   const buffer = encodeText(input, encoding, hasBom);
@@ -18919,37 +19259,89 @@ async function replaceTextFileText(input) {
   if (input.oldString.length === 0) {
     throw createTextError("GBK_EMPTY_OLD_STRING", "oldString \u4E0D\u80FD\u4E3A\u7A7A");
   }
+  const prefixedBlock = parseLineNumberPrefixedBlock2(input.oldString);
+  const derivedScopedRange = prefixedBlock?.isContiguous ? {
+    startLine: normalizedInput.startLine ?? prefixedBlock.startLine,
+    endLine: normalizedInput.endLine ?? prefixedBlock.endLine,
+    oldString: prefixedBlock.strippedText
+  } : null;
+  const effectiveOldString = derivedScopedRange?.oldString ?? input.oldString;
   const resolved = await detectReadableTextFile({
     filePath: input.filePath,
     encoding: input.encoding ?? "auto",
     allowExternal: input.allowExternal,
     context: input.context
   });
+  const hasScopedRange = normalizedInput.startLine !== void 0 || normalizedInput.endLine !== void 0 || normalizedInput.startAnchor !== void 0 || normalizedInput.endAnchor !== void 0 || derivedScopedRange !== null;
+  const preserveEncoding = normalizedInput.preserveEncoding ?? true;
+  const preserveNewlineStyle = normalizedInput.preserveNewlineStyle ?? true;
+  const requestedEncoding = normalizedInput.encoding ?? "auto";
+  if (resolved.stat.size >= TEXT_STREAMING_FILE_SIZE_THRESHOLD_BYTES && !hasScopedRange && preserveEncoding && preserveNewlineStyle && requestedEncoding === "auto") {
+    const loadedForStreaming = await readWholeTextFile({
+      filePath: input.filePath,
+      encoding: requestedEncoding,
+      allowExternal: input.allowExternal,
+      context: input.context
+    });
+    return await replaceLargeTextFileText({
+      loaded: loadedForStreaming,
+      oldString: effectiveOldString,
+      newString: input.newString,
+      replaceAll: normalizedInput.replaceAll ?? false
+    });
+  }
   const loaded = await readWholeTextFile({
     filePath: input.filePath,
     encoding: input.encoding ?? "auto",
     allowExternal: input.allowExternal,
     context: input.context
   });
-  const scope = resolveEditScope2(loaded.content, normalizedInput);
+  const scopedInput = derivedScopedRange === null ? normalizedInput : {
+    ...normalizedInput,
+    startLine: derivedScopedRange.startLine,
+    endLine: derivedScopedRange.endLine
+  };
+  const scope = resolveEditScope2(loaded.content, scopedInput);
   const replaceAll = normalizedInput.replaceAll ?? false;
-  const preserveEncoding = normalizedInput.preserveEncoding ?? true;
-  const requestedEncoding = normalizedInput.encoding ?? "auto";
-  const occurrencesBefore = countOccurrences(scope.selectedText, input.oldString);
+  const targetEncoding = preserveEncoding || requestedEncoding === "auto" ? loaded.encoding : resolveExplicitTextEncoding(requestedEncoding, loaded.encoding);
+  const targetHasBom = preserveEncoding ? loaded.hasBom : targetEncoding === "utf8-bom" || targetEncoding === "utf16le" || targetEncoding === "utf16be";
+  const occurrencesBefore = countOccurrences(scope.selectedText, effectiveOldString);
+  if (!replaceAll && occurrencesBefore === 0) {
+    const loose = tryLooseBlockReplace2(scope.selectedText, effectiveOldString, input.newString);
+    if (loose !== null) {
+      const outputText2 = `${loaded.content.slice(0, scope.rangeStart)}${loose.content}${loaded.content.slice(scope.rangeEnd)}`;
+      ensureLossless(outputText2, targetEncoding, targetHasBom);
+      const buffer2 = encodeText(outputText2, targetEncoding, targetHasBom);
+      await fs3.writeFile(loaded.filePath, buffer2);
+      return {
+        mode: "replace",
+        filePath: loaded.filePath,
+        encoding: targetEncoding,
+        requestedEncoding: loaded.requestedEncoding,
+        detectedEncoding: loaded.detectedEncoding,
+        confidence: loaded.confidence,
+        hasBom: targetHasBom,
+        replacements: 1,
+        occurrencesBefore: loose.occurrencesBefore,
+        bytesRead: loaded.bytesRead,
+        bytesWritten: buffer2.byteLength,
+        newlineStyle: detectNewlineStyle(outputText2),
+        diffPreview: buildLineDiffPreview(loaded.filePath, targetEncoding, loose.matchedOriginal, input.newString)
+      };
+    }
+  }
   if (replaceAll) {
     if (occurrencesBefore === 0) {
-      throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, input.oldString));
+      throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, effectiveOldString));
     }
   } else if (occurrencesBefore === 0) {
-    throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, input.oldString));
+    throw createTextError("GBK_NO_MATCH", buildNoMatchMessage2(scope.selectedText, effectiveOldString));
   } else if (occurrencesBefore > 1) {
-    throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${input.oldString}`);
+    throw createTextError("GBK_MULTIPLE_MATCHES", `\u627E\u5230\u591A\u4E2A\u5339\u914D\u9879: ${effectiveOldString}`);
   }
   const alignedNewString = normalizedInput.preserveNewlineStyle === false ? input.newString : alignTextToNewlineStyle2(input.newString, loaded.newlineStyle);
-  const replaced = replaceAll ? scope.selectedText.split(input.oldString).join(alignedNewString) : scope.selectedText.replace(input.oldString, alignedNewString);
+  const replaced = replaceAll ? scope.selectedText.split(effectiveOldString).join(alignedNewString) : scope.selectedText.replace(effectiveOldString, 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);
@@ -18966,7 +19358,7 @@ async function replaceTextFileText(input) {
     bytesRead: loaded.bytesRead,
     bytesWritten: buffer.byteLength,
     newlineStyle: detectNewlineStyle(outputText),
-    diffPreview: buildLineDiffPreview(loaded.filePath, targetEncoding, input.oldString, alignedNewString)
+    diffPreview: buildLineDiffPreview(loaded.filePath, targetEncoding, effectiveOldString, alignedNewString)
   };
 }