Project refactor, add anthropic API support

- Split pkg/cli/cmd.go into new pkg/cmd package - Split pkg/cli/functions.go into pkg/lmcli/tools package - Refactor pkg/cli/openai.go to pkg/lmcli/provider/openai Other changes: - Made models configurable - Slight config reorganization
2024-02-22 04:55:38 +00:00
parent 2611663168
commit 0a27b9a8d3
41 changed files with 3029 additions and 1899 deletions
--- a/pkg/cmd/clone.go
+++ b/pkg/cmd/clone.go
@@ -0,0 +1,72 @@
+package cmd
+
+import (
+	"fmt"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"github.com/spf13/cobra"
+)
+
+func CloneCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "clone <conversation>",
+		Short: "Clone conversations",
+		Long:  `Clones the provided conversation.`,
+		Args: func(cmd *cobra.Command, args []string) error {
+			argCount := 1
+			if err := cobra.MinimumNArgs(argCount)(cmd, args); err != nil {
+				return err
+			}
+			return nil
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			shortName := args[0]
+			toClone, err := cmdutil.LookupConversationE(ctx, shortName)
+			if err != nil {
+				return err
+			}
+
+			messagesToCopy, err := ctx.Store.Messages(toClone)
+			if err != nil {
+				return fmt.Errorf("Could not retrieve messages for conversation: %s", toClone.ShortName.String)
+			}
+
+			clone := &model.Conversation{
+				Title: toClone.Title + " - Clone",
+			}
+			if err := ctx.Store.SaveConversation(clone); err != nil {
+				return fmt.Errorf("Cloud not create clone: %s", err)
+			}
+
+			var errors []error
+			messageCnt := 0
+			for _, message := range messagesToCopy {
+				newMessage := message
+				newMessage.ConversationID = clone.ID
+				newMessage.ID = 0
+				if err := ctx.Store.SaveMessage(&newMessage); err != nil {
+					errors = append(errors, err)
+				} else {
+					messageCnt++
+				}
+			}
+
+			if len(errors) > 0 {
+				return fmt.Errorf("Messages failed to be cloned: %v", errors)
+			}
+
+			fmt.Printf("Cloned %d messages to: %s\n", messageCnt, clone.Title)
+			return nil
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			compMode := cobra.ShellCompDirectiveNoFileComp
+			if len(args) != 0 {
+				return nil, compMode
+			}
+			return ctx.Store.ConversationShortNameCompletions(toComplete), compMode
+		},
+	}
+	return cmd
+}
--- a/pkg/cmd/cmd.go
+++ b/pkg/cmd/cmd.go
@@ -0,0 +1,93 @@
+package cmd
+
+import (
+	"strings"
+
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/util"
+	"github.com/spf13/cobra"
+)
+
+var (
+	systemPromptFile string
+)
+
+func RootCmd(ctx *lmcli.Context) *cobra.Command {
+	var root = &cobra.Command{
+		Use:           "lmcli <command> [flags]",
+		Long:          `lmcli - Large Language Model CLI`,
+		SilenceErrors: true,
+		SilenceUsage:  true,
+		Run: func(cmd *cobra.Command, args []string) {
+			cmd.Usage()
+		},
+	}
+
+	continueCmd := ContinueCmd(ctx)
+	cloneCmd := CloneCmd(ctx)
+	editCmd := EditCmd(ctx)
+	listCmd := ListCmd(ctx)
+	newCmd := NewCmd(ctx)
+	promptCmd := PromptCmd(ctx)
+	renameCmd := RenameCmd(ctx)
+	replyCmd := ReplyCmd(ctx)
+	retryCmd := RetryCmd(ctx)
+	rmCmd := RemoveCmd(ctx)
+	viewCmd := ViewCmd(ctx)
+
+	inputCmds := []*cobra.Command{newCmd, promptCmd, replyCmd, retryCmd, continueCmd, editCmd}
+	for _, cmd := range inputCmds {
+		cmd.Flags().StringVar(ctx.Config.Defaults.Model, "model", *ctx.Config.Defaults.Model, "Which model to use")
+		cmd.Flags().IntVar(ctx.Config.Defaults.MaxTokens, "length", *ctx.Config.Defaults.MaxTokens, "Maximum response tokens")
+		cmd.Flags().StringVar(ctx.Config.Defaults.SystemPrompt, "system-prompt", *ctx.Config.Defaults.SystemPrompt, "System prompt")
+		cmd.Flags().StringVar(&systemPromptFile, "system-prompt-file", "", "A path to a file containing the system prompt")
+		cmd.MarkFlagsMutuallyExclusive("system-prompt", "system-prompt-file")
+	}
+
+	renameCmd.Flags().Bool("generate", false, "Generate a conversation title")
+
+	root.AddCommand(
+		cloneCmd,
+		continueCmd,
+		editCmd,
+		listCmd,
+		newCmd,
+		promptCmd,
+		renameCmd,
+		replyCmd,
+		retryCmd,
+		rmCmd,
+		viewCmd,
+	)
+
+	return root
+}
+
+func getSystemPrompt(ctx *lmcli.Context) string {
+	if systemPromptFile != "" {
+		content, err := util.ReadFileContents(systemPromptFile)
+		if err != nil {
+			lmcli.Fatal("Could not read file contents at %s: %v\n", systemPromptFile, err)
+		}
+		return content
+	}
+	return *ctx.Config.Defaults.SystemPrompt
+}
+
+// inputFromArgsOrEditor returns either the provided input from the args slice
+// (joined with spaces), or if len(args) is 0, opens an editor and returns
+// whatever input was provided there. placeholder is a string which populates
+// the editor and gets stripped from the final output.
+func inputFromArgsOrEditor(args []string, placeholder string, existingMessage string) (message string) {
+	var err error
+	if len(args) == 0 {
+		message, err = util.InputFromEditor(placeholder, "message.*.md", existingMessage)
+		if err != nil {
+			lmcli.Fatal("Failed to get input: %v\n", err)
+		}
+	} else {
+		message = strings.Join(args, " ")
+	}
+	message = strings.Trim(message, " \t\n")
+	return
+}
--- a/pkg/cmd/continue.go
+++ b/pkg/cmd/continue.go
@@ -0,0 +1,72 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"github.com/spf13/cobra"
+)
+
+func ContinueCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "continue <conversation>",
+		Short: "Continue a conversation from the last message",
+		Long:  `Re-prompt the conversation with all existing prompts. Useful if a reply was cut short.`,
+		Args: func(cmd *cobra.Command, args []string) error {
+			argCount := 1
+			if err := cobra.MinimumNArgs(argCount)(cmd, args); err != nil {
+				return err
+			}
+			return nil
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			shortName := args[0]
+			conversation := cmdutil.LookupConversation(ctx, shortName)
+
+			messages, err := ctx.Store.Messages(conversation)
+			if err != nil {
+				return fmt.Errorf("could not retrieve conversation messages: %v", err)
+			}
+
+			if len(messages) < 2 {
+				return fmt.Errorf("conversation expected to have at least 2 messages")
+			}
+
+			lastMessage := &messages[len(messages)-1]
+			if lastMessage.Role != model.MessageRoleAssistant {
+				return fmt.Errorf("the last message in the conversation is not an assistant message")
+			}
+
+			// Output the contents of the last message so far
+			fmt.Print(lastMessage.Content)
+
+			// Submit the LLM request, allowing it to continue the last message
+			continuedOutput, err := cmdutil.FetchAndShowCompletion(ctx, messages)
+			if err != nil {
+				return fmt.Errorf("error fetching LLM response: %v", err)
+			}
+
+			// Append the new response to the original message
+			lastMessage.Content += strings.TrimRight(continuedOutput[0].Content, "\n\t ")
+
+			// Update the original message
+			err = ctx.Store.UpdateMessage(lastMessage)
+			if err != nil {
+				return fmt.Errorf("could not update the last message: %v", err)
+			}
+
+			return nil
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			compMode := cobra.ShellCompDirectiveNoFileComp
+			if len(args) != 0 {
+				return nil, compMode
+			}
+			return ctx.Store.ConversationShortNameCompletions(toComplete), compMode
+		},
+	}
+	return cmd
+}
--- a/pkg/cmd/edit.go
+++ b/pkg/cmd/edit.go
@@ -0,0 +1,100 @@
+package cmd
+
+import (
+	"fmt"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"github.com/spf13/cobra"
+)
+
+func EditCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "edit <conversation>",
+		Short: "Edit the last user reply in a conversation",
+		Args: func(cmd *cobra.Command, args []string) error {
+			argCount := 1
+			if err := cobra.MinimumNArgs(argCount)(cmd, args); err != nil {
+				return err
+			}
+			return nil
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			shortName := args[0]
+			conversation := cmdutil.LookupConversation(ctx, shortName)
+
+			messages, err := ctx.Store.Messages(conversation)
+			if err != nil {
+				return fmt.Errorf("Could not retrieve messages for conversation: %s", conversation.Title)
+			}
+
+			offset, _ := cmd.Flags().GetInt("offset")
+			if offset < 0 {
+				offset = -offset
+			}
+
+			if offset > len(messages)-1 {
+				return fmt.Errorf("Offset %d is before the start of the conversation.", offset)
+			}
+
+			desiredIdx := len(messages) - 1 - offset
+
+			// walk backwards through the conversation deleting messages until and
+			// including the last user message
+			toRemove := []model.Message{}
+			var toEdit *model.Message
+			for i := len(messages) - 1; i >= 0; i-- {
+				if i == desiredIdx {
+					toEdit = &messages[i]
+				}
+				toRemove = append(toRemove, messages[i])
+				messages = messages[:i]
+				if toEdit != nil {
+					break
+				}
+			}
+
+			newContents := inputFromArgsOrEditor(args[1:], "# Save when finished editing\n", toEdit.Content)
+			switch newContents {
+			case toEdit.Content:
+				return fmt.Errorf("No edits were made.")
+			case "":
+				return fmt.Errorf("No message was provided.")
+			}
+
+			role, _ := cmd.Flags().GetString("role")
+			if role == "" {
+				role = string(toEdit.Role)
+			} else if role != string(model.MessageRoleUser) && role != string(model.MessageRoleAssistant) {
+				return fmt.Errorf("Invalid role specified. Please use 'user' or 'assistant'.")
+			}
+
+			for _, message := range toRemove {
+				err = ctx.Store.DeleteMessage(&message)
+				if err != nil {
+					lmcli.Warn("Could not delete message: %v\n", err)
+				}
+			}
+
+			cmdutil.HandleConversationReply(ctx, conversation, true, model.Message{
+				ConversationID:  conversation.ID,
+				Role:            model.MessageRole(role),
+				Content: newContents,
+			})
+			return nil
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			compMode := cobra.ShellCompDirectiveNoFileComp
+			if len(args) != 0 {
+				return nil, compMode
+			}
+			return ctx.Store.ConversationShortNameCompletions(toComplete), compMode
+		},
+	}
+
+	cmd.Flags().Int("offset", 1, "Offset from the last message to edit")
+	cmd.Flags().StringP("role", "r", "", "Role of the edited message (user or assistant)")
+
+	return cmd
+}
--- a/pkg/cmd/list.go
+++ b/pkg/cmd/list.go
@@ -0,0 +1,122 @@
+package cmd
+
+import (
+	"fmt"
+	"slices"
+	"time"
+
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/util"
+	"github.com/spf13/cobra"
+)
+
+const (
+	LS_COUNT int = 5
+)
+
+func ListCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:     "list",
+		Aliases: []string{"ls"},
+		Short:   "List conversations",
+		Long:    `List conversations in order of recent activity`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			conversations, err := ctx.Store.Conversations()
+			if err != nil {
+				return fmt.Errorf("Could not fetch conversations: %v", err)
+			}
+
+			type Category struct {
+				name   string
+				cutoff time.Duration
+			}
+
+			type ConversationLine struct {
+				timeSinceReply time.Duration
+				formatted      string
+			}
+
+			now := time.Now()
+
+			midnight := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+			monthStart := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
+			dayOfWeek := int(now.Weekday())
+			categories := []Category{
+				{"today", now.Sub(midnight)},
+				{"yesterday", now.Sub(midnight.AddDate(0, 0, -1))},
+				{"this week", now.Sub(midnight.AddDate(0, 0, -dayOfWeek))},
+				{"last week", now.Sub(midnight.AddDate(0, 0, -(dayOfWeek + 7)))},
+				{"this month", now.Sub(monthStart)},
+				{"last month", now.Sub(monthStart.AddDate(0, -1, 0))},
+				{"2 months ago", now.Sub(monthStart.AddDate(0, -2, 0))},
+				{"3 months ago", now.Sub(monthStart.AddDate(0, -3, 0))},
+				{"4 months ago", now.Sub(monthStart.AddDate(0, -4, 0))},
+				{"5 months ago", now.Sub(monthStart.AddDate(0, -5, 0))},
+				{"older", now.Sub(time.Time{})},
+			}
+			categorized := map[string][]ConversationLine{}
+
+			all, _ := cmd.Flags().GetBool("all")
+
+			for _, conversation := range conversations {
+				lastMessage, err := ctx.Store.LastMessage(&conversation)
+				if lastMessage == nil || err != nil {
+					continue
+				}
+
+				messageAge := now.Sub(lastMessage.CreatedAt)
+
+				var category string
+				for _, c := range categories {
+					if messageAge < c.cutoff {
+						category = c.name
+						break
+					}
+				}
+
+				formatted := fmt.Sprintf(
+					"%s - %s - %s",
+					conversation.ShortName.String,
+					util.HumanTimeElapsedSince(messageAge),
+					conversation.Title,
+				)
+
+				categorized[category] = append(
+					categorized[category],
+					ConversationLine{messageAge, formatted},
+				)
+			}
+
+			count, _ := cmd.Flags().GetInt("count")
+			var conversationsPrinted int
+		outer:
+			for _, category := range categories {
+				conversationLines, ok := categorized[category.name]
+				if !ok {
+					continue
+				}
+
+				slices.SortFunc(conversationLines, func(a, b ConversationLine) int {
+					return int(a.timeSinceReply - b.timeSinceReply)
+				})
+
+				fmt.Printf("%s:\n", category.name)
+				for _, conv := range conversationLines {
+					if conversationsPrinted >= count && !all {
+						fmt.Printf("%d remaining message(s), use --all to view.\n", len(conversations)-conversationsPrinted)
+						break outer
+					}
+
+					fmt.Printf("  %s\n", conv.formatted)
+					conversationsPrinted++
+				}
+			}
+			return nil
+		},
+	}
+
+	cmd.Flags().Bool("all", false, "Show all conversations")
+	cmd.Flags().Int("count", LS_COUNT, "How many conversations to show")
+
+	return cmd
+}
--- a/pkg/cmd/new.go
+++ b/pkg/cmd/new.go
@@ -0,0 +1,60 @@
+package cmd
+
+import (
+	"fmt"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"github.com/spf13/cobra"
+)
+
+func NewCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "new [message]",
+		Short: "Start a new conversation",
+		Long:  `Start a new conversation with the Large Language Model.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			messageContents := inputFromArgsOrEditor(args, "# What would you like to say?\n", "")
+			if messageContents == "" {
+				return fmt.Errorf("No message was provided.")
+			}
+
+			conversation := &model.Conversation{}
+			err := ctx.Store.SaveConversation(conversation)
+			if err != nil {
+				return fmt.Errorf("Could not save new conversation: %v", err)
+			}
+
+			messages := []model.Message{
+				{
+					ConversationID:  conversation.ID,
+					Role:            model.MessageRoleSystem,
+					Content: getSystemPrompt(ctx),
+				},
+				{
+					ConversationID:  conversation.ID,
+					Role:            model.MessageRoleUser,
+					Content: messageContents,
+				},
+			}
+
+			cmdutil.HandleConversationReply(ctx, conversation, true, messages...)
+
+			title, err := cmdutil.GenerateTitle(ctx, conversation)
+			if err != nil {
+				lmcli.Warn("Could not generate title for conversation: %v\n", err)
+			}
+
+			conversation.Title = title
+
+			err = ctx.Store.SaveConversation(conversation)
+			if err != nil {
+				lmcli.Warn("Could not save conversation after generating title: %v\n", err)
+			}
+			return nil
+		},
+	}
+
+	return cmd
+}
--- a/pkg/cmd/prompt.go
+++ b/pkg/cmd/prompt.go
@@ -0,0 +1,42 @@
+package cmd
+
+import (
+	"fmt"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"github.com/spf13/cobra"
+)
+
+func PromptCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "prompt [message]",
+		Short: "Do a one-shot prompt",
+		Long:  `Prompt the Large Language Model and get a response.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			message := inputFromArgsOrEditor(args, "# What would you like to say?\n", "")
+			if message == "" {
+				return fmt.Errorf("No message was provided.")
+			}
+
+			messages := []model.Message{
+				{
+					Role:            model.MessageRoleSystem,
+					Content: getSystemPrompt(ctx),
+				},
+				{
+					Role:            model.MessageRoleUser,
+					Content: message,
+				},
+			}
+
+			_, err := cmdutil.FetchAndShowCompletion(ctx, messages)
+			if err != nil {
+				return fmt.Errorf("Error fetching LLM response: %v", err)
+			}
+			return nil
+		},
+	}
+	return cmd
+}
--- a/pkg/cmd/remove.go
+++ b/pkg/cmd/remove.go
@@ -0,0 +1,60 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"github.com/spf13/cobra"
+)
+
+func RemoveCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "rm <conversation>...",
+		Short: "Remove conversations",
+		Long:  `Remove conversations by their short names.`,
+		Args: func(cmd *cobra.Command, args []string) error {
+			argCount := 1
+			if err := cobra.MinimumNArgs(argCount)(cmd, args); err != nil {
+				return err
+			}
+			return nil
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			var toRemove []*model.Conversation
+			for _, shortName := range args {
+				conversation := cmdutil.LookupConversation(ctx, shortName)
+				toRemove = append(toRemove, conversation)
+			}
+			var errors []error
+			for _, c := range toRemove {
+				err := ctx.Store.DeleteConversation(c)
+				if err != nil {
+					errors = append(errors, fmt.Errorf("Could not remove conversation %s: %v", c.ShortName.String, err))
+				}
+			}
+			if len(errors) > 0 {
+				return fmt.Errorf("Could not remove some conversations: %v", errors)
+			}
+			return nil
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			compMode := cobra.ShellCompDirectiveNoFileComp
+			var completions []string
+		outer:
+			for _, completion := range ctx.Store.ConversationShortNameCompletions(toComplete) {
+				parts := strings.Split(completion, "\t")
+				for _, arg := range args {
+					if parts[0] == arg {
+						continue outer
+					}
+				}
+				completions = append(completions, completion)
+			}
+			return completions, compMode
+		},
+	}
+	return cmd
+}
--- a/pkg/cmd/rename.go
+++ b/pkg/cmd/rename.go
@@ -0,0 +1,60 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"github.com/spf13/cobra"
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+)
+
+func RenameCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "rename <conversation> [title]",
+		Short: "Rename a conversation",
+		Long:  `Renames a conversation, either with the provided title or by generating a new name.`,
+		Args: func(cmd *cobra.Command, args []string) error {
+			argCount := 1
+			if err := cobra.MinimumNArgs(argCount)(cmd, args); err != nil {
+				return err
+			}
+			return nil
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			shortName := args[0]
+			conversation := cmdutil.LookupConversation(ctx, shortName)
+			var err error
+
+			generate, _ := cmd.Flags().GetBool("generate")
+			var title string
+			if generate {
+				title, err = cmdutil.GenerateTitle(ctx, conversation)
+				if err != nil {
+					return fmt.Errorf("Could not generate conversation title: %v", err)
+				}
+			} else {
+				if len(args) < 2 {
+					return fmt.Errorf("Conversation title not provided.")
+				}
+				title = strings.Join(args[1:], " ")
+			}
+
+			conversation.Title = title
+			err = ctx.Store.SaveConversation(conversation)
+			if err != nil {
+				lmcli.Warn("Could not save conversation with new title: %v\n", err)
+			}
+			return nil
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			compMode := cobra.ShellCompDirectiveNoFileComp
+			if len(args) != 0 {
+				return nil, compMode
+			}
+			return ctx.Store.ConversationShortNameCompletions(toComplete), compMode
+		},
+	}
+
+	return cmd
+}
--- a/pkg/cmd/reply.go
+++ b/pkg/cmd/reply.go
@@ -0,0 +1,49 @@
+package cmd
+
+import (
+	"fmt"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"github.com/spf13/cobra"
+)
+
+func ReplyCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "reply <conversation> [message]",
+		Short: "Reply to a conversation",
+		Long:  `Sends a reply to conversation and writes the response to stdout.`,
+		Args: func(cmd *cobra.Command, args []string) error {
+			argCount := 1
+			if err := cobra.MinimumNArgs(argCount)(cmd, args); err != nil {
+				return err
+			}
+			return nil
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			shortName := args[0]
+			conversation := cmdutil.LookupConversation(ctx, shortName)
+
+			reply := inputFromArgsOrEditor(args[1:], "# How would you like to reply?\n", "")
+			if reply == "" {
+				return fmt.Errorf("No reply was provided.")
+			}
+
+			cmdutil.HandleConversationReply(ctx, conversation, true, model.Message{
+				ConversationID:  conversation.ID,
+				Role:            model.MessageRoleUser,
+				Content: reply,
+			})
+			return nil
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			compMode := cobra.ShellCompDirectiveNoFileComp
+			if len(args) != 0 {
+				return nil, compMode
+			}
+			return ctx.Store.ConversationShortNameCompletions(toComplete), compMode
+		},
+	}
+	return cmd
+}
--- a/pkg/cmd/retry.go
+++ b/pkg/cmd/retry.go
@@ -0,0 +1,58 @@
+package cmd
+
+import (
+	"fmt"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"github.com/spf13/cobra"
+)
+
+func RetryCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "retry <conversation>",
+		Short: "Retry the last user reply in a conversation",
+		Long:  `Re-prompt the conversation up to the last user response. Can be used to regenerate the last assistant reply, or simply generate one if an error occurred.`,
+		Args: func(cmd *cobra.Command, args []string) error {
+			argCount := 1
+			if err := cobra.MinimumNArgs(argCount)(cmd, args); err != nil {
+				return err
+			}
+			return nil
+		},
+		RunE: func(cmd *cobra.Command, args []string) error {
+			shortName := args[0]
+			conversation := cmdutil.LookupConversation(ctx, shortName)
+
+			messages, err := ctx.Store.Messages(conversation)
+			if err != nil {
+				return fmt.Errorf("Could not retrieve messages for conversation: %s", conversation.Title)
+			}
+
+			// walk backwards through the conversation and delete messages, break
+			// when we find the latest user response
+			for i := len(messages) - 1; i >= 0; i-- {
+				if messages[i].Role == model.MessageRoleUser {
+					break
+				}
+
+				err = ctx.Store.DeleteMessage(&messages[i])
+				if err != nil {
+					lmcli.Warn("Could not delete previous reply: %v\n", err)
+				}
+			}
+
+			cmdutil.HandleConversationReply(ctx, conversation, true)
+			return nil
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			compMode := cobra.ShellCompDirectiveNoFileComp
+			if len(args) != 0 {
+				return nil, compMode
+			}
+			return ctx.Store.ConversationShortNameCompletions(toComplete), compMode
+		},
+	}
+	return cmd
+}
--- a/pkg/cmd/util/util.go
+++ b/pkg/cmd/util/util.go
@@ -0,0 +1,284 @@
+package util
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"time"
+
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/tools"
+	"git.mlow.ca/mlow/lmcli/pkg/util"
+	"github.com/alecthomas/chroma/v2/quick"
+	"github.com/charmbracelet/lipgloss"
+)
+
+// fetchAndShowCompletion prompts the LLM with the given messages and streams
+// the response to stdout. Returns all model reply messages.
+func FetchAndShowCompletion(ctx *lmcli.Context, messages []model.Message) ([]model.Message, error) {
+	content := make(chan string) // receives the reponse from LLM
+	defer close(content)
+
+	// render all content received over the channel
+	go ShowDelayedContent(content)
+
+	completionProvider, err := ctx.GetCompletionProvider(*ctx.Config.Defaults.Model)
+	if err != nil {
+		return nil, err
+	}
+
+	var toolBag []model.Tool
+	for _, toolName := range *ctx.Config.Tools.EnabledTools {
+		tool, ok := tools.AvailableTools[toolName]
+		if ok {
+			toolBag = append(toolBag, tool)
+		}
+	}
+
+	requestParams := model.RequestParameters{
+		Model:       *ctx.Config.Defaults.Model,
+		MaxTokens:   *ctx.Config.Defaults.MaxTokens,
+		Temperature: *ctx.Config.Defaults.Temperature,
+		ToolBag:     toolBag,
+	}
+
+	var apiReplies []model.Message
+	response, err := completionProvider.CreateChatCompletionStream(
+		requestParams, messages, &apiReplies, content,
+	)
+	if response != "" {
+		// there was some content, so break to a new line after it
+		fmt.Println()
+
+		if err != nil {
+			lmcli.Warn("Received partial response. Error: %v\n", err)
+			err = nil
+		}
+	}
+
+	return apiReplies, err
+}
+
+// lookupConversation either returns the conversation found by the
+// short name or exits the program
+func LookupConversation(ctx *lmcli.Context, shortName string) *model.Conversation {
+	c, err := ctx.Store.ConversationByShortName(shortName)
+	if err != nil {
+		lmcli.Fatal("Could not lookup conversation: %v\n", err)
+	}
+	if c.ID == 0 {
+		lmcli.Fatal("Conversation not found with short name: %s\n", shortName)
+	}
+	return c
+}
+
+func LookupConversationE(ctx *lmcli.Context, shortName string) (*model.Conversation, error) {
+	c, err := ctx.Store.ConversationByShortName(shortName)
+	if err != nil {
+		return nil, fmt.Errorf("Could not lookup conversation: %v", err)
+	}
+	if c.ID == 0 {
+		return nil, fmt.Errorf("Conversation not found with short name: %s", shortName)
+	}
+	return c, nil
+}
+
+// handleConversationReply handles sending messages to an existing
+// conversation, optionally persisting both the sent replies and responses.
+func HandleConversationReply(ctx *lmcli.Context, c *model.Conversation, persist bool, toSend ...model.Message) {
+	existing, err := ctx.Store.Messages(c)
+	if err != nil {
+		lmcli.Fatal("Could not retrieve messages for conversation: %s\n", c.Title)
+	}
+
+	if persist {
+		for _, message := range toSend {
+			err = ctx.Store.SaveMessage(&message)
+			if err != nil {
+				lmcli.Warn("Could not save %s message: %v\n", message.Role, err)
+			}
+		}
+	}
+
+	allMessages := append(existing, toSend...)
+
+	RenderConversation(ctx, allMessages, true)
+
+	// render a message header with no contents
+	RenderMessage(ctx, (&model.Message{Role: model.MessageRoleAssistant}))
+
+	replies, err := FetchAndShowCompletion(ctx, allMessages)
+	if err != nil {
+		lmcli.Fatal("Error fetching LLM response: %v\n", err)
+	}
+
+	if persist {
+		for _, reply := range replies {
+			reply.ConversationID = c.ID
+
+			err = ctx.Store.SaveMessage(&reply)
+			if err != nil {
+				lmcli.Warn("Could not save reply: %v\n", err)
+			}
+		}
+	}
+}
+
+func FormatForExternalPrompt(messages []model.Message, system bool) string {
+	sb := strings.Builder{}
+	for _, message := range messages {
+		if message.Role != model.MessageRoleUser && (message.Role != model.MessageRoleSystem || !system) {
+			continue
+		}
+		sb.WriteString(fmt.Sprintf("<%s>\n", message.Role.FriendlyRole()))
+		sb.WriteString(fmt.Sprintf("\"\"\"\n%s\n\"\"\"\n\n", message.Content))
+	}
+	return sb.String()
+}
+
+func GenerateTitle(ctx *lmcli.Context, c *model.Conversation) (string, error) {
+	messages, err := ctx.Store.Messages(c)
+	if err != nil {
+		return "", err
+	}
+
+	const header = "Generate a concise 4-5 word title for the conversation below."
+	prompt := fmt.Sprintf("%s\n\n---\n\n%s", header, FormatForExternalPrompt(messages, false))
+
+	generateRequest := []model.Message{
+		{
+			Role:    model.MessageRoleUser,
+			Content: prompt,
+		},
+	}
+
+	completionProvider, err := ctx.GetCompletionProvider(*ctx.Config.Conversations.TitleGenerationModel)
+	if err != nil {
+		return "", err
+	}
+
+	requestParams := model.RequestParameters{
+		Model:     *ctx.Config.Conversations.TitleGenerationModel,
+		MaxTokens: 25,
+	}
+
+	response, err := completionProvider.CreateChatCompletion(requestParams, generateRequest, nil)
+	if err != nil {
+		return "", err
+	}
+
+	return response, nil
+}
+
+// ShowWaitAnimation prints an animated ellipses to stdout until something is
+// received on the signal channel. An empty string sent to the channel to
+// noftify the caller that the animation has completed (carriage returned).
+func ShowWaitAnimation(signal chan any) {
+	// Save the current cursor position
+	fmt.Print("\033[s")
+
+	animationStep := 0
+	for {
+		select {
+		case _ = <-signal:
+			// Relmcli the cursor position
+			fmt.Print("\033[u")
+			signal <- ""
+			return
+		default:
+			// Move the cursor to the saved position
+			modSix := animationStep % 6
+			if modSix == 3 || modSix == 0 {
+				fmt.Print("\033[u")
+			}
+			if modSix < 3 {
+				fmt.Print(".")
+			} else {
+				fmt.Print(" ")
+			}
+			animationStep++
+			time.Sleep(250 * time.Millisecond)
+		}
+	}
+}
+
+// ShowDelayedContent displays a waiting animation to stdout while waiting
+// for content to be received on the provided channel. As soon as any (possibly
+// chunked) content is received on the channel, the waiting animation is
+// replaced by the content.
+// Blocks until the channel is closed.
+func ShowDelayedContent(content <-chan string) {
+	waitSignal := make(chan any)
+	go ShowWaitAnimation(waitSignal)
+
+	firstChunk := true
+	for chunk := range content {
+		if firstChunk {
+			// notify wait animation that we've received data
+			waitSignal <- ""
+			// wait for signal that wait animation has completed
+			<-waitSignal
+			firstChunk = false
+		}
+		fmt.Print(chunk)
+	}
+}
+
+// RenderConversation renders the given messages to TTY, with optional space
+// for a subsequent message. spaceForResponse controls how many '\n' characters
+// are printed immediately after the final message (1 if false, 2 if true)
+func RenderConversation(ctx *lmcli.Context, messages []model.Message, spaceForResponse bool) {
+	l := len(messages)
+	for i, message := range messages {
+		RenderMessage(ctx, &message)
+		if i < l-1 || spaceForResponse {
+			// print an additional space before the next message
+			fmt.Println()
+		}
+	}
+}
+
+// HighlightMarkdown applies syntax highlighting to the provided markdown text
+// and writes it to stdout.
+func HighlightMarkdown(w io.Writer, markdownText string, formatter string, style string) error {
+	return quick.Highlight(w, markdownText, "md", formatter, style)
+}
+
+func RenderMessage(ctx *lmcli.Context, m *model.Message) {
+	var messageAge string
+	if m.CreatedAt.IsZero() {
+		messageAge = "now"
+	} else {
+		now := time.Now()
+		messageAge = util.HumanTimeElapsedSince(now.Sub(m.CreatedAt))
+	}
+
+	headerStyle := lipgloss.NewStyle().Bold(true)
+
+	switch m.Role {
+	case model.MessageRoleSystem:
+		headerStyle = headerStyle.Foreground(lipgloss.Color("9")) // bright red
+	case model.MessageRoleUser:
+		headerStyle = headerStyle.Foreground(lipgloss.Color("10")) // bright green
+	case model.MessageRoleAssistant:
+		headerStyle = headerStyle.Foreground(lipgloss.Color("12")) // bright blue
+	}
+
+	role := headerStyle.Render(m.Role.FriendlyRole())
+
+	separatorStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("3"))
+	separator := separatorStyle.Render("===")
+	timestamp := separatorStyle.Render(messageAge)
+
+	fmt.Printf("%s %s - %s %s\n\n", separator, role, timestamp, separator)
+	if m.Content != "" {
+		HighlightMarkdown(
+			os.Stdout, m.Content,
+			*ctx.Config.Chroma.Formatter,
+			*ctx.Config.Chroma.Style,
+		)
+		fmt.Println()
+	}
+}
--- a/pkg/cmd/view.go
+++ b/pkg/cmd/view.go
@@ -0,0 +1,45 @@
+package cmd
+
+import (
+	"fmt"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
+	"github.com/spf13/cobra"
+)
+
+func ViewCmd(ctx *lmcli.Context) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "view <conversation>",
+		Short: "View messages in a conversation",
+		Long:  `Finds a conversation by its short name and displays its contents.`,
+		Args: func(cmd *cobra.Command, args []string) error {
+			argCount := 1
+			if err := cobra.MinimumNArgs(argCount)(cmd, args); err != nil {
+				return err
+			}
+			return nil
+		},
+		RunE: func(cmd *cobra.Command, args []string)  error {
+			shortName := args[0]
+			conversation := cmdutil.LookupConversation(ctx, shortName)
+
+			messages, err := ctx.Store.Messages(conversation)
+			if err != nil {
+				return fmt.Errorf("Could not retrieve messages for conversation: %s", conversation.Title)
+			}
+
+			cmdutil.RenderConversation(ctx, messages, false)
+			return nil
+		},
+		ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+			compMode := cobra.ShellCompDirectiveNoFileComp
+			if len(args) != 0 {
+				return nil, compMode
+			}
+			return ctx.Store.ConversationShortNameCompletions(toComplete), compMode
+		},
+	}
+
+	return cmd
+}