app.go 11 KB

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