Pull message rendering into its own method

Removed the system parameter on ChatCopmletion functions, and persist it
in conversations as well.

pkg/cli/cli.go

@@ -12,3 +12,7 @@ func Fatal(format string, args ...any) {
 	fmt.Fprintf(os.Stderr, format, args...)
 	os.Exit(1)
 }
+
+func Warn(format string, args ...any) {
+	fmt.Fprintf(os.Stderr, format, args...)
+}

pkg/cli/cmd.go

@@ -71,29 +71,65 @@ var newCmd = &cobra.Command{
 		messageContents, err := InputFromEditor("# What would you like to say?\n", "message.*.md")
 		if err != nil {
 			Fatal("Failed to get input: %v\n", err)
-			return
 		}
 
 		if messageContents == "" {
 			Fatal("No message was provided.\n")
-			return
 		}
 
-		fmt.Printf("> %s\n", messageContents)
+		// TODO: set title if --title provided, otherwise defer for later(?)
+		conversation := Conversation{}
+		err = store.SaveConversation(&conversation)
+		if err != nil {
+			Fatal("Could not save new conversation: %v\n", err)
+		}
 
+		const system = "You are a helpful assistant."
 		messages := []Message{
 			{
+				ConversationID:  conversation.ID,
+				Role:            "system",
+				OriginalContent: system,
+			},
+			{
+				ConversationID:  conversation.ID,
 				Role:            "user",
 				OriginalContent: messageContents,
 			},
 		}
+		for _, message := range messages {
+			err = store.SaveMessage(&message)
+			if err != nil {
+				Warn("Could not save %s message: %v\n", message.Role, err)
+			}
+		}
+
+		for _, message := range messages {
+			message.RenderTTY(true)
+		}
+
+		reply := Message{
+			ConversationID: conversation.ID,
+			Role:           "assistant",
+		}
+
+		reply.RenderTTY(false)
 
 		receiver := make(chan string)
-		go HandleDelayedResponse(receiver)
+		response := make(chan string)
-		err = CreateChatCompletionStream("You are a helpful assistant.", messages, receiver)
+		go func() {
+			response <- HandleDelayedResponse(receiver)
+		}()
+		err = CreateChatCompletionStream(messages, receiver)
 		if err != nil {
 			Fatal("%v\n", err)
-			return
+		}
+
+		reply.OriginalContent = <-response
+
+		err = store.SaveMessage(&reply)
+		if err != nil {
+			Fatal("Could not save reply: %v\n", err)
 		}
 
 		fmt.Println()
@@ -108,10 +144,14 @@ var promptCmd = &cobra.Command{
 		message := strings.Join(args, " ")
 		if len(strings.Trim(message, " \t\n")) == 0 {
 			Fatal("No message was provided.\n")
-			return
 		}
 
+		const system = "You are a helpful assistant."
 		messages := []Message{
+			{
+				Role:            "system",
+				OriginalContent: system,
+			},
 			{
 				Role:            "user",
 				OriginalContent: message,
@@ -120,10 +160,9 @@ var promptCmd = &cobra.Command{
 
 		receiver := make(chan string)
 		go HandleDelayedResponse(receiver)
-		err := CreateChatCompletionStream("You are a helpful assistant.", messages, receiver)
+		err := CreateChatCompletionStream(messages, receiver)
 		if err != nil {
 			Fatal("%v\n", err)
-			return
 		}
 
 		fmt.Println()
@@ -131,6 +170,9 @@ var promptCmd = &cobra.Command{
 }
 
 func NewRootCmd() *cobra.Command {
-	rootCmd.AddCommand(newCmd, promptCmd)
+	rootCmd.AddCommand(
+		newCmd,
+		promptCmd,
+	)
 	return rootCmd
 }

pkg/cli/config.go

@@ -49,7 +49,7 @@ func InitializeConfig() *Config {
 
 		_, err = file.Write(bytes)
 		if err != nil {
-			Fatal("Could not save default configuratoin: %v", err)
+			Fatal("Could not save default configuration: %v", err)
 			return nil
 		}
 	} else if err != nil {

pkg/cli/openai.go

@@ -8,14 +8,8 @@ import (
 	openai "github.com/sashabaranov/go-openai"
 )
 
-func CreateChatCompletionRequest(system string, messages []Message) *openai.ChatCompletionRequest {
+func CreateChatCompletionRequest(messages []Message) *openai.ChatCompletionRequest {
-	chatCompletionMessages := []openai.ChatCompletionMessage{
+	chatCompletionMessages := []openai.ChatCompletionMessage{}
-		{
-			Role:    "system",
-			Content: system,
-		},
-	}
-
 	for _, m := range messages {
 		chatCompletionMessages = append(chatCompletionMessages, openai.ChatCompletionMessage{
 			Role:    m.Role,
@@ -33,11 +27,11 @@ func CreateChatCompletionRequest(system string, messages []Message) *openai.Chat
 
 // CreateChatCompletion accepts a slice of Message and returns the response
 // of the Large Language Model.
-func CreateChatCompletion(system string, messages []Message) (string, error) {
+func CreateChatCompletion(messages []Message) (string, error) {
 	client := openai.NewClient(config.OpenAI.APIKey)
 	resp, err := client.CreateChatCompletion(
 		context.Background(),
-		*CreateChatCompletionRequest(system, messages),
+		*CreateChatCompletionRequest(messages),
 	)
 
 	if err != nil {
@@ -49,11 +43,11 @@ func CreateChatCompletion(system string, messages []Message) (string, error) {
 
 // CreateChatCompletionStream submits an streaming Chat Completion API request
 // and sends the received data to the output channel.
-func CreateChatCompletionStream(system string, messages []Message, output chan string) error {
+func CreateChatCompletionStream(messages []Message, output chan string) error {
 	client := openai.NewClient(config.OpenAI.APIKey)
 	ctx := context.Background()
 
-	req := CreateChatCompletionRequest(system, messages)
+	req := CreateChatCompletionRequest(messages)
 	req.Stream = true
 
 	defer close(output)

pkg/cli/tty.go

@@ -2,6 +2,7 @@ package cli
 
 import (
 	"fmt"
+	"strings"
 	"time"
 )
 
@@ -33,12 +34,14 @@ func ShowWaitAnimation(signal chan any) {
 }
 
 // HandledDelayedResponse writes a waiting animation (abusing \r) and the
-// content received on the response channel to stdout. Blocks until the channel
+// (possibly chunked) content received on the response channel to stdout.
-// is closed.
+// Blocks until the channel is closed.
-func HandleDelayedResponse(response chan string) {
+func HandleDelayedResponse(response chan string) string {
 	waitSignal := make(chan any)
 	go ShowWaitAnimation(waitSignal)
 
+	sb := strings.Builder{}
+
 	firstChunk := true
 	for chunk := range response {
 		if firstChunk {
@@ -47,5 +50,27 @@ func HandleDelayedResponse(response chan string) {
 			firstChunk = false
 		}
 		fmt.Print(chunk)
+		sb.WriteString(chunk)
+	}
+
+	return sb.String()
+}
+
+func (m *Message) RenderTTY(paddingDown bool) {
+	var friendlyRole string
+	switch m.Role {
+		case "user":
+			friendlyRole = "You"
+		case "system":
+			friendlyRole = "System"
+		case "assistant":
+			friendlyRole = "Assistant"
+	}
+	fmt.Printf("<%s>\n\n", friendlyRole)
+	if m.OriginalContent != "" {
+		fmt.Print(m.OriginalContent)
+	}
+	if paddingDown {
+		fmt.Print("\n\n")
 	}
 }

pkg/cli/util.go

@@ -46,5 +46,5 @@ func InputFromEditor(placeholder string, pattern string) (string, error) {
 		}
 	}
 
-	return content, nil
+	return strings.Trim(content, "\n \t"), nil
 }