gitroots 0.0.0-stage → 0.6.0

package/src/session/workspace.js

@@ -0,0 +1,270 @@
+// /status · /repos · /repo · /approvals · /pushes · /audit · /activity · /members (all live from gitroots)
+import { select, interactive, ask, confirm } from '../ui/term.js';
+import { json } from '../ui/components.js';
+import { localSessions } from '../agents/local.js';
+import { c, h, line, pad, fit, next, needWorkspace, load, ago, empty, table, cols, cmdText } from './helpers.js';
+
+const plural = (n, w) => `${n} ${n === 1 ? w : w.endsWith('y') && !/[aeiou]y$/.test(w) ? `${w.slice(0, -1)}ies` : w.endsWith('s') || w.endsWith('sh') || w.endsWith('ch') ? `${w}es` : w === 'person' ? 'people' : `${w}s`}`;
+
+// ---------------------------------------------------------------- /status
+
+export async function status(ctx) {
+  needWorkspace(ctx);
+  const [home, agents] = await load(ctx, 'Loading your workspace…', () => Promise.all([
+    ctx.api.home({ signal: ctx.signal }),
+    ctx.api.agents({ signal: ctx.signal }).catch(() => null),
+  ]));
+  const local = localSessions({ limit: 30 });
+  const waitingAgents = (agents?.sessions || []).filter((s) => s.needs_you);
+  if (ctx.json) { json({ ...home, agents_waiting: waitingAgents, local_agents_live: local.filter((s) => s.status === 'live').length }); return 0; }
+
+  const p = home.posture || {};
+  const cov = p.coverage || {};
+  line(`${c.g(c.b('gitroots'))} ${c.m('·')} ${c.b(home.organization.name)} ${c.m('·')} ${home.user.display_name || home.user.name} ${c.m('·')} ${c.m(ctx.api.host)}`);
+  line();
+  line(h('Posture'));
+  const inPolicy = p.all_in_policy ? c.g('✓ all in policy') : c.w('◐ not all in policy');
+  line(`  ${plural(p.repo_count || 0, 'repository')} ${c.m('·')} ${p.protected_count || 0} protected ${c.m('·')} ${cov.overlay || 0} shared by overlay ${c.m('·')} ${cov.open || 0} open   ${inPolicy}`);
+  line(`  ${plural(home.developer_count || 0, 'developer')} ${c.m('·')} ${home.blocked_24h ? c.r(`✕ ${plural(home.blocked_24h, 'blocked push')} in 24h`) : c.g('✓ no blocked pushes in 24h')}`);
+  line();
+  line(h('Needs you'));
+  let any = false;
+  for (const a of home.awaiting || []) {
+    any = true;
+    line(`  ${c.w(pad('◐ review', 11))} ${fit(a.title, 44)}  ${c.m(fit(`${a.meta || ''} · ${a.age || ''}`, Math.max(10, cols() - 62)))}`);
+  }
+  if (home.pending_count > (home.awaiting || []).length) line(`  ${c.m(`+ ${home.pending_count - (home.awaiting || []).length} more`)}`);
+  for (const s of waitingAgents.slice(0, 4)) {
+    any = true;
+    line(`  ${c.w(pad('◐ agent', 11))} ${fit(`${s.agent_name} on ${s.machine}: ${s.ask?.what || s.title}`, 44)}  ${c.m(fit(s.ask?.cmd || '', Math.max(10, cols() - 62)))}`);
+  }
+  if (!any) line(`  ${c.g('✓ nothing waiting on you')}`);
+  line();
+  const live = local.filter((s) => s.status === 'live').length;
+  const remote = (agents?.sessions || []).filter((s) => s.active).length;
+  line(h('Agents'));
+  line(`  ${remote ? c.g(`● ${remote} active on your machines`) : c.m('○ none reported by the gitroots app')} ${c.m('·')} ${live ? c.g(`● ${live} live on this computer`) : c.m(`○ ${local.length} recent on this computer`)}`);
+  line();
+  if (home.pending_count) next(ctx, 'approvals');
+  else if (waitingAgents.length) next(ctx, 'agents');
+  else if (home.blocked_24h) next(ctx, 'pushes', '--blocked');
+  else next(ctx, 'repos');
+  return 0;
+}
+
+// ---------------------------------------------------------------- /repos, /repo
+
+export async function repos(ctx) {
+  needWorkspace(ctx);
+  const d = await load(ctx, 'Loading repositories…', () => ctx.api.repos({ signal: ctx.signal }));
+  if (ctx.json) { json(d.repos); return 0; }
+  if (!d.repos.length) {
+    empty(d.github?.connected === false ? 'no repositories · connect GitHub in the gitroots dashboard' : 'no repositories synced yet');
+    return 0;
+  }
+  table([
+    { label: 'REPOSITORY', w: 34, fmt: (r) => c.b(r.full_name) },
+    { label: 'DEFAULT', w: 12, key: 'default_branch' },
+    { label: 'BRANCHES', w: 10, key: 'branch_count' },
+    { label: 'RULES', w: 8, key: 'rule_count' },
+    { label: 'OVERLAYS', w: 10, key: 'overlay_count' },
+    { label: 'STATUS', w: 16, fmt: (r) => (r.protected ? c.g('● protected') : c.m('○ open')) },
+  ], d.repos);
+  line();
+  next(ctx, 'repo', d.repos[0].name);
+  return 0;
+}
+
+async function pickRepo(ctx) {
+  const d = await load(ctx, 'Loading repositories…', () => ctx.api.repos({ signal: ctx.signal }));
+  if (!d.repos.length) throw new Error('no repositories in this workspace yet');
+  if (!interactive()) throw new Error(`which repository? ${cmdText(ctx, 'repo', '<name>')}`);
+  line(`${c.i(c.b('?'))} Which repository?`);
+  const res = await select({
+    count: d.repos.length,
+    render: (i) => windowed(d.repos, i, 10, (r, sel) => `${sel ? c.g('❯ ') : '  '}${sel ? c.b(pad(r.full_name, 40)) : pad(r.full_name, 40)}${r.protected ? c.g('● protected') : c.m('○ open')}`),
+  });
+  return res.action === 'cancel' ? null : d.repos[res.index].full_name;
+}
+
+export function windowed(items, idx, max, row) {
+  const start = Math.max(0, Math.min(idx - Math.floor(max / 2), items.length - max));
+  const out = items.slice(start, start + max).map((it, j) => row(it, start + j === idx));
+  if (items.length > max) out.push(c.m(`  ${idx + 1} of ${items.length} · ↑↓ to move · enter to choose · esc to cancel`));
+  return out.join('\n');
+}
+
+export async function repo(ctx, args) {
+  needWorkspace(ctx);
+  const name = args[0] || await pickRepo(ctx);
+  if (!name) return 1;
+  const r = await load(ctx, `Loading ${name}…`, () => ctx.api.repo(name, { signal: ctx.signal }));
+  if (ctx.json) { json(r); return 0; }
+  line(`${c.b(r.full_name)}  ${r.protected ? c.g('● protected') : c.m('○ open')}  ${c.m(`default ${r.default_branch} · ${plural(r.branches.length, 'branch')} · ${plural(r.overlay_count, 'overlay')}`)}`);
+  line();
+  line(h('Branch rules'));
+  if (!r.branch_rules.length) empty(`no rules${r.can_manage ? ' · add them on gitroots.com › Repositories' : ''}`);
+  for (const b of r.branch_rules) {
+    const push = b.allow_direct_push ? c.g('✓ direct push') : c.r('✕ no direct push');
+    line(`  ${c.b(pad(b.pattern, 22))}${pad(b.level === 'leads' ? c.w('◐ leads only') : b.level === 'open' ? c.m('○ open') : c.g(`● ${b.level}`), 16)}${pad(push, 20)}${c.m(b.description)}`);
+  }
+  if (r.github_protected_branches?.length) line(`  ${c.m(`GitHub protects: ${r.github_protected_branches.join(', ')}`)}`);
+  if (r.environments?.length) {
+    line();
+    line(h('Environments'));
+    for (const e of r.environments) line(`  ${pad(e.name, 18)}${pad(e.branch || '', 22)}${c.m(`${e.audience || ''} · ${e.state || ''}`)}`);
+  }
+  line();
+  line(h(`People · ${r.developer_count}${r.external_count ? ` (${r.external_count} external)` : ''}`));
+  for (const p of r.people.slice(0, 12)) line(`  ${pad(p.display_name || p.name, 26)}${c.m(p.detail || p.kind)}`);
+  if (r.people.length > 12) line(`  ${c.m(`+ ${r.people.length - 12} more`)}`);
+  line();
+  line(h('Branches'));
+  if (!r.branches.length) empty('none synced yet · gitroots fetches them from GitHub');
+  else line(`  ${fit(r.branches.slice(0, 30).join('  '), cols() - 4)}${r.branches.length > 30 ? c.m(`  + ${r.branches.length - 30} more`) : ''}`);
+  return 0;
+}
+
+// ---------------------------------------------------------------- /approvals
+
+function approvalRow(a, sel) {
+  const mark = a.status === 'failed' ? c.r('✕ failed ') : a.status === 'queued' ? c.i('○ merging') : a.type === 'access' ? c.w('◐ access ') : c.w('◐ merge  ');
+  const who = a.requested_by?.display_name || a.user?.display_name || '';
+  const t = `${fit(a.title, 40)}  ${c.m(fit([who, a.meta, a.age].filter(Boolean).join(' · '), Math.max(10, cols() - 62)))}`;
+  return `${sel ? c.g('❯ ') : '  '}${mark}  ${sel ? c.b(t) : t}`;
+}
+
+export async function approvals(ctx, args) {
+  needWorkspace(ctx);
+  const state = ['waiting', 'approved', 'declined'].includes(args[0]) ? args[0] : 'waiting';
+  const d = await load(ctx, 'Loading approvals…', () => ctx.api.approvals(state, { signal: ctx.signal }));
+  if (ctx.json) { json(d); return 0; }
+  if (!d.items.length) { line(`${c.g('✓')} nothing ${state === 'waiting' ? 'waiting on approval' : state}`); return 0; }
+  if (!ctx.session || !interactive() || state !== 'waiting') {
+    for (const a of d.items) line(approvalRow(a, false));
+    line();
+    next(ctx, 'approvals');
+    return 0;
+  }
+  line(`${c.i(c.b('?'))} ${plural(d.waiting_count, 'request')} waiting · pick one`);
+  const res = await select({ count: d.items.length, render: (i) => windowed(d.items, i, 8, approvalRow) });
+  if (res.action === 'cancel') return 0;
+  return decideApproval(ctx, d.items[res.index]);
+}
+
+async function decideApproval(ctx, a) {
+  line();
+  line(`${c.b(a.title)}  ${c.m(a.kind)}`);
+  if (a.type === 'sync') {
+    line(`  ${c.s(pad('from', 10))}${a.from}:${a.from_branch} → ${a.to}:${a.to_branch}`);
+    line(`  ${c.s(pad('changes', 10))}${plural(a.commits || 0, 'commit')}${a.files != null ? ` · ${plural(a.files, 'file')} ${c.g(`+${a.additions || 0}`)} ${c.r(`−${a.deletions || 0}`)}` : ''}`);
+    if (a.requested_by) line(`  ${c.s(pad('by', 10))}${a.requested_by.display_name} ${c.m(a.requester_meta || '')}`);
+    if (a.ai_risk) line(`  ${c.s(pad('ai review', 10))}${a.ai_risk}`);
+  } else {
+    line(`  ${c.s(pad('who', 10))}${a.user?.display_name} ${c.m(a.requester_meta || '')}`);
+    line(`  ${c.s(pad('wants', 10))}${a.rule.replace(/_/g, ' ')} on ${a.repo}${a.branch ? ` (${a.branch})` : ''} for ${a.days} days ${a.within_policy ? c.g('✓ within policy') : c.w(`◐ policy max ${a.policy_max_days} days`)}`);
+  }
+  if (a.note) line(`  ${c.s(pad('note', 10))}${a.note}`);
+  line();
+  const actions = a.type === 'sync'
+    ? (a.status === 'failed' ? [['retry', 'Retry the merge'], ['decline', 'Decline'], ['back', 'Back']]
+      : a.status === 'queued' ? [['back', 'Back (merge in progress)']]
+        : [['approve', 'Approve and merge'], ['changes', 'Request changes'], ['decline', 'Decline'], ['back', 'Back']])
+    : [['approve', 'Approve access'], ['decline', 'Decline'], ['back', 'Back']];
+  const pick = await select({ count: actions.length, render: (i) => actions.map(([, label], j) => `${j === i ? c.g('❯ ') : '  '}${j === i ? c.b(label) : label}`).join('\n') });
+  if (pick.action === 'cancel') return 0;
+  const act = actions[pick.index][0];
+  if (act === 'back') return 0;
+  let result;
+  if (a.type === 'sync' && (act === 'approve' || act === 'retry')) {
+    if (!(await confirm(`Merge ${a.from_branch} into ${a.to}:${a.to_branch}?`, { def: false }))) { line(c.m('  nothing changed')); return 0; }
+    const note = await ask('Note (optional)');
+    result = await load(ctx, 'Approving…', () => ctx.api.approveSync(a.id, note, { signal: ctx.signal }));
+    line(`${c.g('✓')} Approved ${c.b(a.title)} ${c.m(`· ${result?.detail === 'queued' ? 'merge queued' : 'merged'}`)}`);
+  } else if (a.type === 'sync') {
+    const reason = await ask(act === 'changes' ? 'What needs to change?' : 'Reason (optional)');
+    if (act === 'changes' && !reason) { line(c.m('  nothing sent')); return 0; }
+    await load(ctx, 'Sending…', () => ctx.api.declineSync(a.id, act === 'changes' ? 'changes' : 'decline', reason, { signal: ctx.signal }));
+    line(`${act === 'changes' ? c.w('◐ Changes requested on') : c.r('✕ Declined')} ${c.b(a.title)}`);
+  } else {
+    const reason = act === 'decline' ? await ask('Reason (optional)') : '';
+    await load(ctx, 'Saving…', () => ctx.api.decideAccess(a.id, act, reason, { signal: ctx.signal }));
+    line(`${act === 'approve' ? c.g('✓ Approved') : c.r('✕ Declined')} ${c.b(a.title)}`);
+  }
+  next(ctx, 'approvals');
+  return 0;
+}
+
+// ---------------------------------------------------------------- /pushes, /audit, /activity, /members
+
+export async function pushes(ctx, args, flags) {
+  needWorkspace(ctx);
+  const blocked = Boolean(flags.blocked || args.includes('blocked'));
+  const d = await load(ctx, 'Loading pushes…', () => ctx.api.pushEvents(blocked, { signal: ctx.signal }));
+  if (ctx.json) { json(d.items); return 0; }
+  if (!d.items.length) { empty(blocked ? 'no blocked pushes' : 'no pushes recorded yet'); return 0; }
+  table([
+    { label: 'WHEN', w: 18, fmt: (e) => c.m(`${e.date} ${e.time}`) },
+    { label: 'REPO', w: 22, key: 'repo_name' },
+    { label: 'BRANCH', w: 24, key: 'branch' },
+    { label: 'BY', w: 16, key: 'pusher' },
+    { label: 'COMMITS', w: 9, key: 'commit_count' },
+    { label: 'RESULT', w: 30, fmt: (e) => (e.blocked ? c.r(`✕ blocked ${e.rule ? `· ${e.rule}` : ''}`) : c.g('✓ allowed')) },
+  ], d.items.slice(0, 40));
+  return 0;
+}
+
+const CATEGORIES = ['All', 'Blocked', 'Merges', 'Access', 'Other'];
+
+export async function audit(ctx, args, flags) {
+  needWorkspace(ctx);
+  const category = CATEGORIES.find((x) => x.toLowerCase() === String(args[0] || flags.category || 'all').toLowerCase()) || 'All';
+  const q = flags.q || flags.search || (CATEGORIES.some((x) => x.toLowerCase() === String(args[0]).toLowerCase()) ? args.slice(1) : args).join(' ');
+  const d = await load(ctx, 'Loading audit log…', () => ctx.api.audit(category, q, { signal: ctx.signal }));
+  if (ctx.json) { json(d.items); return 0; }
+  if (!d.items.length) { empty('no events match'); return 0; }
+  const summary = (m) => Object.entries(m || {}).filter(([, v]) => v !== '' && v !== null && typeof v !== 'object').slice(0, 3).map(([k, v]) => `${k} ${v}`).join(' · ');
+  table([
+    { label: 'WHEN', w: 17, fmt: (e) => c.m(`${e.day.slice(5)} ${e.time}`) },
+    { label: 'WHO', w: 20, key: 'actor_short' },
+    { label: 'WHAT', w: 30, fmt: (e) => (e.category === 'Blocked' ? c.r(e.action_display) : e.action_display) },
+    { label: 'DETAILS', w: 40, fmt: (e) => c.m(summary(e.metadata)) },
+  ], d.items.slice(0, 50));
+  line(`  ${c.m(`${Math.min(50, d.items.length)} of ${d.items.length} · categories: ${CATEGORIES.join(', ')} · e.g. ${cmdText(ctx, 'audit', 'blocked')}`)}`);
+  return 0;
+}
+
+export async function activity(ctx) {
+  needWorkspace(ctx);
+  const d = await load(ctx, 'Loading team activity…', () => ctx.api.teamActivity({ signal: ctx.signal }));
+  if (ctx.json) { json(d); return 0; }
+  const delta = d.delta_pct === null || d.delta_pct === undefined ? '' : d.delta_pct >= 0 ? c.g(` ↑ ${d.delta_pct}%`) : c.r(` ↓ ${Math.abs(d.delta_pct)}%`);
+  line(`${c.b(d.organization)} ${c.m(`· last ${d.weeks} weeks`)}`);
+  line(`  ${plural(d.commit_count || 0, 'commit')} ${c.m('·')} ${plural(d.merged_count || 0, 'merge')} ${c.m('·')} ${plural(d.people_count || 0, 'person')}${delta}`);
+  // heatmap: one row of the weekly levels
+  const levels = (d.cells || []).map((x) => (typeof x === 'object' ? x.level ?? 0 : x));
+  if (levels.length) {
+    const shades = [c.m('·'), c.g('▁'), c.g('▃'), c.g('▅'), c.g('█')];
+    line(`  ${levels.slice(-Math.min(levels.length, 70)).map((l) => shades[Math.max(0, Math.min(4, l))]).join('')}  ${c.m('daily, oldest → today')}`);
+  }
+  for (const [title, rows] of [['Most active', d.most_active], ['Leads', d.leads], ['External', d.external]]) {
+    if (!rows || !rows.length) continue;
+    line();
+    line(h(title));
+    for (const p of rows.slice(0, 8)) line(`  ${pad(p.display_name || p.name, 26)}${pad(`${p.commits} commits · ${p.merged} merged`, 30)}${c.m(p.detail || p.role || '')}`);
+  }
+  return 0;
+}
+
+export async function members(ctx) {
+  needWorkspace(ctx);
+  const d = await load(ctx, 'Loading members…', () => ctx.api.members({ signal: ctx.signal }));
+  if (ctx.json) { json(d.members); return 0; }
+  table([
+    { label: 'NAME', w: 28, fmt: (m) => c.b(m.display_name || m.name) },
+    { label: 'EMAIL', w: 34, key: 'email' },
+    { label: 'ROLE', w: 16, fmt: (m) => m.role_display || m.role },
+    { label: '', w: 10, fmt: (m) => (m.external ? c.w('external') : '') },
+  ], d.members);
+  return 0;
+}

package/src/ui/ansi.js

@@ -0,0 +1,138 @@
+// Colors, widths and padding. Palette comes straight from the design tokens:
+//   g  #60DD65  success and the one next action
+//   m  #A5B8B1  muted
+//   s  #C9D6D0  secondary
+//   w  #F5BF57  needs you
+//   r  #FF7474  real block or failure
+//   i  #73C5FF  in progress / info
+//   fg #F1F7F3
+// Colors drop when output is piped or NO_COLOR is set.
+
+const env = process.env;
+
+function detectColor(stream = process.stdout) {
+  if (env.NO_COLOR !== undefined && env.NO_COLOR !== '') return false;
+  if (env.FORCE_COLOR !== undefined) return env.FORCE_COLOR !== '0';
+  if (env.TERM === 'dumb') return false;
+  return Boolean(stream.isTTY);
+}
+
+function detectTruecolor() {
+  const ct = (env.COLORTERM || '').toLowerCase();
+  if (ct === 'truecolor' || ct === '24bit') return true;
+  const tp = env.TERM_PROGRAM || '';
+  if (['iTerm.app', 'WezTerm', 'ghostty', 'vscode', 'Hyper'].includes(tp)) return true;
+  if (env.WT_SESSION) return true;
+  const term = env.TERM || '';
+  return /kitty|ghostty|direct|truecolor/.test(term);
+}
+
+export const state = {
+  color: detectColor(),
+  truecolor: detectTruecolor(),
+};
+
+export function setColor(on) { state.color = on; }
+
+const PALETTE = {
+  g: [0x60, 0xdd, 0x65, 77],
+  m: [0xa5, 0xb8, 0xb1, 109],
+  s: [0xc9, 0xd6, 0xd0, 152],
+  w: [0xf5, 0xbf, 0x57, 221],
+  r: [0xff, 0x74, 0x74, 210],
+  i: [0x73, 0xc5, 0xff, 117],
+  fg: [0xf1, 0xf7, 0xf3, 255],
+  ink: [0x07, 0x14, 0x11, 233],
+};
+
+const BG = {
+  bar: [0x0f, 0x26, 0x20, 234],
+  attach: [0x12, 0x44, 0x35, 23],
+  sel: [0x12, 0x44, 0x35, 23],
+  key: [0x1a, 0x33, 0x2c, 236],
+  red: [0x3a, 0x1c, 0x1c, 52],
+  green: [0x60, 0xdd, 0x65, 77],
+};
+
+function fgCode([r, g, b, n]) { return state.truecolor ? `\x1b[38;2;${r};${g};${b}m` : `\x1b[38;5;${n}m`; }
+function bgCode([r, g, b, n]) { return state.truecolor ? `\x1b[48;2;${r};${g};${b}m` : `\x1b[48;5;${n}m`; }
+
+function paint(code, reset) {
+  return (s) => (state.color ? `${code()}${s}${reset}` : String(s));
+}
+
+export const c = {
+  g: paint(() => fgCode(PALETTE.g), '\x1b[39m'),
+  m: paint(() => fgCode(PALETTE.m), '\x1b[39m'),
+  s: paint(() => fgCode(PALETTE.s), '\x1b[39m'),
+  w: paint(() => fgCode(PALETTE.w), '\x1b[39m'),
+  r: paint(() => fgCode(PALETTE.r), '\x1b[39m'),
+  i: paint(() => fgCode(PALETTE.i), '\x1b[39m'),
+  fg: paint(() => fgCode(PALETTE.fg), '\x1b[39m'),
+  ink: paint(() => fgCode(PALETTE.ink), '\x1b[39m'),
+  b: paint(() => '\x1b[1m', '\x1b[22m'),
+  dim: paint(() => '\x1b[2m', '\x1b[22m'),
+  inv: paint(() => '\x1b[7m', '\x1b[27m'),
+  // Backgrounds nest: an inner reset falls back to this background, not the terminal's.
+  bg: (name) => (s) => {
+    if (!state.color) return String(s);
+    const code = bgCode(BG[name]);
+    return `${code}${String(s).split('\x1b[49m').join(code).split('\x1b[0m').join(`\x1b[0m${code}`)}\x1b[49m`;
+  },
+};
+
+// Header labels: muted caps, like the design's small letter-spaced headings.
+export const h = (s) => c.m(String(s).toUpperCase());
+
+const ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b_[^\x1b]*\x1b\\/g;
+
+export function strip(s) { return String(s).replace(ANSI_RE, ''); }
+
+// Visible width. All glyphs the CLI prints (box drawing, ●◐○✓✕, braille spinners) are single-width.
+export function width(s) {
+  let n = 0;
+  for (const ch of strip(s)) {
+    const cp = ch.codePointAt(0);
+    if (cp === 0x200d || (cp >= 0xfe00 && cp <= 0xfe0f) || (cp >= 0x300 && cp <= 0x36f)) continue;
+    n += isWide(cp) ? 2 : 1;
+  }
+  return n;
+}
+
+function isWide(cp) {
+  return (cp >= 0x1100 && cp <= 0x115f) || (cp >= 0x2e80 && cp <= 0xa4cf) || (cp >= 0xac00 && cp <= 0xd7a3) ||
+    (cp >= 0xf900 && cp <= 0xfaff) || (cp >= 0xfe30 && cp <= 0xfe4f) || (cp >= 0xff00 && cp <= 0xff60) ||
+    (cp >= 0xffe0 && cp <= 0xffe6) || (cp >= 0x1f300 && cp <= 0x1faff) || (cp >= 0x20000 && cp <= 0x3fffd);
+}
+
+export function pad(s, n) {
+  const w = width(s);
+  return w >= n ? s : s + ' '.repeat(n - w);
+}
+
+export function padStart(s, n) {
+  const w = width(s);
+  return w >= n ? s : ' '.repeat(n - w) + s;
+}
+
+// Cut a (possibly colored) string to n visible columns.
+export function truncate(s, n) {
+  if (width(s) <= n) return s;
+  let out = '';
+  let w = 0;
+  let i = 0;
+  const str = String(s);
+  while (i < str.length) {
+    ANSI_RE.lastIndex = i;
+    const m = ANSI_RE.exec(str);
+    if (m && m.index === i) { out += m[0]; i += m[0].length; continue; }
+    const ch = String.fromCodePoint(str.codePointAt(i));
+    const cw = width(ch);
+    if (w + cw > n - 1) { out += '…'; break; }
+    out += ch; w += cw; i += ch.length;
+  }
+  return state.color ? `${out}\x1b[0m` : out;
+}
+
+// Fit to exactly n columns: truncate or pad.
+export function fit(s, n) { return pad(truncate(s, n), n); }

package/src/ui/components.js

@@ -0,0 +1,85 @@
+import { c, h, pad, width, strip, state as colorState } from './ansi.js';
+import { line } from './term.js';
+
+export const brand = () => c.g(c.b('gitroots'));
+export const dot = () => c.m('·');
+export const sep = (...parts) => parts.filter((p) => p !== undefined && p !== null && p !== '').join(` ${dot()} `);
+
+// Every screen ends with the next command.
+export function next(cmd, alt) {
+  const tail = alt ? `     ${c.m('or')}  ${c.s(alt)}` : '';
+  return `${c.g(`→ ${cmd}`)}${tail}`;
+}
+
+// State words always pair a symbol with a word.
+export const mark = {
+  running: (w = 'running') => c.g(`● ${w}`),
+  waiting: (w = 'waiting') => c.w(`◐ ${w}`),
+  queued: (w = 'queued') => c.m(`○ ${w}`),
+  done: (w = 'done') => c.g(`✓ ${w}`),
+  blocked: (w = 'blocked') => c.r(`✕ ${w}`),
+  idle: (w = 'idle') => c.s(`○ ${w}`),
+  suspended: (w = 'suspended') => c.m(`⏸ ${w}`),
+  offline: (w = 'offline') => c.m(`○ ${w}`),
+};
+
+export function sessionState(s) {
+  switch (s.state) {
+    case 'running': return mark.running();
+    case 'waiting': return mark.waiting('waiting input');
+    case 'idle': return mark.idle();
+    case 'suspended': return mark.suspended();
+    case 'paused': return c.w('⏸ paused');
+    case 'stopped': return c.m('■ stopped');
+    default: return c.m(s.state);
+  }
+}
+
+export function decision(d) {
+  if (d === 'allowed') return c.g('✓ allowed');
+  if (d === 'recorded') return c.g('✓ recorded');
+  if (d === 'blocked') return c.r('✕ blocked');
+  if (d === 'held') return c.w('◐ held');
+  return c.m(d);
+}
+
+/**
+ * Columns: [{ key, label, w, fmt?(row) }]. Last column has no padding.
+ */
+export function table(cols, rows, { indent = '  ' } = {}) {
+  const head = cols.map((col, i) => (i === cols.length - 1 ? col.label : pad(col.label, col.w))).join('');
+  line(indent + h(head));
+  for (const row of rows) {
+    const cells = cols.map((col, i) => {
+      const v = col.fmt ? col.fmt(row) : String(row[col.key] ?? '');
+      return i === cols.length - 1 ? v : pad(v, col.w);
+    });
+    line(indent + cells.join('').replace(/\s+$/, ''));
+  }
+}
+
+// Bordered box (blocked pushes etc). tone: 'r' | 'w' | 'g'
+export function box(lines, tone = 'r') {
+  const col = c[tone];
+  const inner = Math.max(...lines.map((l) => width(l))) + 2;
+  line(col(`╭${'─'.repeat(inner)}╮`));
+  for (const l of lines) line(`${col('│')} ${pad(l, inner - 2)} ${col('│')}`);
+  line(col(`╰${'─'.repeat(inner)}╯`));
+}
+
+export function heading(text) { line(h(text)); }
+
+export function json(data) {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+
+export function csv(rows, keys) {
+  const esc = (v) => {
+    const s = v === undefined || v === null ? '' : String(v);
+    return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+  };
+  process.stdout.write(`${keys.join(',')}\n`);
+  for (const r of rows) process.stdout.write(`${keys.map((k) => esc(r[k])).join(',')}\n`);
+}
+
+export { c, h, pad, width, strip, colorState };