app.go 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409
  1. package app
  2. import (
  3. "context"
  4. "fmt"
  5. "path/filepath"
  6. "sort"
  7. "strings"
  8. "time"
  9. "log/slog"
  10. tea "github.com/charmbracelet/bubbletea/v2"
  11. "github.com/sst/opencode-sdk-go"
  12. "github.com/sst/opencode/internal/commands"
  13. "github.com/sst/opencode/internal/components/toast"
  14. "github.com/sst/opencode/internal/config"
  15. "github.com/sst/opencode/internal/styles"
  16. "github.com/sst/opencode/internal/theme"
  17. "github.com/sst/opencode/internal/util"
  18. )
  19. type App struct {
  20. Info opencode.App
  21. Version string
  22. StatePath string
  23. Config *opencode.Config
  24. Client *opencode.Client
  25. State *config.State
  26. Provider *opencode.Provider
  27. Model *opencode.Model
  28. Session *opencode.Session
  29. Messages []opencode.Message
  30. Commands commands.CommandRegistry
  31. }
  32. type SessionSelectedMsg = *opencode.Session
  33. type SessionLoadedMsg struct{}
  34. type ModelSelectedMsg struct {
  35. Provider opencode.Provider
  36. Model opencode.Model
  37. }
  38. type SessionClearedMsg struct{}
  39. type CompactSessionMsg struct{}
  40. type SendMsg struct {
  41. Text string
  42. Attachments []Attachment
  43. }
  44. type CompletionDialogTriggeredMsg struct {
  45. InitialValue string
  46. }
  47. type OptimisticMessageAddedMsg struct {
  48. Message opencode.Message
  49. }
  50. type FileRenderedMsg struct {
  51. FilePath string
  52. }
  53. func New(
  54. ctx context.Context,
  55. version string,
  56. appInfo opencode.App,
  57. httpClient *opencode.Client,
  58. ) (*App, error) {
  59. util.RootPath = appInfo.Path.Root
  60. util.CwdPath = appInfo.Path.Cwd
  61. configInfo, err := httpClient.Config.Get(ctx)
  62. if err != nil {
  63. return nil, err
  64. }
  65. if configInfo.Keybinds.Leader == "" {
  66. configInfo.Keybinds.Leader = "ctrl+x"
  67. }
  68. appStatePath := filepath.Join(appInfo.Path.State, "tui")
  69. appState, err := config.LoadState(appStatePath)
  70. if err != nil {
  71. appState = config.NewState()
  72. config.SaveState(appStatePath, appState)
  73. }
  74. if configInfo.Theme != "" {
  75. appState.Theme = configInfo.Theme
  76. }
  77. if configInfo.Model != "" {
  78. splits := strings.Split(configInfo.Model, "/")
  79. appState.Provider = splits[0]
  80. appState.Model = strings.Join(splits[1:], "/")
  81. }
  82. if err := theme.LoadThemesFromDirectories(
  83. appInfo.Path.Config,
  84. appInfo.Path.Root,
  85. appInfo.Path.Cwd,
  86. ); err != nil {
  87. slog.Warn("Failed to load themes from directories", "error", err)
  88. }
  89. if appState.Theme != "" {
  90. if appState.Theme == "system" && styles.Terminal != nil {
  91. theme.UpdateSystemTheme(
  92. styles.Terminal.Background,
  93. styles.Terminal.BackgroundIsDark,
  94. )
  95. }
  96. theme.SetTheme(appState.Theme)
  97. }
  98. slog.Debug("Loaded config", "config", configInfo)
  99. app := &App{
  100. Info: appInfo,
  101. Version: version,
  102. StatePath: appStatePath,
  103. Config: configInfo,
  104. State: appState,
  105. Client: httpClient,
  106. Session: &opencode.Session{},
  107. Messages: []opencode.Message{},
  108. Commands: commands.LoadFromConfig(configInfo),
  109. }
  110. return app, nil
  111. }
  112. func (a *App) Key(commandName commands.CommandName) string {
  113. t := theme.CurrentTheme()
  114. base := styles.NewStyle().Background(t.Background()).Foreground(t.Text()).Bold(true).Render
  115. muted := styles.NewStyle().Background(t.Background()).Foreground(t.TextMuted()).Faint(true).Render
  116. command := a.Commands[commandName]
  117. kb := command.Keybindings[0]
  118. key := kb.Key
  119. if kb.RequiresLeader {
  120. key = a.Config.Keybinds.Leader + " " + kb.Key
  121. }
  122. return base(key) + muted(" "+command.Description)
  123. }
  124. func (a *App) InitializeProvider() tea.Cmd {
  125. return func() tea.Msg {
  126. providersResponse, err := a.Client.Config.Providers(context.Background())
  127. if err != nil {
  128. slog.Error("Failed to list providers", "error", err)
  129. // TODO: notify user
  130. return nil
  131. }
  132. providers := providersResponse.Providers
  133. var defaultProvider *opencode.Provider
  134. var defaultModel *opencode.Model
  135. var anthropic *opencode.Provider
  136. for _, provider := range providers {
  137. if provider.ID == "anthropic" {
  138. anthropic = &provider
  139. }
  140. }
  141. // default to anthropic if available
  142. if anthropic != nil {
  143. defaultProvider = anthropic
  144. defaultModel = getDefaultModel(providersResponse, *anthropic)
  145. }
  146. for _, provider := range providers {
  147. if defaultProvider == nil || defaultModel == nil {
  148. defaultProvider = &provider
  149. defaultModel = getDefaultModel(providersResponse, provider)
  150. }
  151. providers = append(providers, provider)
  152. }
  153. if len(providers) == 0 {
  154. slog.Error("No providers configured")
  155. return nil
  156. }
  157. var currentProvider *opencode.Provider
  158. var currentModel *opencode.Model
  159. for _, provider := range providers {
  160. if provider.ID == a.State.Provider {
  161. currentProvider = &provider
  162. for _, model := range provider.Models {
  163. if model.ID == a.State.Model {
  164. currentModel = &model
  165. }
  166. }
  167. }
  168. }
  169. if currentProvider == nil || currentModel == nil {
  170. currentProvider = defaultProvider
  171. currentModel = defaultModel
  172. }
  173. return ModelSelectedMsg{
  174. Provider: *currentProvider,
  175. Model: *currentModel,
  176. }
  177. }
  178. }
  179. func getDefaultModel(response *opencode.ConfigProvidersResponse, provider opencode.Provider) *opencode.Model {
  180. if match, ok := response.Default[provider.ID]; ok {
  181. model := provider.Models[match]
  182. return &model
  183. } else {
  184. for _, model := range provider.Models {
  185. return &model
  186. }
  187. }
  188. return nil
  189. }
  190. type Attachment struct {
  191. FilePath string
  192. FileName string
  193. MimeType string
  194. Content []byte
  195. }
  196. func (a *App) IsBusy() bool {
  197. if len(a.Messages) == 0 {
  198. return false
  199. }
  200. lastMessage := a.Messages[len(a.Messages)-1]
  201. return lastMessage.Metadata.Time.Completed == 0
  202. }
  203. func (a *App) SaveState() {
  204. err := config.SaveState(a.StatePath, a.State)
  205. if err != nil {
  206. slog.Error("Failed to save state", "error", err)
  207. }
  208. }
  209. func (a *App) InitializeProject(ctx context.Context) tea.Cmd {
  210. cmds := []tea.Cmd{}
  211. session, err := a.CreateSession(ctx)
  212. if err != nil {
  213. // status.Error(err.Error())
  214. return nil
  215. }
  216. a.Session = session
  217. cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))
  218. go func() {
  219. _, err := a.Client.Session.Init(ctx, a.Session.ID, opencode.SessionInitParams{
  220. ProviderID: opencode.F(a.Provider.ID),
  221. ModelID: opencode.F(a.Model.ID),
  222. })
  223. if err != nil {
  224. slog.Error("Failed to initialize project", "error", err)
  225. // status.Error(err.Error())
  226. }
  227. }()
  228. return tea.Batch(cmds...)
  229. }
  230. func (a *App) CompactSession(ctx context.Context) tea.Cmd {
  231. go func() {
  232. _, err := a.Client.Session.Summarize(ctx, a.Session.ID, opencode.SessionSummarizeParams{
  233. ProviderID: opencode.F(a.Provider.ID),
  234. ModelID: opencode.F(a.Model.ID),
  235. })
  236. if err != nil {
  237. slog.Error("Failed to compact session", "error", err)
  238. }
  239. }()
  240. return nil
  241. }
  242. func (a *App) MarkProjectInitialized(ctx context.Context) error {
  243. _, err := a.Client.App.Init(ctx)
  244. if err != nil {
  245. slog.Error("Failed to mark project as initialized", "error", err)
  246. return err
  247. }
  248. return nil
  249. }
  250. func (a *App) CreateSession(ctx context.Context) (*opencode.Session, error) {
  251. session, err := a.Client.Session.New(ctx)
  252. if err != nil {
  253. return nil, err
  254. }
  255. return session, nil
  256. }
  257. func (a *App) SendChatMessage(ctx context.Context, text string, attachments []Attachment) tea.Cmd {
  258. var cmds []tea.Cmd
  259. if a.Session.ID == "" {
  260. session, err := a.CreateSession(ctx)
  261. if err != nil {
  262. return toast.NewErrorToast(err.Error())
  263. }
  264. a.Session = session
  265. cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))
  266. }
  267. optimisticMessage := opencode.Message{
  268. ID: fmt.Sprintf("optimistic-%d", time.Now().UnixNano()),
  269. Role: opencode.MessageRoleUser,
  270. Parts: []opencode.MessagePart{{
  271. Type: opencode.MessagePartTypeText,
  272. Text: text,
  273. }},
  274. Metadata: opencode.MessageMetadata{
  275. SessionID: a.Session.ID,
  276. Time: opencode.MessageMetadataTime{
  277. Created: float64(time.Now().Unix()),
  278. },
  279. },
  280. }
  281. a.Messages = append(a.Messages, optimisticMessage)
  282. cmds = append(cmds, util.CmdHandler(OptimisticMessageAddedMsg{Message: optimisticMessage}))
  283. cmds = append(cmds, func() tea.Msg {
  284. _, err := a.Client.Session.Chat(ctx, a.Session.ID, opencode.SessionChatParams{
  285. Parts: opencode.F([]opencode.MessagePartUnionParam{
  286. opencode.TextPartParam{
  287. Type: opencode.F(opencode.TextPartTypeText),
  288. Text: opencode.F(text),
  289. },
  290. }),
  291. ProviderID: opencode.F(a.Provider.ID),
  292. ModelID: opencode.F(a.Model.ID),
  293. })
  294. if err != nil {
  295. errormsg := fmt.Sprintf("failed to send message: %v", err)
  296. slog.Error(errormsg)
  297. return toast.NewErrorToast(errormsg)()
  298. }
  299. return nil
  300. })
  301. // The actual response will come through SSE
  302. // For now, just return success
  303. return tea.Batch(cmds...)
  304. }
  305. func (a *App) Cancel(ctx context.Context, sessionID string) error {
  306. _, err := a.Client.Session.Abort(ctx, sessionID)
  307. if err != nil {
  308. slog.Error("Failed to cancel session", "error", err)
  309. // status.Error(err.Error())
  310. return err
  311. }
  312. return nil
  313. }
  314. func (a *App) ListSessions(ctx context.Context) ([]opencode.Session, error) {
  315. response, err := a.Client.Session.List(ctx)
  316. if err != nil {
  317. return nil, err
  318. }
  319. if response == nil {
  320. return []opencode.Session{}, nil
  321. }
  322. sessions := *response
  323. sort.Slice(sessions, func(i, j int) bool {
  324. return sessions[i].Time.Created-sessions[j].Time.Created > 0
  325. })
  326. return sessions, nil
  327. }
  328. func (a *App) DeleteSession(ctx context.Context, sessionID string) error {
  329. _, err := a.Client.Session.Delete(ctx, sessionID)
  330. if err != nil {
  331. slog.Error("Failed to delete session", "error", err)
  332. return err
  333. }
  334. return nil
  335. }
  336. func (a *App) ListMessages(ctx context.Context, sessionId string) ([]opencode.Message, error) {
  337. response, err := a.Client.Session.Messages(ctx, sessionId)
  338. if err != nil {
  339. return nil, err
  340. }
  341. if response == nil {
  342. return []opencode.Message{}, nil
  343. }
  344. messages := *response
  345. return messages, nil
  346. }
  347. func (a *App) ListProviders(ctx context.Context) ([]opencode.Provider, error) {
  348. response, err := a.Client.Config.Providers(ctx)
  349. if err != nil {
  350. return nil, err
  351. }
  352. if response == nil {
  353. return []opencode.Provider{}, nil
  354. }
  355. providers := *response
  356. return providers.Providers, nil
  357. }
  358. // func (a *App) loadCustomKeybinds() {
  359. //
  360. // }