soja-cli 1.4.0

package/dist/ui/chrome/StatusBar.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { palette } from '../theme/theme.js';
+import { APP_SLOGAN, WORDMARK_WIDTH } from '../branding/brand.js';
+import { Logo } from '../branding/Logo.js';
+import { FOOTER_BRAND_GAP_ROWS, footerRowsFor } from '../hooks/use-layout.js';
+/**
+ * The bottom bar: a pill with where you are, then the shortcuts that work
+ * right now as keys. Shortcuts that do not fit are dropped from the end.
+ */
+export function StatusBar({ columns, mode, hints, right }) {
+    const footerRows = footerRowsFor(columns);
+    const inlineBrand = columns >= WORDMARK_WIDTH + APP_SLOGAN.length + 4;
+    const sloganWidth = inlineBrand ? columns - WORDMARK_WIDTH - 4 : columns - 2;
+    const available = columns - mode.length - 4 - (right ? right.length + 3 : 0);
+    const shown = [];
+    let used = 0;
+    for (const hint of hints) {
+        const size = hint[0].length + hint[1].length + 4;
+        if (used + size > available)
+            break;
+        shown.push(hint);
+        used += size;
+    }
+    return (_jsxs(Box, { width: columns, height: footerRows, flexDirection: "column", backgroundColor: palette.bar, flexShrink: 0, children: [_jsxs(Box, { width: columns, height: 1, backgroundColor: palette.bar, justifyContent: "space-between", flexShrink: 0, children: [_jsxs(Text, { backgroundColor: palette.bar, wrap: "truncate-end", children: [_jsx(Text, { backgroundColor: palette.accent, color: palette.onAccent, bold: true, children: ` ${mode.toUpperCase()} ` }), shown.map(([keys, action]) => (_jsxs(Text, { children: [_jsx(Text, { backgroundColor: palette.bar, children: " " }), _jsx(Text, { backgroundColor: palette.neutralSoft, color: palette.text, bold: true, children: ` ${keys} ` }), _jsx(Text, { backgroundColor: palette.bar, color: palette.muted, children: ` ${action}` })] }, keys + action)))] }), right ? (_jsx(Text, { backgroundColor: palette.bar, color: palette.faint, children: `${right} ` })) : null] }), _jsx(Box, { height: FOOTER_BRAND_GAP_ROWS, flexShrink: 0 }), _jsxs(Box, { width: columns, height: footerRows - 1 - FOOTER_BRAND_GAP_ROWS, paddingX: 1, backgroundColor: palette.bar, flexShrink: 0, flexDirection: inlineBrand ? 'row' : 'column', alignItems: inlineBrand ? 'center' : 'flex-start', justifyContent: "center", children: [_jsx(Logo, { cursorVisible: true }), _jsx(Box, { width: sloganWidth, marginLeft: inlineBrand ? 2 : 0, children: _jsx(Text, { backgroundColor: palette.bar, color: palette.muted, wrap: "wrap", children: APP_SLOGAN }) })] })] }));
+}

package/dist/ui/chrome/Toast.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { palette, symbols, toneColors } from '../theme/theme.js';
+/** The latest confirmation or error, floating above the status bar at the bottom right. */
+export function Toast({ flash, columns, rows }) {
+    const tone = flash.tone === 'error' ? 'danger' : flash.tone === 'success' ? 'success' : 'info';
+    const { fg } = toneColors(tone);
+    const mark = flash.tone === 'error' ? symbols.cross : flash.tone === 'success' ? symbols.check : symbols.info;
+    const width = Math.min(columns - 4, Math.max(28, Math.min(64, Math.max(flash.text.length, flash.hint?.length ?? 0) + 8)));
+    return (_jsxs(Box, { position: "absolute", top: Math.max(1, rows - (flash.hint ? 6 : 5)), left: Math.max(0, columns - width - 2), width: width, borderStyle: "round", borderColor: fg, backgroundColor: palette.surface, flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { backgroundColor: palette.surface, wrap: "truncate-end", children: [_jsx(Text, { color: fg, bold: true, children: `${mark} ` }), _jsx(Text, { color: palette.text, children: flash.text })] }), flash.hint ? (_jsx(Text, { backgroundColor: palette.surface, color: palette.muted, wrap: "truncate-end", children: `  ${flash.hint}` })) : null] }));
+}

package/dist/ui/chrome/TopBar.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { APP_NAME, APP_VERSION } from '../branding/brand.js';
+import { palette, symbols } from '../theme/theme.js';
+/** The title bar: brand and place on the left, connection and you on the right. */
+export function TopBar({ columns, workspace, trail, username, isCeo, server, sync, chat }) {
+    const roomy = columns >= 90;
+    const syncColor = sync?.tone === 'warn' ? palette.warning : sync?.tone === 'busy' ? palette.info : palette.muted;
+    return (_jsxs(Box, { width: columns, backgroundColor: palette.bar, justifyContent: "space-between", flexShrink: 0, children: [_jsx(Box, { flexShrink: 1, children: _jsxs(Text, { wrap: "truncate-end", backgroundColor: palette.bar, children: [_jsx(Text, { backgroundColor: palette.accent, color: palette.onAccent, bold: true, children: ` ${APP_NAME}${symbols.cursor} ` }), _jsx(Text, { color: palette.barText, bold: true, children: `  ${workspace}` }), trail.map((part) => (_jsx(Text, { color: palette.muted, children: `  ${symbols.chevron} ${part}` }, part)))] }) }), _jsxs(Box, { flexShrink: 0, gap: 2, paddingRight: 1, children: [chat && chat.unread > 0 ? (_jsxs(Text, { backgroundColor: palette.bar, children: [_jsx(Text, { color: palette.accent, children: `${symbols.unread} ${chat.unread}` }), chat.mentions > 0 ? _jsx(Text, { color: palette.warning, bold: true, children: ` @${chat.mentions}` }) : null] })) : null, server ? (_jsx(Text, { backgroundColor: palette.bar, color: syncColor, children: `${symbols.link} ${roomy ? server : ''}${sync ? `${roomy ? ` ${symbols.dot} ` : ''}${sync.text}` : ''}` })) : null, _jsxs(Text, { backgroundColor: palette.bar, color: palette.barText, children: [`@${username}`, isCeo ? _jsx(Text, { color: palette.warning, bold: true, children: ' ★ CEO' }) : null] }), roomy ? _jsx(Text, { backgroundColor: palette.bar, color: palette.faint, children: `v${APP_VERSION}` }) : null] })] }));
+}

package/dist/ui/chrome/context.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useLayoutEffect, useMemo, useState } from 'react';
+const ChromeContext = createContext(null);
+/** Whether the screen (or window) around a component is the one on top. */
+const ActiveContext = createContext(true);
+export function ChromeProvider({ children }) {
+    const [hints, setState] = useState([]);
+    // Same shortcuts again (every render of a screen declares them) change nothing.
+    const setHints = useCallback((next) => setState((current) => (JSON.stringify(current) === JSON.stringify(next) ? current : next)), []);
+    const value = useMemo(() => ({ hints, setHints }), [hints, setHints]);
+    return _jsx(ChromeContext.Provider, { value: value, children: children });
+}
+export function ActiveScope({ active, children }) {
+    return _jsx(ActiveContext.Provider, { value: active, children: children });
+}
+export function useIsActive() {
+    return useContext(ActiveContext);
+}
+export function useChromeHints() {
+    return useContext(ChromeContext)?.hints ?? [];
+}
+/** The shortcuts shown in the status bar, while the screen or window that declares them is on top. */
+export function useHints(hints) {
+    const setHints = useContext(ChromeContext)?.setHints;
+    const active = useIsActive();
+    const key = JSON.stringify(hints);
+    useLayoutEffect(() => {
+        if (active)
+            setHints?.(hints);
+        // `key` stands for the hints' content.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [active, key, setHints]);
+}

package/dist/ui/components/ConsoleLines.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { palette } from '../theme/theme.js';
+/**
+ * Git console lines on an inset like a small terminal: commands stand out,
+ * Git's chatter is dim, results are colored.
+ */
+export function ConsoleLines({ lines, minRows = 0 }) {
+    return (_jsx(Box, { flexDirection: "column", backgroundColor: palette.bar, paddingX: 1, minHeight: minRows, children: lines.map((line) => (_jsx(Text, { wrap: "truncate-end", bold: line.kind === 'command', color: line.kind === 'command'
+                ? palette.accent
+                : line.kind === 'error'
+                    ? palette.danger
+                    : line.kind === 'success'
+                        ? palette.success
+                        : palette.muted, children: line.kind === 'command' ? line.text : `  ${line.text}` }, line.id))) }));
+}

package/dist/ui/components/EmptyState.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { palette } from '../theme/theme.js';
+/** Centered in the space it gets: the fact in normal text, the rest dimmer and with a little personality. */
+export function EmptyState({ lines, icon = '◌' }) {
+    const [first, ...rest] = lines;
+    return (_jsxs(Box, { flexDirection: "column", alignItems: "center", justifyContent: "center", flexGrow: 1, paddingY: 1, children: [_jsx(Text, { color: palette.faint, children: icon }), _jsx(Text, { color: palette.text, bold: true, children: first }), rest.filter(Boolean).map((line) => (_jsx(Text, { color: palette.muted, children: line }, line)))] }));
+}

package/dist/ui/components/Labels.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { palette, priorityStyles, priorityTone, statusStyles, statusTone, toneColors } from '../theme/theme.js';
+const LEVEL = { none: 0, low: 1, medium: 2, high: 3, urgent: 4 };
+/** Priority as a small meter: `▰▰▰▱ HIGH`. The label can be dropped when space is short. */
+export function PriorityMeter({ priority, label = true, background }) {
+    const { fg } = toneColors(priorityTone[priority]);
+    const level = LEVEL[priority];
+    const bg = background ? { backgroundColor: background } : {};
+    return (_jsxs(Text, { ...bg, children: [_jsx(Text, { color: level === 0 ? palette.faint : fg, children: '▰'.repeat(level) }), _jsx(Text, { color: palette.faint, children: '▱'.repeat(4 - level) }), label ? (_jsx(Text, { color: level === 0 ? palette.faint : fg, bold: priority === 'urgent', children: ` ${priority === 'none' ? '—' : priorityStyles[priority].label}` })) : null] }));
+}
+/** Status as a soft filled label: ` ◐ In Progress `, or only its glyph when narrow. */
+export function StatusBadge({ status, glyphOnly = false }) {
+    const style = statusStyles[status];
+    const { fg, bg } = toneColors(statusTone[status]);
+    const color = status === 'todo' ? palette.text : fg;
+    return (_jsx(Text, { backgroundColor: bg, color: color, strikethrough: status === 'cancelled', children: glyphOnly ? ` ${style.glyph} ` : ` ${style.glyph} ${style.label} ` }));
+}
+/** Kept for places that show priority as a word (task detail header). */
+export function PriorityLabel({ priority }) {
+    return _jsx(PriorityMeter, { priority: priority });
+}
+export function StatusLabel({ status, glyphOnly = false }) {
+    return _jsx(StatusBadge, { status: status, glyphOnly: glyphOnly });
+}

package/dist/ui/components/PullRequestLabel.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { palette, symbols } from '../theme/theme.js';
+/** `#12✓`: number plus the one thing that matters most right now. For lists. */
+export function PullRequestMark({ pr }) {
+    const mark = prMark(pr);
+    return (_jsx(Text, { color: mark.color, dimColor: mark.dim, children: `${symbols.pullRequest}${pr.number}${mark.glyph} ` }));
+}
+function prMark(pr) {
+    if (pr.state === 'merged')
+        return { glyph: symbols.check, color: palette.merged };
+    if (pr.state === 'closed')
+        return { glyph: symbols.cross, dim: true };
+    if (pr.checks.failed > 0 || pr.mergeable === 'conflicting' || pr.review === 'changes_requested')
+        return { glyph: symbols.cross, color: palette.danger };
+    if (pr.checks.pending > 0)
+        return { glyph: symbols.running, color: palette.warning };
+    if (pr.review === 'approved')
+        return { glyph: symbols.check, color: palette.success };
+    return { glyph: '', color: palette.info };
+}
+/** The full line for the task detail: state, review, checks, conflicts. */
+export function PullRequestSummary({ pr }) {
+    const stateColor = pr.state === 'merged' ? palette.merged : pr.state === 'open' ? palette.info : undefined;
+    const { checks } = pr;
+    return (_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: stateColor, dimColor: pr.state === 'closed', children: `${symbols.pullRequest}${pr.number} ${pr.draft ? 'draft' : pr.state}` }), pr.state === 'open' && checks.total > 0 ? (checks.failed > 0 ? (_jsx(Text, { color: palette.danger, children: `  ${symbols.cross} ${checks.failed} failing: ${checks.failing.join(', ')}` })) : checks.pending > 0 ? (_jsx(Text, { color: palette.warning, children: `  ${symbols.running} checks ${checks.passed}/${checks.total}, ${checks.pending} running` })) : (_jsx(Text, { color: palette.success, children: `  ${symbols.check} checks ${checks.passed}/${checks.total}` }))) : null, pr.state === 'open' && pr.mergeable === 'conflicting' ? _jsx(Text, { color: palette.danger, children: '  conflicts with base' }) : null, pr.state === 'open' && pr.review ? (_jsx(Text, { color: pr.review === 'approved' ? palette.success : pr.review === 'changes_requested' ? palette.danger : undefined, dimColor: pr.review === 'review_required', children: `  ${pr.review === 'approved' ? `${symbols.check} approved` : pr.review === 'changes_requested' ? `${symbols.cross} changes requested` : 'review required'}` })) : null, _jsx(Text, { color: palette.muted, children: `  → ${pr.base}` })] }));
+}

package/dist/ui/components/TaskTable.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Layer } from '../input/dispatcher.js';
+import { Clickable } from '../kit/Clickable.js';
+import { ScrollBar } from '../kit/ScrollBar.js';
+import { palette, symbols } from '../theme/theme.js';
+import { PriorityMeter, StatusBadge } from './Labels.js';
+import { PullRequestMark } from './PullRequestLabel.js';
+import { layoutTaskColumns } from './task-columns.js';
+export function TaskTable({ tasks, selected, offset, height, width, showAssignee = false, showHeader = true, pullRequests, onSelect, onOpen, onScroll, layer = Layer.screen, active = true, }) {
+    const refWidth = Math.max(8, ...tasks.map((task) => task.ref.length));
+    const columns = layoutTaskColumns(width, { showAssignee, refWidth });
+    const rows = tableRows(height, showHeader);
+    const visible = tasks.slice(offset, offset + rows);
+    return (_jsx(Clickable, { onClick: (event, rect) => {
+            // Rows are separate hit regions; this table-level fallback also handles
+            // terminals that report a point on a text cell outside its row bounds.
+            const row = Math.floor(event.y - rect.y) - (showHeader ? 1 : 0);
+            const index = offset + row;
+            if (row < 0 || row >= visible.length)
+                return;
+            if (index === selected)
+                onOpen?.(index);
+            else
+                onSelect?.(index);
+        }, onWheel: onScroll, layer: layer, active: active, flexDirection: "column", width: width, height: height, children: _jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [showHeader ? (_jsxs(Box, { children: [_jsx(Box, { width: 2 }), _jsx(Cell, { width: columns.ref, text: "ID" }), _jsx(Cell, { width: columns.priority, text: columns.priorityLabel ? "PRIORITY" : "PRI" }), _jsx(Cell, { width: columns.status, text: columns.statusGlyphOnly ? '' : 'STATUS' }), columns.project ? _jsx(Cell, { width: columns.project, text: "PROJECT" }) : null, columns.assignee ? _jsx(Cell, { width: columns.assignee, text: "ASSIGNEE" }) : null, _jsx(Cell, { width: columns.title, text: "TITLE" })] })) : null, _jsxs(Box, { children: [_jsx(Box, { flexDirection: "column", flexGrow: 1, children: visible.map((task, position) => {
+                                const index = offset + position;
+                                const isSelected = index === selected;
+                                const pr = pullRequests?.get(task.id);
+                                const bg = isSelected ? { backgroundColor: palette.selection } : {};
+                                const closed = task.status === 'cancelled' || task.status === 'done';
+                                return (_jsx(Clickable, { layer: layer, active: active, width: "100%", onClick: () => (isSelected ? onOpen?.(index) : onSelect?.(index)), children: _jsxs(Box, { flexGrow: 1, ...bg, children: [_jsx(Box, { width: 2, flexShrink: 0, children: _jsx(Text, { color: palette.accent, ...bg, children: isSelected ? `${symbols.pointer} ` : '  ' }) }), _jsx(Box, { width: columns.ref, flexShrink: 0, children: _jsx(Text, { color: isSelected ? palette.accent : palette.muted, bold: isSelected, ...bg, children: task.ref }) }), _jsx(Box, { width: columns.priority, flexShrink: 0, children: _jsx(PriorityMeter, { priority: task.priority, label: columns.priorityLabel, background: bg.backgroundColor }) }), _jsx(Box, { width: columns.status, flexShrink: 0, children: _jsx(StatusBadge, { status: task.status, glyphOnly: columns.statusGlyphOnly }) }), columns.project ? (_jsx(Box, { width: columns.project, flexShrink: 0, paddingRight: 1, children: _jsx(Text, { color: task.project ? palette.muted : palette.faint, wrap: "truncate-end", ...bg, children: task.project?.name ?? '—' }) })) : null, columns.assignee ? (_jsx(Box, { width: columns.assignee, flexShrink: 0, paddingRight: 1, children: _jsx(Text, { color: palette.muted, wrap: "truncate-end", ...bg, children: task.assignee ? `@${task.assignee.username}` : '—' }) })) : null, _jsx(Box, { flexGrow: 1, flexShrink: 1, children: _jsxs(Text, { wrap: "truncate-end", ...bg, children: [task.archivedAt ? _jsx(Text, { color: palette.faint, children: 'archived · ' }) : null, pr ? _jsx(PullRequestMark, { pr: pr }) : null, _jsx(Text, { color: closed ? palette.muted : palette.text, bold: isSelected, strikethrough: task.status === 'cancelled', children: task.title })] }) })] }) }, task.id));
+                            }) }), _jsx(ScrollBar, { total: tasks.length, visible: rows, offset: offset, height: Math.min(rows, tasks.length) })] })] }) }));
+}
+function Cell({ width, text }) {
+    return (_jsx(Box, { width: width, paddingRight: 1, flexShrink: 0, children: _jsx(Text, { color: palette.faint, bold: true, wrap: "truncate-end", children: text }) }));
+}
+/** Task rows that fit in `height`, which is what list navigation must scroll by. */
+export function tableRows(height, showHeader = true) {
+    return Math.max(1, height - (showHeader ? 1 : 0));
+}

package/dist/ui/components/TextField.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { palette } from '../theme/theme.js';
+import { TextInput } from './TextInput.js';
+/**
+ * A text box that looks like a form field: a filled line with the cursor,
+ * an optional label above it. Editing rules are TextInput's.
+ */
+export function TextField({ value, onChange, placeholder, active = true, label, width, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [label ? _jsx(Text, { color: active ? palette.accent : palette.muted, children: label }) : null, _jsx(Box, { backgroundColor: palette.neutralSoft, paddingX: 1, ...(width ? { width } : {}), children: _jsx(TextInput, { value: value, onChange: onChange, placeholder: placeholder, active: active, prompt: active ? '›' : ' ' }) })] }));
+}

package/dist/ui/components/TextInput.js

@@ -0,0 +1,29 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { useState } from 'react';
+import { useKeys } from '../input/KeyProvider.js';
+import { Layer } from '../input/dispatcher.js';
+import { editText } from '../input/text-editing.js';
+import { palette } from '../theme/theme.js';
+/**
+ * Single-line field. Consumes editing keys only; Enter, Esc, Tab and ↑/↓
+ * fall through to whoever owns the field.
+ */
+export function TextInput({ value, onChange, placeholder, active = true, prompt = '›' }) {
+    // Stored as distance from the end: when the owner replaces the value
+    // (autocomplete), a cursor at the end stays at the end.
+    const [fromEnd, setFromEnd] = useState(0);
+    const cursor = Math.max(0, value.length - fromEnd);
+    useKeys(Layer.input, (input, key) => {
+        const next = editText({ value, cursor }, input, key);
+        if (!next)
+            return false;
+        setFromEnd(next.value.length - next.cursor);
+        if (next.value !== value)
+            onChange(next.value);
+        return true;
+    }, active);
+    const position = cursor;
+    const showPlaceholder = !value && placeholder;
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: active ? palette.accent : undefined, dimColor: !active, children: [prompt, ' '] }), showPlaceholder ? (_jsxs(_Fragment, { children: [active ? _jsx(Text, { inverse: true, children: placeholder.slice(0, 1) }) : null, _jsx(Text, { dimColor: true, children: active ? placeholder.slice(1) : placeholder })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { children: value.slice(0, position) }), active ? _jsx(Text, { inverse: true, children: value.slice(position, position + 1) || ' ' }) : null, _jsx(Text, { children: active ? value.slice(position + 1) : value.slice(position) })] }))] }));
+}

package/dist/ui/components/task-columns.js

@@ -0,0 +1,27 @@
+const POINTER = 2;
+/** The scroll bar column on the right. */
+const SCROLL = 1;
+/**
+ * Drops detail as the space narrows: assignee first, then the priority word,
+ * then the status label (the colored glyph stays), then the project. ID,
+ * priority meter and title always remain.
+ */
+export function layoutTaskColumns(width, options) {
+    const ref = options.refWidth + 2;
+    const wide = width >= 100;
+    const medium = width >= 80;
+    const narrow = width >= 64;
+    const columns = {
+        ref,
+        priority: medium ? 13 : 6,
+        priorityLabel: medium,
+        project: medium ? 15 : narrow ? 13 : 0,
+        status: medium ? 17 : 5,
+        statusGlyphOnly: !medium,
+        assignee: wide && options.showAssignee ? 11 : 0,
+        title: 0,
+    };
+    const used = POINTER + SCROLL + columns.ref + columns.priority + columns.project + columns.status + columns.assignee;
+    columns.title = Math.max(10, width - used);
+    return columns;
+}

package/dist/ui/copy.js

@@ -0,0 +1,23 @@
+/** Empty states. First line is the fact; the rest may smile a little. */
+export const EMPTY_TASKS = {
+    mine: ['No tasks assigned.', "You're free.", 'Press n to ruin that.'],
+    all: ['No open tasks in this workspace.', 'Suspiciously peaceful.'],
+    todo: ['Nothing waiting in Todo.'],
+    in_progress: ['Nothing in progress.', 'Pick something up with s on a task.'],
+    review: ['Nothing waiting for review.'],
+    blocked: ['Nothing blocked.', 'Keep it that way.'],
+    done: ['Nothing done yet.', 'The day is young.'],
+    archived: ['Nothing archived.', 'Archive a task from its Edit menu (e).'],
+};
+export const EMPTY_SEARCH = ['Nothing matches.', 'Maybe it is still in a WhatsApp chat.'];
+export const EMPTY_PROJECTS = ['No projects yet.', 'Press n to add the first one.'];
+/** One dry remark for the summary line, or null. Never more than one. */
+export function summaryRemark(counts) {
+    if (counts.blocked >= 3)
+        return 'That is a lot of walls.';
+    if (counts.review >= 3)
+        return 'Someone has homework.';
+    if (counts.in_progress >= 5)
+        return 'Many plates spinning.';
+    return null;
+}

package/dist/ui/hooks/use-commands.js

@@ -0,0 +1,58 @@
+import { FILTER_LABELS, TASK_FILTERS } from '../../application/filters.js';
+import { useAppState } from '../app-state.js';
+import { useFlows } from './use-flows.js';
+/** The command palette: every major action, filterable by typing. */
+export function useCommandPalette(newTaskProjectId) {
+    const { openOverlay, go, quit, services, session, notify, setHomeFilter } = useAppState();
+    // Views of home: the filter is shared app state (the sidebar shows it too).
+    const showView = (filter) => {
+        setHomeFilter(filter);
+        go({ type: 'reset' });
+    };
+    const flows = useFlows();
+    return () => {
+        const commands = [
+            { id: 'new-task', label: 'New task', key: 'n', run: () => openOverlay({ kind: 'new-task', projectId: newTaskProjectId }) },
+            ...TASK_FILTERS.map((filter) => ({
+                id: `filter-${filter}`,
+                label: FILTER_LABELS[filter],
+                run: () => showView(filter),
+            })),
+            { id: 'filter-archived', label: 'Archived tasks', run: () => showView('archived') },
+            { id: 'search', label: 'Search', key: '/', run: () => openOverlay({ kind: 'search' }) },
+            { id: 'projects', label: 'Projects', key: 'p', run: () => go({ type: 'push', route: { name: 'projects' } }) },
+            { id: 'switch-project', label: 'Switch project', run: () => flows.pickProject() },
+            { id: 'new-project', label: 'New project', run: () => flows.newProject() },
+            { id: 'switch-workspace', label: 'Switch workspace', run: () => flows.pickWorkspace() },
+            { id: 'workspaces', label: 'Workspaces', key: 'w', run: () => go({ type: 'push', route: { name: 'workspaces' } }) },
+            { id: 'new-workspace', label: 'New workspace', run: () => flows.newWorkspace() },
+            { id: 'add-developer', label: 'Add developer', run: () => flows.addDeveloper() },
+            { id: 'parent-folders', label: 'Parent folders', run: () => flows.manageParentFolders() },
+            { id: 'git-log', label: 'Git log', run: () => openOverlay({ kind: 'git-log' }) },
+            ...(services.chat ? [{ id: 'chat', label: 'Chat', key: '#', run: () => go({ type: 'push', route: { name: 'chat' } }) }] : []),
+            ...(services.sync
+                ? [{
+                        id: 'sync',
+                        label: 'Sync now',
+                        run: async () => {
+                            await services.sync?.syncNow(session.workspace.id);
+                            notify('Synced', 'success');
+                        },
+                    }]
+                : []),
+            { id: 'help', label: 'Help', key: '?', run: () => go({ type: 'push', route: { name: 'help' } }) },
+            { id: 'quit', label: 'Quit', key: 'q', run: quit },
+        ];
+        const spec = {
+            kind: 'picker',
+            title: 'Commands',
+            options: commands.map((command) => ({ value: command.id, label: command.label, ...(command.key ? { hint: command.key } : {}) })),
+            filterable: true,
+            onSelect: (id) => {
+                // Commands may open their own overlay; the palette only closes itself if still on top.
+                void commands.find((command) => command.id === id)?.run();
+            },
+        };
+        openOverlay(spec);
+    };
+}

package/dist/ui/hooks/use-flows.js

@@ -0,0 +1,254 @@
+import { basename } from 'node:path';
+import { deriveProjectKey } from '../../domain/naming.js';
+import { toDisplayError } from '../../utils/errors.js';
+import { tildify } from '../../utils/text.js';
+import { useAppState } from '../app-state.js';
+const ADD = '__add-parent__';
+const TYPE = '__type-path__';
+const UNLINK = '__unlink__';
+const MISSING = '__missing__:';
+/** Workspace-level flows, shared by their screens and the command palette. */
+export function useFlows() {
+    const { services, session, setSession, openOverlay, run, notify, go, cwd } = useAppState();
+    const switchWorkspace = async (id) => {
+        if (id === session.workspace.id)
+            return true;
+        let next;
+        const ok = await run(async () => {
+            next = await services.workspaces.switchTo(session.user, id);
+        });
+        if (ok && next) {
+            setSession(next);
+            notify(`Now in ${next.workspace.name}`, 'success');
+        }
+        return ok;
+    };
+    /** Adds a parent folder, then continues with `next` (e.g. reopening the picker). */
+    const addParentFolder = (next) => openOverlay({
+        kind: 'prompt',
+        title: 'Add parent folder',
+        context: 'a folder that contains your repositories',
+        placeholder: '~/workspace/products',
+        onSubmit: async (path) => {
+            const ok = await run(async () => services.folders.add(path), `Added ${path.trim()}`);
+            if (ok && next)
+                await next();
+            return ok;
+        },
+    });
+    const typeRepositoryPath = (project) => openOverlay({
+        kind: 'prompt',
+        title: 'Repository path',
+        context: project.name,
+        initial: project.repositoryPath ?? cwd,
+        onSubmit: (path) => run(() => services.projects.linkRepository(session, project, path), `${project.name} linked to ${path.trim()}`),
+    });
+    /**
+     * Visual repository picker: every subfolder of every parent folder, like
+     * `ls -1`, filterable by typing. Git repositories are marked; folders
+     * already linked to another project say so.
+     */
+    const pickRepository = async (project) => {
+        let parents;
+        try {
+            parents = services.folders.browse();
+        }
+        catch (error) {
+            const display = toDisplayError(error);
+            notify(display.message, 'error', display.hint);
+            return;
+        }
+        if (parents.length === 0) {
+            addParentFolder(() => pickRepository(project));
+            return;
+        }
+        const projects = await services.projects.list(session);
+        const linkedTo = new Map(projects.flatMap((p) => (p.repositoryPath && p.id !== project.id ? [[p.repositoryPath, p.name]] : [])));
+        const names = parents.map((parent) => basename(parent.path));
+        const parentLabel = (path) => {
+            const name = basename(path);
+            return names.filter((candidate) => candidate === name).length > 1 ? tildify(path) : name;
+        };
+        const folders = parents.flatMap((parent) => parent.available
+            ? parent.children.map((child) => {
+                const other = linkedTo.get(child.path);
+                return {
+                    value: child.path,
+                    label: `${parentLabel(parent.path)}/${child.name}`,
+                    hint: !child.isGitRepository ? 'not a Git repository' : other ? `git · linked to ${other}` : 'git',
+                    dim: !child.isGitRepository,
+                };
+            })
+            : [{ value: `${MISSING}${parent.path}`, label: `${tildify(parent.path)}  (folder not found)`, dim: true }]);
+        const actions = [
+            { value: ADD, label: '+ Add parent folder…', hint: `${parents.length} registered` },
+            { value: TYPE, label: 'Type a path…' },
+            ...(project.repositoryPath ? [{ value: UNLINK, label: 'Unlink repository', hint: tildify(project.repositoryPath) }] : []),
+        ];
+        openOverlay({
+            kind: 'picker',
+            title: `Repository for ${project.name}`,
+            context: 'type to filter',
+            options: [...folders, ...actions],
+            initial: project.repositoryPath,
+            filterable: true,
+            onSelect: (value) => {
+                if (value === ADD)
+                    return void addParentFolder(() => pickRepository(project));
+                if (value === TYPE)
+                    return void typeRepositoryPath(project);
+                if (value === UNLINK)
+                    return run(() => services.projects.unlinkRepository(session, project), `${project.name} unlinked`);
+                if (value.startsWith(MISSING)) {
+                    notify('That parent folder no longer exists.', 'error', 'Remove it from Parent folders in the command palette.');
+                    return false;
+                }
+                if (!folders.find((option) => option.value === value && !option.dim)) {
+                    notify(`${tildify(value)} is not a Git repository.`, 'error', 'Run `git init` there, or pick another folder.');
+                    return false;
+                }
+                return run(() => services.projects.linkRepository(session, project, value), `${project.name} linked to ${tildify(value)}`);
+            },
+        });
+    };
+    const prompt = (project, field, title, placeholder) => openOverlay({
+        kind: 'prompt',
+        title,
+        context: `${project.key} · ${project.name}`,
+        initial: project[field] ?? '',
+        placeholder,
+        allowEmpty: field !== 'name',
+        onSubmit: (value) => run(() => services.projects.update(session, project, { [field]: value }), `${project.key} updated`),
+    });
+    return {
+        switchWorkspace,
+        pickRepository,
+        addParentFolder,
+        /** Name, description and repository URL. The key stays (people and scripts use it). */
+        editProject(project) {
+            openOverlay({
+                kind: 'picker',
+                title: 'Edit project',
+                context: `${project.key} · ${project.name}`,
+                options: [
+                    { value: 'name', label: 'Name', hint: project.name },
+                    { value: 'description', label: 'Description', hint: project.description ?? '—' },
+                    { value: 'repositoryUrl', label: 'Repository URL', hint: project.repositoryUrl ?? '—' },
+                    { value: 'repo', label: 'Linked folder on this machine…', hint: project.repositoryPath ? tildify(project.repositoryPath) : 'r' },
+                ],
+                onSelect: (value) => {
+                    if (value === 'name')
+                        prompt(project, 'name', 'Project name', 'EnrollBridge');
+                    else if (value === 'description')
+                        prompt(project, 'description', 'Description', 'What this project is');
+                    else if (value === 'repositoryUrl')
+                        prompt(project, 'repositoryUrl', 'Repository URL', 'https://github.com/org/repo');
+                    else if (value === 'repo')
+                        void pickRepository(project);
+                },
+            });
+        },
+        /** Lists parent folders; choosing one offers to remove it. */
+        manageParentFolders() {
+            const parents = services.folders.browse();
+            openOverlay({
+                kind: 'picker',
+                title: 'Parent folders',
+                context: 'where your repositories live',
+                options: [
+                    ...parents.map((parent) => ({
+                        value: parent.path,
+                        label: tildify(parent.path),
+                        hint: parent.available ? `${parent.children.length} folders` : 'not found',
+                        dim: !parent.available,
+                    })),
+                    { value: ADD, label: '+ Add parent folder…' },
+                ],
+                filterable: parents.length > 8,
+                onSelect: (value) => {
+                    if (value === ADD)
+                        return void addParentFolder();
+                    openOverlay({
+                        kind: 'picker',
+                        title: `Remove ${tildify(value)}?`,
+                        context: 'only forgets it; nothing is deleted from disk',
+                        options: [
+                            { value: 'remove', label: 'Remove from parent folders' },
+                            { value: 'cancel', label: 'Cancel', dim: true },
+                        ],
+                        onSelect: (answer) => answer === 'remove' ? run(async () => services.folders.remove(value), `Removed ${tildify(value)}`) : undefined,
+                    });
+                },
+            });
+        },
+        newProject() {
+            openOverlay({
+                kind: 'prompt',
+                title: 'New project',
+                context: session.workspace.name,
+                placeholder: 'EnrollBridge',
+                // The key prompt replaces this one: confirm or change the derived key.
+                onSubmit: (name) => openOverlay({
+                    kind: 'prompt',
+                    title: 'Project key',
+                    context: name.trim(),
+                    initial: deriveProjectKey(name),
+                    onSubmit: (key) => run(() => services.projects.create(session, { name, key }), `Project ${name.trim()} created`),
+                }),
+            });
+        },
+        addDeveloper() {
+            const remote = services.environment.mode === 'remote';
+            openOverlay({
+                kind: 'prompt',
+                title: 'Add developer',
+                context: remote ? `${session.workspace.name} · GitHub login of someone who ran soja login` : session.workspace.name,
+                placeholder: 'username, e.g. angel',
+                onSubmit: (username) => remote
+                    ? run(() => services.workspaces.addMember(session, { username }), `@${username.trim().replace(/^@/, '').toLowerCase()} joined ${session.workspace.name}`)
+                    : openOverlay({
+                        kind: 'prompt',
+                        title: 'Display name',
+                        context: `@${username.trim().toLowerCase()}`,
+                        initial: username.trim().replace(/^./, (char) => char.toUpperCase()),
+                        onSubmit: (displayName) => run(() => services.workspaces.addMember(session, { username, displayName }), `@${username.trim().toLowerCase()} joined ${session.workspace.name}`),
+                    }),
+            });
+        },
+        newWorkspace() {
+            openOverlay({
+                kind: 'prompt',
+                title: 'New workspace',
+                placeholder: 'Freelance',
+                onSubmit: async (name) => {
+                    let createdId;
+                    const ok = await run(async () => {
+                        createdId = (await services.workspaces.create(session.user, { name })).id;
+                    });
+                    return ok && createdId ? switchWorkspace(createdId) : ok;
+                },
+            });
+        },
+        async pickWorkspace() {
+            const workspaces = await services.workspaces.list(session.user);
+            openOverlay({
+                kind: 'picker',
+                title: 'Switch workspace',
+                options: workspaces.map((workspace) => ({ value: workspace.id, label: workspace.name, hint: workspace.slug })),
+                initial: session.workspace.id,
+                filterable: true,
+                onSelect: switchWorkspace,
+            });
+        },
+        async pickProject() {
+            const projects = await services.projects.list(session);
+            openOverlay({
+                kind: 'picker',
+                title: 'Switch project',
+                options: projects.map((project) => ({ value: project.id, label: project.name, hint: `${project.key} · ${project.active} active` })),
+                filterable: true,
+                onSelect: (projectId) => go({ type: 'reset', route: { name: 'project', projectId } }),
+            });
+        },
+    };
+}