@marcomigozzi/trailhead 0.14.0 → 0.15.0

package/plugins/trailhead/hooks/mod/map-pane-view.ts

@@ -1,7 +1,7 @@
 // Pure view logic of the map pane: parse what `gh` printed, group the rows, word a
 // failure and an age, decide when a refresh may run. No engine calls here, so it is easy to test.
 import { fit } from './work-state-view'
-import type { BurndownHistory, BurndownIssue, MapInfo, MapSummary, PaneTicket, TicketState, TicketType } from '../../types'
+import type { BurndownHistory, BurndownIssue, DashboardRef, MapCounts, MapInfo, MapsRead, MapSummary, PaneTicket, TicketState, TicketType, UatParent } from '../../types'
 
 export const TICKET_TYPES: readonly TicketType[] = ['decision', 'research', 'prototype', 'build', 'bug', 'task']
 
@@ -10,6 +10,8 @@ export type ParsedTickets = { tickets: readonly PaneTicket[]; unverifiedCount: n
 export type TicketGroups = {
   frontier: readonly PaneTicket[]
   inProgress: readonly PaneTicket[]
+  uat: readonly PaneTicket[]
+  paused: readonly PaneTicket[]
   blocked: readonly PaneTicket[]
 }
 export type Failure = { error: unknown } | { exitCode: number; stderr: string }
@@ -53,15 +55,23 @@ const typeOf = (names: readonly string[]): TicketType | null => {
   return found === undefined ? null : (found.slice(LABEL_PREFIX.length) as TicketType)
 }
 
+// A paused label wins over blocked and in-progress: the ticket shows once, under Paused.
 const stateOf = (names: readonly string[], assignees: readonly string[]): TicketState =>
-  names.includes(`${LABEL_PREFIX}blocked`) ? 'blocked' : assignees.length > 0 ? 'in-progress' : 'frontier'
+  names.includes(`${LABEL_PREFIX}paused`)
+    ? 'paused'
+    : names.includes(`${LABEL_PREFIX}blocked`)
+      ? 'blocked'
+      : assignees.length > 0
+        ? 'in-progress'
+        : 'frontier'
 
 // Only an https link is kept; anything else would be drawn as plain text.
 const safeUrl = (raw: unknown): string => (typeof raw === 'string' && /^https:\/\//.test(raw) ? raw : '')
 
 // `gh issue list --json number,title,labels,assignees,url`. Unverified rows are
-// quarantined (counted, never listed); whiteboard rows do not belong to a map.
-export const parseTickets = (stdout: string): ParsedTickets | null => {
+// quarantined (counted, never listed); whiteboard rows do not belong to a map, and on the
+// whiteboard (`isWhiteboard`) only they are kept.
+export const parseTickets = (stdout: string, opts: { isWhiteboard?: boolean } = {}): ParsedTickets | null => {
   let raw: unknown
   try {
     raw = JSON.parse(stdout)
@@ -73,7 +83,8 @@ export const parseTickets = (stdout: string): ParsedTickets | null => {
   const named = rows.map(r => ({ r, names: labelNames(r.labels) }))
   const unverifiedCount = named.filter(({ names }) => names.includes(`${LABEL_PREFIX}unverified`)).length
   const tickets = named
-    .filter(({ names }) => !names.includes(`${LABEL_PREFIX}unverified`) && !names.includes(`${LABEL_PREFIX}whiteboard`))
+    .filter(({ names }) => !names.includes(`${LABEL_PREFIX}unverified`))
+    .filter(({ names }) => names.includes(`${LABEL_PREFIX}whiteboard`) === (opts.isWhiteboard === true))
     .map(({ r, names }): PaneTicket => {
       const assignees = logins(r.assignees)
       return {
@@ -83,11 +94,52 @@ export const parseTickets = (stdout: string): ParsedTickets | null => {
         state: stateOf(names, assignees),
         assignees,
         url: safeUrl(r.url),
+        isUat: names.includes(`${LABEL_PREFIX}uat`),
+        uatOf: null,
       }
     })
   return { tickets, unverifiedCount, isCapped: raw.length >= LIST_LIMIT }
 }
 
+// `gh issue list --label trailhead:uat ... --json number,body`: ticket number -> the parent its first
+// `UAT of:` line names, `[<name>](<url>/issues/<n>)` (or a bare `#<n>`, with an empty title). A row with
+// no such line, or an unreadable one, is skipped; not a list is unreadable (null).
+export const parseUatParents = (stdout: string): ReadonlyMap<number, UatParent> | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!Array.isArray(raw)) return null
+  const parents = new Map<number, UatParent>()
+  for (const r of raw.filter(isRecord)) {
+    if (!isPosInt(r.number) || typeof r.body !== 'string') continue
+    const line = r.body.split(/\r?\n/).find(l => l.startsWith('UAT of:'))
+    if (line === undefined) continue
+    const pointer = line.slice('UAT of:'.length).trim()
+    const link = /^\[([^\]]*)\]\(https:\/\/[^)\s]*\/issues\/(\d+)[^)]*\)/.exec(pointer)
+    const bare = /^#(\d+)\b/.exec(pointer)
+    const found = link !== null ? { number: Number(link[2]), title: flatten(link[1] as string) } : bare !== null ? { number: Number(bare[1]), title: '' } : null
+    if (found !== null && isPosInt(found.number)) parents.set(r.number, found)
+  }
+  return parents
+}
+
+// The tickets with the parent of each UAT one; a missing read leaves them as they are.
+export const withUatParents = (tickets: readonly PaneTicket[], parents: ReadonlyMap<number, UatParent> | null): readonly PaneTicket[] =>
+  parents === null ? tickets : tickets.map(t => (t.isUat ? { ...t, uatOf: parents.get(t.number) ?? null } : t))
+
+// The dim line under a UAT row, `tests <parent title> #<n>`, cut to the pane width; null without a parent.
+export const uatParentLine = (t: PaneTicket, columns: number): string | null => {
+  if (t.uatOf === null) return null
+  const suffix = ` #${t.uatOf.number}`
+  const prefix = 'tests'
+  if (t.uatOf.title === '') return fit(`${prefix}${suffix}`, columns)
+  const title = fit(t.uatOf.title, columns - prefix.length - 1 - suffix.length)
+  return `${prefix} ${title}${suffix}`
+}
+
 // Markdown emphasis, code ticks and links reduced to their text.
 const stripMarkdown = (line: string): string =>
   line
@@ -136,10 +188,73 @@ export const parseMaps = (stdout: string): readonly MapSummary[] | null => {
   return raw
     .filter(isRecord)
     .filter(r => isPosInt(r.number))
-    .map((r): MapSummary => ({ number: r.number as number, title: typeof r.title === 'string' ? flatten(r.title) : '' }))
+    .map((r): MapSummary => ({ number: r.number as number, title: typeof r.title === 'string' ? flatten(r.title) : '', counts: null }))
     .sort((a, b) => a.number - b.number)
 }
 
+const countsOf = (raw: unknown): MapCounts | null => {
+  if (!isRecord(raw)) return null
+  const { total, completed } = raw
+  if (!Number.isInteger(total) || !Number.isInteger(completed) || (total as number) < 0 || (completed as number) < 0) return null
+  return { open: Math.max(0, (total as number) - (completed as number)), total: total as number }
+}
+
+// A GraphQL `totalCount` as a count, else null.
+const totalOf = (raw: unknown): number | null =>
+  isRecord(raw) && Number.isInteger(raw.totalCount) && (raw.totalCount as number) >= 0 ? (raw.totalCount as number) : null
+
+// The whiteboard's open and total tickets; unusable (missing, negative, open above total) is unknown.
+const whiteboardOf = (repo: Record<string, unknown>): MapCounts | null => {
+  const open = totalOf(repo.whiteboardOpen)
+  const total = totalOf(repo.whiteboardAll)
+  return open === null || total === null || open > total ? null : { open, total }
+}
+
+// The GraphQL reply of the maps read: the open maps with their sub-issue counts, same row rules as
+// `parseMaps`, and the whiteboard's counts. A malformed summary keeps the row name-only; unusable
+// whiteboard fields leave only `whiteboard` null. Not that shape, or any `errors` (even next to
+// partial `data`), is unreadable: the caller falls back to the name-only list.
+export const parseMapsRead = (stdout: string): MapsRead | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!isRecord(raw) || 'errors' in raw || !isRecord(raw.data)) return null
+  const repo = raw.data.repository
+  const issues = isRecord(repo) ? repo.issues : null
+  const nodes = isRecord(issues) ? issues.nodes : null
+  if (!isRecord(repo) || !Array.isArray(nodes)) return null
+  const maps = nodes
+    .filter(isRecord)
+    .filter(r => isPosInt(r.number))
+    .map(
+      (r): MapSummary => ({
+        number: r.number as number,
+        title: typeof r.title === 'string' ? flatten(r.title) : '',
+        counts: countsOf(r.subIssuesSummary),
+      }),
+    )
+    .sort((a, b) => a.number - b.number)
+  return { maps, whiteboard: whiteboardOf(repo) }
+}
+
+// `gh issue list --label trailhead:dashboard --json number,url`: the pinned index, the lowest number
+// when there are several. `null` when unreadable; `{ ref: null }` when the repo has none yet.
+export const parseDashboard = (stdout: string): { ref: DashboardRef | null } | null => {
+  let raw: unknown
+  try {
+    raw = JSON.parse(stdout)
+  } catch {
+    return null
+  }
+  if (!Array.isArray(raw)) return null
+  const rows = raw.filter(isRecord).filter(r => isPosInt(r.number))
+  const first = rows.sort((a, b) => (a.number as number) - (b.number as number))[0]
+  return { ref: first === undefined ? null : { number: first.number as number, url: safeUrl(first.url) } }
+}
+
 // The map the pane draws: the one the person is viewing, else the active one.
 export const viewTarget = (active: number | null, viewed: number | null): number | null => viewed ?? active
 
@@ -161,17 +276,24 @@ export type MapRowLayout = {
   // Every map but the viewed one: a press shows it (the active one: back to active).
   isPressable: boolean
 }
-export type MapRowContext = { active: number | null; viewed: number | null; columns: number }
+// `isDashboard`: the dashboard is shown, so no map is viewed and every row is pressable.
+export type MapRowContext = { active: number | null; viewed: number | null; columns: number; isDashboard?: boolean }
 
 const ACTIVE_MARK = '● '
-const ACTIVE_ASIDE = ' active'
+const ACTIVE_LABEL = 'active'
+const ASIDE_SEP = ' · '
+
+// `<open> open / <total>`: the counts beside a map or the whiteboard.
+export const countsLabel = (c: MapCounts): string => `${c.open} open / ${c.total}`
 
 // What one row of the maps list draws, cut to the pane width (a pressable row is a Button).
 export const mapRowLayout = (m: MapSummary, ctx: MapRowContext): MapRowLayout => {
   const isActive = m.number === ctx.active
-  const isViewed = m.number === viewTarget(ctx.active, ctx.viewed)
+  const isViewed = ctx.isDashboard !== true && m.number === viewTarget(ctx.active, ctx.viewed)
   const mark = isActive ? ACTIVE_MARK : '  '
-  const aside = isActive ? ACTIVE_ASIDE : null
+  const parts = [m.counts === null ? null : countsLabel(m.counts), isActive ? ACTIVE_LABEL : null]
+  const shown = parts.filter((p): p is string => p !== null)
+  const aside = shown.length === 0 ? null : ` ${shown.join(ASIDE_SEP)}`
   const prefix = `#${m.number}`
   const isPressable = !isViewed
   const room = ctx.columns - mark.length - (aside?.length ?? 0) - (isPressable ? BUTTON_CHROME : 0) - prefix.length - 1
@@ -179,11 +301,34 @@ export const mapRowLayout = (m: MapSummary, ctx: MapRowContext): MapRowLayout =>
   return { mark, label: title === '' ? prefix : `${prefix} ${title}`, aside, isActive, isViewed, isPressable }
 }
 
+export type WhiteboardRowLayout = { mark: string; label: string; aside: string | null }
+const WHITEBOARD_LABEL = 'Whiteboard'
+
+// The Whiteboard row above the maps list: a Button with its counts beside it, name-only when they are
+// unknown or would not fit (the name is kept whole).
+export const whiteboardRowLayout = (counts: MapCounts | null, columns: number): WhiteboardRowLayout => {
+  const mark = '  '
+  const aside = counts === null ? null : ` ${countsLabel(counts)}`
+  const fits = aside !== null && mark.length + BUTTON_CHROME + WHITEBOARD_LABEL.length + aside.length <= columns
+  return { mark, label: WHITEBOARD_LABEL, aside: fits ? aside : null }
+}
+
+// The whiteboard heading with its counts over the listed (trusted) tickets; bare before the first good read.
+export const whiteboardHeading = (tickets: readonly PaneTicket[] | null, isCapped: boolean): string => {
+  if (tickets === null) return 'Whiteboard'
+  const open = isCapped ? `${LIST_LIMIT}+` : String(tickets.length)
+  return `Whiteboard · ${open} open · ${tickets.filter(t => t.assignees.length > 0).length} assigned`
+}
+
 const byNumber = (a: PaneTicket, b: PaneTicket) => a.number - b.number
 
+// Paused wins, then a UAT ticket (whatever its state), then the state: each ticket shows once.
+type Place = TicketState | 'uat'
+const placeOf = (t: PaneTicket): Place => (t.state === 'paused' ? 'paused' : t.isUat ? 'uat' : t.state)
+
 export const groupTickets = (tickets: readonly PaneTicket[]): TicketGroups => {
-  const of = (state: TicketState) => tickets.filter(t => t.state === state).sort(byNumber)
-  return { frontier: of('frontier'), inProgress: of('in-progress'), blocked: of('blocked') }
+  const of = (place: Place) => tickets.filter(t => placeOf(t) === place).sort(byNumber)
+  return { frontier: of('frontier'), inProgress: of('in-progress'), uat: of('uat'), paused: of('paused'), blocked: of('blocked') }
 }
 
 const errorText = (err: unknown): string => {
@@ -220,7 +365,7 @@ export const ageLabel = (ms: number): string => {
   return `${Math.floor(ms / 3_600_000)}h ago`
 }
 
-export type RowAside = { kind: 'work' | 'queued' | 'holder'; text: string }
+export type RowAside = { kind: 'work' | 'queued' | 'holder' | 'self'; text: string }
 export type RowLayout = {
   mark: string | null
   label: string
@@ -242,6 +387,10 @@ const MARK_PAD = '  '
 // A terminal Button draws `[ label ]`.
 const BUTTON_CHROME = 4
 
+// The dashboard header's button back to the map; the title before it gets the rest of the row.
+export const MAP_LABEL = 'map'
+export const headingRoom = (columns: number, label: string): number => Math.max(0, columns - label.length - BUTTON_CHROME - 1)
+
 const REFRESH_LABEL = 'refresh'
 const CLOSE_LABEL = 'close'
 // The gap between the refresh button and the status, and the one kept before the close button.
@@ -257,7 +406,11 @@ export const footerStatus = (status: string, columns: number): FooterStatus => {
   return Array.from(status).length <= room ? { text: status, isInline: true } : { text: fit(status, columns), isInline: false }
 }
 
-const asideOf = (t: PaneTicket, pendingWork: number | null): RowAside | null => {
+const SELF_ASIDE: RowAside = { kind: 'self', text: 'this session' }
+
+// The ticket in play says `this session`; otherwise a frontier row has its button and the rest their holder.
+const asideOf = (t: PaneTicket, pendingWork: number | null, isInPlay: boolean): RowAside | null => {
+  if (isInPlay) return SELF_ASIDE
   if (t.state === 'frontier') return pendingWork === t.number ? { kind: 'queued', text: 'queued' } : { kind: 'work', text: 'work' }
   return t.assignees.length === 0 ? null : { kind: 'holder', text: t.assignees.map(a => `@${a}`).join(' ') }
 }
@@ -268,7 +421,7 @@ const asideWidth = (a: RowAside | null): number =>
 // What one row draws, cut to the pane width: mark column, `#n title`, type, right-hand part.
 export const rowLayout = (t: PaneTicket, ctx: RowContext): RowLayout => {
   const mark = ctx.isInPlay ? MARK : ctx.hasMarkColumn ? MARK_PAD : null
-  const aside = asideOf(t, ctx.pendingWork)
+  const aside = asideOf(t, ctx.pendingWork, ctx.isInPlay)
   const type = t.type === null ? null : ` ${t.type}`
   const prefix = `#${t.number}`
   const room = ctx.columns - (mark?.length ?? 0) - asideWidth(aside) - (type?.length ?? 0) - prefix.length - 1