opencode-extended-sidebar 0.2.90

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

@@ -0,0 +1,170 @@
+/**
+ * pware.oc.core.opencode.resolver
+ *
+ * Aggregate of the opencode SQLite resolvers: readDbSnapshot composes the
+ * session graph + tools + files for the panel; readProjectFeed rolls the
+ * Sessions-tab feed across a set of sessions. Re-exports the entity resolvers.
+ */
+import fs from "node:fs"
+import type { FileFilter, FileView } from "../pware.oc.opencode.files.js"
+import { profile } from "../../pware.oc.core/pware.oc.core.debug.js"
+import { getOes } from "../../pware.oc.core/pware.oc.core.oes.js"
+import { openReadonlyDb, withDbRead } from "../../pware.oc.core/pware.oc.core.sqlite.js"
+import {
+  getSessionById,
+  getSessionsByIds,
+  listChildSessions,
+  listRecentMainSessions,
+  toSessionView,
+  type SessionView,
+} from "./pware.oc.opencode.resolver.session.js"
+import { listRecentToolEvents, listToolEvents, type ToolView } from "./pware.oc.opencode.resolver.tool.js"
+import { listSessionFiles, listRecentSessionFiles } from "./pware.oc.opencode.resolver.file.js"
+import type { TodoRow } from "./pware.oc.opencode.resolver.todo.js"
+
+export * from "./pware.oc.opencode.resolver.session.js"
+export * from "./pware.oc.opencode.resolver.todo.js"
+export * from "./pware.oc.opencode.resolver.tool.js"
+export * from "./pware.oc.opencode.resolver.file.js"
+export * from "./pware.oc.opencode.resolver.question.js"
+
+export type DbSnapshot = {
+  present: boolean
+  dbPath: string
+  /** Project of the current session — scopes project-wide reads (questions). */
+  projectId: string | null
+  current: SessionView | null
+  /** Orchestrator: parent if current is a child, otherwise current. */
+  main: SessionView | null
+  parent: SessionView | null
+  children: SessionView[]
+  siblings: SessionView[]
+  /** Sessions keyed by id — current, main, and any looked-up delegates. */
+  byId: Record<string, SessionView>
+  /** Recent main (parent_id null) sessions in this project — the `sessionFetch` window. */
+  recent: SessionView[]
+  todos: TodoRow[]
+  /** Current session tool parts — name + status only, no args/outputs. */
+  tools: ToolView[]
+  /** Basenames + optional +/- from edit/write parts. No paths, no bodies. */
+  files: FileView[]
+  error: string | null
+}
+
+export function emptyDb(dbPath: string, error: string | null = null): DbSnapshot {
+  return {
+    present: false,
+    dbPath,
+    projectId: null,
+    current: null,
+    main: null,
+    parent: null,
+    children: [],
+    siblings: [],
+    byId: {},
+    recent: [],
+    todos: [],
+    tools: [],
+    files: [],
+    error,
+  }
+}
+
+export function readDbSnapshot(opts: {
+  dbPath: string
+  sessionId: string
+  extraIds?: string[]
+  projectRoot?: string | null
+}): DbSnapshot {
+  if (!opts.dbPath || !fs.existsSync(opts.dbPath)) {
+    return emptyDb(opts.dbPath, "db missing")
+  }
+
+  const run = (): DbSnapshot => {
+    const db = openReadonlyDb(opts.dbPath)
+    if (!db) return emptyDb(opts.dbPath, "sqlite unavailable")
+
+    const now = Date.now()
+    const row = getSessionById(db, opts.sessionId)
+    if (!row) {
+      return { ...emptyDb(opts.dbPath, "session not in db yet"), present: true }
+    }
+    const current = toSessionView(row, now)
+    let parent: SessionView | null = null
+    const children = listChildSessions(db, row.id).map((r) => toSessionView(r, now))
+    if (row.parent_id) {
+      const p = getSessionById(db, row.parent_id)
+      if (p) parent = toSessionView(p, now)
+    }
+
+    const main = parent ?? current
+    const extra = getSessionsByIds(db, opts.extraIds ?? []).map((r) =>
+      toSessionView(r, now),
+    )
+    const byId: Record<string, SessionView> = {}
+    const oes = getOes(opts.projectRoot)
+    const recent = listRecentMainSessions(db, {
+      projectId: row.project_id,
+      limit: oes.sessionFetch,
+    }).map((r) => toSessionView(r, now))
+    for (const v of [current, parent, main, ...children, ...extra, ...recent]) {
+      if (v) byId[v.id] = v
+    }
+
+    return {
+      present: true,
+      dbPath: opts.dbPath,
+      projectId: row.project_id,
+      current,
+      main,
+      parent,
+      children,
+      siblings: [],
+      byId,
+      recent,
+      todos: [],
+      tools: listToolEvents(db, row.id, oes.toolFetch),
+      files: listSessionFiles(db, row.id, {
+        skipGitignore: oes.skipGitignore,
+        projectRoot: opts.projectRoot,
+      }),
+      error: null,
+    }
+  }
+
+  return profile("db.snapshot", () =>
+    withDbRead(run, (e) =>
+      emptyDb(opts.dbPath, e instanceof Error ? e.message : "db read failed"),
+    ),
+  )
+}
+
+export type ProjectFeed = {
+  tools: ToolView[]
+  files: FileView[]
+}
+
+export function emptyProjectFeed(): ProjectFeed {
+  return { tools: [], files: [] }
+}
+
+/** Lazy read — callers gate on the Sessions tab so the queries never run elsewhere. */
+export function readProjectFeed(opts: {
+  dbPath: string
+  sessionIds: string[]
+  toolLimit: number
+  filter?: FileFilter
+}): ProjectFeed {
+  const empty = emptyProjectFeed()
+  if (!opts.dbPath || opts.sessionIds.length === 0 || !fs.existsSync(opts.dbPath)) return empty
+  return profile("db.feed", () =>
+    withDbRead(() => {
+      const db = openReadonlyDb(opts.dbPath)
+      if (!db) return empty
+      return {
+        tools: listRecentToolEvents(db, opts.sessionIds, opts.toolLimit),
+        files: listRecentSessionFiles(db, opts.sessionIds, opts.filter),
+      }
+    }, () => empty),
+  )
+}

package/src/pware.oc.opencode/resolver/pware.oc.opencode.resolver.file.ts

@@ -0,0 +1,162 @@
+/**
+ * pware.oc.core.opencode.resolver.file
+ *
+ * File-touch parts → FileView (basename + optional +/- diff stats). Patch
+ * parts and edit/write/read tool parts count; never bodies or paths in the
+ * panel. Feeds the Current and Sessions tabs.
+ */
+import { fileHitFromExtracted, filesFromPatchJson, type FileFilter, type FileView } from "../pware.oc.opencode.files.js"
+import { str } from "../../pware.oc.core/pware.oc.core.paths.js"
+import { toEpochMs } from "../../pware.oc.core/pware.oc.core.pulse.js"
+import { uniqueIds, type SqlDb } from "../../pware.oc.core/pware.oc.core.sqlite.js"
+import { PART_TYPE_PATCH } from "../../pware.oc.core/constants/pware.oc.core.constants.partType.js"
+
+const FILE_SCAN = 80
+
+type SessionFileRow = {
+  time_updated: number
+  time_created: number
+  kind: string | null
+  tool: string | null
+  filePath: string | null
+  filePath2: string | null
+  filePath3: string | null
+  addMeta: number | null
+  addMeta2: number | null
+  addTop: number | null
+  delMeta: number | null
+  delMeta2: number | null
+  delTop: number | null
+  files: string | null
+}
+
+/** Shared file-part column list — all columns from `part.data` via json_extract. */
+function fileColumns(): string {
+  return [
+    `time_created`,
+    `time_updated`,
+    `json_extract(data,'$.type') AS kind`,
+    `json_extract(data,'$.tool') AS tool`,
+    `json_extract(data,'$.state.input.filePath') AS filePath`,
+    `json_extract(data,'$.input.filePath') AS filePath2`,
+    `json_extract(data,'$.filePath') AS filePath3`,
+    `json_extract(data,'$.state.metadata.additions') AS addMeta`,
+    `json_extract(data,'$.metadata.additions') AS addMeta2`,
+    `json_extract(data,'$.additions') AS addTop`,
+    `json_extract(data,'$.state.metadata.deletions') AS delMeta`,
+    `json_extract(data,'$.metadata.deletions') AS delMeta2`,
+    `json_extract(data,'$.deletions') AS delTop`,
+    `json_extract(data,'$.files') AS files`,
+  ].join(",\n       ")
+}
+
+/** Patch parts + edit/write/read tool parts — what counts as a file touch. */
+function fileWhere(): string {
+  return `(
+    json_extract(data,'$.type') = 'patch'
+    OR (
+      json_extract(data,'$.type') = 'tool'
+       AND json_extract(data,'$.tool') IN ('edit','write','multiedit','read','delete','apply_edit','applyedit','remove','view','read_file','readfile')
+    )
+  )`
+}
+
+/** Patch `files[]` + edit metadata +/- , aggregated by path. No bodies. */
+function fileViewsFromRows(rows: readonly SessionFileRow[], filter?: FileFilter): FileView[] {
+  const byId = new Map<string, FileView>()
+  const add = (f: FileView) => {
+    const prev = byId.get(f.id)
+    byId.set(f.id, {
+      id: f.id,
+      name: f.name,
+      additions: (prev?.additions ?? 0) + f.additions,
+      deletions: (prev?.deletions ?? 0) + f.deletions,
+      at: Math.max(f.at, prev?.at ?? 0),
+      touch: prev?.touch === "write" || f.touch === "write" ? "write" : "read",
+      letter: f.letter ?? prev?.letter ?? null,
+    })
+  }
+  for (const row of rows) {
+    const at = toEpochMs(row.time_updated) ?? toEpochMs(row.time_created) ?? 0
+    if (str(row.kind) === PART_TYPE_PATCH) {
+      for (const f of filesFromPatchJson(row.files, at, filter)) add(f)
+      continue
+    }
+    const hit = fileHitFromExtracted({
+      tool: str(row.tool),
+      filePath: str(row.filePath) || str(row.filePath2) || str(row.filePath3),
+      additions: row.addMeta ?? row.addMeta2 ?? row.addTop,
+      deletions: row.delMeta ?? row.delMeta2 ?? row.delTop,
+      at,
+      filter,
+    })
+    if (hit) add(hit)
+  }
+  return [...byId.values()].sort((a, b) => b.at - a.at)
+}
+
+function listFileRows(db: SqlDb, where: string, params: string[]): SessionFileRow[] {
+  const candidateRows = db.all<{ id: string }>(
+    `SELECT id
+     FROM part
+     WHERE ${where}
+     ORDER BY time_updated DESC
+     LIMIT ${FILE_SCAN}`,
+    ...params,
+  )
+  const ids = candidateRows.map((r) => String(r.id))
+  if (ids.length === 0) return []
+  const saturated = ids.length === FILE_SCAN
+
+  const placeholders = ids.map(() => "?").join(",")
+  const rows = db.all<SessionFileRow>(
+    `SELECT ${fileColumns()}
+     FROM part
+     WHERE id IN (${placeholders})
+       AND ${fileWhere()}
+     ORDER BY time_updated DESC`,
+    ...ids,
+  )
+
+  if (saturated && rows.length < FILE_SCAN) {
+    return db.all<SessionFileRow>(
+      `SELECT ${fileColumns()}
+       FROM part
+       WHERE ${where}
+         AND ${fileWhere()}
+       ORDER BY time_updated DESC
+       LIMIT ${FILE_SCAN}`,
+      ...params,
+    )
+  }
+  return rows
+}
+
+/** Patch `files[]` + edit metadata +/- for one session. No bodies. */
+export function listSessionFiles(db: SqlDb, sessionId: string, filter?: FileFilter): FileView[] {
+  let rows: SessionFileRow[] = []
+  try {
+    rows = listFileRows(db, "session_id = ?", [sessionId])
+  } catch {
+    return []
+  }
+  return fileViewsFromRows(rows, filter)
+}
+
+/** Files touched by any of the given sessions, aggregated — the Sessions tab feed. */
+export function listRecentSessionFiles(
+  db: SqlDb,
+  sessionIds: string[],
+  filter?: FileFilter,
+): FileView[] {
+  const clean = uniqueIds(sessionIds)
+  if (clean.length === 0) return []
+  const placeholders = clean.map(() => "?").join(",")
+  let rows: SessionFileRow[] = []
+  try {
+    rows = listFileRows(db, `session_id IN (${placeholders})`, clean)
+  } catch {
+    return []
+  }
+  return fileViewsFromRows(rows, filter)
+}

package/src/pware.oc.opencode/resolver/pware.oc.opencode.resolver.question.ts

@@ -0,0 +1,185 @@
+/**
+ * pware.oc.core.opencode.resolver.question
+ *
+ * Open `question` tool parts across a project — the "waiting on my answer"
+ * queue. A question is open while its state has no end time and its status is
+ * running or pending, or while it is a still-unanswered error/interrupted
+ * part. Scanned **project-wide** (every non-archived session of the project),
+ * not just the current+recent window, so an open question keeps showing after
+ * a restart or a session switch. Lazy read, gated on the My work tab;
+ * soft-fails to [] on a missing/locked DB. The question text and options stay
+ * in the `part.data` blob — never read, never shown.
+ */
+import fs from "node:fs"
+import { str } from "../../pware.oc.core/pware.oc.core.paths.js"
+import { toEpochMs } from "../../pware.oc.core/pware.oc.core.pulse.js"
+import { openReadonlyDb, withDbRead } from "../../pware.oc.core/pware.oc.core.sqlite.js"
+import { toToolStatus } from "../../pware.oc.core/pware.oc.core.status.js"
+import { PART_TYPE_TOOL } from "../../pware.oc.core/constants/pware.oc.core.constants.partType.js"
+import {
+  TOOL_STATUS_COMPLETED,
+  TOOL_STATUS_ERROR,
+  TOOL_STATUS_PENDING,
+  TOOL_STATUS_RUNNING,
+} from "../../pware.oc.core/constants/pware.oc.core.constants.status.js"
+import { TOOL_QUESTION } from "../../pware.oc.core/constants/pware.oc.core.constants.toolName.js"
+import {
+  QUESTION_KIND_ERROR,
+  QUESTION_KIND_INTERRUPTED,
+  QUESTION_KIND_QUESTION,
+  type OpenQuestionKind,
+} from "../constants/pware.oc.opencode.constants.questionKind.js"
+
+export type { OpenQuestionKind }
+
+export type OpenQuestion = {
+  partId: string
+  sessionId: string
+  /** The session's own title — the question's session may sit outside the recent window. */
+  title: string
+  startedAt: number | null
+  kind: OpenQuestionKind
+  /** `state.error` text for interrupted/error parts; null for an open question. */
+  reason: string | null
+  /**
+   * True when the part has a terminal end time. An ended plain error is kept in
+   * the queue for the Errors group, but it is no longer "live" — the tab light
+   * must not treat it as something happening right now. Absent = still live.
+   */
+  ended?: boolean
+}
+
+/** Raw SELECT row for an open-question scan. Metadata only — never part.data text. */
+export type OpenQuestionRow = {
+  id: string
+  session_id: string
+  title: string | null
+  time_created: number
+  status: string | null
+  tstart: number | null
+  tend: number | null
+  error: string | null
+  interrupted: number | null
+}
+
+/**
+ * Classify one SELECT row into an open question, or null when the part is not
+ * part of the queue (resolved / completed / a still-terminated interrupt).
+ * Pure — the same row always maps to the same answer.
+ */
+export function classifyQuestionRow(row: OpenQuestionRow): OpenQuestion | null {
+  const start = toEpochMs(row.tstart)
+  const end = toEpochMs(row.tend)
+  const status = toToolStatus(
+    str(row.status) || (end != null ? TOOL_STATUS_COMPLETED : start != null ? TOOL_STATUS_RUNNING : null),
+  )
+  if (status !== TOOL_STATUS_RUNNING && status !== TOOL_STATUS_PENDING && status !== TOOL_STATUS_ERROR) return null
+  const interrupted = row.interrupted === 1
+  // An interrupted question that terminated (has an end time) is resolved:
+  // the abort closed the tool and no answer is pending. Only a still-open
+  // interrupted part (no end time) stays "your call".
+  if (interrupted && end != null) return null
+  const reason = str(row.error) || null
+  const kind: OpenQuestionKind =
+    status === TOOL_STATUS_ERROR
+      ? interrupted
+        ? QUESTION_KIND_INTERRUPTED
+        : QUESTION_KIND_ERROR
+      : QUESTION_KIND_QUESTION
+  return {
+    partId: row.id,
+    sessionId: row.session_id,
+    title: str(row.title) || "untitled",
+    startedAt: start ?? toEpochMs(row.time_created),
+    kind,
+    reason: kind === QUESTION_KIND_QUESTION ? null : reason,
+    ended: end != null,
+  }
+}
+
+export function listOpenQuestions(opts: {
+  dbPath: string
+  projectId: string | null
+}): OpenQuestion[] {
+  if (!opts.dbPath || !opts.projectId || !fs.existsSync(opts.dbPath)) return []
+  return withDbRead(() => {
+    const db = openReadonlyDb(opts.dbPath)
+    if (!db) return []
+    let rows: OpenQuestionRow[] = []
+    try {
+      rows = db.all<OpenQuestionRow>(
+        `SELECT p.id AS id,
+                p.session_id,
+                s.title AS title,
+                p.time_created,
+                json_extract(p.data,'$.state.status') AS status,
+                json_extract(p.data,'$.state.time.start') AS tstart,
+                json_extract(p.data,'$.state.time.end') AS tend,
+                json_extract(p.data,'$.state.error') AS error,
+                json_extract(p.data,'$.state.metadata.interrupted') AS interrupted
+         FROM part p
+         JOIN session s ON s.id = p.session_id
+         WHERE json_extract(p.data,'$.type') = '${PART_TYPE_TOOL}'
+           AND json_extract(p.data,'$.tool') = '${TOOL_QUESTION}'
+           AND (s.time_archived IS NULL OR s.time_archived = 0)
+           AND s.project_id = ?
+         ORDER BY p.time_created DESC
+         LIMIT 80`,
+        opts.projectId,
+      )
+    } catch {
+      return []
+    }
+    return rows
+      .map(classifyQuestionRow)
+      .filter((q): q is OpenQuestion => q != null)
+  }, () => [])
+}
+
+/**
+ * Session-scoped open questions. Same SELECT columns and filters as
+ * `listOpenQuestions`, but `WHERE p.session_id = ?` rides `part_session_idx`
+ * for a cheap targeted re-read. Foundation for later event-driven invalidation
+ * of the "My work" queue.
+ */
+export function listSessionQuestions(opts: {
+  dbPath: string
+  sessionId: string
+  projectId: string | null
+}): OpenQuestion[] {
+  if (!opts.dbPath || !opts.sessionId || !opts.projectId || !fs.existsSync(opts.dbPath)) return []
+  return withDbRead(() => {
+    const db = openReadonlyDb(opts.dbPath)
+    if (!db) return []
+    let rows: OpenQuestionRow[] = []
+    try {
+      rows = db.all<OpenQuestionRow>(
+        `SELECT p.id AS id,
+                p.session_id,
+                s.title AS title,
+                p.time_created,
+                json_extract(p.data,'$.state.status') AS status,
+                json_extract(p.data,'$.state.time.start') AS tstart,
+                json_extract(p.data,'$.state.time.end') AS tend,
+                json_extract(p.data,'$.state.error') AS error,
+                json_extract(p.data,'$.state.metadata.interrupted') AS interrupted
+         FROM part p
+         JOIN session s ON s.id = p.session_id
+         WHERE p.session_id = ?
+           AND json_extract(p.data,'$.type') = '${PART_TYPE_TOOL}'
+           AND json_extract(p.data,'$.tool') = '${TOOL_QUESTION}'
+           AND (s.time_archived IS NULL OR s.time_archived = 0)
+           AND s.project_id = ?
+         ORDER BY p.time_created DESC
+         LIMIT 20`,
+        opts.sessionId,
+        opts.projectId,
+      )
+    } catch {
+      return []
+    }
+    return rows
+      .map(classifyQuestionRow)
+      .filter((q): q is OpenQuestion => q != null)
+  }, () => [])
+}