tui: ability to cancel request in flight

footer now rendered based on model data, instead of being set to a fixed
string

pkg/lmcli/store.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"strings"
-	"time"
 
 	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
 	sqids "github.com/sqids/sqids-go"
@@ -27,7 +26,6 @@ type ConversationStore interface {
 	SaveMessage(message *model.Message) error
 	DeleteMessage(message *model.Message) error
 	UpdateMessage(message *model.Message) error
-	AddReply(conversation *model.Conversation, message model.Message) (*model.Message, error)
 }
 
 type SQLStore struct {
@@ -121,12 +119,3 @@ func (s *SQLStore) LastMessage(conversation *model.Conversation) (*model.Message
 	err := s.db.Where("conversation_id = ?", conversation.ID).Last(&message).Error
 	return &message, err
 }
-
-// AddReply adds the given messages as a reply to the given conversation, can be
-// used to easily copy a message associated with one conversation, to another
-func (s *SQLStore) AddReply(c *model.Conversation, m model.Message) (*model.Message, error) {
-	m.ConversationID = c.ID
-	m.ID = 0
-	m.CreatedAt = time.Time{}
-	return &m, s.SaveMessage(&m)
-}

pkg/lmcli/tools/tools.go

@@ -2,6 +2,7 @@ package tools
 
 import (
 	"fmt"
+	"os"
 
 	"git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
 )
@@ -28,6 +29,9 @@ func ExecuteToolCalls(toolCalls []model.ToolCall, toolBag []model.Tool) ([]model
 			return nil, fmt.Errorf("Requested tool '%s' does not exist. Hallucination?", toolCall.Name)
 		}
 
+		// TODO: ability to silence this
+		fmt.Fprintf(os.Stderr, "\nINFO: Executing tool '%s' with args %s\n", toolCall.Name, toolCall.Parameters)
+
 		// Execute the tool
 		result, err := tool.Impl(tool, toolCall.Parameters)
 		if err != nil {

pkg/tui/tui.go

@@ -3,23 +3,15 @@ package tui
 // The terminal UI for lmcli, launched from the `lmcli chat` command
 // TODO:
 // - binding to open selected message/input in $EDITOR
-// - ability to continue or retry previous response
-// - conversation list view
-// - change model
-// - rename conversation
-// - set system prompt
-// - system prompt library?
 
 import (
 	"context"
 	"fmt"
 	"strings"
-	"time"
 
-	cmdutil "git.mlow.ca/mlow/lmcli/pkg/cmd/util"
 	"git.mlow.ca/mlow/lmcli/pkg/lmcli"
 	models "git.mlow.ca/mlow/lmcli/pkg/lmcli/model"
-	"github.com/charmbracelet/bubbles/spinner"
+	"git.mlow.ca/mlow/lmcli/pkg/lmcli/tools"
 	"github.com/charmbracelet/bubbles/textarea"
 	"github.com/charmbracelet/bubbles/viewport"
 	tea "github.com/charmbracelet/bubbletea"
@@ -34,9 +26,6 @@ const (
 )
 
 type model struct {
-	width  int
-	height int
-
 	ctx           *lmcli.Context
 	convShortname string
 
@@ -44,21 +33,17 @@ type model struct {
 	conversation    *models.Conversation
 	messages        []models.Message
 	waitingForReply bool
-	replyChan       chan models.Message
-	replyChunkChan  chan string
+	replyChan       chan string
 	replyCancelFunc context.CancelFunc
 	err             error
-	persistence     bool // whether we will save new messages in the conversation
 
 	// ui state
 	focus  focusState
 	status string // a general status message
-	highlightCache []string // a cache of syntax highlighted message content
 
 	// ui elements
 	content viewport.Model
 	input   textarea.Model
-	spinner spinner.Model
 }
 
 type message struct {
@@ -72,14 +57,8 @@ type (
 	msgResponseChunk string
 	// sent when response is finished being received
 	msgResponseEnd string
-	// a special case of msgError that stops the response waiting animation
-	msgResponseError error
-	// sent on each completed reply
-	msgAssistantReply models.Message
 	// sent when a conversation is (re)loaded
 	msgConversationLoaded *models.Conversation
-	// sent when a new conversation title is set
-	msgConversationTitleChanged string
 	// send when a conversation's messages are laoded
 	msgMessagesLoaded []models.Message
 	// sent when an error occurs
@@ -88,13 +67,10 @@ type (
 
 // styles
 var (
-	userStyle      = lipgloss.NewStyle().Faint(true).Bold(true).Foreground(lipgloss.Color("10"))
-	assistantStyle = lipgloss.NewStyle().Faint(true).Bold(true).Foreground(lipgloss.Color("12"))
-	messageStyle   = lipgloss.NewStyle().PaddingLeft(1)
-	headerStyle    = lipgloss.NewStyle().
-			Background(lipgloss.Color("0"))
-	contentStyle = lipgloss.NewStyle().
-			Padding(1)
+	inputStyle     = lipgloss.NewStyle().Foreground(lipgloss.Color("#ff0000"))
+	contentStyle   = lipgloss.NewStyle().PaddingLeft(2)
+	userStyle      = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("10"))
+	assistantStyle = lipgloss.NewStyle().Bold(true).Foreground(lipgloss.Color("12"))
 	footerStyle    = lipgloss.NewStyle().
 			BorderTop(true).
 			BorderStyle(lipgloss.NormalBorder())
@@ -103,21 +79,13 @@ var (
 func (m model) Init() tea.Cmd {
 	return tea.Batch(
 		textarea.Blink,
-		m.spinner.Tick,
 		m.loadConversation(m.convShortname),
-		m.waitForChunk(),
-		m.waitForReply(),
+		waitForChunk(m.replyChan),
 	)
 }
 
-func wrapError(err error) tea.Cmd {
-	return func() tea.Msg {
-		return msgError(err)
-	}
-}
-
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	var cmds []tea.Cmd
+	var cmd tea.Cmd
 
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
@@ -128,8 +96,6 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			} else {
 				return m, tea.Quit
 			}
-		case "ctrl+p":
-			m.persistence = !m.persistence
 		case "q":
 			if m.focus != focusInput {
 				return m, tea.Quit
@@ -147,256 +113,70 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			}
 		}
 	case tea.WindowSizeMsg:
-		m.width = msg.Width
-		m.height = msg.Height
 		m.content.Width = msg.Width
-		m.content.Height = msg.Height - m.getFixedComponentHeight()
+		m.content.Height = msg.Height - m.input.Height() - lipgloss.Height(m.footerView())
 		m.input.SetWidth(msg.Width - 1)
 		m.updateContent()
 	case msgConversationLoaded:
-		m.conversation = (*models.Conversation)(msg)
-		cmds = append(cmds, m.loadMessages(m.conversation))
+		c := (*models.Conversation)(msg)
+		cmd = m.loadMessages(c)
 	case msgMessagesLoaded:
-		m.setMessages(msg)
+		m.messages = []models.Message(msg)
 		m.updateContent()
 	case msgResponseChunk:
 		chunk := string(msg)
-		last := len(m.messages) - 1
-		if last >= 0 && m.messages[last].Role == models.MessageRoleAssistant {
-			m.setMessageContents(last, m.messages[last].Content+chunk)
-		} else {
-			m.addMessage(models.Message{
+		if len(m.messages) > 0 {
+			i := len(m.messages) - 1
+			switch m.messages[i].Role {
+			case models.MessageRoleAssistant:
+				m.messages[i].Content += chunk
+			default:
+				m.messages = append(m.messages, models.Message{
 					Role:    models.MessageRoleAssistant,
 					Content: chunk,
 				})
 			}
 			m.updateContent()
-		cmds = append(cmds, m.waitForChunk()) // wait for the next chunk
-	case msgAssistantReply:
-		// the last reply that was being worked on is finished
-		reply := models.Message(msg)
-		last := len(m.messages) - 1
-		if last < 0 {
-			panic("Unexpected messages length handling msgReply")
 		}
-		if reply.Role == models.MessageRoleToolCall && m.messages[last].Role == models.MessageRoleAssistant {
-			m.setMessage(last, reply)
-		} else if reply.Role != models.MessageRoleAssistant {
-			m.addMessage(reply)
-		}
-
-		if m.persistence {
-			var err error
-			if m.conversation.ID == 0 {
-				err = m.ctx.Store.SaveConversation(m.conversation)
-			}
-			if err != nil {
-				cmds = append(cmds, wrapError(err))
-			} else {
-				cmds = append(cmds, m.persistRecentMessages())
-			}
-		}
-
-		if m.conversation.Title == "" {
-			cmds = append(cmds, m.generateConversationTitle())
-		}
-
-		m.updateContent()
-		cmds = append(cmds, m.waitForReply())
+		cmd = waitForChunk(m.replyChan) // wait for the next chunk
 	case msgResponseEnd:
 		m.replyCancelFunc = nil
 		m.waitingForReply = false
 		m.status = "Press ctrl+s to send"
-	case msgResponseError:
-		m.replyCancelFunc = nil
-		m.waitingForReply = false
-		m.status = "Press ctrl+s to send"
-		m.err = error(msg)
-	case msgConversationTitleChanged:
-		title := string(msg)
-		m.conversation.Title = title
-		if m.persistence {
-			err := m.ctx.Store.SaveConversation(m.conversation)
-			if err != nil {
-				cmds = append(cmds, wrapError(err))
-			}
-		}
-	case msgError:
-		m.err = error(msg)
 	}
 
-
-	var cmd tea.Cmd
-	m.spinner, cmd = m.spinner.Update(msg)
 	if cmd != nil {
-		cmds = append(cmds, cmd)
+		return m, cmd
 	}
 
-	inputCaptured := false
 	m.input, cmd = m.input.Update(msg)
 	if cmd != nil {
-		inputCaptured = true
-		cmds = append(cmds, cmd)
+		return m, cmd
 	}
 
-	if !inputCaptured {
 	m.content, cmd = m.content.Update(msg)
 	if cmd != nil {
-			cmds = append(cmds, cmd)
-		}
+		return m, cmd
 	}
 
-	return m, tea.Batch(cmds...)
+	return m, cmd
 }
 
 func (m model) View() string {
-	if m.content.Width == 0 {
-		// this is the case upon initial startup, but it's also a safe bet that
-		// we can just skip rendering if the terminal is really 0 width...
-		// without this, the below view functions may do weird things
-		return ""
-	}
-
-	m.content.Height = m.height - m.getFixedComponentHeight()
-
-	sections := make([]string, 0, 6)
-	error := m.errorView()
-	scrollbar := m.scrollbarView()
-	sections = append(sections, m.headerView())
-	if scrollbar != "" {
-		sections = append(sections, scrollbar)
-	}
-	sections = append(sections, m.contentView())
-	if error != "" {
-		sections = append(sections, error)
-	}
-	sections = append(sections, m.inputView())
-	sections = append(sections, m.footerView())
-
 	return lipgloss.JoinVertical(
 		lipgloss.Left,
-		sections...,
+		m.content.View(),
+		m.inputView(),
+		m.footerView(),
 	)
 }
 
-func (m *model) getFixedComponentHeight() int {
-	h := 0
-	h += m.input.Height()
-	h += lipgloss.Height(m.headerView())
-	h += lipgloss.Height(m.footerView())
-	scrollbar := m.scrollbarView()
-	if scrollbar != "" {
-		h += lipgloss.Height(scrollbar)
-	}
-	errorView := m.errorView()
-	if errorView != "" {
-		h += lipgloss.Height(errorView)
-	}
-	return h
-}
-
-func (m *model) headerView() string {
-	titleStyle := lipgloss.NewStyle().
-		PaddingLeft(1).
-		PaddingRight(1).
-		Bold(true)
-	var title string
-	if m.conversation != nil && m.conversation.Title != "" {
-		title = m.conversation.Title
-	} else {
-		title = "Untitled"
-	}
-	part := titleStyle.Render(title)
-
-	return headerStyle.Width(m.width).Render(part)
-}
-
-func (m *model) contentView() string {
-	return m.content.View()
-}
-
-func (m *model) errorView() string {
-	if m.err == nil {
-		return ""
-	}
-	return lipgloss.NewStyle().
-		Width(m.width).
-		AlignHorizontal(lipgloss.Center).
-		Bold(true).
-		Foreground(lipgloss.Color("1")).
-		Render(fmt.Sprintf("%s", m.err))
-}
-
-func (m *model) scrollbarView() string {
-	if m.content.AtTop() {
-		return ""
-	}
-
-	count := int(m.content.ScrollPercent() * float64(m.width-2))
-	fill := strings.Repeat("-", count)
-	return lipgloss.NewStyle().
-		Width(m.width).
-		PaddingLeft(1).
-		PaddingRight(1).
-		Render(fill)
-}
-
-func (m *model) inputView() string {
-	return m.input.View()
-}
-
-func (m *model) footerView() string {
-	segmentStyle := lipgloss.NewStyle().PaddingLeft(1).PaddingRight(1).Faint(true)
-	segmentSeparator := "|"
-
-	saving := ""
-	if m.persistence {
-		saving = segmentStyle.Copy().Bold(true).Foreground(lipgloss.Color("2")).Render("✅💾")
-	} else {
-		saving = segmentStyle.Copy().Bold(true).Foreground(lipgloss.Color("1")).Render("❌💾")
-	}
-
-	status := m.status
-	if m.waitingForReply {
-		status += m.spinner.View()
-	}
-
-	leftSegments := []string{
-		saving,
-		segmentStyle.Render(status),
-	}
-	rightSegments := []string{
-		segmentStyle.Render(fmt.Sprintf("Model: %s", *m.ctx.Config.Defaults.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 {
-		ellipses := "... "
-		footer = footer[:m.width-len(ellipses)] + ellipses
-	}
-	return footerStyle.Render(footer)
-}
-
 func initialModel(ctx *lmcli.Context, convShortname string) model {
 	m := model{
 		ctx:           ctx,
 		convShortname: convShortname,
-		conversation:  &models.Conversation{},
-		persistence:   true,
 
-		replyChan:      make(chan models.Message),
-		replyChunkChan: make(chan string),
+		replyChan: make(chan string),
 	}
 
 	m.content = viewport.New(0, 0)
@@ -406,22 +186,9 @@ func initialModel(ctx *lmcli.Context, convShortname string) model {
 
 	m.input.FocusedStyle.CursorLine = lipgloss.NewStyle()
 	m.input.ShowLineNumbers = false
-	m.input.SetHeight(4)
 	m.input.Focus()
 
-	m.spinner = spinner.New(spinner.WithSpinner(
-		spinner.Spinner{
-			Frames: []string{
-				".  ",
-				".. ",
-				"...",
-				".. ",
-				".  ",
-				"   ",
-			},
-			FPS: time.Second / 3,
-		},
-	))
+	m.updateContent()
 
 	m.waitingForReply = false
 	m.status = "Press ctrl+s to send"
@@ -447,43 +214,17 @@ func (m *model) handleInputKey(msg tea.KeyMsg) tea.Cmd {
 		if strings.TrimSpace(userInput) == "" {
 			return nil
 		}
-
-		reply := models.Message{
+		m.input.SetValue("")
+		m.messages = append(m.messages, models.Message{
 			Role:    models.MessageRoleUser,
 			Content: userInput,
-		}
-
-		if m.persistence {
-			var err error
-			if m.conversation.ID == 0 {
-				err = m.ctx.Store.SaveConversation(m.conversation)
-			}
-			if err != nil {
-				return wrapError(err)
-			}
-
-			// ensure all messages up to the one we're about to add are
-			// persistent
-			cmd := m.persistRecentMessages()
-			if cmd != nil {
-				return cmd
-			}
-			// persist our new message, returning with any possible errors
-			savedReply, err := m.ctx.Store.AddReply(m.conversation, reply)
-			if err != nil {
-				return wrapError(err)
-			}
-			reply = *savedReply
-		}
-
-		m.input.SetValue("")
-		m.addMessage(reply)
+		})
 
 		m.updateContent()
 		m.content.GotoBottom()
 
 		m.waitingForReply = true
-		m.status = "Press ctrl+c to cancel"
+		m.status = "Waiting for response, press ctrl+c to cancel..."
 		return m.promptLLM()
 	}
 	return nil
@@ -496,10 +237,10 @@ func (m *model) loadConversation(shortname string) tea.Cmd {
 		}
 		c, err := m.ctx.Store.ConversationByShortName(shortname)
 		if err != nil {
-			return msgError(fmt.Errorf("Could not lookup conversation: %v", err))
+			return msgError(fmt.Errorf("Could not lookup conversation: %v\n", err))
 		}
 		if c.ID == 0 {
-			return msgError(fmt.Errorf("Conversation not found: %s", shortname))
+			return msgError(fmt.Errorf("Conversation not found with short name: %s\n", shortname))
 		}
 		return msgConversationLoaded(c)
 	}
@@ -515,25 +256,9 @@ func (m *model) loadMessages(c *models.Conversation) tea.Cmd {
 	}
 }
 
-func (m *model) waitForReply() tea.Cmd {
+func waitForChunk(ch chan string) tea.Cmd {
 	return func() tea.Msg {
-		return msgAssistantReply(<-m.replyChan)
-	}
-}
-
-func (m *model) waitForChunk() tea.Cmd {
-	return func() tea.Msg {
-		return msgResponseChunk(<-m.replyChunkChan)
-	}
-}
-
-func (m *model) generateConversationTitle() tea.Cmd {
-	return func() tea.Msg {
-		title, err := cmdutil.GenerateTitle(m.ctx, m.conversation)
-		if err != nil {
-			return msgError(err)
-		}
-		return msgConversationTitleChanged(title)
+		return msgResponseChunk(<-ch)
 	}
 }
 
@@ -544,130 +269,80 @@ func (m *model) promptLLM() tea.Cmd {
 			return msgError(err)
 		}
 
+		var toolBag []models.Tool
+		for _, toolName := range *m.ctx.Config.Tools.EnabledTools {
+			tool, ok := tools.AvailableTools[toolName]
+			if ok {
+				toolBag = append(toolBag, tool)
+			}
+		}
+
 		requestParams := models.RequestParameters{
 			Model:       *m.ctx.Config.Defaults.Model,
 			MaxTokens:   *m.ctx.Config.Defaults.MaxTokens,
 			Temperature: *m.ctx.Config.Defaults.Temperature,
-			ToolBag:     m.ctx.EnabledTools,
-		}
-
-		replyHandler := func(msg models.Message) {
-			m.replyChan <- msg
+			ToolBag:     toolBag,
 		}
 
 		ctx, replyCancelFunc := context.WithCancel(context.Background())
 		m.replyCancelFunc = replyCancelFunc
 
-		resp, err := completionProvider.CreateChatCompletionStream(
-			ctx, requestParams, m.messages, replyHandler, m.replyChunkChan,
+		// TODO: supply a reply callback and handle error
+		resp, _ := completionProvider.CreateChatCompletionStream(
+			ctx, requestParams, m.messages, nil, m.replyChan,
 		)
 
-		if err != nil {
-			return msgResponseError(err)
-		}
 		return msgResponseEnd(resp)
 	}
 }
 
-func (m *model) persistRecentMessages() tea.Cmd {
-	for i, msg := range m.messages {
-		if msg.ID > 0 {
-			continue
-		}
-		newMessage, err := m.ctx.Store.AddReply(m.conversation, msg)
-		if err != nil {
-			return wrapError(err)
-		}
-		m.setMessage(i, *newMessage)
-	}
-	return nil
-}
-
-func (m *model) setMessages(messages []models.Message) {
-	m.messages = messages
-	m.highlightCache = make([]string, len(messages))
-	for i, msg := range m.messages {
-		highlighted, _ := m.ctx.Chroma.HighlightS(msg.Content)
-		m.highlightCache[i] = highlighted
-	}
-}
-
-func (m *model) setMessage(i int, msg models.Message) {
-	if i >= len(m.messages) {
-		panic("i out of range")
-	}
-	highlighted, _ := m.ctx.Chroma.HighlightS(msg.Content)
-	m.messages[i] = msg
-	m.highlightCache[i] = highlighted
-}
-
-func (m *model) addMessage(msg models.Message) {
-	highlighted, _ := m.ctx.Chroma.HighlightS(msg.Content)
-	m.messages = append(m.messages, msg)
-	m.highlightCache = append(m.highlightCache, highlighted)
-}
-
-func (m *model) setMessageContents(i int, content string) {
-	if i >= len(m.messages) {
-		panic("i out of range")
-	}
-	highlighted, _ := m.ctx.Chroma.HighlightS(content)
-	m.messages[i].Content = content
-	m.highlightCache[i] = highlighted
-}
-
-// render the conversation into the main viewport
 func (m *model) updateContent() {
 	sb := strings.Builder{}
 	msgCnt := len(m.messages)
 	for i, message := range m.messages {
-		icon := "⚙️"
-		friendly := message.Role.FriendlyRole()
-		style := lipgloss.NewStyle().Bold(true).Faint(true)
-
-		switch message.Role {
-		case models.MessageRoleUser:
-			icon = ""
+		var style lipgloss.Style
+		if message.Role == models.MessageRoleUser {
 			style = userStyle
-		case models.MessageRoleAssistant:
-			icon = ""
-			style = assistantStyle
-		case models.MessageRoleToolCall:
-		case models.MessageRoleToolResult:
-			icon = "🔧"
-		}
-
-		var saved string
-		if message.ID == 0 {
-			saved = lipgloss.NewStyle().Faint(true).Render(" (not saved)")
-		}
-
-		// write message heading with space for content
-		header := fmt.Sprintf("%s\n\n", style.Render(icon+friendly)+saved)
-		sb.WriteString(header)
-
-		// TODO: special rendering for tool calls/results?
-
-		// write message contents
-		var highlighted string
-		if m.highlightCache[i] == "" {
-			highlighted = message.Content
 		} else {
-			highlighted = m.highlightCache[i]
+			style = assistantStyle
 		}
-		contents := messageStyle.Width(m.content.Width - 5).Render(highlighted)
-		sb.WriteString(contents)
 
+		sb.WriteString(fmt.Sprintf("%s:\n\n", style.Render(string(message.Role.FriendlyRole()))))
+
+		highlighted, _ := m.ctx.Chroma.HighlightS(message.Content)
+		sb.WriteString(contentStyle.Width(m.content.Width - 5).Render(highlighted))
 		if i < msgCnt-1 {
 			sb.WriteString("\n\n")
 		}
 	}
-	atBottom := m.content.AtBottom()
-	m.content.SetContent(contentStyle.Render(sb.String()))
-	if atBottom {
-		// if we were at bottom before the update, scroll with the output
-		m.content.GotoBottom()
+	m.content.SetContent(sb.String())
 }
+
+func (m model) inputView() string {
+	var inputView string
+	if m.waitingForReply {
+		inputView = inputStyle.Faint(true).Render(m.input.View())
+	} else {
+		inputView = inputStyle.Render(m.input.View())
+	}
+	return inputView
+}
+
+func (m model) footerView() string {
+	left := m.status
+	right := fmt.Sprintf("Model: %s", *m.ctx.Config.Defaults.Model)
+
+	totalWidth := lipgloss.Width(left + right)
+	var padding string
+	if m.content.Width-totalWidth > 0 {
+		padding = strings.Repeat(" ", m.content.Width-totalWidth)
+	} else {
+		padding = ""
+	}
+
+	footer := lipgloss.JoinHorizontal(lipgloss.Center, left, padding, right)
+
+	return footerStyle.Width(m.content.Width).Render(footer)
 }
 
 func Launch(ctx *lmcli.Context, convShortname string) error {