gust: init

.gitignore

···
+*.log
+*.txt
+main

cmd/main.go

···
+package main
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/fsnotify/fsnotify"
+	"tangled.sh/oppili.bsky.social/gust"
+)
+
+func main() {
+	if len(os.Getenv("DEBUG")) > 0 {
+		f, err := tea.LogToFile("debug.log", "debug")
+		if err != nil {
+			log.Println("fatal:", err)
+			os.Exit(1)
+		}
+		defer f.Close()
+	}
+
+	// Create new watcher
+	w, err := fsnotify.NewWatcher()
+	if err != nil {
+		log.Println(err)
+	}
+	defer w.Close()
+
+	err = watchRecursively(w, ".")
+	if err != nil {
+		log.Println(err)
+	}
+
+	m := gust.NewModel(w)
+
+	p := tea.NewProgram(m, tea.WithAltScreen())
+	if _, err := p.Run(); err != nil {
+		log.Printf("Error running program: %v\n", err)
+		os.Exit(1)
+	}
+}
+
+func watchRecursively(watcher *fsnotify.Watcher, path string) error {
+	err := filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if info.IsDir() {
+			return watcher.Add(path)
+		}
+		return nil
+	})
+	return err
+}

fs.go

···
+package gust
+
+import (
+	"bufio"
+	"math"
+	"os"
+	"sort"
+	"strconv"
+)
+
+type Fs map[string]Lines
+type Lines map[int]string
+
+func BuildFs(messages []CompilerMessage) Fs {
+	files := make(Fs)
+	for _, msg := range messages {
+		if msg.Location.File != "" {
+			files[msg.Location.File] = nil
+		}
+	}
+
+	for f := range files {
+		fd, err := os.Open(f)
+		if err != nil {
+			// failed to open file
+			continue
+		}
+
+		lines := make(Lines)
+		scanner := bufio.NewScanner(fd)
+		nr := 1
+		for scanner.Scan() {
+			lines[nr] = scanner.Text()
+			nr++
+		}
+
+		if err := scanner.Err(); err != nil {
+			continue
+		}
+
+		files[f] = lines
+	}
+
+	return files
+}
+
+func (lines Lines) Start() int {
+	start := math.MaxInt
+	for lineNum := range lines {
+		start = min(start, lineNum)
+	}
+	return start
+}
+
+func (lines Lines) Ordered() []string {
+	lineNumbers := make([]int, 0, len(lines))
+	for lineNum := range lines {
+		lineNumbers = append(lineNumbers, lineNum)
+	}
+
+	sort.Ints(lineNumbers)
+
+	ordered := []string{}
+	for _, nr := range lineNumbers {
+		ordered = append(ordered, lines[nr])
+	}
+
+	return ordered
+}
+
+func (fs *Fs) PopulateContext(msgs []CompilerMessage, ctxSize int) {
+	for i, m := range msgs {
+		path := m.Location.File
+		file, _ := (*fs)[path]
+		line := m.Location.Line
+
+		if path != "" && line != "" {
+			nr, _ := strconv.Atoi(line)
+			ctx := make(Lines)
+			for i := nr - ctxSize; i <= nr+ctxSize; i++ {
+				if l, ok := file[i]; ok {
+					ctx[i] = l
+				}
+			}
+
+			// extract lines
+			msgs[i].Context = ctx
+		}
+	}
+}

go.mod

···
+module tangled.sh/oppili.bsky.social/gust
+
+go 1.24.1
+
+require (
+	github.com/charmbracelet/bubbles v0.21.0
+	github.com/charmbracelet/bubbletea v1.3.4
+	github.com/charmbracelet/lipgloss v1.1.0
+	github.com/fsnotify/fsnotify v1.9.0
+)
+
+require (
+	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
+	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
+	github.com/charmbracelet/x/ansi v0.8.0 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd // indirect
+	github.com/charmbracelet/x/term v0.2.1 // indirect
+	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-localereader v0.0.1 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/reflow v0.3.0 // indirect
+	github.com/muesli/termenv v0.16.0 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	golang.org/x/sync v0.11.0 // indirect
+	golang.org/x/sys v0.32.0 // indirect
+	golang.org/x/text v0.3.8 // indirect
+)

go.sum

···
+github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
+github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
+github.com/charmbracelet/bubbletea v1.3.4 h1:kCg7B+jSCFPLYRA52SDZjr51kG/fMUEoPoZrkaDHyoI=
+github.com/charmbracelet/bubbletea v1.3.4/go.mod h1:dtcUCyCGEX3g9tosuYiut3MXgY/Jsv9nKVdibKKRRXo=
+github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
+github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
+github.com/charmbracelet/lipgloss v1.1.0 h1:vYXsiLHVkK7fp74RkV7b2kq9+zDLoEU4MZoFqR/noCY=
+github.com/charmbracelet/lipgloss v1.1.0/go.mod h1:/6Q8FR2o+kj8rz4Dq0zQc3vYf7X+B0binUUBwA0aL30=
+github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE=
+github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q=
+github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd h1:vy0GVL4jeHEwG5YOXDmi86oYw2yuYUGqz6a8sLwg0X8=
+github.com/charmbracelet/x/cellbuf v0.0.13-0.20250311204145-2c3ea96c31dd/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
+github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
+github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
+github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
+github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
+github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
+github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
+github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
+github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
+golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=

gust.go

···
+package gust
+
+import (
+	"fmt"
+	"io"
+	"os/exec"
+	"strings"
+	"time"
+
+	"github.com/charmbracelet/bubbles/spinner"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/fsnotify/fsnotify"
+	"github.com/muesli/reflow/wordwrap"
+)
+
+// Model represents the application state
+type Model struct {
+	stderr string
+	stdout string
+
+	mode     string
+	messages []CompilerMessage
+	fs       Fs
+	w        *fsnotify.Watcher
+	options  Options
+	context  int
+
+	status       Status
+	duration     time.Duration
+	systemErrors []error
+
+	width, height int
+}
+
+type Options struct {
+	summarized bool
+	help       bool
+	styles     Styles
+	signs      Signs
+}
+
+type Styles struct {
+	mode      lipgloss.Style
+	success   lipgloss.Style
+	running   lipgloss.Style
+	error     lipgloss.Style
+	warning   lipgloss.Style
+	duration  lipgloss.Style
+	separator lipgloss.Style
+	file      lipgloss.Style
+	line      lipgloss.Style
+	context   ContextStyles
+}
+
+type ContextStyles struct {
+	activeLine    lipgloss.Style
+	activeLineNr  lipgloss.Style
+	passiveLine   lipgloss.Style
+	passiveLineNr lipgloss.Style
+}
+
+type Signs struct {
+	// sign for error messages
+	error string
+	// sign for warning messages
+	warning string
+	// sign for system messages
+	system string
+	// separator for UI bits
+	separator string
+	// indentation prefix string for passive line in context
+	passiveIndent string
+	// indentation prefix string for active line in context
+	activeIndent string
+}
+
+func NewModel(watcher *fsnotify.Watcher) Model {
+	return Model{
+		w:       watcher,
+		mode:    "build",
+		status:  NewStatus(),
+		context: 1,
+		options: Options{
+			summarized: false,
+			help:       true,
+			styles: Styles{
+				mode:      lipgloss.NewStyle().Foreground(lipgloss.Color("5")),
+				success:   lipgloss.NewStyle().Foreground(lipgloss.Color("2")),
+				running:   lipgloss.NewStyle().Foreground(lipgloss.Color("3")),
+				error:     lipgloss.NewStyle().Foreground(lipgloss.Color("1")),
+				warning:   lipgloss.NewStyle().Foreground(lipgloss.Color("3")),
+				file:      lipgloss.NewStyle().Foreground(lipgloss.Color("4")),
+				duration:  lipgloss.NewStyle().Foreground(lipgloss.Color("7")),
+				separator: lipgloss.NewStyle().Foreground(lipgloss.Color("8")),
+				line:      lipgloss.NewStyle().Foreground(lipgloss.Color("15")),
+				context: ContextStyles{
+					activeLine:    lipgloss.NewStyle().Foreground(lipgloss.Color("12")),
+					activeLineNr:  lipgloss.NewStyle().Foreground(lipgloss.Color("12")),
+					passiveLine:   lipgloss.NewStyle().Foreground(lipgloss.Color("12")),
+					passiveLineNr: lipgloss.NewStyle().Foreground(lipgloss.Color("12")),
+				},
+			},
+			signs: Signs{
+				error:         "err",
+				warning:       "wrn",
+				system:        "sys",
+				separator:     " · ",
+				passiveIndent: " |  ",
+				activeIndent:  " >  ",
+			},
+		},
+	}
+}
+
+func (m Model) Init() tea.Cmd {
+	return tea.Batch(reload, m.status.Init())
+}
+
+func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		m.width, m.height = msg.Width, msg.Height
+		return m, nil
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "q", "ctrl+c":
+			return m, tea.Quit
+		case "r":
+			return m, reload
+		case "s":
+			m.options.summarized = !m.options.summarized
+			return m, nil
+		case "h", "?":
+			m.options.help = !m.options.help
+			return m, nil
+		default:
+			return m, nil
+		}
+	case StatusKind, spinner.TickMsg:
+		var cmd tea.Cmd
+		m.status, cmd = m.status.Update(msg)
+		return m, tea.Batch(cmd, m.listen())
+	case modifiedMsg, reloadMsg:
+		m, cmd := m.reload()
+		return m, tea.Batch(cmd, m.listen())
+	default:
+		return m, nil
+	}
+}
+
+func (m Model) View() string {
+	var b strings.Builder
+
+	b.WriteString(m.viewStatus())
+
+	maxLineLen := 1
+	maxColLen := 1
+	for _, msg := range m.messages {
+		lineLen := len(msg.Location.Line)
+		colLen := len(msg.Location.Column)
+
+		if lineLen > maxLineLen {
+			maxLineLen = lineLen
+		}
+		if colLen > maxColLen {
+			maxColLen = colLen
+		}
+	}
+
+	style := m.options.styles
+	sign := m.options.signs
+
+	for _, msg := range m.messages {
+		if msg.Type == "error" {
+			b.WriteString(style.error.Render(sign.error))
+			b.WriteString(" ")
+		} else {
+			b.WriteString(style.warning.Render(sign.warning))
+			b.WriteString(" ")
+		}
+
+		if msg.Location.Line != "" {
+			b.WriteString(style.line.Align(lipgloss.Right).Width(maxLineLen).Render(msg.Location.Line))
+
+			if msg.Location.Column != "" {
+				b.WriteString(":")
+				b.WriteString(style.line.Align(lipgloss.Left).Width(maxColLen).Render(msg.Location.Column))
+			}
+		}
+		if msg.Location.File != "" {
+			b.WriteString(" ")
+			b.WriteString(style.file.Render(msg.Location.File))
+			b.WriteString(" ")
+		}
+
+		b.WriteString(wordwrap.String(msg.Message, m.width))
+
+		// display context
+		if !m.options.summarized {
+			b.WriteString("\n")
+			start := msg.Context.Start()
+			style := style.context
+			for offset, line := range msg.Context.Ordered() {
+				nr := fmt.Sprintf("%d", start+offset)
+				nrStyle := style.passiveLineNr
+				lineStyle := style.passiveLine
+				indent := sign.passiveIndent
+				if msg.Location.Line == nr {
+					nrStyle = style.activeLineNr
+					lineStyle = style.activeLine
+					indent = sign.activeIndent
+				}
+				b.WriteString(nrStyle.Render(indent))
+				b.WriteString(nrStyle.Align(lipgloss.Right).Render(nr))
+				b.WriteString(" ")
+				b.WriteString(lineStyle.Align(lipgloss.Right).Render(line))
+				b.WriteString("\n")
+			}
+		}
+
+		b.WriteString("\n")
+	}
+
+	for _, e := range m.systemErrors {
+		b.WriteString(style.error.Render(sign.system))
+		b.WriteString(" ")
+		b.WriteString(e.Error())
+		b.WriteString("\n")
+	}
+
+	b.WriteString("\n")
+	return b.String()
+}
+
+func (m Model) viewStatus() string {
+	var b strings.Builder
+
+	errorCount := 0
+	warningCount := 0
+	for _, msg := range m.messages {
+		if msg.Type == "error" {
+			errorCount++
+		} else if msg.Type == "warning" {
+			warningCount++
+		}
+	}
+
+	style := m.options.styles
+	sign := m.options.signs
+
+	// write mode
+	b.WriteString(style.mode.Render(m.mode))
+
+	// write status
+	statusStyle := style.success
+	switch m.status.Kind {
+	case Running, Initializing:
+		statusStyle = style.running
+	case Error:
+		statusStyle = style.error
+	}
+	if len(m.messages) == 0 {
+		b.WriteString(style.separator.Render(sign.separator))
+		b.WriteString(statusStyle.Render(m.status.View()))
+	}
+
+	plural := func(n int) string {
+		if n == 1 {
+			return ""
+		} else {
+			return "s"
+		}
+	}
+
+	// write message summary
+	if errorCount != 0 {
+		b.WriteString(style.separator.Render(sign.separator))
+		b.WriteString(style.error.Render(fmt.Sprintf("%d error%s", errorCount, plural(errorCount))))
+	}
+	if warningCount != 0 {
+		b.WriteString(style.separator.Render(sign.separator))
+		b.WriteString(style.warning.Render(fmt.Sprintf("%d warning%s", warningCount, plural(warningCount))))
+	}
+
+	b.WriteString(style.separator.Render(sign.separator))
+	b.WriteString(style.duration.Render(m.duration.String()))
+
+	b.WriteString("\n")
+
+	if m.options.help {
+		b.WriteString(m.viewHelp())
+	}
+	return b.String()
+}
+
+func (m Model) viewHelp() string {
+	var b strings.Builder
+	style := m.options.styles
+	sign := m.options.signs
+
+	b.WriteString("s ")
+	b.WriteString(style.separator.Render("toggle context"))
+	b.WriteString(style.separator.Render(sign.separator))
+
+	if m.mode != "build" {
+		b.WriteString("b ")
+		b.WriteString(style.separator.Render("build"))
+		b.WriteString(style.separator.Render(sign.separator))
+	}
+
+	if m.mode != "run" {
+		b.WriteString("r ")
+		b.WriteString(style.separator.Render("run"))
+		b.WriteString(style.separator.Render(sign.separator))
+	}
+
+	b.WriteString("q ")
+	b.WriteString(style.separator.Render("quit"))
+	b.WriteString(style.separator.Render(sign.separator))
+
+	b.WriteString("h/? ")
+	b.WriteString(style.separator.Render("hide help"))
+
+	return lipgloss.NewStyle().MarginTop(1).Render(b.String())
+}
+
+type reloadMsg struct{}
+
+func reload() tea.Msg {
+	return reloadMsg{}
+}
+
+type modifiedMsg struct{}
+type watcherrMsg struct{}
+
+func (m Model) listen() tea.Cmd {
+	return func() tea.Msg {
+		select {
+		case event, ok := <-m.w.Events:
+			if !ok {
+				return watcherrMsg{}
+			}
+
+			if event.Has(fsnotify.Write | fsnotify.Create | fsnotify.Remove) {
+				return modifiedMsg{}
+			}
+
+			return nil
+
+		case _, ok := <-m.w.Errors:
+			if !ok {
+				return watcherrMsg{}
+			}
+			return watcherrMsg{}
+		}
+	}
+}
+
+func (m Model) reload() (Model, tea.Cmd) {
+	cmd := Success.Cmd()
+	m.systemErrors = []error{}
+
+	command := exec.Command("go", m.mode, "./cmd/main.go")
+	stderr, err := command.StderrPipe()
+	if err != nil {
+		m.systemErrors = append(m.systemErrors, err)
+		cmd = Error.Cmd()
+		return m, cmd
+	}
+
+	stdout, err := command.StdoutPipe()
+	if err != nil {
+		m.systemErrors = append(m.systemErrors, err)
+		cmd = Error.Cmd()
+	}
+
+	start := time.Now()
+	if err := command.Start(); err != nil {
+		m.systemErrors = append(m.systemErrors, err)
+		cmd = Error.Cmd()
+		return m, cmd
+	}
+	end := time.Now()
+
+	stderrData, _ := io.ReadAll(stderr)
+	stdoutData, _ := io.ReadAll(stdout)
+
+	if err := command.Wait(); err != nil {
+		m.systemErrors = append(m.systemErrors, err)
+		cmd = Error.Cmd()
+	}
+
+	m.stderr = string(stderrData)
+	m.stdout = string(stdoutData)
+
+	if m.mode == "build" {
+		messages := Parse(m.stderr)
+		fs := Fs{}
+		if !m.options.summarized {
+			fs = BuildFs(messages)
+			fs.PopulateContext(messages, m.context)
+		}
+		m.messages = messages
+		m.fs = fs
+		m.duration = end.Sub(start)
+
+		if len(m.messages) != 0 {
+			cmd = Error.Cmd()
+		}
+	}
+
+	return m, cmd
+}

parse.go

···
+package gust
+
+import (
+	"bufio"
+	"regexp"
+	"strings"
+)
+
+var (
+	errorWithColumn    = regexp.MustCompile(`(?:\S+: )?([^:]+):(\d+):(\d+): (.+)`)
+	errorWithoutColumn = regexp.MustCompile(`(?:\S+: )?([^:]+):(\d+): (.+)`)
+	cantLoadPackage    = regexp.MustCompile(`can't load package: (.+)`)
+	continuation       = regexp.MustCompile(`^\s+(.+)`)
+)
+
+type CompilerMessage struct {
+	Type     string // "error" or "warning"
+	Location Location
+	Message  string // error message
+	Raw      string // raw message
+	Priority int    // for sorting
+	Context  Lines
+}
+
+type Location struct {
+	File   string
+	Line   string
+	Column string
+}
+
+func Parse(output string) []CompilerMessage {
+	var messages []CompilerMessage
+	var currentMultilineMsg *CompilerMessage
+
+	scanner := bufio.NewScanner(strings.NewReader(output))
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+
+		if strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		if strings.Contains(line, "panic:") {
+			continue
+		}
+
+		if currentMultilineMsg != nil && continuation.MatchString(line) {
+			matches := continuation.FindStringSubmatch(line)
+			if len(matches) >= 2 {
+				currentMultilineMsg.Message += "\n" + matches[1]
+				continue
+			}
+		}
+
+		currentMultilineMsg = nil
+
+		if matches := errorWithColumn.FindStringSubmatch(line); len(matches) >= 5 {
+			msg := CompilerMessage{
+				Type: determineType(matches[4]),
+				Location: Location{
+					File:   matches[1],
+					Line:   matches[2],
+					Column: matches[3],
+				},
+				Message:  matches[4],
+				Raw:      line,
+				Priority: priorityFor(matches[4]),
+			}
+
+			messages = append(messages, msg)
+			currentMultilineMsg = &messages[len(messages)-1]
+			continue
+		}
+
+		if matches := errorWithoutColumn.FindStringSubmatch(line); len(matches) >= 4 {
+			msg := CompilerMessage{
+				Type: determineType(matches[3]),
+				Location: Location{
+					File: matches[1],
+					Line: matches[2],
+				},
+				Message:  matches[3],
+				Raw:      line,
+				Priority: priorityFor(matches[3]),
+			}
+
+			messages = append(messages, msg)
+			currentMultilineMsg = &messages[len(messages)-1]
+			continue
+		}
+
+		if matches := cantLoadPackage.FindStringSubmatch(line); len(matches) >= 2 {
+			msg := CompilerMessage{
+				Type:     "error",
+				Message:  "can't load package: " + matches[1],
+				Raw:      line,
+				Priority: 1, // High priority error
+			}
+
+			messages = append(messages, msg)
+			currentMultilineMsg = &messages[len(messages)-1]
+			continue
+		}
+
+		if strings.Contains(line, "error") || strings.Contains(line, "failed to build") {
+			msg := CompilerMessage{
+				Type:     "error",
+				Message:  line,
+				Raw:      line,
+				Priority: 10, // Lower priority for generic errors
+			}
+
+			messages = append(messages, msg)
+			currentMultilineMsg = &messages[len(messages)-1]
+		}
+	}
+
+	return messages
+}
+
+func determineType(message string) string {
+	lowercase := strings.ToLower(message)
+	if strings.Contains(lowercase, "error") {
+		return "error"
+	} else if strings.Contains(lowercase, "warning") || strings.Contains(lowercase, "vet") {
+		return "warning"
+	}
+	return "error"
+}
+
+func priorityFor(message string) int {
+	lowercase := strings.ToLower(message)
+	if strings.Contains(lowercase, "warning") {
+		return 0 // Warnings first
+	} else if strings.Contains(lowercase, "syntax error") {
+		return 1 // Syntax errors next
+	} else if strings.Contains(lowercase, "undefined") {
+		return 2 // Undefined references next
+	} else {
+		return 5 // Other errors
+	}
+}

status.go

···
+package gust
+
+import (
+	"fmt"
+
+	"github.com/charmbracelet/bubbles/spinner"
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type Status struct {
+	Kind    StatusKind
+	Spinner spinner.Model
+}
+
+func NewStatus() Status {
+	return Status{
+		Kind:    Initializing,
+		Spinner: spinner.New(spinner.WithSpinner(spinner.Line)),
+	}
+}
+
+type StatusKind int
+
+const (
+	Initializing StatusKind = iota
+	Success
+	Running
+	Error
+)
+
+func (s StatusKind) String() string {
+	switch s {
+	case Initializing:
+		return "initializing"
+	case Success:
+		return "success"
+	case Running:
+		return "running"
+	case Error:
+		return "error"
+	default:
+		return "error"
+	}
+}
+
+func (s StatusKind) Cmd() tea.Cmd {
+	return func() tea.Msg {
+		return s
+	}
+}
+
+func (s StatusKind) Style() spinner.Spinner {
+	switch s {
+	case Initializing:
+		return spinner.Dot
+	case Success:
+		return spinner.Jump
+	default:
+		return spinner.Dot
+	}
+}
+
+func (s Status) Init() tea.Cmd {
+	return tea.Batch(Initializing.Cmd(), s.Spinner.Tick)
+}
+
+func (s Status) Update(msg tea.Msg) (Status, tea.Cmd) {
+	switch msg := msg.(type) {
+	case StatusKind:
+		s.Kind = msg
+		s.Spinner.Spinner = s.Kind.Style()
+		return s, nil
+	case spinner.TickMsg:
+		var cmd tea.Cmd
+		s.Spinner, cmd = s.Spinner.Update(msg)
+		return s, cmd
+	}
+
+	return s, nil
+}
+
+func (s Status) View() string {
+	switch s.Kind {
+	case Initializing:
+		return fmt.Sprintf("initializing %s", s.Spinner.View())
+	case Success:
+		return fmt.Sprintf("success")
+	case Running:
+		return fmt.Sprintf("running %s", s.Spinner.View())
+	case Error:
+		return "error"
+	default:
+		return "error"
+	}
+}