OpenAI APIを使う

;;; chatgpt.el --- OpenAI ChatGPT -*- lexical-binding: t; -*-

;; Copyright (C) 2023-2023  TakesxiSiximada

;; Author: TakesxiSximada <[email protected]>
;; Maintainer: TakesxiSximada <[email protected]>
;; Version: 0.1
;; Package-Requires: ((emacs "28.1") (plz))
;; Keywords: OpenAI, ChatGPT

;; This file is part of GNU Emacs.

;;; License:

;; 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/>.

;;; Code:

;;;; Requirements
(require 'plz)

;;;; Variables
(defvar chatgpt-current-request-body nil
  "OpenAI API request body")

(defvar chatgpt-current-response nil
  "OpenAI API response")

(defvar openapi-received-response-hook nil
  "Hook called when OpenAI API response is received")

(defcustom chatgpt-current-history-file "chat.log"
  "Chat history file path")

(defvar openapi-api-origin "https://api.openai.com"
  "OpenAI API Origin")

(defcustom openapi-api-key nil
  "OpenAI API Key")

;;;; Functions

;;;;; Public

(defun chatgpt-insert-question (question role name)
  "対話履歴の末尾に入力文字列を挿入する。"
  (with-temp-buffer
    (insert "\n")
    (insert
     (json-encode
      (if (string-equal role "function")
	  `((content . ,question)
	    (role . ,role)
	    (name . ,name))
	`((content . ,question)
	  (role . ,role)))))
    (append-to-file (point-min) (point-max)
		    chatgpt-current-history-file)))

(defun chatgpt-sync-chat-log ()
  "結果を対話履歴に反映する"
  (interactive)
  (with-temp-buffer
    (insert "\n")
    (insert
     (json-encode
      `((role . "assistant")
	(content . ,(completing-read
		     "[ChatGPT] "
		     (mapcar (lambda (elm)
			       (cdr (assoc 'content (cdr (assoc 'message elm)))))
			     (cdr (assoc 'choices
					 (json-read-from-string chatgpt-current-response)))))))))
    (append-to-file (point-min) (point-max) chatgpt-current-history-file)))

(defun chatgpt-create-current-request-body ()
  "リクエストを作成"
  (interactive)
  (setq chatgpt-current-request-body
	(progn
	  (shell-command (format "jq -s . %s" chatgpt-current-history-file))
	  (json-encode `(("model" . "gpt-3.5-turbo")
			 ("messages" . ,(with-current-buffer (get-buffer "*Shell Command Output*")
					  (goto-char 1)
					  (json-read-array))))))))

(defun chatgpt-send-request ()
  "APIを送信する"
  (interactive)
  (plz 'post (concat openapi-api-origin "/v1/chat/completions")
    :headers
    `(("Content-Type" . "application/json")
      ("Authorization" . ,(format "Bearer %s" openapi-api-key)))
    :body chatgpt-current-request-body
    :then (lambda (d)
	    (setq chatgpt-current-response d)
	    (princ "Got a openai api response.")
	    (run-hooks 'openapi-received-response-hook))
    :else (lambda (d) (princ d))))

(defun chatgpt-insert-result ()
  "現在位置に結果を挿入"
  (interactive)
  (insert (shell-command-to-string
	   (format "jq -s -r '.[-1].content' %s"
		   chatgpt-current-history-file))))


(defun chatgpt-display-result ()
  (interactive)
  (switch-to-buffer-other-window (get-buffer-create "*ChatGPT*"))
  (chatgpt-sync-chat-log)
  (chatgpt-insert-result))

(add-hook 'openapi-received-response-hook #'chatgpt-display-result)

(defun chatgpt (&optional question role name)
  (interactive
   (let* ((_question
	   (cond
	    ((bound-and-true-p rectangle-mark-mode)  ;; 矩形選択時は矩形領域を使用
	     (extract-rectangle (region-beginning) (region-end))
	     )
	    ((region-active-p)  ;; 領域選択時は領域を使用
	     (buffer-substring (region-beginning) (region-end))
	     )
	    (t  ;; 矩形選択でも領域選択でもない場合は、ミニバッファから入力する
	     (read-from-minibuffer "Question: ")
	     )))
	  (_role (completing-read "Role: " '("user" "function")))
	  (_name (when (string-equal _role "function")
		   (read-from-minibuffer "name: " "emacs"))))
     (list _question _role _name)))
  (chatgpt-insert-question question role name)
  (chatgpt-create-current-request-body)
  (chatgpt-send-request)
  )

(provide 'chatgpt)
;;; chatgpt.el ends here

(setq openai-api-key nil)
(setq openai-chat-result-buffer-name "*ChatGPT Result*")

(setq openai-chat-request-buffer-name "*ChatGPT Request*")
(setq openai-chat-response-buffer-name "*ChatGPT Response*")
(setq openai-chat-response-error-buffer-name "*ChatGPT Response Error*")

(setq openai-chat-send-request-process nil)

(setq openai-chat-chars-q nil)

(setq openai-chat-chars-timer nil)

(defun openai-chat-sync-results ()
  (while openai-chat-chars-q
    (with-current-buffer (get-buffer-create openai-chat-result-buffer-name)
      (goto-char (point-max))
      (let ((ch (car openai-chat-chars-q)))
	(if (string-equal "" ch)
	    (insert "\n")
	  (insert ch)))
      (end-of-buffer)
      (pop-to-buffer (current-buffer))
      (setq openai-chat-chars-q (cdr openai-chat-chars-q)))))

(defun openai-chat-chars-start-timer ()
  (interactive)
  (unless openai-chat-chars-timer
    (setq openai-chat-chars-timer (run-with-idle-timer 1 t #'openai-chat-sync-results))))

(defun openai-chat-chars-cancel-timer ()
  (interactive)
  (cancel-timer openai-chat-chars-timer)
  (setq openai-chat-chars-timer nil))

(require 'json)
 

(defun openai-chat-create-request (sentence)
  (interactive "sSentence: ")
  
  (with-current-buffer (get-buffer-create openai-chat-result-buffer-name)
    (goto-char (point-max))
    (insert "\n\n------------------------------------------------\n")
    (insert "ME: ")
    (insert sentence)
    (insert "\n------------------------------------------------\n")
    (insert "AI: ")
    )
    
  (with-current-buffer (get-buffer-create openai-chat-request-buffer-name)
    (erase-buffer)
    (insert 
     (format "{ 
    \"model\": \"gpt-3.5-turbo\",
    \"messages\": [
	{
            \"role\": \"system\",
            \"content\": \"You are a helpful assistant.\"
	},
	{
            \"role\": \"user\",
            \"content\": %s
	}
    ],
    \"stream\": true
}" (json-encode-string sentence)))))

(defun openai-chat-parse-response ()
  (interactive)
  (with-current-buffer openai-chat-response-buffer-name
    (save-excursion
      (goto-char (point-min))
      (while (re-search-forward "^data: \\(.*\\)

" nil t)
	(if-let ((txt (buffer-substring-no-properties
		       (match-beginning 1) (match-end 1))))
	    (progn
	      (delete-region (point-min) (match-end 1))
	      (if-let ((content
			(cdr (assoc 'content
				    (cdr (assoc 'delta
						(seq-first (cdr (assoc 'choices
								       (json-read-from-string txt))))))))))
		  (setq openai-chat-chars-q (append openai-chat-chars-q (list content))))))))))
	  

(defun openai-chat-send-request ()
  (interactive)
  (if-let ((req-body (with-current-buffer openai-chat-request-buffer-name (buffer-string))))
      (progn
	(setq openai-chat-send-request-process
	      (make-process
	       :name "*OpenAI Chat*"
	       :buffer openai-chat-response-buffer-name
	       :command `("curl" "https://api.openai.com/v1/chat/completions"		       
 	      		  "-X" "POST"							       
 	      		  "-H" "Content-Type: application/json"			       
 	      		  "-H" ,(format "Authorization: Bearer %s" openai-api-key)
 	      		  "-d" "@-")							       
 	       :connection-type 'pipe							       
 	       :coding 'utf-8
	       :filter (lambda (process output)
			 (with-current-buffer (process-buffer process)
			   (goto-char (point-max))
			   (insert output)
			   (openai-chat-parse-response)
			   (openai-chat-sync-results)))
	       :sentinel (lambda (process event)
			   (openai-chat-parse-response)
			   (openai-chat-sync-results))
 	       :stderr openai-chat-response-error-buffer-name))
	
	(process-send-string openai-chat-send-request-process req-body)
	(process-send-eof openai-chat-send-request-process))))
			     
;;;

(defun openai-chat-question (question)
  (interactive (list (read-string-from-buffer "sQuestion" "")))
  (openai-chat-create-request question)
  (openai-chat-send-request)) 
  


(provide 'openai)