jackherd 1.11.2 → 1.12.1

package/src/plans/layout-summary.ts

@@ -1,11 +1,9 @@
 import { phaseLabel } from '../plan-format'
-import { fit, paint, spread, visibleLength } from '../terminal/text'
-import { deeper, type Frame, joinFrames, nest, rowFrame, textFrame } from './frame'
-import type { ActivePhase, LaneSummary, PlacedPhase } from './lane-summary'
+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 {
   activeArrow,
-  activeTitle,
-  agentCell,
   COLUMN_SEPARATOR,
   type LaneContext,
   MIN_TITLE_WIDTH,
@@ -16,24 +14,36 @@ import {
   plain,
   subagentLine,
   TASK_INDENT,
-  taskFrame,
+  type TaskStyle,
+  taskRowFrame,
   taskTitle,
 } from './layout-phase'
 import { type PhaseModel, phaseModelKey } from './phase-models'
 import { phaseRanges } from './phase-ranges'
-import { finishedKey, itemKey, nextKey, phaseKey } from './selection'
-import { PHASE_COUNT } from './symbols'
+import { finishedKey, nextKey, phaseKey } from './selection'
+import { chevronOf, PHASE_COUNT } from './symbols'
 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 }
+
 /** Whether only the boxes of the review gate are open. */
 const onlyGateOpen = ({ items }: ActivePhase['phase']): boolean => {
   const open = items.filter(({ done }) => !done)
   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.
@@ -47,19 +57,21 @@ const ageCell = ({ minutesAgo, phase }: ActivePhase, labels: HerdTexts): string
 }
 
 /**
- * `P12 <title>   [model]  · 6 min ago   16/26`: title at the left, model, age and count at the right edge, no arrow
- * (arrows stand before tasks only). In a pane too narrow to leave the title `MIN_TITLE_WIDTH` cells, the model gives
- * way first, then the age.
+ * `P12 <title>   [model]  · 6 min ago  ████░░  16/26`: the bold heading at the left, model, age, bar and count at the right edge,
+ * no arrow (arrows stand before tasks only). In a pane too narrow to leave the title `MIN_TITLE_WIDTH` cells, the model
+ * gives way first, then the age, then the bar.
  */
-const activeRow = (active: ActivePhase, current: boolean, context: SummaryContext, model?: PhaseModel): string => {
+const phaseHead = (active: ActivePhase, current: boolean, context: SummaryContext, model?: PhaseModel): string => {
   const { width, labels } = context
   const { phase } = active
   const title = phase.title === null ? paint.dim(TEXTS.notInPlan) : plain(phase.title)
-  const head = `${phaseLabel(phase.id)} ${title}`
+  const label = `${phaseLabel(phase.id)} ${title}`
+  const head = phase.title === null ? label : paint.bold(label)
   const count = phaseCountCell(phase, current)
-  const withAge = `${ageCell(active, labels)}${count}`
+  const counted = phase.total > 0 ? `${bar(phase.done, phase.total)} ${count}` : count
+  const withAge = `${ageCell(active, labels)}${counted}`
   const mark = modelMark(model)
-  const candidates = [...(mark ? [`${mark}${COLUMN_SEPARATOR}${withAge}`] : []), withAge]
+  const candidates = [...(mark ? [`${mark}${COLUMN_SEPARATOR}${withAge}`] : []), withAge, counted]
   const titleRoom = (right: string) => width - visibleLength(head) + visibleLength(title) - visibleLength(right) - 1
   return spread(head, candidates.find((right) => titleRoom(right) >= MIN_TITLE_WIDTH) ?? count, width)
 }
@@ -68,75 +80,100 @@ const activeRow = (active: ActivePhase, current: boolean, context: SummaryContex
 const taskText = (item: ActivePhase['phase']['items'][number], labels: HerdTexts): string =>
   item.gate ? labels.reviewGate : taskTitle(item.text)
 
-/** The texts of the tasks agents report on the phase, then the descriptions of the subagents that name no phase as `Subagent: …`. */
-const reportedTexts = (
-  { phase, tasks }: ActivePhase,
-  subagentTasks: readonly string[],
-  labels: HerdTexts,
-): string[] => [
-  ...tasks
+/** The texts of the tasks agents report on the phase. */
+const reportedTaskTexts = ({ phase, tasks }: ActivePhase, labels: HerdTexts): string[] =>
+  tasks
     .filter(({ guessed }) => !guessed)
     .flatMap(({ index }) => {
       const item = phase.items[index]
       return item ? [taskText(item, labels)] : []
-    }),
+    })
+
+/**
+ * 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 = (
+  active: ActivePhase | undefined,
+  { unplanned, subagentTasks }: Pick<LaneSummary, 'unplanned' | 'subagentTasks'>,
+  labels: HerdTexts,
+): string[] => [
+  ...(active ? reportedTaskTexts(active, labels) : []),
+  ...unplanned.map(({ text }) => `${TEXTS.now} ${text}`),
   ...subagentTasks.map((description) => `${TEXTS.subagent} ${taskTitle(description)}`),
 ]
 
 /**
- * `▶ Name +1` for a folded lane, behind `indent`: the first task the phase is on with the arrow of the open lane, `+n`
- * for the others in parallel at the end; no ticks, the phase row shows them; the name cut to the pane's edge. A task
- * an agent reports comes first, the descriptions of the `subagentTasks` after it. Null while neither exists: a task
- * the herd only guesses from words is no sign that the lane works.
+ * `● Name +1` for a folded lane, behind `indent`: the first task the lane reports with the arrow of the open lane, its
+ * text drawn in `style`, `+n` for the others in parallel at the end; no ticks, the phase row shows them; the name cut
+ * to the pane's edge. The order is the open lane's: a task of the `active` phase, then `now: …`, then `Subagent: …`.
+ * Null while none exists: a task the herd only guesses from words is no sign that the lane works.
  */
 export const foldedTaskLine = (
-  active: ActivePhase,
-  subagentTasks: readonly string[],
+  active: ActivePhase | undefined,
+  reported: Pick<LaneSummary, 'unplanned' | 'subagentTasks'>,
   labels: HerdTexts,
-  indent: string,
-  width: number,
+  { indent, width, style }: { indent: string; width: number; style: TaskStyle },
 ): string | null => {
-  const [first, ...others] = reportedTexts(active, subagentTasks, labels)
+  const [first, ...others] = reportedTexts(active, reported, labels)
   if (first === undefined) return null
   const lead = `${activeArrow(false)} `
   const tail = others.length > 0 ? ` +${others.length}` : ''
   const room = Math.max(width - visibleLength(indent) - visibleLength(lead) - visibleLength(tail), 1)
-  return `${indent}${lead}${activeTitle(fit(first, room), false)}${tail}`
+  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]
 }
 
 /**
- * One row per active task under a closed running phase, each with its own arrow: the title bold and the agent dim
- * after it where agents reported it, `▷` and a plain title where the herd guesses. Always on one line whatever the
- * task's fold, and a row a click opens like the task itself; `Review gate` in place of a box of the review gate.
+ * 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.
  */
-const taskLinesFrame = (context: SummaryContext, phaseRowKey: string, { phase, tasks }: ActivePhase): Frame => {
-  return joinFrames(
-    tasks.flatMap((task) => {
-      const item = phase.items[task.index]
-      if (!item) return []
-      const text = taskText(item, context.labels)
-      const line = spread(
-        `${TASK_INDENT}${activeArrow(task.guessed)} ${activeTitle(text, task.guessed)}`,
-        agentCell(task.agent),
-        context.width,
-      )
-      return [taskFrame(itemKey(phaseRowKey, task.index), [line], context)]
-    }),
-  )
+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)]
 }
 
-/** A running phase as a row that opens to its tasks; closed, the task it is on below it. */
+/** The tasks of a phase at the indexes in `shown`, each a row under `key`. */
+const shownTasks = (
+  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) })] : []
+  })
+
+/**
+ * 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.
+ */
 const activeFrame = (context: SummaryContext, active: ActivePhase): Frame => {
   const { progress, state } = 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 row = rowFrame(key, [activeRow(active, current, context, model)], [], context)
-  if (!state.expanded.has(key)) return joinFrames([row, taskLinesFrame(context, key, active)])
+  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)) : []
   return joinFrames([
-    row,
-    nest(phaseChildren(deeper(context), key, active.phase, new Map(active.tasks.map((task) => [task.index, task])))),
+    textFrame([phaseHead(active, current, context, model)]),
+    indented(joinFrames([...shownTasks(inner, key, shown, active, running), ...more, ...rest]), TASK_INDENT),
   ])
 }
 
@@ -148,15 +185,30 @@ const unwrittenText = ({ id, missing }: LaneSummary['unwritten'][number]): strin
  * `next P5–P7, P10 P8 ? · Second plan: P1` on one line: every open phase that does not run, the current plan's as
  * ranges, then the other plans' by their name; empty when none waits.
  */
-const nextLineText = (summary: LaneSummary, labels: HerdTexts): string => {
+const rangesText = (summary: LaneSummary): string => {
   const ownIds = summary.waiting.filter(({ planTitle }) => planTitle === null).flatMap(({ phaseIds }) => phaseIds)
   const ownRanges = phaseRanges(ownIds)
   const own = [...(ownRanges ? [ownRanges] : []), ...summary.unwritten.map(unwrittenText)]
   const others = summary.waiting
     .filter(({ planTitle }) => planTitle !== null)
     .map(({ planTitle, phaseIds }) => `${plain((planTitle ?? '').split(':')[0]).trim()}: ${phaseRanges(phaseIds)}`)
-  const text = [...(own.length > 0 ? [own.join(' ')] : []), ...others].join(' · ')
-  return text ? `${paint.dim(labels.next)} ${text}` : ''
+  return [...(own.length > 0 ? [own.join(' ')] : []), ...others].join(' · ')
+}
+
+/**
+ * The outlook of an open lane, `next  P5 Export  +2`: the first phase that waits by its title and how many wait
+ * after it; without a written one, every waiting phase as ranges. Empty when none waits.
+ */
+const nextLineText = (summary: LaneSummary, labels: HerdTexts): string => {
+  const [first] = summary.waitingPhases
+  const count = summary.waiting.flatMap(({ phaseIds }) => phaseIds).length + summary.unwritten.length
+  if (!first) {
+    const ranges = rangesText(summary)
+    return ranges ? `${paint.dim(labels.next)}${COLUMN_SEPARATOR}${ranges}` : ''
+  }
+  const title = first.phase.title ? ` ${plain(first.phase.title)}` : ''
+  const more = count > 1 ? paint.dim(`${COLUMN_SEPARATOR}+${count - 1}`) : ''
+  return `${paint.dim(labels.next)}${COLUMN_SEPARATOR}${phaseLabel(first.phase.id)}${title}${more}`
 }
 
 /** `done P1–P7, P10` on one line: the word `done` in green, the finished phases as ranges. */
@@ -165,13 +217,13 @@ const finishedText = (summary: LaneSummary, labels: HerdTexts): string => {
   return phases ? `${paint.green(labels.done)} ${phases}` : ''
 }
 
-/** A phase that does not run as a row, which opens to its tasks like a running one; closed, it has no task line below it. */
+/** 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: [] })
 
 /**
- * One line of text cut at the pane's edge, a row under `key`; no line when the text is empty. Open, it continues with
- * a row per phase it names and the `unwritten` lines, each phase opening to its tasks.
+ * `▸ <text>`: one line cut at the pane's edge, a row under `key`; no line when the text is empty. Open (`▾`), it
+ * continues with each phase it names and the `unwritten` lines, indented under it.
  */
 const foldFrame = (
   context: SummaryContext,
@@ -180,19 +232,17 @@ const foldFrame = (
   { phases, unwritten }: { phases: readonly PlacedPhase[]; unwritten: string[] },
 ): Frame => {
   if (!text) return textFrame([])
-  const row = rowFrame(key, [fit(text, context.width)], [], context)
-  if (!context.state.expanded.has(key)) return row
-  const inner = deeper(context)
+  const open = context.state.expanded.has(key)
+  const row = rowFrame(key, [fit(`${paint.dim(chevronOf(open))} ${text}`, context.width)], [], context)
+  if (!open) return row
+  const inner = narrower(context, TASK_INDENT.length)
   const children = [
     ...phases.map((placed) => restingFrame(inner, placed)),
     ...unwritten.map((line) => textFrame([fit(line, inner.width)])),
   ]
-  return joinFrames([row, nest(children)])
+  return joinFrames([row, indented(joinFrames(children), TASK_INDENT)])
 }
 
-/** What an open lane shows above its phases, drawn at the width of its branches: the session, its pull requests and its link chips. */
-export type LaneHead = { session: Frame; pullRequests: Frame; chips: Frame }
-
 /** The `next` and `done` rows of an open lane. */
 const restingFrames = (context: SummaryContext, summary: LaneSummary): Frame[] => {
   const laneName = context.progress.lane.name
@@ -209,21 +259,21 @@ const restingFrames = (context: SummaryContext, summary: LaneSummary): Frame[] =
 }
 
 /**
- * The children of an open lane, one branch each, told apart by their marks rather than by a label: the session
- * (`⎇`), the pull requests (`↗`), the link chips, then one branch per running phase (its tasks `▶`/`▷` under it), the
- * `now:` and `Subagent:` lines, `next` with the open phases that wait, and `done` with the finished ones; a branch without lines is left out.
+ * The children of an open lane, told apart by their marks and a blank line between the groups, not by a label or a
+ * tree: the session (`⎇`), the link chips and the pull requests (`↗`); each running phase with its tasks (`●`/`◌`); the
+ * `now:` and `Subagent:` lines; the outlook, `next` with the open phases that wait and `done` with the finished ones.
+ * A group without lines is left out.
  */
-export const summaryChildren = (context: LaneContext, summary: LaneSummary, head: LaneHead): Frame[] => {
-  const labels = TEXTS.herd
-  const inner = { ...context, labels }
-  const { width } = context
-  return [
-    head.session,
-    head.pullRequests,
-    head.chips,
+export const openLaneFrame = (context: LaneContext, summary: LaneSummary, head: LaneHead): Frame => {
+  const inner = { ...context, labels: TEXTS.herd }
+  const { width, taskStyle } = context
+  return spaced([
+    joinFrames([head.session, head.chips, head.pullRequests]),
     ...summary.active.map((active) => activeFrame(inner, active)),
-    ...summary.unplanned.map((task) => textFrame([nowLine(task, width)])),
-    ...summary.subagentTasks.map((description) => textFrame([subagentLine(description, width)])),
-    ...restingFrames(inner, summary),
-  ]
+    textFrame([
+      ...summary.unplanned.map((task) => nowLine(task, width, taskStyle)),
+      ...summary.subagentTasks.map((description) => subagentLine(description, width, taskStyle)),
+    ]),
+    joinFrames(restingFrames(inner, summary)),
+  ])
 }