jackherd 1.8.0 → 1.9.0

package/src/plans/layout-summary.ts

@@ -1,49 +1,59 @@
-import { phaseLabel, phaseLabels } from '../plan-format'
-import { fit, padVisible, paint, spread, visibleLength } from '../terminal/text'
-import { textWidth } from '../terminal/width'
-import { deeper, type Frame, joinFrames, nest, prefixed, rowFrame, textFrame } from './frame'
+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 } from './lane-summary'
 import {
-  ACTIVE_MARK,
+  activeArrow,
+  activeTitle,
+  agentCell,
   COLUMN_SEPARATOR,
-  DEFERRED_MARK,
   type LaneContext,
   MIN_TITLE_WIDTH,
   modelMark,
+  nowLine,
   phaseChildren,
   phaseCountCell,
   plain,
+  TASK_INDENT,
   taskFrame,
 } from './layout-phase'
 import { type PhaseModel, phaseModelKey } from './phase-models'
+import { phaseRanges } from './phase-ranges'
 import { itemKey, phaseKey } from './selection'
 import { PHASE_COUNT } from './symbols'
 import { type HerdTexts, TEXTS } from './texts'
 
-/** The context of a lane's sections: the lane's, with the herd's words. */
+/** The context of a lane's branches: the lane's, with the herd's words. */
 type SummaryContext = LaneContext & { labels: HerdTexts }
 
-/** The label column of the summary's sections, as wide as the widest label and two cells. */
-const sectionWidth = ({ sections }: HerdTexts): number =>
-  Math.max(...Object.values(sections).map(textWidth)) + COLUMN_SEPARATOR.length
-
-/** A frame behind a section label on its first line, its other lines indented to where the content starts. */
-const labelled = (labelWidth: number, label: string, frame: Frame): Frame =>
-  prefixed(frame, { first: padVisible(label, labelWidth), rest: ' '.repeat(labelWidth), style: paint.dim })
+/** 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)
+}
 
-/** `· 6 min ago`, dim: when the running phase last moved. */
-const ageCell = ({ minutesAgo }: ActivePhase, labels: HerdTexts): string =>
-  `${paint.dim(labels.minutesAgo(minutesAgo))}${COLUMN_SEPARATOR}`
+/**
+ * `· 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.
+ */
+const ageCell = ({ minutesAgo, phase }: ActivePhase, labels: HerdTexts): string => {
+  const words = [
+    ...(minutesAgo === null ? [] : [labels.minutesAgo(minutesAgo)]),
+    ...(onlyGateOpen(phase) ? [labels.gate] : []),
+  ]
+  return words.length > 0 ? `${paint.dim(words.join(' '))}${COLUMN_SEPARATOR}` : ''
+}
 
 /**
- * `▶ P12 <title>   [model]  · 6 min ago   16/26`: title at the left, model, age and count at the right edge. 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`: 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.
  */
 const activeRow = (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 = `${paint.yellow(ACTIVE_MARK)} ${phaseLabel(phase.id)} ${title}`
+  const head = `${phaseLabel(phase.id)} ${title}`
   const count = phaseCountCell(phase, current)
   const withAge = `${ageCell(active, labels)}${count}`
   const mark = modelMark(model)
@@ -53,16 +63,24 @@ const activeRow = (active: ActivePhase, current: boolean, context: SummaryContex
 }
 
 /**
- * `→ <task>` under a closed running phase: the task it is on, dim, 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; nothing when no task is open.
+ * 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.
  */
-const taskLineFrame = (context: SummaryContext, phaseRowKey: string, { phase, taskIndex }: ActivePhase): Frame => {
-  const item = taskIndex === null ? undefined : phase.items[taskIndex]
-  if (!item || taskIndex === null) return textFrame([])
-  const text = item.gate ? context.labels.reviewGate : plain(item.text)
-  const underTitle = ' '.repeat(visibleLength(ACTIVE_MARK) + 1)
-  const line = fit(`${underTitle}${paint.dim(`${DEFERRED_MARK} ${text}`)}`, context.width)
-  return taskFrame(itemKey(phaseRowKey, taskIndex), [line], context)
+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 = item.gate ? context.labels.reviewGate : plain(item.text)
+      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)]
+    }),
+  )
 }
 
 /** A running phase as a row that opens to its tasks; closed, the task it is on below it. */
@@ -71,70 +89,70 @@ const activeFrame = (context: SummaryContext, active: ActivePhase): Frame => {
   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 item = active.taskIndex === null ? null : (active.phase.items[active.taskIndex] ?? null)
   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, taskLineFrame(context, key, active)])
-  return joinFrames([row, nest(phaseChildren(deeper(context), key, active.phase, item))])
+  if (!state.expanded.has(key)) return joinFrames([row, taskLinesFrame(context, key, active)])
+  return joinFrames([
+    row,
+    nest(phaseChildren(deeper(context), key, active.phase, new Map(active.tasks.map((task) => [task.index, task])))),
+  ])
 }
 
-/** `wave 2: P5 · P10` or, without waves, `P7`. */
-const nextText = ({ next }: LaneSummary, labels: HerdTexts): string =>
-  next ? `${next.wave === null ? '' : `${labels.wave(next.wave)} `}${phaseLabels(next.phaseIds, ' · ')}` : ''
-
 /** `P8 ?` for a named phase the plan lacks, `P9 –` for one without a checkbox. */
 const unwrittenText = ({ id, missing }: LaneSummary['unwritten'][number]): string =>
   `${phaseLabel(id)} ${paint.dim(missing ? PHASE_COUNT.missing : PHASE_COUNT.empty)}`
 
-/** `P6 P7 P8 ? · Second plan: P1`: the current plan's waiting phases, then the other plans' by their name. */
-const laterText = ({ later, unwritten }: LaneSummary): string => {
-  const own = [
-    ...(later[0]?.planTitle === null ? [phaseLabels(later[0].phaseIds, ' ')] : []),
-    ...unwritten.map(unwrittenText),
-  ]
-  const others = later
+/**
+ * `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 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()}: ${phaseLabels(phaseIds, ' ')}`)
-  return [...(own.length > 0 ? [own.join(' ')] : []), ...others].join(' · ')
+    .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}` : ''
 }
 
-/** ` · not merged` once for the line when every finished phase waits for its merge, ` · P1 P2 not merged` when some do. */
+/** ` · not merged` once for the line when every finished phase waits for its merge, ` · P1–P2 not merged` when some do. */
 const unmergedNote = ({ finished }: LaneSummary, labels: HerdTexts): string => {
   const unmerged = finished.filter(({ unmerged }) => unmerged).map(({ id }) => id)
   if (unmerged.length === 0) return ''
-  const which = unmerged.length === finished.length ? '' : `${phaseLabels(unmerged, ' ')} `
+  const which = unmerged.length === finished.length ? '' : `${phaseRanges(unmerged)} `
   return ` · ${paint.yellow(`${which}${labels.notMerged}`)}`
 }
 
-/** `✓ P1 ✓ P4 · not merged` on one line. */
+/** `✓ P1–P7, P10 · not merged` on one line: one ✓, the finished phases as ranges. */
 const finishedText = (summary: LaneSummary, labels: HerdTexts): string => {
-  const phases = summary.finished.map(({ id }) => `${paint.green(PHASE_COUNT.allTicked)} ${phaseLabel(id)}`).join(' ')
-  return phases ? `${phases}${unmergedNote(summary, labels)}` : ''
+  const phases = phaseRanges(summary.finished.map(({ id }) => id))
+  return phases ? `${paint.green(PHASE_COUNT.allTicked)} ${phases}${unmergedNote(summary, labels)}` : ''
 }
 
-/** A section with one line of text, cut at the pane's edge; no frame when the text is empty. */
-const textSection = (labelWidth: number, label: string, text: string, width: number): Frame =>
-  text ? labelled(labelWidth, label, textFrame([fit(text, Math.max(width - labelWidth, 1))])) : textFrame([])
+/** One line of text cut at the pane's edge; no line when the text is empty. */
+const lineFrame = (text: string, width: number): Frame => textFrame(text ? [fit(text, width)] : [])
 
-/** What an open lane shows above its sections, each drawn at the width its label column leaves. */
-export type LaneHead = { session: (width: number) => string; chips: (width: number) => Frame }
+/** 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 children of an open lane, each on a branch with its label in one column: SESSION, the 📎 chips, then NOW, NEXT,
- * LATER and DONE, each section only when it has phases.
+ * 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:` lines, `next` with the open phases that wait, and `✓` with the finished ones; a branch without lines is left out.
  */
 export const summaryChildren = (context: LaneContext, summary: LaneSummary, head: LaneHead): Frame[] => {
   const labels = TEXTS.herd
-  const labelWidth = sectionWidth(labels)
-  const inner = { ...context, width: Math.max(context.width - labelWidth, 1), labels }
-  const { sections } = labels
-  const now = summary.active.map((active) => activeFrame(inner, active))
+  const inner = { ...context, labels }
+  const { width } = context
   return [
-    labelled(labelWidth, sections.session, textFrame([head.session(inner.width)])),
-    labelled(labelWidth, sections.chips, head.chips(inner.width)),
-    ...(now.length > 0 ? [labelled(labelWidth, sections.now, joinFrames(now))] : []),
-    textSection(labelWidth, sections.next, nextText(summary, labels), context.width),
-    textSection(labelWidth, sections.later, laterText(summary), context.width),
-    textSection(labelWidth, sections.done, finishedText(summary, labels), context.width),
+    head.session,
+    head.pullRequests,
+    head.chips,
+    ...summary.active.map((active) => activeFrame(inner, active)),
+    ...summary.unplanned.map((task) => textFrame([nowLine(task, width)])),
+    lineFrame(nextLineText(summary, labels), width),
+    lineFrame(finishedText(summary, labels), width),
   ]
 }