@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/bash-file-access.js

@@ -0,0 +1,830 @@
+import * as nodeFs from "node:fs";
+import * as path from "node:path";
+import { isReadableSourceFile } from "./file-kinds.js";
+import { classifyMutatingTool } from "./mutating-tool.js";
+import { countFileLines } from "./read-guard-tool-lines.js";
+import { stripAnsi } from "./sanitize.js";
+function stripQuotes(token) {
+  if (token.length >= 2) {
+    const first = token[0];
+    const last = token[token.length - 1];
+    if (first === "'" && last === "'" || first === '"' && last === '"') {
+      return token.slice(1, -1);
+    }
+  }
+  return token;
+}
+function parseHeredocDelimiter(command, start) {
+  let i = start;
+  const stripTabs = command[i] === "-";
+  if (stripTabs)
+    i += 1;
+  while (/\s/.test(command[i] ?? ""))
+    i += 1;
+  let delimiter = "";
+  let quoted = false;
+  while (i < command.length && !/[\s;&|<>]/.test(command[i] ?? "")) {
+    const ch = command[i];
+    if (ch === "'" || ch === '"') {
+      quoted = true;
+      const quote = ch;
+      i += 1;
+      while (i < command.length && command[i] !== quote) {
+        delimiter += command[i++];
+      }
+      if (command[i] !== quote)
+        return;
+      i += 1;
+      continue;
+    }
+    if (ch === "\\") {
+      quoted = true;
+      i += 1;
+      if (i >= command.length)
+        return;
+      delimiter += command[i++];
+      continue;
+    }
+    delimiter += ch;
+    i += 1;
+  }
+  if (!delimiter)
+    return;
+  return { heredoc: { delimiter, stripTabs, quoted }, end: i - 1 };
+}
+function heredocSubstitutionBodies(body) {
+  const substitutions = [];
+  for (let i = 0;i < body.length; i += 1) {
+    if (body.startsWith("$(", i)) {
+      let depth = 1;
+      let quote;
+      for (let end = i + 2;end < body.length; end += 1) {
+        const ch = body[end];
+        if (quote === "single") {
+          if (ch === "'")
+            quote = undefined;
+          continue;
+        }
+        if (quote === "double") {
+          if (ch === '"' && body[end - 1] !== "\\")
+            quote = undefined;
+          continue;
+        }
+        if (ch === "'" || ch === '"') {
+          quote = ch === "'" ? "single" : "double";
+        } else if (body.startsWith("$(", end)) {
+          depth += 1;
+          end += 1;
+        } else if (ch === ")") {
+          depth -= 1;
+          if (depth === 0) {
+            substitutions.push(body.slice(i + 2, end));
+            i = end;
+            break;
+          }
+        }
+      }
+    } else if (body[i] === "`" && body[i - 1] !== "\\") {
+      const end = body.indexOf("`", i + 1);
+      if (end >= 0) {
+        substitutions.push(body.slice(i + 1, end));
+        i = end;
+      }
+    }
+  }
+  return substitutions;
+}
+function consumeHeredocBodies(command, start, heredocs) {
+  let cursor = start;
+  const substitutions = [];
+  for (const heredoc of heredocs) {
+    const bodyStart = cursor;
+    let found = false;
+    while (cursor < command.length) {
+      const lineEnd = command.indexOf(`
+`, cursor);
+      const end = lineEnd < 0 ? command.length : lineEnd;
+      let line = command.slice(cursor, end);
+      if (heredoc.stripTabs)
+        line = line.replace(/^\t+/, "");
+      if (line.replace(/\r$/, "") === heredoc.delimiter) {
+        if (!heredoc.quoted)
+          substitutions.push(...heredocSubstitutionBodies(command.slice(bodyStart, cursor)));
+        cursor = lineEnd < 0 ? end : end + 1;
+        found = true;
+        break;
+      }
+      cursor = lineEnd < 0 ? end : end + 1;
+    }
+    if (!found) {
+      if (!heredoc.quoted)
+        substitutions.push(...heredocSubstitutionBodies(command.slice(bodyStart)));
+      return { end: command.length - 1, substitutions };
+    }
+  }
+  return { end: cursor - 1, substitutions };
+}
+export function tokenizeShellCommand(command) {
+  const segments = [];
+  const pendingHeredocs = [];
+  let tokens = [];
+  let word = "";
+  let quote;
+  let escaped = false;
+  let unsupported = false;
+  let atTokenStart = true;
+  const flushWord = () => {
+    if (word)
+      tokens.push(word);
+    word = "";
+    atTokenStart = true;
+  };
+  const flushSegment = (terminator) => {
+    flushWord();
+    if (tokens.length > 0 || unsupported)
+      segments.push({ tokens, unsupported, terminator });
+    tokens = [];
+    unsupported = false;
+    atTokenStart = true;
+  };
+  for (let i = 0;i < command.length; i++) {
+    const ch = command[i];
+    const next = command[i + 1];
+    if (quote === "single") {
+      if (ch === "'")
+        quote = undefined;
+      else
+        word += ch;
+      continue;
+    }
+    if (quote === "double") {
+      if (escaped) {
+        word += ch;
+        escaped = false;
+      } else if (ch === "\\")
+        escaped = true;
+      else if (ch === '"')
+        quote = undefined;
+      else
+        word += ch;
+      continue;
+    }
+    if (escaped) {
+      if (ch !== `
+`)
+        word += ch;
+      escaped = false;
+      atTokenStart = false;
+      continue;
+    }
+    if (ch === "\\") {
+      if (next === `
+` || /[\s\\'";$|&<>]/.test(next ?? "")) {
+        escaped = true;
+      } else {
+        word += ch;
+        atTokenStart = false;
+      }
+      atTokenStart = false;
+      continue;
+    }
+    if (ch === "'") {
+      quote = "single";
+      atTokenStart = false;
+      continue;
+    }
+    if (ch === '"') {
+      quote = "double";
+      atTokenStart = false;
+      continue;
+    }
+    if (ch === "#" && atTokenStart) {
+      while (i + 1 < command.length && command[i + 1] !== `
+`)
+        i++;
+      continue;
+    }
+    if (/\s/.test(ch) && ch !== `
+`) {
+      flushWord();
+      continue;
+    }
+    if (ch === ";" || ch === `
+` || ch === "|" || ch === "&") {
+      flushWord();
+      if (ch === `
+` && pendingHeredocs.length > 0) {
+        const heredocs = pendingHeredocs.splice(0);
+        flushSegment();
+        const consumed = consumeHeredocBodies(command, i + 1, heredocs);
+        for (const substitution of consumed.substitutions)
+          segments.push(...tokenizeShellCommand(substitution));
+        i = consumed.end;
+        continue;
+      }
+      let terminator;
+      if (ch === "|" && next === "|")
+        i++;
+      else if (ch === "&" && next === "&")
+        i++;
+      else if (ch === "|") {
+        unsupported = true;
+        terminator = "pipe";
+      } else if (ch === "&")
+        unsupported = true;
+      flushSegment(terminator);
+      continue;
+    }
+    if (ch === "<" || ch === ">") {
+      flushWord();
+      if (ch === "<" && next === "<" && command[i - 1] !== "<" && command[i + 2] !== "<") {
+        const parsed = parseHeredocDelimiter(command, i + 2);
+        if (parsed) {
+          pendingHeredocs.push(parsed.heredoc);
+          i = parsed.end;
+        }
+      }
+      unsupported = true;
+      continue;
+    }
+    word += ch;
+    atTokenStart = false;
+  }
+  if (quote || escaped)
+    unsupported = true;
+  flushSegment();
+  return segments;
+}
+function resolveCandidate(token, cwd) {
+  const cleaned = stripQuotes(token);
+  if (!cleaned || cleaned.startsWith("-") || !isReadableSourceFile(cleaned)) {
+    return null;
+  }
+  return path.isAbsolute(cleaned) ? cleaned : path.resolve(cwd, cleaned);
+}
+function parseCountFlag(token) {
+  const digits = token.replace(/^-n?/, "").replace(/[^0-9]/g, "");
+  if (!digits)
+    return;
+  const n = Number.parseInt(digits, 10);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+function commandSegments(command) {
+  return tokenizeShellCommand(command).map((segment) => segment.tokens);
+}
+function unwrapCommand(tokens) {
+  let verb = path.basename(tokens[0] ?? "");
+  let args = tokens.slice(1);
+  if (verb === "npx") {
+    while (args[0] === "-y" || args[0] === "--yes")
+      args = args.slice(1);
+    verb = path.basename(args[0] ?? "");
+    args = args.slice(1);
+  }
+  return { verb, args };
+}
+function formatterFileArgs(args, start = 0, valueOptions = new Set) {
+  const files = [];
+  for (let i = start;i < args.length; i += 1) {
+    const arg = args[i] ?? "";
+    if (valueOptions.has(arg)) {
+      i += 1;
+      continue;
+    }
+    if (arg === "--" || arg.startsWith("-"))
+      continue;
+    files.push(arg);
+  }
+  return files;
+}
+function extractRedirectTargets(command) {
+  const targets = [];
+  let quote;
+  let escaped = false;
+  for (let i = 0;i < command.length; i += 1) {
+    const ch = command[i];
+    if (quote === "single") {
+      if (ch === "'")
+        quote = undefined;
+      continue;
+    }
+    if (quote === "double") {
+      if (escaped)
+        escaped = false;
+      else if (ch === "\\")
+        escaped = true;
+      else if (ch === '"')
+        quote = undefined;
+      continue;
+    }
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === "'") {
+      quote = "single";
+      continue;
+    }
+    if (ch === '"') {
+      quote = "double";
+      continue;
+    }
+    if (ch !== ">")
+      continue;
+    while (i + 1 < command.length && /\s/.test(command[i + 1]))
+      i += 1;
+    if (command[i + 1] === ">")
+      i += 1;
+    while (i + 1 < command.length && /\s/.test(command[i + 1]))
+      i += 1;
+    let target = "";
+    for (i += 1;i < command.length; i += 1) {
+      const next = command[i];
+      if (/\s/.test(next) || next === ";" || next === "|" || next === "&") {
+        i -= 1;
+        break;
+      }
+      target += next;
+    }
+    if (target)
+      targets.push(target);
+  }
+  return targets;
+}
+export function extractReadPathsFromCommand(command, cwd) {
+  const spans = [];
+  const seen = new Set;
+  const resolveFile = (token) => {
+    const abs = resolveCandidate(token, cwd);
+    if (!abs)
+      return null;
+    try {
+      if (!nodeFs.statSync(abs).isFile())
+        return null;
+    } catch {
+      return null;
+    }
+    return { abs, total: countFileLines(abs) };
+  };
+  const addSpan = (token, start, count) => {
+    const file = resolveFile(token);
+    if (!file)
+      return;
+    const offset = Math.min(Math.max(1, start), file.total);
+    const limit = Math.min(count, file.total - offset + 1);
+    if (limit < 1)
+      return;
+    const key = `${file.abs}:${offset}:${limit}`;
+    if (seen.has(key))
+      return;
+    seen.add(key);
+    spans.push({ filePath: file.abs, offset, limit });
+  };
+  for (const tokens of commandSegments(command)) {
+    if (tokens.length === 0)
+      continue;
+    const verb = path.basename(tokens[0] ?? "");
+    const args = tokens.slice(1);
+    if (["cat", "bat", "less", "more", "nl"].includes(verb)) {
+      for (const a of args)
+        addSpan(a, 1, Number.MAX_SAFE_INTEGER);
+    } else if (verb === "head" || verb === "tail") {
+      let count;
+      const files = [];
+      for (let i = 0;i < args.length; i++) {
+        const a = args[i];
+        if (a === "-n" || a === "-c") {
+          const next = args[i + 1];
+          if (next !== undefined) {
+            count = parseCountFlag(next) ?? count;
+            i++;
+          }
+        } else if (/^-n?\d+$/.test(a)) {
+          count = parseCountFlag(a) ?? count;
+        } else if (!a.startsWith("-")) {
+          files.push(a);
+        }
+      }
+      const n = count ?? 10;
+      for (const f of files) {
+        const file = resolveFile(f);
+        if (!file)
+          continue;
+        if (verb === "head")
+          addSpan(f, 1, n);
+        else
+          addSpan(f, file.total - n + 1, n);
+      }
+    } else if (verb === "sed") {
+      if (args.includes("-i"))
+        continue;
+      let range;
+      for (const a of args) {
+        const m = stripQuotes(a).match(/^(\d+),(\d+)p$/);
+        if (m) {
+          range = {
+            start: Number.parseInt(m[1], 10),
+            end: Number.parseInt(m[2], 10)
+          };
+          break;
+        }
+      }
+      if (!range)
+        continue;
+      for (const a of args)
+        addSpan(a, range.start, range.end - range.start + 1);
+    }
+  }
+  return spans;
+}
+function grepHasLineNumbers(args) {
+  return args.some((arg) => {
+    const token = stripQuotes(arg);
+    if (token === "--line-number")
+      return true;
+    if (!token.startsWith("-") || token.startsWith("--"))
+      return false;
+    return token.slice(1).includes("n");
+  });
+}
+const GREP_OPTIONS_WITH_VALUE = new Set([
+  "-e",
+  "-f",
+  "-m",
+  "-A",
+  "-B",
+  "-C",
+  "--regexp",
+  "--file",
+  "--max-count",
+  "--after-context",
+  "--before-context",
+  "--context"
+]);
+function parseContextValue(inline, next) {
+  const raw = inline !== "" ? inline : next;
+  if (raw === undefined)
+    return;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n < 0)
+    return;
+  return Math.min(n, 100);
+}
+export function parseGrepContextLines(args) {
+  let before = 0;
+  let after = 0;
+  for (let i = 0;i < args.length; i++) {
+    const token = stripQuotes(args[i]);
+    if (token === "--")
+      break;
+    const nextToken = args[i + 1] === undefined ? undefined : stripQuotes(args[i + 1]);
+    const long = /^--(after|before)-context(?:=(\d+))?$/.exec(token);
+    if (long) {
+      const value = parseContextValue(long[2] ?? "", nextToken);
+      if (value === undefined)
+        continue;
+      if (long[1] === "after")
+        after = Math.max(after, value);
+      else
+        before = Math.max(before, value);
+      continue;
+    }
+    const longBoth = /^--context(?:=(\d+))?$/.exec(token);
+    if (longBoth) {
+      const value = parseContextValue(longBoth[1] ?? "", nextToken);
+      if (value === undefined)
+        continue;
+      before = Math.max(before, value);
+      after = Math.max(after, value);
+      continue;
+    }
+    const bare = /^-(\d+)$/.exec(token);
+    if (bare) {
+      const value = parseContextValue(bare[1], undefined);
+      if (value === undefined)
+        continue;
+      before = Math.max(before, value);
+      after = Math.max(after, value);
+      continue;
+    }
+    const short = /^-[A-Za-z]*([ABC])(\d*)$/.exec(token);
+    if (!short)
+      continue;
+    const value = parseContextValue(short[2], nextToken);
+    if (value === undefined)
+      continue;
+    if (short[1] === "A")
+      after = Math.max(after, value);
+    else if (short[1] === "B")
+      before = Math.max(before, value);
+    else {
+      before = Math.max(before, value);
+      after = Math.max(after, value);
+    }
+  }
+  return { before, after };
+}
+function extractGrepSearchFiles(args, cwd) {
+  const files = [];
+  let patternSeen = false;
+  let endOfOptions = false;
+  for (let i = 0;i < args.length; i++) {
+    const token = stripQuotes(args[i]);
+    if (!endOfOptions && token === "--") {
+      endOfOptions = true;
+      continue;
+    }
+    if (!endOfOptions && GREP_OPTIONS_WITH_VALUE.has(token)) {
+      i++;
+      continue;
+    }
+    if (!endOfOptions && /^-[ef].+/.test(token))
+      continue;
+    if (!endOfOptions && token.startsWith("-"))
+      continue;
+    if (!patternSeen) {
+      patternSeen = true;
+      continue;
+    }
+    const abs = resolveCandidate(token, cwd);
+    if (!abs)
+      continue;
+    try {
+      if (!nodeFs.statSync(abs).isFile())
+        continue;
+    } catch {
+      continue;
+    }
+    files.push(abs);
+  }
+  return files;
+}
+function parseGrepLineWithFile(line, cwd) {
+  const match = /^(.*?):(\d+):/.exec(stripAnsi(line));
+  if (!match)
+    return;
+  const lineNumber = Number.parseInt(match[2], 10);
+  if (!Number.isFinite(lineNumber) || lineNumber < 1)
+    return;
+  const abs = resolveCandidate(match[1], cwd);
+  if (!abs)
+    return;
+  try {
+    if (!nodeFs.statSync(abs).isFile())
+      return;
+  } catch {
+    return;
+  }
+  return { file: abs, startLine: lineNumber, endLine: lineNumber };
+}
+function parseGrepLineWithoutFile(line, file) {
+  const match = /^(\d+):/.exec(stripAnsi(line));
+  if (!match)
+    return;
+  const lineNumber = Number.parseInt(match[1], 10);
+  if (!Number.isFinite(lineNumber) || lineNumber < 1)
+    return;
+  return { file, startLine: lineNumber, endLine: lineNumber };
+}
+const LINE_DROPPING_TAIL_VERBS = new Set(["head", "tail", "uniq"]);
+function isSedQuitCommand(args) {
+  for (const arg of args) {
+    const token = stripQuotes(arg);
+    if (token.startsWith("-"))
+      continue;
+    if (/(^|[;\n])\s*(\d+|\$)?\s*q\b/.test(token))
+      return true;
+  }
+  return false;
+}
+function isLineDroppingTailCommand(tokens) {
+  const verb = path.basename(stripQuotes(tokens[0] ?? ""));
+  if (LINE_DROPPING_TAIL_VERBS.has(verb))
+    return true;
+  if (verb === "sed")
+    return isSedQuitCommand(tokens.slice(1));
+  return false;
+}
+function grepPipesIntoTruncatingTail(segments, index) {
+  if (segments[index]?.terminator !== "pipe")
+    return false;
+  for (let j = index + 1;j < segments.length; j++) {
+    if (isLineDroppingTailCommand(segments[j].tokens))
+      return true;
+    if (segments[j].terminator !== "pipe")
+      return false;
+  }
+  return false;
+}
+function collectGrepCommandFiles(command, cwd) {
+  const files = new Set;
+  let hasLineNumberGrep = false;
+  let context;
+  let truncated = false;
+  const segments = tokenizeShellCommand(command);
+  for (let i = 0;i < segments.length; i++) {
+    const tokens = segments[i].tokens;
+    const verb = path.basename(stripQuotes(tokens[0] ?? ""));
+    if (verb !== "grep" && verb !== "egrep" && verb !== "fgrep")
+      continue;
+    const args = tokens.slice(1);
+    if (!grepHasLineNumbers(args))
+      continue;
+    hasLineNumberGrep = true;
+    const segmentContext = parseGrepContextLines(args);
+    context = context ? {
+      before: Math.min(context.before, segmentContext.before),
+      after: Math.min(context.after, segmentContext.after)
+    } : segmentContext;
+    for (const file of extractGrepSearchFiles(args, cwd))
+      files.add(file);
+    if (grepPipesIntoTruncatingTail(segments, i))
+      truncated = true;
+  }
+  return {
+    hasLineNumberGrep,
+    files,
+    context: truncated ? { before: 0, after: 0 } : context ?? { before: 0, after: 0 }
+  };
+}
+function dedupePushSearchRead(out, seen, loc) {
+  if (!loc)
+    return;
+  const key = `${loc.file}:${loc.startLine}:${loc.endLine ?? loc.startLine}`;
+  if (seen.has(key))
+    return;
+  seen.add(key);
+  out.push(loc);
+}
+function parseGrepOutputSearchReads(output, cwd, singleFile) {
+  const out = [];
+  const seen = new Set;
+  for (const rawLine of output.split(/\r?\n/)) {
+    if (!rawLine)
+      continue;
+    dedupePushSearchRead(out, seen, parseGrepLineWithFile(rawLine, cwd));
+    if (singleFile) {
+      dedupePushSearchRead(out, seen, parseGrepLineWithoutFile(rawLine, singleFile));
+    }
+  }
+  return out;
+}
+export function extractGrepSearchReadsFromOutput(command, cwd, output) {
+  const { hasLineNumberGrep, files, context } = collectGrepCommandFiles(command, cwd);
+  if (!hasLineNumberGrep)
+    return [];
+  const singleFile = files.size === 1 ? [...files][0] : undefined;
+  const locations = parseGrepOutputSearchReads(output, cwd, singleFile);
+  for (const loc of locations) {
+    loc.contextBefore = context.before;
+    loc.contextAfter = context.after;
+  }
+  return locations;
+}
+export function extractWrittenPathsFromCommand(command, cwd) {
+  const out = new Set;
+  const add = (token) => {
+    const abs = resolveCandidate(token, cwd);
+    if (abs)
+      out.add(abs);
+  };
+  for (const tokens of commandSegments(command)) {
+    if (tokens.length === 0)
+      continue;
+    for (const target of extractRedirectTargets(command))
+      add(target);
+    break;
+  }
+  for (const tokens of commandSegments(command)) {
+    if (tokens.length === 0)
+      continue;
+    const { verb, args } = unwrapCommand(tokens);
+    if (verb === "tee" || verb === "touch") {
+      for (const a of args)
+        if (!a.startsWith("-"))
+          add(a);
+    } else if (verb === "sed" && args.includes("-i")) {
+      for (const a of args)
+        add(a);
+    } else if (verb === "cp" || verb === "mv" || verb === "install") {
+      const files = args.filter((a) => !a.startsWith("-"));
+      if (files.length >= 1)
+        add(files[files.length - 1]);
+    } else if (verb === "biome") {
+      const sub = args[0];
+      if ((sub === "format" || sub === "check") && args.includes("--write")) {
+        for (const file of formatterFileArgs(args, 1, new Set(["--config-path"])))
+          add(file);
+      }
+    } else if (verb === "prettier" && args.includes("--write")) {
+      for (const file of formatterFileArgs(args, 0, new Set(["--config", "--ignore-path", "--parser", "--plugin"])))
+        add(file);
+    } else if (verb === "eslint" && args.includes("--fix")) {
+      for (const file of formatterFileArgs(args, 0, new Set(["--config", "--ignore-path", "--parser", "--plugin"])))
+        add(file);
+    } else if (verb === "ruff") {
+      const sub = args[0];
+      if (sub === "format" || args.includes("--fix")) {
+        const start = sub === "format" || sub === "check" ? 1 : 0;
+        for (const file of formatterFileArgs(args, start, new Set(["--config"])))
+          add(file);
+      }
+    } else if (verb === "gofmt" && args.includes("-w")) {
+      for (const file of formatterFileArgs(args))
+        add(file);
+    } else if (verb === "cargo" && args[0] === "fmt") {
+      const separator = args.indexOf("--");
+      if (separator >= 0) {
+        for (const file of formatterFileArgs(args, separator + 1, new Set(["--edition", "--config-path"])))
+          add(file);
+      }
+    } else if (verb === "rustfmt") {
+      for (const file of formatterFileArgs(args, 0, new Set(["--edition", "--config-path"])))
+        add(file);
+    } else if (verb === "black") {
+      for (const file of formatterFileArgs(args, 0, new Set([
+        "--config",
+        "--exclude",
+        "--include",
+        "--line-length",
+        "--target-version"
+      ])))
+        add(file);
+    } else if (verb === "clang-format" && args.includes("-i")) {
+      for (const file of formatterFileArgs(args, 0, new Set(["--style", "--fallback-style", "--assume-filename"])))
+        add(file);
+    } else if (verb === "dotnet" && args[0] === "format") {
+      for (let i = 1;i < args.length; i += 1) {
+        if (args[i] === "--include" && args[i + 1]) {
+          for (const file of (args[i + 1] ?? "").split(","))
+            add(file);
+          i += 1;
+        } else if (args[i]?.startsWith("--include=")) {
+          for (const file of (args[i] ?? "").slice("--include=".length).split(","))
+            add(file);
+        }
+      }
+    } else if (verb === "git") {
+      const sub = args[0];
+      if (sub === "checkout" || sub === "restore") {
+        const dashDash = args.indexOf("--");
+        const fileArgs = dashDash >= 0 ? args.slice(dashDash + 1) : sub === "restore" ? args.slice(1).filter((a) => !a.startsWith("-")) : [];
+        for (const a of fileArgs)
+          add(a);
+      } else if (sub === "mv") {
+        const files = args.slice(1).filter((a) => !a.startsWith("-"));
+        if (files.length >= 1)
+          add(files[files.length - 1]);
+      }
+    }
+  }
+  return Array.from(out);
+}
+export function extractDeletedPathsFromCommand(command, cwd) {
+  const out = new Set;
+  const add = (token) => {
+    const abs = resolveCandidate(token, cwd);
+    if (abs)
+      out.add(abs);
+  };
+  const addMoveSources = (args) => {
+    const files = args.filter((a) => !a.startsWith("-"));
+    if (files.length >= 2) {
+      for (const src of files.slice(0, -1))
+        add(src);
+    }
+  };
+  for (const tokens of commandSegments(command)) {
+    if (tokens.length === 0)
+      continue;
+    const verb = path.basename(tokens[0] ?? "");
+    const args = tokens.slice(1);
+    if (verb === "rm") {
+      for (const a of args)
+        if (!a.startsWith("-"))
+          add(a);
+    } else if (verb === "git" && args[0] === "rm") {
+      const rmArgs = args.slice(1);
+      const dashDash = rmArgs.indexOf("--");
+      const fileArgs = dashDash >= 0 ? rmArgs.slice(dashDash + 1) : rmArgs.filter((a) => !a.startsWith("-"));
+      for (const a of fileArgs)
+        add(a);
+    } else if (verb === "git" && args[0] === "mv") {
+      addMoveSources(args.slice(1));
+    } else if (verb === "mv") {
+      addMoveSources(args);
+    }
+  }
+  return Array.from(out);
+}
+export function isEditClassToolResult(event, cwd) {
+  if (classifyMutatingTool(event, { recognizeOnly: true }) !== undefined) {
+    return true;
+  }
+  const command = event?.input?.command;
+  return typeof command === "string" && extractWrittenPathsFromCommand(command, cwd).length > 0;
+}