@defrex/autobuild 0.8.0

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

@@ -0,0 +1,66 @@
+/** Pure stable-identity selection for every selectable dashboard row. */
+import type { DashboardModel, DashboardSelection } from './model'
+
+/** Render order is selection order: the always-present process-global row,
+ * optional repository harvest, then the model's already slug-sorted builds. */
+export function dashboardSelections(
+  model: Pick<DashboardModel, 'harvest' | 'builds'>,
+): DashboardSelection[] {
+  return [
+    { kind: 'global' },
+    ...(model.harvest !== undefined ? [{ kind: 'harvest' } as const] : []),
+    ...model.builds.map((build) => ({ kind: 'build' as const, slug: build.slug })),
+  ]
+}
+
+export function sameSelection(
+  left: DashboardSelection | undefined,
+  right: DashboardSelection | undefined,
+): boolean {
+  if (left === undefined || right === undefined) return left === right
+  return (
+    left.kind === right.kind &&
+    (left.kind === 'global' ||
+      left.kind === 'harvest' ||
+      (right.kind === 'build' && left.slug === right.slug))
+  )
+}
+
+export function initialSelection(
+  rows: readonly DashboardSelection[],
+): DashboardSelection | undefined {
+  return rows[0]
+}
+
+/** Move by one (or any supplied delta) without wrapping. */
+export function moveSelection(
+  rows: readonly DashboardSelection[],
+  selected: DashboardSelection | undefined,
+  delta: number,
+): DashboardSelection | undefined {
+  if (rows.length === 0) return undefined
+  const current = selected === undefined ? 0 : rows.findIndex((row) => sameSelection(row, selected))
+  const index = current === -1 ? 0 : current
+  const next = Math.max(0, Math.min(rows.length - 1, index + delta))
+  return rows[next]
+}
+
+/**
+ * Preserve the selected ROW across repaints, harvest appearance, and build
+ * re-sorts. If it disappears, its old row index chooses the successor now
+ * occupying that row, or the final predecessor when the old row was last.
+ * Only an empty list clears selection.
+ */
+export function reconcileSelection(
+  previousRows: readonly DashboardSelection[],
+  nextRows: readonly DashboardSelection[],
+  selected: DashboardSelection | undefined,
+): DashboardSelection | undefined {
+  if (nextRows.length === 0) return undefined
+  if (selected === undefined) return initialSelection(nextRows)
+  const retained = nextRows.find((row) => sameSelection(row, selected))
+  if (retained !== undefined) return retained
+  const oldIndex = previousRows.findIndex((row) => sameSelection(row, selected))
+  if (oldIndex === -1) return initialSelection(nextRows)
+  return nextRows[Math.min(oldIndex, nextRows.length - 1)]
+}

package/packages/core/src/cli/dashboard/session-feed.ts

@@ -0,0 +1,244 @@
+/**
+ * The session view's live-read cycle (SPEC §9): ONE module both controllers
+ * call, so the follow/close/fallback semantics cannot drift between the
+ * `DispatchLoop` (the wire-injected path the capture harness exercises) and
+ * `DispatchFrontend` (the production interactive path).
+ *
+ * `SessionStreamFeed.poll(view)` performs one immediate store read
+ * (`waitSeconds: 0` — the store waits only when `waitSeconds > 0`), so no read
+ * can hold a frame longer than the controller's poll interval, and the writer's
+ * 250 ms flush cadence puts new parts on screen within one poll. It returns the
+ * next view fields — appended parts, advanced `lastSeq`, status/outcome on
+ * close, the pruned-chunk artifact fallback, or an error message that the next
+ * poll retries — and never throws into the frame.
+ *
+ * The returned update carries the identity and `since` cursor it started from;
+ * `applySessionFeedUpdate` is the apply-fence: a read that raced an Escape, a
+ * session switch, or a newer apply is discarded instead of retargeting the
+ * view. The stored part sequence is only ever appended to — the view never
+ * rewrites history.
+ */
+import type { UIMessage } from 'ai'
+import type { StreamOutcome, StreamPart, StreamRead } from '../../store/streams/types'
+import type { SessionDashboardView } from './model'
+
+/** The read-only store surface the feed consumes (injected; no terminal). */
+export interface SessionFeedStore {
+  readStream(streamId: string, opts?: { since?: number; waitSeconds?: number }): Promise<StreamRead>
+  getArtifact(
+    slug: string,
+    kind: string,
+    rev?: number,
+  ): Promise<{
+    content: Uint8Array | string
+  } | null>
+}
+
+/** The mutable fields of a session view the feed may produce. */
+export interface SessionViewFields {
+  status: 'open' | 'closed'
+  outcome?: StreamOutcome
+  source:
+    | { kind: 'parts'; parts: StreamPart[]; lastSeq: number }
+    | { kind: 'document'; document: UIMessage[] }
+  error?: string
+}
+
+/** The identity-bearing result of one poll: `since` is the cursor the read
+ * started from (the parts `lastSeq`, or 0 for a document retry), and
+ * everything is applied only through the fence below. */
+export interface SessionFeedUpdate {
+  slug: string
+  sessionId: string
+  stream: string
+  since: number
+  /** Which source shape this update was polled from — the fence compares it
+   * against the current view so a read that raced a source switch is
+   * discarded. */
+  polledSource: 'parts' | 'document'
+  fields: SessionViewFields
+}
+
+/** The shape of a session view the feed polls. */
+export type PollableSessionView = SessionDashboardView
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function parseDocument(content: Uint8Array | string): UIMessage[] | undefined {
+  try {
+    const text = typeof content === 'string' ? content : new TextDecoder().decode(content)
+    const parsed: unknown = JSON.parse(text)
+    if (!Array.isArray(parsed)) return undefined
+    return parsed as UIMessage[]
+  } catch {
+    return undefined
+  }
+}
+
+export class SessionStreamFeed {
+  constructor(
+    private readonly store: SessionFeedStore,
+    private readonly slug: string,
+  ) {}
+
+  /** One immediate read cycle for the given view. Returns `undefined` when
+   * nothing changed (a document-source view is final; an open stream with no
+   * new chunks leaves the view alone). Errors are retained as view fields and
+   * retried by the next poll, never thrown. */
+  async poll(view: PollableSessionView): Promise<SessionFeedUpdate | undefined> {
+    // A finalized document is the end state; only a failed read of it retries.
+    if (view.source.kind === 'document' && view.error === undefined) return undefined
+
+    const polledSource = view.source.kind
+    const since = view.source.kind === 'parts' ? view.source.lastSeq : 0
+    const base: SessionViewFields = {
+      status: view.status,
+      ...(view.outcome !== undefined ? { outcome: view.outcome } : {}),
+      source: view.source,
+      ...(view.error !== undefined ? { error: view.error } : {}),
+    }
+    try {
+      const read = await this.store.readStream(this.streamId(view), { since, waitSeconds: 0 })
+
+      // A clean close appends no chunk, so a closed read with no new chunks
+      // is the normal close signal — not a reason to swap sources. When the
+      // view already holds part content, keep it: `error` and `abort` lines
+      // exist only on the parts path, and a failed artifact read must never
+      // turn a healthy view into an error view. The finalized-artifact
+      // fallback applies only when there is nothing to keep — a closed
+      // session opened to an empty (e.g. pruned) chunk log.
+      if (
+        read.status === 'closed' &&
+        read.chunks.length === 0 &&
+        view.source.kind === 'parts' &&
+        view.source.parts.length === 0
+      ) {
+        return await this.artifactFallback(view, base, since, polledSource, read)
+      }
+
+      // A document-source view only polls to retry a failed read; the
+      // finalized content is already in hand, so a successful read just
+      // clears the error and tracks the stream's status/outcome.
+      if (view.source.kind === 'document') {
+        const outcome = read.outcome ?? base.outcome
+        if (read.status === base.status && outcome === base.outcome && base.error === undefined)
+          return undefined
+        return this.update(view, since, polledSource, {
+          status: read.status,
+          ...(outcome !== undefined ? { outcome } : {}),
+          source: view.source,
+        })
+      }
+
+      const parts = view.source.kind === 'parts' ? [...view.source.parts] : []
+      let lastSeq = since
+      for (const chunk of read.chunks) {
+        parts.push(...chunk.parts)
+        if (chunk.seq > lastSeq) lastSeq = chunk.seq
+      }
+      const fields: SessionViewFields = {
+        status: read.status,
+        ...(read.outcome !== undefined ? { outcome: read.outcome } : {}),
+        source: { kind: 'parts', parts, lastSeq },
+      }
+      if (
+        read.chunks.length === 0 &&
+        read.status === base.status &&
+        read.outcome === base.outcome &&
+        base.error === undefined
+      ) {
+        return undefined
+      }
+      return this.update(view, since, polledSource, fields)
+    } catch (error) {
+      return this.update(view, since, polledSource, { ...base, error: errorMessage(error) })
+    }
+  }
+
+  /** Read the closed stream's deposited document artifact. A failed or absent
+   * read keeps the view's current content and carries the error for the next
+   * poll to retry. */
+  private async artifactFallback(
+    view: PollableSessionView,
+    base: SessionViewFields,
+    since: number,
+    polledSource: 'parts' | 'document',
+    read: StreamRead,
+  ): Promise<SessionFeedUpdate> {
+    try {
+      const artifact = await this.store.getArtifact(this.slug, `stream:${this.streamId(view)}`, 0)
+      const document = artifact === null ? undefined : parseDocument(artifact.content)
+      if (document === undefined) {
+        return this.update(view, since, polledSource, {
+          ...base,
+          status: 'closed',
+          ...(read.outcome !== undefined ? { outcome: read.outcome } : {}),
+          error:
+            artifact === null
+              ? `stream artifact stream:${this.streamId(view)} is not retrievable`
+              : 'stream artifact is not a readable session document',
+        })
+      }
+      return this.update(view, since, polledSource, {
+        status: 'closed',
+        ...(read.outcome !== undefined ? { outcome: read.outcome } : {}),
+        source: { kind: 'document', document },
+      })
+    } catch (error) {
+      return this.update(view, since, polledSource, {
+        ...base,
+        status: 'closed',
+        ...(read.outcome !== undefined ? { outcome: read.outcome } : {}),
+        error: errorMessage(error),
+      })
+    }
+  }
+
+  private streamId(view: PollableSessionView): string {
+    return view.stream
+  }
+
+  private update(
+    view: PollableSessionView,
+    since: number,
+    polledSource: 'parts' | 'document',
+    fields: SessionViewFields,
+  ): SessionFeedUpdate {
+    return {
+      slug: view.slug,
+      sessionId: view.sessionId,
+      stream: view.stream,
+      since,
+      polledSource,
+      fields,
+    }
+  }
+}
+
+/**
+ * The apply-fence: apply a feed update to `current` only when it is still the
+ * same session view this update was polled from, at the same cursor. Anything
+ * else — an Escape to detail, a session switch, a newer apply — rejects the
+ * stale read by returning `undefined`.
+ */
+export function applySessionFeedUpdate(
+  current: SessionDashboardView | undefined,
+  update: SessionFeedUpdate,
+): SessionDashboardView | undefined {
+  if (current === undefined) return undefined
+  if (
+    current.slug !== update.slug ||
+    current.sessionId !== update.sessionId ||
+    current.stream !== update.stream
+  ) {
+    return undefined
+  }
+  if (update.polledSource === 'parts') {
+    if (current.source.kind !== 'parts' || current.source.lastSeq !== update.since) return undefined
+  } else if (current.source.kind !== 'document') {
+    return undefined
+  }
+  return { ...current, ...update.fields }
+}