opencode-extended-sidebar 0.2.90 → 0.2.91

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

@@ -1,13 +1,13 @@
-/**
- * pware.oc.runtime
- *
- * Runtime composition: the only layer that combines opencode + omo into one
- * snapshot, plus the monitor that keeps it fresh and the My work queue.
- */
-export * from "./pware.oc.runtime.monitor.js"
-export * from "./pware.oc.runtime.source.js"
-export * from "./pware.oc.runtime.snapshotClient.js"
-export * from "./pware.oc.runtime.mywork.js"
-export * from "./pware.oc.runtime.mywork-enrich.js"
-export * from "./pware.oc.runtime.questions.js"
-export * from "./resolver/index.js"
+/**
+ * pware.oc.runtime
+ *
+ * Runtime composition: the only layer that combines opencode + omo into one
+ * snapshot, plus the monitor that keeps it fresh and the My work queue.
+ */
+export * from "./pware.oc.runtime.monitor.js"
+export * from "./pware.oc.runtime.source.js"
+export * from "./pware.oc.runtime.snapshotClient.js"
+export * from "./pware.oc.runtime.mywork.js"
+export * from "./pware.oc.runtime.mywork-enrich.js"
+export * from "./pware.oc.runtime.questions.js"
+export * from "./resolver/index.js"

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

@@ -1,142 +1,142 @@
-/**
- * Watch boulder.json + poll SQLite stamps. Invokes onChange when fingerprint changes.
- */
-import fs from "node:fs"
-import path from "node:path"
-import type { PwareEvent } from "../pware.oc.core/pware.oc.core.bus.js"
-import { EV_OES_SNAPSHOT } from "../pware.oc.core/constants/pware.oc.core.constants.eventName.js"
-import { EV_OMO_BOULDER_CHANGED } from "../pware.oc.omo/constants/pware.oc.omo.constants.eventName.js"
-import { findBoulder } from "../pware.oc.omo/resolver/index.js"
-import { computeFingerprint, type RuntimeSnapshot } from "./resolver/index.js"
-import { readRuntimeSnapshotAsync } from "./pware.oc.runtime.snapshotClient.js"
-import { getOpenCodeDbPath } from "../pware.oc.core/pware.oc.core.paths.js"
-import { MONITOR_POLL_MS, MONITOR_WATCH_DEBOUNCE_MS } from "../pware.oc.core/pware.oc.core.timing.js"
-import { dbg, profile } from "../pware.oc.core/pware.oc.core.debug.js"
-
-export type MonitorOptions = {
-  sessionId: string
-  projectRoot: string | null
-  dbPath?: string
-  pollMs?: number
-  onChange?: (snap: RuntimeSnapshot) => void
-  emit?: (evt: PwareEvent) => void
-}
-
-export type MonitorHandle = {
-  stop: () => void
-  refresh: () => void
-  question: (sessionId: string) => void
-}
-
-export function startMonitor(opts: MonitorOptions): MonitorHandle {
-  const dbPath = opts.dbPath || getOpenCodeDbPath(process.env, undefined, opts.projectRoot)
-  dbg("monitor", "start", { dbPath, sessionId: opts.sessionId, projectRoot: opts.projectRoot ?? null })
-  const pollMs = opts.pollMs ?? MONITOR_POLL_MS
-  let lastFp = ""
-  let stopped = false
-  let emitGen = 0
-  let debounce: ReturnType<typeof setTimeout> | null = null
-  let pendingQuestionHint: string | null = null
-  const watchers: fs.FSWatcher[] = []
-
-  const emit = (force = false) =>
-    profile("monitor.emit", () => {
-      if (stopped) return
-      const fp = computeFingerprint({
-        dbPath,
-        projectRoot: opts.projectRoot,
-        sessionId: opts.sessionId,
-      })
-      if (!force && fp === lastFp) return
-      dbg("monitor", "emit", { force, fp: fp.slice(0, 40) })
-      lastFp = fp
-      const gen = ++emitGen
-      const questionHint = pendingQuestionHint ?? undefined
-      pendingQuestionHint = null
-      void readRuntimeSnapshotAsync({
-        sessionId: opts.sessionId,
-        projectRoot: opts.projectRoot,
-        dbPath,
-        questionHint,
-      }).then((snapshot) => {
-        if (stopped || gen !== emitGen) return
-        opts.onChange?.(snapshot)
-        opts.emit?.({
-          type: EV_OES_SNAPSHOT,
-          ts: Date.now(),
-          data: { snapshot },
-        })
-      })
-    })
-
-  const schedule = () => {
-    if (stopped) return
-    if (debounce) clearTimeout(debounce)
-    debounce = setTimeout(() => {
-      debounce = null
-      emit()
-    }, MONITOR_WATCH_DEBOUNCE_MS)
-  }
-
-  // Initial
-  emit(true)
-
-  const interval = setInterval(schedule, pollMs)
-
-  const root = opts.projectRoot
-  if (root) {
-    const boulderPath = findBoulder(root)
-    if (boulderPath) {
-      try {
-        watchers.push(
-          fs.watch(boulderPath, { persistent: false }, () => {
-            opts.emit?.({
-              type: EV_OMO_BOULDER_CHANGED,
-              ts: Date.now(),
-              data: {},
-            })
-            schedule()
-          }),
-        )
-      } catch {
-        // poll covers it
-      }
-    }
-  }
-
-  // SQLite: watching the file is flaky under WAL — poll stamps instead.
-  // Still try a non-recursive watch on the data dir for companions.
-  try {
-    const dataDir = path.dirname(dbPath)
-    if (fs.existsSync(dataDir)) {
-      watchers.push(
-        fs.watch(dataDir, { persistent: false }, (event, filename) => {
-          const name = filename?.toString() || ""
-          if (!name || name.includes("opencode.db")) schedule()
-        }),
-      )
-    }
-  } catch {
-    // poll only
-  }
-
-  return {
-    refresh: () => emit(true),
-    question: (sessionId: string) => {
-      pendingQuestionHint = sessionId
-      emit(true)
-    },
-    stop: () => {
-      stopped = true
-      if (debounce) clearTimeout(debounce)
-      clearInterval(interval)
-      for (const w of watchers) {
-        try {
-          w.close()
-        } catch {
-          // ignore
-        }
-      }
-    },
-  }
-}
+/**
+ * Watch boulder.json + poll SQLite stamps. Invokes onChange when fingerprint changes.
+ */
+import fs from "node:fs"
+import path from "node:path"
+import type { PwareEvent } from "../pware.oc.core/pware.oc.core.bus.js"
+import { EV_OES_SNAPSHOT } from "../pware.oc.core/constants/pware.oc.core.constants.eventName.js"
+import { EV_OMO_BOULDER_CHANGED } from "../pware.oc.omo/constants/pware.oc.omo.constants.eventName.js"
+import { findBoulder } from "../pware.oc.omo/resolver/index.js"
+import { computeFingerprint, type RuntimeSnapshot } from "./resolver/index.js"
+import { readRuntimeSnapshotAsync } from "./pware.oc.runtime.snapshotClient.js"
+import { getOpenCodeDbPath } from "../pware.oc.core/pware.oc.core.paths.js"
+import { MONITOR_POLL_MS, MONITOR_WATCH_DEBOUNCE_MS } from "../pware.oc.core/pware.oc.core.timing.js"
+import { dbg, profile } from "../pware.oc.core/pware.oc.core.debug.js"
+
+export type MonitorOptions = {
+  sessionId: string
+  projectRoot: string | null
+  dbPath?: string
+  pollMs?: number
+  onChange?: (snap: RuntimeSnapshot) => void
+  emit?: (evt: PwareEvent) => void
+}
+
+export type MonitorHandle = {
+  stop: () => void
+  refresh: () => void
+  question: (sessionId: string) => void
+}
+
+export function startMonitor(opts: MonitorOptions): MonitorHandle {
+  const dbPath = opts.dbPath || getOpenCodeDbPath(process.env, undefined, opts.projectRoot)
+  dbg("monitor", "start", { dbPath, sessionId: opts.sessionId, projectRoot: opts.projectRoot ?? null })
+  const pollMs = opts.pollMs ?? MONITOR_POLL_MS
+  let lastFp = ""
+  let stopped = false
+  let emitGen = 0
+  let debounce: ReturnType<typeof setTimeout> | null = null
+  let pendingQuestionHint: string | null = null
+  const watchers: fs.FSWatcher[] = []
+
+  const emit = (force = false) =>
+    profile("monitor.emit", () => {
+      if (stopped) return
+      const fp = computeFingerprint({
+        dbPath,
+        projectRoot: opts.projectRoot,
+        sessionId: opts.sessionId,
+      })
+      if (!force && fp === lastFp) return
+      dbg("monitor", "emit", { force, fp: fp.slice(0, 40) })
+      lastFp = fp
+      const gen = ++emitGen
+      const questionHint = pendingQuestionHint ?? undefined
+      pendingQuestionHint = null
+      void readRuntimeSnapshotAsync({
+        sessionId: opts.sessionId,
+        projectRoot: opts.projectRoot,
+        dbPath,
+        questionHint,
+      }).then((snapshot) => {
+        if (stopped || gen !== emitGen) return
+        opts.onChange?.(snapshot)
+        opts.emit?.({
+          type: EV_OES_SNAPSHOT,
+          ts: Date.now(),
+          data: { snapshot },
+        })
+      })
+    })
+
+  const schedule = () => {
+    if (stopped) return
+    if (debounce) clearTimeout(debounce)
+    debounce = setTimeout(() => {
+      debounce = null
+      emit()
+    }, MONITOR_WATCH_DEBOUNCE_MS)
+  }
+
+  // Initial
+  emit(true)
+
+  const interval = setInterval(schedule, pollMs)
+
+  const root = opts.projectRoot
+  if (root) {
+    const boulderPath = findBoulder(root)
+    if (boulderPath) {
+      try {
+        watchers.push(
+          fs.watch(boulderPath, { persistent: false }, () => {
+            opts.emit?.({
+              type: EV_OMO_BOULDER_CHANGED,
+              ts: Date.now(),
+              data: {},
+            })
+            schedule()
+          }),
+        )
+      } catch {
+        // poll covers it
+      }
+    }
+  }
+
+  // SQLite: watching the file is flaky under WAL — poll stamps instead.
+  // Still try a non-recursive watch on the data dir for companions.
+  try {
+    const dataDir = path.dirname(dbPath)
+    if (fs.existsSync(dataDir)) {
+      watchers.push(
+        fs.watch(dataDir, { persistent: false }, (event, filename) => {
+          const name = filename?.toString() || ""
+          if (!name || name.includes("opencode.db")) schedule()
+        }),
+      )
+    }
+  } catch {
+    // poll only
+  }
+
+  return {
+    refresh: () => emit(true),
+    question: (sessionId: string) => {
+      pendingQuestionHint = sessionId
+      emit(true)
+    },
+    stop: () => {
+      stopped = true
+      if (debounce) clearTimeout(debounce)
+      clearInterval(interval)
+      for (const w of watchers) {
+        try {
+          w.close()
+        } catch {
+          // ignore
+        }
+      }
+    },
+  }
+}

package/src/pware.oc.runtime/pware.oc.runtime.mywork-enrich.ts

@@ -1,79 +1,87 @@
-/**
- * pware.oc.runtime.mywork-enrich
- *
- * Enriches the OMO approval queue with the writer session's activity state:
- * builds the plan-file → writer-session index once, then per item resolves the
- * writer via `basenameOf(item.rel)` and asks `sessionActivityState` (SQLite
- * freshness + the omo `.omo/run-continuation` marker). Soft-fails to
- * `sessionState: null` per item — never throws. This is the runtime layer's
- * job: it composes omo (`.omo/run-continuation`) with opencode (SQLite session
- * activity).
- */
-import fs from "node:fs"
-import {
-  sessionActivityState,
-  type SessionActivityState,
-} from "../pware.oc.opencode/resolver/pware.oc.opencode.resolver.session.js"
-import { listTodos } from "../pware.oc.opencode/resolver/pware.oc.opencode.resolver.todo.js"
-import { planSessionIndex } from "../pware.oc.omo/resolver/index.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 { basenameOf } from "../pware.oc.core/pware.oc.core.paths.js"
-import { readRunContinuationState } from "../pware.oc.omo/resolver/pware.oc.omo.resolver.approvalState.js"
-import { BACKGROUND_TASK_ACTIVE } from "../pware.oc.omo/constants/pware.oc.omo.constants.backgroundTask.js"
-import { STATUS_COMPLETED } from "../pware.oc.core/constants/pware.oc.core.constants.status.js"
-import type { ApprovalItem } from "../pware.oc.omo/resolver/pware.oc.omo.resolver.plan.js"
-
-/**
- * An approval item with its planner-session activity attached. `sessionState`
- * is a runtime enrichment: it lives here on the runtime layer's enriched type,
- * not on omo's base `ApprovalItem` (omo must not import the opencode session type).
- */
-export type EnrichedApproval = ApprovalItem & {
-  sessionState: SessionActivityState | null
-  /** Writer session's todos all completed (and at least one present). */
-  todosDone: boolean
-}
-
-function blank(items: readonly ApprovalItem[]): EnrichedApproval[] {
-  return items.map((item) => ({ ...item, sessionState: null, todosDone: false }))
-}
-
-function sessionTodosDone(db: SqlDb, sessionId: string): boolean {
-  const todos = listTodos(db, sessionId)
-  return todos.length > 0 && todos.every((t) => t.status === STATUS_COMPLETED)
-}
-
-export function enrichApprovalSessionStates(
-  items: readonly ApprovalItem[],
-  opts: { dbPath: string | null | undefined; projectRoot: string | null | undefined; now?: number },
-): EnrichedApproval[] {
-  if (items.length === 0) return []
-  const dbPath = opts.dbPath
-  const projectRoot = opts.projectRoot
-  if (!dbPath || !projectRoot || !fs.existsSync(dbPath)) return blank(items)
-  return profile("mywork.approvals", () =>
-    withDbRead(
-      () => {
-        const db = openReadonlyDb(dbPath)
-        if (!db) return blank(items)
-        // Index once; match writers by basename across all sessions (no
-        // projectId in the opts shape — same scope as sessionForPlanFile).
-        const index = planSessionIndex(db, null, projectRoot)
-        return items.map((item) => {
-          const sessionId = index.fileWriter.get(basenameOf(item.rel))?.sessionId ?? null
-          const sessionState = sessionId
-            ? sessionActivityState(db, sessionId, {
-                backgroundTaskActive:
-                  readRunContinuationState(projectRoot, sessionId) === BACKGROUND_TASK_ACTIVE,
-                now: opts.now,
-              })
-            : null
-          const todosDone = sessionId ? sessionTodosDone(db, sessionId) : false
-          return { ...item, sessionState, todosDone }
-        })
-      },
-      () => blank(items),
-    ),
-  )
-}
+/**
+ * pware.oc.runtime.mywork-enrich
+ *
+ * Enriches the OMO approval queue with the writer session's activity state:
+ * builds the plan-file → writer-session index once, then per item resolves the
+ * writer via `basenameOf(item.rel)` and asks `sessionActivityState` (SQLite
+ * freshness + the omo `.omo/run-continuation` marker). Soft-fails to
+ * `sessionState: null` per item — never throws. This is the runtime layer's
+ * job: it composes omo (`.omo/run-continuation`) with opencode (SQLite session
+ * activity).
+ */
+import {
+  sessionActivityState,
+  type SessionActivityState,
+} from "../pware.oc.opencode/resolver/pware.oc.opencode.resolver.session.js"
+import { listTodos } from "../pware.oc.opencode/resolver/pware.oc.opencode.resolver.todo.js"
+import { planSessionIndex, type PlanSessionIndex } from "../pware.oc.omo/resolver/index.js"
+import type { SqlDb } from "../pware.oc.core/pware.oc.core.sqlite.js"
+import { readonlyReadGateway } from "../pware.oc.core/pware.oc.core.sqliteGateway.js"
+import { profileAsync } from "../pware.oc.core/pware.oc.core.debug.js"
+import { basenameOf } from "../pware.oc.core/pware.oc.core.paths.js"
+import { readRunContinuationState } from "../pware.oc.omo/resolver/pware.oc.omo.resolver.approvalState.js"
+import { BACKGROUND_TASK_ACTIVE } from "../pware.oc.omo/constants/pware.oc.omo.constants.backgroundTask.js"
+import { STATUS_COMPLETED } from "../pware.oc.core/constants/pware.oc.core.constants.status.js"
+import type { ApprovalItem } from "../pware.oc.omo/resolver/pware.oc.omo.resolver.plan.js"
+
+/**
+ * An approval item with its planner-session activity attached. `sessionState`
+ * is a runtime enrichment: it lives here on the runtime layer's enriched type,
+ * not on omo's base `ApprovalItem` (omo must not import the opencode session type).
+ */
+export type EnrichedApproval = ApprovalItem & {
+  sessionState: SessionActivityState | null
+  /** Writer session's todos all completed (and at least one present). */
+  todosDone: boolean
+}
+
+function blank(items: readonly ApprovalItem[]): EnrichedApproval[] {
+  return items.map((item) => ({ ...item, sessionState: null, todosDone: false }))
+}
+
+function sessionTodosDone(db: SqlDb, sessionId: string): boolean {
+  const todos = listTodos(db, sessionId)
+  return todos.length > 0 && todos.every((t) => t.status === STATUS_COMPLETED)
+}
+
+type EnrichmentRead = {
+  readonly index: PlanSessionIndex | null
+  readonly approvals: EnrichedApproval[]
+}
+
+export async function enrichApprovalSessionStates(
+  items: readonly ApprovalItem[],
+  opts: { dbPath: string | null | undefined; projectRoot: string | null | undefined; now?: number },
+): Promise<EnrichedApproval[]> {
+  if (items.length === 0) return []
+  const dbPath = opts.dbPath
+  const projectRoot = opts.projectRoot
+  if (!dbPath || !projectRoot) return blank(items)
+  const itemStages = items.map((item) => (db: SqlDb, state: EnrichmentRead): EnrichmentRead => {
+    const sessionId = state.index?.fileWriter.get(basenameOf(item.rel))?.sessionId ?? null
+    const sessionState = sessionId
+      ? sessionActivityState(db, sessionId, {
+          backgroundTaskActive:
+            readRunContinuationState(projectRoot, sessionId) === BACKGROUND_TASK_ACTIVE,
+          now: opts.now,
+        })
+      : null
+    const todosDone = sessionId ? sessionTodosDone(db, sessionId) : false
+    return {
+      ...state,
+      approvals: [...state.approvals, { ...item, sessionState, todosDone }],
+    }
+  })
+  const result = await profileAsync("mywork.approvals", () =>
+    readonlyReadGateway.run<EnrichmentRead>({
+      dbPath,
+      initial: () => ({ index: null, approvals: [] }),
+      stages: [
+        (db, state) => ({ ...state, index: planSessionIndex(db, null, projectRoot) }),
+        ...itemStages,
+      ],
+      fallback: () => ({ index: null, approvals: blank(items) }),
+    }),
+  )
+  return result.approvals
+}