app.go 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645
  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. // findModelByFullID finds a model by its full ID in the format "provider/model"
  244. func findModelByFullID(providers []opencode.Provider, fullModelID string) (*opencode.Provider, *opencode.Model) {
  245. modelParts := strings.SplitN(fullModelID, "/", 2)
  246. if len(modelParts) < 2 {
  247. return nil, nil
  248. }
  249. providerID := modelParts[0]
  250. modelID := modelParts[1]
  251. return findModelByProviderAndModelID(providers, providerID, modelID)
  252. }
  253. // findModelByProviderAndModelID finds a model by provider ID and model ID
  254. func findModelByProviderAndModelID(providers []opencode.Provider, providerID, modelID string) (*opencode.Provider, *opencode.Model) {
  255. for _, provider := range providers {
  256. if provider.ID != providerID {
  257. continue
  258. }
  259. for _, model := range provider.Models {
  260. if model.ID == modelID {
  261. return &provider, &model
  262. }
  263. }
  264. // Provider found but model not found
  265. return nil, nil
  266. }
  267. // Provider not found
  268. return nil, nil
  269. }
  270. // findProviderByID finds a provider by its ID
  271. func findProviderByID(providers []opencode.Provider, providerID string) *opencode.Provider {
  272. for _, provider := range providers {
  273. if provider.ID == providerID {
  274. return &provider
  275. }
  276. }
  277. return nil
  278. }
  279. func (a *App) InitializeProvider() tea.Cmd {
  280. providersResponse, err := a.Client.App.Providers(context.Background())
  281. if err != nil {
  282. slog.Error("Failed to list providers", "error", err)
  283. // TODO: notify user
  284. return nil
  285. }
  286. providers := providersResponse.Providers
  287. if len(providers) == 0 {
  288. slog.Error("No providers configured")
  289. return nil
  290. }
  291. a.Providers = providers
  292. // retains backwards compatibility with old state format
  293. if model, ok := a.State.ModeModel[a.State.Mode]; ok {
  294. a.State.Provider = model.ProviderID
  295. a.State.Model = model.ModelID
  296. }
  297. var selectedProvider *opencode.Provider
  298. var selectedModel *opencode.Model
  299. // Priority 1: Command line --model flag (InitialModel)
  300. if a.InitialModel != nil && *a.InitialModel != "" {
  301. if provider, model := findModelByFullID(providers, *a.InitialModel); provider != nil && model != nil {
  302. selectedProvider = provider
  303. selectedModel = model
  304. slog.Debug("Selected model from command line", "provider", provider.ID, "model", model.ID)
  305. } else {
  306. slog.Debug("Command line model not found", "model", *a.InitialModel)
  307. }
  308. }
  309. // Priority 2: Config file model setting
  310. if selectedProvider == nil && a.Config.Model != "" {
  311. if provider, model := findModelByFullID(providers, a.Config.Model); provider != nil && model != nil {
  312. selectedProvider = provider
  313. selectedModel = model
  314. slog.Debug("Selected model from config", "provider", provider.ID, "model", model.ID)
  315. } else {
  316. slog.Debug("Config model not found", "model", a.Config.Model)
  317. }
  318. }
  319. // Priority 3: Recent model usage (most recently used model)
  320. if selectedProvider == nil && len(a.State.RecentlyUsedModels) > 0 {
  321. recentUsage := a.State.RecentlyUsedModels[0] // Most recent is first
  322. if provider, model := findModelByProviderAndModelID(providers, recentUsage.ProviderID, recentUsage.ModelID); provider != nil && model != nil {
  323. selectedProvider = provider
  324. selectedModel = model
  325. slog.Debug("Selected model from recent usage", "provider", provider.ID, "model", model.ID)
  326. } else {
  327. slog.Debug("Recent model not found", "provider", recentUsage.ProviderID, "model", recentUsage.ModelID)
  328. }
  329. }
  330. // Priority 4: State-based model (backwards compatibility)
  331. if selectedProvider == nil && a.State.Provider != "" && a.State.Model != "" {
  332. if provider, model := findModelByProviderAndModelID(providers, a.State.Provider, a.State.Model); provider != nil && model != nil {
  333. selectedProvider = provider
  334. selectedModel = model
  335. slog.Debug("Selected model from state", "provider", provider.ID, "model", model.ID)
  336. } else {
  337. slog.Debug("State model not found", "provider", a.State.Provider, "model", a.State.Model)
  338. }
  339. }
  340. // Priority 5: Internal priority fallback (Anthropic preferred, then first available)
  341. if selectedProvider == nil {
  342. // Try Anthropic first as internal priority
  343. if provider := findProviderByID(providers, "anthropic"); provider != nil {
  344. if model := getDefaultModel(providersResponse, *provider); model != nil {
  345. selectedProvider = provider
  346. selectedModel = model
  347. slog.Debug("Selected model from internal priority (Anthropic)", "provider", provider.ID, "model", model.ID)
  348. }
  349. }
  350. // If Anthropic not available, use first available provider
  351. if selectedProvider == nil && len(providers) > 0 {
  352. provider := &providers[0]
  353. if model := getDefaultModel(providersResponse, *provider); model != nil {
  354. selectedProvider = provider
  355. selectedModel = model
  356. slog.Debug("Selected model from fallback (first available)", "provider", provider.ID, "model", model.ID)
  357. }
  358. }
  359. }
  360. // Final safety check
  361. if selectedProvider == nil || selectedModel == nil {
  362. slog.Error("Failed to select any model")
  363. return nil
  364. }
  365. var cmds []tea.Cmd
  366. cmds = append(cmds, util.CmdHandler(ModelSelectedMsg{
  367. Provider: *selectedProvider,
  368. Model: *selectedModel,
  369. }))
  370. if a.InitialPrompt != nil && *a.InitialPrompt != "" {
  371. cmds = append(cmds, util.CmdHandler(SendPrompt{Text: *a.InitialPrompt}))
  372. }
  373. return tea.Sequence(cmds...)
  374. }
  375. func getDefaultModel(
  376. response *opencode.AppProvidersResponse,
  377. provider opencode.Provider,
  378. ) *opencode.Model {
  379. if match, ok := response.Default[provider.ID]; ok {
  380. model := provider.Models[match]
  381. return &model
  382. } else {
  383. for _, model := range provider.Models {
  384. return &model
  385. }
  386. }
  387. return nil
  388. }
  389. func (a *App) IsBusy() bool {
  390. if len(a.Messages) == 0 {
  391. return false
  392. }
  393. lastMessage := a.Messages[len(a.Messages)-1]
  394. if casted, ok := lastMessage.Info.(opencode.AssistantMessage); ok {
  395. return casted.Time.Completed == 0
  396. }
  397. return true
  398. }
  399. func (a *App) SaveState() tea.Cmd {
  400. return func() tea.Msg {
  401. err := SaveState(a.StatePath, a.State)
  402. if err != nil {
  403. slog.Error("Failed to save state", "error", err)
  404. }
  405. return nil
  406. }
  407. }
  408. func (a *App) InitializeProject(ctx context.Context) tea.Cmd {
  409. cmds := []tea.Cmd{}
  410. session, err := a.CreateSession(ctx)
  411. if err != nil {
  412. // status.Error(err.Error())
  413. return nil
  414. }
  415. a.Session = session
  416. cmds = append(cmds, util.CmdHandler(SessionCreatedMsg{Session: session}))
  417. go func() {
  418. _, err := a.Client.Session.Init(ctx, a.Session.ID, opencode.SessionInitParams{
  419. MessageID: opencode.F(id.Ascending(id.Message)),
  420. ProviderID: opencode.F(a.Provider.ID),
  421. ModelID: opencode.F(a.Model.ID),
  422. })
  423. if err != nil {
  424. slog.Error("Failed to initialize project", "error", err)
  425. // status.Error(err.Error())
  426. }
  427. }()
  428. return tea.Batch(cmds...)
  429. }
  430. func (a *App) CompactSession(ctx context.Context) tea.Cmd {
  431. if a.compactCancel != nil {
  432. a.compactCancel()
  433. }
  434. compactCtx, cancel := context.WithCancel(ctx)
  435. a.compactCancel = cancel
  436. go func() {
  437. defer func() {
  438. a.compactCancel = nil
  439. }()
  440. _, err := a.Client.Session.Summarize(
  441. compactCtx,
  442. a.Session.ID,
  443. opencode.SessionSummarizeParams{
  444. ProviderID: opencode.F(a.Provider.ID),
  445. ModelID: opencode.F(a.Model.ID),
  446. },
  447. )
  448. if err != nil {
  449. if compactCtx.Err() != context.Canceled {
  450. slog.Error("Failed to compact session", "error", err)
  451. }
  452. }
  453. }()
  454. return nil
  455. }
  456. func (a *App) MarkProjectInitialized(ctx context.Context) error {
  457. _, err := a.Client.App.Init(ctx)
  458. if err != nil {
  459. slog.Error("Failed to mark project as initialized", "error", err)
  460. return err
  461. }
  462. return nil
  463. }
  464. func (a *App) CreateSession(ctx context.Context) (*opencode.Session, error) {
  465. session, err := a.Client.Session.New(ctx)
  466. if err != nil {
  467. return nil, err
  468. }
  469. return session, nil
  470. }
  471. func (a *App) SendPrompt(ctx context.Context, prompt Prompt) (*App, tea.Cmd) {
  472. var cmds []tea.Cmd
  473. if a.Session.ID == "" {
  474. session, err := a.CreateSession(ctx)
  475. if err != nil {
  476. return a, toast.NewErrorToast(err.Error())
  477. }
  478. a.Session = session
  479. cmds = append(cmds, util.CmdHandler(SessionCreatedMsg{Session: session}))
  480. }
  481. messageID := id.Ascending(id.Message)
  482. message := prompt.ToMessage(messageID, a.Session.ID)
  483. a.Messages = append(a.Messages, message)
  484. cmds = append(cmds, func() tea.Msg {
  485. _, err := a.Client.Session.Chat(ctx, a.Session.ID, opencode.SessionChatParams{
  486. ProviderID: opencode.F(a.Provider.ID),
  487. ModelID: opencode.F(a.Model.ID),
  488. Mode: opencode.F(a.Mode.Name),
  489. MessageID: opencode.F(messageID),
  490. Parts: opencode.F(message.ToSessionChatParams()),
  491. })
  492. if err != nil {
  493. errormsg := fmt.Sprintf("failed to send message: %v", err)
  494. slog.Error(errormsg)
  495. return toast.NewErrorToast(errormsg)()
  496. }
  497. return nil
  498. })
  499. // The actual response will come through SSE
  500. // For now, just return success
  501. return a, tea.Batch(cmds...)
  502. }
  503. func (a *App) Cancel(ctx context.Context, sessionID string) error {
  504. // Cancel any running compact operation
  505. if a.compactCancel != nil {
  506. a.compactCancel()
  507. a.compactCancel = nil
  508. }
  509. _, err := a.Client.Session.Abort(ctx, sessionID)
  510. if err != nil {
  511. slog.Error("Failed to cancel session", "error", err)
  512. return err
  513. }
  514. return nil
  515. }
  516. func (a *App) ListSessions(ctx context.Context) ([]opencode.Session, error) {
  517. response, err := a.Client.Session.List(ctx)
  518. if err != nil {
  519. return nil, err
  520. }
  521. if response == nil {
  522. return []opencode.Session{}, nil
  523. }
  524. sessions := *response
  525. return sessions, nil
  526. }
  527. func (a *App) DeleteSession(ctx context.Context, sessionID string) error {
  528. _, err := a.Client.Session.Delete(ctx, sessionID)
  529. if err != nil {
  530. slog.Error("Failed to delete session", "error", err)
  531. return err
  532. }
  533. return nil
  534. }
  535. func (a *App) ListMessages(ctx context.Context, sessionId string) ([]Message, error) {
  536. response, err := a.Client.Session.Messages(ctx, sessionId)
  537. if err != nil {
  538. return nil, err
  539. }
  540. if response == nil {
  541. return []Message{}, nil
  542. }
  543. messages := []Message{}
  544. for _, message := range *response {
  545. msg := Message{
  546. Info: message.Info.AsUnion(),
  547. Parts: []opencode.PartUnion{},
  548. }
  549. for _, part := range message.Parts {
  550. msg.Parts = append(msg.Parts, part.AsUnion())
  551. }
  552. messages = append(messages, msg)
  553. }
  554. return messages, nil
  555. }
  556. func (a *App) ListProviders(ctx context.Context) ([]opencode.Provider, error) {
  557. response, err := a.Client.App.Providers(ctx)
  558. if err != nil {
  559. return nil, err
  560. }
  561. if response == nil {
  562. return []opencode.Provider{}, nil
  563. }
  564. providers := *response
  565. return providers.Providers, nil
  566. }
  567. // func (a *App) loadCustomKeybinds() {
  568. //
  569. // }