opencode-extended-sidebar 0.2.90

package/src/pware.oc.runtime/pware.oc.runtime.source.ts

@@ -0,0 +1,105 @@
+import type { PwareEventBus } from "../pware.oc.core/pware.oc.core.bus.js"
+import { EVENT_SCAN_DEBOUNCE_MS } from "../pware.oc.core/pware.oc.core.timing.js"
+import {
+  EV_OES_QUESTION_HINT,
+  EV_OES_REFRESH_HINT,
+} from "../pware.oc.core/constants/pware.oc.core.constants.eventName.js"
+import {
+  EV_OMO_BOULDER_CHANGED,
+  EV_OMO_CONFIG_CHANGED,
+  EV_OMO_DOCS_CHANGED,
+} from "../pware.oc.omo/constants/pware.oc.omo.constants.eventName.js"
+import { startMonitor, type MonitorHandle } from "./pware.oc.runtime.monitor.js"
+import { shutdownSnapshotWorker } from "./pware.oc.runtime.snapshotClient.js"
+
+export type RuntimeSourceOptions = {
+  bus: PwareEventBus
+  sessionId: string
+  projectRoot: string | null
+  dbPath?: string
+  pollMs?: number
+}
+
+export type RuntimeSourceHandle = {
+  stop: () => void
+  refresh: () => void
+  setSession: (sessionId: string) => void
+}
+
+export function startRuntimeSource(opts: RuntimeSourceOptions): RuntimeSourceHandle {
+  let stopped = false
+  let watchedSessionId = opts.sessionId
+  let debounce: ReturnType<typeof setTimeout> | null = null
+  let questionDebounce: ReturnType<typeof setTimeout> | null = null
+  let pendingQuestionSession: string | null = null
+
+  const bindMonitor = (sessionId: string): MonitorHandle =>
+    startMonitor({
+      sessionId,
+      projectRoot: opts.projectRoot,
+      dbPath: opts.dbPath,
+      pollMs: opts.pollMs,
+      emit: opts.bus.emit,
+    })
+
+  let monitor = bindMonitor(watchedSessionId)
+
+  const scheduleRefresh = (): void => {
+    if (stopped) return
+    if (debounce) clearTimeout(debounce)
+    debounce = setTimeout(() => {
+      debounce = null
+      monitor.refresh()
+    }, EVENT_SCAN_DEBOUNCE_MS)
+  }
+
+  const scheduleQuestionHint = (sessionId: string): void => {
+    if (stopped) return
+    pendingQuestionSession = sessionId
+    if (questionDebounce) clearTimeout(questionDebounce)
+    questionDebounce = setTimeout(() => {
+      questionDebounce = null
+      const sid = pendingQuestionSession
+      pendingQuestionSession = null
+      if (sid) monitor.question(sid)
+    }, EVENT_SCAN_DEBOUNCE_MS)
+  }
+
+  const offRefreshHint = opts.bus.on(EV_OES_REFRESH_HINT, scheduleRefresh)
+  const offQuestionHint = opts.bus.on(EV_OES_QUESTION_HINT, (evt) => {
+    const data = evt.data as { sessionId?: string } | null | undefined
+    if (data?.sessionId) scheduleQuestionHint(data.sessionId)
+  })
+  const offBoulderChanged = opts.bus.on(EV_OMO_BOULDER_CHANGED, scheduleRefresh)
+  const offDocsChanged = opts.bus.on(EV_OMO_DOCS_CHANGED, scheduleRefresh)
+  const offConfigChanged = opts.bus.on(EV_OMO_CONFIG_CHANGED, scheduleRefresh)
+
+  return {
+    refresh: () => monitor.refresh(),
+    setSession: (sessionId: string) => {
+      if (!sessionId || sessionId === watchedSessionId) return
+      watchedSessionId = sessionId
+      if (debounce) {
+        clearTimeout(debounce)
+        debounce = null
+      }
+      monitor.stop()
+      monitor = bindMonitor(sessionId)
+    },
+    stop: () => {
+      stopped = true
+      if (debounce) clearTimeout(debounce)
+      debounce = null
+      if (questionDebounce) clearTimeout(questionDebounce)
+      questionDebounce = null
+      pendingQuestionSession = null
+      offRefreshHint()
+      offQuestionHint()
+      offBoulderChanged()
+      offDocsChanged()
+      offConfigChanged()
+      monitor.stop()
+      shutdownSnapshotWorker()
+    },
+  }
+}

package/src/pware.oc.runtime/pware.oc.runtime.worker.ts

@@ -0,0 +1,43 @@
+/**
+ * pware.oc.runtime.worker
+ *
+ * Runs `readRuntimeSnapshot` off the TUI main thread. A Bun Worker receiving
+ * `{type:"snapshot", id, opts}` replies `{type:"snapshot:done", id, ok, snap}`;
+ * `{type:"shutdown"}` closes the worker. The sync resolvers run unchanged in
+ * this thread, so the unit/snapshot test surface stays intact.
+ */
+import { readRuntimeSnapshot } from "./resolver/index.js"
+
+type SnapshotRequest = {
+  type: "snapshot"
+  id: number
+  opts: { sessionId: string; projectRoot: string | null; dbPath?: string; questionHint?: string }
+}
+
+type ShutdownRequest = { type: "shutdown" }
+
+type WorkerScope = {
+  onmessage: ((event: MessageEvent<SnapshotRequest | ShutdownRequest>) => void) | null
+  postMessage: (message: unknown) => void
+  close: () => void
+}
+
+const scope = self as unknown as WorkerScope
+
+scope.onmessage = (event) => {
+  const msg = event.data
+  if (msg.type === "shutdown") {
+    scope.close()
+    return
+  }
+  try {
+    scope.postMessage({ type: "snapshot:done", id: msg.id, ok: true, snap: readRuntimeSnapshot(msg.opts) })
+  } catch (err) {
+    scope.postMessage({
+      type: "snapshot:done",
+      id: msg.id,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+    })
+  }
+}

package/src/pware.oc.runtime/resolver/index.ts

@@ -0,0 +1,224 @@
+/**
+ * pware.oc.core.live.resolver
+ *
+ * Unified live snapshot: OpenCode SQLite + OMO files.
+ * Fingerprint-driven — callers poll / watch and call readRuntimeSnapshot.
+ */
+import { createStampCache } from "../../pware.oc.core/pware.oc.core.cache.js"
+import { gitignoreStamp } from "../../pware.oc.core/git/pware.oc.core.gitignore.js"
+import { oesStamp, getOes } from "../../pware.oc.core/pware.oc.core.oes.js"
+import { dbStamp, getOpenCodeDbPath } from "../../pware.oc.core/pware.oc.core.paths.js"
+import { openReadonlyDb, withDbRead, type SqlDb } from "../../pware.oc.core/pware.oc.core.sqlite.js"
+import { profile } from "../../pware.oc.core/pware.oc.core.debug.js"
+import {
+  emptyDb,
+  readDbSnapshot,
+  refreshSessionStatus,
+  sessionScanStamp,
+  type DbSnapshot,
+  type OpenQuestion,
+  type SessionView,
+} from "../../pware.oc.opencode/resolver/index.js"
+import { createQuestionCache } from "../pware.oc.runtime.questions.js"
+import {
+  emptyOmo,
+  omoStamp,
+  readOmo,
+  readOmoConfig,
+  type OmoConfigView,
+  type OmoSnapshot,
+} from "../../pware.oc.omo/resolver/index.js"
+import { enrichDelegates, type DelegateView } from "./pware.oc.runtime.resolver.delegate.js"
+
+export * from "./pware.oc.runtime.resolver.delegate.js"
+
+export type RuntimeSnapshot = {
+  generatedAt: number
+  fingerprint: string
+  /** session.time_updated + MAX(part.time_updated) — Perf cache key, not git. */
+  scanStamp: string
+  db: DbSnapshot
+  omo: OmoSnapshot
+  omoConfig: OmoConfigView
+  delegates: DelegateView[]
+  /** Open `question` tools across the project — computed off the UI thread. */
+  openQuestions: OpenQuestion[]
+}
+
+/** Cheap poll key: WAL + omo/oes stamps. No git, no boulder JSON. */
+export function computeFingerprint(opts: {
+  dbPath: string
+  projectRoot: string | null
+  sessionId: string
+}): string {
+  return [
+    opts.sessionId,
+    dbStamp(opts.dbPath),
+    omoStamp(opts.projectRoot),
+    oesStamp(opts.projectRoot),
+    gitignoreStamp(opts.projectRoot),
+  ].join("::")
+}
+
+/**
+ * Visible-session-graph stamp: the current session row + its parts + its
+ * children + any non-archived main session. Covers everything readDbSnapshot
+ * displays, so the live cache only misses when shown data actually changed
+ * (sessionScanStamp alone would miss delegate/recent rows).
+ */
+function snapshotGraphStamp(db: SqlDb, sessionId: string): { scan: string; graph: string } {
+  const scan = sessionScanStamp(db, sessionId)
+  const kids = db.get<{ m: number }>(
+    `SELECT MAX(time_updated) AS m FROM session WHERE parent_id = ?`,
+    sessionId,
+  )
+  const mains = db.get<{ m: number }>(
+    `SELECT MAX(time_updated) AS m FROM session
+     WHERE parent_id IS NULL AND (time_archived IS NULL OR time_archived = 0)`,
+  )
+  return { scan, graph: `${scan}|${kids?.m ?? 0}|${mains?.m ?? 0}` }
+}
+
+export function readRuntimeSnapshot(opts: {
+  sessionId: string
+  projectRoot: string | null
+  dbPath?: string
+  questionHint?: string
+}): RuntimeSnapshot {
+  const dbPath = opts.dbPath || getOpenCodeDbPath(process.env, undefined, opts.projectRoot)
+  const cheap = computeFingerprint({
+    dbPath,
+    projectRoot: opts.projectRoot,
+    sessionId: opts.sessionId,
+  })
+  let scan = "0"
+  let graph = "0"
+  if (opts.sessionId) {
+    const stamps = withDbRead(() => {
+      const handle = openReadonlyDb(dbPath)
+      return handle ? snapshotGraphStamp(handle, opts.sessionId) : null
+    }, () => null)
+    if (stamps) {
+      scan = stamps.scan
+      graph = stamps.graph
+    }
+  }
+
+  const cacheId = `${cheap}::${graph}`
+  const hit = liveCache.peek(cacheId)
+  if (hit) {
+    const now = Date.now()
+    const questionHint = opts.questionHint
+    const projectId = hit.db.projectId
+    if (questionHint && projectId) {
+      profile("db.questions", () => questionCache.touch(dbPath, projectId, questionHint))
+      return {
+        ...hit,
+        generatedAt: now,
+        fingerprint: cacheId,
+        scanStamp: scan,
+        db: withAges(hit.db, now),
+        openQuestions: questionCache.get(),
+      }
+    }
+    return {
+      ...hit,
+      generatedAt: now,
+      fingerprint: cacheId,
+      scanStamp: scan,
+      db: withAges(hit.db, now),
+    }
+  }
+
+  const omo = readOmo(opts.projectRoot)
+  const extraIds = omo.delegates
+    .map((d) => d.sessionId)
+    .filter((id): id is string => Boolean(id))
+  const db = withDbRead(
+    () =>
+      opts.sessionId
+        ? readDbSnapshot({
+            dbPath,
+            sessionId: opts.sessionId,
+            extraIds,
+            projectRoot: opts.projectRoot,
+          })
+        : emptyDb(dbPath, "no session"),
+    () =>
+      lastGood && lastGood.db.current?.id === opts.sessionId
+        ? lastGood.db
+        : emptyDb(dbPath, "db read failed"),
+  )
+
+  const projectId = db.projectId
+  const questionHint = opts.questionHint
+  let openQuestions: OpenQuestion[] = []
+  if (projectId) {
+    if (projectId !== questionProjectId) {
+      questionCache.reset()
+      questionProjectId = projectId
+      questionLastReconcile = 0
+    }
+    if (questionHint) {
+      profile("db.questions", () => questionCache.touch(dbPath, projectId, questionHint))
+    } else if (Date.now() - questionLastReconcile >= getOes(opts.projectRoot).questionReconcileSec * 1000) {
+      profile("db.questions", () => questionCache.reconcile(dbPath, projectId))
+      questionLastReconcile = Date.now()
+    }
+    openQuestions = questionCache.get()
+  }
+
+  const snap: RuntimeSnapshot = {
+    generatedAt: Date.now(),
+    fingerprint: cacheId,
+    scanStamp: scan,
+    db,
+    omo,
+    omoConfig: readOmoConfig(),
+    delegates: enrichDelegates(omo, db),
+    openQuestions,
+  }
+  lastGood = snap
+  liveCache.set(cacheId, snap)
+  return snap
+}
+
+const liveCache = createStampCache<RuntimeSnapshot>()
+
+/** Last successfully-read snapshot, served when a locked DB read fails. */
+let lastGood: RuntimeSnapshot | null = null
+
+/** Module-level open-question cache — seeded once, invalidated per-session via questionHint. */
+const questionCache = createQuestionCache()
+let questionLastReconcile = 0
+let questionProjectId: string | null = null
+
+/** Drop the in-memory live snapshot so the next read is a real load. */
+export function resetRuntimeCache(): void {
+  liveCache.reset()
+  lastGood = null
+  questionCache.reset()
+  questionLastReconcile = 0
+  questionProjectId = null
+}
+
+function withAges(db: DbSnapshot, now: number): DbSnapshot {
+  const bump = (v: SessionView | null): SessionView | null =>
+    v
+      ? {
+          ...v,
+          ageMs: Math.max(0, now - v.timeUpdated),
+          status: refreshSessionStatus(v, now),
+        }
+      : null
+  const current = bump(db.current)
+  const parent = bump(db.parent)
+  const main = bump(db.main)
+  const children = db.children.map((v) => bump(v)!)
+  const recent = db.recent.map((v) => bump(v)!)
+  const byId: DbSnapshot["byId"] = {}
+  for (const v of [current, parent, main, ...children, ...recent, ...Object.values(db.byId).map((x) => bump(x)!)]) {
+    if (v) byId[v.id] = v
+  }
+  return { ...db, current, parent, main, children, recent, byId }
+}

package/src/pware.oc.runtime/resolver/pware.oc.runtime.resolver.delegate.ts

@@ -0,0 +1,146 @@
+/**
+ * pware.oc.core.live.resolver.delegate
+ *
+ * Delegate resolution across providers: boulder tasks enriched with SQLite
+ * session rows, plus the grouping rules for the panel. `RuntimeSnapshot` is a
+ * type-only import from the live aggregate, so there is no runtime cycle.
+ */
+import type { Delegate, OmoSnapshot } from "../../pware.oc.omo/resolver/pware.oc.omo.resolver.boulder.js"
+import { normalizeStatus } from "../../pware.oc.core/pware.oc.core.status.js"
+import {
+  STATUS_ARCHIVED,
+  STATUS_COMPLETED,
+  STATUS_ERROR,
+  STATUS_RUNNING,
+  STATUS_UNKNOWN,
+} from "../../pware.oc.core/constants/pware.oc.core.constants.status.js"
+import {
+  SESSION_STATUS_ARCHIVED,
+  SESSION_STATUS_IDLE,
+  SESSION_STATUS_RUNNING,
+} from "../../pware.oc.opencode/constants/pware.oc.opencode.constants.sessionStatus.js"
+import { isRealSession, type DbSnapshot, type SessionView } from "../../pware.oc.opencode/resolver/index.js"
+import type { RuntimeSnapshot } from "./index.js"
+
+export type DelegateView = Delegate & {
+  tokensTotal: number | null
+  timeUpdated: number | null
+  archived: boolean
+}
+
+/**
+ * Boulder often leaves `task_sessions` on `running` after the work (and the
+ * OpenCode session) has finished. SQLite session status wins.
+ */
+export function reconcileDelegateStatus(
+  omoStatus: string,
+  sess?: Pick<SessionView, "status"> | null,
+): string {
+  const omo = (omoStatus || STATUS_UNKNOWN).toLowerCase()
+  if (!sess) return omo
+  if (sess.status === SESSION_STATUS_ARCHIVED) return STATUS_COMPLETED
+  const c = normalizeStatus(omoStatus)
+  const omoError = c === STATUS_ERROR
+  const omoDone = c === STATUS_COMPLETED
+  if (sess.status === SESSION_STATUS_IDLE) {
+    if (omoError) return omo
+    if (omoDone) return omo
+    return STATUS_COMPLETED
+  }
+  if (omoError || omoDone) return omo
+  // A live SQLite session is authoritative — a queued boulder entry (no status
+  // yet) must not show as waiting while its subagent is actually running.
+  if (sess.status === SESSION_STATUS_RUNNING) return STATUS_RUNNING
+  return omo === STATUS_UNKNOWN ? STATUS_RUNNING : omo
+}
+
+export function enrichDelegates(omo: OmoSnapshot, db: DbSnapshot): DelegateView[] {
+  return omo.delegates.map((d) => {
+    const sess = d.sessionId ? db.byId[d.sessionId] : undefined
+    return {
+      ...d,
+      status: reconcileDelegateStatus(d.status, sess),
+      tokensTotal: sess ? sess.tokensTotal : null,
+      timeUpdated: sess?.timeUpdated ?? d.updatedAt,
+      archived: sess?.status === SESSION_STATUS_ARCHIVED,
+    }
+  })
+}
+
+/** Display key — empty / missing agent collapses to `agent`. */
+export function delegateAgentKey(d: Pick<DelegateView, "agent">): string {
+  const s = (d.agent || "").trim()
+  return s || "agent"
+}
+
+export type DelegateListItem =
+  | { kind: "header"; agent: string; count: number; members: DelegateView[] }
+  | { kind: "row"; grouped: boolean; delegate: DelegateView }
+
+/**
+ * Cluster by agent when two or more names appear. Group order follows first
+ * appearance (keeps recency on Current). One agent → flat rows, no headers.
+ */
+export function groupDelegates(list: DelegateView[]): DelegateListItem[] {
+  if (list.length === 0) return []
+  const seen = new Set<string>()
+  for (const d of list) seen.add(delegateAgentKey(d))
+  const grouped = seen.size >= 2
+  if (!grouped) {
+    return list.map((delegate) => ({ kind: "row" as const, grouped: false, delegate }))
+  }
+  const order: string[] = []
+  const buckets = new Map<string, DelegateView[]>()
+  for (const d of list) {
+    const key = delegateAgentKey(d)
+    let bucket = buckets.get(key)
+    if (!bucket) {
+      bucket = []
+      buckets.set(key, bucket)
+      order.push(key)
+    }
+    bucket.push(d)
+  }
+  const out: DelegateListItem[] = []
+  for (const agent of order) {
+    const rows = buckets.get(agent) ?? []
+    out.push({ kind: "header", agent, count: rows.length, members: rows })
+    for (const delegate of rows) out.push({ kind: "row", grouped: true, delegate })
+  }
+  return out
+}
+
+/** Delegates of this session only: SQLite children + OMO tasks whose parent is this session. */
+export function delegatesForSession(snap: RuntimeSnapshot, sessionId: string): DelegateView[] {
+  const childIds = new Set(snap.db.children.map((c) => c.id))
+  const out: DelegateView[] = []
+  const seen = new Set<string>()
+  const push = (d: DelegateView) => {
+    const key = d.sessionId || d.taskKey
+    if (!key || seen.has(key) || key === sessionId) return
+    seen.add(key)
+    out.push(d)
+  }
+
+  // Boulder is project-wide. A new main session must not inherit another run's tasks.
+  for (const d of snap.delegates) {
+    const parent = d.sessionId ? snap.db.byId[d.sessionId]?.parentId : null
+    if (parent === sessionId || (d.sessionId && childIds.has(d.sessionId))) push(d)
+  }
+
+  for (const c of snap.db.children) {
+    if (!isRealSession(c)) continue
+    push({
+      taskKey: c.id,
+      title: c.title,
+      sessionId: c.id,
+      agent: c.agent,
+      status: c.status,
+      updatedAt: c.timeUpdated,
+      tokensTotal: c.tokensTotal,
+      timeUpdated: c.timeUpdated,
+      archived: c.status === SESSION_STATUS_ARCHIVED,
+    })
+  }
+  return out
+}

package/src/pware.oc.ui/index.ts

@@ -0,0 +1,12 @@
+/**
+ * pware.oc.ui
+ *
+ * TUI layer: chrome, shared sections, the sidebar panel, dialogs, glyphs.
+ */
+export * from "./pware.oc.ui.chrome.js"
+export * from "./pware.oc.ui.sections.js"
+export * from "./pware.oc.ui.sidebar.js"
+export * from "./pware.oc.ui.menudialogs.js"
+export * from "./pware.oc.ui.glyphs.js"
+export * from "./pware.oc.ui.live.js"
+export * from "./pware.oc.ui.host.js"