Function EditFile

internal/tools/edit.go:15–62

EditFile replaces old_string with new_string in path. old_string must match EXACTLY ONCE; otherwise the file is untouched and an error string is returned so the model sees the failure and reacts, same convention as bash/WriteFile. Empty old_string is rejected (no anchor, every position matches); ol

(path, oldString, newString string)

// Empty old_string is rejected (no anchor, every position matches);
// old_string == new_string is rejected as a no-op turn-waster.
func EditFile(path, oldString, newString string) string {
	if path == "" {
		return "(empty path)"
	}
	if oldString == "" {
		return "(empty old_string)"
	}
	if oldString == newString {
		return "(no change: old_string equals new_string)"
	}
	// Same guard as ReadFile: open(2) on a FIFO blocks forever and Ctrl+C
	// can't unblock it, leaking the tool goroutine. Stat never blocks.
	if info, err := os.Stat(path); err == nil && !info.Mode().IsRegular() && !info.IsDir() {
		return fmt.Sprintf("(read error: %s is not a regular file)", path)
	}
	raw, err := os.ReadFile(path)
	if err != nil {
		return fmt.Sprintf("(read error: %v)", err)
	}
	content := string(raw)
	n := strings.Count(content, oldString)
	if n == 0 {
		// A near-miss that differs only in whitespace (wrong indentation, tabs vs
		// spaces) is the most common edit_file failure for an LLM. Name it so the
		// model fixes the bytes instead of burning retries toward the failure nudge.
		// Detection only; never auto-apply a fuzzy match, or the exact-match-once
		// safety the caller relies on is gone.
		if differsOnlyInWhitespace(content, oldString) {
			return fmt.Sprintf("(not found: no exact match in %s - a block there differs only in whitespace (indentation/tabs/newlines); copy the exact bytes, including indentation)", path)
		}
		return fmt.Sprintf("(not found: old_string does not appear in %s)", path)
	}
	if n > 1 {
		return fmt.Sprintf("(ambiguous: old_string appears %d times - provide more context to make it unique)", n)
	}
	// strings.Count only counts non-overlapping occurrences, so a self-
	// overlapping old_string ("==" in "a === b") passes n == 1 yet matches at
	// two positions with different results. Catch the overlapping second match
	// so the exactly-once guarantee holds.
	if idx := strings.Index(content, oldString); strings.Contains(content[idx+1:], oldString) {
		return "(ambiguous: old_string overlaps itself - provide more context to make it unique)"
	}
	updated := strings.Replace(content, oldString, newString, 1)
	if err := os.WriteFile(path, []byte(updated), 0o644); err != nil {
		return fmt.Sprintf("(write error: %v)", err)
	}
	return fmt.Sprintf("edited %s: -%d +%d bytes", path, len(oldString), len(newString))
}

// differsOnlyInWhitespace reports whether oldString matches content at exactly
// one spot once every whitespace run is collapsed: i.e. the sole mismatch is