dotfiles/emacs/.emacs.d/config/init-ai.el

;; -*- lexical-binding: t; -*-

(defvar ai-map (make-sparse-keymap))
(define-key leader-map "a" (cons "ai" ai-map))

(use-package gptel
  :commands (gptel-request)
  :config
  (defvar gptel-backend-openai (gptel-make-openai "ChatGPT"
                                 :key #'gptel-api-key-from-auth-source
                                 :stream t
                                 :models '("gpt-4o"
                                           "gpt-4o-mini")))
  (defvar gptel-backend-ollama (gptel-make-ollama "Ollama"
                                 :stream t
                                 :models '("llama3:latest"
                                           "mistral:latest")))
  (setq gptel-backend gptel-backend-openai
        gptel-model "gpt-4o")
  (defun gptel-select-backend ()
    (interactive)
    (let ((backend
           (cl-loop
            for (name . backend) in gptel--known-backends
            nconc (cl-loop for model in (gptel-backend-models backend)
                           collect (list (concat name ":" model) backend model))
            into models-alist finally return
            (cdr (assoc (completing-read "Backend: " models-alist nil t)
                        models-alist)))))
      (setq gptel-backend (car backend)
            gptel-model (cadr backend))))
  :general
  ("C-c RET" #'gptel-send
   "C-c C-<return>" #'gptel-menu)
  (ai-map
   "g" #'gptel
   "s" #'gptel-send
   "m" #'gptel-menu
   "b" #'gptel-select-backend
   "a" #'gptel-context-add
   "f" #'gptel-context-add-file))

(use-package gptel-quick
  :straight (:type git :host github :repo "karthink/gptel-quick")
  :commands gptel-quick
  :general
  (embark-general-map
   "?" #'gptel-quick))

(defun gptel-commit-message ()
  "Generate a commit message via gptel."
  (interactive)
  (unless git-commit-mode
    (user-error "Not in a git commit buffer!"))
  (let* ((diff-buf (magit-get-mode-buffer 'magit-diff-mode))
         (diff (with-current-buffer diff-buf
                 (buffer-substring-no-properties
                  (point-min)
                  ;; Skip the last line, which is just the [back] button
                  (save-excursion
                    (goto-char (point-max))
                    (forward-line -1)
                    (point)))))
         (prompt (format "%s\n\nWrite a clear, concise commit message for this diff. The first line should succinctly summarize the changes made and should be no more than 50 characters. If additional context is needed, include it in an additional paragraph separate by a blank line from the first line. Reply with the commit message only." diff)))
    (message "Generating commit message...")
    (gptel-request prompt
      :stream t
      :system "You are a professional software engineer.")))

(use-package llama
  :straight `(:local-repo ,(expand-file-name "packages/llama" user-emacs-directory) :type nil)
  :load-path "packages/llama"
  :config
  (require 'llm-ollama)
  (setq llama-llm-provider (make-llm-ollama :chat-model "llama3:latest")
        llm-warn-on-nonfree nil))

(defvar comfy-ui-path (expand-file-name "~/ComfyUI")
  "Path to ComfyUI source repository.")

(defvar comfy-ui-command (list "pipenv" "run" "python" "main.py")
  "Command to run ComfyUI server.")

(defvar-local comfy-ui--url nil
  "URL for this buffer's ComfyUI process.")

(defun comfy-ui-process-filter (proc string)
  (when-let ((match (s-match "To see the GUI go to: \\(.*\\)" string)))
    (with-current-buffer (process-buffer proc)
      (setq comfy-ui--url (nth 1 match))
      (browse-url comfy-ui--url)))
  (when (buffer-live-p (process-buffer proc))
    (with-current-buffer (process-buffer proc)
      (let ((moving (= (point) (process-mark proc))))
        (save-excursion
          ;; Insert the text, advancing the process marker.
          (goto-char (process-mark proc))
          (insert string)
          (set-marker (process-mark proc) (point)))
        (if moving (goto-char (process-mark proc)))))))

(defun comfy-ui ()
  "Launch Comfy UI in a subprocess and opens the web UI."
  (interactive)
  (unless (file-exists-p (expand-file-name (f-join comfy-ui-path "main.py")))
    (user-error "Could not find ComfyUI installation!"))
  (if-let ((proc (get-process "comfy-ui")))
      (with-current-buffer (process-buffer proc)
        (browse-url comfy-ui--url))
    (with-temp-buffer
      (cd comfy-ui-path)
      (make-process :name "comfy-ui"
                    :buffer "*ComfyUI*"
                    :command comfy-ui-command
                    :filter #'comfy-ui-process-filter))))

(defvar ollama-copilot-proxy-port 11435
  "Port for the Ollama Copilot proxy server.")

(defvar ollama-copilot-model "codellama:code"
  "Model for the Ollama Copilot proxy server.")

(defun ollama-copilot-ensure ()
  "Start the Ollama Copilot proxy server if it's not already running."
  (let ((proc-name "ollama-copilot"))
    (unless (get-process proc-name)
      (unless (executable-find "ollama-copilot")
        (user-error "Could not find ollama-copilot executable!"))
      (make-process :name proc-name
                    :buffer (format "*%s*" proc-name)
                    :command `("ollama-copilot"
                               "-proxy-port" ,(format ":%s" ollama-copilot-proxy-port)
                               "-model" ,ollama-copilot-model)))))

(defvar ollama-copilot--proxy-cache nil
  "Internal variable to cache the old proxy value.")

(define-minor-mode ollama-copilot-mode
  "Minor mode to use ollama-copilot as a local Copilot proxy."
  :global t
  (require 'copilot)
  (if ollama-copilot-mode
      (progn
        (ollama-copilot-ensure)
        (setq ollama-copilot--proxy-cache copilot-network-proxy)
        (setq copilot-network-proxy `(:host "127.0.0.1"
                                      :port ,ollama-copilot-proxy-port
                                      :rejectUnauthorized :json-false))
        (copilot-diagnose))
    (setq copilot-network-proxy ollama-copilot--proxy-cache)
    (copilot-diagnose)))

(provide 'init-ai)