jackherd 1.18.1 → 1.19.0

package/src/plans/folded-detail.ts

@@ -0,0 +1,47 @@
+import { fit, paint, visibleLength } from '../terminal/text'
+
+/**
+ * The words of a folded lane line behind its name; an empty one is left out. `phaseCount` is `P2/5`, `phaseMore` the
+ * other running phases (`+1 phase`), which stands whole behind the phase name or not at all.
+ */
+export type FoldedDetailParts = {
+  lead: string
+  plan: string
+  phaseCount: string
+  phaseName: string
+  phaseMore: string
+  reason: string
+}
+
+const SEPARATOR = ' · '
+const PHASE_GAP = ' '
+const MIN_PLAN_WIDTH = 8
+const MIN_NAME_WIDTH = 8
+
+const joined = ({ lead, plan, phaseCount, phaseName, phaseMore, reason }: FoldedDetailParts): string => {
+  const phase = [phaseCount, phaseName, phaseName && phaseMore].filter(Boolean).join(PHASE_GAP)
+  const rest = [plan, phase, reason].filter(Boolean).join(paint.dim(SEPARATOR))
+  return [lead, rest].filter(Boolean).join(' ')
+}
+
+/** The part cut to `room` cells, or dropped when `room` is under `minimum`. */
+const cutTo = (part: string, room: number, minimum: number): string => (room >= minimum ? fit(part, room) : '')
+
+/**
+ * `Plan · P2/5 Phase name · reason` within `room` cells. A pane too narrow gives up the plan title first (cut to what
+ * is left, dropped under 8 cells), then the phase name (cut to what is left, dropped under 8 cells); the phase count
+ * and the reason stay whole, and only a reason wider than the pane itself is cut.
+ */
+export const foldedDetail = (parts: FoldedDetailParts, room: number): string => {
+  const fits = (candidate: FoldedDetailParts) => visibleLength(joined(candidate)) <= room
+  if (fits(parts)) return joined(parts)
+  const withoutPlan = { ...parts, plan: '' }
+  const planRoom = room - visibleLength(joined(withoutPlan)) - SEPARATOR.length
+  const cutPlan = { ...parts, plan: cutTo(parts.plan, planRoom, MIN_PLAN_WIDTH) }
+  if (cutPlan.plan && fits(cutPlan)) return joined(cutPlan)
+  if (fits(withoutPlan)) return joined(withoutPlan)
+  const moreWidth = parts.phaseMore ? PHASE_GAP.length + visibleLength(parts.phaseMore) : 0
+  const nameRoom = room - visibleLength(joined({ ...withoutPlan, phaseName: '' })) - PHASE_GAP.length - moreWidth
+  const cutName = { ...withoutPlan, phaseName: cutTo(parts.phaseName, nameRoom, MIN_NAME_WIDTH) }
+  return fit(joined(cutName), room)
+}

package/src/plans/lane-line.ts

@@ -0,0 +1,86 @@
+import { TONE_ROLE } from '../config/tones'
+import { ellipsize } from '../plan-format/terminal-text'
+import { badge, paint } from '../terminal/text'
+import { AGENT_STATUS, isRestingAgent } from '../terminal/types'
+import { LANE_REASON, type LaneReason } from './lane-reason'
+import { TEXTS } from './texts'
+import { paintOfRole } from './tones'
+
+/** What a folded lane line says first: the lane needs the user, is blocked on something, or runs. */
+export const LANE_STATE = { needsYou: 'needs-you', blocked: 'blocked', running: 'running' } as const
+export type LaneState = (typeof LANE_STATE)[keyof typeof LANE_STATE]
+
+/** A lane as its line needs it: the agent's status, why a resting lane rests, the age of its last activity and its step. */
+export type LaneLineInput = {
+  agent: string | null
+  reason: LaneReason | null
+  minutesAgo: number | null
+  step: string
+  /** The most cells the text behind the status may take; under `MIN_TEXT_WIDTH` the lead is the status alone. */
+  maxText?: number
+}
+
+const LIST_MARKER = /^·\s*/
+
+/**
+ * The state of a lane: a blocked agent or a resting lane with an open question needs you; a resting lane that waits
+ * on a row of "Your turn" or on its starts-after cell is blocked; a working lane runs. Null for the rest (a resting
+ * lane without a known reason, a lane without an agent), which the line leaves to its older words.
+ */
+export const laneStateOf = (agent: string | null, reason: LaneReason | null): LaneState | null => {
+  if (agent === AGENT_STATUS.blocked) return LANE_STATE.needsYou
+  if (agent === AGENT_STATUS.working) return LANE_STATE.running
+  if (!isRestingAgent(agent) || !reason) return null
+  if (reason.kind === LANE_REASON.you) return LANE_STATE.needsYou
+  return reason.kind === LANE_REASON.none ? null : LANE_STATE.blocked
+}
+
+const STATE_WORD: Record<LaneState, () => string> = {
+  [LANE_STATE.needsYou]: () => TEXTS.laneNeedsYou,
+  [LANE_STATE.blocked]: () => TEXTS.laneBlocked,
+  [LANE_STATE.running]: () => TEXTS.laneRunning,
+}
+
+const STATE_PAINT: Record<LaneState, (text: string) => string> = {
+  [LANE_STATE.needsYou]: (text) => paint.bold(paintOfRole(TONE_ROLE.waiting)(text)),
+  [LANE_STATE.blocked]: paintOfRole(TONE_ROLE.waiting),
+  [LANE_STATE.running]: paintOfRole(TONE_ROLE.running),
+}
+
+/** The most of a question, wait reason or step the lead names, so the phase count behind it stays in view. */
+const TEXT_WIDTH = 44
+
+const MIN_TEXT_WIDTH = 8
+
+const rawText = (state: LaneState, { reason, step }: LaneLineInput): string => {
+  if (state === LANE_STATE.running) return step
+  if (!reason) return ''
+  return state === LANE_STATE.needsYou
+    ? reason.text.replace(LIST_MARKER, '')
+    : [reason.label, reason.text].filter(Boolean).join(' ')
+}
+
+/** The question to the user is never cut for room; a wait reason or a step gives way to the phase count behind it. */
+const stateText = (state: LaneState, input: LaneLineInput): string => {
+  if (state === LANE_STATE.needsYou) return rawText(state, input)
+  const width = Math.min(TEXT_WIDTH, input.maxText ?? TEXT_WIDTH)
+  return width < MIN_TEXT_WIDTH ? '' : ellipsize(rawText(state, input), width)
+}
+
+/**
+ * The words that open a folded lane line: `needs you 3 min · <question>`, `blocked 3 min · waits on <what>` or
+ * `running 3 min · <step>`. The age is that of the lane's last activity, whole minutes, so a line changes once a
+ * minute; the step is the lane's reported task, which changes with the work and not with every action. Empty
+ * for a lane without a state.
+ */
+export const laneLead = (input: LaneLineInput): string => {
+  const state = laneStateOf(input.agent, input.reason)
+  if (!state) return ''
+  const age = input.minutesAgo === null ? '' : ` ${TEXTS.laneAge(input.minutesAgo)}`
+  const text = stateText(state, input)
+  return `${STATE_PAINT[state](`${STATE_WORD[state]()}${age}`)}${text ? `${paint.dim(' ·')} ${text}` : ''}`
+}
+
+/** `:3100 ↗` as a badge linked to the lane's dev server; empty while the lane has no port or nothing listens on it. */
+export const portBadge = (port: number | null, listening: boolean): string =>
+  port === null || !listening ? '' : badge(`http://localhost:${port}`, `:${port} ↗`)

package/src/plans/lane-reason.ts

@@ -1,6 +1,7 @@
 import type { SprintLane } from '../plan-format'
+import { ellipsize } from '../plan-format/terminal-text'
 import { AGENT_STATUS, isRestingAgent } from '../terminal/types'
-import { REST_QUESTION_COUNT } from '../watch/lane-rest'
+import { REST_NOTE_LABEL, REST_QUESTION_COUNT } from '../watch/lane-rest'
 import { waitingNote } from './lane-standing'
 import { plain } from './markdown-text'
 import { shortTitle } from './task-name'
@@ -28,9 +29,28 @@ const shortOf = (text: string): string => plain(shortTitle(text)).trim()
 /** How many open questions the watcher counted in the report; a note without its count is one. */
 const noteQuestionCount = (note: string): number => Number(note.match(REST_QUESTION_COUNT)?.[1] ?? 1)
 
+const LIST_MARKER = /^[*\-\s]*(?:\d+\.\s+)?/
+
+/** The first question of a rest note in its words, markdown and list markers out; empty when only its label or count remains. */
+const noteQuestion = (note: string): string =>
+  plain((note.startsWith(REST_NOTE_LABEL) ? note.slice(REST_NOTE_LABEL.length) : note).replace(REST_QUESTION_COUNT, ''))
+    .trim()
+    .replace(LIST_MARKER, '')
+
+/** The most of a question the line shows: a longer one would push the plan title out of a wide pane. */
+const QUESTION_WIDTH = 30
+
+/** What a question to you says: the first question in its words and `+n` for the others, else the count alone. */
+const questionText = (note: string): string => {
+  const question = noteQuestion(note)
+  return question
+    ? TEXTS.restAsks(ellipsize(question, QUESTION_WIDTH), noteQuestionCount(note) - 1)
+    : TEXTS.restQuestions(noteQuestionCount(note))
+}
+
 /**
- * Why a resting lane (idle or done) rests: the open questions of its report wait on you, by their count alone (their
- * text stands as rows of "Your turn"), else a row of "Your turn" that unblocks it, else its starts-after cell, both cut
+ * Why a resting lane (idle or done) rests: the open questions of its report wait on you, the first in its words and
+ * `+n` for the others, else a row of "Your turn" that unblocks it, else its starts-after cell, both cut
  * to their short title, else nothing known, which is meant to stand out. Null for a lane that works or whose agent is
  * blocked: the blocked word says it waits on you.
  */
@@ -43,7 +63,7 @@ export const laneReason = (
     return {
       kind: LANE_REASON.you,
       label: TEXTS.restWaitsOnYou,
-      text: TEXTS.restQuestions(noteQuestionCount(restNote)),
+      text: questionText(restNote),
     }
   const row = rows.find(({ unblocks }) => unblocks.includes(lane.name))
   if (row) return { kind: LANE_REASON.on, label: TEXTS.restWaitsOn, text: shortOf(row.text) }

package/src/plans/layout-phase.ts

@@ -153,7 +153,7 @@ export const subagentLine = (description: string, width: number, style: TaskStyl
 const taskLook = ({ done }: ChecklistItem, active: ActiveTask | undefined, taskStyle: TaskStyle): TaskLook => {
   if (active) {
     const style = active.guessed ? PLAIN_TASK : taskStyle
-    return { mark: activeArrow(active.guessed), style, suffix: agentSuffix(active.agent) }
+    return { mark: activeArrow(active.guessed || active.fromPlan === true), style, suffix: agentSuffix(active.agent) }
   }
   return done
     ? { mark: paint.green('☑'), style: paint.dim, suffix: '' }
@@ -236,22 +236,6 @@ export const taskRowFrame = (
 const deferredRow = ({ text, target }: DeferredItem, width: number): string =>
   fit(paint.dim(`${DEFERRED_MARK} ${phaseLabel(target)} ${plain(text)}`), width)
 
-/**
- * The children of an open phase below its fold row, one frame per task: the open ones first, the `active` ones (by
- * task index) marked, then the ones deferred to another phase, then the ticked ones, all listed: an opened phase has
- * no second fold row. The tasks in `shown` stand above already and are left out.
- */
-export const phaseChildren = (
-  context: LaneContext,
-  phaseRowKey: string,
-  phase: PhaseProgress,
-  active: ReadonlyMap<number, ActiveTask>,
-  shown: ReadonlySet<number>,
-): Frame[] => {
-  const frameOf = (item: ChecklistItem, index: number): Frame =>
-    taskRowFrame(context, phaseRowKey, { item, index, active: active.get(index) })
-  const framesWhere = (done: boolean): Frame[] =>
-    phase.items.flatMap((item, index) => (item.done === done && !shown.has(index) ? [frameOf(item, index)] : []))
-  const deferred = (phase.deferred ?? []).map((item) => textFrame([deferredRow(item, context.width)]))
-  return [...framesWhere(false), ...deferred, ...framesWhere(true)]
-}
+/** The checkboxes a phase moved to another phase, one dim row each, listed below the tasks of an opened phase. */
+export const deferredFrames = (phase: PhaseProgress, width: number): Frame[] =>
+  (phase.deferred ?? []).map((item) => textFrame([deferredRow(item, width)]))

package/src/plans/layout-summary.ts

@@ -1,15 +1,15 @@
 import { phaseLabel } from '../plan-format'
 import { bar, fit, paint, spread, visibleLength } from '../terminal/text'
 import { type Frame, indented, joinFrames, narrower, rowFrame, spaced, textFrame } from './frame'
-import { type ActivePhase, type LaneSummary, type PlacedPhase, SHOWN_OPEN_TASKS } from './lane-summary'
+import { type ActivePhase, type LaneSummary, type PlacedPhase } from './lane-summary'
 import {
   activeArrow,
   COLUMN_SEPARATOR,
+  deferredFrames,
   type LaneContext,
   MIN_TITLE_WIDTH,
   modelMark,
   nowLine,
-  phaseChildren,
   phaseCountCell,
   subagentLine,
   TASK_INDENT,
@@ -20,16 +20,14 @@ import {
 import { plain } from './markdown-text'
 import { type PhaseModel, phaseModelKey } from './phase-models'
 import { phaseRanges } from './phase-ranges'
-import { finishedKey, nextKey, phaseKey } from './selection'
+import { finishedKey, moreTasksKey, nextKey, phaseKey } from './selection'
 import { chevronOf, PHASE_COUNT } from './symbols'
+import { checklistRows, runningTaskIndexes } from './task-checklist'
 import { type HerdTexts, TEXTS } from './texts'
 
 /** The context of a lane's branches: the lane's, with the herd's words. */
 type SummaryContext = LaneContext & { labels: HerdTexts }
 
-/** What the row under a phase's tasks counts: the open tasks past the first ones and the done ones. */
-type TaskTally = { more: number; done: number }
-
 /** What an open lane shows above its phases, drawn at the width of its children: the session, its link chips and its pull requests. */
 export type LaneHead = { session: Frame; chips: Frame; pullRequests: Frame }
 
@@ -39,11 +37,6 @@ const onlyGateOpen = ({ items }: ActivePhase['phase']): boolean => {
   return open.length > 0 && open.every(({ gate }) => gate)
 }
 
-const taskTally = ({ items }: ActivePhase['phase']): TaskTally => {
-  const done = items.filter((item) => item.done).length
-  return { more: Math.max(items.length - done - SHOWN_OPEN_TASKS, 0), done }
-}
-
 /**
  * `· 6 min ago`, dim: when the running phase was last ticked or reported, nothing when the herd saw neither; `· gate`
  * after it while only the review gate is open. Empty when there is neither.
@@ -93,7 +86,7 @@ const reportedTaskTexts = ({ phase, tasks }: ActivePhase, labels: HerdTexts): st
  * In the order of the open lane: the tasks agents report on the phase, the reported ones no plan task names as
  * `now: …`, then the descriptions of the subagents that name no phase as `Subagent: …`.
  */
-const reportedTexts = (
+export const reportedTexts = (
   active: ActivePhase | undefined,
   { unplanned, subagentTasks }: Pick<LaneSummary, 'unplanned' | 'subagentTasks'>,
   labels: HerdTexts,
@@ -123,57 +116,75 @@ export const foldedTaskLine = (
   return `${indent}${lead}${style(fit(first, room))}${tail}`
 }
 
-/** The indexes of a phase's open tasks: the ones it is on first, then the others in the order of the plan. */
-const openTaskOrder = ({ phase, tasks }: ActivePhase): number[] => {
-  const isOpen = (index: number) => phase.items[index]?.done === false
-  const running = tasks.map(({ index }) => index).filter(isOpen)
-  const others = phase.items.flatMap((item, index) => (!item.done && !running.includes(index) ? [index] : []))
-  return [...new Set(running), ...others]
-}
-
 /**
- * The row that opens and folds a phase's tasks, dim: `▸ 2 more open · 12 done` while the phase shows its first open
- * ones, the same text with `▾` once it lists them all. None while the first open tasks are all the phase has.
+ * The tasks of a phase that run: the ones agents report, else, while the lane runs the phase, its first open task
+ * from the plan, which no agent reported: drawn `◌`, but shimmering like a reported task (`fromPlan`).
  */
-const moreTasksFrame = (key: string, tally: TaskTally, open: boolean, context: SummaryContext): Frame[] => {
-  if (tally.more === 0 && tally.done === 0) return []
-  const text = TEXTS.moreTasks(tally.more, tally.done)
-  return [rowFrame(key, [fit(paint.dim(`${chevronOf(open)} ${text}`), context.width)], [], context)]
+const runningTasks = ({ phase, tasks }: ActivePhase, laneRuns: boolean): Map<number, ActivePhase['tasks'][number]> => {
+  const indexes = runningTaskIndexes(
+    phase.items,
+    tasks.map(({ index }) => index),
+    laneRuns,
+  )
+  const reported = new Map(tasks.map((task) => [task.index, task]))
+  return new Map(
+    indexes.map((index) => [
+      index,
+      reported.get(index) ?? { index, agent: null, guessed: false, startedAt: null, fromPlan: true as const },
+    ]),
+  )
 }
 
-/** The tasks of a phase at the indexes in `shown`, each a row under `key`. */
-const shownTasks = (
+/** The dim row for the tasks a window leaves out, a row of its own under `key` when it opens the whole list. */
+const countFrame = (key: string, text: string, open: boolean, context: SummaryContext): Frame =>
+  rowFrame(key, [fit(paint.dim(`${chevronOf(open)} ${text}`), context.width)], [], context)
+
+/**
+ * The checklist of a phase in the plan's order (`checklistRows`): ticked tasks, the running ones marked, the ones to
+ * come. The first count row of a window opens the whole list; opened, `▾ <n> tasks` stands first and folds it, and the
+ * checkboxes moved to another phase close it.
+ */
+const checklistFrames = (
   context: SummaryContext,
   key: string,
-  shown: readonly number[],
   active: ActivePhase,
   running: ReadonlyMap<number, ActivePhase['tasks'][number]>,
-): Frame[] =>
-  shown.flatMap((index) => {
-    const item = active.phase.items[index]
-    return item ? [taskRowFrame(context, key, { item, index, active: running.get(index) })] : []
+): Frame[] => {
+  const { items } = active.phase
+  const moreKey = moreTasksKey(key)
+  const { expanded } = context.state
+  const open = expanded.has(key) || expanded.has(moreKey)
+  const rows = checklistRows(items, [...running.keys()], open)
+  const windowed = checklistRows(items, [...running.keys()], false).some(({ kind }) => kind !== 'task')
+  const frames = rows.map((row): Frame => {
+    if (row.kind === 'task') {
+      const item = items[row.index]
+      return item
+        ? taskRowFrame(context, key, { item, index: row.index, active: running.get(row.index) })
+        : textFrame([])
+    }
+    return countFrame(row.kind === 'above' ? key : moreKey, TEXTS.tasksMore(row.count), open, context)
   })
+  const foldKey = expanded.has(key) ? key : moreKey
+  const folder = open && windowed ? [countFrame(foldKey, TEXTS.tasksListed(items.length), true, context)] : []
+  return [...folder, ...frames, ...(open ? deferredFrames(active.phase, context.width) : [])]
+}
 
 /**
- * A phase the lane works on: its head with the bar, no row of its own; under it the open tasks, the ones it is on
- * first, at most `SHOWN_OPEN_TASKS`, then `▸ <n> more open · <k> done`. Opened, that row stays where it stood with
- * its text and a `▾`, and the rest of the tasks (`phaseChildren`) stand below it, never above.
+ * A phase the lane works on: its head with the bar, no row of its own; under it the checklist of its tasks in the
+ * plan's order, the running one marked (`checklistFrames`). `laneRuns` is false for a phase that only waits.
  */
-const activeFrame = (context: SummaryContext, active: ActivePhase): Frame => {
-  const { progress, state } = context
+const activeFrame = (context: SummaryContext, active: ActivePhase, laneRuns = true): Frame => {
+  const { progress } = context
   const stepIndex = active.stepIndex ?? -1
   const key = phaseKey(progress.lane.name, stepIndex, active.phase.id)
   const current = progress.current?.stepIndex === stepIndex && progress.current.phaseId === active.phase.id
   const model = context.models[phaseModelKey(stepIndex, active.phase.id)]
   const inner = narrower(context, TASK_INDENT.length)
-  const running = new Map(active.tasks.map((task) => [task.index, task]))
-  const open = state.expanded.has(key)
-  const shown = openTaskOrder(active).slice(0, SHOWN_OPEN_TASKS)
-  const more = moreTasksFrame(key, taskTally(active.phase), open, inner)
-  const rest = open ? phaseChildren(inner, key, active.phase, running, new Set(shown)) : []
+  const running = runningTasks(active, laneRuns)
   return joinFrames([
     textFrame([phaseHead(active, current, context, model)]),
-    indented(joinFrames([...shownTasks(inner, key, shown, active, running), ...more, ...rest]), TASK_INDENT),
+    indented(joinFrames(checklistFrames(inner, key, active, running)), TASK_INDENT),
   ])
 }
 
@@ -219,7 +230,7 @@ const finishedText = (summary: LaneSummary, labels: HerdTexts): string => {
 
 /** A phase that does not run, drawn like a running one: its head, its first open tasks and the line that lists them all. */
 const restingFrame = (context: SummaryContext, { phase, stepIndex }: PlacedPhase): Frame =>
-  activeFrame(context, { phase, stepIndex, minutesAgo: null, tasks: [] })
+  activeFrame(context, { phase, stepIndex, minutesAgo: null, tasks: [] }, false)
 
 /**
  * `▸ <text>`: one line cut at the pane's edge, a row under `key`; no line when the text is empty. Open (`▾`), it