jackherd 1.10.0 → 1.11.1

package/src/plan-format/waiting.ts

@@ -12,6 +12,10 @@ export type WaitingItem = {
   since: string
   item: string
   open: boolean
+  /** The board row's origin cell, one line; absent when the table has no such column or the cell is empty. */
+  origin?: string
+  /** What the herd shows before the item (the label of the source the row came from); set by the herd, never read from the board. */
+  prefix?: string
   /** A `file:` address the item links to, for a sent file; absent for a row of the board. */
   url?: string
   /** Absent for a row of the board. */
@@ -30,7 +34,7 @@ const isOpen = (status: string, language: PlanLanguage): boolean => {
 
 /**
  * The rows of the board's waiting section in `language` (`## Wartet auf dich`, `## Waiting for you`), its columns
- * found by their header names in any order; the origin column is not read. A table without the since, item or status
+ * found by their header names in any order; the origin column is read when the table has it and the cell is not empty. A table without the since, item or status
  * column, a section without a table and a row without an item give nothing.
  */
 export const readWaitingItems = (board: string, language: PlanLanguage): WaitingItem[] => {
@@ -40,11 +44,20 @@ export const readWaitingItems = (board: string, language: PlanLanguage): Waiting
   const positions = [columns.since, columns.item, statusName].map((name) => header.indexOf(name))
   if (positions.includes(-1)) return []
   const [since, item, status] = positions
+  const originPosition = header.indexOf(columns.origin)
   return rows.flatMap((cells) => {
     const text = oneLine(cells[item] ?? '')
+    const origin = oneLine(cells[originPosition] ?? '')
     return text === ''
       ? []
-      : [{ since: oneLine(cells[since] ?? ''), item: text, open: isOpen(cells[status] ?? '', language) }]
+      : [
+          {
+            since: oneLine(cells[since] ?? ''),
+            item: text,
+            open: isOpen(cells[status] ?? '', language),
+            ...(origin === '' ? {} : { origin }),
+          },
+        ]
   })
 }
 

package/src/plans/appointment-rows.ts

@@ -1,13 +1,15 @@
-import { twoDigits } from '../plan-format/clock'
+import { DAY_MS, twoDigits } from '../plan-format/clock'
 import { padVisible } from '../terminal/text'
 import { textWidth } from '../terminal/width'
 import type { PlanLanguage } from '../vocabulary'
 import { type Appointment, readAppointmentTable } from '../watch/appointments'
+import { ASK_KIND } from './ask-target'
+import { DONE_KIND } from './row-targets'
 import { shortTitle } from './task-name'
-import type { BlockItem } from './waiting-click'
+import { type BlockButton, type BlockItem, DONE_BUTTON, MOVE_BUTTON, RUN_BUTTON } from './waiting-click'
 
 /** An open appointment as the herd shows it: `label` is the weekday and the time, `Mon 09:03` (the weekday is English whatever the board's language); `key` is the watcher's. */
-export type AppointmentRow = { key: string; label: string; action: string }
+export type AppointmentRow = { key: string; when: string; label: string; action: string }
 
 /** The appointment block: the open rows, the earliest first. */
 export type AppointmentBlock = { rows: AppointmentRow[] }
@@ -18,11 +20,26 @@ const WEEKDAY_LOCALE = 'en-US'
 
 const weekdayOf = (when: Date): string => new Intl.DateTimeFormat(WEEKDAY_LOCALE, { weekday: 'short' }).format(when)
 
-const rowOf = ({ when, action, key }: Appointment): AppointmentRow => ({
-  key,
-  label: `${weekdayOf(when)} ${twoDigits(when.getHours())}:${twoDigits(when.getMinutes())}`,
-  action,
-})
+const DATE_FROM_DAYS_AHEAD = 7
+
+const startOfDay = (when: Date): number => new Date(when.getFullYear(), when.getMonth(), when.getDate()).getTime()
+
+const daysAhead = (when: Date, now: Date): number => Math.round((startOfDay(when) - startOfDay(now)) / DAY_MS)
+
+/** The weekday names a day within the week; from a week on it is the date, `13.01.`, since the weekday would repeat. */
+const dayOf = (when: Date, now: Date): string =>
+  daysAhead(when, now) >= DATE_FROM_DAYS_AHEAD
+    ? `${twoDigits(when.getDate())}.${twoDigits(when.getMonth() + 1)}.`
+    : weekdayOf(when)
+
+const rowOf =
+  (now: Date) =>
+  ({ when, whenText, action, key }: Appointment): AppointmentRow => ({
+    key,
+    when: whenText,
+    label: `${dayOf(when, now)} ${twoDigits(when.getHours())}:${twoDigits(when.getMinutes())}`,
+    action,
+  })
 
 /**
  * The open appointments of the board's section, read as the watcher reads them, the earliest first. A done row, a
@@ -32,7 +49,7 @@ export const appointmentRows = (board: string, language: PlanLanguage, now: Date
   readAppointmentTable(board, language, now)
     .appointments.filter(({ open }) => open)
     .sort((left, right) => left.when.getTime() - right.when.getTime())
-    .map(rowOf)
+    .map(rowOf(now))
 
 /** The block of the board's open appointments, as the herd shows them. */
 export const appointmentBlock = (board: string, language: PlanLanguage, now: Date): AppointmentBlock => ({
@@ -41,7 +58,13 @@ export const appointmentBlock = (board: string, language: PlanLanguage, now: Dat
 
 const appointmentKey = ({ key }: AppointmentRow): string => `appointment>${key}`
 
-/** The rows as the block draws them; a click on one only expands it, so they carry no address and no question. */
+const buttonsOf = ({ when, action }: AppointmentRow): BlockButton[] => [
+  { label: DONE_BUTTON, click: { done: { kind: DONE_KIND.appointment, when, action } } },
+  { label: RUN_BUTTON, click: { ask: { kind: ASK_KIND.appointmentRun, when, action } } },
+  { label: MOVE_BUTTON, click: { ask: { kind: ASK_KIND.appointmentMove, when, action } } },
+]
+
+/** The rows as the block draws them; a click on the row only expands it, the buttons close it, run it or move it. */
 export const appointmentItems = (rows: readonly AppointmentRow[]): BlockItem[] => {
   const timeWidth = Math.max(0, ...rows.map(({ label }) => textWidth(label)))
   return rows.map((row) => ({
@@ -52,6 +75,7 @@ export const appointmentItems = (rows: readonly AppointmentRow[]): BlockItem[] =
     title: shortTitle(row.action),
     url: null,
     ask: null,
+    buttons: buttonsOf(row),
   }))
 }
 

package/src/plans/ask-coordinator.ts

@@ -17,34 +17,68 @@ export type AskDependencies = {
   run: HerdrRunner
 }
 
-type AskSentences = { question: (id: string) => string; boardRow: (key: string) => string }
+/** A sentence takes the subject's key and, for an entry of a source, the source it belongs to (else `''`). */
+type AskSentences = Record<AskTarget['kind'], (subject: string, scope: string) => string>
 
 const ASK_LINES: Record<PlanLanguage, AskSentences> = {
   [PLAN_LANGUAGE.de]: {
-    question: (id) => `Stell mir die offene Frage ${id} jetzt (jh waiting).`,
-    boardRow: (key) => `Stell mir die offene Board-Zeile \`${key}\` jetzt (jh waiting).`,
+    [ASK_KIND.question]: (id) => `Stell mir die offene Frage ${id} jetzt (jh waiting).`,
+    [ASK_KIND.boardRow]: (key) => `Stell mir die offene Board-Zeile \`${key}\` jetzt (jh waiting).`,
+    [ASK_KIND.appointmentRun]: (key) => `Führe den Termin \`${key}\` jetzt aus, unter den Freigaben, die er braucht.`,
+    [ASK_KIND.appointmentMove]: (key) =>
+      `Frag den User per Dialog nach der neuen Zeit für den Termin \`${key}\` und trag sie ins Board ein (verschobene Zeile = neuer Termin).`,
+    [ASK_KIND.sourceEntry]: (title, source) =>
+      `Sieh dir die Meldung \`${title}\` der Quelle \`${source}\` an und stell mir, falls nötig, die Frage dazu (jh waiting).`,
   },
   [PLAN_LANGUAGE.en]: {
-    question: (id) => `Ask me the open question ${id} now (jh waiting).`,
-    boardRow: (key) => `Ask me the open board row \`${key}\` now (jh waiting).`,
+    [ASK_KIND.question]: (id) => `Ask me the open question ${id} now (jh waiting).`,
+    [ASK_KIND.boardRow]: (key) => `Ask me the open board row \`${key}\` now (jh waiting).`,
+    [ASK_KIND.appointmentRun]: (key) => `Run the appointment \`${key}\` now, under the approvals it needs.`,
+    [ASK_KIND.appointmentMove]: (key) =>
+      `Ask the user in a dialog for the new time of the appointment \`${key}\` and write it into the board (a moved row is a new appointment).`,
+    [ASK_KIND.sourceEntry]: (title, source) =>
+      `Look at the report \`${title}\` of the source \`${source}\` and, if it needs it, put the question about it to me (jh waiting).`,
   },
 }
 
+/** What the sentence names: the id of a question, else the sanitised key of the row (`boardRowKey`). */
+const subjectKeyOf = (target: AskTarget): string => {
+  if (target.kind === ASK_KIND.question) return target.id
+  if (target.kind === ASK_KIND.sourceEntry) return boardRowKey('', target.title)
+  return target.kind === ASK_KIND.boardRow
+    ? boardRowKey(target.since, target.item)
+    : boardRowKey(target.when, target.action)
+}
+
+/** The source of an entry, sanitised like the key; `''` for every other target. */
+const scopeOf = (target: AskTarget): string =>
+  target.kind === ASK_KIND.sourceEntry ? boardRowKey('', target.source) : ''
+
 /**
  * The line sent to the coordinator: a fixed sentence that carries the id of a question, or the sanitised key of a
- * board row (`boardRowKey`), and nothing else from the board or the question, so a prompt line cannot be steered by
+ * row (`boardRowKey`), and nothing else from the board or the question, so a prompt line cannot be steered by
  * the file it reads. The caller checks the id with `isQuestionId`.
  */
 export const askLine = (target: AskTarget, language: PlanLanguage): string =>
-  target.kind === ASK_KIND.question
-    ? ASK_LINES[language].question(target.id)
-    : ASK_LINES[language].boardRow(boardRowKey(target.since, target.item))
+  ASK_LINES[language][target.kind](subjectKeyOf(target), scopeOf(target))
 
 const isAskable = (target: AskTarget): boolean =>
-  target.kind === ASK_KIND.question ? isQuestionId(target.id) : boardRowKey(target.since, target.item) !== ''
+  target.kind === ASK_KIND.question
+    ? isQuestionId(target.id)
+    : subjectKeyOf(target) !== '' && (target.kind !== ASK_KIND.sourceEntry || scopeOf(target) !== '')
+
+const SUBJECT_NAMES: Record<AskTarget['kind'], string> = {
+  [ASK_KIND.question]: 'question',
+  [ASK_KIND.boardRow]: 'board row',
+  [ASK_KIND.appointmentRun]: 'appointment',
+  [ASK_KIND.appointmentMove]: 'appointment',
+  [ASK_KIND.sourceEntry]: 'report',
+}
 
-const subjectOf = (target: AskTarget): string =>
-  target.kind === ASK_KIND.question ? `question ${target.id}` : `board row ${boardRowKey(target.since, target.item)}`
+const subjectOf = (target: AskTarget): string => {
+  const scope = scopeOf(target)
+  return `${SUBJECT_NAMES[target.kind]} ${subjectKeyOf(target)}${scope === '' ? '' : ` of ${scope}`}`
+}
 
 const agentNamesOf = (run: HerdrRunner): string[] => parseAgentList(run(['agent', 'list'])).map(({ name }) => name)
 

package/src/plans/ask-target.ts

@@ -1,11 +1,22 @@
 import { ellipsize, terminalSafe } from '../plan-format/terminal-text'
 
-/** What the coordinator can be asked to put to the user: an open dialog question, or an open row of the board. */
-export const ASK_KIND = { question: 'question', boardRow: 'boardRow' } as const
+/**
+ * What the coordinator can be asked: to put an open dialog question or an open board row to the user, to run an
+ * appointment now, or to ask the user for a new time for it.
+ */
+export const ASK_KIND = {
+  question: 'question',
+  boardRow: 'boardRow',
+  appointmentRun: 'appointmentRun',
+  appointmentMove: 'appointmentMove',
+  sourceEntry: 'sourceEntry',
+} as const
 
 export type AskTarget =
   | { kind: typeof ASK_KIND.question; id: string }
   | { kind: typeof ASK_KIND.boardRow; since: string; item: string }
+  | { kind: typeof ASK_KIND.appointmentRun | typeof ASK_KIND.appointmentMove; when: string; action: string }
+  | { kind: typeof ASK_KIND.sourceEntry; source: string; title: string }
 
 /** The longest key a prompt line carries for a board row, the ellipsis included. */
 export const MAX_ROW_KEY_LENGTH = 120

package/src/plans/board-close.ts

@@ -0,0 +1,85 @@
+import { twoDigits } from '../plan-format/clock'
+import { firstTableRows, sectionLines, sectionStart } from '../plan-format/markdown'
+import { APPOINTMENT_VOCABULARY, PLAN_LANGUAGE, type PlanLanguage, WAITING_VOCABULARY } from '../vocabulary'
+
+type SectionColumns = {
+  heading: string
+  /** The header names of the two cells that identify a row, then the names that count as the status column. */
+  keys: readonly [string, string]
+  status: readonly string[]
+}
+
+const DONE_WORD: Record<PlanLanguage, string> = { [PLAN_LANGUAGE.de]: 'erledigt', [PLAN_LANGUAGE.en]: 'done' }
+
+/** The status a closed row gets, `erledigt (User <date> <time>)`: the time comes from `now`, never from an estimate. */
+export const doneStatus = (language: PlanLanguage, now: Date): string =>
+  `${DONE_WORD[language]} (User ${twoDigits(now.getDate())}.${twoDigits(now.getMonth() + 1)}. ${twoDigits(now.getHours())}:${twoDigits(now.getMinutes())})`
+
+const squeezed = (text: string): string => text.replace(/\s+/g, ' ').trim()
+
+const waitingColumns = (language: PlanLanguage): SectionColumns => {
+  const { heading, columns, statusAlso } = WAITING_VOCABULARY[language]
+  return { heading, keys: [columns.since, columns.item], status: [columns.status, ...statusAlso] }
+}
+
+const appointmentColumns = (language: PlanLanguage): SectionColumns => {
+  const { heading, columns, statusAlso } = APPOINTMENT_VOCABULARY[language]
+  return { heading, keys: [columns.when, columns.action], status: [columns.status, ...statusAlso] }
+}
+
+/** The line with the status cell (the `index`th between the bars) replaced; the other cells keep their text as written. */
+const withStatus = (line: string, index: number, status: string): string => {
+  const parts = line.split('|')
+  if (index + 1 >= parts.length) return line
+  parts[index + 1] = ` ${status} `
+  return parts.join('|')
+}
+
+/**
+ * The board with the status cell of the first row of the section's table whose two key cells equal `keys` replaced by
+ * `status`; null when the section, a column or the row is missing, so a row the board lost since the herd drew it
+ * writes nothing.
+ */
+const closeRow = (
+  board: string,
+  { heading, keys: keyNames, status: statusNames }: SectionColumns,
+  keys: readonly [string, string],
+  status: string,
+): string | null => {
+  const start = sectionStart(board, heading)
+  if (start === -1) return null
+  const lines = sectionLines(board, heading)
+  const header = lines.find((line) => line.startsWith('|'))
+  if (!header) return null
+  const names = header
+    .slice(1, header.endsWith('|') ? -1 : undefined)
+    .split('|')
+    .map((cell) => cell.trim())
+  const positions = keyNames.map((name) => names.indexOf(name))
+  const statusAt = names.findIndex((name) => statusNames.includes(name))
+  if (positions.includes(-1) || statusAt === -1) return null
+  const row = firstTableRows(lines).find(({ cells }) =>
+    positions.every((position, index) => squeezed(cells[position] ?? '') === squeezed(keys[index])),
+  )
+  if (!row) return null
+  const all = board.split('\n')
+  const at = start + row.index
+  all[at] = withStatus(all[at], statusAt, status)
+  return all.join('\n')
+}
+
+/** The board with the waiting row `since`/`item` closed at `now`; null when the board has no such row. */
+export const closeWaitingRow = (
+  board: string,
+  language: PlanLanguage,
+  { since, item }: { since: string; item: string },
+  now: Date,
+): string | null => closeRow(board, waitingColumns(language), [since, item], doneStatus(language, now))
+
+/** The board with the appointment `when`/`action` closed at `now`; null when the board has no such row. */
+export const closeAppointmentRow = (
+  board: string,
+  language: PlanLanguage,
+  { when, action }: { when: string; action: string },
+  now: Date,
+): string | null => closeRow(board, appointmentColumns(language), [when, action], doneStatus(language, now))

package/src/plans/frame.ts

@@ -1,4 +1,5 @@
-import { BAR_SEGMENT, INVERSE_ON, paint, RESET, stripAnsi, visibleLength } from '../terminal/text'
+import { paint, visibleLength } from '../terminal/text'
+import { focusLine, isFocused } from './row-focus'
 import type { ClickTarget, Selection } from './selection'
 
 /**
@@ -73,17 +74,9 @@ const branches = (children: Frame[]): Frame[] => {
 export const nest = (children: Frame[]): Frame => joinFrames(branches(children))
 
 /**
- * A row drawn inverse across the pane. A progress bar inside it is switched back to normal video: inverted,
- * its filled and empty blocks would trade places with the background and the bar would be unreadable.
+ * A selectable row: drawn with the focus background and mark (`focusLine`) when selected or under the mouse, clickable
+ * across the pane on every line, `below` follows unselectable. Only the selected row holds the cursor.
  */
-const highlight = (line: string, width: number): string => {
-  const bars = line.match(BAR_SEGMENT) ?? []
-  const texts = line.split(BAR_SEGMENT).map(stripAnsi)
-  const body = texts.map((text, index) => `${text}${bars[index] ? `${bars[index]}${INVERSE_ON}` : ''}`).join('')
-  return `${INVERSE_ON}${body}${' '.repeat(Math.max(width - visibleLength(line), 0))}${RESET}`
-}
-
-/** A selectable row: drawn inverse when selected, clickable across the pane on every line, `below` follows unselectable. */
 export const rowFrame = (
   key: string,
   rows: string[],
@@ -92,7 +85,7 @@ export const rowFrame = (
 ): Frame => {
   const selected = state.selected === key
   return {
-    lines: [...(selected ? rows.map((row) => highlight(row, width)) : rows), ...below],
+    lines: [...(isFocused(state, key) ? rows.map((row, index) => focusLine(row, width, index === 0)) : rows), ...below],
     cursorLine: selected ? 0 : -1,
     targets: rows.map((_, line) => ({ line, from: 0, to: width, key, wholeLine: true as const })),
   }

package/src/plans/git.ts

@@ -32,6 +32,41 @@ export const showAtRef = (root: string, ref: string, path: string): string | nul
 export const commitOf = (root: string, ref: string): string | null =>
   git(root, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`])
 
+const lastChangeAt = (root: string, commit: string, path: string): number | null => {
+  const seconds = Number(git(root, ['log', '-1', '--format=%ct', commit, '--', path]))
+  return Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : null
+}
+
+/** The last-change times read per `root\0commit`, by path, the commit asked last at the end; a change at a commit never moves. */
+const cachedChanges = new Map<string, Map<string, number | null>>()
+
+const changesOf = (root: string, commit: string): Map<string, number | null> => {
+  const key = `${root}\0${commit}`
+  const changes = cachedChanges.get(key) ?? new Map<string, number | null>()
+  cachedChanges.delete(key)
+  cachedChanges.set(key, changes)
+  const oldest = cachedChanges.keys().next().value
+  if (cachedChanges.size > CACHED_COMMITS && oldest !== undefined) cachedChanges.delete(oldest)
+  return changes
+}
+
+/**
+ * A reader of the commit time, in epoch milliseconds, of the last commit at `ref` that changed a path; null when the
+ * ref or the file is unknown there. The commit is resolved once per reader and each answer is kept per commit, so a
+ * refresh while the ref stands costs one `git rev-parse`, and a moved ref reads afresh.
+ */
+export const lastChangeReaderOf = (root: string, ref: string): ((path: string) => number | null) => {
+  const commit = commitOf(root, ref)
+  if (commit === null) return () => null
+  const changes = changesOf(root, commit)
+  return (path) => {
+    if (changes.has(path)) return changes.get(path) ?? null
+    const at = lastChangeAt(root, commit, path)
+    changes.set(path, at)
+    return at
+  }
+}
+
 /** Reads files as they are at the base ref. */
 export type BaseReader = (path: string) => string | null
 

package/src/plans/groomed.ts

@@ -0,0 +1,27 @@
+import { DAY_MS } from '../plan-format/clock'
+import { APPOINTMENT_VOCABULARY, type PlanLanguage } from '../vocabulary'
+import { readAppointmentTable } from '../watch/appointments'
+
+const GROOMING_INTERVAL_DAYS = 7
+const STALE_FROM_DAYS = 8
+
+/**
+ * Whole days since the board was last groomed, or null when the board has no open grooming appointment. The
+ * coordinator moves that appointment a week on after each grooming, so the last one was a week before it. A time
+ * before that (a board never groomed on the clock) counts as 0.
+ */
+export const groomedDaysAgo = (board: string, language: PlanLanguage, now: Date): number | null => {
+  const word = APPOINTMENT_VOCABULARY[language].grooming
+  const next = readAppointmentTable(board, language, now)
+    .appointments.filter(({ open, action }) => open && action.toLowerCase().startsWith(word))
+    .sort((left, right) => left.when.getTime() - right.when.getTime())[0]
+  if (!next) return null
+  const groomedAt = next.when.getTime() - GROOMING_INTERVAL_DAYS * DAY_MS
+  return Math.max(Math.floor((now.getTime() - groomedAt) / DAY_MS), 0)
+}
+
+/** The header text; `stale` from eight days on, when the herd paints it amber. */
+export const groomedText = (days: number): { text: string; stale: boolean } => ({
+  text: days === 0 ? 'groomed today' : `groomed ${days}d ago`,
+  stale: days >= STALE_FROM_DAYS,
+})

package/src/plans/layout-phase.ts

@@ -177,8 +177,11 @@ export const taskFrame = (key: string, rows: string[], context: Pick<LaneContext
 const deferredRow = ({ text, target }: DeferredItem, width: number): string =>
   fit(paint.dim(`${DEFERRED_MARK} ${phaseLabel(target)} ${plain(text)}`), width)
 
-const tickedSummaryFrame = (count: number, phaseRowKey: string, width: number): Frame => ({
-  lines: [fit(paint.dim(`${chevronOf(false)} ${TEXTS.tickedSummary(count)}`), width)],
+/** The clickable line of a phase's ticked tasks: `▸ <n> ticked · …lists them`, or `▾ …folds them` above the listed ones. */
+const tickedSummaryFrame = (count: number, phaseRowKey: string, width: number, listed: boolean): Frame => ({
+  lines: [
+    fit(paint.dim(`${chevronOf(listed)} ${listed ? TEXTS.tickedFold(count) : TEXTS.tickedSummary(count)}`), width),
+  ],
   cursorLine: -1,
   targets: [{ line: 0, from: 0, to: width, key: tickedKey(phaseRowKey), wholeLine: true }],
 })
@@ -203,7 +206,7 @@ export const phaseChildren = (
   const framesWhere = (done: boolean): Frame[] =>
     phase.items.flatMap((item, index) => (item.done === done ? [frameOf(item, index)] : []))
   const tickedCount = phase.items.filter((item) => item.done).length
-  const summary = tickedCount > 0 ? [tickedSummaryFrame(tickedCount, phaseRowKey, width)] : []
+  const summary = tickedCount > 0 ? [tickedSummaryFrame(tickedCount, phaseRowKey, width, state.showDone)] : []
   const deferred = (phase.deferred ?? []).map((item) => textFrame([deferredRow(item, width)]))
-  return [...framesWhere(false), ...deferred, ...(state.showDone ? framesWhere(true) : summary)]
+  return [...framesWhere(false), ...deferred, ...summary, ...(state.showDone ? framesWhere(true) : [])]
 }