@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/cli/dashboard/facts.ts

@@ -0,0 +1,215 @@
+/**
+ * The facts a dashboard row reads from a build's event array, as an
+ * incremental reducer: the queued-row dispatch text, the session brackets, the
+ * per-phase wall-clock intervals, the pause timestamp, and the seqs of the four
+ * loop outputs. `projectBuildFromFacts` renders a row from these plus the
+ * reduced `BuildState`, so a row derives from a stored accumulator and a delta
+ * read with no event array, and `projectBuild(…, events, …)` is the same
+ * projection over `dashboardFactsReducer.reduce(events)` — one implementation,
+ * so the snapshot and replay paths agree by construction.
+ *
+ * The accumulator is plain JSON (see `kernel/incremental.ts`).
+ */
+import type { AbEvent } from '../../events/catalog'
+import { defineReducer } from '../../kernel/incremental'
+import { verifyPhase } from '../../ontology'
+
+export const DASHBOARD_FACTS_REDUCER_VERSION = 1
+
+/** One phase occurrence's wall-clock span, keyed by phase. `startSeq` is the
+ * seq of the `*.started` event, so callers can scope by the same seq
+ * boundaries (`restartSince`/`cycleSince`) the step STATES already use. */
+export interface PhaseInterval {
+  start: number
+  end: number
+  startSeq: number
+}
+
+export interface PhaseTiming {
+  closed: PhaseInterval[]
+  open?: { start: number; startSeq: number }
+}
+
+export interface DispatchFailureFact {
+  seq: number
+  stage: string
+  attempt: number
+  error: string
+}
+
+/** Max seq per round of one loop output event. */
+export type RoundSeqs = Record<string, number>
+
+type SessionEvent = Extract<AbEvent, { type: 'session.started' | 'session.ended' }>
+
+export interface DashboardFacts {
+  /** Seq of the latest event of each queued-row kind (`undefined` until seen). */
+  created?: number
+  workspaceProvisioned?: number
+  workspaceReleased?: number
+  specLanded?: number
+  commentPosted?: number
+  latestFailure?: DispatchFailureFact
+  /** The session brackets, in log order; `projectSessions` pairs them. */
+  sessionEvents: SessionEvent[]
+  intervals: Record<string, PhaseTiming>
+  /** Timestamp of the latest `build.paused`. */
+  pausedAt?: string
+  produced: {
+    planCompleted: RoundSeqs
+    planReviewVerdict: RoundSeqs
+    implementCompleted: RoundSeqs
+    codeReviewVerdict: RoundSeqs
+  }
+}
+
+/** Whether a loop output of `round` landed after `since` (the restart boundary). */
+export function producedAfter(seqs: RoundSeqs, round: number, since: number): boolean {
+  const seq = seqs[String(round)]
+  return seq !== undefined && seq > since
+}
+
+function raise(seqs: RoundSeqs, round: number, seq: number): void {
+  const key = String(round)
+  const current = seqs[key]
+  seqs[key] = current === undefined ? seq : Math.max(current, seq)
+}
+
+function foldInterval(intervals: Record<string, PhaseTiming>, ev: AbEvent): void {
+  const ms = Date.parse(ev.ts)
+  const get = (key: string): PhaseTiming => {
+    let t = intervals[key]
+    if (t === undefined) {
+      t = { closed: [] }
+      intervals[key] = t
+    }
+    return t
+  }
+  const open = (key: string): void => {
+    get(key).open = { start: ms, startSeq: ev.seq }
+  }
+  const close = (key: string): void => {
+    const t = get(key)
+    if (t.open === undefined) return
+    t.closed.push({ start: t.open.start, end: ms, startSeq: t.open.startSeq })
+    delete t.open
+  }
+  // Each `*.started` opens an interval for its phase key and its terminal event
+  // (`.completed`/`.verdict`) closes it. A second `*.started` while one is still
+  // open REPLACES the open start — a §15.6-C cross-sandbox re-run starts the
+  // phase afresh, so the crashed attempt contributes nothing. Finalize
+  // post-steps (`finalize.step-completed`) have no `.started` and no interval.
+  switch (ev.type) {
+    case 'plan.started':
+      open('plan')
+      break
+    case 'plan.completed':
+      close('plan')
+      break
+    case 'plan-review.started':
+      open('plan-review')
+      break
+    case 'plan-review.verdict':
+      close('plan-review')
+      break
+    case 'implement.started':
+      open('implement')
+      break
+    case 'implement.completed':
+      close('implement')
+      break
+    case 'code-review.started':
+      open('code-review')
+      break
+    case 'code-review.verdict':
+      close('code-review')
+      break
+    case 'verify.started':
+      open(verifyPhase(ev.payload.step))
+      break
+    case 'verify.completed':
+      close(verifyPhase(ev.payload.step))
+      break
+    case 'finalize.started':
+      open('finalize')
+      break
+    case 'finalize.completed':
+      close('finalize')
+      break
+    case 'reconcile.started':
+      open('reconcile')
+      break
+    case 'reconcile.completed':
+      close('reconcile')
+      break
+    default:
+      break
+  }
+}
+
+export const dashboardFactsReducer = defineReducer<DashboardFacts, AbEvent, DashboardFacts>({
+  version: DASHBOARD_FACTS_REDUCER_VERSION,
+  initial: () => ({
+    sessionEvents: [],
+    intervals: {},
+    produced: {
+      planCompleted: {},
+      planReviewVerdict: {},
+      implementCompleted: {},
+      codeReviewVerdict: {},
+    },
+  }),
+  fold(acc, events) {
+    for (const event of events) {
+      foldInterval(acc.intervals, event)
+      switch (event.type) {
+        case 'build.created':
+          acc.created = event.seq
+          break
+        case 'workspace.provisioned':
+          acc.workspaceProvisioned = event.seq
+          break
+        case 'workspace.released':
+          acc.workspaceReleased = event.seq
+          break
+        case 'spec.imported':
+        case 'spec.authored':
+          acc.specLanded = event.seq
+          break
+        case 'dispatch.comment-posted':
+          acc.commentPosted = event.seq
+          break
+        case 'dispatch.failed':
+          acc.latestFailure = {
+            seq: event.seq,
+            stage: event.payload.stage,
+            attempt: event.payload.attempt,
+            error: event.payload.error,
+          }
+          break
+        case 'session.started':
+        case 'session.ended':
+          acc.sessionEvents.push(event)
+          break
+        case 'build.paused':
+          acc.pausedAt = event.ts
+          break
+        case 'plan.completed':
+          raise(acc.produced.planCompleted, event.payload.round, event.seq)
+          break
+        case 'plan-review.verdict':
+          raise(acc.produced.planReviewVerdict, event.payload.round, event.seq)
+          break
+        case 'implement.completed':
+          raise(acc.produced.implementCompleted, event.payload.round, event.seq)
+          break
+        case 'code-review.verdict':
+          raise(acc.produced.codeReviewVerdict, event.payload.round, event.seq)
+          break
+        default:
+          break
+      }
+    }
+  },
+  finish: (acc) => structuredClone(acc),
+})

package/packages/core/src/cli/dashboard/frame-parse.ts

@@ -0,0 +1,223 @@
+import { graphemes } from './cells'
+
+/**
+ * Deterministic parsing of a rendered dashboard frame.
+ *
+ * The dashboard deliberately emits a tiny terminal vocabulary: SGR reset,
+ * bold/dim and six named foreground colours, plus OSC 8 hyperlinks. This
+ * parser accepts exactly that vocabulary and nothing else. Unknown control
+ * traffic is an error rather than evidence that merely looks plausible after
+ * bytes were dropped. Every rendition of a frame — the PNG evidence, the
+ * website's HTML — derives from these same exact cells.
+ */
+
+const ESC = '\x1b'
+const BEL = '\x07'
+
+export type Foreground = 'foreground' | 'red' | 'green' | 'yellow' | 'blue' | 'cyan'
+
+export interface FrameStyle {
+  foreground: Foreground
+  bold: boolean
+  dim: boolean
+  href?: string
+}
+
+export interface FrameRun {
+  /** Zero-based terminal cell column the run starts at. */
+  column: number
+  /** Terminal cells the run occupies. */
+  cells: number
+  text: string
+  style: FrameStyle
+}
+
+export interface ParsedFrameLine {
+  /** The line with every escape removed. */
+  text: string
+  /** Terminal cells the whole line occupies. */
+  cells: number
+  runs: FrameRun[]
+}
+
+function cloneStyle(style: FrameStyle): FrameStyle {
+  return {
+    foreground: style.foreground,
+    bold: style.bold,
+    dim: style.dim,
+    ...(style.href !== undefined ? { href: style.href } : {}),
+  }
+}
+
+function sameStyle(left: FrameStyle, right: FrameStyle): boolean {
+  return (
+    left.foreground === right.foreground &&
+    left.bold === right.bold &&
+    left.dim === right.dim &&
+    left.href === right.href
+  )
+}
+
+function applySgr(style: FrameStyle, raw: string, line: number): void {
+  const codes = raw === '' ? [0] : raw.split(';').map((part) => Number(part))
+  if (codes.some((code) => !Number.isInteger(code))) {
+    throw new Error(`dashboard frame line ${line}: malformed SGR sequence ESC[${raw}m`)
+  }
+  for (const code of codes) {
+    switch (code) {
+      case 0:
+        style.foreground = 'foreground'
+        style.bold = false
+        style.dim = false
+        break
+      case 1:
+        style.bold = true
+        break
+      case 2:
+        style.dim = true
+        break
+      case 22:
+        style.bold = false
+        style.dim = false
+        break
+      case 31:
+        style.foreground = 'red'
+        break
+      case 32:
+        style.foreground = 'green'
+        break
+      case 33:
+        style.foreground = 'yellow'
+        break
+      case 34:
+        style.foreground = 'blue'
+        break
+      case 36:
+        style.foreground = 'cyan'
+        break
+      case 39:
+        style.foreground = 'foreground'
+        break
+      default:
+        throw new Error(`dashboard frame line ${line}: unsupported SGR code ${code} in ESC[${raw}m`)
+    }
+  }
+}
+
+/** Parse one rendered line into styled runs pinned to their terminal cells.
+ * `lineNumber` is one-based and only names the line in errors. */
+export function parseFrameLine(value: string, lineNumber: number): ParsedFrameLine {
+  const style: FrameStyle = {
+    foreground: 'foreground',
+    bold: false,
+    dim: false,
+  }
+  const runs: FrameRun[] = []
+  let text = ''
+  let cells = 0
+
+  const append = (cluster: string, width: number): void => {
+    const previous = runs.at(-1)
+    // ASCII runs may coalesce. Unicode clusters stay independently pinned to
+    // their terminal cell columns so font fallback/advance cannot shift the
+    // run that follows a wide glyph.
+    if (
+      previous !== undefined &&
+      previous.column + previous.cells === cells &&
+      /^[\x20-\x7e]*$/.test(previous.text) &&
+      /^[\x20-\x7e]$/.test(cluster) &&
+      sameStyle(previous.style, style)
+    ) {
+      previous.text += cluster
+      previous.cells += width
+    } else {
+      runs.push({ column: cells, cells: width, text: cluster, style: cloneStyle(style) })
+    }
+    text += cluster
+    cells += width
+  }
+
+  for (let index = 0; index < value.length; ) {
+    if (value[index] === ESC) {
+      const family = value[index + 1]
+      if (family === '[') {
+        const rest = value.slice(index + 2)
+        const match = /^([0-9;]*)m/.exec(rest)
+        if (match === null) {
+          throw new Error(
+            `dashboard frame line ${lineNumber}: unsupported or unterminated CSI sequence`,
+          )
+        }
+        applySgr(style, match[1]!, lineNumber)
+        index += 2 + match[0].length
+        continue
+      }
+      if (family === ']') {
+        const end = value.indexOf(BEL, index + 2)
+        if (end === -1) {
+          throw new Error(`dashboard frame line ${lineNumber}: unterminated OSC sequence`)
+        }
+        const payload = value.slice(index + 2, end)
+        const match = /^8;;(.*)$/.exec(payload)
+        if (match === null) {
+          throw new Error(
+            `dashboard frame line ${lineNumber}: unsupported OSC sequence ${JSON.stringify(payload)}`,
+          )
+        }
+        const href = match[1]!
+        style.href = href === '' ? undefined : href
+        index = end + 1
+        continue
+      }
+      throw new Error(
+        `dashboard frame line ${lineNumber}: unsupported escape family ${JSON.stringify(family ?? '')}`,
+      )
+    }
+
+    const nextEscape = value.indexOf(ESC, index)
+    const stop = nextEscape === -1 ? value.length : nextEscape
+    const plain = value.slice(index, stop)
+    for (const character of plain) {
+      const code = character.codePointAt(0)!
+      if (code < 0x20 || code === 0x7f || (code >= 0x80 && code <= 0x9f)) {
+        throw new Error(
+          `dashboard frame line ${lineNumber}: unsupported control U+${code
+            .toString(16)
+            .toUpperCase()
+            .padStart(4, '0')}`,
+        )
+      }
+    }
+    for (const cluster of graphemes(plain)) append(cluster.text, cluster.width)
+    index = stop
+  }
+
+  if (style.href !== undefined) {
+    throw new Error(`dashboard frame line ${lineNumber}: OSC 8 hyperlink was not closed`)
+  }
+  if (style.foreground !== 'foreground' || style.bold || style.dim) {
+    throw new Error(
+      `dashboard frame line ${lineNumber}: SGR style was not reset before end of line`,
+    )
+  }
+  return { text, cells, runs }
+}
+
+/** Parse a whole frame, holding every line to the declared terminal width. */
+export function parseFrame(lines: readonly string[], columns: number): ParsedFrameLine[] {
+  if (!Number.isInteger(columns) || columns <= 0) {
+    throw new Error(`dashboard frame columns must be a positive integer, got ${columns}`)
+  }
+  if (lines.length === 0) {
+    throw new Error('dashboard frame is empty')
+  }
+  const parsed = lines.map((line, index) => parseFrameLine(line, index + 1))
+  for (const [index, line] of parsed.entries()) {
+    if (line.cells > columns) {
+      throw new Error(
+        `dashboard frame line ${index + 1} is ${line.cells} cells wide, exceeding declared terminal width ${columns}`,
+      )
+    }
+  }
+  return parsed
+}