@cdoing/core 0.1.0

package/src/utils/search-match.ts

@@ -0,0 +1,495 @@
+/**
+ * Search Match — multi-strategy string matching for file editing.
+ *
+ * Inspired by Continue's cascading match strategies:
+ *   1. Exact match
+ *   2. Trimmed match (ignore leading/trailing whitespace)
+ *   3. Case-insensitive match
+ *   4. Whitespace-ignored match (strips all whitespace, maps back to original positions)
+ *
+ * This makes the edit tool far more resilient to LLM formatting differences.
+ */
+
+export interface SearchMatchResult {
+  startIndex: number;
+  endIndex: number;
+  strategyName: string;
+}
+
+type MatchStrategy = (fileContent: string, searchContent: string) => SearchMatchResult | null;
+
+/** 1. Exact string match */
+function exactMatch(fileContent: string, searchContent: string): SearchMatchResult | null {
+  const idx = fileContent.indexOf(searchContent);
+  if (idx !== -1) {
+    return { startIndex: idx, endIndex: idx + searchContent.length, strategyName: "exact" };
+  }
+  return null;
+}
+
+/** 2. Trimmed match — ignore leading/trailing whitespace */
+function trimmedMatch(fileContent: string, searchContent: string): SearchMatchResult | null {
+  const trimmed = searchContent.trim();
+  if (!trimmed) return null;
+  if (trimmed === searchContent) return null;
+  const idx = fileContent.indexOf(trimmed);
+  if (idx !== -1) {
+    return { startIndex: idx, endIndex: idx + trimmed.length, strategyName: "trimmed" };
+  }
+  return null;
+}
+
+/** 3. Case-insensitive match */
+function caseInsensitiveMatch(fileContent: string, searchContent: string): SearchMatchResult | null {
+  const idx = fileContent.toLowerCase().indexOf(searchContent.toLowerCase());
+  if (idx !== -1) {
+    return { startIndex: idx, endIndex: idx + searchContent.length, strategyName: "caseInsensitive" };
+  }
+  return null;
+}
+
+/** 4. Whitespace-ignored match — strips all whitespace, maps positions back */
+function whitespaceIgnoredMatch(fileContent: string, searchContent: string): SearchMatchResult | null {
+  const strippedFile = fileContent.replace(/\s/g, "");
+  const strippedSearch = searchContent.replace(/\s/g, "");
+
+  if (!strippedSearch) return null;
+
+  const strippedIdx = strippedFile.indexOf(strippedSearch);
+  if (strippedIdx === -1) return null;
+
+  // Map stripped position back to original
+  let originalStart = -1;
+  let nonWsCount = 0;
+
+  for (let i = 0; i < fileContent.length; i++) {
+    if (!/\s/.test(fileContent[i])) {
+      if (nonWsCount === strippedIdx) {
+        originalStart = i;
+        break;
+      }
+      nonWsCount++;
+    }
+  }
+
+  if (originalStart === -1) return null;
+
+  // Find end position
+  let originalEnd = originalStart;
+  let matchedChars = 0;
+
+  for (let i = originalStart; i < fileContent.length; i++) {
+    if (!/\s/.test(fileContent[i])) {
+      matchedChars++;
+      if (matchedChars === strippedSearch.length) {
+        originalEnd = i + 1;
+        break;
+      }
+    }
+    originalEnd = i + 1;
+  }
+
+  return { startIndex: originalStart, endIndex: originalEnd, strategyName: "whitespaceIgnored" };
+}
+
+/** 5. Jaro-Winkler fuzzy match — line-based sliding window with 90%+ threshold */
+function fuzzyMatch(fileContent: string, searchContent: string): SearchMatchResult | null {
+  const searchBlock = searchContent.trim();
+  if (searchBlock.length < 10) return null; // Too short for meaningful fuzzy match
+
+  const searchLines = searchBlock.split("\n");
+  const fileLines = fileContent.split("\n");
+  if (searchLines.length > fileLines.length) return null;
+
+  let bestMatch: SearchMatchResult | null = null;
+  let bestSimilarity = 0;
+  const threshold = 0.9;
+
+  // Sliding window of searchLines.length over fileLines
+  for (let i = 0; i <= fileLines.length - searchLines.length; i++) {
+    const candidate = fileLines.slice(i, i + searchLines.length).join("\n").trim();
+    if (candidate.length < 5) continue;
+
+    const similarity = jaroWinklerSimilarity(searchBlock, candidate);
+    if (similarity >= threshold && similarity > bestSimilarity) {
+      const before = fileLines.slice(0, i).join("\n");
+      const startIndex = before.length + (i > 0 ? 1 : 0);
+      bestMatch = {
+        startIndex,
+        endIndex: startIndex + candidate.length,
+        strategyName: "fuzzy",
+      };
+      bestSimilarity = similarity;
+    }
+  }
+
+  return bestMatch;
+}
+
+function jaroSimilarity(s1: string, s2: string): number {
+  if (s1 === s2) return 1.0;
+  if (!s1.length || !s2.length) return 0.0;
+
+  const matchDist = Math.floor(Math.max(s1.length, s2.length) / 2) - 1;
+  if (matchDist < 0) return 0.0;
+
+  const s1m = new Array(s1.length).fill(false);
+  const s2m = new Array(s2.length).fill(false);
+  let matches = 0;
+  let transpositions = 0;
+
+  for (let i = 0; i < s1.length; i++) {
+    const lo = Math.max(0, i - matchDist);
+    const hi = Math.min(i + matchDist + 1, s2.length);
+    for (let j = lo; j < hi; j++) {
+      if (s2m[j] || s1[i] !== s2[j]) continue;
+      s1m[i] = s2m[j] = true;
+      matches++;
+      break;
+    }
+  }
+
+  if (!matches) return 0.0;
+
+  let k = 0;
+  for (let i = 0; i < s1.length; i++) {
+    if (!s1m[i]) continue;
+    while (!s2m[k]) k++;
+    if (s1[i] !== s2[k]) transpositions++;
+    k++;
+  }
+
+  return (matches / s1.length + matches / s2.length + (matches - transpositions / 2) / matches) / 3;
+}
+
+function jaroWinklerSimilarity(s1: string, s2: string): number {
+  const jaro = jaroSimilarity(s1, s2);
+  if (jaro < 0.7) return jaro;
+  let prefix = 0;
+  const max = Math.min(4, Math.min(s1.length, s2.length));
+  for (let i = 0; i < max; i++) {
+    if (s1[i] === s2[i]) prefix++;
+    else break;
+  }
+  return jaro + prefix * 0.1 * (1 - jaro);
+}
+
+const strategies: MatchStrategy[] = [
+  exactMatch,
+  trimmedMatch,
+  caseInsensitiveMatch,
+  whitespaceIgnoredMatch,
+  fuzzyMatch,
+];
+
+/**
+ * Find a match for searchContent in fileContent using cascading strategies.
+ * Returns null if no strategy matches.
+ */
+export function findSearchMatch(fileContent: string, searchContent: string): SearchMatchResult | null {
+  if (!searchContent.trim()) {
+    return { startIndex: 0, endIndex: 0, strategyName: "empty" };
+  }
+
+  for (const strategy of strategies) {
+    const result = strategy(fileContent, searchContent);
+    if (result) return result;
+  }
+
+  return null;
+}
+
+/**
+ * Find all matches for searchContent in fileContent.
+ */
+export function findAllSearchMatches(fileContent: string, searchContent: string): SearchMatchResult[] {
+  if (!searchContent.trim()) {
+    return [{ startIndex: 0, endIndex: 0, strategyName: "empty" }];
+  }
+
+  const matches: SearchMatchResult[] = [];
+  let remaining = fileContent;
+  let offset = 0;
+
+  while (remaining.length > 0) {
+    const match = findSearchMatch(remaining, searchContent);
+    if (!match) break;
+
+    const adjusted: SearchMatchResult = {
+      startIndex: match.startIndex + offset,
+      endIndex: match.endIndex + offset,
+      strategyName: match.strategyName,
+    };
+
+    // Prevent infinite loops
+    if (matches.length > 0 && adjusted.startIndex <= matches[matches.length - 1].startIndex) break;
+
+    matches.push(adjusted);
+    offset = adjusted.endIndex;
+    remaining = fileContent.slice(offset);
+  }
+
+  return matches;
+}
+
+/**
+ * Execute a single find-and-replace on content.
+ * Uses multi-strategy matching. Returns the new content.
+ * Throws if match not found or multiple matches without replace_all.
+ *
+ * When a non-exact strategy is used, indentation is automatically
+ * adjusted so that new_string matches the file's original indentation
+ * rather than whatever the LLM happened to produce.
+ */
+export function executeFindAndReplace(
+  content: string,
+  oldString: string,
+  newString: string,
+  replaceAll: boolean,
+): { result: string; count: number; strategy: string } {
+  if (oldString === newString) {
+    throw new Error("old_string and new_string are identical — no change needed");
+  }
+
+  const matches = findAllSearchMatches(content, oldString);
+
+  if (matches.length === 0) {
+    throw new Error(`old_string not found in file (tried exact, trimmed, case-insensitive, and whitespace-ignored matching)`);
+  }
+
+  if (!replaceAll && matches.length > 1) {
+    throw new Error(`Multiple matches found (${matches.length}). Use replace_all or add more surrounding context to make old_string unique.`);
+  }
+
+  const toReplace = replaceAll ? matches : [matches[0]];
+  const strategy = matches[0].strategyName;
+
+  // Apply replacements in reverse order to preserve positions
+  let result = content;
+  for (let i = toReplace.length - 1; i >= 0; i--) {
+    const m = toReplace[i];
+    const adjustedNewString = normalizeIndentation(content, m.startIndex, oldString, newString, strategy === "exact");
+    result = result.substring(0, m.startIndex) + adjustedNewString + result.substring(m.endIndex);
+  }
+
+  return { result, count: toReplace.length, strategy };
+}
+
+/**
+ * Normalize indentation of new_string so it matches the file's context.
+ *
+ * The key idea: preserve the RELATIVE indentation within new_string,
+ * but set the BASE indentation to match the target (the file's actual
+ * indentation at the match point).
+ *
+ * Example:
+ *   File:       "  update: (id, data) => {\n    return id;\n  }"   (base: 2 spaces)
+ *   new_string: "      modifyItem: (id, data) => {\n        return id;\n      }"  (base: 6 spaces)
+ *   Result:     "  modifyItem: (id, data) => {\n    return id;\n  }"  (base: 2 spaces, relative preserved)
+ */
+function normalizeIndentation(
+  fileContent: string,
+  matchStartIndex: number,
+  _oldString: string,
+  newString: string,
+  _isExact: boolean,
+): string {
+  // Get the full line indentation at the match point in the file
+  const fileLineIndent = getLineIndent(fileContent, matchStartIndex);
+
+  // How much of that indent is BEFORE matchStartIndex?
+  // (already in the file, outside the matched range — it stays in the output)
+  //
+  // For exact match: match includes the indent → preMatchIndent = ""
+  // For trimmed match: match starts after indent → preMatchIndent = fileLineIndent
+  const lineStartPos = matchStartIndex - fileLineIndent.length;
+  const preMatchIndent = fileContent.substring(lineStartPos, matchStartIndex);
+
+  // The first line of the replacement needs LESS indent because preMatchIndent
+  // is already in the file before the insertion point.
+  // Subsequent lines start on fresh lines (after \n) — they need the full indent.
+  const firstLineTargetIndent = fileLineIndent.substring(preMatchIndent.length);
+
+  // What base indentation does new_string currently have?
+  const newBaseIndent = getLeadingWhitespace(newString);
+
+  // If first-line target already matches new_string's base, no adjustment needed
+  if (firstLineTargetIndent === newBaseIndent) return newString;
+
+  // Re-indent every line: strip newBaseIndent, prepend the correct target indent.
+  const lines = newString.split("\n");
+  const adjusted = lines.map((line, i) => {
+    const lineIndent = getLeadingWhitespace(line);
+    const content = line.substring(lineIndent.length);
+
+    // Empty/whitespace-only lines: keep as-is
+    if (!content) return line;
+
+    // Compute relative indent (how much deeper than new_string's base)
+    let relativeIndent = "";
+    if (lineIndent.length >= newBaseIndent.length && lineIndent.startsWith(newBaseIndent)) {
+      relativeIndent = lineIndent.substring(newBaseIndent.length);
+    }
+
+    // First line: use firstLineTargetIndent (accounts for pre-match whitespace already in file)
+    // Subsequent lines: use full fileLineIndent (they start on fresh lines after \n)
+    const baseIndent = i === 0 ? firstLineTargetIndent : fileLineIndent;
+
+    return baseIndent + relativeIndent + content;
+  });
+
+  return adjusted.join("\n");
+}
+
+/** Get the indentation (leading whitespace) at a position in the file */
+function getLineIndent(content: string, position: number): string {
+  // Walk backwards to find the start of the line
+  let lineStart = position;
+  while (lineStart > 0 && content[lineStart - 1] !== "\n") {
+    lineStart--;
+  }
+  // Extract leading whitespace from line start to the first non-whitespace
+  let indent = "";
+  for (let i = lineStart; i < content.length && (content[i] === " " || content[i] === "\t"); i++) {
+    indent += content[i];
+  }
+  return indent;
+}
+
+/** Get leading whitespace of a string's first line */
+function getLeadingWhitespace(text: string): string {
+  const match = text.match(/^([ \t]*)/);
+  return match ? match[1] : "";
+}
+
+
+/**
+ * Execute multiple sequential find-and-replace operations.
+ * Each edit operates on the result of the previous one.
+ * Atomic: if any edit fails, none are applied (throws).
+ */
+export function executeMultiFindAndReplace(
+  content: string,
+  edits: Array<{ old_string: string; new_string: string; replace_all?: boolean }>,
+): { result: string; totalCount: number } {
+  let current = content;
+  let totalCount = 0;
+
+  for (let i = 0; i < edits.length; i++) {
+    const edit = edits[i];
+    try {
+      const { result, count } = executeFindAndReplace(
+        current,
+        edit.old_string,
+        edit.new_string,
+        edit.replace_all ?? false,
+      );
+      current = result;
+      totalCount += count;
+    } catch (err) {
+      throw new Error(`Edit ${i + 1}/${edits.length} failed: ${(err as Error).message}`);
+    }
+  }
+
+  return { result: current, totalCount };
+}
+
+// ── Unified Diff Application ────────────────────────────────────────────────
+
+/**
+ * Check if a string looks like a unified diff format.
+ */
+export function isUnifiedDiff(text: string): boolean {
+  return /^@@\s+-\d+(?:,\d+)?\s+\+\d+(?:,\d+)?\s+@@/m.test(text);
+}
+
+/**
+ * Apply a unified diff to file content.
+ * Supports standard @@ -n,m +n,m @@ hunk headers.
+ * Tolerates minor whitespace differences in context lines.
+ */
+export function applyUnifiedDiff(originalContent: string, diff: string): string {
+  const lines = diff.split("\n");
+  const sourceLines = originalContent.split("\n");
+  const resultLines = [...sourceLines];
+
+  // Parse hunks
+  const hunks: Array<{
+    oldStart: number;
+    oldCount: number;
+    newStart: number;
+    newCount: number;
+    lines: Array<{ type: "context" | "add" | "remove"; text: string }>;
+  }> = [];
+
+  let currentHunk: typeof hunks[0] | null = null;
+
+  for (const line of lines) {
+    // Skip file headers
+    if (line.startsWith("---") || line.startsWith("+++")) continue;
+
+    // Parse hunk header
+    const hunkMatch = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+    if (hunkMatch) {
+      if (currentHunk) hunks.push(currentHunk);
+      currentHunk = {
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldCount: parseInt(hunkMatch[2] ?? "1", 10),
+        newStart: parseInt(hunkMatch[3], 10),
+        newCount: parseInt(hunkMatch[4] ?? "1", 10),
+        lines: [],
+      };
+      continue;
+    }
+
+    if (!currentHunk) continue;
+
+    if (line.startsWith("+")) {
+      currentHunk.lines.push({ type: "add", text: line.substring(1) });
+    } else if (line.startsWith("-")) {
+      currentHunk.lines.push({ type: "remove", text: line.substring(1) });
+    } else if (line.startsWith(" ") || line === "") {
+      currentHunk.lines.push({ type: "context", text: line.startsWith(" ") ? line.substring(1) : line });
+    }
+  }
+
+  if (currentHunk) hunks.push(currentHunk);
+
+  if (hunks.length === 0) {
+    throw new Error("No valid hunks found in diff");
+  }
+
+  // Apply hunks in reverse order to preserve line numbers
+  for (let h = hunks.length - 1; h >= 0; h--) {
+    const hunk = hunks[h];
+    const startLine = hunk.oldStart - 1; // Convert to 0-based
+
+    // Collect removals and additions
+    const toRemove: number[] = [];
+    const toAdd: string[] = [];
+    let lineIdx = startLine;
+
+    for (const dl of hunk.lines) {
+      if (dl.type === "remove") {
+        toRemove.push(lineIdx);
+        lineIdx++;
+      } else if (dl.type === "add") {
+        toAdd.push(dl.text);
+      } else {
+        // context
+        lineIdx++;
+      }
+    }
+
+    // Remove lines (reverse order)
+    for (let i = toRemove.length - 1; i >= 0; i--) {
+      resultLines.splice(toRemove[i], 1);
+    }
+
+    // Insert new lines at the position of first removal (or startLine if no removals)
+    const insertAt = toRemove.length > 0 ? toRemove[0] : startLine;
+    resultLines.splice(insertAt, 0, ...toAdd);
+  }
+
+  return resultLines.join("\n");
+}

package/src/utils/shell-paths.ts

@@ -0,0 +1,79 @@
+/**
+ * Shell command path extraction — shared between ShellExecTool and PermissionManager.
+ *
+ * Heuristically extracts file paths from a shell command and classifies them
+ * as read / write / delete operations so permission rules can be applied.
+ */
+
+import * as path from "path";
+
+/** Commands that READ files */
+const READ_COMMANDS  = /\b(?:cat|less|more|head|tail|bat|view|open|code|vim|nano|emacs|pg|nl|od|xxd|strings|file|wc|cksum|md5|sha\w+sum|diff|cmp|sort|uniq|awk|sed|grep|rg|ag|fzf)\b/;
+/** Commands that WRITE/MODIFY files */
+const WRITE_COMMANDS = /\b(?:cp|mv|install|patch|chmod|chown|chgrp|touch|truncate|split|csplit|sed\s+-i|perl\s+-[pi])\b/;
+/** Commands that DELETE files */
+const DELETE_COMMANDS = /\b(?:rm|rmdir|del|rd|unlink|shred|trash|git\s+clean)\b/;
+
+export interface ExtractedPaths {
+  read:   string[];
+  write:  string[];
+  delete: string[];
+}
+
+/**
+ * Extract file paths from a shell command and classify by operation type.
+ * Best-effort heuristic — compound commands are split on operators and analyzed per segment.
+ */
+export function extractShellPaths(command: string, workingDir: string): ExtractedPaths {
+  const result: ExtractedPaths = { read: [], write: [], delete: [] };
+
+  const segments = command.split(/\s*(?:&&|\|\||;|\|)\s*/);
+
+  for (const seg of segments) {
+    const trimmed = seg.trim();
+    if (!trimmed) continue;
+
+    const parts = trimmed.split(/\s+/).filter((p) => !p.includes("=") || p.startsWith("-"));
+    if (parts.length === 0) continue;
+
+    const args = parts.slice(1).filter((a) => !a.startsWith("-") && a !== "");
+
+    const resolvePath = (p: string): string => {
+      if (p.startsWith("/") || p.startsWith("~")) return p;
+      return path.resolve(workingDir, p);
+    };
+
+    if (DELETE_COMMANDS.test(trimmed)) {
+      for (const a of args) result.delete.push(resolvePath(a));
+    } else if (WRITE_COMMANDS.test(trimmed)) {
+      // cp/mv: last arg is destination (write), rest are sources (read)
+      if (/\b(?:cp|mv)\b/.test(trimmed) && args.length >= 2) {
+        for (let i = 0; i < args.length - 1; i++) result.read.push(resolvePath(args[i]));
+        result.write.push(resolvePath(args[args.length - 1]));
+      } else {
+        for (const a of args) result.write.push(resolvePath(a));
+      }
+    } else if (READ_COMMANDS.test(trimmed)) {
+      for (const a of args) result.read.push(resolvePath(a));
+    }
+
+    // Redirect writes: > file, >> file
+    let m;
+    const redirectRe = />{1,2}\s*([^\s;|&>]+)/g;
+    while ((m = redirectRe.exec(trimmed)) !== null) {
+      result.write.push(resolvePath(m[1]));
+    }
+
+    // tee writes
+    const teeRe = /\btee\s+(?:-[a-zA-Z]\s+)*([^\s;|&]+)/g;
+    while ((m = teeRe.exec(trimmed)) !== null) {
+      result.write.push(resolvePath(m[1]));
+    }
+  }
+
+  result.read   = [...new Set(result.read)];
+  result.write  = [...new Set(result.write)];
+  result.delete = [...new Set(result.delete)];
+
+  return result;
+}