@fatalmistake02/rian 0.0.0-stage → 0.2.1

package/internal/ui/actions.go

@@ -0,0 +1,259 @@
+package ui
+
+import (
+	"fmt"
+	"os/exec"
+	"sort"
+	"strings"
+
+	tea "charm.land/bubbletea/v2"
+
+	"rian/internal/config"
+	"rian/internal/detect"
+	"rian/internal/project"
+	"rian/internal/tools"
+)
+
+func (m *Model) actions(p project.Project) []Action {
+	items := []Action{}
+	for _, tool := range []struct{ id, label, binary string }{{"vscode", "Open in VS Code", "code"}, {"opencode", "Open in OpenCode", "opencode"}, {"kilocode", "Open in KiloCode", "kilocode"}, {"chatgpt", "Open ChatGPT", ""}, {"terminal", "Open Terminal", ""}} {
+		item := Action{ID: tool.id, Label: tool.label}
+		if !p.ToolEnabled(tool.id) {
+			item.Disabled = "Disabled in project settings"
+		} else if tool.binary != "" && !m.available[tool.binary] {
+			item.Disabled = tool.binary + " was not found in PATH"
+		}
+		items = append(items, item)
+	}
+	repoURL, err := tools.GitHubURL(p, m.statuses[p.ID])
+	item := Action{ID: "github", Label: "Open GitHub", Detail: repoURL}
+	if err != nil {
+		item.Disabled = "No GitHub remote or override"
+	}
+	items = append(items, item)
+	for _, label := range []string{"local", "production"} {
+		if p.URLs[label] != "" {
+			items = append(items, Action{ID: "url", Label: "Open " + label + " URL", Value: p.URLs[label], Detail: p.URLs[label]})
+		}
+	}
+	for _, name := range detect.CommandNames(p.AllCommands()) {
+		items = append(items, Action{ID: "run", Label: "Run " + name, Value: name, Detail: p.AllCommands()[name]})
+	}
+	if m.statuses[p.ID].Repository {
+		items = append(items, m.gitActions()...)
+	}
+	if m.manager.Snapshot(p.ID).Command != "" {
+		items = append(items, Action{ID: "process", Label: "Show process output"})
+	}
+	favorite := "Favorite project"
+	if p.Favorite {
+		favorite = "Unfavorite project"
+	}
+	return append(items, Action{ID: "favorite", Label: favorite}, Action{ID: "edit", Label: "Edit project"}, Action{ID: "remove", Label: "Remove project"}, Action{ID: "add", Label: "Add project"}, Action{ID: "refresh", Label: "Rescan project", Detail: "Refresh stack, commands, tools, and Git"})
+}
+
+func (m *Model) gitActions() []Action {
+	items := []Action{{ID: "git", Label: "Git Pull", Value: "pull", Detail: "Fast-forward only"}, {ID: "git", Label: "Git Push", Value: "push", Detail: "Push current branch"}, {ID: "git", Label: "Git Fetch", Value: "fetch"}, {ID: "commit", Label: "Git Commit", Detail: "Commit staged changes"}, {ID: "branch", Label: "Switch branch", Detail: "An existing local branch"}, {ID: "github", Label: "Open GitHub"}}
+	item := Action{ID: "lazygit", Label: "Open lazygit"}
+	if !m.available["lazygit"] {
+		item.Disabled = "lazygit was not found in PATH"
+	}
+	return append(items, item)
+}
+
+func (m *Model) openMenu(which mode) tea.Cmd {
+	m.mode, m.menuIndex = which, 0
+	m.query = input("Search actions…")
+	p, ok := m.current()
+	if !ok {
+		m.menu = []Action{{ID: "add", Label: "Add project"}, {ID: "help", Label: "Keyboard shortcuts"}}
+	} else {
+		switch which {
+		case gitMenu:
+			m.menu = m.gitActions()
+		case commands:
+			m.menu = nil
+			for _, name := range detect.CommandNames(p.AllCommands()) {
+				detail := p.AllCommands()[name]
+				if _, custom := p.Commands[name]; custom {
+					detail = "Custom · " + detail
+				}
+				m.menu = append(m.menu, Action{ID: "run", Label: name, Value: name, Detail: detail})
+			}
+			m.menu = append(m.menu, Action{ID: "custom", Label: "+ Add custom command"}, Action{ID: "adhoc", Label: "Run a one-off command"})
+		default:
+			m.menu = m.actions(p)
+		}
+	}
+	m.resize()
+	return m.query.Focus()
+}
+
+func (m *Model) filteredActions() []Action {
+	items := []Action{}
+	for _, action := range m.menu {
+		if project.Score(m.query.Value(), action.Label) >= 0 {
+			items = append(items, action)
+		}
+	}
+	if m.query.Value() != "" {
+		sort.SliceStable(items, func(i, j int) bool {
+			return project.Score(m.query.Value(), items[i].Label) > project.Score(m.query.Value(), items[j].Label)
+		})
+	}
+	return items
+}
+
+func (m *Model) execute(action Action) tea.Cmd {
+	if action.Disabled != "" {
+		return m.notify("Action unavailable", fmt.Errorf("%s", action.Disabled))
+	}
+	if action.ID == "add" {
+		m.startAdd()
+		return m.query.Focus()
+	}
+	if action.ID == "help" {
+		m.mode = help
+		m.resize()
+		m.viewport.GotoTop()
+		return nil
+	}
+	p, ok := m.current()
+	if !ok {
+		return nil
+	}
+	if !p.ToolEnabled(action.ID) {
+		return m.notify("Action disabled", fmt.Errorf("%s is disabled in project settings", action.Label))
+	}
+	m.closeModal()
+	switch action.ID {
+	case "favorite":
+		return m.save(p.ID, "Favorite updated", func(cfg *config.Config) error {
+			for i := range cfg.Projects {
+				if cfg.Projects[i].ID == p.ID {
+					cfg.Projects[i].Favorite = !cfg.Projects[i].Favorite
+					return nil
+				}
+			}
+			return fmt.Errorf("project no longer exists")
+		})
+	case "edit":
+		m.startEdit(p)
+		return m.fields[0].input.Focus()
+	case "remove":
+		m.editProject = p
+		m.mode = removeConfirm
+		return nil
+	case "refresh":
+		return m.inspectDirectory("refresh", p.Path, p.ID)
+	case "process":
+		m.showProcess(p.ID)
+		return nil
+	case "run":
+		return m.runCommand(p, action.Value, p.AllCommands()[action.Value])
+	case "adhoc":
+		m.startPrompt("run", "Command to run…")
+		return m.query.Focus()
+	case "custom":
+		m.startCustom("", "")
+		return m.commandName.Focus()
+	case "commit":
+		m.startPrompt("commit", "Commit message (staged changes only)…")
+		return m.query.Focus()
+	case "branch":
+		m.startPrompt("branch", "Existing branch name…")
+		return m.query.Focus()
+	case "git":
+		args := []string{action.Value}
+		if action.Value == "pull" {
+			args = append(args, "--ff-only")
+		}
+		return m.interactive(p, func() (*exec.Cmd, error) { return tools.GitCommand(p, args...) }, action.Label, true)
+	case "terminal", "opencode", "kilocode", "lazygit":
+		return m.interactive(p, func() (*exec.Cmd, error) { return m.launcher.Interactive(action.ID, p) }, action.Label, true)
+	default:
+		launcher := m.launcher
+		status := m.statuses[p.ID]
+		return func() tea.Msg {
+			var err error
+			switch action.ID {
+			case "vscode":
+				err = launcher.OpenEditor(p)
+			case "chatgpt":
+				err = launcher.OpenChatGPT()
+			case "github":
+				var value string
+				value, err = tools.GitHubURL(p, status)
+				if err == nil {
+					err = launcher.OpenURL(value)
+				}
+			case "url":
+				err = launcher.OpenURL(action.Value)
+			}
+			return actionMsg{id: p.ID, notice: action.Label + " opened", err: err}
+		}
+	}
+}
+
+type preparedExecMsg struct {
+	cmd       *exec.Cmd
+	id, label string
+	refresh   bool
+	err       error
+}
+
+func (m *Model) interactive(p project.Project, prepare func() (*exec.Cmd, error), label string, refresh bool) tea.Cmd {
+	return func() tea.Msg { cmd, err := prepare(); return preparedExecMsg{cmd, p.ID, label, refresh, err} }
+}
+
+func (m *Model) runCommand(p project.Project, name, command string) tea.Cmd {
+	if strings.TrimSpace(command) == "" {
+		return m.notify("No command", fmt.Errorf("this command is empty"))
+	}
+	m.showProcess(p.ID)
+	m.processState.Command = command
+	m.busy = true
+	manager := m.manager
+	return func() tea.Msg {
+		state, err := manager.Start(p.ID, p.Path, command)
+		return processMsg{p.ID, state, err}
+	}
+}
+
+func (m *Model) showProcess(id string) {
+	m.mode = processView
+	m.resize()
+	m.processID = id
+	m.processState = m.manager.Snapshot(id)
+	m.followOutput = true
+	m.viewport.SetContent(plain(m.processState.Output))
+	m.viewport.GotoBottom()
+}
+
+func (m *Model) startPrompt(action, placeholder string) {
+	m.mode = prompt
+	m.promptAction = action
+	m.query = input(placeholder)
+	m.resize()
+}
+
+func (m *Model) submitPrompt() tea.Cmd {
+	value := strings.TrimSpace(m.query.Value())
+	if value == "" {
+		m.formError = "Enter a value first"
+		return nil
+	}
+	p, ok := m.current()
+	if !ok {
+		return nil
+	}
+	action := m.promptAction
+	m.closeModal()
+	if action == "run" {
+		return m.runCommand(p, "custom", value)
+	}
+	if action == "commit" {
+		return m.interactive(p, func() (*exec.Cmd, error) { return tools.GitCommand(p, "commit", "-m", value) }, "Git commit", true)
+	}
+	return m.interactive(p, func() (*exec.Cmd, error) { return tools.GitCommand(p, "switch", "--", value) }, "Switch branch", true)
+}

package/internal/ui/forms.go

@@ -0,0 +1,156 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+
+	tea "charm.land/bubbletea/v2"
+
+	"rian/internal/config"
+	"rian/internal/detect"
+	"rian/internal/git"
+	"rian/internal/project"
+	"rian/internal/tools"
+)
+
+func (m *Model) startAdd() {
+	m.mode, m.formError = add, ""
+	m.query = input("Directory, e.g. ~/dev/my-project")
+	m.resize()
+}
+
+func (m *Model) inspectDirectory(purpose, path, id string) tea.Cmd {
+	m.busy = true
+	return func() tea.Msg { result, err := detect.Inspect(path); return inspectedMsg{result, err, purpose, id} }
+}
+
+func (m *Model) confirmAdd() tea.Cmd {
+	p := m.pending.Project
+	return m.save(p.ID, "Project added", func(cfg *config.Config) error { return config.Add(cfg, p) })
+}
+
+func (m *Model) startEdit(p project.Project) {
+	m.mode, m.formError, m.editProject = edit, "", p
+	m.fields = nil
+	for _, field := range []struct{ label, value, hint string }{
+		{"Name", p.Name, "Display name"}, {"Directory", p.Path, "Project directory"},
+		{"GitHub", p.GitHub, "owner/repo override (optional)"}, {"Local URL", p.URLs["local"], "http://localhost:3000"}, {"Production URL", p.URLs["production"], "https://example.com"},
+	} {
+		i := input(field.hint)
+		i.SetValue(field.value)
+		m.fields = append(m.fields, formField{label: field.label, input: i})
+	}
+	m.fields = append(m.fields, formField{label: "Favorite", toggle: true, checked: p.Favorite})
+	for _, name := range []string{"vscode", "opencode", "kilocode", "chatgpt", "terminal"} {
+		m.fields = append(m.fields, formField{label: name, toggle: true, checked: p.ToolEnabled(name)})
+	}
+	m.fieldIndex = 0
+	m.resize()
+}
+
+func (m *Model) focusField(index int) tea.Cmd {
+	m.fields[m.fieldIndex].input.Blur()
+	m.fieldIndex = (index + len(m.fields)) % len(m.fields)
+	if !m.fields[m.fieldIndex].toggle {
+		return m.fields[m.fieldIndex].input.Focus()
+	}
+	return nil
+}
+
+func (m *Model) submitEdit() tea.Cmd {
+	if strings.TrimSpace(m.fields[0].input.Value()) == "" {
+		m.formError = "Give this project a name"
+		return nil
+	}
+	repo, err := git.NormalizeRepo(strings.TrimSpace(m.fields[2].input.Value()))
+	if err != nil {
+		m.formError = err.Error()
+		return nil
+	}
+	for _, i := range []int{3, 4} {
+		if err := tools.ValidateURL(strings.TrimSpace(m.fields[i].input.Value())); err != nil {
+			m.formError = m.fields[i].label + ": " + err.Error()
+			return nil
+		}
+	}
+	p := m.editProject
+	p.Name = strings.TrimSpace(m.fields[0].input.Value())
+	p.GitHub = repo
+	p.URLs = map[string]string{"local": strings.TrimSpace(m.fields[3].input.Value()), "production": strings.TrimSpace(m.fields[4].input.Value())}
+	p.Favorite = m.fields[5].checked
+	p.Tools = map[string]bool{}
+	for _, field := range m.fields[6:] {
+		p.Tools[field.label] = field.checked
+	}
+	m.editProject = p
+	return m.inspectDirectory("edit", m.fields[1].input.Value(), p.ID)
+}
+
+func (m *Model) startCustom(name, command string) {
+	m.commandOriginal = name
+	m.mode, m.commandEditing, m.formError = prompt, true, ""
+	m.promptAction, m.commandField = "custom", 0
+	m.commandName, m.commandValue = input("e.g. dev, deploy, docs"), input("e.g. npm run dev")
+	m.commandName.SetValue(name)
+	m.commandValue.SetValue(command)
+	m.resize()
+}
+
+func (m *Model) submitCustom() tea.Cmd {
+	name, value := strings.TrimSpace(m.commandName.Value()), strings.TrimSpace(m.commandValue.Value())
+	if name == "" || value == "" {
+		m.formError = "A name and command are required"
+		return nil
+	}
+	p, ok := m.current()
+	if !ok {
+		return nil
+	}
+	original := m.commandOriginal
+	return m.save(p.ID, "Command saved", func(cfg *config.Config) error {
+		for i := range cfg.Projects {
+			if cfg.Projects[i].ID == p.ID {
+				if cfg.Projects[i].Commands == nil {
+					cfg.Projects[i].Commands = map[string]string{}
+				}
+				if original != "" && original != name {
+					delete(cfg.Projects[i].Commands, original)
+				}
+				cfg.Projects[i].Commands[name] = value
+				return nil
+			}
+		}
+		return fmt.Errorf("project no longer exists")
+	})
+}
+
+func (m *Model) commandEdit(remove bool) tea.Cmd {
+	items := m.filteredActions()
+	if len(items) == 0 {
+		return nil
+	}
+	item := items[min(m.menuIndex, len(items)-1)]
+	if item.ID != "run" {
+		return nil
+	}
+	p, ok := m.current()
+	if !ok {
+		return nil
+	}
+	if !remove {
+		m.startCustom(item.Value, p.AllCommands()[item.Value])
+		return m.commandName.Focus()
+	}
+	if _, custom := p.Commands[item.Value]; !custom {
+		return m.notify("Detected command", fmt.Errorf("detected commands come from project files; Ctrl+E adds an override"))
+	}
+	return m.save(p.ID, "Custom command removed", func(cfg *config.Config) error {
+		for i := range cfg.Projects {
+			if cfg.Projects[i].ID == p.ID {
+				delete(cfg.Projects[i].Commands, item.Value)
+				return nil
+			}
+		}
+		return fmt.Errorf("project no longer exists")
+	})
+}

package/internal/ui/model.go

@@ -0,0 +1,220 @@
+package ui
+
+import (
+	"log"
+	"time"
+
+	"charm.land/bubbles/v2/spinner"
+	"charm.land/bubbles/v2/textinput"
+	"charm.land/bubbles/v2/viewport"
+	tea "charm.land/bubbletea/v2"
+
+	"rian/internal/config"
+	"rian/internal/detect"
+	"rian/internal/git"
+	"rian/internal/process"
+	"rian/internal/project"
+	"rian/internal/tools"
+)
+
+type mode int
+
+const (
+	home mode = iota
+	add
+	addConfirm
+	edit
+	palette
+	commands
+	gitMenu
+	help
+	removeConfirm
+	quitConfirm
+	prompt
+	processView
+)
+
+type Action struct{ ID, Label, Detail, Value, Disabled string }
+type formField struct {
+	label   string
+	input   textinput.Model
+	toggle  bool
+	checked bool
+}
+
+type Model struct {
+	store           *config.Store
+	manager         *process.Manager
+	launcher        tools.System
+	logger          *log.Logger
+	cfg             config.Config
+	width, height   int
+	mode            mode
+	selected        int
+	search          textinput.Model
+	searching       bool
+	query           textinput.Model
+	menuIndex       int
+	menu            []Action
+	available       map[string]bool
+	statuses        map[string]git.Status
+	loading         map[string]bool
+	lastRefresh     map[string]time.Time
+	spin            spinner.Model
+	viewport        viewport.Model
+	toast           string
+	toastError      bool
+	toastID         int
+	busy            bool
+	pending         detect.Result
+	fields          []formField
+	fieldIndex      int
+	editProject     project.Project
+	promptAction    string
+	commandName     textinput.Model
+	commandValue    textinput.Model
+	commandEditing  bool
+	commandField    int
+	commandOriginal string
+	formError       string
+	processID       string
+	processState    process.Snapshot
+	followOutput    bool
+}
+
+type readyMsg struct {
+	cfg       config.Config
+	available map[string]bool
+	err       error
+}
+type inspectedMsg struct {
+	result  detect.Result
+	err     error
+	purpose string
+	id      string
+}
+type gitMsg struct {
+	id     string
+	status git.Status
+}
+type savedMsg struct {
+	cfg        config.Config
+	id, notice string
+	err        error
+}
+type actionMsg struct {
+	id, notice string
+	err        error
+	refresh    bool
+}
+type processMsg struct {
+	id    string
+	state process.Snapshot
+	err   error
+}
+type tickMsg time.Time
+type toastExpired int
+
+func New(store *config.Store, manager *process.Manager, logger *log.Logger) *Model {
+	s := spinner.New(spinner.WithSpinner(spinner.MiniDot), spinner.WithStyle(highlight))
+	return &Model{store: store, manager: manager, logger: logger, search: input("Search projects…"), query: input(""),
+		spin: s, viewport: viewport.New(viewport.WithWidth(60), viewport.WithHeight(12)),
+		statuses: map[string]git.Status{}, loading: map[string]bool{}, lastRefresh: map[string]time.Time{}, available: map[string]bool{}, followOutput: true}
+}
+
+func (m *Model) Init() tea.Cmd {
+	store := m.store
+	return tea.Batch(func() tea.Msg {
+		cfg, err := store.Update(func(*config.Config) error { return nil })
+		return readyMsg{cfg, detect.AvailableTools(), err}
+	}, tick(), m.spin.Tick)
+}
+
+func tick() tea.Cmd { return tea.Tick(time.Second, func(t time.Time) tea.Msg { return tickMsg(t) }) }
+
+func (m *Model) projects() []project.Project { return project.Filter(m.cfg.Projects, m.search.Value()) }
+
+func (m *Model) current() (project.Project, bool) {
+	projects := m.projects()
+	if len(projects) == 0 {
+		return project.Project{}, false
+	}
+	return projects[min(m.selected, len(projects)-1)], true
+}
+
+func (m *Model) selectID(id string) {
+	for i, p := range m.projects() {
+		if p.ID == id {
+			m.selected = i
+			return
+		}
+	}
+	m.selected = min(m.selected, max(0, len(m.projects())-1))
+}
+
+func (m *Model) refresh(p project.Project, force bool) tea.Cmd {
+	if m.loading[p.ID] || !force && time.Since(m.lastRefresh[p.ID]) < 15*time.Second {
+		return nil
+	}
+	m.loading[p.ID] = true
+	return func() tea.Msg { return gitMsg{p.ID, git.Inspect(p.Path)} }
+}
+
+func (m *Model) notify(message string, err error) tea.Cmd {
+	m.toastID++
+	id := m.toastID
+	m.toast, m.toastError = message, err != nil
+	if err != nil {
+		m.toast = err.Error()
+		if m.logger != nil {
+			m.logger.Printf("%s: %v", message, err)
+		}
+	}
+	return tea.Tick(7*time.Second, func(time.Time) tea.Msg { return toastExpired(id) })
+}
+
+func (m *Model) save(id, notice string, change func(*config.Config) error) tea.Cmd {
+	m.busy = true
+	store := m.store
+	return func() tea.Msg { cfg, err := store.Update(change); return savedMsg{cfg, id, notice, err} }
+}
+
+func (m *Model) closeModal() {
+	m.mode = home
+	m.query.Blur()
+	m.formError = ""
+	m.commandEditing = false
+}
+
+func (m *Model) quit() tea.Cmd {
+	if m.manager.Active() > 0 {
+		m.mode = quitConfirm
+		return nil
+	}
+	return tea.Quit
+}
+
+func (m *Model) resize() {
+	w := max(10, min(78, m.width-8))
+	m.query.SetWidth(w - 7)
+	leftWidth := min(44, max(25, (m.width-4)*36/100))
+	if m.width < 84 {
+		leftWidth = max(23, (m.width-4)/2-1)
+	}
+	m.search.SetWidth(max(5, min(42, leftWidth-7)))
+	for i := range m.fields {
+		m.fields[i].input.SetWidth(max(5, w-25))
+	}
+	m.commandName.SetWidth(max(5, w-8))
+	m.commandValue.SetWidth(max(5, w-8))
+	m.viewport.SetWidth(max(5, w-6))
+	viewHeight := m.height - 11
+	if m.mode == processView {
+		viewHeight -= 3
+	}
+	m.viewport.SetHeight(max(1, min(18, viewHeight)))
+	m.viewport.SoftWrap = true
+	if m.mode == help {
+		m.viewport.SetContent(m.helpView(w - 6))
+	}
+}