Fixes to message/conversation handling in tui chat view

This set of changes fixes root/child message cycling and ensures all
database operations happen within a `tea.Cmd`

pkg/lmcli/store.go

@@ -241,6 +241,7 @@ func (s *SQLStore) Reply(to *model.Message, messages ...model.Message) ([]model.
 			}
 
 			// update parent selected reply
+			currentParent.Replies = append(currentParent.Replies, message)
 			currentParent.SelectedReply = &message
 			if err := tx.Model(currentParent).Update("selected_reply_id", message.ID).Error; err != nil {
 				return err
@@ -257,7 +258,7 @@ func (s *SQLStore) Reply(to *model.Message, messages ...model.Message) ([]model.
 
 // CloneBranch returns a deep clone of the given message and its replies, returning
 // a new message object. The new message will be attached to the same parent as
-// the message to clone.
+// the messageToClone
 func (s *SQLStore) CloneBranch(messageToClone model.Message) (*model.Message, uint, error) {
 	newMessage := messageToClone
 	newMessage.ID = 0
@@ -302,7 +303,7 @@ func (s *SQLStore) CloneBranch(messageToClone model.Message) (*model.Message, ui
 
 func fetchMessages(db *gorm.DB) ([]model.Message, error) {
 	var messages []model.Message
-	if err := db.Find(&messages).Error; err != nil {
+	if err := db.Preload("Conversation").Find(&messages).Error; err != nil {
 		return nil, fmt.Errorf("Could not fetch messages: %v", err)
 	}
 
@@ -375,7 +376,9 @@ func (s *SQLStore) buildPath(message *model.Message, getNext func(*model.Message
 	return path, nil
 }
 
-// PathToRoot traverses message Parent until reaching the tree root
+// PathToRoot traverses the provided message's Parent until reaching the tree
+// root and returns a slice of all messages traversed in chronological order
+// (starting with the root and ending with the message provided)
 func (s *SQLStore) PathToRoot(message *model.Message) ([]model.Message, error) {
 	if message == nil || message.ID <= 0 {
 		return nil, fmt.Errorf("Message is nil or has invalid ID")
@@ -392,7 +395,9 @@ func (s *SQLStore) PathToRoot(message *model.Message) ([]model.Message, error) {
 	return path, nil
 }
 
-// PathToLeaf traverses message SelectedReply until reaching a tree leaf
+// PathToLeaf traverses the provided message's SelectedReply until reaching a
+// tree leaf and returns a slice of all messages traversed in chronological
+// order (starting with the message provided and ending with the leaf)
 func (s *SQLStore) PathToLeaf(message *model.Message) ([]model.Message, error) {
 	if message == nil || message.ID <= 0 {
 		return nil, fmt.Errorf("Message is nil or has invalid ID")

pkg/tui/views/chat/conversation.go

@@ -0,0 +1,293 @@
+package chat
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
+	models "git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"git.mlow.ca/mlow/lmcli/pkg/tui/shared"
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func (m *Model) setMessage(i int, msg models.Message) {
+	if i >= len(m.messages) {
+		panic("i out of range")
+	}
+	m.messages[i] = msg
+	m.messageCache[i] = m.renderMessage(i)
+}
+
+func (m *Model) addMessage(msg models.Message) {
+	m.messages = append(m.messages, msg)
+	m.messageCache = append(m.messageCache, m.renderMessage(len(m.messages)-1))
+}
+
+func (m *Model) setMessageContents(i int, content string) {
+	if i >= len(m.messages) {
+		panic("i out of range")
+	}
+	m.messages[i].Content = content
+	m.messageCache[i] = m.renderMessage(i)
+}
+
+func (m *Model) rebuildMessageCache() {
+	m.messageCache = make([]string, len(m.messages))
+	for i := range m.messages {
+		m.messageCache[i] = m.renderMessage(i)
+	}
+}
+
+func (m *Model) updateContent() {
+	atBottom := m.content.AtBottom()
+	m.content.SetContent(m.conversationMessagesView())
+	if atBottom {
+		// if we were at bottom before the update, scroll with the output
+		m.content.GotoBottom()
+	}
+}
+
+func (m *Model) loadConversation(shortname string) tea.Cmd {
+	return func() tea.Msg {
+		if shortname == "" {
+			return nil
+		}
+		c, err := m.State.Ctx.Store.ConversationByShortName(shortname)
+		if err != nil {
+			return shared.MsgError(fmt.Errorf("Could not lookup conversation: %v", err))
+		}
+		if c.ID == 0 {
+			return shared.MsgError(fmt.Errorf("Conversation not found: %s", shortname))
+		}
+		rootMessages, err := m.State.Ctx.Store.RootMessages(c.ID)
+		if err != nil {
+			return shared.MsgError(fmt.Errorf("Could not load conversation root messages: %v\n", err))
+		}
+		return msgConversationLoaded{c, rootMessages}
+	}
+}
+
+func (m *Model) loadConversationMessages() tea.Cmd {
+	return func() tea.Msg {
+		messages, err := m.State.Ctx.Store.PathToLeaf(m.conversation.SelectedRoot)
+		if err != nil {
+			return shared.MsgError(fmt.Errorf("Could not load conversation messages: %v\n", err))
+		}
+		return msgMessagesLoaded(messages)
+	}
+}
+
+func (m *Model) generateConversationTitle() tea.Cmd {
+	return func() tea.Msg {
+		title, err := cmdutil.GenerateTitle(m.State.Ctx, m.messages)
+		if err != nil {
+			return shared.MsgError(err)
+		}
+		return msgConversationTitleGenerated(title)
+	}
+}
+
+func (m *Model) updateConversationTitle(conversation *models.Conversation) tea.Cmd {
+	return func() tea.Msg {
+		err := m.State.Ctx.Store.UpdateConversation(conversation)
+		if err != nil {
+			return shared.WrapError(err)
+		}
+		return nil
+	}
+}
+
+// Clones the given message (and its descendents). If selected is true, updates
+// either its parent's SelectedReply or its conversation's SelectedRoot to
+// point to the new clone
+func (m *Model) cloneMessage(message models.Message, selected bool) tea.Cmd {
+	return func() tea.Msg {
+		msg, _, err := m.Ctx.Store.CloneBranch(message)
+		if err != nil {
+			return shared.WrapError(fmt.Errorf("Could not clone message: %v", err))
+		}
+		if selected {
+			if msg.Parent == nil {
+				msg.Conversation.SelectedRoot = msg
+				err = m.State.Ctx.Store.UpdateConversation(&msg.Conversation)
+			} else {
+				msg.Parent.SelectedReply = msg
+				err = m.State.Ctx.Store.UpdateMessage(msg.Parent)
+			}
+			if err != nil {
+				return shared.WrapError(fmt.Errorf("Could not update selected message: %v", err))
+			}
+		}
+		return msgMessageCloned(msg)
+	}
+}
+
+func (m *Model) updateMessageContent(message *models.Message) tea.Cmd {
+	return func() tea.Msg {
+		err := m.State.Ctx.Store.UpdateMessage(message)
+		if err != nil {
+			return shared.WrapError(fmt.Errorf("Could not update message: %v", err))
+		}
+		return msgMessageUpdated(message)
+	}
+}
+
+func cycleSelectedMessage(selected *models.Message, choices []models.Message, dir MessageCycleDirection) (*models.Message, error) {
+	currentIndex := -1
+	for i, reply := range choices {
+		if reply.ID == selected.ID {
+			currentIndex = i
+			break
+		}
+	}
+
+	if currentIndex < 0 {
+		// this should probably be an assert
+		return nil, fmt.Errorf("Selected message %d not found in choices, this is a bug", selected.ID)
+	}
+
+	var next int
+	if dir == CyclePrev {
+		// Wrap around to the last reply if at the beginning
+		next = (currentIndex - 1 + len(choices)) % len(choices)
+	} else {
+		// Wrap around to the first reply if at the end
+		next = (currentIndex + 1) % len(choices)
+	}
+	return &choices[next], nil
+}
+
+func (m *Model) cycleSelectedRoot(conv *models.Conversation, dir MessageCycleDirection) tea.Cmd {
+	if len(m.rootMessages) < 2 {
+		return nil
+	}
+
+	return func() tea.Msg {
+		nextRoot, err := cycleSelectedMessage(conv.SelectedRoot, m.rootMessages, dir)
+		if err != nil {
+			return shared.WrapError(err)
+		}
+
+		conv.SelectedRoot = nextRoot
+		err = m.State.Ctx.Store.UpdateConversation(conv)
+		if err != nil {
+			return shared.WrapError(fmt.Errorf("Could not update conversation SelectedRoot: %v", err))
+		}
+		return msgSelectedRootCycled(nextRoot)
+	}
+}
+
+func (m *Model) cycleSelectedReply(message *models.Message, dir MessageCycleDirection) tea.Cmd {
+	if len(message.Replies) < 2 {
+		return nil
+	}
+
+	return func() tea.Msg {
+		nextReply, err := cycleSelectedMessage(message.SelectedReply, message.Replies, dir)
+		if err != nil {
+			return shared.WrapError(err)
+		}
+
+		message.SelectedReply = nextReply
+		err = m.State.Ctx.Store.UpdateMessage(message)
+		if err != nil {
+			return shared.WrapError(fmt.Errorf("Could not update message SelectedReply: %v", err))
+		}
+		return msgSelectedReplyCycled(nextReply)
+	}
+}
+
+func (m *Model) persistConversation() tea.Cmd {
+	conversation := m.conversation
+	messages := m.messages
+
+	var err error
+	if m.conversation.ID == 0 {
+		return func() tea.Msg {
+			// Start a new conversation with all messages so far
+			conversation, messages, err = m.State.Ctx.Store.StartConversation(messages...)
+			if err != nil {
+				return shared.MsgError(fmt.Errorf("Could not start new conversation: %v", err))
+			}
+			return msgConversationPersisted{conversation, messages}
+		}
+	}
+
+	return func() tea.Msg {
+		// else, we'll handle updating an existing conversation's messages
+		for i := range messages {
+			if messages[i].ID > 0 {
+				// message has an ID, update its contents
+				err := m.State.Ctx.Store.UpdateMessage(&messages[i])
+				if err != nil {
+					return shared.MsgError(err)
+				}
+			} else if i > 0 {
+				if messages[i].Content == "" {
+					continue
+				}
+				// messages is new, so add it as a reply to previous message
+				saved, err := m.State.Ctx.Store.Reply(&messages[i-1], messages[i])
+				if err != nil {
+					return shared.MsgError(err)
+				}
+				messages[i] = saved[0]
+			} else {
+				// message has no id and no previous messages to add it to
+				// this shouldn't happen?
+				return fmt.Errorf("Error: no messages to reply to")
+			}
+		}
+		return msgConversationPersisted{conversation, messages}
+	}
+}
+
+func (m *Model) promptLLM() tea.Cmd {
+	m.waitingForReply = true
+	m.replyCursor.Blink = false
+	m.status = "Press ctrl+c to cancel"
+
+	m.tokenCount = 0
+	m.startTime = time.Now()
+	m.elapsed = 0
+
+	return func() tea.Msg {
+		model, provider, err := m.State.Ctx.GetModelProvider(*m.State.Ctx.Config.Defaults.Model)
+		if err != nil {
+			return shared.MsgError(err)
+		}
+
+		requestParams := models.RequestParameters{
+			Model:       model,
+			MaxTokens:   *m.State.Ctx.Config.Defaults.MaxTokens,
+			Temperature: *m.State.Ctx.Config.Defaults.Temperature,
+			ToolBag:     m.State.Ctx.EnabledTools,
+		}
+
+		replyHandler := func(msg models.Message) {
+			m.replyChan <- msg
+		}
+
+		ctx, cancel := context.WithCancel(context.Background())
+
+		canceled := false
+		go func() {
+			select {
+			case <-m.stopSignal:
+				canceled = true
+				cancel()
+			}
+		}()
+
+		resp, err := provider.CreateChatCompletionStream(
+			ctx, requestParams, m.messages, replyHandler, m.replyChunkChan,
+		)
+
+		if err != nil && !canceled {
+			return msgResponseError(err)
+		}
+
+		return msgResponseEnd(resp)
+	}
+}

pkg/tui/views/chat/input.go

@@ -0,0 +1,181 @@
+package chat
+
+import (
+	"fmt"
+	"strings"
+
+	models "git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"git.mlow.ca/mlow/lmcli/pkg/tui/shared"
+	tuiutil "git.mlow.ca/mlow/lmcli/pkg/tui/util"
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type MessageCycleDirection int
+
+const (
+	CycleNext MessageCycleDirection = 1
+	CyclePrev MessageCycleDirection = -1
+)
+
+func (m *Model) HandleInput(msg tea.KeyMsg) (bool, tea.Cmd) {
+	switch m.focus {
+	case focusInput:
+		consumed, cmd := m.handleInputKey(msg)
+		if consumed {
+			return true, cmd
+		}
+	case focusMessages:
+		consumed, cmd := m.handleMessagesKey(msg)
+		if consumed {
+			return true, cmd
+		}
+	}
+
+	switch msg.String() {
+	case "esc":
+		if m.waitingForReply {
+			m.stopSignal <- struct{}{}
+			return true, nil
+		}
+		return true, func() tea.Msg {
+			return shared.MsgViewChange(shared.StateConversations)
+		}
+	case "ctrl+c":
+		if m.waitingForReply {
+			m.stopSignal <- struct{}{}
+			return true, nil
+		}
+	case "ctrl+p":
+		m.persistence = !m.persistence
+		return true, nil
+	case "ctrl+t":
+		m.showToolResults = !m.showToolResults
+		m.rebuildMessageCache()
+		m.updateContent()
+		return true, nil
+	case "ctrl+w":
+		m.wrap = !m.wrap
+		m.rebuildMessageCache()
+		m.updateContent()
+		return true, nil
+	}
+	return false, nil
+}
+
+// handleMessagesKey handles input when the messages pane is focused
+func (m *Model) handleMessagesKey(msg tea.KeyMsg) (bool, tea.Cmd) {
+	switch msg.String() {
+	case "tab", "enter":
+		m.focus = focusInput
+		m.updateContent()
+		m.input.Focus()
+		return true, nil
+	case "e":
+		if m.selectedMessage < len(m.messages) {
+			m.editorTarget = selectedMessage
+			return true, tuiutil.OpenTempfileEditor(
+				"message.*.md",
+				m.messages[m.selectedMessage].Content,
+				"# Edit the message below\n",
+			)
+		}
+		return false, nil
+	case "ctrl+k":
+		if m.selectedMessage > 0 && len(m.messages) == len(m.messageOffsets) {
+			m.selectedMessage--
+			m.updateContent()
+			offset := m.messageOffsets[m.selectedMessage]
+			tuiutil.ScrollIntoView(&m.content, offset, m.content.Height/2)
+		}
+		return true, nil
+	case "ctrl+j":
+		if m.selectedMessage < len(m.messages)-1 && len(m.messages) == len(m.messageOffsets) {
+			m.selectedMessage++
+			m.updateContent()
+			offset := m.messageOffsets[m.selectedMessage]
+			tuiutil.ScrollIntoView(&m.content, offset, m.content.Height/2)
+		}
+		return true, nil
+	case "ctrl+h", "ctrl+l":
+		dir := CyclePrev
+		if msg.String() == "ctrl+l" {
+			dir = CycleNext
+		}
+
+		var cmd tea.Cmd
+		if m.selectedMessage == 0 {
+			cmd = m.cycleSelectedRoot(m.conversation, dir)
+		} else if m.selectedMessage > 0 {
+			cmd = m.cycleSelectedReply(&m.messages[m.selectedMessage-1], dir)
+		}
+
+		return cmd != nil, cmd
+	case "ctrl+r":
+		// resubmit the conversation with all messages up until and including the selected message
+		if m.waitingForReply || len(m.messages) == 0 {
+			return true, nil
+		}
+		m.messages = m.messages[:m.selectedMessage+1]
+		m.messageCache = m.messageCache[:m.selectedMessage+1]
+		cmd := m.promptLLM()
+		m.updateContent()
+		m.content.GotoBottom()
+		return true, cmd
+	}
+	return false, nil
+}
+
+// handleInputKey handles input when the input textarea is focused
+func (m *Model) handleInputKey(msg tea.KeyMsg) (bool, tea.Cmd) {
+	switch msg.String() {
+	case "esc":
+		m.focus = focusMessages
+		if len(m.messages) > 0 {
+			if m.selectedMessage < 0 || m.selectedMessage >= len(m.messages) {
+				m.selectedMessage = len(m.messages) - 1
+			}
+			offset := m.messageOffsets[m.selectedMessage]
+			tuiutil.ScrollIntoView(&m.content, offset, m.content.Height/2)
+		}
+		m.updateContent()
+		m.input.Blur()
+		return true, nil
+	case "ctrl+s":
+		// TODO: call a "handleSend" function with returns a tea.Cmd
+		if m.waitingForReply {
+			return false, nil
+		}
+
+		input := strings.TrimSpace(m.input.Value())
+		if input == "" {
+			return true, nil
+		}
+
+		if len(m.messages) > 0 && m.messages[len(m.messages)-1].Role == models.MessageRoleUser {
+			return true, shared.WrapError(fmt.Errorf("Can't reply to a user message"))
+		}
+
+		m.addMessage(models.Message{
+			Role:    models.MessageRoleUser,
+			Content: input,
+		})
+
+		m.input.SetValue("")
+
+		var cmds []tea.Cmd
+		if m.persistence {
+			cmds = append(cmds, m.persistConversation())
+		}
+
+		cmds = append(cmds, m.promptLLM())
+
+		m.updateContent()
+		m.content.GotoBottom()
+		return true, tea.Batch(cmds...)
+	case "ctrl+e":
+		cmd := tuiutil.OpenTempfileEditor("message.*.md", m.input.Value(), "# Edit your input below\n")
+		m.editorTarget = input
+		return true, cmd
+	}
+	return false, nil
+}

pkg/tui/views/chat/update.go

@@ -0,0 +1,250 @@
+package chat
+
+import (
+	"strings"
+	"time"
+
+	models "git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"git.mlow.ca/mlow/lmcli/pkg/tui/shared"
+	tuiutil "git.mlow.ca/mlow/lmcli/pkg/tui/util"
+	"github.com/charmbracelet/bubbles/cursor"
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func (m *Model) HandleResize(width, height int) {
+	m.Width, m.Height = width, height
+	m.content.Width = width
+	m.input.SetWidth(width - m.input.FocusedStyle.Base.GetHorizontalFrameSize())
+	if len(m.messages) > 0 {
+		m.rebuildMessageCache()
+		m.updateContent()
+	}
+}
+
+func (m *Model) waitForResponse() tea.Cmd {
+	return func() tea.Msg {
+		return msgResponse(<-m.replyChan)
+	}
+}
+
+func (m *Model) waitForResponseChunk() tea.Cmd {
+	return func() tea.Msg {
+		return msgResponseChunk(<-m.replyChunkChan)
+	}
+}
+
+func (m Model) Update(msg tea.Msg) (Model, tea.Cmd) {
+	var cmds []tea.Cmd
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		m.HandleResize(msg.Width, msg.Height)
+	case shared.MsgViewEnter:
+		// wake up spinners and cursors
+		cmds = append(cmds, cursor.Blink, m.spinner.Tick)
+
+		if m.State.Values.ConvShortname != "" {
+			// (re)load conversation contents
+			cmds = append(cmds, m.loadConversation(m.State.Values.ConvShortname))
+
+			if m.conversation.ShortName.String != m.State.Values.ConvShortname {
+				// clear existing messages if we're loading a new conversation
+				m.messages = []models.Message{}
+				m.selectedMessage = 0
+			}
+		}
+
+		m.rebuildMessageCache()
+		m.updateContent()
+	case tuiutil.MsgTempfileEditorClosed:
+		contents := string(msg)
+		switch m.editorTarget {
+		case input:
+			m.input.SetValue(contents)
+		case selectedMessage:
+			toEdit := m.messages[m.selectedMessage]
+			if toEdit.Content != contents {
+				toEdit.Content = contents
+				m.setMessage(m.selectedMessage, toEdit)
+				if m.persistence && toEdit.ID > 0 {
+					// create clone of message with its new contents
+					cmds = append(cmds, m.cloneMessage(toEdit, true))
+				}
+			}
+		}
+	case msgConversationLoaded:
+		m.conversation = msg.conversation
+		m.rootMessages = msg.rootMessages
+		m.selectedMessage = -1
+		if len(m.rootMessages) > 0 {
+			cmds = append(cmds, m.loadConversationMessages())
+		}
+	case msgMessagesLoaded:
+		m.messages = msg
+		if m.selectedMessage == -1 {
+			m.selectedMessage = len(msg) - 1
+		} else {
+			m.selectedMessage = min(m.selectedMessage, len(m.messages))
+		}
+		m.rebuildMessageCache()
+		m.updateContent()
+	case msgResponseChunk:
+		cmds = append(cmds, m.waitForResponseChunk()) // wait for the next chunk
+
+		chunk := string(msg)
+		if chunk == "" {
+			break
+		}
+
+		last := len(m.messages) - 1
+		if last >= 0 && m.messages[last].Role.IsAssistant() {
+			// append chunk to existing message
+			m.setMessageContents(last, m.messages[last].Content+chunk)
+		} else {
+			// use chunk in new message
+			m.addMessage(models.Message{
+				Role:    models.MessageRoleAssistant,
+				Content: chunk,
+			})
+		}
+		m.updateContent()
+
+		// show cursor and reset blink interval (simulate typing)
+		m.replyCursor.Blink = false
+		cmds = append(cmds, m.replyCursor.BlinkCmd())
+
+		m.tokenCount++
+		m.elapsed = time.Now().Sub(m.startTime)
+	case msgResponse:
+		cmds = append(cmds, m.waitForResponse()) // wait for the next response
+
+		reply := models.Message(msg)
+		reply.Content = strings.TrimSpace(reply.Content)
+
+		last := len(m.messages) - 1
+		if last < 0 {
+			panic("Unexpected empty messages handling msgAssistantReply")
+		}
+
+		if reply.Role.IsAssistant() && m.messages[last].Role.IsAssistant() {
+			// this was a continuation, so replace the previous message with the completed reply
+			m.setMessage(last, reply)
+		} else {
+			m.addMessage(reply)
+		}
+
+		if m.persistence {
+			cmds = append(cmds, m.persistConversation())
+		}
+
+		if m.conversation.Title == "" {
+			cmds = append(cmds, m.generateConversationTitle())
+		}
+
+		m.updateContent()
+	case msgResponseEnd:
+		m.waitingForReply = false
+		last := len(m.messages) - 1
+		if last < 0 {
+			panic("Unexpected empty messages handling msgResponseEnd")
+		}
+		m.setMessageContents(last, strings.TrimSpace(m.messages[last].Content))
+		m.updateContent()
+		m.status = "Press ctrl+s to send"
+	case msgResponseError:
+		m.waitingForReply = false
+		m.status = "Press ctrl+s to send"
+		m.State.Err = error(msg)
+		m.updateContent()
+	case msgConversationTitleGenerated:
+		title := string(msg)
+		m.conversation.Title = title
+		if m.persistence {
+			cmds = append(cmds, m.updateConversationTitle(m.conversation))
+		}
+	case cursor.BlinkMsg:
+		if m.waitingForReply {
+			// ensure we show the updated "wait for response" cursor blink state
+			m.updateContent()
+		}
+	case msgConversationPersisted:
+		m.conversation = msg.conversation
+		m.messages = msg.messages
+		m.rebuildMessageCache()
+		m.updateContent()
+	case msgMessageCloned:
+		if msg.Parent == nil {
+			m.conversation = &msg.Conversation
+			m.rootMessages = append(m.rootMessages, *msg)
+		}
+		cmds = append(cmds, m.loadConversationMessages())
+	case msgSelectedRootCycled, msgSelectedReplyCycled, msgMessageUpdated:
+		cmds = append(cmds, m.loadConversationMessages())
+	}
+
+	var cmd tea.Cmd
+	m.spinner, cmd = m.spinner.Update(msg)
+	if cmd != nil {
+		cmds = append(cmds, cmd)
+	}
+	m.replyCursor, cmd = m.replyCursor.Update(msg)
+	if cmd != nil {
+		cmds = append(cmds, cmd)
+	}
+
+	prevInputLineCnt := m.input.LineCount()
+	inputCaptured := false
+	m.input, cmd = m.input.Update(msg)
+	if cmd != nil {
+		inputCaptured = true
+		cmds = append(cmds, cmd)
+	}
+
+	if !inputCaptured {
+		m.content, cmd = m.content.Update(msg)
+		if cmd != nil {
+			cmds = append(cmds, cmd)
+		}
+	}
+
+	// update views once window dimensions are known
+	if m.Width > 0 {
+		m.Header = m.headerView()
+		m.Footer = m.footerView()
+		m.Error = tuiutil.ErrorBanner(m.Err, m.Width)
+		fixedHeight := tuiutil.Height(m.Header) + tuiutil.Height(m.Error) + tuiutil.Height(m.Footer)
+
+		// calculate clamped input height to accomodate input text
+		// minimum 4 lines, maximum half of content area
+		newHeight := max(4, min((m.Height-fixedHeight-1)/2, m.input.LineCount()))
+		m.input.SetHeight(newHeight)
+		m.Input = m.input.View()
+
+		// remaining height towards content
+		m.content.Height = m.Height - fixedHeight - tuiutil.Height(m.Input)
+		m.Content = m.content.View()
+	}
+
+	// this is a pretty nasty hack to ensure the input area viewport doesn't
+	// scroll below its content, which can happen when the input viewport
+	// height has grown, or previously entered lines have been deleted
+	if prevInputLineCnt != m.input.LineCount() {
+		// dist is the distance we'd need to scroll up from the current cursor
+		// position to position the last input line at the bottom of the
+		// viewport. if negative, we're already scrolled above the bottom
+		dist := m.input.Line() - (m.input.LineCount() - m.input.Height())
+		if dist > 0 {
+			for i := 0; i < dist; i++ {
+				// move cursor up until content reaches the bottom of the viewport
+				m.input.CursorUp()
+			}
+			m.input, _ = m.input.Update(nil)
+			for i := 0; i < dist; i++ {
+				// move cursor back down to its previous position
+				m.input.CursorDown()
+			}
+			m.input, _ = m.input.Update(nil)
+		}
+	}
+
+	return m, tea.Batch(cmds...)
+}

pkg/tui/views/chat/view.go

@@ -0,0 +1,327 @@
+package chat
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	models "git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
+	"git.mlow.ca/mlow/lmcli/pkg/tui/styles"
+	tuiutil "git.mlow.ca/mlow/lmcli/pkg/tui/util"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/muesli/reflow/wordwrap"
+	"github.com/muesli/reflow/wrap"
+	"gopkg.in/yaml.v2"
+)
+
+// styles
+var (
+	messageHeadingStyle = lipgloss.NewStyle().
+				MarginTop(1).
+				MarginBottom(1).
+				PaddingLeft(1).
+				Bold(true)
+
+	userStyle = lipgloss.NewStyle().Faint(true).Foreground(lipgloss.Color("10"))
+
+	assistantStyle = lipgloss.NewStyle().Faint(true).Foreground(lipgloss.Color("12"))
+
+	messageStyle = lipgloss.NewStyle().
+			PaddingLeft(2).
+			PaddingRight(2)
+
+	inputFocusedStyle = lipgloss.NewStyle().
+				Border(lipgloss.RoundedBorder(), true, true, true, false)
+
+	inputBlurredStyle = lipgloss.NewStyle().
+				Faint(true).
+				Border(lipgloss.RoundedBorder(), true, true, true, false)
+
+	footerStyle = lipgloss.NewStyle()
+)
+
+func (m Model) View() string {
+	if m.Width == 0 {
+		return ""
+	}
+	sections := make([]string, 0, 6)
+
+	if m.Header != "" {
+		sections = append(sections, m.Header)
+	}
+
+	sections = append(sections, m.Content)
+	if m.Error != "" {
+		sections = append(sections, m.Error)
+	}
+	sections = append(sections, m.Input)
+
+	if m.Footer != "" {
+		sections = append(sections, m.Footer)
+	}
+
+	return lipgloss.JoinVertical(lipgloss.Left, sections...)
+}
+
+func (m *Model) renderMessageHeading(i int, message *models.Message) string {
+	icon := ""
+	friendly := message.Role.FriendlyRole()
+	style := lipgloss.NewStyle().Faint(true).Bold(true)
+
+	switch message.Role {
+	case models.MessageRoleSystem:
+		icon = "⚙️"
+	case models.MessageRoleUser:
+		style = userStyle
+	case models.MessageRoleAssistant:
+		style = assistantStyle
+	case models.MessageRoleToolCall:
+		style = assistantStyle
+		friendly = models.MessageRoleAssistant.FriendlyRole()
+	case models.MessageRoleToolResult:
+		icon = "🔧"
+	}
+
+	user := style.Render(icon + friendly)
+
+	var prefix string
+	var suffix string
+
+	faint := lipgloss.NewStyle().Faint(true)
+
+	if i == 0 && len(m.rootMessages) > 1 && m.conversation.SelectedRootID != nil {
+		selectedRootIndex := 0
+		for j, reply := range m.rootMessages {
+			if reply.ID == *m.conversation.SelectedRootID {
+				selectedRootIndex = j
+				break
+			}
+		}
+		suffix += faint.Render(fmt.Sprintf(" <%d/%d>", selectedRootIndex+1, len(m.rootMessages)))
+	}
+	if i > 0 && len(m.messages[i-1].Replies) > 1 {
+		// Find the selected reply index
+		selectedReplyIndex := 0
+		for j, reply := range m.messages[i-1].Replies {
+			if reply.ID == *m.messages[i-1].SelectedReplyID {
+				selectedReplyIndex = j
+				break
+			}
+		}
+		suffix += faint.Render(fmt.Sprintf(" <%d/%d>", selectedReplyIndex+1, len(m.messages[i-1].Replies)))
+	}
+
+	if m.focus == focusMessages {
+		if i == m.selectedMessage {
+			prefix = "> "
+		}
+	}
+
+	if message.ID == 0 {
+		suffix += faint.Render(" (not saved)")
+	}
+
+	return messageHeadingStyle.Render(prefix + user + suffix)
+}
+
+func (m *Model) renderMessage(i int) string {
+	msg := &m.messages[i]
+
+	// Write message contents
+	sb := &strings.Builder{}
+	sb.Grow(len(msg.Content) * 2)
+	if msg.Content != "" {
+		err := m.State.Ctx.Chroma.Highlight(sb, msg.Content)
+		if err != nil {
+			sb.Reset()
+			sb.WriteString(msg.Content)
+		}
+	}
+
+	// Show the assistant's cursor
+	if m.waitingForReply && i == len(m.messages)-1 && msg.Role == models.MessageRoleAssistant {
+		sb.WriteString(m.replyCursor.View())
+	}
+
+	// Write tool call info
+	var toolString string
+	switch msg.Role {
+	case models.MessageRoleToolCall:
+		bytes, err := yaml.Marshal(msg.ToolCalls)
+		if err != nil {
+			toolString = "Could not serialize ToolCalls"
+		} else {
+			toolString = "tool_calls:\n" + string(bytes)
+		}
+	case models.MessageRoleToolResult:
+		if !m.showToolResults {
+			break
+		}
+
+		type renderedResult struct {
+			ToolName string `yaml:"tool"`
+			Result   any
+		}
+
+		var toolResults []renderedResult
+		for _, result := range msg.ToolResults {
+			var jsonResult interface{}
+			err := json.Unmarshal([]byte(result.Result), &jsonResult)
+			if err != nil {
+				// If parsing as JSON fails, treat Result as a plain string
+				toolResults = append(toolResults, renderedResult{
+					ToolName: result.ToolName,
+					Result:   result.Result,
+				})
+			} else {
+				// If parsing as JSON succeeds, marshal the parsed JSON into YAML
+				toolResults = append(toolResults, renderedResult{
+					ToolName: result.ToolName,
+					Result:   &jsonResult,
+				})
+			}
+		}
+
+		bytes, err := yaml.Marshal(toolResults)
+		if err != nil {
+			toolString = "Could not serialize ToolResults"
+		} else {
+			toolString = "tool_results:\n" + string(bytes)
+		}
+	}
+
+	if toolString != "" {
+		toolString = strings.TrimRight(toolString, "\n")
+		if msg.Content != "" {
+			sb.WriteString("\n\n")
+		}
+		_ = m.State.Ctx.Chroma.HighlightLang(sb, toolString, "yaml")
+	}
+
+	content := strings.TrimRight(sb.String(), "\n")
+
+	if m.wrap {
+		wrapWidth := m.content.Width - messageStyle.GetHorizontalPadding()
+		// first we word-wrap text to slightly less than desired width (since
+		// wordwrap seems to have an off-by-1 issue), then hard wrap at
+		// desired with
+		content = wrap.String(wordwrap.String(content, wrapWidth-2), wrapWidth)
+	}
+
+	return messageStyle.Width(0).Render(content)
+}
+
+// render the conversation into a string
+func (m *Model) conversationMessagesView() string {
+	sb := strings.Builder{}
+
+	m.messageOffsets = make([]int, len(m.messages))
+	lineCnt := 1
+	for i, message := range m.messages {
+		m.messageOffsets[i] = lineCnt
+
+		switch message.Role {
+		case models.MessageRoleToolCall:
+			if !m.showToolResults && message.Content == "" {
+				continue
+			}
+		case models.MessageRoleToolResult:
+			if !m.showToolResults {
+				continue
+			}
+		}
+
+		heading := m.renderMessageHeading(i, &message)
+		sb.WriteString(heading)
+		sb.WriteString("\n")
+		lineCnt += lipgloss.Height(heading)
+
+		var rendered string
+		if m.waitingForReply && i == len(m.messages)-1 {
+			// do a direct render of final (assistant) message to handle the
+			// assistant cursor blink
+			rendered = m.renderMessage(i)
+		} else {
+			rendered = m.messageCache[i]
+		}
+
+		sb.WriteString(rendered)
+		sb.WriteString("\n")
+		lineCnt += lipgloss.Height(rendered)
+	}
+
+	// Render a placeholder for the incoming assistant reply
+	if m.waitingForReply && (len(m.messages) == 0 || m.messages[len(m.messages)-1].Role != models.MessageRoleAssistant) {
+		heading := m.renderMessageHeading(-1, &models.Message{
+			Role: models.MessageRoleAssistant,
+		})
+		sb.WriteString(heading)
+		sb.WriteString("\n")
+		sb.WriteString(messageStyle.Width(0).Render(m.replyCursor.View()))
+		sb.WriteString("\n")
+	}
+
+	return sb.String()
+}
+
+func (m *Model) headerView() string {
+	titleStyle := lipgloss.NewStyle().Bold(true)
+	var title string
+	if m.conversation != nil && m.conversation.Title != "" {
+		title = m.conversation.Title
+	} else {
+		title = "Untitled"
+	}
+	title = tuiutil.TruncateToCellWidth(title, m.Width-styles.Header.GetHorizontalPadding(), "...")
+	header := titleStyle.Render(title)
+	return styles.Header.Width(m.Width).Render(header)
+}
+
+func (m *Model) footerView() string {
+	segmentStyle := lipgloss.NewStyle().PaddingLeft(1).PaddingRight(1).Faint(true)
+	segmentSeparator := "|"
+
+	savingStyle := segmentStyle.Copy().Bold(true)
+	saving := ""
+	if m.persistence {
+		saving = savingStyle.Foreground(lipgloss.Color("2")).Render("✅💾")
+	} else {
+		saving = savingStyle.Foreground(lipgloss.Color("1")).Render("❌💾")
+	}
+
+	status := m.status
+	if m.waitingForReply {
+		status += m.spinner.View()
+	}
+
+	leftSegments := []string{
+		saving,
+		segmentStyle.Render(status),
+	}
+	rightSegments := []string{}
+
+	if m.elapsed > 0 && m.tokenCount > 0 {
+		throughput := fmt.Sprintf("%.0f t/sec", float64(m.tokenCount)/m.elapsed.Seconds())
+		rightSegments = append(rightSegments, segmentStyle.Render(throughput))
+	}
+
+	model := fmt.Sprintf("Model: %s", *m.State.Ctx.Config.Defaults.Model)
+	rightSegments = append(rightSegments, segmentStyle.Render(model))
+
+	left := strings.Join(leftSegments, segmentSeparator)
+	right := strings.Join(rightSegments, segmentSeparator)
+
+	totalWidth := lipgloss.Width(left) + lipgloss.Width(right)
+	remaining := m.Width - totalWidth
+
+	var padding string
+	if remaining > 0 {
+		padding = strings.Repeat(" ", remaining)
+	}
+
+	footer := left + padding + right
+	if remaining < 0 {
+		footer = tuiutil.TruncateToCellWidth(footer, m.Width, "...")
+	}
+	return footerStyle.Width(m.Width).Render(footer)
+}