@matthesketh/fleet 1.1.0 → 1.6.0

package/dist/tui/routines/components/LiveRunPanel.js

@@ -0,0 +1,107 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import { useRegisterHandler } from '@matthesketh/ink-input-dispatcher';
+import { formatDuration, formatUsd, truncate } from '../format.js';
+export function LiveRunPanel({ engine, routineId, target, onClose }) {
+    const [feed, setFeed] = useState([]);
+    const [status, setStatus] = useState('starting');
+    const [startedAt, setStartedAt] = useState(null);
+    const [endedAt, setEndedAt] = useState(null);
+    const [cost, setCost] = useState(null);
+    const [error, setError] = useState(null);
+    const abortRef = useRef(null);
+    useEffect(() => {
+        const ac = new AbortController();
+        abortRef.current = ac;
+        const append = (line) => {
+            setFeed(prev => (prev.length < 200 ? [...prev, line] : [...prev.slice(-199), line]));
+        };
+        void (async () => {
+            try {
+                for await (const ev of engine.runOnce(routineId, target ?? { repo: null, repoPath: null }, 'manual', ac.signal)) {
+                    switch (ev.kind) {
+                        case 'start':
+                            setStartedAt(Date.now());
+                            setStatus('running');
+                            append({ kind: 'info', text: `▶ start ${routineId}${ev.target ? ` · ${ev.target}` : ''}` });
+                            break;
+                        case 'stdout':
+                            for (const l of ev.chunk.split('\n'))
+                                if (l.trim())
+                                    append({ kind: 'stdout', text: l });
+                            break;
+                        case 'stderr':
+                            for (const l of ev.chunk.split('\n'))
+                                if (l.trim())
+                                    append({ kind: 'stderr', text: l });
+                            break;
+                        case 'tool-call':
+                            append({ kind: 'tool-call', text: `${ev.name}${ev.argsPreview ? ` ${ev.argsPreview}` : ''}` });
+                            break;
+                        case 'cost':
+                            setCost(ev);
+                            break;
+                        case 'end':
+                            setEndedAt(Date.now());
+                            setStatus(ev.status);
+                            if (ev.error)
+                                setError(ev.error);
+                            append({ kind: 'info', text: `◼ ${ev.status} exit=${ev.exitCode} (${formatDuration(ev.durationMs)})` });
+                            break;
+                    }
+                }
+            }
+            catch (err) {
+                setStatus('failed');
+                setEndedAt(Date.now());
+                setError(err.message);
+            }
+        })();
+        return () => {
+            ac.abort();
+        };
+    }, [engine, routineId, target?.repo, target?.repoPath]);
+    useRegisterHandler((input, key) => {
+        if (status === 'running' || status === 'starting') {
+            if (input === 'a') {
+                abortRef.current?.abort();
+                return true;
+            }
+            return false;
+        }
+        if (key.escape || key.return || input === 'q') {
+            onClose();
+            return true;
+        }
+        return false;
+    });
+    const running = status === 'starting' || status === 'running';
+    const statusColor = (() => {
+        switch (status) {
+            case 'ok': return 'green';
+            case 'failed': return 'red';
+            case 'timeout': return 'yellow';
+            case 'aborted': return 'gray';
+            case 'running': return 'cyan';
+            case 'starting': return 'cyan';
+            default: return 'gray';
+        }
+    })();
+    const elapsed = startedAt
+        ? (endedAt ?? Date.now()) - startedAt
+        : 0;
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: statusColor, paddingX: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, color: statusColor, children: running ? _jsxs(_Fragment, { children: [_jsx(Spinner, { type: "dots" }), " ", status] }) : _jsxs(_Fragment, { children: ["\u25FC ", status] }) }), _jsx(Text, { color: "gray", children: routineId }), target?.repo && _jsxs(Text, { color: "yellow", children: ["\u00B7 ", target.repo] }), _jsxs(Text, { color: "gray", children: ["\u00B7 ", formatDuration(elapsed)] }), cost && _jsxs(Text, { color: "magenta", children: ["\u00B7 ", formatUsd(cost.usd)] })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [feed.slice(-18).map((line, i) => {
+                        const color = line.kind === 'stderr' ? 'red'
+                            : line.kind === 'tool-call' ? 'magenta'
+                                : line.kind === 'info' ? 'cyan'
+                                    : undefined;
+                        const prefix = line.kind === 'tool-call' ? '↳ '
+                            : line.kind === 'stderr' ? '✖ '
+                                : line.kind === 'info' ? '' : '  ';
+                        return (_jsxs(Text, { color: color, children: [prefix, truncate(line.text, 160)] }, i));
+                    }), feed.length === 0 && running && _jsx(Text, { color: "gray", children: "  (no output yet)" })] }), error && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "red", children: ["\u2716 ", error] }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: running
+                        ? 'a abort · q cancel and close'
+                        : 'Enter / Esc / q close' }) })] }));
+}

package/dist/tui/routines/components/RoutineForm.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { type Routine } from '../../../core/routines/schema.js';
+export interface RoutineFormProps {
+    initial?: Routine;
+    onSubmit(r: Routine): void;
+    onCancel(): void;
+}
+export declare function RoutineForm({ initial, onSubmit, onCancel }: RoutineFormProps): React.JSX.Element;

package/dist/tui/routines/components/RoutineForm.js

@@ -0,0 +1,254 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text } from 'ink';
+import { useRegisterHandler } from '@matthesketh/ink-input-dispatcher';
+import TextInput from 'ink-text-input';
+import { RoutineSchema } from '../../../core/routines/schema.js';
+function toDraft(r) {
+    if (!r) {
+        return {
+            id: '',
+            name: '',
+            description: '',
+            scheduleKind: 'calendar',
+            onCalendar: '*-*-* 02:00:00',
+            taskKind: 'claude-cli',
+            prompt: '',
+            argv: '',
+            tool: '',
+            tokenCap: '100000',
+            maxUsd: '2',
+            enabled: false,
+        };
+    }
+    return {
+        id: r.id,
+        name: r.name,
+        description: r.description,
+        scheduleKind: r.schedule.kind === 'calendar' ? 'calendar' : 'manual',
+        onCalendar: r.schedule.kind === 'calendar' ? r.schedule.onCalendar : '*-*-* 02:00:00',
+        taskKind: r.task.kind,
+        prompt: r.task.kind === 'claude-cli' ? r.task.prompt : '',
+        argv: r.task.kind === 'shell' ? r.task.argv.join(' ') : '',
+        tool: r.task.kind === 'mcp-call' ? r.task.tool : '',
+        tokenCap: r.task.kind === 'claude-cli' ? String(r.task.tokenCap) : '100000',
+        maxUsd: r.task.kind === 'claude-cli' ? String(r.task.maxUsd) : '2',
+        enabled: r.enabled,
+    };
+}
+function buildRoutine(draft) {
+    const errors = [];
+    const trimmed = {
+        id: draft.id.trim(),
+        name: draft.name.trim() || draft.id.trim(),
+        description: draft.description.trim(),
+        onCalendar: draft.onCalendar.trim(),
+        prompt: draft.prompt.trim(),
+        argv: draft.argv.trim(),
+        tool: draft.tool.trim(),
+        tokenCap: parseInt(draft.tokenCap, 10),
+        maxUsd: parseFloat(draft.maxUsd),
+    };
+    if (!trimmed.id)
+        errors.push('id is required');
+    if (draft.scheduleKind === 'calendar' && !trimmed.onCalendar)
+        errors.push('OnCalendar is required for calendar schedule');
+    let task;
+    if (draft.taskKind === 'claude-cli') {
+        if (!trimmed.prompt)
+            errors.push('prompt is required for claude-cli task');
+        if (!Number.isFinite(trimmed.tokenCap) || trimmed.tokenCap <= 0)
+            errors.push('tokenCap must be a positive integer');
+        if (!Number.isFinite(trimmed.maxUsd) || trimmed.maxUsd <= 0)
+            errors.push('maxUsd must be positive');
+        task = {
+            kind: 'claude-cli',
+            prompt: trimmed.prompt,
+            outputFormat: 'json',
+            tokenCap: trimmed.tokenCap,
+            maxUsd: trimmed.maxUsd,
+            wallClockMs: 15 * 60 * 1000,
+        };
+    }
+    else if (draft.taskKind === 'shell') {
+        const argv = trimmed.argv.length > 0 ? trimmed.argv.split(/\s+/) : [];
+        if (argv.length === 0)
+            errors.push('argv is required for shell task');
+        task = { kind: 'shell', argv, wallClockMs: 15 * 60 * 1000 };
+    }
+    else {
+        if (!trimmed.tool)
+            errors.push('tool is required for mcp-call task');
+        task = { kind: 'mcp-call', tool: trimmed.tool, args: {}, wallClockMs: 60_000 };
+    }
+    if (errors.length > 0)
+        return { ok: false, errors };
+    const candidate = {
+        id: trimmed.id,
+        name: trimmed.name || trimmed.id,
+        description: trimmed.description,
+        schedule: draft.scheduleKind === 'manual'
+            ? { kind: 'manual' }
+            : { kind: 'calendar', onCalendar: trimmed.onCalendar, randomizedDelaySec: 300, persistent: true },
+        enabled: draft.enabled,
+        targets: [],
+        perTarget: false,
+        task,
+        notify: [],
+        tags: [],
+    };
+    const parsed = RoutineSchema.safeParse(candidate);
+    if (!parsed.success) {
+        return { ok: false, errors: parsed.error.issues.map(i => `${i.path.join('.')}: ${i.message}`) };
+    }
+    return { ok: true, routine: parsed.data };
+}
+const FIELD_ORDER_ALL = [
+    'id', 'name', 'description',
+    'scheduleKind', 'onCalendar',
+    'taskKind', 'prompt', 'argv', 'tool', 'tokenCap', 'maxUsd',
+    'enabled',
+];
+function visibleFields(draft) {
+    return FIELD_ORDER_ALL.filter(f => {
+        if (f === 'onCalendar' && draft.scheduleKind !== 'calendar')
+            return false;
+        if (f === 'prompt' && draft.taskKind !== 'claude-cli')
+            return false;
+        if (f === 'tokenCap' && draft.taskKind !== 'claude-cli')
+            return false;
+        if (f === 'maxUsd' && draft.taskKind !== 'claude-cli')
+            return false;
+        if (f === 'argv' && draft.taskKind !== 'shell')
+            return false;
+        if (f === 'tool' && draft.taskKind !== 'mcp-call')
+            return false;
+        return true;
+    });
+}
+const FIELD_LABEL = {
+    id: 'id',
+    name: 'name',
+    description: 'description',
+    scheduleKind: 'schedule',
+    onCalendar: 'OnCalendar',
+    taskKind: 'task kind',
+    prompt: 'prompt',
+    argv: 'argv',
+    tool: 'MCP tool',
+    tokenCap: 'token cap',
+    maxUsd: 'max USD',
+    enabled: 'enabled',
+};
+export function RoutineForm({ initial, onSubmit, onCancel }) {
+    const [draft, setDraft] = useState(() => toDraft(initial));
+    const [cursor, setCursor] = useState(0);
+    const [textValue, setTextValue] = useState(() => {
+        const fields = visibleFields(draft);
+        return draft[fields[0]];
+    });
+    const [errors, setErrors] = useState([]);
+    const [editing, setEditing] = useState(true);
+    const fields = visibleFields(draft);
+    const currentField = fields[cursor];
+    const isDisabledId = !!initial;
+    useRegisterHandler((input, key) => {
+        if (editing && (currentField === 'scheduleKind' || currentField === 'taskKind' || currentField === 'enabled')) {
+            return false;
+        }
+        if (key.escape) {
+            onCancel();
+            return true;
+        }
+        if (!editing) {
+            if (key.return) {
+                const result = buildRoutine(draft);
+                if (!result.ok) {
+                    setErrors(result.errors);
+                    return true;
+                }
+                onSubmit(result.routine);
+                return true;
+            }
+            if (input === 'e') {
+                setEditing(true);
+                return true;
+            }
+            if (input === 'j' || key.downArrow) {
+                const next = Math.min(cursor + 1, fields.length - 1);
+                setCursor(next);
+                const nextField = fields[next];
+                if (nextField !== 'scheduleKind' && nextField !== 'taskKind' && nextField !== 'enabled') {
+                    setTextValue(String(draft[nextField] ?? ''));
+                }
+                return true;
+            }
+            if (input === 'k' || key.upArrow) {
+                const next = Math.max(cursor - 1, 0);
+                setCursor(next);
+                const nextField = fields[next];
+                if (nextField !== 'scheduleKind' && nextField !== 'taskKind' && nextField !== 'enabled') {
+                    setTextValue(String(draft[nextField] ?? ''));
+                }
+                return true;
+            }
+            return false;
+        }
+        if (currentField === 'scheduleKind') {
+            if (input === ' ' || key.return) {
+                setDraft(d => ({ ...d, scheduleKind: d.scheduleKind === 'manual' ? 'calendar' : 'manual' }));
+                return true;
+            }
+        }
+        if (currentField === 'taskKind') {
+            if (input === ' ' || key.return) {
+                setDraft(d => {
+                    const next = {
+                        'claude-cli': 'shell',
+                        'shell': 'mcp-call',
+                        'mcp-call': 'claude-cli',
+                    };
+                    return { ...d, taskKind: next[d.taskKind] };
+                });
+                return true;
+            }
+        }
+        if (currentField === 'enabled') {
+            if (input === ' ' || key.return) {
+                setDraft(d => ({ ...d, enabled: !d.enabled }));
+                return true;
+            }
+        }
+        return false;
+    });
+    const renderField = (f, selected) => {
+        const marker = selected ? '▶' : ' ';
+        const label = FIELD_LABEL[f];
+        const editable = editing && selected && f !== 'scheduleKind' && f !== 'taskKind' && f !== 'enabled';
+        const d = draft;
+        const valueNode = (() => {
+            if (editable && typeof d[f] === 'string') {
+                return (_jsx(TextInput, { value: textValue, onChange: setTextValue, onSubmit: () => {
+                        setDraft(prev => ({ ...prev, [f]: textValue }));
+                        setEditing(false);
+                    } }));
+            }
+            if (f === 'enabled')
+                return _jsx(Text, { color: draft.enabled ? 'green' : 'gray', children: draft.enabled ? 'yes' : 'no' });
+            if (f === 'scheduleKind')
+                return _jsx(Text, { color: "cyan", children: draft.scheduleKind });
+            if (f === 'taskKind')
+                return _jsx(Text, { color: "cyan", children: draft.taskKind });
+            if (f === 'id' && isDisabledId)
+                return _jsxs(Text, { color: "gray", children: [String(d[f]), " (locked)"] });
+            return _jsx(Text, { children: String(d[f]) });
+        })();
+        return (_jsxs(Box, { children: [_jsx(Box, { width: 2, children: _jsx(Text, { color: selected ? 'cyan' : undefined, children: marker }) }), _jsx(Box, { width: 16, children: _jsx(Text, { color: selected ? 'cyan' : 'gray', children: label }) }), _jsx(Box, { children: valueNode })] }, f));
+    };
+    const hint = editing && currentField !== 'scheduleKind' && currentField !== 'taskKind' && currentField !== 'enabled'
+        ? 'type to edit · Enter to confirm field · Esc cancel'
+        : editing
+            ? 'Space/Enter to toggle · Esc cancel'
+            : 'j/k move · e edit · Enter submit · Esc cancel';
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, gap: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: initial ? `edit ${initial.id}` : 'new routine' }), _jsx(Box, { flexDirection: "column", children: fields.map((f, i) => renderField(f, i === cursor)) }), errors.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", bold: true, children: "errors" }), errors.map((e, i) => _jsxs(Text, { color: "red", children: ["  \u00B7 ", e] }, i))] })), _jsx(Text, { color: "gray", children: hint })] }));
+}

package/dist/tui/routines/components/SignalsGrid.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { Signal, SignalKind } from '../../../core/routines/schema.js';
+export interface SignalsGridRow {
+    repo: string;
+    signals: Signal[];
+}
+export interface SignalsGridProps {
+    rows: SignalsGridRow[];
+    selectedIndex: number;
+    kinds: SignalKind[];
+    nameWidth?: number;
+}
+export declare function SignalsGrid({ rows, selectedIndex, kinds, nameWidth }: SignalsGridProps): React.JSX.Element;

package/dist/tui/routines/components/SignalsGrid.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { Box, Text } from 'ink';
+import { signalStateColor, signalStateGlyph, truncate } from '../format.js';
+const KIND_LABEL = {
+    'git-clean': 'GIT',
+    'git-ahead': 'AHEAD',
+    'git-behind': 'BEHIND',
+    'open-prs': 'PRS',
+    'pr-age-max': 'PR-AGE',
+    'deps-outdated': 'DEPS',
+    'deps-vulns': 'VULNS',
+    'build-ok': 'BUILD',
+    'tests-ok': 'TESTS',
+    'env-schema-ok': 'ENV',
+    'container-up': 'CTRS',
+    'ci-status': 'CI',
+    'cache-age': 'CACHE',
+};
+function Cell({ signal }) {
+    if (!signal)
+        return _jsx(Text, { color: "gray", children: "  \u00B7  " });
+    const color = signalStateColor[signal.state];
+    const glyph = signalStateGlyph[signal.state];
+    return _jsxs(Text, { color: color, children: ["  ", glyph, "  "] });
+}
+export function SignalsGrid({ rows, selectedIndex, kinds, nameWidth = 22 }) {
+    const header = useMemo(() => kinds.map(k => KIND_LABEL[k].padEnd(5).slice(0, 5)).join(''), [kinds]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Box, { width: nameWidth + 2, children: _jsx(Text, { bold: true, children: "REPO" }) }), _jsx(Text, { bold: true, children: header })] }), rows.length === 0 && (_jsx(Text, { color: "gray", children: "  no repos registered \u2014 run `fleet add`" })), rows.map((row, idx) => {
+                const byKind = new Map(row.signals.map(s => [s.kind, s]));
+                const selected = idx === selectedIndex;
+                return (_jsxs(Box, { children: [_jsx(Box, { width: nameWidth + 2, children: _jsxs(Text, { color: selected ? 'cyan' : undefined, bold: selected, children: [selected ? '▶ ' : '  ', truncate(row.repo, nameWidth)] }) }), kinds.map(kind => _jsx(Cell, { signal: byKind.get(kind) }, kind))] }, row.repo));
+            })] }));
+}

package/dist/tui/routines/components/SignalsGrid.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tui/routines/components/SignalsGrid.test.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { describe, it, expect } from 'vitest';
+import { SignalsGrid } from './SignalsGrid.js';
+const mkSignal = (kind, state, detail = '') => ({
+    repo: 'demo',
+    kind,
+    state,
+    value: state === 'ok',
+    detail,
+    collectedAt: new Date().toISOString(),
+    ttlMs: 10_000,
+});
+describe('SignalsGrid', () => {
+    it('renders header row with column labels', () => {
+        const { lastFrame } = render(_jsx(SignalsGrid, { rows: [], selectedIndex: 0, kinds: ['git-clean', 'container-up', 'ci-status'] }));
+        const frame = lastFrame();
+        expect(frame).toContain('REPO');
+        expect(frame).toContain('GIT');
+        expect(frame).toContain('CTRS');
+        expect(frame).toContain('CI');
+    });
+    it('renders a row with repo name when signals present', () => {
+        const rows = [{ repo: 'abmanandvan', signals: [mkSignal('git-clean', 'ok')] }];
+        const { lastFrame } = render(_jsx(SignalsGrid, { rows: rows, selectedIndex: 0, kinds: ['git-clean'] }));
+        expect(lastFrame()).toContain('abmanandvan');
+    });
+    it('shows empty-state message with no repos', () => {
+        const { lastFrame } = render(_jsx(SignalsGrid, { rows: [], selectedIndex: 0, kinds: ['git-clean'] }));
+        expect(lastFrame()).toContain('no repos registered');
+    });
+    it('marks the selected row with an arrow', () => {
+        const rows = [
+            { repo: 'first', signals: [] },
+            { repo: 'second', signals: [] },
+        ];
+        const { lastFrame } = render(_jsx(SignalsGrid, { rows: rows, selectedIndex: 1, kinds: ['git-clean'] }));
+        const frame = lastFrame();
+        const lines = frame.split('\n');
+        const secondLine = lines.find(l => l.includes('second'));
+        expect(secondLine).toContain('▶');
+    });
+});

package/dist/tui/routines/format.d.ts

@@ -0,0 +1,7 @@
+import type { SignalState } from '../../core/routines/schema.js';
+export declare const signalStateColor: Record<SignalState, string>;
+export declare const signalStateGlyph: Record<SignalState, string>;
+export declare function formatRelative(iso: string | null, now?: number): string;
+export declare function formatDuration(ms: number | null): string;
+export declare function formatUsd(usd: number | null): string;
+export declare function truncate(s: string, max: number): string;

package/dist/tui/routines/format.js

@@ -0,0 +1,51 @@
+export const signalStateColor = {
+    ok: 'green',
+    warn: 'yellow',
+    error: 'red',
+    unknown: 'gray',
+};
+export const signalStateGlyph = {
+    ok: '●',
+    warn: '◐',
+    error: '●',
+    unknown: '○',
+};
+export function formatRelative(iso, now = Date.now()) {
+    if (!iso)
+        return '—';
+    const ms = now - new Date(iso).getTime();
+    const abs = Math.abs(ms);
+    const suffix = ms >= 0 ? 'ago' : 'from now';
+    if (abs < 10_000)
+        return 'just now';
+    if (abs < 60_000)
+        return `${Math.round(abs / 1000)}s ${suffix}`;
+    if (abs < 3_600_000)
+        return `${Math.round(abs / 60_000)}m ${suffix}`;
+    if (abs < 86_400_000)
+        return `${Math.round(abs / 3_600_000)}h ${suffix}`;
+    return `${Math.round(abs / 86_400_000)}d ${suffix}`;
+}
+export function formatDuration(ms) {
+    if (ms == null)
+        return '—';
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60_000)}m ${Math.round((ms % 60_000) / 1000)}s`;
+}
+export function formatUsd(usd) {
+    if (usd == null)
+        return '—';
+    if (usd < 0.01)
+        return `<$0.01`;
+    if (usd < 1)
+        return `$${usd.toFixed(3)}`;
+    return `$${usd.toFixed(2)}`;
+}
+export function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return `${s.slice(0, max - 1)}…`;
+}

package/dist/tui/routines/hooks/use-git-fleet.d.ts

@@ -0,0 +1,33 @@
+import type { AppEntry } from '../../../core/registry.js';
+export interface FleetPr {
+    repo: string;
+    number: number;
+    title: string;
+    author: string;
+    updatedAt: string;
+    url: string;
+    isDraft: boolean;
+    reviewDecision: string | null;
+}
+export interface FleetBranchState {
+    repo: string;
+    branch: string;
+    ahead: number;
+    behind: number;
+    clean: boolean;
+    dirtyCount: number;
+    releasePending: number;
+}
+export interface GitFleetSnapshot {
+    loading: boolean;
+    prs: FleetPr[];
+    branchStates: FleetBranchState[];
+    refreshedAt: number;
+    errors: {
+        repo: string;
+        message: string;
+    }[];
+}
+export declare function useGitFleet(apps: AppEntry[]): GitFleetSnapshot & {
+    refresh(): void;
+};

package/dist/tui/routines/hooks/use-git-fleet.js

@@ -0,0 +1,82 @@
+import { useEffect, useState } from 'react';
+import { execSafe } from '../../../core/exec.js';
+import { getGitStatus } from '../../../core/git.js';
+function listPrsForRepo(cwd, repo) {
+    const res = execSafe('gh', [
+        'pr', 'list', '--state', 'open',
+        '--json', 'number,title,author,updatedAt,url,isDraft,reviewDecision',
+        '--limit', '20',
+    ], { cwd, timeout: 8000 });
+    if (!res.ok)
+        return [];
+    try {
+        const raw = JSON.parse(res.stdout);
+        return raw.map(p => ({
+            repo,
+            number: p.number,
+            title: p.title,
+            author: p.author?.login ?? 'unknown',
+            updatedAt: p.updatedAt,
+            url: p.url,
+            isDraft: p.isDraft,
+            reviewDecision: p.reviewDecision,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function countReleasePending(cwd) {
+    const res = execSafe('git', ['-C', cwd, 'rev-list', '--count', 'origin/main..origin/develop'], { timeout: 5000 });
+    if (!res.ok)
+        return 0;
+    return parseInt(res.stdout.trim() || '0', 10) || 0;
+}
+export function useGitFleet(apps) {
+    const [state, setState] = useState({
+        loading: false,
+        prs: [],
+        branchStates: [],
+        refreshedAt: 0,
+        errors: [],
+    });
+    const load = () => {
+        setState(s => ({ ...s, loading: true }));
+        const prs = [];
+        const branchStates = [];
+        const errors = [];
+        for (const app of apps) {
+            const cwd = app.composePath ?? '';
+            if (!cwd)
+                continue;
+            try {
+                const git = getGitStatus(cwd);
+                if (git.initialised) {
+                    branchStates.push({
+                        repo: app.name,
+                        branch: git.branch,
+                        ahead: git.ahead,
+                        behind: git.behind,
+                        clean: git.clean,
+                        dirtyCount: git.modified + git.staged + git.untracked,
+                        releasePending: countReleasePending(cwd),
+                    });
+                }
+                prs.push(...listPrsForRepo(cwd, app.name));
+            }
+            catch (err) {
+                errors.push({ repo: app.name, message: err.message });
+            }
+        }
+        prs.sort((a, b) => new Date(a.updatedAt).getTime() - new Date(b.updatedAt).getTime());
+        setState({ loading: false, prs, branchStates, refreshedAt: Date.now(), errors });
+    };
+    useEffect(() => {
+        if (apps.length === 0)
+            return;
+        load();
+        const id = setInterval(load, 60_000);
+        return () => clearInterval(id);
+    }, [apps.map(a => a.name).join('|')]);
+    return { ...state, refresh: load };
+}

package/dist/tui/routines/hooks/use-logs-stream.d.ts

@@ -0,0 +1,13 @@
+import type { LogLine } from '@matthesketh/ink-log-viewer';
+export interface LogsStreamOptions {
+    command: string;
+    args: string[];
+    bufferSize?: number;
+}
+export interface LogsStream {
+    lines: LogLine[];
+    running: boolean;
+    error: string | null;
+    restart(): void;
+}
+export declare function useLogsStream(opts: LogsStreamOptions | null): LogsStream;