jackherd 1.10.0 → 1.11.0

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) : [])]
 }