app.go 10 KB

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