jackherd 1.9.0 → 1.11.0

package/src/plans/layout-summary.ts

@@ -1,7 +1,7 @@
 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 type { ActivePhase, LaneSummary, PlacedPhase } from './lane-summary'
 import {
   activeArrow,
   activeTitle,
@@ -14,12 +14,14 @@ import {
   phaseChildren,
   phaseCountCell,
   plain,
+  subagentLine,
   TASK_INDENT,
   taskFrame,
+  taskTitle,
 } from './layout-phase'
 import { type PhaseModel, phaseModelKey } from './phase-models'
 import { phaseRanges } from './phase-ranges'
-import { itemKey, phaseKey } from './selection'
+import { finishedKey, itemKey, nextKey, phaseKey } from './selection'
 import { PHASE_COUNT } from './symbols'
 import { type HerdTexts, TEXTS } from './texts'
 
@@ -62,6 +64,46 @@ const activeRow = (active: ActivePhase, current: boolean, context: SummaryContex
   return spread(head, candidates.find((right) => titleRoom(right) >= MIN_TITLE_WIDTH) ?? count, width)
 }
 
+/** What an active task reads as on one row: `Review gate` for a box of the review gate, else its short name or text. */
+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
+    .filter(({ guessed }) => !guessed)
+    .flatMap(({ index }) => {
+      const item = phase.items[index]
+      return item ? [taskText(item, labels)] : []
+    }),
+  ...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.
+ */
+export const foldedTaskLine = (
+  active: ActivePhase,
+  subagentTasks: readonly string[],
+  labels: HerdTexts,
+  indent: string,
+  width: number,
+): string | null => {
+  const [first, ...others] = reportedTexts(active, subagentTasks, 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}`
+}
+
 /**
  * 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
@@ -72,7 +114,7 @@ const taskLinesFrame = (context: SummaryContext, phaseRowKey: string, { phase, t
     tasks.flatMap((task) => {
       const item = phase.items[task.index]
       if (!item) return []
-      const text = item.gate ? context.labels.reviewGate : plain(item.text)
+      const text = taskText(item, context.labels)
       const line = spread(
         `${TASK_INDENT}${activeArrow(task.guessed)} ${activeTitle(text, task.guessed)}`,
         agentCell(task.agent),
@@ -117,30 +159,59 @@ const nextLineText = (summary: LaneSummary, labels: HerdTexts): string => {
   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. */
-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 ? '' : `${phaseRanges(unmerged)} `
-  return ` · ${paint.yellow(`${which}${labels.notMerged}`)}`
-}
-
-/** `✓ P1–P7, P10 · not merged` on one line: one ✓, the finished phases as ranges. */
+/** `done P1–P7, P10` on one line: the word `done` in green, the finished phases as ranges. */
 const finishedText = (summary: LaneSummary, labels: HerdTexts): string => {
   const phases = phaseRanges(summary.finished.map(({ id }) => id))
-  return phases ? `${paint.green(PHASE_COUNT.allTicked)} ${phases}${unmergedNote(summary, labels)}` : ''
+  return phases ? `${paint.green(labels.done)} ${phases}` : ''
 }
 
-/** 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)] : [])
+/** 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. */
+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.
+ */
+const foldFrame = (
+  context: SummaryContext,
+  key: string,
+  text: string,
+  { 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 children = [
+    ...phases.map((placed) => restingFrame(inner, placed)),
+    ...unwritten.map((line) => textFrame([fit(line, inner.width)])),
+  ]
+  return joinFrames([row, nest(children)])
+}
 
 /** 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
+  return [
+    foldFrame(context, nextKey(laneName), nextLineText(summary, context.labels), {
+      phases: summary.waitingPhases,
+      unwritten: summary.unwritten.map(unwrittenText),
+    }),
+    foldFrame(context, finishedKey(laneName), finishedText(summary, context.labels), {
+      phases: summary.finishedPhases,
+      unwritten: [],
+    }),
+  ]
+}
+
 /**
  * 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.
+ * `now:` and `Subagent:` lines, `next` with the open phases that wait, and `done` 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
@@ -152,7 +223,7 @@ export const summaryChildren = (context: LaneContext, summary: LaneSummary, head
     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),
+    ...summary.subagentTasks.map((description) => textFrame([subagentLine(description, width)])),
+    ...restingFrames(inner, summary),
   ]
 }