llm-tools.el

llm-tools-edit.el (4586B)

---

 ;; llm-tools-edit.el --- Hashline file operations for llm-tools  -*- lexical-binding: t; -*-
 
 ;; Copyright (C) 2026 Vineet K
 
 ;; Author: Vineet K <git@vineetk.net>
 ;; Version: 1.0
 ;; Keywords: llm, gptel
 ;; Package-Requires: ((emacs "28.1"))
 
 ;; This program is free software; you can redistribute it and/or modify
 ;; it under the terms of the GNU General Public License as published by
 ;; the Free Software Foundation, either version 3 of the License, or
 ;; (at your option) any later version.
 
 ;; This program is distributed in the hope that it will be useful,
 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ;; GNU General Public License for more details.
 
 ;; You should have received a copy of the GNU General Public License
 ;; along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 ;;; Commentary:
 
 ;; File editing tool for the llm-tools package.
 ;; Provides functions for reading, editing, and verifying files using
 ;; a content-addressed line format.
 
 ;;; Code:
 
 (require 'cl-lib)
 (require 'subr-x)
 
 (defun llm-tools--edit-file-lines (file &optional beg end)
   "Return FILE contents as a list of strings.
 With optional BEG and END (inclusive, 1-based), return the lines between that range."
   (with-temp-buffer
     (insert-file-contents-literally file)
     (let ((lines (string-lines (buffer-string))))
       (if beg
 	  (cl-subseq lines (1- beg) end)
 	lines))))
 
 (defun llm-tools--edit-file-read (file &optional beg end as-list? tail)
   "Return FILE contents.
 With optional BEG and END (inclusive, 1-based), return lines BEG to END.
 If AS-LIST? is non-nil, return a list of strings instead of a single
 string.
 TAIL reads the last N lines and cannot be combined with BEG or END."
   (when (and tail (or beg end (not (and (integerp tail) (> tail 0)))))
     (error "tail must be positive and cannot be combined with beg or end"))
   (let* ((lines (llm-tools--edit-file-lines file beg end))
          (lines (if tail (last lines tail) lines))
 	 (formatted (string-join lines "\n")))
     (if as-list?
 	lines
       formatted)))
 
 (defun llm-tools--edit-apply (content old-string new-string &optional replace-all?)
   "Replace literal OLD-STRING with NEW-STRING in CONTENT.
 Require exactly one non-overlapping match unless REPLACE-ALL? is non-nil.
 Normalize CRLF to LF. Return the edited string, or signal an error."
   (when (string-empty-p old-string)
     (error "old_string must be a non-empty string"))
   (when (string= old-string new-string)
     (error "old_string and new_string must differ"))
   (let* ((content (string-replace "\r\n" "\n" content))
          (old-string (string-replace "\r\n" "\n" old-string))
          (new-string (string-replace "\r\n" "\n" new-string))
          (pattern (regexp-quote old-string))
          (case-fold-search nil)
          (position 0)
          (count 0))
     (while (string-match pattern content position)
       (setq count (1+ count)
             position (match-end 0)))
     (cond
      ((zerop count)
       (error "old_string was not found"))
      ((and (> count 1) (not replace-all?))
       (error "old_string matched %d times; provide more context or set replace_all to true"
              count)))
     (replace-regexp-in-string pattern new-string content t t)))
 
 (defun llm-tools--edit (file-path old-string new-string &optional replace-all?)
   "Replace literal OLD-STRING with NEW-STRING in FILE-PATH.
 Require a unique match unless REPLACE-ALL? is non-nil.
 Return a success message, or an error message without writing on match failure."
   (condition-case err
       (progn
         (when (string-empty-p (string-trim file-path))
           (error "file_path must be a non-empty string"))
         (unless (file-regular-p file-path)
           (error "Not an existing regular file: %s" file-path))
         (with-temp-buffer
           (insert-file-contents file-path)
           (let* ((coding buffer-file-coding-system)
                  (edited (llm-tools--edit-apply
                           (buffer-string) old-string new-string replace-all?)))
             (erase-buffer)
             (insert edited)
             (let ((coding-system-for-write coding))
               (write-region (point-min) (point-max) file-path nil 'silent))))
         (if replace-all?
             (format "The file %s has been updated. All occurrences were successfully replaced."
                     file-path)
           (format "The file %s has been updated successfully." file-path)))
     (error (format "Error: %s" (error-message-string err)))))
 
 (provide 'llm-tools-edit)