Change category strings to symbols

* llm-tool-collection.el (llm-tool-collection-get-category): Update
docstring and example code.  Use 'eq' instead of 'string=' when
comparing categories.
(read-file, list-directory, create-file, create-directory)
(view-buffer): Change :category values from strings to symbols.

Author: ultronozm

llm-tool-collection.el

@@ -116,13 +116,14 @@ called with the tool's spec as their argument."
 ;;;###autoload
 (defun llm-tool-collection-get-category (category)
   "Return a list of all tool definitions in the collection part of CATEGORY.
+CATEGORY should be a symbol like \\='filesystem or \\='buffers.
 
 Mapping over this list with `gptel-make-tool', `llm-make-tool', or
 similar will add all tools to the respective client:
 
  (mapcar (apply-partially #\\='apply #\\='gptel-make-tool)
-         (llm-tool-collection-get-category \"filesystem\"))"
-  (seq-filter (lambda (tool) (string= (plist-get tool :category) category))
+         (llm-tool-collection-get-category \\='filesystem))"
+  (seq-filter (lambda (tool) (eq (plist-get tool :category) category))
               (llm-tool-collection-get-all)))
 
 ;;;###autoload
@@ -147,7 +148,7 @@ similar will add all tools to the respective client:
 (llm-tool-collection-deftool read-file
   (:description
    "Read the contents of a file and return its content as a string."
-   :category "filesystem"
+   :category filesystem
    :confirm t
    :include t)
   ((path
@@ -159,7 +160,7 @@ similar will add all tools to the respective client:
 
 (llm-tool-collection-deftool list-directory
   (:description "List the contents of a specified directory."
-                :category "filesystem"
+                :category filesystem
                 :confirm t
                 :include t)
   ((path
@@ -168,14 +169,16 @@ similar will add all tools to the respective client:
   (let ((expanded-path (expand-file-name path)))
     (if (file-directory-p expanded-path)
         (string-join `(,(format "Contents of %s:" path)
-                       ,@(directory-files expanded-path))
+                       ,@(seq-filter (lambda (file)
+                                       (not (member file '("." ".."))))
+                                     (directory-files expanded-path)))
                      "\n")
       (error "%s is not a directory" expanded-path))))
 
 (llm-tool-collection-deftool create-file
   (:description
    "Create a new file with the specified content if it does not already exist."
-   :category "filesystem"
+   :category filesystem
    :confirm t)
   ((path
     :type string
@@ -191,7 +194,7 @@ similar will add all tools to the respective client:
 (llm-tool-collection-deftool create-directory
   (:description
    "Create a new directory at the specified path if it does not already exist."
-   :category "filesystem"
+   :category filesystem
    :confirm t)
   ((path
     :type string
@@ -206,7 +209,7 @@ similar will add all tools to the respective client:
   (:description "View contents of BUFFER-NAME with optional OFFSET and LIMIT.
 OFFSET specifies the starting line (0-based).
 LIMIT specifies the maximum number of lines to return."
-                :category "buffers")
+                :category buffers)
   ((buffer-name :type string :description "Name of the buffer to view.")
    &optional
    (offset
@@ -221,6 +224,279 @@ LIMIT specifies the maximum number of lines to return."
            (selected-lines (seq-subseq lines start end)))
       (string-join selected-lines "\n"))))
 
+(llm-tool-collection-deftool bash
+  (:description "Executes bash commands"
+                :category system
+                :confirm t)
+  ((command
+    :type string :description "Command to execute")
+   &optional
+   (timeout
+    :type number :description "Optional timeout in milliseconds (max 600000)"))
+  ;; TODO: use the timeout
+  (let ((result (shell-command-to-string command)))
+    (if (string-empty-p result)
+        "Command executed successfully (no output)"
+      result)))
+
+(llm-tool-collection-deftool glob
+  (:description "File pattern matching"
+                :category filesystem
+                :include t)
+  ((pattern
+    :type string
+    :description "Glob pattern to match files")
+   &optional
+   (path
+    :type string
+    :description "Directory to search in"))
+  (let* ((default-directory (or path default-directory))
+         (files (file-expand-wildcards pattern)))
+    (string-join files "\n")))
+
+(llm-tool-collection-deftool grep
+  (:description "Content search using regex"
+                :category search
+                :include t)
+  ((pattern
+    :type string
+    :description "Regex pattern to search in file contents")
+   &optional
+   (include
+    :type string
+    :description "File pattern to include in search")
+   (path
+    :type string
+    :description "Directory to search in"))
+  (let* ((default-directory (or path default-directory))
+         (include-arg (if include
+                          (format "--include=\"%s\"" include)
+                        ""))
+         (command (format "grep -r -n -E %s %s ."
+                          (shell-quote-argument pattern)
+                          include-arg))
+         (result (shell-command-to-string command)))
+    (if (string-empty-p result)
+        "No matches found"
+      result)))
+
+(llm-tool-collection-deftool ls
+  (:description "Lists files and directories"
+                :category filesystem
+                :include t)
+  ((path
+    :type string
+    :description "Absolute path to directory to list")
+   &optional
+   (ignore
+    :type array :items (:type string)
+    :description "Array of Elisp regexp patterns (e.g., \\.pdf$) to ignore"))
+  (let ((files (directory-files path t nil t)))
+    (when ignore
+      (let ((ignore-patterns (if (stringp ignore)
+                                 (list ignore)
+                               ignore)))
+        (seq-do (lambda (pattern)
+                  (setq files (seq-filter (lambda (f)
+                                            (not (string-match-p pattern f)))
+                                          files)))
+                ignore-patterns)))
+    (string-join (mapcar #'file-name-nondirectory files) "\n")))
+
+(llm-tool-collection-deftool view-file
+  (:description "Reads files"
+                :category filesystem
+                :include t)
+  ((file-path
+    :type string
+    :description "Absolute path to the file to read")
+   &optional
+   (offset
+    :type number
+    :description "Line number to start reading from")
+   (limit
+    :type number
+    :description "Number of lines to read"))
+  (with-temp-buffer
+    (insert-file-contents file-path)
+    (let* ((lines (split-string (buffer-string) "\n"))
+           (start (or offset 0))
+           (end (if limit (min (+ start limit) (length lines)) (length lines)))
+           (selected-lines (seq-subseq lines start end)))
+      (string-join selected-lines "\n"))))
+
+(llm-tool-collection-deftool edit-file
+  (:description "Edits files"
+                :category filesystem
+                :confirm t)
+  ((file-path
+    :type string
+    :description "Absolute path to the file to modify")
+   (old-string
+    :type string
+    :description "Text to replace (must match exactly)")
+   (new-string
+    :type string
+    :description "Text to replace old_string with"))
+  (with-temp-buffer
+    (insert-file-contents file-path)
+    (let ((case-fold-search nil))
+      (if (string= old-string "")
+          (progn
+            (erase-buffer)
+            (insert new-string)
+            (write-file file-path)
+            (format "Created new file: %s" file-path))
+        (goto-char (point-min))
+        (let ((count 0))
+          (while (search-forward old-string nil t)
+            (setq count (1+ count)))
+          (if (= count 0)
+              (format "Error: Could not find text to replace in %s" file-path)
+            (if (> count 1)
+                (format "Error: Found %d matches for the text to replace in %s" count file-path)
+              (goto-char (point-min))
+              (search-forward old-string)
+              (replace-match new-string t t)
+              (write-file file-path)
+              (format "Successfully edited %s" file-path))))))))
+
+(llm-tool-collection-deftool replace-file
+  (:description "Completely overwrites files"
+                :category filesystem
+                :confirm t)
+  ((file-path
+    :type string
+    :description "Absolute path to file to write")
+   (content
+    :type string
+    :description "Content to write to the file"))
+  (with-temp-buffer
+    (insert content)
+    (write-file file-path)
+    (format "File replaced: %s" file-path)))
+
+;; Buffer-related tools
+
+(llm-tool-collection-deftool buffer-search
+  (:description "Searches within Emacs buffers for text patterns"
+                :category buffers
+                :include t)
+  ((pattern
+    :type string
+    :description "Regex pattern to search for in buffer contents.\nRegex syntax is that of Emacs -- parentheses are NOT escaped!  Search for \"'(defun\", not \"\\\\(defun\".")
+   &optional
+   (buffer-name
+    :type string
+    :description "Buffer name to search in (searches all user buffers if not specified)"))
+  (condition-case err
+      (let ((results '()))
+        (dolist (buf (if buffer-name
+                         (if-let ((specified-buf (get-buffer buffer-name)))
+                             (list specified-buf)
+                           (error "Buffer '%s' does not exist" buffer-name))
+                       (seq-filter (lambda (buf)
+                                     (let ((buf-name (buffer-name buf)))
+                                       (and (not (string-prefix-p " " buf-name))
+                                            (not (string-prefix-p "*" buf-name)))))
+                                   (buffer-list))))
+          (with-current-buffer buf
+            (save-excursion
+              (goto-char (point-min))
+              (let ((line-num 1))
+                (while (re-search-forward pattern nil t)
+                  (let* ((line-beg (line-beginning-position))
+                         (line-end (line-end-position))
+                         (line-text (buffer-substring-no-properties line-beg line-end))
+                         (col-num (- (point) line-beg)))
+                    (push (format "%s:%d:%d: %s"
+                                  (buffer-name buf)
+                                  line-num
+                                  col-num
+                                  line-text)
+                          results))
+                  (forward-line 1)
+                  (setq line-num (1+ line-num)))))))
+        (if results
+            (string-join (nreverse results) "\n")
+          "No matches found"))
+    (invalid-regexp
+     (format "Invalid regexp pattern: %s" (error-message-string err)))
+    (error
+     (format "Error during search: %s" (error-message-string err)))))
+
+(llm-tool-collection-deftool list-buffers
+  (:description "Lists active buffers that a user might care about"
+                :category buffers
+                :include t)
+  ()
+  (let* ((all-buffers (buffer-list))
+         (user-buffers (seq-filter
+                        (lambda (buf)
+                          (let ((buf-name (buffer-name buf)))
+                            (and (not (string-prefix-p " " buf-name))
+                                 (not (string-prefix-p "*" buf-name))
+                                 (not (eq buf (current-buffer))))))
+                        all-buffers))
+         (sorted-buffers (sort user-buffers
+                               (lambda (a b)
+                                 (string< (buffer-name a)
+                                          (buffer-name b))))))
+    (mapconcat (lambda (buf)
+                 (let ((buf-name (buffer-name buf))
+                       (file-name (or (buffer-file-name buf) "")))
+                   (format "%s%s"
+                           buf-name
+                           (if (string-empty-p file-name)
+                               ""
+                             (format " (%s)" file-name)))))
+               sorted-buffers
+               "\n")))
+
+(llm-tool-collection-deftool edit-buffer
+  (:description "Edits Emacs buffers"
+                :category buffers
+                :confirm t)
+  ((buffer-name
+    :type string
+    :description "Name of the buffer to modify")
+   (old-string
+    :type string
+    :description "Text to replace (must match exactly)")
+   (new-string
+    :type string
+    :description "Text to replace old_string with"))
+  (with-current-buffer buffer-name
+    (let ((case-fold-search nil))
+      (save-excursion
+        (goto-char (point-min))
+        (let ((count 0))
+          (while (search-forward old-string nil t)
+            (setq count (1+ count)))
+          (if (= count 0)
+              (format "Error: Could not find text to replace in buffer %s" buffer-name)
+            (if (> count 1)
+                (format "Error: Found %d matches for the text to replace in buffer %s" count buffer-name)
+              (goto-char (point-min))
+              (search-forward old-string)
+              (replace-match new-string t t)
+              (format "Successfully edited buffer %s" buffer-name))))))))
+
+(llm-tool-collection-deftool replace-buffer
+  (:description "Completely overwrites buffer contents"
+                :category buffers
+                :confirm t)
+  ((buffer-name
+    :type string
+    :description "Name of the buffer to overwrite")
+   (content
+    :type string
+    :description "Content to write to the buffer"))
+  (with-current-buffer buffer-name
+    (erase-buffer)
+    (insert content)
+    (format "Buffer replaced: %s" buffer-name)))
+
 (provide 'llm-tool-collection)
 
 ;;; llm-tool-collection.el ends here