lmcli/pkg/tui/views/chat/cmds.go

package chat

import (
	"time"

	"git.mlow.ca/mlow/lmcli/pkg/api"
	"git.mlow.ca/mlow/lmcli/pkg/tui/model"
	"git.mlow.ca/mlow/lmcli/pkg/tui/shared"
	tea "github.com/charmbracelet/bubbletea"
)

func (m *Model) waitForResponseChunk() tea.Cmd {
	return func() tea.Msg {
		return msgChatResponseChunk(<-m.chatReplyChunks)
	}
}

func (m *Model) loadConversationMessages() tea.Cmd {
	return func() tea.Msg {
		messages, err := m.App.LoadConversationMessages()
		if err != nil {
			return shared.AsMsgError(err)
		}
		rootMessages, err := m.App.LoadConversationRootMessages()
		if err != nil {
			return shared.AsMsgError(err)
		}
		return msgConversationMessagesLoaded{
			messages, rootMessages,
		}
	}
}

func (m *Model) generateConversationTitle() tea.Cmd {
	return func() tea.Msg {
		title, err := m.App.GenerateConversationTitle(m.App.Messages)
		if err != nil {
			return shared.AsMsgError(err)
		}
		return msgConversationTitleGenerated(title)
	}
}

func (m *Model) updateConversationTitle(conversation *api.Conversation) tea.Cmd {
	return func() tea.Msg {
		err := m.App.UpdateConversationTitle(conversation)
		if err != nil {
			return shared.WrapError(err)
		}
		return nil
	}
}

func (m *Model) cloneMessage(message api.Message, selected bool) tea.Cmd {
	return func() tea.Msg {
		msg, err := m.App.CloneMessage(message, selected)
		if err != nil {
			return shared.WrapError(err)
		}
		return msgMessageCloned(msg)
	}
}

func (m *Model) updateMessageContent(message *api.Message) tea.Cmd {
	return func() tea.Msg {
		err := m.App.UpdateMessageContent(message)
		if err != nil {
			return shared.WrapError(err)
		}
		return msgMessageUpdated(message)
	}
}

func (m *Model) cycleSelectedRoot(conv *api.Conversation, dir model.MessageCycleDirection) tea.Cmd {
	if len(m.App.RootMessages) < 2 {

		return nil
	}

	return func() tea.Msg {
		nextRoot, err := m.App.CycleSelectedRoot(conv, m.App.RootMessages, dir)
		if err != nil {
			return shared.WrapError(err)
		}
		return msgSelectedRootCycled(nextRoot)
	}
}

func (m *Model) cycleSelectedReply(message *api.Message, dir model.MessageCycleDirection) tea.Cmd {
	if len(message.Replies) < 2 {
		return nil
	}

	return func() tea.Msg {
		nextReply, err := m.App.CycleSelectedReply(message, dir)
		if err != nil {
			return shared.WrapError(err)
		}
		return msgSelectedReplyCycled(nextReply)
	}
}

func (m *Model) persistConversation() tea.Cmd {
	return func() tea.Msg {
		conversation, messages, err := m.App.PersistConversation(m.App.Conversation, m.App.Messages)
		if err != nil {
			return shared.AsMsgError(err)
		}
		return msgConversationPersisted{conversation.ID == 0, conversation, messages}
	}
}

func (m *Model) executeToolCalls(toolCalls []api.ToolCall) tea.Cmd {
	return func() tea.Msg {
		results, err := m.App.ExecuteToolCalls(toolCalls)
		if err != nil {
			return shared.AsMsgError(err)
		}
		return msgToolResults(results)
	}
}

func (m *Model) promptLLM() tea.Cmd {
	m.state = pendingResponse
	m.replyCursor.Blink = false

	m.startTime = time.Now()
	m.elapsed = 0
	m.tokenCount = 0

	return func() tea.Msg {
		resp, err := m.App.PromptLLM(m.App.Messages, m.chatReplyChunks, m.stopSignal)
		if err != nil {
			return msgChatResponseError{ Err: err }
		}
		return msgChatResponse(resp)
	}
}