opencode-extended-sidebar 0.2.90

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

@@ -0,0 +1,211 @@
+/**
+ * pware.oc.core.opencode.resolver.session
+ *
+ * Session rows → SessionView plus the hierarchy queries (current, children,
+ * siblings, recent mains, lookups by id). Read-only against opencode.db.
+ */
+import { uniqueIds, type SqlDb } from "../../pware.oc.core/pware.oc.core.sqlite.js"
+import {
+  SESSION_STATE_ARCHIVED,
+  SESSION_STATE_AWAITING_BACKGROUND,
+  SESSION_STATE_IDLE,
+  SESSION_STATE_STREAMING,
+  SESSION_STATE_UNKNOWN,
+  SESSION_STATUS_ARCHIVED,
+  SESSION_STATUS_IDLE,
+  SESSION_STATUS_RUNNING,
+  SESSION_STATUS_UNKNOWN,
+  type AgentStatus,
+  type SessionState,
+} from "../constants/pware.oc.opencode.constants.sessionStatus.js"
+
+export type { AgentStatus, SessionState }
+
+export type SessionRow = {
+  id: string
+  project_id: string
+  parent_id: string | null
+  directory: string
+  title: string
+  agent: string | null
+  model: string | null
+  cost: number
+  tokens_input: number
+  tokens_output: number
+  tokens_reasoning: number
+  time_created: number
+  time_updated: number
+  time_archived: number | null
+  /** 1 when the session has at least one part, 0 for an empty shell (ghost). */
+  has_content: number
+}
+
+/** Finer-grained "is this session still working" state for approval rows. */
+export type SessionActivityState = {
+  running: boolean
+  state: SessionState
+}
+
+export type SessionView = {
+  id: string
+  title: string
+  agent: string
+  status: AgentStatus
+  isMain: boolean
+  parentId: string | null
+  directory: string
+  tokensTotal: number
+  cost: number
+  timeUpdated: number
+  ageMs: number
+  hasContent: boolean
+}
+
+const RUNNING_MS = 2 * 60 * 1000
+
+const SESSION_SELECT = `
+  id, project_id, parent_id, directory, title, agent, model,
+  cost, tokens_input, tokens_output, tokens_reasoning,
+  time_created, time_updated, time_archived,
+  EXISTS (SELECT 1 FROM part WHERE part.session_id = session.id) AS has_content
+`
+
+export function inferStatus(row: SessionRow, now = Date.now()): AgentStatus {
+  if (row.time_archived) return SESSION_STATUS_ARCHIVED
+  const age = now - (row.time_updated || 0)
+  if (age < 0) return SESSION_STATUS_UNKNOWN
+  if (age <= RUNNING_MS) return SESSION_STATUS_RUNNING
+  return SESSION_STATUS_IDLE
+}
+
+export function toSessionView(row: SessionRow, now = Date.now()): SessionView {
+  const ti = row.tokens_input || 0
+  const to = row.tokens_output || 0
+  const tr = row.tokens_reasoning || 0
+  return {
+    id: row.id,
+    title: row.title?.trim() || "untitled",
+    agent: row.agent?.trim() || "unknown",
+    status: inferStatus(row, now),
+    isMain: !row.parent_id,
+    parentId: row.parent_id,
+    directory: row.directory,
+    tokensTotal: ti + to + tr,
+    cost: row.cost || 0,
+    timeUpdated: row.time_updated,
+    ageMs: Math.max(0, now - (row.time_updated || 0)),
+    hasContent: row.has_content === 1,
+  }
+}
+
+/** A session with real content (≥1 part). A ghost — created but never prompted — is false. */
+export function isRealSession(view: Pick<SessionView, "hasContent"> | null | undefined): boolean {
+  return Boolean(view?.hasContent)
+}
+
+/**
+ * Recompute a `SessionView` status against a fresh clock. The live snapshot
+ * cache refreshes `ageMs` on every hit, so `status` (also age-derived) must be
+ * refreshed with it — otherwise a session that went idle keeps reading running.
+ */
+export function refreshSessionStatus(view: SessionView, now: number): AgentStatus {
+  if (view.status === SESSION_STATUS_ARCHIVED) return SESSION_STATUS_ARCHIVED
+  const age = now - view.timeUpdated
+  if (age < 0) return SESSION_STATUS_UNKNOWN
+  if (age <= RUNNING_MS) return SESSION_STATUS_RUNNING
+  return SESSION_STATUS_IDLE
+}
+
+export function getSessionById(db: SqlDb, id: string): SessionRow | null {
+  return db.get<SessionRow>(
+    `SELECT ${SESSION_SELECT} FROM session WHERE id = ? LIMIT 1`,
+    id,
+  )
+}
+
+/**
+ * Is this session still working, and how? Streaming = a fresh `time_updated`;
+ * awaiting-background = stale in SQLite but the caller's already-resolved
+ * `backgroundTaskActive` (`.omo/run-continuation` marker) is true;
+ * idle/archived/unknown otherwise. The omo layer resolves the marker — this
+ * opencode function never reads omo files.
+ */
+export function sessionActivityState(
+  db: SqlDb,
+  sessionId: string,
+  opts?: { backgroundTaskActive?: boolean | null; now?: number },
+): SessionActivityState {
+  const row = getSessionById(db, sessionId)
+  if (!row) return { running: false, state: SESSION_STATE_UNKNOWN }
+  if (row.time_archived) return { running: false, state: SESSION_STATE_ARCHIVED }
+  const now = opts?.now ?? Date.now()
+  if (now - row.time_updated <= RUNNING_MS) return { running: true, state: SESSION_STATE_STREAMING }
+  if (opts?.backgroundTaskActive) return { running: true, state: SESSION_STATE_AWAITING_BACKGROUND }
+  return { running: false, state: SESSION_STATE_IDLE }
+}
+
+export function listChildSessions(db: SqlDb, parentId: string): SessionRow[] {
+  return db.all<SessionRow>(
+    `SELECT ${SESSION_SELECT} FROM session WHERE parent_id = ? ORDER BY time_updated DESC LIMIT 40`,
+    parentId,
+  )
+}
+
+export function listSiblingSessions(db: SqlDb, parentId: string, excludeId: string): SessionRow[] {
+  return db.all<SessionRow>(
+    `SELECT ${SESSION_SELECT} FROM session
+     WHERE parent_id = ? AND id != ?
+     ORDER BY time_updated DESC LIMIT 40`,
+    parentId,
+    excludeId,
+  )
+}
+
+const RECENT_LIMIT = 4
+
+export function listRecentMainSessions(
+  db: SqlDb,
+  opts: { projectId: string; limit?: number },
+): SessionRow[] {
+  const limit = Math.max(1, Math.min(opts.limit ?? RECENT_LIMIT, 20))
+  try {
+    return db.all<SessionRow>(
+      `SELECT ${SESSION_SELECT} FROM session
+       WHERE parent_id IS NULL
+         AND (time_archived IS NULL OR time_archived = 0)
+         AND project_id = ?
+         AND EXISTS (SELECT 1 FROM part WHERE part.session_id = session.id)
+       ORDER BY time_updated DESC
+       LIMIT ${limit}`,
+      opts.projectId,
+    )
+  } catch {
+    return []
+  }
+}
+
+export function getSessionsByIds(db: SqlDb, ids: string[]): SessionRow[] {
+  const clean = uniqueIds(ids)
+  if (clean.length === 0) return []
+  const placeholders = clean.map(() => "?").join(",")
+  return db.all<SessionRow>(
+    `SELECT ${SESSION_SELECT} FROM session WHERE id IN (${placeholders})`,
+    ...clean,
+  )
+}
+
+export function sessionScanStamp(db: SqlDb, sessionId: string): string {
+  try {
+    const s = db.get<{ time_updated: number }>(
+      `SELECT time_updated FROM session WHERE id = ? LIMIT 1`,
+      sessionId,
+    )
+    const p = db.get<{ m: number | null }>(
+      `SELECT MAX(time_updated) AS m FROM part WHERE session_id = ?`,
+      sessionId,
+    )
+    return `${s?.time_updated ?? 0}|${p?.m ?? 0}`
+  } catch {
+    return "x"
+  }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * pware.oc.core.opencode.resolver.todo
+ *
+ * Todo rows for one session — content, status, priority, position.
+ */
+import type { SqlDb } from "../../pware.oc.core/pware.oc.core.sqlite.js"
+
+export type TodoRow = {
+  content: string
+  status: string
+  priority: string
+  position: number
+}
+
+export function listTodos(db: SqlDb, sessionId: string): TodoRow[] {
+  try {
+    return db.all<TodoRow>(
+      `SELECT content, status, priority, position
+       FROM todo WHERE session_id = ?
+       ORDER BY position ASC LIMIT 40`,
+      sessionId,
+    )
+  } catch {
+    return []
+  }
+}

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

@@ -0,0 +1,236 @@
+/**
+ * pware.oc.core.opencode.resolver.tool
+ *
+ * Tool-call parts → ToolView (name, status, timings). Metadata only — never
+ * args or outputs. Feeds the Current and Sessions tabs.
+ */
+import { preferToolLabel, shortToolLabel, toEpochMs, type ToolHit } from "../../pware.oc.core/pware.oc.core.pulse.js"
+import { str } from "../../pware.oc.core/pware.oc.core.paths.js"
+import { uniqueIds, type SqlDb } from "../../pware.oc.core/pware.oc.core.sqlite.js"
+import { toToolStatus, type ToolStatus } from "../../pware.oc.core/pware.oc.core.status.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 { PART_TYPE_TOOL } from "../../pware.oc.core/constants/pware.oc.core.constants.partType.js"
+
+export type { ToolStatus }
+
+export { toToolStatus as normalizeToolStatus }
+
+export type ToolView = {
+  id: string
+  callId?: string | null
+  /** Display label: command / file / task description, not just "bash" or "task". */
+  name: string
+  tool: string
+  status: ToolStatus
+  startedAt: number | null
+  endedAt: number | null
+  durationMs: number | null
+}
+
+const TOOL_SCAN = 80
+const TOOL_ROWS = 8
+
+/** Metadata only — json_extract, never the part blob. */
+type ToolEventRow = {
+  id: string
+  time_created: number
+  time_updated: number
+  tool: string | null
+  callID: string | null
+  status: string | null
+  tstart: number | null
+  tend: number | null
+  title: string | null
+  command: string | null
+  command2: string | null
+  filePath: string | null
+  filePath2: string | null
+  pattern: string | null
+  pattern2: string | null
+  description: string | null
+  description2: string | null
+  subagent: string | null
+  category: string | null
+}
+
+/** Shared tool-part column list — all columns from `part.data` via json_extract. */
+function toolColumns(): string {
+  return [
+    `id`,
+    `time_created`,
+    `time_updated`,
+    `json_extract(data,'$.tool') AS tool`,
+    `json_extract(data,'$.callID') AS callID`,
+    `json_extract(data,'$.state.status') AS status`,
+    `json_extract(data,'$.state.time.start') AS tstart`,
+    `json_extract(data,'$.state.time.end') AS tend`,
+    `json_extract(data,'$.state.title') AS title`,
+    `json_extract(data,'$.state.input.command') AS command`,
+    `json_extract(data,'$.input.command') AS command2`,
+    `json_extract(data,'$.state.input.filePath') AS filePath`,
+    `json_extract(data,'$.input.filePath') AS filePath2`,
+    `json_extract(data,'$.state.input.pattern') AS pattern`,
+    `json_extract(data,'$.input.pattern') AS pattern2`,
+    `json_extract(data,'$.state.input.description') AS description`,
+    `json_extract(data,'$.input.description') AS description2`,
+    `json_extract(data,'$.state.input.subagent_type') AS subagent`,
+    `json_extract(data,'$.state.input.category') AS category`,
+  ].join(",\n       ")
+}
+
+function toolViewsFromRows(rows: readonly ToolEventRow[], limit: number): ToolView[] {
+  const out: ToolView[] = []
+  for (const row of rows) {
+    const tool = str(row.tool) || "tool"
+    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),
+    )
+    const startedAt = start ?? toEpochMs(row.time_created)
+    const endedAt =
+      end ??
+      (status === TOOL_STATUS_COMPLETED || status === TOOL_STATUS_ERROR ? toEpochMs(row.time_updated) : null)
+    const durationMs =
+      startedAt != null && endedAt != null && endedAt >= startedAt ? endedAt - startedAt : null
+    out.push({
+      id: String(row.id),
+      callId: str(row.callID),
+      tool,
+      name: shortToolLabel({
+        tool,
+        title: str(row.title),
+        command: str(row.command) || str(row.command2),
+        filePath: str(row.filePath) || str(row.filePath2),
+        pattern: str(row.pattern) || str(row.pattern2),
+        description: str(row.description) || str(row.description2),
+        subagent: str(row.subagent) || str(row.category),
+      }),
+      status,
+      startedAt,
+      endedAt,
+      durationMs,
+    })
+    if (out.length >= limit) break
+  }
+  return out
+}
+
+function listToolRows(db: SqlDb, where: string, params: string[], limit: number): ToolEventRow[] {
+  const candidateRows = db.all<{ id: string }>(
+    `SELECT id
+     FROM part
+     WHERE ${where}
+     ORDER BY time_created DESC
+     LIMIT ${TOOL_SCAN}`,
+    ...params,
+  )
+  const ids = candidateRows.map((r) => String(r.id))
+  if (ids.length === 0) return []
+  const saturated = ids.length === TOOL_SCAN
+
+  const placeholders = ids.map(() => "?").join(",")
+  const rows = db.all<ToolEventRow>(
+    `SELECT ${toolColumns()}
+     FROM part
+     WHERE id IN (${placeholders})
+       AND json_extract(data,'$.type') = '${PART_TYPE_TOOL}'
+     ORDER BY time_created DESC
+     LIMIT ${limit}`,
+    ...ids,
+  )
+
+  if (saturated && rows.length < limit) {
+    return db.all<ToolEventRow>(
+      `SELECT ${toolColumns()}
+       FROM part
+       WHERE ${where}
+         AND json_extract(data,'$.type') = '${PART_TYPE_TOOL}'
+       ORDER BY time_created DESC
+       LIMIT ${TOOL_SCAN}`,
+      ...params,
+    )
+  }
+  return rows
+}
+
+/** Newest tool parts of one session — the Current tab feed. */
+export function listToolEvents(db: SqlDb, sessionId: string, limit = TOOL_ROWS): ToolView[] {
+  let rows: ToolEventRow[] = []
+  try {
+    rows = listToolRows(db, "session_id = ?", [sessionId], limit)
+  } catch {
+    return []
+  }
+  return toolViewsFromRows(rows, limit)
+}
+
+/** Newest tool parts across the given sessions — the Sessions tab feed. */
+export function listRecentToolEvents(db: SqlDb, sessionIds: string[], limit = TOOL_ROWS): ToolView[] {
+  const clean = uniqueIds(sessionIds)
+  if (clean.length === 0) return []
+  const placeholders = clean.map(() => "?").join(",")
+  let rows: ToolEventRow[] = []
+  try {
+    rows = listToolRows(db, `session_id IN (${placeholders})`, clean, limit)
+  } catch {
+    return []
+  }
+  return toolViewsFromRows(rows, limit)
+}
+
+export function mergeTools(
+  dbTools: ToolView[],
+  live: Record<string, ToolHit>,
+  now: number,
+  limit: number,
+): ToolView[] {
+  // DB rows are keyed by the part id (`prt_…`) but carry the callID (`call_…`);
+  // live events reference only the callID. Key both sides by callID so a live
+  // hit lands on the same slot as its DB row, or the same call renders twice.
+  // A live hit fills in a running start it saw first, but once the DB row has
+  // the real endedAt/duration, the live event must not clobber them — the panel
+  // sorts finished calls by endedAt, and `now` would keep reordering them.
+  const byId = new Map<string, ToolView>()
+  const byCall = new Map<string, string>()
+  for (const t of dbTools) {
+    const key = t.callId || t.id
+    byId.set(key, t)
+    if (t.callId && t.callId !== t.id) byCall.set(t.id, key)
+  }
+  for (const hit of Object.values(live)) {
+    const key = byCall.get(hit.id) ?? hit.id
+    const prev = byId.get(key)
+    if (prev && (prev.status === TOOL_STATUS_COMPLETED || prev.status === TOOL_STATUS_ERROR) && hit.status === TOOL_STATUS_RUNNING) {
+      continue
+    }
+    byId.set(key, {
+      id: prev?.id ?? hit.id,
+      callId: prev?.callId ?? null,
+      name: preferToolLabel(hit.name, prev?.name),
+      tool: prev?.tool || "tool",
+      status: hit.status,
+      startedAt: prev?.startedAt ?? now,
+      endedAt: hit.status === TOOL_STATUS_RUNNING ? null : (prev?.endedAt ?? now),
+      durationMs:
+        hit.status === TOOL_STATUS_RUNNING
+          ? null
+          : prev?.durationMs ?? (prev?.startedAt != null ? Math.max(0, now - prev.startedAt) : null),
+    })
+  }
+  return [...byId.values()]
+    .sort((a, b) => {
+      const ar = a.status === TOOL_STATUS_RUNNING || a.status === TOOL_STATUS_PENDING ? 0 : 1
+      const br = b.status === TOOL_STATUS_RUNNING || b.status === TOOL_STATUS_PENDING ? 0 : 1
+      if (ar !== br) return ar - br
+      const at = ar === 0 ? (a.startedAt ?? 0) : (a.endedAt ?? a.startedAt ?? 0)
+      const bt = br === 0 ? (b.startedAt ?? 0) : (b.endedAt ?? b.startedAt ?? 0)
+      return bt - at
+    })
+    .slice(0, limit)
+}

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

@@ -0,0 +1,14 @@
+/**
+ * pware.oc.perf
+ *
+ * Turn-timing analysis: reader + TUI view.
+ */
+export * from "./pware.oc.perf.reader.js"
+export * from "./pware.oc.perf.self.js"
+export * from "./pware.oc.perf.charts.js"
+export * from "./pware.oc.perf.realtime.js"
+export * from "./pware.oc.perf.realtimeBlock.js"
+export * from "./pware.oc.perf.realtimeTimeline.js"
+export * from "./pware.oc.perf.realtimeSampler.js"
+export * from "./pware.oc.perf.realtimeCpuRam.js"
+export * from "./pware.oc.perf.view.js"

package/src/pware.oc.perf/pware.oc.perf.asciichart.d.ts

@@ -0,0 +1,15 @@
+declare module "asciichart" {
+  export function plot(
+    series: number[] | number[][],
+    config?: {
+      min?: number
+      max?: number
+      offset?: number
+      padding?: string
+      height?: number
+      colors?: string[]
+      symbols?: string[]
+      format?: (x: number, i: number) => string
+    },
+  ): string
+}