jackherd 1.3.0 → 1.5.0

package/src/watch/command.ts

@@ -46,6 +46,7 @@ import { clockLocaleOf, type PlansSettings, plansSettingsOf, worktreeOf } from '
 import { boardTexts } from '../plans/texts'
 import { defaultUpdateCheck } from '../sync/if-changed'
 import { herdrLaneStatusSource } from '../terminal/herdr'
+import { AGENT_STATUS } from '../terminal/types'
 import { startedKit } from '../version/started-kit'
 import {
   type CoordinatorRead,
@@ -68,6 +69,7 @@ import {
 } from './feedback'
 import { type FeedbackItemsRead, readCommentItems, readFeedbackItems, readOwnLogin } from './feedback-read'
 import { answered, deployTargetOf, type GithubRead, readGithub, targetText } from './github-read'
+import { currentPhaseCountsOf, type PhaseCount, progressNotes } from './heartbeat-progress'
 import { agentScreen, listAgents } from './herdr'
 import { endedByKitUpdate } from './kit-update'
 import { type LaneReadings, laneFillEvents, recordLaneLevels } from './lane-fill'
@@ -216,6 +218,8 @@ type Watching = {
   state: WatchState
   baseline: LaneSnapshot
   current: LaneSnapshot
+  /** The phase count of each lane at the last heartbeat, so a heartbeat names only a count that moved. */
+  heartbeatCounts: Record<string, PhaseCount>
   /** The last `herdr agent list` answer, kept for finding the coordinator by its pane. */
   agents: HerdrAgent[]
   github: GithubRead | null
@@ -762,6 +766,20 @@ const report = async (
   return shown
 }
 
+/**
+ * The heartbeat of a stream: one line, a working lane with its phase count when that moved since the last heartbeat.
+ * The plans are read only when a lane works; a board that cannot be read leaves the lines without a count, and the
+ * next report names the failure.
+ */
+const printStreamHeartbeat = async (watch: Watch, watching: Watching, now: number): Promise<void> => {
+  const working = watching.lanes.filter((lane) => watching.current[lane]?.status === AGENT_STATUS.working)
+  const { progress } = working.length > 0 ? await boardReadOrNote(watch, working) : { progress: {} }
+  const counts = currentPhaseCountsOf(progress)
+  const notes = progressNotes(watching.lanes, watching.current, counts, watching.heartbeatCounts)
+  watching.heartbeatCounts = { ...watching.heartbeatCounts, ...counts }
+  console.log(streamHeartbeatLine(clock(watch, now), watching.lanes, watching.current, notes))
+}
+
 /**
  * One poll: reports what is due and tells whether to keep watching. Without `--stream` the first
  * report ends the watch; in a stream every reported lane counts as seen and the heartbeat is one line.
@@ -784,7 +802,7 @@ const pollOnce = async (watch: Watch, watching: Watching): Promise<boolean> => {
   } else if (heartbeat && !stream) {
     next = await report(watch, watching, [], [{ kind: WATCH_EVENT.heartbeat }], { ...next, statusLines: null })
   } else {
-    if (heartbeat) console.log(streamHeartbeatLine(clock(watch, now), watching.lanes, watching.current))
+    if (heartbeat) await printStreamHeartbeat(watch, watching, now)
     if (due) writePrivate(watch.files.state, JSON.stringify(next))
     watching.baseline = advanceBaseline(watching.baseline, watching.current)
   }
@@ -809,6 +827,7 @@ const initialWatching = (
   agents: start.agents,
   github: null,
   laneBranches: {},
+  heartbeatCounts: {},
   githubReadAt: 0,
   coordinator: { name: watch.options.coordinator, read: null },
   herdrDown: false,

package/src/watch/heartbeat-progress.ts

@@ -0,0 +1,47 @@
+import { currentPhase, type LaneProgress, PHASE_ID_PREFIX, type PhaseProgress } from '../plan-format'
+import { AGENT_STATUS } from '../terminal/types'
+import type { LaneSnapshot } from './lane-watch'
+
+/** The current phase of a lane and how many of its checkboxes are ticked, as the plans view counts them. */
+export type PhaseCount = Pick<PhaseProgress, 'id' | 'done' | 'total'>
+
+/** What a heartbeat adds to a working lane, by lane name: `P12 7/12`, without the middle dot of `shortTitle`, which the heartbeat's separator rewrite would turn into a slash. */
+export type LaneNotes = Readonly<Record<string, string>>
+
+/** The count of the lane's current phase; null without a plan, without a current phase or with nothing to tick. */
+export const currentPhaseCountOf = (progress: LaneProgress | null): PhaseCount | null => {
+  const phase = progress ? currentPhase(progress) : null
+  return phase && phase.total > 0 ? { id: phase.id, done: phase.done, total: phase.total } : null
+}
+
+/** The counts of the lanes that have one. */
+export const currentPhaseCountsOf = (progress: Readonly<Record<string, LaneProgress>>): Record<string, PhaseCount> =>
+  Object.fromEntries(
+    Object.entries(progress).flatMap(([lane, laneProgress]) => {
+      const count = currentPhaseCountOf(laneProgress)
+      return count ? [[lane, count]] : []
+    }),
+  )
+
+const sameCount = (left: PhaseCount | undefined, right: PhaseCount): boolean =>
+  left?.id === right.id && left.done === right.done && left.total === right.total
+
+/**
+ * The note of each working lane whose count differs from the one at the last heartbeat (or has none before): a lane
+ * that has not moved says nothing, so a stretch on one number tells the coordinator to look for itself.
+ */
+export const progressNotes = (
+  lanes: readonly string[],
+  current: LaneSnapshot,
+  counts: Readonly<Record<string, PhaseCount>>,
+  previous: Readonly<Record<string, PhaseCount>>,
+): LaneNotes =>
+  Object.fromEntries(
+    lanes.flatMap((lane) => {
+      const count = counts[lane]
+      const moved = count !== undefined && !sameCount(previous[lane], count)
+      return moved && current[lane]?.status === AGENT_STATUS.working
+        ? [[lane, `${PHASE_ID_PREFIX}${count.id} ${count.done}/${count.total}`]]
+        : []
+    }),
+  )

package/src/watch/source-command.ts

@@ -0,0 +1,16 @@
+import { basename } from 'node:path'
+
+const BUN_NAMES = new Set(['bun', 'bun.exe'])
+
+/**
+ * The command a source starts. The watcher starts it without a shell, so `bun` would be looked up on the PATH, where
+ * Bun may be missing although the watcher itself runs under it (installed in `~/.bun/bin` only). `bun` as the program
+ * therefore means the Bun that runs the watcher (`execPath`); a path written out, another program, or a watcher that
+ * runs under something else is left as written.
+ */
+export const resolveSourceCommand = (command: readonly string[], execPath: string): string[] => {
+  const [program, ...rest] = command
+  return program === 'bun' && BUN_NAMES.has(basename(execPath.replaceAll('\\', '/')))
+    ? [execPath, ...rest]
+    : [...command]
+}

package/src/watch/source-run.ts

@@ -1,3 +1,4 @@
+import { resolveSourceCommand } from './source-command'
 import { exitFailure, parseSourceOutput, SOURCE_FAILURE, type SourceRun, type SourceSettings } from './sources'
 
 /** How long a source's command may run and how much it may print before it is stopped. */
@@ -39,7 +40,13 @@ const readCapped = async (child: Child, maxBytes: number): Promise<string | null
 /** Started in a process group of its own, so a timeout reaches what the command started too (`curl` behind `sh`). */
 const spawned = (command: readonly string[], cwd: string): Child | null => {
   try {
-    return Bun.spawn([...command], { cwd, stdin: 'ignore', stdout: 'pipe', stderr: 'ignore', detached: true })
+    return Bun.spawn(resolveSourceCommand(command, process.execPath), {
+      cwd,
+      stdin: 'ignore',
+      stdout: 'pipe',
+      stderr: 'ignore',
+      detached: true,
+    })
   } catch {
     return null
   }

package/src/watch/stream-output.ts

@@ -1,14 +1,31 @@
 import { terminalSafe } from '../plan-format/terminal-text'
+import { AGENT_STATUS } from '../terminal/types'
+import type { LaneNotes } from './heartbeat-progress'
 import { type LaneSnapshot, NO_AGENT } from './lane-watch'
 import { WATCH_EVENT } from './watch-events'
 
+const SEPARATOR = ' · '
+
+/** `lane status`, a working lane with its note: `lane working: P12 7/12`. */
+const laneState = (lane: string, current: LaneSnapshot, notes: LaneNotes): string => {
+  const status = current[lane]?.status ?? NO_AGENT
+  const note = status === AGENT_STATUS.working ? notes[lane] : undefined
+  const head = `${terminalSafe(lane)} ${terminalSafe(status)}`
+  return note === undefined ? head : `${head}: ${terminalSafe(note).replaceAll(SEPARATOR, ' / ')}`
+}
+
 /**
  * The heartbeat of a stream, as one line, since every line of a stream reaches the coordinator as a
  * message of its own: `=== heartbeat <time> · <lane> <status> · …`.
  */
-export const streamHeartbeatLine = (time: string, lanes: readonly string[], current: LaneSnapshot): string => {
-  const states = lanes.map((lane) => `${terminalSafe(lane)} ${terminalSafe(current[lane]?.status ?? NO_AGENT)}`)
+export const streamHeartbeatLine = (
+  time: string,
+  lanes: readonly string[],
+  current: LaneSnapshot,
+  notes: LaneNotes,
+): string => {
+  const states = lanes.map((lane) => laneState(lane, current, notes))
   return [`=== ${WATCH_EVENT.heartbeat} ${terminalSafe(time)}`, ...(states.length > 0 ? states : ['no lanes'])].join(
-    ' · ',
+    SEPARATOR,
   )
 }