@alecsibilia/luca 14.0.0-alpha.2 → 14.0.0-alpha.21

package/board/client/ticket-card-view.tsx

@@ -0,0 +1,238 @@
+/**
+ * A ticket's card in the panel: its number and title, its stage pill, the
+ * step dots, its agent's model and Clef's line, the fix and review counters, its tokens and tests, and its
+ * details when opened. With an entry in the run's live file (#628), the
+ * step text gives way to what its agent is doing now, and its tokens count
+ * up with the turn, followed by the latest action's age; a busy card's
+ * line ends in its heartbeat (#631), each running helper gets a line under
+ * it (#636), and a check waiting there for a slot (#632) reads as a wait,
+ * with the amber bar. In a run with no sign of life (#635), a busy or
+ * waiting card's step text says so, in place of any wait, its heartbeat is
+ * a flat red line, and its timers stop at the last sign of life. Each line stays on one line (`one-line.tsx`): the
+ * number, pill, dots, counters and tokens keep their size, the text beside
+ * them is cut, and a tap on it shows it whole in a bubble.
+ */
+import { Icon } from '@getpaseo/plugin/client/react-native'
+import { Pressable, Text, View } from 'react-native'
+
+import { stageColor, tokensText, useNow } from './board-look'
+import { Counter, StepLine } from './board-panel-parts'
+import type { Look } from './board-panel-styles'
+import { noLife } from './engine-life'
+import { Heartbeat } from './heartbeat'
+import { HelperLines } from './helper-lines'
+import { liveAgeText, liveText } from './live-line'
+import { ModelLine } from './model-line'
+import { BubbleScope, CutLine, useBubbles } from './one-line'
+import { StepDots } from './step-dots'
+import { TicketDetail } from './ticket-detail'
+import { slotWait, ticketWait } from './ticket-wait'
+import { WaitLine } from './wait-line'
+
+import {
+    planUsedText,
+    type BoardState,
+    type TicketCard,
+    type TicketStage,
+} from '../shared/board-state'
+
+/** The stages whose card has no heartbeat (#631), live entry or not. */
+const QUIET: ReadonlySet<TicketStage> = new Set([
+    'done',
+    'skipped',
+    'stuck',
+    'blocked',
+])
+
+export const TicketCardView = ({
+    ticket,
+    state,
+    open,
+    onToggle,
+    theme,
+    styles,
+}: {
+    ticket: TicketCard
+    state: BoardState
+    open: boolean
+    onToggle: () => void
+} & Look) => {
+    const bubbles = useBubbles()
+    const now = useNow()
+    const held = ticketWait({ state, ticket }) ?? slotWait({ ticket })
+    // A busy or waiting card of a run with no sign of life says so, and
+    // its timers stop.
+    const busy =
+        !QUIET.has(ticket.stage) &&
+        (ticket.live !== null || ticket.current_step !== null || held !== null)
+    const lifeless = busy ? noLife({ state, now }) : null
+    const clock = lifeless?.at ?? now
+    // A ticket waiting on purpose between steps, or its check waiting for
+    // a slot (#632), reads "waiting", in amber, while the run is alive.
+    const wait = lifeless ? null : held
+    // What its agent is doing now, from the live file, in place of the step text.
+    const doing = liveText({ live: ticket.live, now: clock })
+    const color = wait
+        ? theme.colors.statusWarning
+        : stageColor({ stage: ticket.stage, theme })
+    const failing =
+        ticket.tests &&
+        ticket.tests.failing > 0 &&
+        ticket.stage !== 'done' &&
+        ticket.stage !== 'skipped'
+            ? ticket.tests
+            : null
+    const blockers =
+        ticket.findings && ticket.stage !== 'done' ? ticket.findings.blocker : 0
+    return (
+        <Pressable
+            accessibilityRole="button"
+            accessibilityLabel={`Ticket ${ticket.number}, ${ticket.stage}. ${open ? 'Hide' : 'Show'} details`}
+            onPress={() => {
+                // A tap beside an open bubble only closes it.
+                if (bubbles.open) bubbles.show(null)
+                else onToggle()
+            }}
+            style={({ pressed }) => [
+                styles.card,
+                pressed ? styles.cardPressed : null,
+            ]}
+        >
+            <BubbleScope bubbles={bubbles} styles={styles}>
+                <View style={styles.cardTop}>
+                    <Text style={styles.number} numberOfLines={1}>
+                        #{ticket.number}
+                    </Text>
+                    <CutLine
+                        text={ticket.title}
+                        style={styles.cardTitle}
+                        styles={styles}
+                    />
+                    {ticket.refactor ? (
+                        <Text style={styles.tag} numberOfLines={1}>
+                            refactor
+                        </Text>
+                    ) : null}
+                    <View style={styles.spacer} />
+                    <Text
+                        style={[styles.pill, { color, borderColor: color }]}
+                        numberOfLines={1}
+                    >
+                        {wait ? 'waiting' : ticket.activity}
+                    </Text>
+                    <Icon
+                        name={open ? 'ChevronDown' : 'ChevronRight'}
+                        size={14}
+                        color={theme.colors.foregroundMuted}
+                    />
+                </View>
+                <View style={styles.line}>
+                    <StepDots ticket={ticket} theme={theme} styles={styles} />
+                    {lifeless ? (
+                        <CutLine
+                            text={lifeless.text}
+                            style={[
+                                styles.text,
+                                { color: theme.colors.statusDanger },
+                            ]}
+                            styles={styles}
+                        />
+                    ) : wait ? (
+                        <WaitLine wait={wait} theme={theme} styles={styles} />
+                    ) : doing || ticket.role ? (
+                        <CutLine
+                            text={doing ?? ticket.role ?? ''}
+                            style={styles.text}
+                            styles={styles}
+                        />
+                    ) : null}
+                    {lifeless ||
+                    (!wait &&
+                        ticket.live !== null &&
+                        !QUIET.has(ticket.stage)) ? (
+                        <>
+                            <View style={styles.spacer} />
+                            <Heartbeat
+                                live={ticket.live}
+                                gone={lifeless !== null}
+                                theme={theme}
+                                styles={styles}
+                            />
+                        </>
+                    ) : null}
+                </View>
+                <HelperLines
+                    live={ticket.live}
+                    now={clock}
+                    theme={theme}
+                    styles={styles}
+                />
+                {ticket.current_step && doing === null && wait === null ? (
+                    <StepLine
+                        step={ticket.current_step}
+                        prefix=""
+                        at={lifeless?.at ?? null}
+                        styles={styles}
+                    />
+                ) : null}
+                {ticket.model !== null && ticket.model.role === ticket.role ? (
+                    <ModelLine
+                        model={ticket.model}
+                        bar={state.confidence_bar}
+                        theme={theme}
+                        styles={styles}
+                    />
+                ) : null}
+                <View style={styles.line}>
+                    <Counter
+                        label="fix"
+                        value={ticket.fix_round}
+                        theme={theme}
+                        styles={styles}
+                    />
+                    <Counter
+                        label="review"
+                        value={ticket.review_round}
+                        theme={theme}
+                        styles={styles}
+                    />
+                    <Text style={[styles.mono, styles.fixed]} numberOfLines={1}>
+                        {`${tokensText({
+                            tokens: ticket.tokens + (ticket.live?.tokens ?? 0),
+                        })} tokens${liveAgeText({ live: ticket.live, now: clock })}`}
+                    </Text>
+                    {ticket.plan_used.length > 0 ? (
+                        <CutLine
+                            text={`plan: ${planUsedText({ used: ticket.plan_used, sign: '+' })}`}
+                            style={styles.mono}
+                            styles={styles}
+                        />
+                    ) : null}
+                    {failing ? (
+                        <CutLine
+                            text={`${failing.failing} of ${failing.total} tests failing`}
+                            style={[
+                                styles.muted,
+                                { color: theme.colors.statusDanger },
+                            ]}
+                            styles={styles}
+                        />
+                    ) : null}
+                    {blockers > 0 ? (
+                        <CutLine
+                            text={`${blockers} blocker from the ticket review`}
+                            style={[
+                                styles.muted,
+                                { color: theme.colors.statusWarning },
+                            ]}
+                            styles={styles}
+                        />
+                    ) : null}
+                </View>
+            </BubbleScope>
+            {open ? (
+                <TicketDetail ticket={ticket} state={state} styles={styles} />
+            ) : null}
+        </Pressable>
+    )
+}

package/board/client/ticket-detail.tsx

@@ -0,0 +1,87 @@
+/**
+ * What a ticket card shows when it is open: its steps, what it waits on, its
+ * last tests, findings, review fix rounds, tokens, and what was tried.
+ */
+import { Text, View } from 'react-native'
+
+import { tokensText } from './board-look'
+import type { Styles } from './board-panel-styles'
+import { dotKinds } from './step-dots'
+
+import {
+    LOOP_CAP,
+    STEP_NAMES,
+    type BoardState,
+    type TicketCard,
+} from '../shared/board-state'
+
+export const TicketDetail = ({
+    ticket,
+    state,
+    styles,
+}: {
+    ticket: TicketCard
+    state: BoardState
+    styles: Styles
+}) => {
+    const kinds = dotKinds({ ticket })
+    const waits = ticket.blockers.map((number) => {
+        const blocker = state.tickets.find((card) => card.number === number)
+        return `#${number} ${blocker ? blocker.stage : 'closed'}`
+    })
+    return (
+        <View style={styles.detail}>
+            <Text style={styles.muted}>
+                steps:{' '}
+                {STEP_NAMES.map(
+                    (name, index) =>
+                        `${name} ${kinds[index] === 'skip' ? '(not needed)' : (kinds[index] ?? '')}`
+                ).join(' → ')}
+            </Text>
+            <Text style={styles.muted}>
+                waits on: {waits.length > 0 ? waits.join(', ') : 'nothing'}
+            </Text>
+            {ticket.tests ? (
+                <Text style={styles.muted}>
+                    last tests:{' '}
+                    {ticket.tests.failing > 0
+                        ? `${ticket.tests.failing} of ${ticket.tests.total} failing`
+                        : `${ticket.tests.total} passing`}
+                </Text>
+            ) : null}
+            {ticket.findings ? (
+                <Text style={styles.muted}>
+                    findings: {ticket.findings.blocker} blocker ·{' '}
+                    {ticket.findings.should_fix} should-fix ·{' '}
+                    {ticket.findings.nit} nit
+                </Text>
+            ) : null}
+            {ticket.review_fix_round > 0 ? (
+                <Text style={styles.muted}>
+                    review fix rounds: {ticket.review_fix_round}/{LOOP_CAP}
+                </Text>
+            ) : null}
+            {Object.keys(ticket.agent_tokens).length > 0 ? (
+                <Text style={styles.muted}>
+                    tokens:{' '}
+                    {Object.entries(ticket.agent_tokens)
+                        .map(
+                            ([role, tokens]) =>
+                                `${role} ${tokensText({ tokens })}`
+                        )
+                        .join(' · ')}
+                </Text>
+            ) : null}
+            {ticket.tried.length > 0 ? (
+                <>
+                    <Text style={styles.label}>Tried</Text>
+                    {ticket.tried.map((line, index) => (
+                        <Text key={`${index}-${line}`} style={styles.muted}>
+                            {index + 1}. {line}
+                        </Text>
+                    ))}
+                </>
+            ) : null}
+        </View>
+    )
+}

package/board/client/ticket-stack.tsx

@@ -0,0 +1,119 @@
+/**
+ * The tickets as a stack of stages (Blocked, Building, Reviewing, Testing,
+ * Fixing, Joining, Done, Skipped), each a fold of ticket cards, then the
+ * tickets left out for a person.
+ */
+import type { Dispatch, SetStateAction } from 'react'
+
+import { Text, View } from 'react-native'
+
+import { stageColor } from './board-look'
+import { Section, StageHeader } from './board-panel-parts'
+import {
+    FOR_A_PERSON,
+    TICKET_STAGES,
+    toggled,
+    type Key,
+} from './board-panel-stages'
+import type { Look } from './board-panel-styles'
+import { TicketCardView } from './ticket-card-view'
+
+import type { BoardState, TicketCard } from '../shared/board-state'
+
+export const TicketStack = ({
+    state,
+    folded,
+    setFolded,
+    openCards,
+    setOpenCards,
+    theme,
+    styles,
+}: {
+    state: BoardState
+    folded: ReadonlySet<Key>
+    setFolded: Dispatch<SetStateAction<ReadonlySet<Key>>>
+    openCards: ReadonlySet<Key>
+    setOpenCards: Dispatch<SetStateAction<ReadonlySet<Key>>>
+} & Look) => {
+    const look = { theme, styles }
+    const card = (ticket: TicketCard) => {
+        const key = `ticket-${ticket.number}`
+        return (
+            <TicketCardView
+                key={key}
+                ticket={ticket}
+                state={state}
+                open={openCards.has(key)}
+                onToggle={() => setOpenCards((set) => toggled({ set, key }))}
+                {...look}
+            />
+        )
+    }
+
+    return (
+        <>
+            {TICKET_STAGES.map((entry) => {
+                const tickets = state.tickets.filter(
+                    (ticket) => ticket.stage === entry.stage
+                )
+                const isFolded = folded.has(entry.stage)
+                return (
+                    <Section key={entry.stage} styles={styles}>
+                        <StageHeader
+                            title={entry.title}
+                            hint={entry.hint}
+                            icon={entry.icon}
+                            count={tickets.length}
+                            color={stageColor({ stage: entry.stage, theme })}
+                            folded={isFolded}
+                            onPress={() =>
+                                setFolded((set) =>
+                                    toggled({ set, key: entry.stage })
+                                )
+                            }
+                            {...look}
+                        />
+                        {tickets.length > 0 && !isFolded ? (
+                            <View style={styles.stageBody}>
+                                {tickets.map(card)}
+                            </View>
+                        ) : null}
+                    </Section>
+                )
+            })}
+
+            {state.for_a_person.length > 0 ? (
+                <Section styles={styles}>
+                    <StageHeader
+                        title="For a person"
+                        hint="left out of this run: a person does these, or they wait on one"
+                        icon="User"
+                        count={state.for_a_person.length}
+                        color={theme.colors.foregroundMuted}
+                        folded={folded.has(FOR_A_PERSON)}
+                        onPress={() =>
+                            setFolded((set) =>
+                                toggled({ set, key: FOR_A_PERSON })
+                            )
+                        }
+                        {...look}
+                    />
+                    {folded.has(FOR_A_PERSON) ? null : (
+                        <View style={styles.stageBody}>
+                            {state.for_a_person.map((ticket) => (
+                                <Text
+                                    key={ticket.number}
+                                    style={styles.muted}
+                                    numberOfLines={2}
+                                >
+                                    #{ticket.number} {ticket.title} ·{' '}
+                                    {ticket.why}
+                                </Text>
+                            ))}
+                        </View>
+                    )}
+                </Section>
+            ) : null}
+        </>
+    )
+}

package/board/client/ticket-wait.ts

@@ -0,0 +1,188 @@
+/**
+ * What a waiting card waits for (#558, #559): a ticket the engine holds on
+ * purpose between steps. The engine's `ticket_waiting` names the reason; an
+ * old journal without it gets the same reasons from the board's own rules,
+ * or "waiting for the engine's next step" when none fits, never a guess.
+ * A check waiting for a slot inside its step (#632) comes from the live file.
+ */
+import {
+    BASELINE_STEP_TEXT,
+    type BoardState,
+    type TicketCard,
+    type TicketStage,
+    type WaitFor,
+} from '../shared/board-state'
+
+/** A wait as the card shows it: its text, and since when (if known). */
+export type ShownWait = { text: string; since: string | null }
+
+/** The cards that never wait: done, stuck, skipped, or blocked. */
+const NEVER_WAITS = new Set<TicketStage>([
+    'done',
+    'stuck',
+    'skipped',
+    'blocked',
+])
+
+/** What no rule explains. */
+export const ENGINE_NEXT_STEP = "waiting for the engine's next step"
+
+/**
+ * A wait's reason in words.
+ *
+ * @example
+ * waitText({ waiting_for: 'join', on_ticket: 331 }) // 'waiting to join after #331'
+ */
+export const waitText = ({
+    waiting_for,
+    on_ticket,
+}: {
+    waiting_for: WaitFor
+    on_ticket: number | null
+}): string => {
+    const other = on_ticket === null ? null : `#${on_ticket}`
+    switch (waiting_for) {
+        case 'baseline':
+            return other === null
+                ? 'waiting for the shared baseline tests'
+                : `waiting for ${other}'s baseline tests`
+        case 'join':
+            return other === null
+                ? 'waiting to join'
+                : `waiting to join after ${other}`
+        case 'start':
+            return other === null
+                ? 'waiting to start'
+                : `starts once ${other} has joined`
+    }
+}
+
+/**
+ * What a ticket's check waits for inside its step (#632), from the live
+ * file, or `null` when it waits for no slot.
+ *
+ * @example
+ * slotWait({ ticket }) // { text: 'waiting for a test slot (2 of 2 in use)', since: '2026-...' }
+ */
+export const slotWait = ({
+    ticket,
+}: {
+    ticket: TicketCard
+}): ShownWait | null => {
+    const wait = ticket.slot_wait
+    if (wait === null) return null
+    const slot = wait.for === 'prepare_slot' ? 'a prepare slot' : 'a test slot'
+    return {
+        text: `waiting for ${slot} (${wait.in_use} of ${wait.slots} in use)`,
+        since: wait.since,
+    }
+}
+
+/** An approved ticket in the join queue, not yet joining. */
+const approvedWaiting = (card: TicketCard): boolean =>
+    card.stage === 'joining' &&
+    card.activity === 'approved' &&
+    card.current_step === null
+
+/** The ticket joining the run branch now, other than `number`. */
+const joinerBesides = ({
+    state,
+    number,
+}: {
+    state: BoardState
+    number: number
+}): number | null =>
+    state.tickets.find(
+        (card) =>
+            card.number !== number &&
+            card.stage === 'joining' &&
+            !approvedWaiting(card)
+    )?.number ?? null
+
+/** The ticket running the baseline tests now, other than `number`. */
+const baselineRunner = ({
+    state,
+    number,
+}: {
+    state: BoardState
+    number: number
+}): number | null =>
+    state.tickets.find(
+        (card) =>
+            card.number !== number &&
+            card.current_step?.text === BASELINE_STEP_TEXT
+    )?.number ?? null
+
+/** #558's rules, for a started ticket between steps of an old journal. */
+const guessedReason = ({
+    state,
+    ticket,
+}: {
+    state: BoardState
+    ticket: TicketCard
+}): string => {
+    const { number } = ticket
+    if (ticket.stage === 'building' && ticket.baseline_tests === null) {
+        const runner = baselineRunner({ state, number })
+        if (runner !== null) {
+            return waitText({ waiting_for: 'baseline', on_ticket: runner })
+        }
+    }
+    if (approvedWaiting(ticket)) {
+        const joiner = joinerBesides({ state, number })
+        if (joiner !== null) {
+            return waitText({ waiting_for: 'join', on_ticket: joiner })
+        }
+    }
+    return ENGINE_NEXT_STEP
+}
+
+/**
+ * What `ticket` waits for between steps, or `null` when it isn't waiting:
+ * it is in a step, it never waits (done, stuck, skipped, blocked), or the
+ * engine isn't running the run. A ticket not started yet waits only to
+ * start, behind a ticket in the join queue.
+ *
+ * @example
+ * ticketWait({ state, ticket })
+ * // { text: "waiting for #553's baseline tests", since: '2026-...' }
+ */
+export const ticketWait = ({
+    state,
+    ticket,
+}: {
+    state: BoardState
+    ticket: TicketCard
+}): ShownWait | null => {
+    if (NEVER_WAITS.has(ticket.stage) || ticket.current_step !== null) {
+        return null
+    }
+    if (state.run.engine_ended !== null || state.run.stopped !== null) {
+        return null
+    }
+    const { wait } = ticket
+    if (wait?.for) {
+        return {
+            text: waitText({
+                waiting_for: wait.for,
+                on_ticket: wait.on_ticket,
+            }),
+            since: wait.since,
+        }
+    }
+    if (!ticket.started) {
+        const ahead =
+            joinerBesides({ state, number: ticket.number }) ??
+            state.tickets.find(approvedWaiting)?.number ??
+            null
+        return ahead === null
+            ? null
+            : {
+                  text: waitText({ waiting_for: 'start', on_ticket: ahead }),
+                  since: null,
+              }
+    }
+    // A journal with no step records never says the ticket is between steps.
+    if (wait === null) return null
+    return { text: guessedReason({ state, ticket }), since: wait.since }
+}