opencode-extended-sidebar 0.2.90

package/src/pware.oc.omo/resolver/pware.oc.omo.resolver.planFile.ts

@@ -0,0 +1,361 @@
+/**
+ * pware.oc.omo.resolver.planFile
+ *
+ * Omo-file → writer-session index. Reads the OpenCode SQLite database through
+ * a raw `SqlDb` handle to map `.omo/` / `.sisyphus/` document files to the
+ * session that last wrote them. Lives in the omo layer because omo may read
+ * opencode data (one-way relaxation): the index needs the session/part rows,
+ * not any opencode-layer code.
+ *
+ * One generic engine (`omoFileIndex` / `sessionForOmoFile`) serves every
+ * document kind; the plan/draft index (`planSessionIndex` /
+ * `sessionForPlanFile`) is a legacy specialisation that folds plans and drafts
+ * into one map so a session's latest plan is preferred over its latest draft.
+ */
+import { createStampCache } from "../../pware.oc.core/pware.oc.core.cache.js"
+import { basenameOf, str } from "../../pware.oc.core/pware.oc.core.paths.js"
+import type { SqlDb } from "../../pware.oc.core/pware.oc.core.sqlite.js"
+import { DOC_KIND_PLAN, type DocKind } from "../constants/pware.oc.omo.constants.docKind.js"
+import {
+  listOmoFiles,
+  type DocView,
+  type ListOmoFilesOptions,
+} from "./pware.oc.omo.resolver.doc.js"
+
+/** Every OMO on-disk document kind (the subdirectory under `.omo/` / `.sisyphus/`). */
+export const OMO_FILE_KINDS = [
+  "plan",
+  "draft",
+  "notepad",
+  "proof",
+  "rule",
+  "run-continuation",
+] as const
+
+/** An OMO on-disk document kind. */
+export type OmoFileKind = (typeof OMO_FILE_KINDS)[number]
+
+/** One case-insensitive regex per kind matching the omo/sisyphus subdir. */
+const OMO_FILE_KIND_RE: Record<OmoFileKind, RegExp> = {
+  plan: /\.(omo|sisyphus)\/plans\//i,
+  draft: /\.(omo|sisyphus)\/drafts\//i,
+  notepad: /\.(omo|sisyphus)\/notepads\//i,
+  proof: /\.(omo|sisyphus)\/evidence\//i,
+  rule: /\.(omo|sisyphus)\/rules\//i,
+  "run-continuation": /\.(omo|sisyphus)\/run-continuation\//i,
+}
+
+export type PlanSessionIndex = {
+  fileWriter: Map<string, { sessionId: string; lastAt: number }>
+  sessionPlan: Map<string, { rel: string; lastAt: number; isPlan: boolean }>
+}
+
+export type OmoFileIndex = {
+  fileWriter: Map<string, { sessionId: string; lastAt: number }>
+  sessionFiles: Map<string, { rel: string; lastAt: number }>
+}
+
+const PLAN_FILE_RE = /\.(omo|sisyphus)\/(drafts|plans)\//i
+
+/**
+ * Normalise `fp` to a project-relative posix path, match it against `regex`,
+ * and slice to the marker start. `projectRoot` strips the absolute prefix;
+ * without it the fp is used as-is and the marker may sit mid-path. Null when
+ * the path does not match `regex`.
+ */
+function omoRelOf(
+  fp: string,
+  projectRoot: string | null | undefined,
+  regex: RegExp,
+): string | null {
+  let rel = fp.replace(/\\/g, "/").trim()
+  if (!rel) return null
+  if (projectRoot) {
+    const root = projectRoot.replace(/\\/g, "/").replace(/\/+$/, "")
+    if (rel.toLowerCase().startsWith(root.toLowerCase() + "/")) {
+      rel = rel.slice(root.length + 1)
+    } else if (rel.toLowerCase() === root.toLowerCase()) {
+      rel = ""
+    }
+  }
+  const m = rel.match(regex)
+  if (!m) return null
+  const start = m.index ?? 0
+  return start > 0 ? rel.slice(start) : rel
+}
+
+/**
+ * If `fp` is a plan/draft target under `.omo/` or `.sisyphus/`, return its
+ * project-relative path and whether it is under `plans/`. `projectRoot`
+ * strips the absolute prefix; without it the fp is used as-is and the marker
+ * may sit mid-path. Null for anything else (plain source files included).
+ */
+function planFileOf(
+  fp: string,
+  projectRoot: string | null | undefined,
+): { rel: string; isPlan: boolean } | null {
+  const rel = omoRelOf(fp, projectRoot, PLAN_FILE_RE)
+  if (!rel) return null
+  const m = rel.match(PLAN_FILE_RE)
+  return { rel, isPlan: m?.[2]?.toLowerCase() === "plans" }
+}
+
+/** `MAX(part.time_updated)` over the part/session join, or null on error. */
+function partsStampInfo(
+  db: SqlDb,
+  projectId: string | null | undefined,
+): { id: string; max: number } | null {
+  try {
+    const where = projectId ? "session.project_id = ?" : "1=1"
+    const args = projectId ? [projectId] : []
+    const p = db.get<{ m: number | null }>(
+      `SELECT MAX(part.time_updated) AS m
+       FROM part JOIN session ON session.id = part.session_id
+       WHERE ${where}`,
+      ...args,
+    )
+    return { id: projectId ?? "*", max: p?.m ?? 0 }
+  } catch {
+    return null
+  }
+}
+
+function planIndexStamp(db: SqlDb, projectId: string | null | undefined): string {
+  const info = partsStampInfo(db, projectId)
+  return info ? `${info.id}|${info.max}` : "x"
+}
+
+function omoFileStamp(db: SqlDb, projectId: string | null | undefined, kind: OmoFileKind): string {
+  const info = partsStampInfo(db, projectId)
+  return info ? `${info.id}|${kind}|${info.max}` : "x"
+}
+
+/** One write-ish part row: session, resolved filePath, latest write time, and
+ *  whether the session ever `write`-created the file. */
+type FilePartRow = {
+  session_id: string | null
+  fp: string | null
+  last: number | null
+  is_writer: number | null
+}
+
+function queryFileParts(db: SqlDb, projectId: string | null | undefined): FilePartRow[] {
+  const where = projectId ? "session.project_id = ? AND" : ""
+  const args = projectId ? [projectId] : []
+  return db.all<FilePartRow>(
+    `SELECT part.session_id,
+            COALESCE(
+              json_extract(part.data,'$.state.input.filePath'),
+              json_extract(part.data,'$.input.filePath'),
+              json_extract(part.data,'$.filePath')
+            ) AS fp,
+            MAX(part.time_updated) AS last,
+            MAX(CASE WHEN json_extract(part.data,'$.tool')='write' THEN 1 ELSE 0 END) AS is_writer
+     FROM part
+     JOIN session ON session.id = part.session_id
+     WHERE ${where} json_extract(part.data,'$.type')='tool'
+       AND json_extract(part.data,'$.tool') IN ('write','edit','multiedit','apply_edit','applyedit')
+     GROUP BY part.session_id, fp`,
+    ...args,
+  )
+}
+
+function buildPlanSessionIndex(
+  db: SqlDb,
+  projectId: string | null | undefined,
+  projectRoot: string | null | undefined,
+): PlanSessionIndex {
+  const fileWriter = new Map<string, { sessionId: string; lastAt: number }>()
+  const writerPref = new Map<string, number>() // basename → is_writer of the current entry
+  const sessionPlan = new Map<string, { rel: string; lastAt: number; isPlan: boolean }>()
+  try {
+    for (const row of queryFileParts(db, projectId)) {
+      const sessionId = str(row.session_id)
+      const fp = str(row.fp)
+      const last = typeof row.last === "number" && row.last > 0 ? row.last : 0
+      if (!sessionId || !fp) continue
+      const info = planFileOf(fp, projectRoot)
+      if (!info) continue
+      const base = basenameOf(info.rel)
+      const isWriter = row.is_writer === 1 ? 1 : 0
+      const writer = fileWriter.get(base)
+      if (!writer) {
+        fileWriter.set(base, { sessionId, lastAt: last })
+        writerPref.set(base, isWriter)
+      } else {
+        const cur = writerPref.get(base) ?? 0
+        // A `write` creator beats a session that only edited the file, even
+        // when the edit came later; equal preference falls back to the later
+        // timestamp.
+        if (isWriter > cur || (isWriter === cur && last > writer.lastAt)) {
+          fileWriter.set(base, { sessionId, lastAt: last })
+          writerPref.set(base, isWriter)
+        }
+      }
+      const plan = sessionPlan.get(sessionId)
+      if (!plan) {
+        sessionPlan.set(sessionId, { rel: info.rel, lastAt: last, isPlan: info.isPlan })
+      } else if (last > plan.lastAt) {
+        sessionPlan.set(sessionId, { rel: info.rel, lastAt: last, isPlan: info.isPlan })
+      } else if (last === plan.lastAt && info.isPlan && !plan.isPlan) {
+        sessionPlan.set(sessionId, { rel: info.rel, lastAt: last, isPlan: info.isPlan })
+      }
+    }
+  } catch {
+    // soft-fail → empty index
+  }
+  return { fileWriter, sessionPlan }
+}
+
+function buildOmoFileIndex(
+  db: SqlDb,
+  projectId: string | null | undefined,
+  projectRoot: string | null | undefined,
+  kind: OmoFileKind,
+): OmoFileIndex {
+  const fileWriter = new Map<string, { sessionId: string; lastAt: number }>()
+  const writerPref = new Map<string, number>() // basename → is_writer of the current entry
+  const sessionFiles = new Map<string, { rel: string; lastAt: number }>()
+  const regex = OMO_FILE_KIND_RE[kind]
+  try {
+    for (const row of queryFileParts(db, projectId)) {
+      const sessionId = str(row.session_id)
+      const fp = str(row.fp)
+      const last = typeof row.last === "number" && row.last > 0 ? row.last : 0
+      if (!sessionId || !fp) continue
+      const rel = omoRelOf(fp, projectRoot, regex)
+      if (!rel) continue
+      const base = basenameOf(rel)
+      const isWriter = row.is_writer === 1 ? 1 : 0
+      const writer = fileWriter.get(base)
+      if (!writer) {
+        fileWriter.set(base, { sessionId, lastAt: last })
+        writerPref.set(base, isWriter)
+      } else {
+        const cur = writerPref.get(base) ?? 0
+        // A `write` creator beats a session that only edited the file, even
+        // when the edit came later; equal preference falls back to the later
+        // timestamp.
+        if (isWriter > cur || (isWriter === cur && last > writer.lastAt)) {
+          fileWriter.set(base, { sessionId, lastAt: last })
+          writerPref.set(base, isWriter)
+        }
+      }
+      const curFile = sessionFiles.get(sessionId)
+      if (!curFile || last > curFile.lastAt) {
+        sessionFiles.set(sessionId, { rel, lastAt: last })
+      }
+    }
+  } catch {
+    // soft-fail → empty index
+  }
+  return { fileWriter, sessionFiles }
+}
+
+const planIndexCache = createStampCache<PlanSessionIndex>()
+const omoIndexCache = createStampCache<OmoFileIndex>()
+
+/**
+ * In-memory bidirectional plan-file index for one project, built from a single
+ * write-ish `part` join. `fileWriter` maps a plan/draft basename to its latest
+ * writer session; `sessionPlan` maps a session to its latest plan/draft file,
+ * preferring `plans/` over `drafts/` on an equal timestamp. Stamp-cached on the
+ * project's `MAX(part.time_updated)` so it rebuilds only when parts change.
+ */
+export function planSessionIndex(
+  db: SqlDb,
+  projectId: string | null | undefined,
+  projectRoot: string | null | undefined,
+): PlanSessionIndex {
+  return planIndexCache.get(planIndexStamp(db, projectId), () =>
+    buildPlanSessionIndex(db, projectId, projectRoot),
+  )
+}
+
+/**
+ * The session that last wrote a `.omo/` plan/draft file, if any. Matches
+ * write-ish tool parts by the file's basename, so the planner session that
+ * created a pending approval is the one "Continue" should jump to.
+ */
+export function sessionForPlanFile(db: SqlDb, relPath: string | null | undefined): string | null {
+  const base = basenameOf(relPath ?? "")
+  if (!base || base === "file") return null
+  return planSessionIndex(db, null, null).fileWriter.get(base)?.sessionId ?? null
+}
+
+/**
+ * In-memory bidirectional index for one OMO document kind, built from a single
+ * write-ish `part` join. `fileWriter` maps a file basename to its latest writer
+ * session; `sessionFiles` maps a session to its latest file of that kind.
+ * Stamp-cached on the project's `MAX(part.time_updated)` so it rebuilds only
+ * when parts change.
+ */
+export function omoFileIndex(
+  db: SqlDb,
+  projectId: string | null | undefined,
+  projectRoot: string | null | undefined,
+  kind: OmoFileKind,
+): OmoFileIndex {
+  return omoIndexCache.get(omoFileStamp(db, projectId, kind), () =>
+    buildOmoFileIndex(db, projectId, projectRoot, kind),
+  )
+}
+
+/**
+ * The writer session for a rel path from an already-built index. The per-file
+ * half of `sessionForOmoFile`, split out so a caller can filter a whole list
+ * against one index build instead of one stamp lookup per file.
+ */
+export function omoWriterSession(
+  index: OmoFileIndex,
+  relPath: string | null | undefined,
+): string | null {
+  const base = basenameOf(relPath ?? "")
+  if (!base || base === "file") return null
+  return index.fileWriter.get(base)?.sessionId ?? null
+}
+
+/**
+ * The session that last wrote a `.omo/` file of `kind`, if any. Matches
+ * write-ish tool parts by the file's basename.
+ */
+export function sessionForOmoFile(
+  db: SqlDb,
+  relPath: string | null | undefined,
+  kind: OmoFileKind,
+): string | null {
+  return omoWriterSession(omoFileIndex(db, null, null, kind), relPath)
+}
+
+/** A per-kind omo-file resolver: the index builder + the writer-session lookup. */
+export function makeOmoFileResolver(kind: OmoFileKind): {
+  sessionIndex: (
+    db: SqlDb,
+    projectId: string | null | undefined,
+    projectRoot: string | null | undefined,
+  ) => OmoFileIndex
+  sessionForFile: (db: SqlDb, relPath: string | null | undefined) => string | null
+} {
+  return {
+    sessionIndex: (db, projectId, projectRoot) => omoFileIndex(db, projectId, projectRoot, kind),
+    sessionForFile: (db, relPath) => sessionForOmoFile(db, relPath, kind),
+  }
+}
+
+/** A per-doc-kind `.list` wrapper — the `XxxFile.list` shape. */
+export function makeOmoFileList(docKind: DocKind): {
+  list: (
+    projectRoot: string | null | undefined,
+    sessionId?: string | null,
+    opts?: ListOmoFilesOptions,
+  ) => DocView[]
+} {
+  return {
+    list(projectRoot, sessionId = null, opts = {}) {
+      return listOmoFiles(docKind, projectRoot, { ...opts, sessionId })
+    },
+  }
+}
+
+/** Plan files under `.omo/plans/`, optionally filtered by writer session. */
+export const PlanFile = makeOmoFileList(DOC_KIND_PLAN)

package/src/pware.oc.omo/resolver/pware.oc.omo.resolver.proofFile.ts

@@ -0,0 +1,18 @@
+/**
+ * pware.oc.omo.resolver.proofFile
+ *
+ * Evidence (proof) file → writer-session index. Thin re-export of the shared
+ * omo file engine (`planFile.ts`), pinned to the `.omo/evidence/` document kind.
+ */
+import { DOC_KIND_PROOF } from "../constants/pware.oc.omo.constants.docKind.js"
+import {
+  makeOmoFileList,
+  makeOmoFileResolver,
+} from "./pware.oc.omo.resolver.planFile.js"
+
+/** Bidirectional evidence-file index for one project (see `omoFileIndex`). */
+export const { sessionIndex: proofSessionIndex, sessionForFile: sessionForProofFile } =
+  makeOmoFileResolver("proof")
+
+/** Evidence files under `.omo/evidence/`, optionally filtered by writer session. */
+export const ProofFile = makeOmoFileList(DOC_KIND_PROOF)

package/src/pware.oc.omo/resolver/pware.oc.omo.resolver.rulesFile.ts

@@ -0,0 +1,11 @@
+/**
+ * pware.oc.omo.resolver.rulesFile
+ *
+ * Rule-file → writer-session index. Thin re-export of the shared omo file
+ * engine (`planFile.ts`), pinned to the `.omo/rules/` document kind.
+ */
+import { makeOmoFileResolver } from "./pware.oc.omo.resolver.planFile.js"
+
+/** Bidirectional rule-file index for one project (see `omoFileIndex`). */
+export const { sessionIndex: rulesSessionIndex, sessionForFile: sessionForRuleFile } =
+  makeOmoFileResolver("rule")

package/src/pware.oc.omo/resolver/pware.oc.omo.resolver.runContinuationFile.ts

@@ -0,0 +1,14 @@
+/**
+ * pware.oc.omo.resolver.runContinuationFile
+ *
+ * Run-continuation file → writer-session index. Thin re-export of the shared
+ * omo file engine (`planFile.ts`), pinned to the `.omo/run-continuation/`
+ * document kind.
+ */
+import { makeOmoFileResolver } from "./pware.oc.omo.resolver.planFile.js"
+
+/** Bidirectional run-continuation index for one project (see `omoFileIndex`). */
+export const {
+  sessionIndex: runContinuationSessionIndex,
+  sessionForFile: sessionForRunContinuationFile,
+} = makeOmoFileResolver("run-continuation")

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

@@ -0,0 +1,10 @@
+/**
+ * pware.oc.opencode.constants
+ *
+ * Single source of truth for the OpenCode-domain string literals: session
+ * statuses and activity states, question-tool kinds, and file-touch kinds.
+ */
+export * from "./pware.oc.opencode.constants.sessionStatus.js"
+export * from "./pware.oc.opencode.constants.questionKind.js"
+export * from "./pware.oc.opencode.constants.fileTouch.js"
+export * from "./pware.oc.opencode.constants.eventName.js"

package/src/pware.oc.opencode/constants/pware.oc.opencode.constants.eventName.ts

@@ -0,0 +1,15 @@
+export const EV_OC_SESSION_ACTIVITY = "pware.oc.session.activity"
+export const EV_OC_FLOW = "pware.oc.flow"
+export const EV_OC_TOOL_HIT = "pware.oc.tool.hit"
+export const EV_OC_FILES_TOUCHED = "pware.oc.files.touched"
+export const EV_OC_TOKENS_DELTA = "pware.oc.tokens.delta"
+
+export const OC_EVENT_NAMES = [
+  EV_OC_SESSION_ACTIVITY,
+  EV_OC_FLOW,
+  EV_OC_TOOL_HIT,
+  EV_OC_FILES_TOUCHED,
+  EV_OC_TOKENS_DELTA,
+] as const
+
+export type OcEventName = (typeof OC_EVENT_NAMES)[number]

package/src/pware.oc.opencode/constants/pware.oc.opencode.constants.fileTouch.ts

@@ -0,0 +1,18 @@
+/**
+ * pware.oc.opencode.constants.filetouch
+ *
+ * OpenCode file-touch kinds: whether a tool call reads or writes a file.
+ * Classified in `pware.oc.opencode/pware.oc.opencode.files.ts`.
+ */
+
+/** File touch: the tool read/viewed the file. */
+export const FILE_TOUCH_READ = "read"
+
+/** File touch: the tool wrote/deleted the file. */
+export const FILE_TOUCH_WRITE = "write"
+
+/** Every file-touch kind. */
+export const FILE_TOUCHES = [FILE_TOUCH_READ, FILE_TOUCH_WRITE] as const
+
+/** A file-touch kind. */
+export type FileTouch = (typeof FILE_TOUCHES)[number]

package/src/pware.oc.opencode/constants/pware.oc.opencode.constants.questionKind.ts

@@ -0,0 +1,45 @@
+/**
+ * pware.oc.opencode.constants.questionkind
+ *
+ * OpenCode `question` tool-part kinds: what an open question means for the
+ * "My work" queue. Classified in
+ * `pware.oc.opencode/resolver/pware.oc.opencode.resolver.question.ts`:
+ * - `question` — the agent is live and waiting for an answer (running/pending).
+ * - `interrupted` — the tool was aborted (`metadata.interrupted`), the answer
+ *   never came, but the session moved on or died — still your call.
+ * - `error` — the tool genuinely failed (no answer, no interrupt marker).
+ */
+
+/** Question kind: the agent is live and waiting for an answer. */
+export const QUESTION_KIND_QUESTION = "question"
+
+/** Question kind: the tool was aborted — the answer never came. */
+export const QUESTION_KIND_INTERRUPTED = "interrupted"
+
+/** Question kind: the tool genuinely failed. */
+export const QUESTION_KIND_ERROR = "error"
+
+/** Every open-question kind. */
+export const QUESTION_KINDS = [
+  QUESTION_KIND_QUESTION,
+  QUESTION_KIND_INTERRUPTED,
+  QUESTION_KIND_ERROR,
+] as const
+
+/** An open-question kind. */
+export type OpenQuestionKind = (typeof QUESTION_KINDS)[number]
+
+/** True when the open question is live and awaiting an answer. */
+export function isWaitingForAnswer(kind: OpenQuestionKind | null): boolean {
+  return kind === QUESTION_KIND_QUESTION
+}
+
+/** True when the question was aborted and the answer never came. */
+export function isInterrupted(kind: OpenQuestionKind | null): boolean {
+  return kind === QUESTION_KIND_INTERRUPTED
+}
+
+/** True when the question tool genuinely failed. */
+export function isQuestionError(kind: OpenQuestionKind | null): boolean {
+  return kind === QUESTION_KIND_ERROR
+}

package/src/pware.oc.opencode/constants/pware.oc.opencode.constants.sessionStatus.ts

@@ -0,0 +1,58 @@
+/**
+ * pware.oc.opencode.constants.sessionstatus
+ *
+ * OpenCode session-domain string literals: the session status a `SessionView`
+ * carries, and the finer-grained activity state used for approval rows. Both
+ * derive from SQLite rows + host events in
+ * `pware.oc.opencode/resolver/pware.oc.opencode.resolver.session.ts`.
+ */
+
+/** Session status: recently updated — the agent is likely still working. */
+export const SESSION_STATUS_RUNNING = "running"
+
+/** Session status: quiet — no recent updates. */
+export const SESSION_STATUS_IDLE = "idle"
+
+/** Session status: archived by the host. */
+export const SESSION_STATUS_ARCHIVED = "archived"
+
+/** Session status: no state could be determined. */
+export const SESSION_STATUS_UNKNOWN = "unknown"
+
+/** Every session status a `SessionView` can carry. */
+export const SESSION_STATUSES = [
+  SESSION_STATUS_RUNNING,
+  SESSION_STATUS_IDLE,
+  SESSION_STATUS_ARCHIVED,
+  SESSION_STATUS_UNKNOWN,
+] as const
+
+/** A session status value. */
+export type AgentStatus = (typeof SESSION_STATUSES)[number]
+
+/** Session activity state: a fresh `time_updated` — the session is streaming. */
+export const SESSION_STATE_STREAMING = "streaming"
+
+/** Session activity state: stale in SQLite but a background task is running. */
+export const SESSION_STATE_AWAITING_BACKGROUND = "awaiting-background"
+
+/** Session activity state: quiet. */
+export const SESSION_STATE_IDLE = SESSION_STATUS_IDLE
+
+/** Session activity state: archived. */
+export const SESSION_STATE_ARCHIVED = SESSION_STATUS_ARCHIVED
+
+/** Session activity state: unknown. */
+export const SESSION_STATE_UNKNOWN = SESSION_STATUS_UNKNOWN
+
+/** Every session activity state. */
+export const SESSION_STATES = [
+  SESSION_STATE_STREAMING,
+  SESSION_STATE_AWAITING_BACKGROUND,
+  SESSION_STATE_IDLE,
+  SESSION_STATE_ARCHIVED,
+  SESSION_STATE_UNKNOWN,
+] as const
+
+/** A session activity state. */
+export type SessionState = (typeof SESSION_STATES)[number]

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

@@ -0,0 +1,8 @@
+/**
+ * pware.oc.opencode
+ *
+ * OpenCode domain: SQLite + host-event file activity. Imports core only.
+ */
+export * from "./pware.oc.opencode.files.js"
+export * from "./pware.oc.opencode.events.js"
+export * from "./resolver/index.js"