app.go 9.7 KB

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