package main

import (
    "fmt"
    "github.com/charmbracelet/bubbletea"
    "github.com/charmbracelet/lipgloss"
)

type AgentSession struct {
    ID      string
    Status  string  // running, stopped, error
    Output  []string
}

type Model struct {
    sessions []AgentSession
    selected int
}

func (m Model) Init() tea.Cmd {
    return nil
}

func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        switch msg.String() {
        case "q", "ctrl+c":
            return m, tea.Quit
        case "up", "k":
            if m.selected > 0 {
                m.selected--
            }
        case "down", "j":
            if m.selected < len(m.sessions)-1 {
                m.selected++
            }
        case "enter":
            // Switch to selected agent session
            fmt.Printf("Switching to agent: %s\n", m.sessions[m.selected].ID)
        }
    }
    return m, nil
}

func (m Model) View() string {
    var sessionList string
    for i, session := range m.sessions {
        style := lipgloss.NewStyle()
        if i == m.selected {
            style = style.Bold(true).Foreground(lipgloss.Color("#00FF00"))
        }
        sessionList += fmt.Sprintf("%s %s [%s]\n", 
            style.Render("▶"), 
            session.ID, 
            session.Status)
    }
    return fmt.Sprintf("\nAgent Sessions:\n\n%s\n\nPress q to quit\n", sessionList)
}

func main() {
    model := Model{
        sessions: []AgentSession{
            {ID: "code-writer-01", Status: "running"},
            {ID: "debugger-ai", Status: "stopped"},
            {ID: "test-bot", Status: "error"},
        },
    }
    p := bubbletea.NewProgram(model)
    if _, err := p.Run(); err != nil {
        panic(err)
    }
}

The Terminal Tab Apocalypse

Remember when terminal tabs were just for SSH sessions and running your local server? Those were simpler times. Now we need specialized software to manage the terminal sessions of our AI coding agents, which are presumably writing more specialized software to manage their own terminal sessions. It's turtles all the way down, except the turtles are writing Go code and drinking bubble tea.

Because Your AI Needs a Personal Assistant

The sheer absurdity of this project is what makes it brilliant. We've reached peak meta when our AI tools need management tools. Next up: an AI to manage the AI that manages the AI coding agents. I'm calling it "Agent Deck Deck" and it'll be built with Rust and Chai Tea for maximum performance and pretentiousness.

What's particularly amusing is the technology stack choice. Go for performance, Bubble Tea for the TUI (Terminal User Interface). It's like building a Ferrari engine and then putting a teacup holder where the steering wheel should be. The combination says everything about modern tech culture: we want things to be fast, efficient, and also kind of cute.

The Real Problem It Solves

Let's be honest - the actual problem here isn't managing AI agents. The real problem is that we've created so many AI agents that we need to manage them. It's the tech equivalent of buying 15 Roomba vacuums for your studio apartment and then needing a Roomba manager to coordinate them all.

The project currently has 114 stars on GitHub, which in today's economy means it's either:

• A) Revolutionary technology that will change everything
• B) Another weekend project that got slightly more attention than expected
• C) Evidence that we'll build tools for literally anything

My money's on C, with a side of "this is actually useful if you're doing the specific weird thing it's built for."

The Bubble Tea Framework: Serious Business

Nothing says "enterprise-grade software" like naming your framework after a sweet Taiwanese drink. Bubble Tea (the framework, not the beverage) is actually a legitimate TUI library for Go. But let's be real - the naming alone tells you everything about modern developer culture. We've moved past boring names like "Enterprise Window Manager 2.0" to things that sound like they belong on a hipster cafe menu.