app.go 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478
  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. "golang.design/x/clipboard"
  19. )
  20. type App struct {
  21. Info opencode.App
  22. Version string
  23. StatePath string
  24. Config *opencode.Config
  25. Client *opencode.Client
  26. State *config.State
  27. Provider *opencode.Provider
  28. Model *opencode.Model
  29. Session *opencode.Session
  30. Messages []opencode.MessageUnion
  31. Commands commands.CommandRegistry
  32. InitialModel *string
  33. InitialPrompt *string
  34. }
  35. type SessionSelectedMsg = *opencode.Session
  36. type SessionLoadedMsg struct{}
  37. type ModelSelectedMsg struct {
  38. Provider opencode.Provider
  39. Model opencode.Model
  40. }
  41. type SessionClearedMsg struct{}
  42. type CompactSessionMsg struct{}
  43. type SendMsg struct {
  44. Text string
  45. Attachments []opencode.FilePartParam
  46. }
  47. type OptimisticMessageAddedMsg struct {
  48. Message opencode.MessageUnion
  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. model *string,
  59. prompt *string,
  60. ) (*App, error) {
  61. util.RootPath = appInfo.Path.Root
  62. util.CwdPath = appInfo.Path.Cwd
  63. configInfo, err := httpClient.Config.Get(ctx)
  64. if err != nil {
  65. return nil, err
  66. }
  67. if configInfo.Keybinds.Leader == "" {
  68. configInfo.Keybinds.Leader = "ctrl+x"
  69. }
  70. appStatePath := filepath.Join(appInfo.Path.State, "tui")
  71. appState, err := config.LoadState(appStatePath)
  72. if err != nil {
  73. appState = config.NewState()
  74. config.SaveState(appStatePath, appState)
  75. }
  76. if configInfo.Theme != "" {
  77. appState.Theme = configInfo.Theme
  78. }
  79. if configInfo.Model != "" {
  80. splits := strings.Split(configInfo.Model, "/")
  81. appState.Provider = splits[0]
  82. appState.Model = strings.Join(splits[1:], "/")
  83. }
  84. if err := theme.LoadThemesFromDirectories(
  85. appInfo.Path.Config,
  86. appInfo.Path.Root,
  87. appInfo.Path.Cwd,
  88. ); err != nil {
  89. slog.Warn("Failed to load themes from directories", "error", err)
  90. }
  91. if appState.Theme != "" {
  92. if appState.Theme == "system" && styles.Terminal != nil {
  93. theme.UpdateSystemTheme(
  94. styles.Terminal.Background,
  95. styles.Terminal.BackgroundIsDark,
  96. )
  97. }
  98. theme.SetTheme(appState.Theme)
  99. }
  100. slog.Debug("Loaded config", "config", configInfo)
  101. app := &App{
  102. Info: appInfo,
  103. Version: version,
  104. StatePath: appStatePath,
  105. Config: configInfo,
  106. State: appState,
  107. Client: httpClient,
  108. Session: &opencode.Session{},
  109. Messages: []opencode.MessageUnion{},
  110. Commands: commands.LoadFromConfig(configInfo),
  111. InitialModel: model,
  112. InitialPrompt: prompt,
  113. }
  114. return app, nil
  115. }
  116. func (a *App) Key(commandName commands.CommandName) string {
  117. t := theme.CurrentTheme()
  118. base := styles.NewStyle().Background(t.Background()).Foreground(t.Text()).Bold(true).Render
  119. muted := styles.NewStyle().
  120. Background(t.Background()).
  121. Foreground(t.TextMuted()).
  122. Faint(true).
  123. Render
  124. command := a.Commands[commandName]
  125. kb := command.Keybindings[0]
  126. key := kb.Key
  127. if kb.RequiresLeader {
  128. key = a.Config.Keybinds.Leader + " " + kb.Key
  129. }
  130. return base(key) + muted(" "+command.Description)
  131. }
  132. func (a *App) SetClipboard(text string) tea.Cmd {
  133. var cmds []tea.Cmd
  134. cmds = append(cmds, func() tea.Msg {
  135. clipboard.Write(clipboard.FmtText, []byte(text))
  136. return nil
  137. })
  138. // try to set the clipboard using OSC52 for terminals that support it
  139. cmds = append(cmds, tea.SetClipboard(text))
  140. return tea.Sequence(cmds...)
  141. }
  142. func (a *App) InitializeProvider() tea.Cmd {
  143. providersResponse, err := a.Client.Config.Providers(context.Background())
  144. if err != nil {
  145. slog.Error("Failed to list providers", "error", err)
  146. // TODO: notify user
  147. return nil
  148. }
  149. providers := providersResponse.Providers
  150. var defaultProvider *opencode.Provider
  151. var defaultModel *opencode.Model
  152. var anthropic *opencode.Provider
  153. for _, provider := range providers {
  154. if provider.ID == "anthropic" {
  155. anthropic = &provider
  156. }
  157. }
  158. // default to anthropic if available
  159. if anthropic != nil {
  160. defaultProvider = anthropic
  161. defaultModel = getDefaultModel(providersResponse, *anthropic)
  162. }
  163. for _, provider := range providers {
  164. if defaultProvider == nil || defaultModel == nil {
  165. defaultProvider = &provider
  166. defaultModel = getDefaultModel(providersResponse, provider)
  167. }
  168. providers = append(providers, provider)
  169. }
  170. if len(providers) == 0 {
  171. slog.Error("No providers configured")
  172. return nil
  173. }
  174. var currentProvider *opencode.Provider
  175. var currentModel *opencode.Model
  176. for _, provider := range providers {
  177. if provider.ID == a.State.Provider {
  178. currentProvider = &provider
  179. for _, model := range provider.Models {
  180. if model.ID == a.State.Model {
  181. currentModel = &model
  182. }
  183. }
  184. }
  185. }
  186. if currentProvider == nil || currentModel == nil {
  187. currentProvider = defaultProvider
  188. currentModel = defaultModel
  189. }
  190. var initialProvider *opencode.Provider
  191. var initialModel *opencode.Model
  192. if a.InitialModel != nil && *a.InitialModel != "" {
  193. splits := strings.Split(*a.InitialModel, "/")
  194. for _, provider := range providers {
  195. if provider.ID == splits[0] {
  196. initialProvider = &provider
  197. for _, model := range provider.Models {
  198. modelID := strings.Join(splits[1:], "/")
  199. if model.ID == modelID {
  200. initialModel = &model
  201. }
  202. }
  203. }
  204. }
  205. }
  206. if initialProvider != nil && initialModel != nil {
  207. currentProvider = initialProvider
  208. currentModel = initialModel
  209. }
  210. var cmds []tea.Cmd
  211. cmds = append(cmds, util.CmdHandler(ModelSelectedMsg{
  212. Provider: *currentProvider,
  213. Model: *currentModel,
  214. }))
  215. if a.InitialPrompt != nil && *a.InitialPrompt != "" {
  216. cmds = append(cmds, util.CmdHandler(SendMsg{Text: *a.InitialPrompt}))
  217. }
  218. return tea.Sequence(cmds...)
  219. }
  220. func getDefaultModel(
  221. response *opencode.ConfigProvidersResponse,
  222. provider opencode.Provider,
  223. ) *opencode.Model {
  224. if match, ok := response.Default[provider.ID]; ok {
  225. model := provider.Models[match]
  226. return &model
  227. } else {
  228. for _, model := range provider.Models {
  229. return &model
  230. }
  231. }
  232. return nil
  233. }
  234. func (a *App) IsBusy() bool {
  235. if len(a.Messages) == 0 {
  236. return false
  237. }
  238. lastMessage := a.Messages[len(a.Messages)-1]
  239. if casted, ok := lastMessage.(opencode.AssistantMessage); ok {
  240. return casted.Time.Completed == 0
  241. }
  242. return false
  243. }
  244. func (a *App) SaveState() {
  245. err := config.SaveState(a.StatePath, a.State)
  246. if err != nil {
  247. slog.Error("Failed to save state", "error", err)
  248. }
  249. }
  250. func (a *App) InitializeProject(ctx context.Context) tea.Cmd {
  251. cmds := []tea.Cmd{}
  252. session, err := a.CreateSession(ctx)
  253. if err != nil {
  254. // status.Error(err.Error())
  255. return nil
  256. }
  257. a.Session = session
  258. cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))
  259. go func() {
  260. _, err := a.Client.Session.Init(ctx, a.Session.ID, opencode.SessionInitParams{
  261. ProviderID: opencode.F(a.Provider.ID),
  262. ModelID: opencode.F(a.Model.ID),
  263. })
  264. if err != nil {
  265. slog.Error("Failed to initialize project", "error", err)
  266. // status.Error(err.Error())
  267. }
  268. }()
  269. return tea.Batch(cmds...)
  270. }
  271. func (a *App) CompactSession(ctx context.Context) tea.Cmd {
  272. go func() {
  273. _, err := a.Client.Session.Summarize(ctx, a.Session.ID, opencode.SessionSummarizeParams{
  274. ProviderID: opencode.F(a.Provider.ID),
  275. ModelID: opencode.F(a.Model.ID),
  276. })
  277. if err != nil {
  278. slog.Error("Failed to compact session", "error", err)
  279. }
  280. }()
  281. return nil
  282. }
  283. func (a *App) MarkProjectInitialized(ctx context.Context) error {
  284. _, err := a.Client.App.Init(ctx)
  285. if err != nil {
  286. slog.Error("Failed to mark project as initialized", "error", err)
  287. return err
  288. }
  289. return nil
  290. }
  291. func (a *App) CreateSession(ctx context.Context) (*opencode.Session, error) {
  292. session, err := a.Client.Session.New(ctx)
  293. if err != nil {
  294. return nil, err
  295. }
  296. return session, nil
  297. }
  298. func (a *App) SendChatMessage(
  299. ctx context.Context,
  300. text string,
  301. attachments []opencode.FilePartParam,
  302. ) (*App, tea.Cmd) {
  303. var cmds []tea.Cmd
  304. if a.Session.ID == "" {
  305. session, err := a.CreateSession(ctx)
  306. if err != nil {
  307. return a, toast.NewErrorToast(err.Error())
  308. }
  309. a.Session = session
  310. cmds = append(cmds, util.CmdHandler(SessionSelectedMsg(session)))
  311. }
  312. optimisticParts := []opencode.UserMessagePart{{
  313. Type: opencode.UserMessagePartTypeText,
  314. Text: text,
  315. }}
  316. if len(attachments) > 0 {
  317. for _, attachment := range attachments {
  318. optimisticParts = append(optimisticParts, opencode.UserMessagePart{
  319. Type: opencode.UserMessagePartTypeFile,
  320. Filename: attachment.Filename.Value,
  321. Mime: attachment.Mime.Value,
  322. URL: attachment.URL.Value,
  323. })
  324. }
  325. }
  326. optimisticMessage := opencode.UserMessage{
  327. ID: fmt.Sprintf("optimistic-%d", time.Now().UnixNano()),
  328. Role: opencode.UserMessageRoleUser,
  329. Parts: optimisticParts,
  330. SessionID: a.Session.ID,
  331. Time: opencode.UserMessageTime{
  332. Created: float64(time.Now().Unix()),
  333. },
  334. }
  335. a.Messages = append(a.Messages, optimisticMessage)
  336. cmds = append(cmds, util.CmdHandler(OptimisticMessageAddedMsg{Message: optimisticMessage}))
  337. cmds = append(cmds, func() tea.Msg {
  338. parts := []opencode.UserMessagePartUnionParam{
  339. opencode.TextPartParam{
  340. Type: opencode.F(opencode.TextPartTypeText),
  341. Text: opencode.F(text),
  342. },
  343. }
  344. if len(attachments) > 0 {
  345. for _, attachment := range attachments {
  346. parts = append(parts, opencode.FilePartParam{
  347. Mime: attachment.Mime,
  348. Type: attachment.Type,
  349. URL: attachment.URL,
  350. Filename: attachment.Filename,
  351. })
  352. }
  353. }
  354. _, err := a.Client.Session.Chat(ctx, a.Session.ID, opencode.SessionChatParams{
  355. Parts: opencode.F(parts),
  356. ProviderID: opencode.F(a.Provider.ID),
  357. ModelID: opencode.F(a.Model.ID),
  358. })
  359. if err != nil {
  360. errormsg := fmt.Sprintf("failed to send message: %v", err)
  361. slog.Error(errormsg)
  362. return toast.NewErrorToast(errormsg)()
  363. }
  364. return nil
  365. })
  366. // The actual response will come through SSE
  367. // For now, just return success
  368. return a, tea.Batch(cmds...)
  369. }
  370. func (a *App) Cancel(ctx context.Context, sessionID string) error {
  371. _, err := a.Client.Session.Abort(ctx, sessionID)
  372. if err != nil {
  373. slog.Error("Failed to cancel session", "error", err)
  374. // status.Error(err.Error())
  375. return err
  376. }
  377. return nil
  378. }
  379. func (a *App) ListSessions(ctx context.Context) ([]opencode.Session, error) {
  380. response, err := a.Client.Session.List(ctx)
  381. if err != nil {
  382. return nil, err
  383. }
  384. if response == nil {
  385. return []opencode.Session{}, nil
  386. }
  387. sessions := *response
  388. sort.Slice(sessions, func(i, j int) bool {
  389. return sessions[i].Time.Created-sessions[j].Time.Created > 0
  390. })
  391. return sessions, nil
  392. }
  393. func (a *App) DeleteSession(ctx context.Context, sessionID string) error {
  394. _, err := a.Client.Session.Delete(ctx, sessionID)
  395. if err != nil {
  396. slog.Error("Failed to delete session", "error", err)
  397. return err
  398. }
  399. return nil
  400. }
  401. func (a *App) ListMessages(ctx context.Context, sessionId string) ([]opencode.Message, error) {
  402. response, err := a.Client.Session.Messages(ctx, sessionId)
  403. if err != nil {
  404. return nil, err
  405. }
  406. if response == nil {
  407. return []opencode.Message{}, nil
  408. }
  409. messages := *response
  410. return messages, nil
  411. }
  412. func (a *App) ListProviders(ctx context.Context) ([]opencode.Provider, error) {
  413. response, err := a.Client.Config.Providers(ctx)
  414. if err != nil {
  415. return nil, err
  416. }
  417. if response == nil {
  418. return []opencode.Provider{}, nil
  419. }
  420. providers := *response
  421. return providers.Providers, nil
  422. }
  423. // func (a *App) loadCustomKeybinds() {
  424. //
  425. // }