rename from gptel-tools an add gptel-agent's bash tool

3 files changed, 144 insertions, 78 deletions

diff --git a/gptel-tools.el b/gptel-tools.el
deleted file mode 100644
index 1e8453c..0000000
--- a/gptel-tools.el
+++ /dev/null
@@ -1,61 +0,0 @@
-;; read_file (hl-file-read)
-(gptel-make-tool
- :name "read_file"
- :function 'hl-file-read
- :description "\
-Read an entire file and return its contents in hashline format. Each
-line is represented as LINE_NUMBER HASH|CONTENT, where LINE_NUMBER is
-the 1-based line number, HASH is a 2-character content-derived bigram,
-and CONTENT is the verbatim line text. Example output:
-
-1aa|const char *TITLE = \"Mr\";
-2ab|void greet(char *name) {
-3cd|    return name;
-
-The LINE_NUMBER and HASH together form an anchor (e.g., 1aa, 2ab) that
-uniquely identifies a line by position and content. Copy anchors
-verbatim from the output when referencing lines in edit operations. Do
-not fabricate or modify hashes. Call this tool before editing any file
-to obtain current content and valid anchors. Re-call if anchors no
-longer match after external changes."
- :args (list '(:name "file"
-                     :type string
-                     :description "Path to the file to read, relative to the working directory."))
- :async nil
- :confirm nil
- :include t)
-
-;; TODO write_file (with-temp-buffer + insert)
-;; TODO edit_file (hashline + patch apply)
-
-;; TODO bash_readonly (shell-command-to-string, whitelisted commands)
-;; TODO bash (shell-command-to-string, needs heavy filtering)
-
-;; find_files (directory-files-recursively)
-(gptel-make-tool
- :name "find_files"
- :function (lambda (dir &optional pattern)
-             (let ((git-dir (concat (file-name-as-directory dir) ".git")))
-               (delq nil (mapcar (lambda (f)
-                                   (unless (string-prefix-p git-dir f) f))
-                                 (directory-files-recursively dir (or pattern ""))))))
- :description "\
-Recursively find all files in a given directory, excluding files within
-.git directories. Returns a list of absolute file paths. Optionally
-accepts a pattern to filter file names (e.g., `*.el' for Emacs Lisp
-files). Use this to discover files in a project directory before reading
-or editing them."
- :args (list '(:name "directory"
-                     :type string
-                     :description "Path to the directory to be read, relative to the working directory.")
-             '(:name "pattern"
-                     :type string
-                     :description "Optional file name pattern to filter results, e.g. `*.el' or `*.txt'."
-                     :optional t))
- :async nil
- :confirm nil
- :include t)
-
-;; TODO grep (just grep :D)
-;; TODO fetch_url (use gptel-agent's one as a base, but needs mime handling like PDFs and images)
-;; TODO web_search (use gptel-agent's eww/shr method as a base)
diff --git a/gptel-tools-hl.el b/llm-tools-hl.el
index fd08260..c682334 100644
--- a/gptel-tools-hl.el
+++ b/llm-tools-hl.el
@@ -1,4 +1,4 @@
-(defvar hl-bigrams
+(defvar llm-tools--hl-bigrams
   (list "aa" "ab" "ac" "ad" "ae" "af" "ag" "ah" "ai" "aj" "ak" "al" "am" "an"
         "ao" "ap" "aq" "ar" "as" "at" "au" "av" "aw" "ax" "ay" "az" "ba" "bb"
         "bc" "bd" "be" "bf" "bg" "bh" "bi" "bj" "bk" "bl" "bm" "bn" "bo" "bp"
@@ -54,10 +54,10 @@ vocabulary, unlike a hash's hex digits.
 Taken from https://github.com/can1357/oh-my-pi.
 Precisely: https://raw.githubusercontent.com/can1357/oh-my-pi/85003ca/packages/coding-agent/src/hashline/bigrams.json")
 
-(defun hl-hash (line)
-  (elt hl-bigrams (% (sxhash line) 647)))
+(defun llm-tools--hl-hash (line)
+  (elt llm-tools--hl-bigrams (% (sxhash line) 647)))
 
-(defun hl-file-lines (file &optional beg end)
+(defun llm-tools--hl-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
@@ -67,36 +67,41 @@ With optional BEG and END (inclusive, 1-based), return the lines between that ra
           (cl-subseq lines (1- beg) end)
         lines))))
 
-(defun hl-format-lines (lines &optional start include-content?)
+(defun llm-tools--hl-format-lines (lines &optional start include-content?)
   "Format LINES in hashline format.
 START is 1-based (default 1).
 If INCLUDE-CONTENT is non-nil, append `|LINE' after each hash."
   (string-join
    (cl-mapcar (lambda (line i)
                 (if include-content?
-                    (format "%d%2s|%s" i (hl-hash line) line)
-                  (format "%d%2s" i (hl-hash line))))
+                    (format "%d%2s|%s" i (llm-tools--hl-hash line) line)
+                  (format "%d%2s" i (llm-tools--hl-hash line))))
               lines
               (number-sequence (or start 1) (+ (or start 1) (1- (length lines)))))
    "\n"))
 
-(defun hl-file-read (file)
+(defun llm-tools--hl-file-read (file)
   "Return FILE contents in hashline format."
-  (hl-format-lines (hl-file-lines file) nil t))
+  (llm-tools--hl-format-lines (llm-tools--hl-file-lines file) nil t))
 
-(defun hl-file-read-range (file beg end)
+(defun llm-tools--hl-file-read-range (file beg end)
   "Return FILE contents in hashline format from lines BEG to END."
-  (hl-format-lines (hl-file-lines file beg end) beg t))
+  (llm-tools--hl-format-lines (llm-tools--hl-file-lines file beg end) beg t))
 
-;; FIXME might be redundant with =hl-file-line-hash= if I'm only
+;; FIXME might be redundant with =llm-tools--hl-file-line-hash= if I'm only
 ;; verifying the hash of the anchors and telling LLM to re-read the
 ;; file when they don't match
-(defun hl-file-read-hashes (file)
+(defun llm-tools--hl-file-read-hashes (file)
   "Return FILE contents in hashline format without content."
-  (hl-format-lines (hl-file-lines file)))
+  (llm-tools--hl-format-lines (llm-tools--hl-file-lines file)))
 
-(defun hl-file-line-hash (file n)
+(defun llm-tools--hl-file-line-hash (file n)
   "Return the hash of the Nth line in FILE."
-  (let ((lines (hl-file-lines file)))
-      (hl-hash (elt lines (1- n)))))
+  (let ((lines (llm-tools--hl-file-lines file)))
+      (llm-tools--hl-hash (elt lines (1- n)))))
 
+;; before applying patch, first read the file to see if there were any changes
+;; if the llm's replacement text's hashlines do not match current hashlines, reject the request
+;; maybe if it just shifted a little bit (since the anchor is line number and hash of the line's content), there can be some kind of autohealing?
+;; rather, the llm would not format it like the reads. it's just going to provide text according to what the anchors it gives say
+;; so I just need to verify if the anchors didn't change
diff --git a/llm-tools.el b/llm-tools.el
new file mode 100644
index 0000000..6476d15
--- /dev/null
+++ b/llm-tools.el
@@ -0,0 +1,122 @@
+;; read_file (hl-file-read)
+(gptel-make-tool
+ :name "read_file"
+ :function 'llm-tools--hl-file-read
+ :description "\
+Read an entire file and return its contents in hashline format. Each
+line is represented as LINE_NUMBER HASH|CONTENT, where LINE_NUMBER is
+the 1-based line number, HASH is a 2-character content-derived bigram,
+and CONTENT is the verbatim line text. Example output:
+
+1aa|const char *TITLE = \"Mr\";
+2ab|void greet(char *name) {
+3cd|    return name;
+
+The LINE_NUMBER and HASH together form an anchor (e.g., 1aa, 2ab) that
+uniquely identifies a line by position and content. Copy anchors
+verbatim from the output when referencing lines in edit operations. Do
+not fabricate or modify hashes. Call this tool before editing any file
+to obtain current content and valid anchors. Re-call if anchors no
+longer match after external changes."
+ :args '((:name "file"
+                :type string
+                :description "Path to the file to read, relative to the working directory."))
+ :async nil
+ :confirm nil
+ :include t)
+
+;; TODO write_file (with-temp-buffer + insert)
+;; TODO edit_file (hashline + patch apply)
+
+;; TODO bash_readonly (shell-command-to-string, whitelisted commands)
+;; TODO compile command (calls build system, doesn't need confirmation, whitelisted commands)
+
+;; bash (make-process, taken from gptel-agent)
+(defun llm-tools--execute-bash (callback command)
+  "Execute COMMAND asynchronously in bash and call CALLBACK with output.
+
+CALLBACK is called with the command output string when the process finishes.
+COMMAND is the bash command string to execute."
+  (let* ((output-buffer (generate-new-buffer " *llm-tools-bash*"))
+         (proc (make-process
+                :name "llm-tools-bash"
+                :buffer output-buffer
+                :command (list "bash" "-c" command)
+                :connection-type 'pipe
+                :sentinel
+                (lambda (process _event)
+                  (when (memq (process-status process) '(exit signal))
+                    (let* ((exit-code (process-exit-status process))
+                           (output (with-current-buffer (process-buffer process)
+                                     (buffer-string))))
+                      (kill-buffer (process-buffer process))
+                      (funcall callback
+                               (if (zerop exit-code)
+                                   output
+                                 (format "Command failed with exit code %d:\nSTDOUT+STDERR:\n%s"
+                                         exit-code output)))))))))
+    proc))
+
+(gptel-make-tool
+ :name "Bash"
+ :function #'llm-tools--execute-bash
+ :description "Execute Bash commands.
+
+This tool provides access to a Bash shell with GNU coreutils (or
+equivalents) available. Use this to inspect system state, run builds,
+tests or other development or system administration tasks.
+
+Do NOT use this for file operations, finding, reading or editing files.
+Use the provided file tools instead: `read_file`, `write_file`,
+`edit_file`, `find_file`, `grep`.
+
+- Quote file paths with spaces using double quotes.
+- Chain dependent commands with && (or ; if failures are OK)
+- Use absolute paths instead of cd when possible
+- For parallel commands, make multiple `Bash` calls in one message
+- Run tests, check your work or otherwise close the loop to verify changes you make.
+
+EXAMPLES:
+- Find recent errors: 'grep -i error /var/log/app.log | tail -20'
+- Check file type: 'file document.pdf'
+- Count lines: 'wc -l *.txt'
+
+The command will be executed in the current working directory.  Output is
+returned as a string.  Long outputs should be filtered/limited using pipes."
+ :args '(( :name "command"
+           :type string
+           :description "The Bash command to execute.  \
+Can include pipes and standard shell operators.
+Example: 'ls -la | head -20' or 'grep -i error app.log | tail -50'"))
+ :confirm t
+ :include t
+ :async t)
+
+;; find_files (directory-files-recursively)
+(gptel-make-tool
+ :name "find_files"
+ :function (lambda (dir &optional pattern)
+             (let ((git-dir (concat (file-name-as-directory dir) ".git")))
+               (delq nil (mapcar (lambda (f)
+                                   (unless (string-prefix-p git-dir f) f))
+                                 (directory-files-recursively dir (or pattern ""))))))
+ :description "\
+Recursively find all files in a given directory, excluding files within
+.git directories. Returns a list of absolute file paths. Optionally
+accepts a pattern to filter file names (e.g., `*.el' for Emacs Lisp
+files). Use this to discover files in a project directory before reading
+or editing them."
+ :args '((:name "directory"
+                :type string
+                :description "Path to the directory to be read, relative to the working directory.")
+         (:name "pattern"
+                :type string
+                :description "Optional file name pattern to filter results, e.g. `*.el' or `*.txt'."
+                :optional t))
+ :async nil
+ :confirm nil
+ :include t)
+
+;; TODO grep (just grep :D)
+;; TODO fetch_url (use gptel-agent's one as a base, but needs mime handling like PDFs and images)
+;; TODO web_search (use gptel-agent's eww/shr method as a base)