feat: Add cognitive tools to skills.org (reload-skill, read-file, write-file, replace-string)

New tools require manual addition to skills.lisp due to compilation issue.

harness/skills.org

@@ -360,3 +360,121 @@ EXAMPLES:
                 (uiop:run-program (list "bash" "-c" cmd) :output :string :error-output :string :ignore-error-status t)
               (format nil "EXIT-CODE: ~a~%~%STDOUT:~%~a~%~%STDERR:~%~a" code out err)))))
 #+end_src
+
+*** The Reload-Skill Tool (Hot Reload)
+#+begin_src lisp :tangle ../library/skills.lisp
+(def-cognitive-tool :reload-skill "Reloads a skill from its Org-mode source file, recompiling into the live image without restarting the daemon."
+  ((:skill :type :string :description "The skill name (e.g., \"org-skill-policy\") or full path to the .org file"))
+  :guard (lambda (args context)
+           (declare (ignore context))
+           (let ((skill (getf args :skill)))
+             (or (uiop:file-exists-p skill)
+                 (let ((skills-dir (or (ignore-errors (uiop:getenv "SKILLS_DIR"))
+                                       (namestring (merge-pathnames "notes/" (user-homedir-pathname))))))
+                   (uiop:file-exists-p (merge-pathnames (format nil "~a.org" skill) skills-dir))))))
+  :body (lambda (args)
+          (let ((skill (getf args :skill)))
+            (snapshot-memory)
+            (let ((skills-dir (or (ignore-errors (uiop:getenv "SKILLS_DIR"))
+                                  (namestring (merge-pathnames "notes/" (user-homedir-pathname)))))
+                 (resolved-path (context-resolve-path skills-dir))
+                 (skills-dir-actual (if (ignore-errors (uiop:getenv "SKILLS_DIR"))
+                                        (uiop:ensure-directory-pathname (context-resolve-path (uiop:getenv "SKILLS_DIR")))
+                                        (uiop:ensure-directory-pathname (user-homedir-pathname)))))
+              (let ((file (if (uiop:file-exists-p skill)
+                             (uiop:ensure-pathname skill)
+                             (merge-pathnames (format nil "~a.org" skill) skills-dir-actual))))
+                (cond
+                  ((not (uiop:file-exists-p file))
+                   (format nil "ERROR: Skill file not found: ~a" (uiop:native-namestring file)))
+                  (t
+                   (harness-log "SKILL: Hot-reloading ~a..." (pathname-name file))
+                   (let ((status (load-skill-with-timeout file 10)))
+                     (if (eq status :success)
+                         (let ((base-name (pathname-name file)))
+                           (setf (skill-entry-status (gethash base-name *skill-catalog*)) :ready)
+                           (format nil "OK: Skill '~a' reloaded successfully." base-name))
+                         (format nil "ERROR: Reload failed with status ~a" status)))))))))
+#+end_src
+
+*** The File Read Tool (V 0.2.0 File I/O)
+#+begin_src lisp :tangle ../library/skills.lisp
+(def-cognitive-tool :read-file "Reads the contents of a file as a string."
+  ((:file :type :string :description "The path to the file to read"))
+  :guard (lambda (args context)
+           (declare (ignore context))
+           (let* ((file (getf args :file))
+                  (memex-root (or (uiop:getenv "MEMEX_DIR") "/home/user/memex"))
+                  (truename (ignore-errors (namestring (truename file)))))
+             (or (null truename)
+                 (str:starts-with-p memex-root truename))))
+  :body (lambda (args)
+          (let ((file (getf args :file)))
+            (handler-case
+                (uiop:read-file-string file)
+              (error (c)
+                (format nil "ERROR reading ~a: ~a" file c)))))
+#+end_src
+
+*** The File Write Tool (V 0.2.0 File I/O)
+#+begin_src lisp :tangle ../library/skills.lisp
+(def-cognitive-tool :write-file "Writes content to a file, creating it if it doesn't exist."
+  ((:file :type :string :description "The path to the file to write")
+   (:content :type :string :description "The content to write")
+   (:append :type :string :description "\"t\" to append instead of overwriting (optional)"))
+  :guard (lambda (args context)
+           (declare (ignore context))
+           (let* ((file (getf args :file))
+                  (memex-root (or (uiop:getenv "MEMEX_DIR") "/home/user/memex"))
+                  (truename (ignore-errors (namestring (truename file)))))
+             (or (null truename)
+                 (str:starts-with-p memex-root truename))))
+  :body (lambda (args)
+          (let ((file (getf args :file))
+                (content (getf args :content))
+                (append-p (string-equal (getf args :append) "t")))
+            (handler-case
+                (progn
+                  (snapshot-memory)
+                  (with-open-file (out file
+                                      :direction :output
+                                      :if-exists (if append-p :append :supersede)
+                                      :if-does-not-exist :create)
+                    (write-string content out))
+                  (format nil "OK: ~a written to ~a" 
+                          (if append-p "content appended" "file written")
+                          file))
+              (error (c)
+                (format nil "ERROR writing ~a: ~a" file c)))))
+#+end_src
+
+*** The String Replace Tool (V 0.2.0 File I/O)
+#+begin_src lisp :tangle ../library/skills.lisp
+(def-cognitive-tool :replace-string "Replaces occurrences of old-string with new-string in a file."
+  ((:file :type :string :description "The path to the file")
+   (:old :type :string :description "The substring to find and replace")
+   (:new :type :string :description "The replacement string"))
+  :guard (lambda (args context)
+           (declare (ignore context))
+           (let* ((file (getf args :file))
+                  (memex-root (or (uiop:getenv "MEMEX_DIR") "/home/user/memex"))
+                  (truename (ignore-errors (namestring (truename file)))))
+             (or (null truename)
+                 (str:starts-with-p memex-root truename))))
+  :body (lambda (args)
+          (let ((file (getf args :file))
+                (old (getf args :old))
+                (new (getf args :new)))
+            (handler-case
+                (progn
+                  (snapshot-memory)
+                  (let ((content (uiop:read-file-string file)))
+                    (if (search old content)
+                        (let ((new-content (cl-ppcre:regex-replace-all (cl-ppcre:quote-meta-chars old) content new)))
+                          (with-open-file (out file :direction :output :if-exists :supersede)
+                            (write-string new-content out))
+                          (format nil "OK: Replaced first occurrence in ~a" file))
+                        (format nil "ERROR: Pattern not found in ~a" file))))
+              (error (c)
+                (format nil "ERROR replacing in ~a: ~a" file c)))))
+#+end_src