app.go 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617
  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/clipboard"
  13. "github.com/sst/opencode/internal/commands"
  14. "github.com/sst/opencode/internal/components/toast"
  15. "github.com/sst/opencode/internal/config"
  16. "github.com/sst/opencode/internal/id"
  17. "github.com/sst/opencode/internal/styles"
  18. "github.com/sst/opencode/internal/theme"
  19. "github.com/sst/opencode/internal/util"
  20. )
  21. type Message struct {
  22. Info opencode.MessageUnion
  23. Parts []opencode.PartUnion
  24. }
  25. type App struct {
  26. Info opencode.App
  27. Modes []opencode.Mode
  28. Providers []opencode.Provider
  29. Version string
  30. StatePath string
  31. Config *opencode.Config
  32. Client *opencode.Client
  33. State *config.State
  34. ModeIndex int
  35. Mode *opencode.Mode
  36. Provider *opencode.Provider
  37. Model *opencode.Model
  38. Session *opencode.Session
  39. Messages []Message
  40. Commands commands.CommandRegistry
  41. InitialModel *string
  42. InitialPrompt *string
  43. IntitialMode *string
  44. compactCancel context.CancelFunc
  45. IsLeaderSequence bool
  46. }
  47. type SessionSelectedMsg = *opencode.Session
  48. type SessionLoadedMsg struct{}
  49. type ModelSelectedMsg struct {
  50. Provider opencode.Provider
  51. Model opencode.Model
  52. }
  53. type SessionClearedMsg struct{}
  54. type CompactSessionMsg struct{}
  55. type SendMsg struct {
  56. Text string
  57. Attachments []opencode.FilePartParam
  58. }
  59. type SetEditorContentMsg struct {
  60. Text string
  61. }
  62. type OptimisticMessageAddedMsg struct {
  63. Message opencode.MessageUnion
  64. }
  65. type FileRenderedMsg struct {
  66. FilePath string
  67. }
  68. func New(
  69. ctx context.Context,
  70. version string,
  71. appInfo opencode.App,
  72. modes []opencode.Mode,
  73. httpClient *opencode.Client,
  74. initialModel *string,
  75. initialPrompt *string,
  76. initialMode *string,
  77. ) (*App, error) {
  78. util.RootPath = appInfo.Path.Root
  79. util.CwdPath = appInfo.Path.Cwd
  80. configInfo, err := httpClient.Config.Get(ctx)
  81. if err != nil {
  82. return nil, err
  83. }
  84. if configInfo.Keybinds.Leader == "" {
  85. configInfo.Keybinds.Leader = "ctrl+x"
  86. }
  87. appStatePath := filepath.Join(appInfo.Path.State, "tui")
  88. appState, err := config.LoadState(appStatePath)
  89. if err != nil {
  90. appState = config.NewState()
  91. config.SaveState(appStatePath, appState)
  92. }
  93. if appState.ModeModel == nil {
  94. appState.ModeModel = make(map[string]config.ModeModel)
  95. }
  96. if configInfo.Theme != "" {
  97. appState.Theme = configInfo.Theme
  98. }
  99. var modeIndex int
  100. var mode *opencode.Mode
  101. modeName := "build"
  102. if appState.Mode != "" {
  103. modeName = appState.Mode
  104. }
  105. if initialMode != nil && *initialMode != "" {
  106. modeName = *initialMode
  107. }
  108. for i, m := range modes {
  109. if m.Name == modeName {
  110. modeIndex = i
  111. break
  112. }
  113. }
  114. mode = &modes[modeIndex]
  115. if mode.Model.ModelID != "" {
  116. appState.ModeModel[mode.Name] = config.ModeModel{
  117. ProviderID: mode.Model.ProviderID,
  118. ModelID: mode.Model.ModelID,
  119. }
  120. }
  121. if err := theme.LoadThemesFromDirectories(
  122. appInfo.Path.Config,
  123. appInfo.Path.Root,
  124. appInfo.Path.Cwd,
  125. ); err != nil {
  126. slog.Warn("Failed to load themes from directories", "error", err)
  127. }
  128. if appState.Theme != "" {
  129. if appState.Theme == "system" && styles.Terminal != nil {
  130. theme.UpdateSystemTheme(
  131. styles.Terminal.Background,
  132. styles.Terminal.BackgroundIsDark,
  133. )
  134. }
  135. theme.SetTheme(appState.Theme)
  136. }
  137. slog.Debug("Loaded config", "config", configInfo)
  138. app := &App{
  139. Info: appInfo,
  140. Modes: modes,
  141. Version: version,
  142. StatePath: appStatePath,
  143. Config: configInfo,
  144. State: appState,
  145. Client: httpClient,
  146. ModeIndex: modeIndex,
  147. Mode: mode,
  148. Session: &opencode.Session{},
  149. Messages: []Message{},
  150. Commands: commands.LoadFromConfig(configInfo),
  151. InitialModel: initialModel,
  152. InitialPrompt: initialPrompt,
  153. IntitialMode: initialMode,
  154. }
  155. return app, nil
  156. }
  157. func (a *App) Key(commandName commands.CommandName) string {
  158. t := theme.CurrentTheme()
  159. base := styles.NewStyle().Background(t.Background()).Foreground(t.Text()).Bold(true).Render
  160. muted := styles.NewStyle().
  161. Background(t.Background()).
  162. Foreground(t.TextMuted()).
  163. Faint(true).
  164. Render
  165. command := a.Commands[commandName]
  166. kb := command.Keybindings[0]
  167. key := kb.Key
  168. if kb.RequiresLeader {
  169. key = a.Config.Keybinds.Leader + " " + kb.Key
  170. }
  171. return base(key) + muted(" "+command.Description)
  172. }
  173. func (a *App) SetClipboard(text string) tea.Cmd {
  174. var cmds []tea.Cmd
  175. cmds = append(cmds, func() tea.Msg {
  176. clipboard.Write(clipboard.FmtText, []byte(text))
  177. return nil
  178. })
  179. // try to set the clipboard using OSC52 for terminals that support it
  180. cmds = append(cmds, tea.SetClipboard(text))
  181. return tea.Sequence(cmds...)
  182. }
  183. func (a *App) SwitchMode() (*App, tea.Cmd) {
  184. a.ModeIndex++
  185. if a.ModeIndex >= len(a.Modes) {
  186. a.ModeIndex = 0
  187. }
  188. a.Mode = &a.Modes[a.ModeIndex]
  189. modelID := a.Mode.Model.ModelID
  190. providerID := a.Mode.Model.ProviderID
  191. if modelID == "" {
  192. if model, ok := a.State.ModeModel[a.Mode.Name]; ok {
  193. modelID = model.ModelID
  194. providerID = model.ProviderID
  195. }
  196. }
  197. if modelID != "" {
  198. for _, provider := range a.Providers {
  199. if provider.ID == providerID {
  200. a.Provider = &provider
  201. for _, model := range provider.Models {
  202. if model.ID == modelID {
  203. a.Model = &model
  204. break
  205. }
  206. }
  207. break
  208. }
  209. }
  210. }
  211. a.State.Mode = a.Mode.Name
  212. return a, func() tea.Msg {
  213. a.SaveState()
  214. return nil
  215. }
  216. }
  217. func (a *App) InitializeProvider() tea.Cmd {
  218. providersResponse, err := a.Client.Config.Providers(context.Background())
  219. if err != nil {
  220. slog.Error("Failed to list providers", "error", err)
  221. // TODO: notify user
  222. return nil
  223. }
  224. providers := providersResponse.Providers
  225. var defaultProvider *opencode.Provider
  226. var defaultModel *opencode.Model
  227. var anthropic *opencode.Provider
  228. for _, provider := range providers {
  229. if provider.ID == "anthropic" {
  230. anthropic = &provider
  231. }
  232. }
  233. // default to anthropic if available
  234. if anthropic != nil {
  235. defaultProvider = anthropic
  236. defaultModel = getDefaultModel(providersResponse, *anthropic)
  237. }
  238. for _, provider := range providers {
  239. if defaultProvider == nil || defaultModel == nil {
  240. defaultProvider = &provider
  241. defaultModel = getDefaultModel(providersResponse, provider)
  242. }
  243. providers = append(providers, provider)
  244. }
  245. if len(providers) == 0 {
  246. slog.Error("No providers configured")
  247. return nil
  248. }
  249. a.Providers = providers
  250. // retains backwards compatibility with old state format
  251. if model, ok := a.State.ModeModel[a.State.Mode]; ok {
  252. a.State.Provider = model.ProviderID
  253. a.State.Model = model.ModelID
  254. }
  255. var currentProvider *opencode.Provider
  256. var currentModel *opencode.Model
  257. for _, provider := range providers {
  258. if provider.ID == a.State.Provider {
  259. currentProvider = &provider
  260. for _, model := range provider.Models {
  261. if model.ID == a.State.Model {
  262. currentModel = &model
  263. }
  264. }
  265. }
  266. }
  267. if currentProvider == nil || currentModel == nil {
  268. currentProvider = defaultProvider
  269. currentModel = defaultModel
  270. }
  271. var initialProvider *opencode.Provider
  272. var initialModel *opencode.Model
  273. if a.InitialModel != nil && *a.InitialModel != "" {
  274. splits := strings.Split(*a.InitialModel, "/")
  275. for _, provider := range providers {
  276. if provider.ID == splits[0] {
  277. initialProvider = &provider
  278. for _, model := range provider.Models {
  279. modelID := strings.Join(splits[1:], "/")
  280. if model.ID == modelID {
  281. initialModel = &model
  282. }
  283. }
  284. }
  285. }
  286. }
  287. if initialProvider != nil && initialModel != nil {
  288. currentProvider = initialProvider
  289. currentModel = initialModel
  290. }
  291. var cmds []tea.Cmd
  292. cmds = append(cmds, util.CmdHandler(ModelSelectedMsg{
  293. Provider: *currentProvider,
  294. Model: *currentModel,
  295. }))
  296. if a.InitialPrompt != nil && *a.InitialPrompt != "" {
  297. cmds = append(cmds, util.CmdHandler(SendMsg{Text: *a.InitialPrompt}))
  298. }
  299. return tea.Sequence(cmds...)
  300. }
  301. func getDefaultModel(
  302. response *opencode.ConfigProvidersResponse,
  303. provider opencode.Provider,
  304. ) *opencode.Model {
  305. if match, ok := response.Default[provider.ID]; ok {
  306. model := provider.Models[match]
  307. return &model
  308. } else {
  309. for _, model := range provider.Models {
  310. return &model
  311. }
  312. }
  313. return nil
  314. }
  315. func (a *App) IsBusy() bool {
  316. if len(a.Messages) == 0 {
  317. return false
  318. }
  319. lastMessage := a.Messages[len(a.Messages)-1]
  320. if casted, ok := lastMessage.Info.(opencode.AssistantMessage); ok {
  321. return casted.Time.Completed == 0
  322. }
  323. return false
  324. }
  325. func (a *App) SaveState() {
  326. err := config.SaveState(a.StatePath, a.State)
  327. if err != nil {
  328. slog.Error("Failed to save state", "error", err)
  329. }
  330. }
  331. func (a *App) InitializeProject(ctx context.Context) tea.Cmd {
  332. cmds := []tea.Cmd{}
  333. session, err := a.CreateSession(ctx)
  334. if err != nil {
  335. // status.Error(err.Error())
  336. return nil
  337. }
  338. a.Session = session
  339. cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))
  340. go func() {
  341. _, err := a.Client.Session.Init(ctx, a.Session.ID, opencode.SessionInitParams{
  342. MessageID: opencode.F(id.Ascending(id.Message)),
  343. ProviderID: opencode.F(a.Provider.ID),
  344. ModelID: opencode.F(a.Model.ID),
  345. })
  346. if err != nil {
  347. slog.Error("Failed to initialize project", "error", err)
  348. // status.Error(err.Error())
  349. }
  350. }()
  351. return tea.Batch(cmds...)
  352. }
  353. func (a *App) CompactSession(ctx context.Context) tea.Cmd {
  354. if a.compactCancel != nil {
  355. a.compactCancel()
  356. }
  357. compactCtx, cancel := context.WithCancel(ctx)
  358. a.compactCancel = cancel
  359. go func() {
  360. defer func() {
  361. a.compactCancel = nil
  362. }()
  363. _, err := a.Client.Session.Summarize(
  364. compactCtx,
  365. a.Session.ID,
  366. opencode.SessionSummarizeParams{
  367. ProviderID: opencode.F(a.Provider.ID),
  368. ModelID: opencode.F(a.Model.ID),
  369. },
  370. )
  371. if err != nil {
  372. if compactCtx.Err() != context.Canceled {
  373. slog.Error("Failed to compact session", "error", err)
  374. }
  375. }
  376. }()
  377. return nil
  378. }
  379. func (a *App) MarkProjectInitialized(ctx context.Context) error {
  380. _, err := a.Client.App.Init(ctx)
  381. if err != nil {
  382. slog.Error("Failed to mark project as initialized", "error", err)
  383. return err
  384. }
  385. return nil
  386. }
  387. func (a *App) CreateSession(ctx context.Context) (*opencode.Session, error) {
  388. session, err := a.Client.Session.New(ctx)
  389. if err != nil {
  390. return nil, err
  391. }
  392. return session, nil
  393. }
  394. func (a *App) SendChatMessage(
  395. ctx context.Context,
  396. text string,
  397. attachments []opencode.FilePartParam,
  398. ) (*App, tea.Cmd) {
  399. var cmds []tea.Cmd
  400. if a.Session.ID == "" {
  401. session, err := a.CreateSession(ctx)
  402. if err != nil {
  403. return a, toast.NewErrorToast(err.Error())
  404. }
  405. a.Session = session
  406. cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))
  407. }
  408. message := opencode.UserMessage{
  409. ID: id.Ascending(id.Message),
  410. SessionID: a.Session.ID,
  411. Role: opencode.UserMessageRoleUser,
  412. Time: opencode.UserMessageTime{
  413. Created: float64(time.Now().UnixMilli()),
  414. },
  415. }
  416. parts := []opencode.PartUnion{opencode.TextPart{
  417. ID: id.Ascending(id.Part),
  418. MessageID: message.ID,
  419. SessionID: a.Session.ID,
  420. Type: opencode.TextPartTypeText,
  421. Text: text,
  422. }}
  423. if len(attachments) > 0 {
  424. for _, attachment := range attachments {
  425. parts = append(parts, opencode.FilePart{
  426. ID: id.Ascending(id.Part),
  427. MessageID: message.ID,
  428. SessionID: a.Session.ID,
  429. Type: opencode.FilePartTypeFile,
  430. Filename: attachment.Filename.Value,
  431. Mime: attachment.Mime.Value,
  432. URL: attachment.URL.Value,
  433. })
  434. }
  435. }
  436. a.Messages = append(a.Messages, Message{Info: message, Parts: parts})
  437. cmds = append(cmds, util.CmdHandler(OptimisticMessageAddedMsg{Message: message}))
  438. cmds = append(cmds, func() tea.Msg {
  439. partsParam := []opencode.SessionChatParamsPartUnion{}
  440. for _, part := range parts {
  441. switch casted := part.(type) {
  442. case opencode.TextPart:
  443. partsParam = append(partsParam, opencode.TextPartParam{
  444. ID: opencode.F(casted.ID),
  445. MessageID: opencode.F(casted.MessageID),
  446. SessionID: opencode.F(casted.SessionID),
  447. Type: opencode.F(casted.Type),
  448. Text: opencode.F(casted.Text),
  449. })
  450. case opencode.FilePart:
  451. partsParam = append(partsParam, opencode.FilePartParam{
  452. ID: opencode.F(casted.ID),
  453. Mime: opencode.F(casted.Mime),
  454. MessageID: opencode.F(casted.MessageID),
  455. SessionID: opencode.F(casted.SessionID),
  456. Type: opencode.F(casted.Type),
  457. URL: opencode.F(casted.URL),
  458. Filename: opencode.F(casted.Filename),
  459. })
  460. }
  461. }
  462. _, err := a.Client.Session.Chat(ctx, a.Session.ID, opencode.SessionChatParams{
  463. Parts: opencode.F(partsParam),
  464. MessageID: opencode.F(message.ID),
  465. ProviderID: opencode.F(a.Provider.ID),
  466. ModelID: opencode.F(a.Model.ID),
  467. Mode: opencode.F(a.Mode.Name),
  468. })
  469. if err != nil {
  470. errormsg := fmt.Sprintf("failed to send message: %v", err)
  471. slog.Error(errormsg)
  472. return toast.NewErrorToast(errormsg)()
  473. }
  474. return nil
  475. })
  476. // The actual response will come through SSE
  477. // For now, just return success
  478. return a, tea.Batch(cmds...)
  479. }
  480. func (a *App) Cancel(ctx context.Context, sessionID string) error {
  481. // Cancel any running compact operation
  482. if a.compactCancel != nil {
  483. a.compactCancel()
  484. a.compactCancel = nil
  485. }
  486. _, err := a.Client.Session.Abort(ctx, sessionID)
  487. if err != nil {
  488. slog.Error("Failed to cancel session", "error", err)
  489. // status.Error(err.Error())
  490. return err
  491. }
  492. return nil
  493. }
  494. func (a *App) ListSessions(ctx context.Context) ([]opencode.Session, error) {
  495. response, err := a.Client.Session.List(ctx)
  496. if err != nil {
  497. return nil, err
  498. }
  499. if response == nil {
  500. return []opencode.Session{}, nil
  501. }
  502. sessions := *response
  503. sort.Slice(sessions, func(i, j int) bool {
  504. return sessions[i].Time.Created-sessions[j].Time.Created > 0
  505. })
  506. return sessions, nil
  507. }
  508. func (a *App) DeleteSession(ctx context.Context, sessionID string) error {
  509. _, err := a.Client.Session.Delete(ctx, sessionID)
  510. if err != nil {
  511. slog.Error("Failed to delete session", "error", err)
  512. return err
  513. }
  514. return nil
  515. }
  516. func (a *App) ListMessages(ctx context.Context, sessionId string) ([]Message, error) {
  517. response, err := a.Client.Session.Messages(ctx, sessionId)
  518. if err != nil {
  519. return nil, err
  520. }
  521. if response == nil {
  522. return []Message{}, nil
  523. }
  524. messages := []Message{}
  525. for _, message := range *response {
  526. msg := Message{
  527. Info: message.Info.AsUnion(),
  528. Parts: []opencode.PartUnion{},
  529. }
  530. for _, part := range message.Parts {
  531. msg.Parts = append(msg.Parts, part.AsUnion())
  532. }
  533. messages = append(messages, msg)
  534. }
  535. return messages, nil
  536. }
  537. func (a *App) ListProviders(ctx context.Context) ([]opencode.Provider, error) {
  538. response, err := a.Client.Config.Providers(ctx)
  539. if err != nil {
  540. return nil, err
  541. }
  542. if response == nil {
  543. return []opencode.Provider{}, nil
  544. }
  545. providers := *response
  546. return providers.Providers, nil
  547. }
  548. // func (a *App) loadCustomKeybinds() {
  549. //
  550. // }