jackherd 1.11.2 → 1.12.1

package/src/plans/waiting-click.ts

@@ -3,14 +3,12 @@ import { WAITING_KIND, type WaitingItem } from '../plan-format/waiting'
 import { fit, padVisible, wrap } from '../terminal/text'
 import { textWidth } from '../terminal/width'
 import { ASK_KIND, type AskTarget } from './ask-target'
-import { plain } from './layout-phase'
 import { DONE_KIND, type DoneTarget } from './row-targets'
 import { MOUSE_BUTTON, type MouseEvent } from './selection'
-import { shortTitle } from './task-name'
 
 /**
  * One row of a block of the herd as drawn: its plain text lines (more than one while it is expanded; the first starts
- * with `mark` and a blank and, for a row with `[ask]`, is padded to leave the button its cells), whether its text is wider than the pane (`cut`), whether it is expanded, and the address a
+ * with `mark` and a blank and, for a row with `[ask]`, is padded to leave the button its cells), whether its text is wider than the pane and the row may expand (`cut`), whether it is expanded, and the address a
  * click opens.
  */
 export type BlockRow = {
@@ -20,12 +18,8 @@ export type BlockRow = {
   cut: boolean
   expanded: boolean
   url: string | null
-  /** What the coordinator can be asked to put: a dialog question or a row of the board; null for files and appointments. */
-  ask: AskTarget | null
   /** The buttons at the right edge of the first line, `[ask]` first, each with the screen column (1-based) it starts in. */
   buttons: PlacedButton[]
-  /** What the folded block shows of the row: the time column, if any, and the short title, without the mark. */
-  preview: string
   /** Per line, the index in it where the part behind the short title starts; the line's length where none of it is. */
   dimFrom: number[]
   /** The tone of the mark when it differs from the block's; absent for most rows. */
@@ -58,43 +52,33 @@ export type BlockItem = {
   /** A column before the text, padded by the caller to the widest of the block (the time of an appointment). */
   lead?: string
   text: string
-  /** What the row shows while folded; the whole `text` when absent. */
-  title?: string
   url: string | null
   ask: AskTarget | null
-  /** The buttons after `[ask]`, in the order they are drawn. */
-  buttons?: readonly BlockButton[]
   tone?: ToneName
   /** The key in the expanded set that a click on the row flips, whatever its text or address. */
   toggle?: string
   /** The row is dim from its text on (an entry already asked about). */
   dim?: boolean
+  /** The row never expands: everything it says fits its one line, so a click opens its address (a source's entry). */
+  expands?: false
 }
 
 /**
  * What a click on a block is matched against, built from the block as it was drawn: `firstLine` is the screen line
  * (0-based) of the first row, the line above it is the block's head; `rows` and `moreKey` are empty and null while the
- * block is folded; `keys` are all its points, what a fold of the block remembers.
+ * block is folded. `headKey` is the key the arrows select the head under, absent for a head that cannot open.
  */
 export type BlockHit = {
   firstLine: number
   rows: readonly BlockRow[]
   moreKey: string | null
-  keys: readonly string[]
+  headKey?: string
 }
 
-/** How many rows a block of the herd (for-you, appointments) draws; the rest is one `+<n>` line. */
+/** How many rows the sources block draws; the rest is one `+<n>` line. */
 export const SHOWN_BLOCK_ROWS = 5
-/** The key in the herd's expanded set that shows every point of the for-you block instead of the first five. */
-export const WAITING_MORE_KEY = 'more>waiting'
-/** The same for the appointment block. */
-export const APPOINTMENT_MORE_KEY = 'more>appointment'
-/** The same for the next block. */
-export const NEXT_MORE_KEY = 'more>next'
-/** The same for the sources block. */
+/** The key in the herd's expanded set that shows every source instead of the first five. */
 export const SOURCE_MORE_KEY = 'more>source'
-/** The bar and the blank that start every line of a for-you row. */
-export const WAITING_MARK = '▌'
 
 /** The button at the right edge of a question or a board row; a click on it, and only on it, asks the coordinator. */
 export const ASK_BUTTON = '[ask]'
@@ -103,42 +87,44 @@ export const DONE_BUTTON = '[done]'
 /** The appointment buttons that ask the coordinator to run the row now, and to ask the user for a new time. */
 export const RUN_BUTTON = '[run]'
 export const MOVE_BUTTON = '[move]'
-const ASK_GAP = 1
+/** The blank between a row's text and its first button. */
+export const ASK_GAP = 1
 const BUTTON_GAP = 1
-const FILE_MARK = '📎'
-const QUESTION_MARK = '?'
 const OPENABLE = /^(https?|file):\/\//
 
 /** The key of a row in the herd's expanded set: the record's id, else its text. */
 export const waitingKey = ({ id, item }: WaitingItem): string => `waiting>${id ?? item}`
 
-/** The keys of all open points, the shown ones and the `+<n>` rest alike: what the fold of the block remembers. */
-export const waitingKeys = (items: readonly WaitingItem[]): string[] => items.map(waitingKey)
-
-const BAR_WIDTH = textWidth(`${WAITING_MARK} `)
+/** The cells the two blanks take that start every line of a block row (`blockBar` and the gap after it). */
+export const BAR_WIDTH = 2
 
 const roomOf = (width: number): number => Math.max(width - BAR_WIDTH, 1)
 
-/** The buttons of an item, `[ask]` first when the item can be asked. */
-const buttonsOf = ({ ask, buttons = [] }: Pick<BlockItem, 'ask' | 'buttons'>): BlockButton[] => [
-  ...(ask ? [{ label: ASK_BUTTON, click: { ask } }] : []),
-  ...buttons,
-]
+/** `[ask]` for what the coordinator can put, none for what it cannot. */
+const askButtons = (ask: AskTarget | null): BlockButton[] => (ask ? [{ label: ASK_BUTTON, click: { ask } }] : [])
 
-const buttonsWidth = (buttons: readonly BlockButton[]): number =>
+/** The cells a row's buttons take, one blank apart. */
+export const buttonsWidth = (buttons: readonly BlockButton[]): number =>
   buttons.reduce((sum, { label }) => sum + textWidth(label), 0) + Math.max(buttons.length - 1, 0) * BUTTON_GAP
 
-/** The cells a row's text may take and the buttons with the screen columns they start in; none for a row without one. */
-const buttonLayout = (items: readonly BlockButton[], width: number): { room: number; placed: PlacedButton[] } => {
-  if (items.length === 0) return { room: roomOf(width), placed: [] }
-  const room = Math.max(roomOf(width) - (buttonsWidth(items) + ASK_GAP), 1)
+/** The buttons with the screen columns (1-based) they start in, the first one after `room` cells of text and a blank. */
+export const placedButtons = (buttons: readonly BlockButton[], room: number): PlacedButton[] => {
   let column = BAR_WIDTH + room + ASK_GAP + 1
-  const placed = items.map((button) => {
+  return buttons.map((button) => {
     const at = column
     column += textWidth(button.label) + BUTTON_GAP
     return { ...button, column: at }
   })
-  return { room, placed }
+}
+
+/** The cells a row's text may take beside `buttonCells` of buttons (0 for none) and the blank before them. */
+export const textRoom = (width: number, buttonCells: number): number =>
+  buttonCells === 0 ? roomOf(width) : Math.max(roomOf(width) - (buttonCells + ASK_GAP), 1)
+
+/** The cells a row's text may take and the buttons with the screen columns they start in; none for a row without one. */
+const buttonLayout = (items: readonly BlockButton[], width: number): { room: number; placed: PlacedButton[] } => {
+  const room = textRoom(width, items.length === 0 ? 0 : buttonsWidth(items))
+  return { room, placed: placedButtons(items, room) }
 }
 
 /** The labels of a row's buttons as drawn after its text, one blank apart, each painted with `paintLabel`. */
@@ -153,32 +139,19 @@ const askOf = (item: WaitingItem): AskTarget | null => {
   return { kind: ASK_KIND.boardRow, since: item.since, item: item.item }
 }
 
-/** The text wrapped to `room` cells behind `start` (the mark and the time column), the other lines indented to the column of the text. */
-const hangingLines = (start: string, text: string, room: number): string[] => {
-  const hang = textWidth(start)
-  const [first, ...rest] = wrap(text, Math.max(room - hang, 1))
-  return [`${start}${first}`, ...rest.map((line) => `${' '.repeat(hang)}${line}`)]
-}
+/** The fewest cells a wrapped line behind the lead may take; with less room the row is cut to one line instead. */
+const MIN_WRAP_WIDTH = 12
 
 /**
- * Per line, the index where the part behind the short title starts (the line's length while none of it is on the
- * line): the title may take several lines, and the rest starts on the line where it ends. `titleLength` is 0 for a
- * row without a short title.
+ * The text wrapped to `room` cells behind `start` (the mark and the time column), the other lines indented to the
+ * column of the text; one line cut at `room` when the lead leaves fewer than `MIN_WRAP_WIDTH` cells, so a wide lead never
+ * wraps the text one cell per line.
  */
-const dimStarts = (lines: readonly string[], start: string, titleLength: number): number[] => {
-  let remaining = titleLength
-  return lines.map((line, index) => {
-    if (titleLength === 0) return line.length
-    const from = index === 0 ? start.length : textWidth(start)
-    const content = line.length - from
-    if (remaining > content) {
-      remaining -= content + 1
-      return line.length
-    }
-    const dimFrom = from + Math.max(remaining, 0)
-    remaining = 0
-    return dimFrom
-  })
+const hangingLines = (start: string, text: string, room: number): string[] => {
+  const hang = textWidth(start)
+  if (room - hang < MIN_WRAP_WIDTH) return [fit(`${start}${text}`, room)]
+  const [first, ...rest] = wrap(text, room - hang)
+  return [`${start}${first}`, ...rest.map((line) => `${' '.repeat(hang)}${line}`)]
 }
 
 /** What `[done]` closes: the record of a file or a question, else the row of the board; none for a record-less question. */
@@ -192,32 +165,27 @@ const doneButtons = (item: WaitingItem): BlockButton[] => {
   return done ? [{ label: DONE_BUTTON, click: { done } }] : []
 }
 
-const withPrefix = (prefix: string | undefined, text: string): string => (prefix ? `${prefix}: ${text}` : text)
+/** The buttons of what waits on the user, `[ask]` where the coordinator can put it, then `[done]` where it can be closed. */
+export const waitingButtons = (item: WaitingItem): BlockButton[] => [...askButtons(askOf(item)), ...doneButtons(item)]
 
-const itemOf = (item: WaitingItem): BlockItem => ({
-  buttons: doneButtons(item),
-  key: waitingKey(item),
-  mark: item.kind === WAITING_KIND.file ? FILE_MARK : QUESTION_MARK,
-  text: withPrefix(item.prefix, plain(item.item)),
-  title: withPrefix(item.prefix, shortTitle(plain(item.item))),
-  url: item.kind === WAITING_KIND.file && item.url && OPENABLE.test(item.url) ? item.url : null,
-  ask: askOf(item),
-})
+/** The address a click on what waits opens: a sent file's, when it is one the herd can open. */
+export const waitingUrl = (item: WaitingItem): string | null =>
+  item.kind === WAITING_KIND.file && item.url && OPENABLE.test(item.url) ? item.url : null
 
 const rowOf = (item: BlockItem, expandedKeys: ReadonlySet<string>, width: number): BlockRow => {
-  const { key, mark, lead, text, title = text, url, ask, tone, toggle, dim } = item
-  const { room, placed } = buttonLayout(buttonsOf(item), width)
+  const { key, mark, lead, text, url, ask, tone, toggle, dim, expands } = item
+  const { room, placed } = buttonLayout(askButtons(ask), width)
   const leadText = lead === undefined ? '' : `${lead} `
   const start = `${mark} ${leadText}`
-  const cut = title !== text || textWidth(`${start}${text}`) > room
+  const cut = expands !== false && textWidth(`${start}${text}`) > room
   const expanded = cut && expandedKeys.has(key)
-  const [first, ...rest] = expanded ? hangingLines(start, text, room) : [fit(`${start}${title}`, room)]
-  const lines = placed.length > 0 ? [padVisible(first, room + ASK_GAP), ...rest] : [first, ...rest]
-  const lineParts = [first, ...rest]
-  const dimFrom = dim
-    ? lineParts.map((_, index) => (index === 0 ? mark.length + 1 : 0))
-    : dimStarts(lineParts, start, expanded && title !== text ? title.length : 0)
-  const preview = `${leadText}${title}`
+  const parts = expanded ? hangingLines(start, text, room) : [fit(`${start}${text}`, room)]
+  const lines =
+    placed.length > 0 ? parts.map((line, index) => (index === 0 ? padVisible(line, room + ASK_GAP) : line)) : parts
+  const dimFrom = parts.map((line, index) => {
+    if (!dim) return line.length
+    return index === 0 ? mark.length + 1 : 0
+  })
   return {
     key,
     mark,
@@ -225,9 +193,7 @@ const rowOf = (item: BlockItem, expandedKeys: ReadonlySet<string>, width: number
     cut,
     expanded,
     url,
-    ask,
     buttons: placed,
-    preview,
     dimFrom,
     ...(tone && { tone }),
     ...(toggle && { toggle }),
@@ -235,35 +201,13 @@ const rowOf = (item: BlockItem, expandedKeys: ReadonlySet<string>, width: number
   }
 }
 
-/**
- * The rows a block of the herd draws: the first five, or all of them while `moreKey` is in the expanded set; each
- * folded to one line unless expanded.
- */
-export const blockRows = (
-  items: readonly BlockItem[],
-  expandedKeys: ReadonlySet<string>,
-  width: number,
-  moreKey: string,
-): BlockRow[] =>
-  (expandedKeys.has(moreKey) ? items : items.slice(0, SHOWN_BLOCK_ROWS)).map((item) => rowOf(item, expandedKeys, width))
-
-/** Every item as a row, for a block that limits its rows itself (the sources block, five entries per source). */
+/** Every item as a row, each folded to one line unless expanded; the block limits its rows itself (five per source). */
 export const allBlockRows = (
   items: readonly BlockItem[],
   expandedKeys: ReadonlySet<string>,
   width: number,
 ): BlockRow[] => items.map((item) => rowOf(item, expandedKeys, width))
 
-/** The rows the herd draws for what waits on the user. */
-export const waitingRows = (
-  items: readonly WaitingItem[],
-  expandedKeys: ReadonlySet<string>,
-  width: number,
-): BlockRow[] => blockRows(items.map(itemOf), expandedKeys, width, WAITING_MORE_KEY)
-
-/** The key of the `+<n>` line of a block with `count` points, null while the block has no more than it shows. */
-export const moreKeyOf = (count: number, key: string): string | null => (count > SHOWN_BLOCK_ROWS ? key : null)
-
 const rowAt = (
   rows: readonly BlockRow[],
   firstLine: number,

package/src/plans/watch-burst.ts

@@ -0,0 +1,25 @@
+import type { FetchState } from './fetch'
+
+/**
+ * How a refresh asked for outside the pace turns into one: a watched file (a plan written, `FETCH_HEAD` moved), the end
+ * of the herd's fetch, a new read of the pull requests. The first after a quiet spell waits only `debounceMs`, which
+ * bundles the several events of one write; any ask within `windowMs` after a refresh waits for the end of that window,
+ * so a burst of edits or fetches costs one refresh per window, not one per event.
+ */
+export const WATCH_BURST = { debounceMs: 150, windowMs: 5_000 } as const
+
+/** The wait before the refresh an ask at `now` gets, after the last refresh started at `lastRefreshAt`. */
+export const watchRefreshDelay = (lastRefreshAt: number | null, now: number): number =>
+  lastRefreshAt === null
+    ? WATCH_BURST.debounceMs
+    : Math.max(WATCH_BURST.debounceMs, lastRefreshAt + WATCH_BURST.windowMs - now)
+
+/**
+ * Whether a write to `FETCH_HEAD` at `modifiedAt` (epoch milliseconds) came from the herd's own fetch: one running, or
+ * the last that succeeded, between its start and its end. The herd refreshes once when its fetch ends, so that write
+ * asks for no refresh of its own; a fetch by anyone else still does.
+ */
+export const isOwnFetchWrite = (modifiedAt: number, { lastAttempt, lastSuccess, running }: FetchState): boolean => {
+  if (lastAttempt === null || modifiedAt < lastAttempt) return false
+  return running || (lastSuccess !== null && modifiedAt <= lastSuccess.getTime())
+}

package/src/plans/worktree-stamp.ts

@@ -0,0 +1,35 @@
+import { readFileSync, statSync } from 'node:fs'
+import { isAbsolute, join, resolve } from 'node:path'
+
+const GIT_DIRECTORY_LINE = /^gitdir:\s*(.+)$/m
+
+/** The git directory of `worktree`: `.git` itself in a main checkout, the directory its `.git` file names in a linked one. */
+const gitDirectoryOf = (worktree: string): string => {
+  const dotGit = join(worktree, '.git')
+  try {
+    if (statSync(dotGit).isDirectory()) return dotGit
+    const named = GIT_DIRECTORY_LINE.exec(readFileSync(dotGit, 'utf8'))?.[1]?.trim()
+    if (!named) return dotGit
+    return isAbsolute(named) ? named : resolve(worktree, named)
+  } catch {
+    return dotGit
+  }
+}
+
+const fileMark = (path: string): string => {
+  try {
+    const { mtimeMs, size } = statSync(path)
+    return `${mtimeMs}:${size}`
+  } catch {
+    return '-'
+  }
+}
+
+/**
+ * What tells whether a worktree's `git status` may have changed without asking git: its index and HEAD as stat-ed,
+ * and `activity` (`logMark` of its agent, its subagents' work). Stable for a worktree that does not exist.
+ */
+export const worktreeStamp = (worktree: string, activity: string): string => {
+  const gitDirectory = gitDirectoryOf(worktree)
+  return [fileMark(join(gitDirectory, 'index')), fileMark(join(gitDirectory, 'HEAD')), activity].join('|')
+}

package/src/plans/your-turn-rows.ts

@@ -0,0 +1,102 @@
+import { WAITING_KIND } from '../plan-format/waiting'
+import { fit, padVisible, spread } from '../terminal/text'
+import { textWidth } from '../terminal/width'
+import { appointmentButtons } from './appointment-rows'
+import { chevronOf, TURN_MARK } from './symbols'
+import {
+  ASK_GAP,
+  type BlockButton,
+  type BlockRow,
+  buttonsWidth,
+  placedButtons,
+  textRoom,
+  waitingButtons,
+  waitingUrl,
+} from './waiting-click'
+import { OLD_DAYS, TURN_KIND, type TurnPage, type TurnRow } from './your-turn'
+
+/** The key of the line under the now rows that shows them all, and of the one under the planned rows. */
+export const YOUR_TURN_MORE_KEY = 'more>yourTurn>now'
+export const YOUR_TURN_LATER_KEY = 'more>yourTurn>planned'
+
+/** The blanks between a row's text and its time column. */
+const TIME_GAP = 2
+const UNBLOCKS_INDENT = '  '
+
+const markOf = (row: TurnRow): string => {
+  if (row.kind === TURN_KIND.planned) return TURN_MARK.planned
+  return row.waiting?.kind === WAITING_KIND.file ? TURN_MARK.file : TURN_MARK.now
+}
+
+const buttonsOf = (row: TurnRow): BlockButton[] => {
+  if (row.appointment) return appointmentButtons(row.appointment)
+  return row.waiting ? waitingButtons(row.waiting) : []
+}
+
+/** The text cut to leave the time its column, the time flush right at `room`. */
+const firstLineOf = (mark: string, row: TurnRow, room: number): string => {
+  const textCells = Math.max(room - textWidth(row.time) - TIME_GAP, 1)
+  return spread(fit(`${mark} ${row.text}`, textCells), row.time, room)
+}
+
+/**
+ * A topic as a block row: the mark, the text and the time flush right at the edge of the text room, which every row
+ * of the block shares (`room`), so the times end in one column before the buttons; under a row that frees lanes the
+ * dim line `unblocks …`. The buttons keep their columns whether drawn or not; the block draws them at the focused row.
+ */
+const rowOf = (row: TurnRow, room: number): BlockRow => {
+  const mark = markOf(row)
+  const first = firstLineOf(mark, row, room)
+  const unblocks = row.unblocks.length > 0 ? [fit(`${UNBLOCKS_INDENT}unblocks ${row.unblocks.join(', ')}`, room)] : []
+  const buttons = buttonsOf(row)
+  return {
+    key: row.key,
+    mark,
+    lines: [buttons.length > 0 ? padVisible(first, room + ASK_GAP) : first, ...unblocks],
+    cut: false,
+    expanded: false,
+    url: row.waiting ? waitingUrl(row.waiting) : null,
+    buttons: placedButtons(buttons, room),
+    dimFrom: [first.length - row.time.length, ...unblocks.map(() => 0)],
+  }
+}
+
+/** `▸ 23 more · 9 older than 7 days`, `▸ 2 later`: a dim line that a click opens and folds. */
+const toggleRow = (key: string, text: string, open: boolean, room: number): BlockRow => {
+  const line = fit(`${chevronOf(open)} ${text}`, room)
+  return {
+    key,
+    mark: chevronOf(open),
+    lines: [line],
+    cut: false,
+    expanded: false,
+    url: null,
+    buttons: [],
+    dimFrom: [0],
+    toggle: key,
+  }
+}
+
+const moreText = ({ count, older }: { count: number; older: number }): string =>
+  older > 0 ? `${count} more · ${older} older than ${OLD_DAYS} days` : `${count} more`
+
+/** The cells of text every row of the block may take: what the widest set of buttons leaves of the pane. */
+const sharedRoom = (rows: readonly TurnRow[], width: number): number =>
+  textRoom(width, Math.max(0, ...rows.map((row) => buttonsWidth(buttonsOf(row)))))
+
+/**
+ * The rows of the open "Your turn" block: the now rows, the line for the rest of them, the planned rows and the line
+ * for the later ones; an opened line points down at the rest of its rows, which stand below it.
+ */
+export const turnRows = (page: TurnPage, width: number): BlockRow[] => {
+  const { opened } = page
+  const room = sharedRoom([...page.now, ...page.nowRest, ...page.planned, ...page.plannedRest], width)
+  return [
+    ...page.now.map((row) => rowOf(row, room)),
+    ...(page.nowMore ? [toggleRow(YOUR_TURN_MORE_KEY, moreText(page.nowMore), opened.allNow, room)] : []),
+    ...page.nowRest.map((row) => rowOf(row, room)),
+    ...page.planned.map((row) => rowOf(row, room)),
+    ...(page.later > 0 ? [toggleRow(YOUR_TURN_LATER_KEY, `${page.later} later`, opened.allPlanned, room)] : []),
+    ...page.plannedRest.map((row) => rowOf(row, room)),
+  ]
+}