vibepup 1.0.2 → 1.0.3

package/tui/main.go

@@ -4,17 +4,52 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"os/exec"
-	"strings"
 	"time"
 
+	"github.com/charmbracelet/bubbles/help"
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/spinner"
 	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/harmonica"
 	"github.com/charmbracelet/huh"
 	"github.com/charmbracelet/lipgloss"
-	"github.com/charmbracelet/log"
+	"github.com/mattn/go-isatty"
+
+	"vibepup-tui/config"
+	"vibepup-tui/motion"
+	"vibepup-tui/persona"
+	"vibepup-tui/process"
+	"vibepup-tui/theme"
+	"vibepup-tui/ui"
 )
 
+// --- Key Bindings ---
+
+type KeyMap struct {
+	Quit      key.Binding
+	Help      key.Binding
+	NextTheme key.Binding
+	Pet       key.Binding
+}
+
+func DefaultKeyMap() KeyMap {
+	return KeyMap{
+		Quit: key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
+		Help: key.NewBinding(key.WithKeys("?"), key.WithHelp("?", "help")),
+		NextTheme: key.NewBinding(key.WithKeys("t"), key.WithHelp("t", "theme")),
+		Pet: key.NewBinding(key.WithKeys("p"), key.WithHelp("p", "pet dog")),
+	}
+}
+
+func (k KeyMap) ShortHelp() []key.Binding {
+	return []key.Binding{k.Help, k.Quit, k.NextTheme, k.Pet}
+}
+
+func (k KeyMap) FullHelp() [][]key.Binding {
+	return [][]key.Binding{{k.Help, k.Quit, k.NextTheme, k.Pet}}
+}
+
+// --- Model ---
+
 type viewState int
 
 const (
@@ -25,257 +60,293 @@ const (
 )
 
 type model struct {
-	state     viewState
-	start     time.Time
-	frame     int
-	args      []string
-	form      *huh.Form
-	newForm   *huh.Form
-	selected  string
-	newIdea   string
-	spring    harmonica.Spring
-	pos       float64
-	velocity  float64
-	targetPos float64
+	state      viewState
+	width      int
+	height     int
+	ready      bool
+	
+	// Components
+	keys       KeyMap
+	help       help.Model
+	form       *huh.Form
+	newForm    *huh.Form
+	viewport   ui.LogViewport
+	spinner    spinner.Model
+	
+	// Config & State
+	flags      config.Flags
+	theme      theme.Theme
+	styles     lipgloss.Style // Simplified, use theme package directly where possible
+	snark      persona.SnarkLevel
+	
+	// Process
+	runner     *process.Runner
+	selected   string
+	newIdea    string
+	args       []string
+	
+	// Animation
+	motion     motion.Engine
+	frame      int
+	dogState   string // "sleeping", "running", "barking", "happy"
 }
 
-func initialModel() model {
-	args := []string{"--watch"}
-	if len(os.Args) > 1 {
-		args = os.Args[1:]
-	}
+func initialModel(flags config.Flags) model {
+	th := theme.Get(flags.Theme)
+	snark := persona.ParseSnark(flags.Snark)
+	
+	s := spinner.New()
+	s.Spinner = spinner.Points // More modern spinner
+	s.Style = lipgloss.NewStyle().Foreground(th.Highlight)
 
-	spring := harmonica.NewSpring(harmonica.FPS(60), 6.0, 0.2)
+	m := model{
+		state:    stateSplash,
+		keys:     DefaultKeyMap(),
+		help:     help.New(),
+		flags:    flags,
+		theme:    th,
+		snark:    snark,
+		motion:   motion.New(flags.PerfLow, flags.Quiet),
+		spinner:  s,
+		dogState: "sleeping",
+		selected: "watch", // Default
+		args:     os.Args[1:],
+	}
 
-	m := model{state: stateSplash, start: time.Now(), args: args, selected: "watch", spring: spring, targetPos: 10}
+	// Setup Form
 	m.form = huh.NewForm(
 		huh.NewGroup(
 			huh.NewSelect[string]().
-				Title("♥ What shall we do today? ♥").
+				Title("♥ Pick your poison ♥").
 				Options(
-					huh.NewOption("Watch (recommended)", "watch"),
-					huh.NewOption("Run 5 iterations", "run"),
-					huh.NewOption("New project from idea", "new"),
-					huh.NewOption("Free setup (opencode + auth)", "free"),
+					huh.NewOption("Watch Mode (Stalker vibes)", "watch"),
+					huh.NewOption("Run 5 Loops (Quickie)", "run"),
+					huh.NewOption("New Project (YOLO)", "new"),
+					huh.NewOption("Free Setup (Broke af)", "free"),
 				).
 				Value(&m.selected),
 		),
-	)
+	).WithTheme(huh.ThemeDracula())
+
 	m.newForm = huh.NewForm(
 		huh.NewGroup(
 			huh.NewInput().
-				Title("Describe your project idea").
-				Prompt("Idea: ").
-				Placeholder("A vibe-coded project").
+				Title("Spill the tea ☕").
+				Prompt("Manifest: ").
+				Placeholder("Make me a unicorn...").
 				Value(&m.newIdea),
 		),
-	)
+	).WithTheme(huh.ThemeDracula())
 
 	return m
 }
 
 func (m model) Init() tea.Cmd {
-	log.SetLevel(log.InfoLevel)
-	log.SetReportCaller(false)
-	log.SetTimeFormat("")
-	return tea.Tick(time.Millisecond*80, func(t time.Time) tea.Msg { return t })
+	return tea.Batch(
+		m.motion.Next(),
+		m.spinner.Tick,
+	)
 }
 
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmds []tea.Cmd
+	var cmd tea.Cmd
+
 	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		m.width = msg.Width
+		m.height = msg.Height
+		m.help.Width = msg.Width
+		
+		// Dynamic Layout Calculation
+		headerHeight := 10 // Approximation, should be measured
+		footerHeight := 3
+		vpHeight := msg.Height - headerHeight - footerHeight - 2 // Borders
+		
+		if !m.ready {
+			m.viewport = ui.NewLogViewport(msg.Width-4, vpHeight)
+			m.ready = true
+		} else {
+			m.viewport.SetSize(msg.Width-4, vpHeight)
+		}
+
 	case tea.KeyMsg:
-		if msg.String() == "ctrl+c" || msg.String() == "esc" {
+		if m.state == stateRunning && m.runner != nil {
+			// Pass interactions to viewport if needed
+		}
+		
+		switch {
+		case key.Matches(msg, m.keys.Quit):
+			if m.runner != nil {
+				m.runner.Kill() // ZOMBIE KILLER
+			}
 			return m, tea.Quit
+		case key.Matches(msg, m.keys.Pet):
+			m.dogState = "happy"
+			cmds = append(cmds, tea.Tick(time.Second, func(t time.Time) tea.Msg {
+				return "dog_reset"
+			}))
 		}
-	case time.Time:
-		switch m.state {
-		case stateSplash:
-			m.frame++
-			if time.Since(m.start) > time.Second*2 {
-				m.state = stateSetup
-				return m, m.form.Init()
+
+	case string:
+		if msg == "dog_reset" {
+			if m.runner != nil {
+				m.dogState = "running"
+			} else {
+				m.dogState = "sleeping"
 			}
-			return m, tea.Tick(time.Millisecond*80, func(t time.Time) tea.Msg { return t })
-		case stateRunning:
-			m.frame++
-			if m.frame%20 == 0 {
-				if m.targetPos == 0 {
-					m.targetPos = 10
+		}
+
+	case motion.TickMsg:
+		m.frame++
+		cmds = append(cmds, m.motion.Next())
+
+	case spinner.TickMsg:
+		m.spinner, cmd = m.spinner.Update(msg)
+		cmds = append(cmds, cmd)
+
+	case process.OutputMsg:
+		m.viewport.WriteLine(string(msg))
+		cmds = append(cmds, m.runner.WaitForOutput())
+
+	case process.DoneMsg:
+		m.dogState = "sleeping"
+		m.viewport.WriteLine("\n--- Process Finished ---")
+		if msg.Err != nil {
+			m.viewport.WriteLine(fmt.Sprintf("Error: %v", msg.Err))
+			m.dogState = "barking"
+		}
+		m.runner = nil
+	}
+
+	// Handle Forms
+	if m.state == stateSetup {
+		form, cmd := m.form.Update(msg)
+		if f, ok := form.(*huh.Form); ok {
+			m.form = f
+			if m.form.State == huh.StateCompleted {
+				if m.selected == "new" {
+					m.state = stateRunning
+					cmds = append(cmds, m.newForm.Init())
 				} else {
-					m.targetPos = 0
+					m.state = stateRunning
+					cmds = append(cmds, m.startProcess())
 				}
 			}
-			m.pos, m.velocity = m.spring.Update(m.pos, m.velocity, m.targetPos)
-			return m, tea.Tick(time.Millisecond*80, func(t time.Time) tea.Msg { return t })
 		}
+		cmds = append(cmds, cmd)
 	}
 
-	switch m.state {
-	case stateSetup:
-		fm, cmd := m.form.Update(msg)
-		m.form = fm.(*huh.Form)
-		if m.form.State == huh.StateCompleted {
-			if m.selected == "new" {
-				m.state = stateRunning
-				return m, m.newForm.Init()
-			}
-			m.state = stateRunning
-			return m, launchCmd(m.selected, m.args)
-		}
-		return m, cmd
-	case stateRunning:
-		if m.selected == "new" {
-			fm, cmd := m.newForm.Update(msg)
-			m.newForm = fm.(*huh.Form)
+	if m.state == stateRunning && m.selected == "new" && m.runner == nil {
+		form, cmd := m.newForm.Update(msg)
+		if f, ok := form.(*huh.Form); ok {
+			m.newForm = f
 			if m.newForm.State == huh.StateCompleted {
-				idea := strings.TrimSpace(m.newIdea)
-				if idea == "" {
-					idea = "A vibe-coded project"
-				}
-				return m, launchCmd("new", append([]string{idea}, m.args...))
+				m.args = append(m.args, "new", m.newIdea)
+				cmds = append(cmds, m.startProcess())
 			}
-			return m, cmd
 		}
+		cmds = append(cmds, cmd)
 	}
-
-	return m, nil
-}
-
-func (m model) View() string {
-	// Theme Palette
-	pink := lipgloss.Color("#FFB7C5")     // Sakura Pink
-	hotPink := lipgloss.Color("#FF69B4")  // Hot Pink
-	babyBlue := lipgloss.Color("#89CFF0") // Baby Blue
-	lavender := lipgloss.Color("#E6E6FA") // Lavender
-	gray := lipgloss.Color("245")         // Muted Gray
-
-	// Layout Styles
-	boxStyle := lipgloss.NewStyle().
-		Border(lipgloss.RoundedBorder()).
-		BorderForeground(pink).
-		Padding(1, 2).
-		Margin(1, 1)
-
-	titleStyle := lipgloss.NewStyle().
-		Foreground(hotPink).
-		Background(lavender).
-		Bold(true).
-		Padding(0, 1).
-		MarginBottom(1)
-
-	// Animation Frames
-	frames := []string{
-		"૮ ˶ᵔ ᵕ ᵔ˶ ა",        // Happy
-		"૮ ˶• ﻌ •˶ ა",        // Alert
-		"૮ ≧ ﻌ ≦ ა",          // Blink
-		"૮ / ˶ • ﻌ • ˶ \\ ა", // Paws up
+	
+	// Auto-advance splash
+	if m.state == stateSplash && m.frame > 100 {
+		m.state = stateSetup
 	}
 
-	// Sparkle Animation
-	sparkles := []string{"｡･ﾟ✧", "✧･ﾟ｡", "｡･ﾟ★", "☆･ﾟ｡"}
-
-	// Frame Calculations
-	// Slow down the dog animation (every 4th frame)
-	idx := (m.frame / 4) % len(frames)
-	// Fast sparkles (every 2nd frame)
-	sIdx := (m.frame / 2) % len(sparkles)
+	// Update viewport
+	if m.ready {
+		m.viewport, cmd = m.viewport.Update(msg)
+		cmds = append(cmds, cmd)
+	}
 
-	currentDog := frames[idx]
-	currentSparkle := sparkles[sIdx]
+	return m, tea.Batch(cmds...)
+}
 
-	// Spring Animation (Horizontal movement)
-	pad := ""
-	if m.pos > 0 {
-		pad = strings.Repeat(" ", int(m.pos))
+func (m *model) startProcess() tea.Cmd {
+	if !m.flags.ForceRun && !isatty.IsTerminal(os.Stdout.Fd()) {
+		m.viewport.WriteLine("Error: Not a TTY. Use --force-run.")
+		return nil
 	}
 
-	// Common Elements
-	dogRender := lipgloss.NewStyle().Foreground(pink).Render(pad + currentDog + " " + currentSparkle)
+	args := m.args
+	if m.selected == "watch" {
+		args = append([]string{"--watch"}, args...)
+	} else if m.selected == "run" {
+		args = append([]string{"5"}, args...)
+	} else if m.selected == "free" {
+		args = []string{"free"}
+	}
+	
+	// Actually invoke the CLI (ralph.js -> ralph.sh mechanism, but we call 'vibepup' assuming it's in path or we call the shell script directly)
+	// For local dev, we might need to call the script directly if 'vibepup' isn't in PATH.
+	// But let's assume 'vibepup' is the command.
+	runCmd := "vibepup"
+	if m.flags.Runner != "" {
+		runCmd = m.flags.Runner
+	}
+	
+	// If running locally from repo, we might want to call the script directly?
+	// The user said "run this project from the build".
+	// We'll stick to "vibepup" and assume it's linked or we can use absolute path if needed.
+	// Let's use the first arg as the command if provided, or default to "vibepup"
+	
+	m.dogState = "running"
+	m.viewport.WriteLine("--- Starting Vibepup ---")
+	
+	var cmd tea.Cmd
+	m.runner, cmd = process.Start(context.Background(), runCmd, args)
+	
+	return tea.Batch(cmd, m.runner.WaitForOutput())
+}
 
-	// Splash Screen Content
-	splashContent := lipgloss.JoinVertical(lipgloss.Center,
-		titleStyle.Render("♥ Vibepup TUI ♥"),
-		"",
-		dogRender,
-		"",
-		lipgloss.NewStyle().Foreground(gray).Render("Loading cuteness..."),
-	)
+func (m model) View() string {
+	if !m.ready {
+		return "Initializing..."
+	}
 
-	switch m.state {
-	case stateSplash:
-		return boxStyle.Render(splashContent)
-
-	case stateSetup:
-		return boxStyle.Render(
-			lipgloss.JoinVertical(lipgloss.Left,
-				lipgloss.NewStyle().Foreground(babyBlue).Bold(true).Render("♥ Setup Phase"),
-				lipgloss.NewStyle().Foreground(gray).Render("Tip: choose Free setup to auto-configure opencode"),
-				"",
-				m.form.View(),
+	// 1. Splash
+	if m.state == stateSplash {
+		return ui.BoxStyle.Render(
+			lipgloss.JoinVertical(lipgloss.Center,
+				lipgloss.NewStyle().Foreground(m.theme.Accent).Render("♥ VIBEPUP TUI ♥"),
+				"\nLoading Vibes...\n",
+				m.spinner.View(),
 			),
 		)
-	case stateRunning:
+	}
+
+	// 2. Form
+	if m.state == stateSetup || (m.state == stateRunning && m.runner == nil && m.selected == "new" && m.newForm.State != huh.StateCompleted) {
+		form := m.form.View()
 		if m.selected == "new" {
-			return boxStyle.Render(
-				lipgloss.JoinVertical(lipgloss.Left,
-					lipgloss.NewStyle().Foreground(babyBlue).Bold(true).Render("♥ New Project"),
-					lipgloss.NewStyle().Foreground(gray).Render("Describe what you want Vibepup to build"),
-					"",
-					m.newForm.View(),
-				),
-			)
+			form = m.newForm.View()
 		}
-		status := lipgloss.NewStyle().Foreground(hotPink).Bold(true).Render("♥ Vibepup is Working ♥")
-		mode := lipgloss.NewStyle().Foreground(babyBlue).Render("MODE: " + strings.ToUpper(m.selected))
-		spinner := sparkles[m.frame%len(sparkles)]
-
-		content := lipgloss.JoinVertical(lipgloss.Left,
-			status,
-			mode,
-			"",
-			lipgloss.NewStyle().Foreground(gray).Render(spinner+" Running engine... (check output below)"),
-			"",
-			dogRender,
-		)
-		return boxStyle.Render(content)
-
-	case stateDone:
-		return boxStyle.Render(
-			lipgloss.NewStyle().Foreground(hotPink).Bold(true).Render("♥ All Done! Good Pup! ♥"),
-		)
-
-	default:
-		return boxStyle.Render(splashContent)
+		return ui.BoxStyle.Render(lipgloss.JoinVertical(lipgloss.Left,
+			lipgloss.NewStyle().Foreground(m.theme.Accent).Render("SETUP"),
+			form,
+		))
 	}
-}
 
-func launchCmd(choice string, args []string) tea.Cmd {
-	return func() tea.Msg {
-		ctx := context.Background()
-		if choice == "watch" {
-			args = append([]string{"--watch"}, args...)
-		}
-		if choice == "run" {
-			args = append([]string{"5"}, args...)
-		}
-		if choice == "new" {
-			args = append([]string{"new", "A vibe-coded project"}, args...)
-		}
+	// 3. Running
+	header := lipgloss.JoinVertical(lipgloss.Left,
+		lipgloss.NewStyle().Foreground(m.theme.Highlight).Render("♥ "+persona.GetStatus(m.selected, m.snark)+" ♥ "+m.spinner.View()),
+		motion.GetDogFrame(m.dogState, m.frame),
+		persona.RandomQuip(m.snark),
+	)
 
-		log.Info("Starting Vibepup", "args", strings.Join(args, " "))
-		cmd := exec.CommandContext(ctx, "bash", "-lc", "vibepup "+strings.Join(args, " "))
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		cmd.Stdin = os.Stdin
-		_ = cmd.Run()
-		return tea.Quit()
-	}
+	return ui.BoxStyle.Render(lipgloss.JoinVertical(lipgloss.Left,
+		header,
+		m.viewport.View(),
+		m.help.View(m.keys),
+	))
 }
 
 func main() {
-	p := tea.NewProgram(initialModel())
-	if _, err := p.Run(); err != nil {
-		fmt.Println("failed to start vibepup tui")
+	flags := config.Parse()
+	m := initialModel(flags)
+	if _, err := tea.NewProgram(m, tea.WithAltScreen()).Run(); err != nil {
+		fmt.Println("Error:", err)
 		os.Exit(1)
 	}
 }

package/tui/motion/engine.go

@@ -0,0 +1,86 @@
+package motion
+
+import (
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/Nomadcxx/sysc-Go/animations"
+)
+
+type TickMsg time.Time
+
+type Engine struct {
+	Quiet   bool
+	LowPerf bool
+	Effect  animations.Animation
+}
+
+func New(lowPerf, quiet bool) Engine {
+	// Initialize default effect (Matrix Rain)
+	// sysc-Go animations usually need initialization
+	// For now, we'll just placeholder it or use a simple one if available
+	return Engine{
+		Quiet:   quiet,
+		LowPerf: lowPerf,
+	}
+}
+
+func (e Engine) Next() tea.Cmd {
+	d := time.Millisecond * 1000 / 60
+	if e.LowPerf {
+		d = time.Millisecond * 1000 / 15
+	}
+	return tea.Tick(d, func(t time.Time) tea.Msg {
+		return TickMsg(t)
+	})
+}
+
+// ASCII Dog Sprites
+var DogSleeping = []string{
+	"      z",
+	"     z ",
+	"    Z  ",
+	"૮ – ﻌ – ა",
+}
+
+var DogRunning = []string{
+	"            ",
+	"            ",
+	"            ",
+	"૮ ˶ᵔ ᵕ ᵔ˶ ა", // Frame 1
+	"            ",
+	"            ",
+	"            ",
+	"૮ ˶• ﻌ •˶ ა", // Frame 2
+}
+
+var DogBarking = []string{
+	"    WOOF!   ",
+	"            ",
+	"            ",
+	"૮ ≧ ﻌ ≦ ა",
+}
+
+// GetDogFrame returns the current frame for the dog state
+func GetDogFrame(state string, frame int) string {
+	switch state {
+	case "sleeping":
+		// Animate Zzz
+		zzz := []string{"", "z", "zz", "zzz"}
+		return "      " + zzz[(frame/30)%4] + "\n" + DogSleeping[3]
+	case "barking":
+		if (frame/10)%2 == 0 {
+			return DogBarking[0] + "\n" + DogBarking[3]
+		}
+		return "            \n" + DogBarking[3]
+	case "happy":
+		// Jump animation
+		if (frame/5)%2 == 0 {
+			return "            \n" + "૮ ˶ᵔ ᵕ ᵔ˶ ა" // Up
+		}
+		return "            \n" + "૮ ˶• ﻌ •˶ ა" // Down
+	default: // Running
+		frames := []string{"૮ ˶ᵔ ᵕ ᵔ˶ ა", "૮ ˶• ﻌ •˶ ა"}
+		return "            \n" + frames[(frame/10)%len(frames)]
+	}
+}