app.go 14 KB

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