@fatalmistake02/rian 0.0.0-stage → 0.2.1

package/internal/ui/view.go

@@ -0,0 +1,459 @@
+package ui
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	tea "charm.land/bubbletea/v2"
+	"charm.land/lipgloss/v2"
+
+	"rian/internal/detect"
+	"rian/internal/project"
+)
+
+func (m *Model) View() tea.View {
+	if m.width == 0 {
+		v := tea.NewView("Starting Rian…")
+		v.AltScreen = true
+		return v
+	}
+	var content string
+	if m.width < 52 || m.height < 16 {
+		content = fit(highlight.Bold(true).Render("RIAN")+"\n\n"+muted.Render("Resize to at least 52 × 16.\nYour projects are ready when you are.\n\nq quit · Ctrl+K actions"), m.width)
+	} else {
+		content = m.homeView()
+		if m.mode != home {
+			modal := m.modalView()
+			x, y := max(0, (m.width-lipgloss.Width(modal))/2), max(0, (m.height-lipgloss.Height(modal))/2)
+			content = lipgloss.NewCompositor(lipgloss.NewLayer(content), lipgloss.NewLayer(modal).X(x).Y(y).Z(1)).Render()
+		}
+	}
+	// A toast is also visible over a modal, where most validation happens.
+	if m.toast != "" && m.height >= 16 && m.width >= 52 {
+		style := muted
+		if m.toastError {
+			style = warning
+		}
+		toast := lipgloss.NewStyle().Background(background).Padding(0, 1).Render(style.Render(fit(oneLine(m.toast), m.width-6)))
+		content = lipgloss.NewCompositor(lipgloss.NewLayer(content), lipgloss.NewLayer(toast).X(2).Y(m.height-1).Z(2)).Render()
+	}
+	v := tea.NewView(content)
+	v.AltScreen, v.ReportFocus, v.WindowTitle = true, true, "Rian · Projects"
+	v.BackgroundColor, v.ForegroundColor = background, foreground
+	return v
+}
+
+func (m *Model) homeView() string {
+	w, h := m.width-4, m.height-6
+	head := highlight.Bold(true).Render("RIAN") + muted.Render("  /  your project desk")
+	right := keyHint("Ctrl+K", "actions")
+	header := "  " + head + strings.Repeat(" ", max(1, w-lipgloss.Width(head)-lipgloss.Width(right))) + right
+	leftW := min(44, max(25, w*36/100))
+	if m.width < 84 {
+		leftW = max(23, w/2-1)
+	}
+	rightW := w - leftW - 1
+	left := box(m.listView(leftW-4, h-2), leftW, h, m.mode == home)
+	rightPanel := box(m.detailView(rightW-4, h-2), rightW, h, false)
+	body := lipgloss.JoinHorizontal(lipgloss.Top, left, " ", rightPanel)
+	footer := keyHint("↑↓ / jk", "navigate") + "   " + keyHint("a", "add") + "   " + keyHint("/", "search") + "   " + keyHint("?", "help") + "   " + keyHint("q", "quit")
+	if m.busy {
+		footer = m.spin.View() + muted.Render(" Working…")
+	}
+	return header + "\n\n" + lipgloss.NewStyle().MarginLeft(2).Render(body) + "\n " + fit(footer, m.width-2) + "\n\n"
+}
+
+func (m *Model) listView(width, height int) string {
+	projects := m.projects()
+	heading := titleStyle.Render("PROJECTS") + muted.Render(fmt.Sprintf("  %d", len(projects)))
+	lines := []string{pad(heading, width), ""}
+	if m.searching || m.search.Value() != "" {
+		lines = append(lines, fit(highlight.Render("/ ")+m.search.View(), width), "")
+	}
+	if len(projects) == 0 {
+		if m.search.Value() != "" {
+			lines = append(lines, muted.Render("No matching projects."), "", muted.Render("Esc clears your search."))
+		} else {
+			lines = append(lines, "", titleStyle.Render("A home for your work."), "", fit(muted.Render("Save a directory once."), width), fit(muted.Render("Pick up where you left off."), width), "", keyHint("a", "Add your first project"))
+		}
+		return strings.Join(lines, "\n")
+	}
+	visible := max(1, (height-len(lines)-2)/3)
+	start := max(0, m.selected-visible+1)
+	end := min(len(projects), start+visible)
+	for i := start; i < end; i++ {
+		p := projects[i]
+		prefix := "  "
+		if i == m.selected {
+			prefix = "› "
+		}
+		name := oneLine(p.Name)
+		if p.Favorite {
+			name = "★ " + name
+		}
+		status := m.statuses[p.ID]
+		branch := fit(oneLine(status.Branch), min(11, width/3))
+		marker := ""
+		if status.Repository {
+			if status.Dirty() {
+				marker = warning.Render(" ●")
+			} else {
+				marker = good.Render(" ○")
+			}
+		}
+		if m.loading[p.ID] {
+			marker = " " + m.spin.View()
+		}
+		meta := muted.Render(branch) + marker
+		nameWidth := max(4, width-lipgloss.Width(meta)-3)
+		row := pad(prefix+fit(name, nameWidth-2), width-lipgloss.Width(meta)) + meta
+		if i == m.selected {
+			row = selectedStyle.Render(row)
+		} else {
+			row = textStyle.Render(row)
+		}
+		lines = append(lines, row, muted.Render(pad("  "+shortPath(p.Path), width)), "")
+	}
+	for len(lines) < height-1 {
+		lines = append(lines, "")
+	}
+	position := fmt.Sprintf("%d of %d", min(m.selected+1, len(projects)), len(projects))
+	if len(projects) > visible {
+		position += " · scroll ↑↓"
+	}
+	lines = append(lines, muted.Render(fit(position, width)))
+	return strings.Join(lines, "\n")
+}
+
+func (m *Model) detailView(width, height int) string {
+	p, ok := m.current()
+	if !ok {
+		return strings.Join([]string{titleStyle.Render("READY WHEN YOU ARE"), "", "", highlight.Render("Local projects. Less friction."), "", fit(muted.Render("Open your editor, coding tools, and commands"), width), fit(muted.Render("from one keyboard-first workspace."), width), "", keyHint("a", "add a project"), keyHint("Ctrl+K", "browse actions")}, "\n")
+	}
+	s := m.statuses[p.ID]
+	lines := []string{titleStyle.Render(fit(oneLine(p.Name), width)), muted.Render(fit(shortPath(p.Path), width)), ""}
+	if len(p.Stack) > 0 {
+		lines = append(lines, muted.Render(fit(strings.Join(p.Stack, " · "), width)), "")
+	}
+	label := func(name, value string) string {
+		return muted.Render(pad(name, min(14, width/3))) + textStyle.Render(fit(oneLine(value), max(1, width-min(14, width/3))))
+	}
+	repo := p.GitHub
+	if repo == "" {
+		repo = s.GitHub
+	}
+	if repo != "" {
+		lines = append(lines, highlight.Render("GITHUB"), textStyle.Render(fit(oneLine(repo), width)), "")
+	}
+	if s.Repository {
+		state := good.Render("○ clean")
+		if s.Dirty() {
+			state = warning.Render("● changes")
+		}
+		lines = append(lines, label("Branch", s.Branch), label("Status", "")+state, label("Modified", fmt.Sprint(s.Modified)), label("Untracked", fmt.Sprint(s.Untracked)), label("Ahead / back", fmt.Sprintf("↑ %d   ↓ %d", s.Ahead, s.Behind)), "")
+		if s.Commit != "" {
+			lines = append(lines, muted.Render("LAST COMMIT"), fit(oneLine(s.Commit), width), muted.Render(relativeTime(s.CommitTime)), "")
+		}
+		if s.Remote != "" && repo == "" {
+			lines = append(lines, label("Remote", s.Remote))
+		}
+	} else if m.loading[p.ID] {
+		lines = append(lines, m.spin.View()+muted.Render(" Reading Git status…"), "")
+	} else {
+		lines = append(lines, muted.Render("No Git repository detected."), "")
+	}
+	if s.Error != "" {
+		lines = append(lines, fit(warning.Render(s.Error), width))
+	}
+	state := m.manager.Snapshot(p.ID)
+	if state.Command != "" {
+		status := "stopped"
+		if state.Running {
+			status = "running"
+		}
+		lines = append(lines, highlight.Render("PROCESS · "+status), fit(oneLine(state.Command), width), keyHint("p", "output"), "")
+	}
+	if !p.LastUsed.IsZero() {
+		lines = append(lines, muted.Render("Used "+relativeTime(p.LastUsed)), "")
+	}
+	// Keep the action hints anchored below the details at every terminal size.
+	hints := []string{keyHint("v", "VS Code") + "   " + keyHint("o", "OpenCode"), keyHint("K", "KiloCode") + "  " + keyHint("c", "ChatGPT"), keyHint("t", "Terminal") + "  " + keyHint("g", "GitHub"), keyHint("r", "Run") + "  " + keyHint("d", "Commands") + "  " + keyHint("G", "Git")}
+	space := max(2, height-len(hints)-1)
+	if len(lines) > space {
+		lines = lines[:space]
+	}
+	for len(lines) < space {
+		lines = append(lines, "")
+	}
+	lines = append(lines, muted.Render(strings.Repeat("─", width)))
+	for _, hint := range hints {
+		lines = append(lines, fit(hint, width))
+	}
+	return strings.Join(lines, "\n")
+}
+
+func (m *Model) modalView() string {
+	w := max(20, min(78, m.width-8))
+	inner := w - 6
+	var body, title, footer string
+	switch m.mode {
+	case add:
+		title = "ADD PROJECT"
+		body = muted.Render("Choose a directory. Rian will inspect it first.") + "\n\n" + m.query.View()
+		footer = keyHint("Enter", "inspect") + "   " + keyHint("Esc", "cancel")
+	case addConfirm:
+		title = "PROJECT FOUND"
+		body = m.viewport.View()
+		footer = keyHint("Enter", "save project") + "   " + keyHint("↑↓", "scroll") + "   " + keyHint("Esc", "cancel")
+	case edit:
+		title = "EDIT PROJECT"
+		lines := []string{muted.Render("Commands: press d, then Ctrl+N / Ctrl+E."), ""}
+		visible := max(3, min(len(m.fields), m.height-13))
+		start := max(0, m.fieldIndex-visible+1)
+		for i := start; i < min(len(m.fields), start+visible); i++ {
+			field := m.fields[i]
+			label := muted.Render(pad(field.label, 16))
+			value := field.input.View()
+			if field.toggle {
+				value = muted.Render("[ ] disabled")
+				if field.checked {
+					value = good.Render("[✓] enabled")
+				}
+				if field.label == "Favorite" {
+					value = "[ ]"
+					if field.checked {
+						value = highlight.Render("[★]")
+					}
+				}
+			}
+			prefix := "  "
+			if i == m.fieldIndex {
+				prefix = highlight.Render("› ")
+				label = textStyle.Render(pad(field.label, 16))
+			}
+			lines = append(lines, fit(prefix+label+value, inner))
+		}
+		body = strings.Join(lines, "\n")
+		footer = keyHint("Tab / ↑↓", "field") + "  " + keyHint("Space", "toggle") + "  " + keyHint("Ctrl+S", "save")
+		if inner < 54 {
+			footer = keyHint("Tab", "field") + "  " + keyHint("Space", "toggle") + "  " + keyHint("Ctrl+S", "save")
+		}
+	case palette, commands, gitMenu:
+		title = "COMMAND PALETTE"
+		if m.mode == commands {
+			title = "PROJECT COMMANDS"
+		}
+		if m.mode == gitMenu {
+			title = "GIT ACTIONS"
+		}
+		items := m.filteredActions()
+		lines := []string{m.query.View(), muted.Render(strings.Repeat("─", inner)), ""}
+		bodyCapacity := m.height - 11
+		if m.mode == commands {
+			bodyCapacity--
+		}
+		stride := 2
+		if m.height < 24 {
+			stride = 1
+		}
+		visible := max(1, min(8, (bodyCapacity-3)/stride))
+		start := max(0, m.menuIndex-visible+1)
+		if len(items) == 0 {
+			lines = append(lines, muted.Render("No matching actions."))
+		}
+		for i := start; i < min(len(items), start+visible); i++ {
+			item := items[i]
+			prefix := "  "
+			if i == m.menuIndex {
+				prefix = "› "
+			}
+			row := pad(prefix+oneLine(item.Label), inner)
+			if i == m.menuIndex {
+				row = selectedStyle.Render(row)
+			} else if item.Disabled != "" {
+				row = muted.Render(row)
+			}
+			detail := item.Detail
+			if item.Disabled != "" {
+				detail = item.Disabled
+			}
+			lines = append(lines, row)
+			if stride == 2 {
+				lines = append(lines, muted.Render(fit("  "+oneLine(detail), inner)))
+			}
+		}
+		body = strings.Join(lines, "\n")
+		footer = keyHint("↑↓", "choose") + "   " + keyHint("Enter", "select") + "   " + keyHint("Esc", "close")
+		if m.mode == commands {
+			footer += "\n" + keyHint("Ctrl+N", "new") + "  " + keyHint("Ctrl+E", "edit") + "  " + keyHint("Ctrl+D", "remove")
+		}
+	case help:
+		title = "KEYBOARD SHORTCUTS"
+		body = m.viewport.View()
+		footer = keyHint("↑↓", "scroll") + "   " + keyHint("Esc / ?", "close")
+	case removeConfirm:
+		title = "REMOVE PROJECT?"
+		body = titleStyle.Render(fit(oneLine(m.editProject.Name), inner)) + "\n\n" + muted.Render("Only the Rian entry will be removed.\nYour project directory and files stay in place.")
+		footer = keyHint("Enter / y", "remove entry") + "   " + keyHint("Esc / n", "keep project")
+	case quitConfirm:
+		title = "COMMANDS ARE STILL RUNNING"
+		body = fmt.Sprintf("%d active process(es).\n\nQuitting will stop their process trees.", m.manager.Active())
+		footer = keyHint("Enter / y", "stop and quit") + "   " + keyHint("Esc / n", "stay")
+	case prompt:
+		title = "RUN COMMAND"
+		if m.promptAction == "commit" {
+			title = "COMMIT STAGED CHANGES"
+		}
+		if m.promptAction == "branch" {
+			title = "SWITCH BRANCH"
+		}
+		body = m.query.View()
+		footer = keyHint("Enter", "continue") + "   " + keyHint("Esc", "cancel")
+		if m.commandEditing {
+			title = "CUSTOM COMMAND"
+			body = muted.Render("Name (an existing name overrides detection)") + "\n" + m.commandName.View() + "\n\n" + muted.Render("Shell command, run in the project directory") + "\n" + m.commandValue.View()
+			footer = keyHint("Tab", "field") + "   " + keyHint("Ctrl+S", "save") + "   " + keyHint("Esc", "cancel")
+		}
+	case processView:
+		title = "PROCESS OUTPUT"
+		s := m.processState
+		state := muted.Render("STOPPED")
+		if s.Error != "" {
+			state = warning.Render("FAILED")
+		}
+		if s.Running {
+			state = good.Render("● RUNNING")
+		}
+		if s.Command == "" {
+			state = muted.Render("No command has run yet.")
+		}
+		meta := state
+		if s.PID > 0 {
+			meta += muted.Render(fmt.Sprintf("   PID %d   started %s", s.PID, s.Started.Local().Format("15:04:05")))
+		}
+		body = fit(oneLine(s.Command), inner) + "\n" + fit(meta, inner) + "\n\n" + m.viewport.View()
+		if s.Error != "" {
+			body += "\n" + warning.Render(fit(oneLine(s.Error), inner))
+		}
+		follow := "paused"
+		if m.followOutput {
+			follow = "live"
+		}
+		footer = keyHint("s", "stop") + "   " + keyHint("r", "rerun") + "   " + keyHint("f", "follow: "+follow) + "   " + keyHint("Esc", "back")
+		if inner < 60 {
+			footer = keyHint("s", "stop") + "  " + keyHint("r", "rerun") + "  " + keyHint("f", "follow") + "  " + keyHint("Esc", "back")
+		}
+	}
+	if m.formError != "" {
+		body += "\n\n" + warning.Render(fit(oneLine(m.formError), inner))
+	}
+	if m.busy {
+		footer = m.spin.View() + muted.Render(" Working…")
+	}
+	bodyLines := strings.Split(body, "\n")
+	footerLines := strings.Split(footer, "\n")
+	allowed := max(1, m.height-10-len(footerLines))
+	if len(bodyLines) > allowed {
+		bodyLines = bodyLines[:allowed]
+	}
+	for i := range bodyLines {
+		bodyLines[i] = fit(bodyLines[i], inner)
+	}
+	for i := range footerLines {
+		footerLines[i] = fit(footerLines[i], inner)
+	}
+	content := titleStyle.Render(title) + "\n\n" + strings.Join(bodyLines, "\n") + "\n\n" + strings.Join(footerLines, "\n")
+	return lipgloss.NewStyle().Border(lipgloss.RoundedBorder()).BorderForeground(accent).
+		Background(background).Foreground(foreground).Padding(1, 2).Width(w).
+		MaxWidth(w).MaxHeight(m.height - 2).Render(content)
+}
+
+func (m *Model) detectionSummary(result detect.Result) string {
+	p := result.Project
+	lines := []string{titleStyle.Render(oneLine(p.Name)), muted.Render(oneLine(p.Path)), ""}
+	if len(p.Stack) > 0 {
+		lines = append(lines, "Stack    "+strings.Join(p.Stack, " · "))
+	}
+	if result.Git.Repository {
+		lines = append(lines, "Branch   "+oneLine(result.Git.Branch))
+	}
+	if result.Git.GitHub != "" {
+		lines = append(lines, "GitHub   "+oneLine(result.Git.GitHub))
+	}
+	lines = append(lines, "", highlight.Render("DETECTED COMMANDS"))
+	if len(p.AutoCommands) == 0 {
+		lines = append(lines, muted.Render("None yet. Add custom commands with d."))
+	}
+	for _, name := range detect.CommandNames(p.AutoCommands) {
+		lines = append(lines, pad(oneLine(name), 14)+oneLine(p.AutoCommands[name]))
+	}
+	lines = append(lines, "", highlight.Render("TOOLS"))
+	for _, tool := range []string{"code", "opencode", "kilocode", "gh", "lazygit"} {
+		status := "not in PATH"
+		if result.Available[tool] {
+			status = "available"
+		}
+		lines = append(lines, pad(tool, 14)+status)
+	}
+	for _, warning := range result.Warnings {
+		lines = append(lines, "", oneLine(warning))
+	}
+	return strings.Join(lines, "\n")
+}
+
+func (m *Model) helpView(width int) string {
+	rows := []struct{ label, keys string }{
+		{"NAVIGATION", "↑↓ / j k  projects    /  fuzzy search    Enter  actions"},
+		{"OPEN", "v  VS Code   o  OpenCode   K  KiloCode\nt  shell   c  ChatGPT   g  GitHub"},
+		{"RUN", "r  run / active process   d  commands   p  output\nProcess: s  stop   r  rerun   f  follow output"},
+		{"GIT", "G  Git menu    Ctrl+R  refresh status"},
+		{"PROJECT", "a  add    e  edit    f  favorite    Delete  remove\nCommands: Ctrl+N  new   Ctrl+E  edit   Ctrl+D  remove"},
+		{"GLOBAL", "Ctrl+K  palette    ?  help    q / Ctrl+C  quit"},
+	}
+	var lines []string
+	for _, row := range rows {
+		lines = append(lines, highlight.Render(row.label))
+		for _, line := range strings.Split(row.keys, "\n") {
+			lines = append(lines, fit(line, width))
+		}
+		lines = append(lines, "")
+	}
+	if m.height < 33 {
+		lines = []string{keyHint("↑↓ / jk", "navigate") + "   " + keyHint("/", "search"), keyHint("Ctrl+K / Enter", "actions"), keyHint("v / o / K", "VS Code / OpenCode / KiloCode"), keyHint("t / c / g", "shell / ChatGPT / GitHub"), keyHint("r / d / p", "run / commands / output"), keyHint("G / Ctrl+R", "Git menu / refresh"), keyHint("a / e / f", "add / edit / favorite"), keyHint("Delete", "remove entry"), keyHint("q / Ctrl+C", "quit")}
+	}
+	return strings.Join(lines, "\n")
+}
+
+func shortPath(path string) string {
+	if home, err := os.UserHomeDir(); err == nil {
+		if project.SamePath(path, home) {
+			return "~"
+		}
+		if len(path) > len(home) && project.SamePath(path[:len(home)], home) && (path[len(home)] == '/' || path[len(home)] == '\\') {
+			return "~" + oneLine(path[len(home):])
+		}
+	}
+	return oneLine(path)
+}
+
+func relativeTime(t time.Time) string {
+	if t.IsZero() {
+		return "—"
+	}
+	d := time.Since(t)
+	if d < time.Minute {
+		return "just now"
+	}
+	if d < time.Hour {
+		return fmt.Sprintf("%d min ago", int(d.Minutes()))
+	}
+	if d < 24*time.Hour {
+		return fmt.Sprintf("%d hr ago", int(d.Hours()))
+	}
+	if d < 30*24*time.Hour {
+		return fmt.Sprintf("%d days ago", int(d.Hours()/24))
+	}
+	return t.Format("Jan 2, 2006")
+}

package/lib/launcher.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+const { targetFor } = require('./platforms.cjs');
+const { name: packageName } = require('../package.json');
+
+function binaryPath(root, platform = process.platform, arch = process.arch) {
+  const target = targetFor(platform, arch);
+  const binary = path.join(root, 'dist', 'binaries', target.key, target.filename);
+  if (!fs.existsSync(binary)) {
+    throw new Error(`The Rian executable is missing. Reinstall with: npm install -g ${packageName}`);
+  }
+  if (platform !== 'win32' && !(fs.statSync(binary).mode & 0o111)) {
+    try { fs.chmodSync(binary, 0o755); } catch {
+      throw new Error(`The Rian executable needs permission to run. Repair the installation with: npm rebuild -g ${packageName}`);
+    }
+  }
+  return binary;
+}
+
+function launch(root, args = process.argv.slice(2), spawnProcess = spawn) {
+  const binary = binaryPath(root);
+  // Native stdio must pass straight through: Bubble Tea owns the terminal.
+  const child = spawnProcess(binary, args, { stdio: 'inherit', shell: false, windowsHide: false });
+  const handlers = new Map();
+  for (const signal of ['SIGINT', 'SIGTERM', ...(process.platform === 'win32' ? [] : ['SIGHUP'])]) {
+    const handler = () => { if (child.exitCode === null && child.signalCode === null) child.kill(signal); };
+    handlers.set(signal, handler);
+    process.on(signal, handler);
+  }
+  const cleanup = () => { for (const [signal, handler] of handlers) process.removeListener(signal, handler); };
+  child.once('error', err => {
+    cleanup();
+    console.error(`rian: could not start the executable: ${err.message}`);
+    process.exitCode = 1;
+  });
+  child.once('exit', (code, signal) => {
+    cleanup();
+    process.exitCode = code ?? ({ SIGINT: 130, SIGTERM: 143, SIGHUP: 129 }[signal] ?? 1);
+  });
+  return child;
+}
+
+module.exports = { binaryPath, launch };

package/lib/platforms.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const targets = Object.freeze([
+  { platform: 'darwin', arch: 'arm64', goos: 'darwin', goarch: 'arm64' },
+  { platform: 'darwin', arch: 'x64', goos: 'darwin', goarch: 'amd64' },
+  { platform: 'linux', arch: 'arm64', goos: 'linux', goarch: 'arm64' },
+  { platform: 'linux', arch: 'x64', goos: 'linux', goarch: 'amd64' },
+  { platform: 'win32', arch: 'arm64', goos: 'windows', goarch: 'arm64' },
+  { platform: 'win32', arch: 'x64', goos: 'windows', goarch: 'amd64' },
+]);
+
+function targetFor(platform = process.platform, arch = process.arch) {
+  const target = targets.find(item => item.platform === platform && item.arch === arch);
+  if (!target) {
+    throw new Error(`Rian does not support ${platform}/${arch}. Use macOS, Linux, or Windows on x64 or arm64.`);
+  }
+  return { ...target, key: `${platform}-${arch}`, filename: platform === 'win32' ? 'rian.exe' : 'rian' };
+}
+
+module.exports = { targets, targetFor };

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@fatalmistake02/rian",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1",
+  "description": "Rian: your local project desk. A keyboard-first terminal app for Git, coding tools, and project commands.",
+  "license": "MIT",
+  "bin": {
+    "rian": "bin/rian.cjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "os": ["darwin", "linux", "win32"],
+  "cpu": ["arm64", "x64"],
+  "files": [
+    "bin/rian.cjs",
+    "lib/",
+    "dist/binaries/",
+    "cmd/",
+    "internal/",
+    "go.mod",
+    "go.sum",
+    "scripts/",
+    "test/npm/",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.txt"
+  ],
+  "scripts": {
+    "build": "node scripts/build-binaries.cjs",
+    "test": "node --test test/npm/launcher.test.cjs test/npm/package.test.cjs",
+    "check:package": "node scripts/check-package.cjs",
+    "postinstall": "node scripts/ensure-binary.cjs",
+    "prepack": "npm run check:package",
+    "prepublishOnly": "npm test && npm run check:package"
+  },
+  "keywords": ["rian", "tui", "terminal", "projects", "git", "developer-tools", "bubbletea"],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/scripts/build-binaries.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawnSync } = require('node:child_process');
+const { targets, targetFor } = require('../lib/platforms.cjs');
+
+const root = path.resolve(__dirname, '..');
+const pkg = require('../package.json');
+const output = path.join(root, 'dist', 'binaries');
+
+function runGo(args, env = {}, capture = false) {
+  const result = spawnSync('go', args, { cwd: root, env: { ...process.env, ...env },
+    encoding: 'utf8', stdio: capture ? 'pipe' : 'inherit', maxBuffer: 10 * 1024 * 1024 });
+  if (result.error || result.status !== 0) {
+    throw new Error(result.error?.message || result.stderr?.trim() || `go ${args[0]} failed (${result.status})`);
+  }
+  return result.stdout || '';
+}
+
+function collectLicenses() {
+  const goroot = runGo(['env', 'GOROOT'], {}, true).trim();
+  const parts = ['Rian bundles the Go runtime and the following third-party modules.\nTheir original copyright and license notices are reproduced below.\n',
+    `Go runtime\n${runGo(['version'], {}, true).trim()}\n\n${fs.readFileSync(path.join(goroot, 'LICENSE'), 'utf8')}`];
+  const modules = runGo(['list', '-m', '-f', '{{.Path}}|{{.Version}}|{{.Dir}}', 'all'], {}, true).trim().split(/\r?\n/);
+  for (const entry of modules) {
+    const [name, version, dir] = entry.split('|');
+    if (!version || !dir) continue;
+    const files = fs.readdirSync(dir).filter(name => /^(LICENSE|COPYING|NOTICE)([.-].*)?$/i.test(name)).sort();
+    if (!files.length) throw new Error(`Missing license notice for ${name}@${version}`);
+    for (const file of files) {
+      if (!fs.statSync(path.join(dir, file)).isFile()) continue;
+      parts.push(`${name}@${version} — ${file}\n\n${fs.readFileSync(path.join(dir, file), 'utf8')}`);
+    }
+  }
+  fs.writeFileSync(path.join(root, 'THIRD_PARTY_NOTICES.txt'), parts.join('\n\n' + '='.repeat(72) + '\n\n'));
+}
+
+function build() {
+  if (!/^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/.test(pkg.version)) throw new Error('Invalid package version');
+  fs.mkdirSync(output, { recursive: true });
+  const manifest = { version: pkg.version, targets: {} };
+  for (const item of targets) {
+    const target = targetFor(item.platform, item.arch);
+    const relative = `${target.key}/${target.filename}`;
+    const file = path.join(output, relative);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    console.log(`Building Rian ${pkg.version} for ${target.key}…`);
+    runGo(['build', '-trimpath', '-buildvcs=false', '-ldflags', `-s -w -X main.version=${pkg.version}`, '-o', file, './cmd/rian'],
+      { GOOS: target.goos, GOARCH: target.goarch, CGO_ENABLED: '0' });
+    fs.chmodSync(file, 0o755);
+    manifest.targets[target.key] = { file: relative, sha256: crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex') };
+  }
+  collectLicenses();
+  fs.writeFileSync(path.join(output, 'manifest.json'), JSON.stringify(manifest, null, 2) + '\n');
+  console.log('All six executables and dependency licenses are ready.');
+}
+
+try { build(); } catch (err) { console.error(`rian build: ${err.message}`); process.exitCode = 1; }