@link-assistant/agent 0.26.15 → 0.27.1

package/src/tool/edit.ts

@@ -14,11 +14,29 @@ import { FileTime } from '../file/time';
 import { Instance } from '../project/instance';
 import { Snapshot } from '../snapshot';
 import { Permission } from '../permission';
+import { Bom } from '../util/bom';
+import { config } from '../config/config';
 
 function normalizeLineEndings(text: string): string {
   return text.replaceAll('\r\n', '\n');
 }
 
+// The dominant line ending, so one stray CRLF line does not turn every
+// inserted line of an LF file into CRLF (upstream #53166). Ties keep LF.
+function detectLineEnding(text: string): '\n' | '\r\n' {
+  const crlf = text.split('\r\n').length - 1;
+  const lf = text.split('\n').length - 1 - crlf;
+  return crlf > lf ? '\r\n' : '\n';
+}
+
+function convertToLineEnding(text: string, ending: '\n' | '\r\n'): string {
+  if (ending === '\n') return text;
+  return text.replaceAll('\n', '\r\n');
+}
+
+const EMPTY_OLD_STRING_ERROR =
+  'oldString cannot be empty when editing an existing file. Provide the exact text to replace, or use write for an intentional full-file replacement.';
+
 export const EditTool = Tool.define('edit', {
   description: DESCRIPTION,
   parameters: z.object({
@@ -61,16 +79,24 @@ export const EditTool = Tool.define('edit', {
     let diff = '';
     let contentOld = '';
     let contentNew = '';
-    await (async () => {
+    // Tool calls of one step run concurrently; serialize read-modify-write of
+    // the same file so parallel edits cannot drop each other's changes.
+    await FileTime.withLock(filePath, async () => {
       if (params.oldString === '') {
-        contentNew = params.newString;
+        // --legacy-edit-matching: an empty oldString overwrote the file.
+        if (!config.legacyEditMatching && (await Bun.file(filePath).exists())) {
+          throw new Error(EMPTY_OLD_STRING_ERROR);
+        }
+        const next = Bom.split(params.newString);
+        contentNew = next.text;
         diff = trimDiff(
           createTwoFilesPatch(filePath, filePath, contentOld, contentNew)
         );
-        await Bun.write(filePath, params.newString);
+        await Bun.write(filePath, Bom.join(contentNew, next.bom));
         await Bus.publish(File.Event.Edited, {
           file: filePath,
         });
+        FileTime.read(ctx.sessionID, filePath);
         return;
       }
 
@@ -80,28 +106,30 @@ export const EditTool = Tool.define('edit', {
       if (stats.isDirectory())
         throw new Error(`Path is a directory, not a file: ${filePath}`);
       await FileTime.assert(ctx.sessionID, filePath);
-      contentOld = await file.text();
-      contentNew = replace(
-        contentOld,
-        params.oldString,
-        params.newString,
-        params.replaceAll
+      const source = await Bom.readFile(filePath);
+      contentOld = source.text;
+
+      // Models usually send LF; keep the file's own line endings so a CRLF
+      // file is neither left unmatched nor partially converted to LF.
+      const ending = detectLineEnding(contentOld);
+      const oldString = convertToLineEnding(
+        normalizeLineEndings(params.oldString),
+        ending
       );
-
-      diff = trimDiff(
-        createTwoFilesPatch(
-          filePath,
-          filePath,
-          normalizeLineEndings(contentOld),
-          normalizeLineEndings(contentNew)
-        )
+      const newString = convertToLineEnding(
+        normalizeLineEndings(params.newString),
+        ending
+      );
+      const next = Bom.split(
+        replace(contentOld, oldString, newString, params.replaceAll)
       );
+      contentNew = next.text;
 
-      await file.write(contentNew);
+      await Bun.write(filePath, Bom.join(contentNew, source.bom || next.bom));
       await Bus.publish(File.Event.Edited, {
         file: filePath,
       });
-      contentNew = await file.text();
+      FileTime.read(ctx.sessionID, filePath);
       diff = trimDiff(
         createTwoFilesPatch(
           filePath,
@@ -110,11 +138,10 @@ export const EditTool = Tool.define('edit', {
           normalizeLineEndings(contentNew)
         )
       );
-    })();
-
-    FileTime.read(ctx.sessionID, filePath);
+    });
 
-    let output = '';
+    // --legacy-tool-output: edit used to return an empty output.
+    const output = config.legacyToolOutput ? '' : 'Edit applied successfully.';
     const diagnostics = {};
 
     const filediff: Snapshot.FileDiff = {
@@ -147,8 +174,29 @@ export type Replacer = (
 ) => Generator<string, void, unknown>;
 
 // Similarity thresholds for block anchor fallback matching
-const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0;
-const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3;
+// (raised from 0.0 / 0.3 in upstream #30932: with 0.0 any block whose first
+// and last lines matched was replaced, even when the middle was unrelated)
+// --legacy-edit-matching / LINK_ASSISTANT_AGENT_LEGACY_EDIT_MATCHING restores
+// the old thresholds and drops the block-size and disproportionate-match
+// guards.
+const SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.65;
+const MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.65;
+const LEGACY_SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0.0;
+const LEGACY_MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3;
+
+function thresholds() {
+  return config.legacyEditMatching
+    ? {
+        single: LEGACY_SINGLE_CANDIDATE_SIMILARITY_THRESHOLD,
+        multiple: LEGACY_MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD,
+        maxLineDelta: (_size: number) => Infinity,
+      }
+    : {
+        single: SINGLE_CANDIDATE_SIMILARITY_THRESHOLD,
+        multiple: MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD,
+        maxLineDelta: (size: number) => Math.max(1, Math.floor(size * 0.25)),
+      };
+}
 
 /**
  * Levenshtein distance algorithm implementation
@@ -236,6 +284,8 @@ export const BlockAnchorReplacer: Replacer = function* (content, find) {
   const firstLineSearch = searchLines[0].trim();
   const lastLineSearch = searchLines[searchLines.length - 1].trim();
   const searchBlockSize = searchLines.length;
+  const limits = thresholds();
+  const maxLineDelta = limits.maxLineDelta(searchBlockSize);
 
   // Collect all candidate positions where both anchors match
   const candidates: Array<{ startLine: number; endLine: number }> = [];
@@ -247,7 +297,10 @@ export const BlockAnchorReplacer: Replacer = function* (content, find) {
     // Look for the matching last line after this first line
     for (let j = i + 2; j < originalLines.length; j++) {
       if (originalLines[j].trim() === lastLineSearch) {
-        candidates.push({ startLine: i, endLine: j });
+        const actualBlockSize = j - i + 1;
+        if (Math.abs(actualBlockSize - searchBlockSize) <= maxLineDelta) {
+          candidates.push({ startLine: i, endLine: j });
+        }
         break; // Only match the first occurrence of the last line
       }
     }
@@ -278,7 +331,7 @@ export const BlockAnchorReplacer: Replacer = function* (content, find) {
         similarity += (1 - distance / maxLen) / linesToCheck;
 
         // Exit early when threshold is reached
-        if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+        if (similarity >= limits.single) {
           break;
         }
       }
@@ -287,7 +340,7 @@ export const BlockAnchorReplacer: Replacer = function* (content, find) {
       similarity = 1.0;
     }
 
-    if (similarity >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
+    if (similarity >= limits.single) {
       let matchStartIndex = 0;
       for (let k = 0; k < startLine; k++) {
         matchStartIndex += originalLines[k].length + 1;
@@ -339,7 +392,7 @@ export const BlockAnchorReplacer: Replacer = function* (content, find) {
   }
 
   // Threshold judgment
-  if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
+  if (maxSimilarity >= limits.multiple && bestMatch) {
     const { startLine, endLine } = bestMatch;
     let matchStartIndex = 0;
     for (let k = 0; k < startLine; k++) {
@@ -631,6 +684,11 @@ export function replace(
   if (oldString === newString) {
     throw new Error('oldString and newString must be different');
   }
+  if (oldString === '') {
+    // Every replacer would "match" the empty string (MultiOccurrenceReplacer
+    // never terminates on it), so reject it explicitly.
+    throw new Error(EMPTY_OLD_STRING_ERROR);
+  }
 
   let notFound = true;
 
@@ -649,8 +707,18 @@ export function replace(
       const index = content.indexOf(search);
       if (index === -1) continue;
       notFound = false;
+      if (
+        !config.legacyEditMatching &&
+        isDisproportionateMatch(search, oldString)
+      ) {
+        throw new Error(
+          'Refusing replacement because the matched span is much larger than oldString. Re-read the file and provide the full exact oldString for the intended replacement.'
+        );
+      }
       if (replaceAll) {
-        return content.replaceAll(search, newString);
+        // split/join instead of String#replaceAll so `$&`, `$1`, `$'` in
+        // newString are inserted literally.
+        return content.split(search).join(newString);
       }
       const lastIndex = content.lastIndexOf(search);
       if (index !== lastIndex) continue;
@@ -669,3 +737,16 @@ export function replace(
     'Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match.'
   );
 }
+
+// A fuzzy replacer matched far more text than the model asked to replace
+// (upstream #30932): refuse instead of deleting unrelated code.
+function isDisproportionateMatch(search: string, oldString: string) {
+  const oldLines = oldString.split('\n').length;
+  const searchLines = search.split('\n').length;
+  if (searchLines >= Math.max(oldLines + 3, oldLines * 2)) return true;
+  if (oldLines === 1) return false;
+  return (
+    search.trim().length >
+    Math.max(oldString.trim().length + 500, oldString.trim().length * 4)
+  );
+}

package/src/tool/glob.ts

@@ -16,7 +16,7 @@ export const GlobTool = Tool.define('glob', {
         `The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.`
       ),
   }),
-  async execute(params) {
+  async execute(params, ctx) {
     let search = params.path ?? Instance.directory;
     search = path.isAbsolute(search)
       ? search
@@ -28,6 +28,7 @@ export const GlobTool = Tool.define('glob', {
     for await (const file of Ripgrep.files({
       cwd: search,
       glob: [params.pattern],
+      signal: ctx.abort,
     })) {
       if (files.length >= limit) {
         truncated = true;

package/src/tool/grep.ts

@@ -1,15 +1,23 @@
 import z from 'zod';
+import * as fs from 'fs/promises';
+import * as path from 'path';
 import { Tool } from './tool';
 import { Ripgrep } from '../file/ripgrep';
 
 import DESCRIPTION from './grep.txt';
 import { Instance } from '../project/instance';
+import { config } from '../config/config';
 import {
   byteOffsetToColumnIndex,
   formatFocusedLineWindow,
 } from './text-window';
 
 const MAX_MATCHING_LINE_LENGTH = 2000;
+const RESULT_LIMIT = 100;
+// rg output is parsed while it streams in, so memory is bounded by the
+// matches kept, not by rg's total output. Past this many matches rg is
+// stopped and the newest RESULT_LIMIT of the collected ones are returned.
+const MAX_COLLECTED_MATCHES = 10_000;
 
 export const GrepTool = Tool.define('grep', {
   description: DESCRIPTION,
@@ -30,28 +38,94 @@ export const GrepTool = Tool.define('grep', {
         'File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'
       ),
   }),
-  async execute(params) {
+  async execute(params, ctx) {
     if (!params.pattern) {
       throw new Error('pattern is required');
     }
 
-    const searchPath = params.path || Instance.directory;
+    // Relative paths are relative to the session directory, not to the
+    // process cwd that rg would otherwise use.
+    const searchPath = path.resolve(Instance.directory, params.path || '.');
+    // upstream 8f4b62eb49 (#35337): say so instead of passing rg's exit 2 on
+    if (!(await fs.stat(searchPath).catch(() => undefined))) {
+      throw new Error(`Search path does not exist: ${searchPath}`);
+    }
 
     const rgPath = await Ripgrep.filepath();
-    const args = ['--json', '--regexp', params.pattern];
+    // `--hidden` finds dotfiles such as `.github/` like glob/ls do (upstream
+    // d5738f542c #7501); --no-grep-hidden restores the previous behaviour.
+    // `--no-messages` keeps per-file errors out of stderr (upstream
+    // 4edb4fa4fa #8612); `--no-config` ignores RIPGREP_CONFIG_PATH.
+    const args = ['--json'];
+    if (config.grepHidden) args.push('--hidden');
+    args.push('--no-messages', '--no-config');
+    if (config.grepHidden) args.push('--glob=!**/.git/**');
+    args.push('--regexp', params.pattern);
     if (params.include) {
       args.push('--glob', params.include);
     }
     args.push(searchPath);
 
+    // upstream 4d2696e027 / 3bda0ce123 (#39238): honor the tool call's abort
+    // signal and do not let a huge search run forever
+    // (--grep-timeout-ms, 0 = no timeout).
+    ctx.abort.throwIfAborted();
+    const timeoutMs = config.grepTimeoutMs;
+    // rg gets its own controller: a listener on the long-lived ctx.abort
+    // would keep the process object reachable after the call returns.
+    const stop = new AbortController();
+    let timedOut = false;
+    const onAbort = () => stop.abort();
+    ctx.abort.addEventListener('abort', onAbort, { once: true });
+    const timer =
+      timeoutMs > 0
+        ? setTimeout(() => {
+            timedOut = true;
+            stop.abort();
+          }, timeoutMs)
+        : undefined;
+
     const proc = Bun.spawn([rgPath, ...args], {
       stdout: 'pipe',
       stderr: 'pipe',
+      signal: stop.signal,
     });
 
-    const output = await new Response(proc.stdout).text();
-    const errorOutput = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
+    const matches: Match[] = [];
+    let collectedAll = true;
+    let exitCode: number;
+    let errorOutput: string;
+    try {
+      // Drain both pipes concurrently: reading stdout to the end first
+      // deadlocks once rg fills the stderr pipe.
+      const stderr = new Response(proc.stderr).text();
+      const mtimes = new Map<string, number | null>();
+      for await (const line of lines(proc.stdout)) {
+        const match = await parseMatch(line, mtimes);
+        if (!match) continue;
+        matches.push(match);
+        if (matches.length >= MAX_COLLECTED_MATCHES) {
+          collectedAll = false;
+          proc.kill();
+          break;
+        }
+      }
+      [errorOutput, exitCode] = await Promise.all([stderr, proc.exited]);
+    } finally {
+      if (timer) clearTimeout(timer);
+      ctx.abort.removeEventListener('abort', onAbort);
+      // A parse error must not leave rg running.
+      if (proc.exitCode === null) proc.kill();
+    }
+
+    ctx.abort.throwIfAborted();
+    if (timedOut) {
+      throw new Error(
+        `Search timed out after ${timeoutMs / 1000} seconds. Consider using a more specific path or pattern.`
+      );
+    }
+    // rg was stopped on purpose after enough matches.
+    if (!collectedAll) exitCode = 0;
 
     if (exitCode === 1) {
       return {
@@ -61,59 +135,36 @@ export const GrepTool = Tool.define('grep', {
       };
     }
 
-    if (exitCode !== 0) {
-      throw new Error(`Exit code ${exitCode}\nripgrep failed: ${errorOutput}`);
+    // Exit codes: 0 = matches, 1 = no matches, 2 = an error occurred. With
+    // `--no-messages`, exit 2 without a regex error means some paths could
+    // not be read; the matches from readable files are still valid.
+    if (
+      exitCode === 2 &&
+      /regex parse error|error parsing regex/i.test(errorOutput)
+    ) {
+      throw new Error(`Invalid regex pattern: ${errorOutput.trim()}`);
     }
 
-    const matches = [];
-
-    for (const line of output.trim().split('\n')) {
-      if (!line) continue;
-
-      const event = JSON.parse(line);
-      if (event.type !== 'match') continue;
-
-      const filePath = event.data?.path?.text;
-      const lineNum = event.data?.line_number;
-      const rawLineText = event.data?.lines?.text;
-      const submatch = event.data?.submatches?.[0];
-      if (!filePath || !lineNum || typeof rawLineText !== 'string') continue;
-
-      const lineText = stripTrailingLineEnding(rawLineText);
-      const matchStart = byteOffsetToColumnIndex(
-        lineText,
-        submatch?.start ?? 0
-      );
-      const matchEnd = byteOffsetToColumnIndex(
-        lineText,
-        submatch?.end ?? submatch?.start ?? 0
-      );
-
-      const file = Bun.file(filePath);
-      const stats = await file.stat().catch(() => null);
-      if (!stats) continue;
-
-      matches.push({
-        path: filePath,
-        modTime: stats.mtime.getTime(),
-        lineNum,
-        lineText,
-        matchStart,
-        matchEnd,
-      });
+    if (exitCode !== 0 && exitCode !== 2) {
+      throw new Error(`Exit code ${exitCode}\nripgrep failed: ${errorOutput}`);
     }
 
+    const hasErrors = exitCode === 2;
+
     matches.sort((a, b) => b.modTime - a.modTime);
 
-    const limit = 100;
-    const truncated = matches.length > limit;
-    const finalMatches = truncated ? matches.slice(0, limit) : matches;
+    const limit = RESULT_LIMIT;
+    const truncated = matches.length > limit || !collectedAll;
+    const finalMatches =
+      matches.length > limit ? matches.slice(0, limit) : matches;
 
     if (finalMatches.length === 0) {
       return {
         title: params.pattern,
         metadata: { matches: 0, truncated: false },
-        output: 'No files found',
+        output: hasErrors
+          ? 'No files found\n\n(Some paths were inaccessible and skipped)'
+          : 'No files found',
       };
     }
 
@@ -128,15 +179,7 @@ export const GrepTool = Tool.define('grep', {
         currentFile = match.path;
         outputLines.push(`${match.path}:`);
       }
-      outputLines.push(
-        `  Line ${match.lineNum}: ${formatFocusedLineWindow({
-          line: match.lineText,
-          lineNumber: match.lineNum,
-          focusStart: match.matchStart,
-          focusEnd: match.matchEnd,
-          limit: MAX_MATCHING_LINE_LENGTH,
-        })}`
-      );
+      outputLines.push(`  Line ${match.lineNum}: ${match.text}`);
     }
 
     if (truncated) {
@@ -146,6 +189,11 @@ export const GrepTool = Tool.define('grep', {
       );
     }
 
+    if (hasErrors) {
+      outputLines.push('');
+      outputLines.push('(Some paths were inaccessible and skipped)');
+    }
+
     return {
       title: params.pattern,
       metadata: {
@@ -157,6 +205,76 @@ export const GrepTool = Tool.define('grep', {
   },
 });
 
+type Match = {
+  path: string;
+  modTime: number;
+  lineNum: number;
+  // Already windowed to MAX_MATCHING_LINE_LENGTH, so a minified file does not
+  // keep megabyte-long lines in memory.
+  text: string;
+};
+
+// Split a byte stream into lines without buffering the whole stream.
+async function* lines(stream: ReadableStream<Uint8Array>) {
+  const decoder = new TextDecoder();
+  let pending = '';
+  for await (const chunk of stream) {
+    pending += decoder.decode(chunk, { stream: true });
+    let index: number;
+    while ((index = pending.indexOf('\n')) !== -1) {
+      yield pending.slice(0, index).replace(/\r$/, '');
+      pending = pending.slice(index + 1);
+    }
+  }
+  pending += decoder.decode();
+  if (pending) yield pending;
+}
+
+async function parseMatch(
+  line: string,
+  mtimes: Map<string, number | null>
+): Promise<Match | undefined> {
+  if (!line) return undefined;
+  const event = JSON.parse(line);
+  if (event.type !== 'match') return undefined;
+
+  const filePath = event.data?.path?.text;
+  const lineNum = event.data?.line_number;
+  const rawLineText = event.data?.lines?.text;
+  const submatch = event.data?.submatches?.[0];
+  if (!filePath || !lineNum || typeof rawLineText !== 'string')
+    return undefined;
+
+  // One stat per file, not per matching line.
+  if (!mtimes.has(filePath)) {
+    const stats = await Bun.file(filePath)
+      .stat()
+      .catch(() => null);
+    mtimes.set(filePath, stats ? stats.mtime.getTime() : null);
+  }
+  const modTime = mtimes.get(filePath);
+  if (modTime === null || modTime === undefined) return undefined;
+
+  const lineText = stripTrailingLineEnding(rawLineText);
+  const matchStart = byteOffsetToColumnIndex(lineText, submatch?.start ?? 0);
+  const matchEnd = byteOffsetToColumnIndex(
+    lineText,
+    submatch?.end ?? submatch?.start ?? 0
+  );
+  return {
+    path: filePath,
+    modTime,
+    lineNum,
+    text: formatFocusedLineWindow({
+      line: lineText,
+      lineNumber: lineNum,
+      focusStart: matchStart,
+      focusEnd: matchEnd,
+      limit: MAX_MATCHING_LINE_LENGTH,
+    }),
+  };
+}
+
 function stripTrailingLineEnding(line: string) {
   return line.replace(/\r?\n$/, '');
 }

package/src/tool/ls.ts

@@ -48,7 +48,7 @@ export const ListTool = Tool.define('list', {
       .describe('List of glob patterns to ignore')
       .optional(),
   }),
-  async execute(params) {
+  async execute(params, ctx) {
     const searchPath = path.resolve(Instance.directory, params.path || '.');
 
     const ignoreGlobs = IGNORE_PATTERNS.map((p) => `!${p}*`).concat(
@@ -58,6 +58,7 @@ export const ListTool = Tool.define('list', {
     for await (const file of Ripgrep.files({
       cwd: searchPath,
       glob: ignoreGlobs,
+      signal: ctx.abort,
     })) {
       files.push(file);
       if (files.length >= LIMIT) break;

package/src/tool/multiedit.ts

@@ -49,7 +49,9 @@ export const MultiEditTool = Tool.define('multiedit', {
       metadata: {
         results: results.map((r) => r.metadata),
       },
-      output: results.at(-1)!.output,
+      // `edits: []` applies nothing; return an empty output like the Rust
+      // tool instead of throwing a TypeError (issue #335 parity audit).
+      output: results.at(-1)?.output ?? '',
     };
   },
 });