opencode-extended-sidebar 0.2.90 → 0.2.91

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

@@ -1,95 +1,83 @@
-/**
- * pware.oc.runtime.questions
- *
- * In-memory, per-session cache of open questions for the "My work" queue. A
- * later wiring task feeds it from cheap host-event hints (targeted
- * `listSessionQuestions` on the session a `message.part.updated` just touched)
- * and a periodic `listOpenQuestions` backstop, replacing the expensive
- * project-wide scan that used to run on every snapshot.
- *
- * `createQuestionCache()` returns a fresh instance — no module-level mutable
- * singleton — so tests build their own and the wiring task owns the one real
- * instance. State is `bySession`, a Map keyed by `sessionId`; `get` flattens
- * and dedupes it. The two read functions below already soft-fail to `[]`, so
- * this cache only holds/merges their results and needs no try/catch of its own.
- */
-import {
-  listOpenQuestions,
-  listSessionQuestions,
-  type OpenQuestion,
-} from "../pware.oc.opencode/resolver/pware.oc.opencode.resolver.question.js"
-
-export type QuestionCache = {
-  /** Project-wide open questions, deduped by partId, sorted `startedAt` DESC (nulls last). */
-  get: () => OpenQuestion[]
-  /** Full `listOpenQuestions` scan; replaces the whole map (drop gone sessions). */
-  seed: (dbPath: string, projectId: string | null) => void
-  /** One session's `listSessionQuestions`; merges in, or removes on empty. */
-  touch: (dbPath: string, projectId: string | null, sessionId: string) => void
-  /** Full `listOpenQuestions` scan — semantic alias of `seed` for the backstop call site. */
-  reconcile: (dbPath: string, projectId: string | null) => void
-  /** Drop every cached session. */
-  reset: () => void
-}
-
-/**
- * Flatten all per-session slices, dedupe by `partId` (a question may briefly
- * appear in two sessions' slices — keep the first), and sort by `startedAt`
- * descending with nulls last. Pure — never mutates its input.
- */
-export function mergeQuestions(
-  bySession: ReadonlyMap<string, readonly OpenQuestion[]>,
-): OpenQuestion[] {
-  const seen = new Set<string>()
-  const out: OpenQuestion[] = []
-  for (const list of bySession.values()) {
-    for (const q of list) {
-      if (seen.has(q.partId)) continue
-      seen.add(q.partId)
-      out.push(q)
-    }
-  }
-  out.sort((a, b) => {
-    const x = a.startedAt
-    const y = b.startedAt
-    if (x === y) return 0
-    if (x == null) return 1
-    if (y == null) return -1
-    return y - x
-  })
-  return out
-}
-
-export function createQuestionCache(): QuestionCache {
-  let bySession = new Map<string, OpenQuestion[]>()
-
-  function refill(dbPath: string, projectId: string | null): void {
-    const next = new Map<string, OpenQuestion[]>()
-    for (const q of listOpenQuestions({ dbPath, projectId })) {
-      const bucket = next.get(q.sessionId)
-      if (bucket) bucket.push(q)
-      else next.set(q.sessionId, [q])
-    }
-    bySession = next
-  }
-
-  return {
-    get() {
-      return mergeQuestions(bySession)
-    },
-    seed(dbPath, projectId) {
-      refill(dbPath, projectId)
-    },
-    touch(dbPath, projectId, sessionId) {
-      const result = listSessionQuestions({ dbPath, sessionId, projectId })
-      if (result.length > 0) bySession.set(sessionId, result)
-      else bySession.delete(sessionId)
-    },
-    reconcile(dbPath, projectId) {
-      refill(dbPath, projectId)
-    },
-    reset() {
-      bySession = new Map()
-    },
-  }
-}
+/**
+ * pware.oc.runtime.questions
+ *
+ * In-memory, per-session cache of open questions for the "My work" queue. A
+ * later wiring task feeds it from cheap host-event hints (targeted
+ * `listSessionQuestions` on the session a `message.part.updated` just touched)
+ * and a periodic `listOpenQuestions` backstop, replacing the expensive
+ * project-wide scan that used to run on every snapshot.
+ *
+ * `createQuestionCache()` returns a fresh instance — no module-level mutable
+ * singleton — so tests build their own and the wiring task owns the one real
+ * instance. State is `bySession`, a Map keyed by `sessionId`; `get` flattens
+ * and dedupes it. The two read functions below already soft-fail to `[]`, so
+ * this cache only holds/merges their results and needs no try/catch of its own.
+ */
+import type { OpenQuestion } from "../pware.oc.opencode/resolver/pware.oc.opencode.resolver.question.js"
+
+export type QuestionCache = {
+  /** Project-wide open questions, deduped by partId, sorted `startedAt` DESC (nulls last). */
+  get: () => OpenQuestion[]
+  seed: (questions: readonly OpenQuestion[]) => void
+  touch: (sessionId: string, questions: readonly OpenQuestion[]) => void
+  /** Drop every cached session. */
+  reset: () => void
+}
+
+/**
+ * Flatten all per-session slices, dedupe by `partId` (a question may briefly
+ * appear in two sessions' slices — keep the first), and sort by `startedAt`
+ * descending with nulls last. Pure — never mutates its input.
+ */
+export function mergeQuestions(
+  bySession: ReadonlyMap<string, readonly OpenQuestion[]>,
+): OpenQuestion[] {
+  const seen = new Set<string>()
+  const out: OpenQuestion[] = []
+  for (const list of bySession.values()) {
+    for (const q of list) {
+      if (seen.has(q.partId)) continue
+      seen.add(q.partId)
+      out.push(q)
+    }
+  }
+  out.sort((a, b) => {
+    const x = a.startedAt
+    const y = b.startedAt
+    if (x === y) return 0
+    if (x == null) return 1
+    if (y == null) return -1
+    return y - x
+  })
+  return out
+}
+
+export function createQuestionCache(): QuestionCache {
+  let bySession = new Map<string, OpenQuestion[]>()
+
+  function refill(questions: readonly OpenQuestion[]): void {
+    const next = new Map<string, OpenQuestion[]>()
+    for (const q of questions) {
+      const bucket = next.get(q.sessionId)
+      if (bucket) bucket.push(q)
+      else next.set(q.sessionId, [q])
+    }
+    bySession = next
+  }
+
+  return {
+    get() {
+      return mergeQuestions(bySession)
+    },
+    seed(questions) {
+      refill(questions)
+    },
+    touch(sessionId, questions) {
+      if (questions.length > 0) bySession.set(sessionId, [...questions])
+      else bySession.delete(sessionId)
+    },
+    reset() {
+      bySession = new Map()
+    },
+  }
+}

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

@@ -1,129 +1,130 @@
-/**
- * pware.oc.runtime.snapshotClient
- *
- * Async facade over the snapshot worker. `readRuntimeSnapshotAsync` posts a
- * snapshot request and resolves with the composed snapshot; when the worker
- * cannot be spawned, errors, or fails to answer within the timeout it falls
- * back to the synchronous `readRuntimeSnapshot` — so the panel never hard
- * depends on worker availability.
- */
-import { dbg } from "../pware.oc.core/pware.oc.core.debug.js"
-import { readRuntimeSnapshot, type RuntimeSnapshot } from "./resolver/index.js"
-
-export type SnapshotRequestOpts = {
-  sessionId: string
-  projectRoot: string | null
-  dbPath?: string
-  questionHint?: string
-}
-
-type SnapshotDoneMessage = {
-  type: "snapshot:done"
-  id: number
-  ok: boolean
-  snap?: RuntimeSnapshot
-  error?: string
-}
-
-/** Bound on a single worker round-trip before the sync path takes over. */
-const WORKER_TIMEOUT_MS = 4_000
-
-type PendingEntry = {
-  opts: SnapshotRequestOpts
-  resolve: (snap: RuntimeSnapshot) => void
-  timer: ReturnType<typeof setTimeout>
-}
-
-let worker: Worker | null = null
-let workerFailed = false
-let nextId = 0
-const pending = new Map<number, PendingEntry>()
-
-function syncFallback(opts: SnapshotRequestOpts): RuntimeSnapshot {
-  return readRuntimeSnapshot(opts)
-}
-
-function settle(id: number, snap: RuntimeSnapshot): void {
-  const entry = pending.get(id)
-  if (!entry) return
-  pending.delete(id)
-  clearTimeout(entry.timer)
-  entry.resolve(snap)
-}
-
-function failAll(reason: string): void {
-  dbg("snapshot.worker", "failed", { reason })
-  workerFailed = true
-  for (const id of [...pending.keys()]) {
-    const entry = pending.get(id)
-    if (entry) settle(id, syncFallback(entry.opts))
-  }
-}
-
-function ensureWorker(): Worker | null {
-  if (workerFailed) return null
-  if (worker) return worker
-  try {
-    const w = new Worker(new URL("./pware.oc.runtime.worker.ts", import.meta.url), { type: "module" })
-    w.onmessage = (event: MessageEvent<SnapshotDoneMessage>) => {
-      const msg = event.data
-      if (!msg || msg.type !== "snapshot:done") return
-      const entry = pending.get(msg.id)
-      if (!entry) return
-      settle(msg.id, msg.ok && msg.snap ? msg.snap : syncFallback(entry.opts))
-    }
-    w.onerror = (event) => {
-      const message =
-        typeof event === "object" && event !== null && "message" in event
-          ? String((event as { message: unknown }).message)
-          : String(event)
-      failAll(message)
-      try {
-        w.terminate()
-      } catch {
-        // ignore
-      }
-      worker = null
-    }
-    worker = w
-    dbg("snapshot.worker", "spawned", {})
-    return w
-  } catch (err) {
-    dbg("snapshot.worker", "spawn failed", { error: err instanceof Error ? err.message : String(err) })
-    workerFailed = true
-    return null
-  }
-}
-
-/** Off-main-thread snapshot read, falling back to the sync path on any failure. */
-export function readRuntimeSnapshotAsync(opts: SnapshotRequestOpts): Promise<RuntimeSnapshot> {
-  const w = ensureWorker()
-  if (!w) return Promise.resolve(syncFallback(opts))
-  const id = ++nextId
-  return new Promise<RuntimeSnapshot>((resolve) => {
-    const timer = setTimeout(() => settle(id, syncFallback(opts)), WORKER_TIMEOUT_MS)
-    pending.set(id, { opts, resolve, timer })
-    try {
-      w.postMessage({ type: "snapshot", id, opts })
-    } catch (err) {
-      dbg("snapshot.worker", "post failed", { error: err instanceof Error ? err.message : String(err) })
-      settle(id, syncFallback(opts))
-    }
-  })
-}
-
-/** Terminate the shared worker (idempotent). Safe to call on plugin shutdown. */
-export function shutdownSnapshotWorker(): void {
-  if (!worker) return
-  try {
-    worker.postMessage({ type: "shutdown" })
-  } catch {
-    // ignore
-  }
-  try {
-    worker.terminate()
-  } catch {
-    // ignore
-  }
-  worker = null
-}
+/**
+ * pware.oc.runtime.snapshotClient
+ *
+ * Async facade over the snapshot worker. `readRuntimeSnapshotAsync` posts a
+ * snapshot request and resolves with the composed snapshot; when the worker
+ * cannot be spawned, errors, or fails to answer within the timeout it runs the
+ * same paced request gateway in the host process.
+ */
+import { dbg } from "../pware.oc.core/pware.oc.core.debug.js"
+import { readRuntimeSnapshot, type RuntimeSnapshot } from "./resolver/index.js"
+
+export type SnapshotRequestOpts = {
+  sessionId: string
+  projectRoot: string | null
+  dbPath?: string
+  questionHint?: string
+}
+
+type SnapshotDoneMessage = {
+  type: "snapshot:done"
+  id: number
+  ok: boolean
+  snap?: RuntimeSnapshot
+  error?: string
+}
+
+/** Bound on a single worker round-trip before the sync path takes over. */
+const WORKER_TIMEOUT_MS = 4_000
+
+type PendingEntry = {
+  opts: SnapshotRequestOpts
+  resolve: (snap: RuntimeSnapshot) => void
+  timer: ReturnType<typeof setTimeout>
+}
+
+let worker: Worker | null = null
+let workerFailed = false
+let nextId = 0
+const pending = new Map<number, PendingEntry>()
+
+function fallbackRead(opts: SnapshotRequestOpts): Promise<RuntimeSnapshot> {
+  return readRuntimeSnapshot(opts)
+}
+
+function settle(id: number, snap: RuntimeSnapshot): void {
+  const entry = pending.get(id)
+  if (!entry) return
+  pending.delete(id)
+  clearTimeout(entry.timer)
+  entry.resolve(snap)
+}
+
+function failAll(reason: string): void {
+  dbg("snapshot.worker", "failed", { reason })
+  workerFailed = true
+  for (const id of [...pending.keys()]) {
+    const entry = pending.get(id)
+    if (entry) void fallbackRead(entry.opts).then((snap) => settle(id, snap))
+  }
+}
+
+function ensureWorker(): Worker | null {
+  if (workerFailed) return null
+  if (worker) return worker
+  try {
+    const w = new Worker(new URL("./pware.oc.runtime.worker.ts", import.meta.url), { type: "module" })
+    w.onmessage = (event: MessageEvent<SnapshotDoneMessage>) => {
+      const msg = event.data
+      if (!msg || msg.type !== "snapshot:done") return
+      const entry = pending.get(msg.id)
+      if (!entry) return
+      if (msg.ok && msg.snap) settle(msg.id, msg.snap)
+      else void fallbackRead(entry.opts).then((snap) => settle(msg.id, snap))
+    }
+    w.onerror = (event) => {
+      const message =
+        typeof event === "object" && event !== null && "message" in event
+          ? String((event as { message: unknown }).message)
+          : String(event)
+      failAll(message)
+      try {
+        w.terminate()
+      } catch {
+        // ignore
+      }
+      worker = null
+    }
+    worker = w
+    dbg("snapshot.worker", "spawned", {})
+    return w
+  } catch (err) {
+    dbg("snapshot.worker", "spawn failed", { error: err instanceof Error ? err.message : String(err) })
+    workerFailed = true
+    return null
+  }
+}
+
+export function readRuntimeSnapshotAsync(opts: SnapshotRequestOpts): Promise<RuntimeSnapshot> {
+  const w = ensureWorker()
+  if (!w) return fallbackRead(opts)
+  const id = ++nextId
+  return new Promise<RuntimeSnapshot>((resolve) => {
+    const timer = setTimeout(() => {
+      void fallbackRead(opts).then((snap) => settle(id, snap))
+    }, WORKER_TIMEOUT_MS)
+    pending.set(id, { opts, resolve, timer })
+    try {
+      w.postMessage({ type: "snapshot", id, opts })
+    } catch (err) {
+      dbg("snapshot.worker", "post failed", { error: err instanceof Error ? err.message : String(err) })
+      void fallbackRead(opts).then((snap) => settle(id, snap))
+    }
+  })
+}
+
+/** Terminate the shared worker (idempotent). Safe to call on plugin shutdown. */
+export function shutdownSnapshotWorker(): void {
+  if (!worker) return
+  try {
+    worker.postMessage({ type: "shutdown" })
+  } catch {
+    // ignore
+  }
+  try {
+    worker.terminate()
+  } catch {
+    // ignore
+  }
+  worker = null
+}

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

@@ -1,105 +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()
-    },
-  }
-}
+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()
+    },
+  }
+}