@sleepy-ai/cli 0.0.0-main-202607032053 → 0.1.4

package/src/history/extract.ts

@@ -0,0 +1,67 @@
+import type { MessageV2 } from "../session/message-v2"
+
+export type Kind =
+  | "user_text"
+  | "assistant_text"
+  | "tool_input"
+  | "tool_error"
+  | "reasoning"
+  | "tool_output"
+
+export const DEFAULT_KINDS: ReadonlyArray<Kind> = [
+  "user_text",
+  "assistant_text",
+  "tool_input",
+  "tool_error",
+]
+
+export type Extracted = { kind: Kind; body: string; tool_name: string | null }
+
+export function extract(
+  part: MessageV2.Part,
+  messageRole: "user" | "assistant",
+  enabledKinds: ReadonlySet<Kind>,
+): Extracted | null {
+  switch (part.type) {
+    case "text": {
+      const kind: Kind = messageRole === "user" ? "user_text" : "assistant_text"
+      if (!enabledKinds.has(kind)) return null
+      if (!part.text) return null
+      return { kind, body: part.text, tool_name: null }
+    }
+    case "reasoning": {
+      if (!enabledKinds.has("reasoning")) return null
+      if (!part.text) return null
+      return { kind: "reasoning", body: part.text, tool_name: null }
+    }
+    case "tool": {
+      const state = part.state
+      if (state.status === "pending" || state.status === "running") return null
+
+      if (state.status === "error" && enabledKinds.has("tool_error")) {
+        return {
+          kind: "tool_error",
+          body: `${part.tool} ${JSON.stringify(state.input ?? {})} ${state.error ?? ""}`,
+          tool_name: part.tool,
+        }
+      }
+      if (state.status === "completed" && enabledKinds.has("tool_output")) {
+        return {
+          kind: "tool_output",
+          body: `${part.tool} ${JSON.stringify(state.input ?? {})} ${JSON.stringify(state.output ?? "")}`,
+          tool_name: part.tool,
+        }
+      }
+      if (enabledKinds.has("tool_input")) {
+        return {
+          kind: "tool_input",
+          body: `${part.tool} ${JSON.stringify(state.input ?? {})}`,
+          tool_name: part.tool,
+        }
+      }
+      return null
+    }
+    default:
+      return null
+  }
+}

package/src/history/fts-query.ts

@@ -0,0 +1,15 @@
+// Build an FTS5 MATCH expression from a free-form user query.
+// Tokenize on non-word boundaries (preserving CJK / Unicode letters and digits),
+// wrap each token in phrase quotes, AND-join. Returns null when no usable tokens.
+//
+// Independent copy from memory/fts-query.ts so the two modules can evolve apart.
+export function buildFtsQuery(raw: string): string | null {
+  const tokens =
+    raw
+      .match(/[\p{L}\p{N}_]+/gu)
+      ?.map((t) => t.trim())
+      .filter(Boolean) ?? []
+  if (tokens.length === 0) return null
+  const quoted = tokens.map((t) => `"${t.replaceAll('"', "")}"`)
+  return quoted.join(" AND ")
+}

package/src/history/fts.sql.ts

@@ -0,0 +1,20 @@
+import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core"
+
+export const HistoryFtsTable = sqliteTable(
+  "history_fts",
+  {
+    part_id: text().primaryKey(),
+    session_id: text().notNull(),
+    message_id: text().notNull(),
+    project_id: text().notNull(),
+    kind: text().notNull(),
+    tool_name: text(),
+    body: text().notNull(),
+    time_created: integer().notNull(),
+  },
+  (t) => [
+    index("history_fts_session_idx").on(t.session_id, t.time_created),
+    index("history_fts_project_idx").on(t.project_id, t.time_created),
+    index("history_fts_message_idx").on(t.message_id),
+  ],
+)

package/src/history/index.ts

@@ -0,0 +1,10 @@
+// History (trajectory search) module entry.
+//
+// `History.defaultLayer` provides three services: History (search/around),
+// HistoryWriter (Bus subscriber), and HistoryBackfill (startup scan).
+// HistoryWriter and HistoryBackfill must be activated by calling `init()` at
+// bootstrap time — see `packages/opencode/src/project/bootstrap.ts`. Layer-merge
+// alone does NOT start them (mirrors the ShareNext / Vcs / FileWatcher pattern).
+export * as History from "./service"
+export { Service as WriterService } from "./writer"
+export { Service as BackfillService } from "./backfill"

package/src/history/resolve.ts

@@ -0,0 +1,65 @@
+import { Effect } from "effect"
+import { eq, Database } from "../storage"
+import { MessageTable, SessionTable } from "../session/session.sql"
+import type { MessageID } from "../session/schema"
+import type { SessionID } from "../session/schema"
+
+class LRU<K, V> {
+  private map = new Map<K, V>()
+  constructor(private readonly max: number) {}
+  get(k: K): V | undefined {
+    const v = this.map.get(k)
+    if (v === undefined) return undefined
+    this.map.delete(k)
+    this.map.set(k, v)
+    return v
+  }
+  set(k: K, v: V) {
+    if (this.map.has(k)) this.map.delete(k)
+    this.map.set(k, v)
+    if (this.map.size > this.max) {
+      const oldest = this.map.keys().next().value
+      if (oldest !== undefined) this.map.delete(oldest)
+    }
+  }
+}
+
+export type Resolver = {
+  role: (messageID: string) => Effect.Effect<"user" | "assistant">
+  projectID: (sessionID: string) => Effect.Effect<string>
+}
+
+export function makeResolver(): Resolver {
+  const roleCache = new LRU<string, "user" | "assistant">(1024)
+  const projectCache = new LRU<string, string>(512)
+
+  return {
+    role: (messageID) =>
+      Effect.sync(() => {
+        const cached = roleCache.get(messageID)
+        if (cached) return cached
+        const row = Database.use((db) =>
+          db.select({ data: MessageTable.data }).from(MessageTable).where(eq(MessageTable.id, messageID as MessageID)).get(),
+        )
+        const role = (row?.data as { role?: string } | undefined)?.role === "user" ? "user" : "assistant"
+        roleCache.set(messageID, role)
+        return role
+      }),
+
+    projectID: (sessionID) =>
+      Effect.sync(() => {
+        const cached = projectCache.get(sessionID)
+        if (cached) return cached
+        const row = Database.use((db) =>
+          db
+            .select({ project_id: SessionTable.project_id })
+            .from(SessionTable)
+            .where(eq(SessionTable.id, sessionID as SessionID))
+            .get(),
+        )
+        const projectID = row?.project_id ?? ""
+        projectCache.set(sessionID, projectID)
+        return projectID
+      }),
+  }
+}

package/src/history/service.ts

@@ -0,0 +1,258 @@
+import { Context, Effect, Layer } from "effect"
+import { and, asc, desc, eq, sql } from "drizzle-orm"
+import { Database } from "../storage"
+import { MessageTable, PartTable } from "../session/session.sql"
+import type { MessageID } from "../session/schema"
+import { Config } from "../config"
+import { Bus } from "../bus"
+import { Instance } from "../project/instance"
+import { buildFtsQuery } from "./fts-query"
+import type { Kind } from "./extract"
+import { layer as writerLayer, Service as WriterService } from "./writer"
+import { layer as backfillLayer, Service as BackfillService } from "./backfill"
+
+export type SearchHit = {
+  part_id: string
+  session_id: string
+  message_id: string
+  project_id: string
+  kind: Kind
+  tool_name: string | null
+  snippet: string
+  score: number
+  time_created: number
+}
+
+export type MessagePart = {
+  part_id: string
+  type: string
+  role: "user" | "assistant"
+  tool_name: string | null
+  text: string
+}
+
+export type MessageContext = {
+  message_id: string
+  matched: boolean
+  time_created: number
+  parts: MessagePart[]
+}
+
+export interface Interface {
+  readonly search: (input: {
+    query: string
+    scope?: "project" | "global"
+    session_id?: string
+    kind?: Kind | Kind[]
+    tool_name?: string
+    time_after?: number
+    time_before?: number
+    limit?: number
+  }) => Effect.Effect<SearchHit[]>
+
+  readonly around: (input: {
+    message_id: string
+    before?: number
+    after?: number
+  }) => Effect.Effect<{ session_id: string; messages: MessageContext[] }>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/History") {}
+
+const HARD_CAP = 50
+
+type Row = {
+  part_id: string
+  session_id: string
+  message_id: string
+  project_id: string
+  kind: string
+  tool_name: string | null
+  snippet: string
+  score: number
+  time_created: number
+}
+
+export const defaultLayer: Layer.Layer<Service | WriterService | BackfillService, never, never> = Layer.suspend(() =>
+  Layer.mergeAll(layer, writerLayer, backfillLayer).pipe(
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(Bus.defaultLayer),
+  ),
+)
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const search = Effect.fn("History.search")(function* (input: Parameters<Interface["search"]>[0]) {
+      const ftsQuery = buildFtsQuery(input.query)
+      if (!ftsQuery) return []
+
+      const limit = Math.min(input.limit ?? 10, HARD_CAP)
+      const conditions: string[] = []
+      const params: (string | number)[] = []
+
+      const scope = input.scope ?? "project"
+      if (scope === "project") {
+        conditions.push("history_fts.project_id = ?")
+        params.push(Instance.project.id)
+      }
+
+      if (input.session_id) {
+        conditions.push("history_fts.session_id = ?")
+        params.push(input.session_id)
+      }
+      if (input.kind) {
+        const kinds = Array.isArray(input.kind) ? input.kind : [input.kind]
+        conditions.push(`history_fts.kind IN (${kinds.map(() => "?").join(",")})`)
+        for (const k of kinds) params.push(k)
+      }
+      if (input.tool_name) {
+        conditions.push("history_fts.tool_name = ?")
+        params.push(input.tool_name)
+      }
+      if (input.time_after !== undefined) {
+        conditions.push("history_fts.time_created >= ?")
+        params.push(input.time_after)
+      }
+      if (input.time_before !== undefined) {
+        conditions.push("history_fts.time_created <= ?")
+        params.push(input.time_before)
+      }
+
+      const whereClause = conditions.length > 0 ? `AND ${conditions.join(" AND ")}` : ""
+      const sqlText = `
+        SELECT history_fts.part_id, history_fts.session_id, history_fts.message_id,
+               history_fts.project_id, history_fts.kind, history_fts.tool_name,
+               history_fts.time_created,
+               snippet(history_fts_idx, 0, '<<', '>>', '...', 32) AS snippet,
+               bm25(history_fts_idx) AS score
+        FROM history_fts_idx
+        JOIN history_fts ON history_fts.rowid = history_fts_idx.rowid
+        WHERE history_fts_idx MATCH ?
+        ${whereClause}
+        ORDER BY score
+        LIMIT ?
+      `
+      const rows = Database.Client().$client.query(sqlText).all(ftsQuery, ...params, limit) as Row[]
+      return rows.map((r) => ({
+        part_id: r.part_id,
+        session_id: r.session_id,
+        message_id: r.message_id,
+        project_id: r.project_id,
+        kind: r.kind as Kind,
+        tool_name: r.tool_name,
+        snippet: r.snippet,
+        score: -r.score,
+        time_created: r.time_created,
+      }))
+    })
+
+    const around = Effect.fn("History.around")(function* (input: Parameters<Interface["around"]>[0]) {
+      const before = input.before ?? 5
+      const after = input.after ?? 5
+      const anchor = Database.use((db) =>
+        db
+          .select({
+            id: MessageTable.id,
+            session_id: MessageTable.session_id,
+            time_created: MessageTable.time_created,
+          })
+          .from(MessageTable)
+          .where(eq(MessageTable.id, input.message_id as MessageID))
+          .get(),
+      )
+      if (!anchor) return { session_id: "", messages: [] }
+
+      const beforeRows = Database.use((db) =>
+        db
+          .select()
+          .from(MessageTable)
+          .where(
+            and(
+              eq(MessageTable.session_id, anchor.session_id),
+              sql`(${MessageTable.time_created} < ${anchor.time_created} OR (${MessageTable.time_created} = ${anchor.time_created} AND ${MessageTable.id} <= ${anchor.id}))`,
+            ),
+          )
+          .orderBy(desc(MessageTable.time_created), desc(MessageTable.id))
+          .limit(before + 1)
+          .all(),
+      )
+      const afterRows = Database.use((db) =>
+        db
+          .select()
+          .from(MessageTable)
+          .where(
+            and(
+              eq(MessageTable.session_id, anchor.session_id),
+              sql`(${MessageTable.time_created} > ${anchor.time_created} OR (${MessageTable.time_created} = ${anchor.time_created} AND ${MessageTable.id} > ${anchor.id}))`,
+            ),
+          )
+          .orderBy(asc(MessageTable.time_created), asc(MessageTable.id))
+          .limit(after)
+          .all(),
+      )
+
+      const messages = [...beforeRows.reverse(), ...afterRows]
+      if (messages.length === 0) return { session_id: anchor.session_id, messages: [] }
+      const parts = Database.use((db) =>
+        db
+          .select()
+          .from(PartTable)
+          .where(
+            and(
+              eq(PartTable.session_id, anchor.session_id),
+              sql`${PartTable.message_id} IN (${sql.join(
+                messages.map((m) => sql`${m.id}`),
+                sql`, `,
+              )})`,
+            ),
+          )
+          .orderBy(asc(PartTable.message_id), asc(PartTable.id))
+          .all(),
+      )
+
+      const byMessage = new Map<string, typeof parts>()
+      for (const p of parts) {
+        const list = byMessage.get(p.message_id) ?? []
+        list.push(p)
+        byMessage.set(p.message_id, list)
+      }
+
+      const out: MessageContext[] = messages.map((m) => {
+        const role: "user" | "assistant" =
+          (m.data as { role?: "user" | "assistant" })?.role === "user" ? "user" : "assistant"
+        const partsHere = (byMessage.get(m.id) ?? []).map((p) => {
+          const d = p.data as {
+            type: string
+            text?: string
+            tool?: string
+            state?: { input?: unknown; output?: unknown; error?: string }
+          }
+          const text =
+            d.type === "text" || d.type === "reasoning"
+              ? (d.text ?? "")
+              : d.type === "tool"
+                ? `tool: ${d.tool ?? ""}\ninput: ${JSON.stringify(d.state?.input ?? {})}\n${d.state?.error ? `error: ${d.state.error}` : `output: ${JSON.stringify(d.state?.output ?? "")}`}`
+                : `[${d.type}]`
+          return {
+            part_id: p.id,
+            type: d.type,
+            role,
+            tool_name: d.type === "tool" ? (d.tool ?? null) : null,
+            text,
+          }
+        })
+        return {
+          message_id: m.id,
+          matched: m.id === input.message_id,
+          time_created: m.time_created,
+          parts: partsHere,
+        }
+      })
+
+      return { session_id: anchor.session_id, messages: out }
+    })
+
+    return Service.of({ search, around })
+  }),
+)

package/src/history/writer.ts

@@ -0,0 +1,112 @@
+import { Context, Effect, Layer, Queue } from "effect"
+import { Database, eq } from "../storage"
+import { Bus } from "../bus"
+import { MessageV2 } from "../session/message-v2"
+import { Config } from "../config"
+import { InstanceState } from "../effect"
+import { HistoryFtsTable } from "./fts.sql"
+import { extract, DEFAULT_KINDS, type Kind } from "./extract"
+import { makeResolver, type Resolver } from "./resolve"
+import { Log } from "../util"
+
+const log = Log.create({ service: "history.writer" })
+
+type Job =
+  | { type: "upsert"; part: MessageV2.Part; time: number }
+  | { type: "delete"; partID: string }
+
+export interface Interface {
+  readonly init: () => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/History.Writer") {}
+
+export const layer: Layer.Layer<Service, never, Config.Service | Bus.Service> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const cfg = yield* Config.Service
+    const bus = yield* Bus.Service
+
+    const state = yield* InstanceState.make<{ started: boolean }>(
+      Effect.fn("History.Writer.state")(function* (_ctx) {
+        const config = yield* cfg.get()
+        const kinds = config.history?.kinds ?? DEFAULT_KINDS
+        const enabled = new Set<Kind>(kinds as readonly Kind[])
+        if (enabled.size === 0) return { started: true }
+
+        const queue = yield* Queue.unbounded<Job>()
+        const resolver = makeResolver()
+
+        // Use subscribeCallback (synchronous PubSub.subscribe) so subscriptions
+        // are guaranteed live before init() returns. Stream-based subscribe is
+        // lazy (Stream.unwrap) and would race with immediate publishes.
+        yield* bus.subscribeCallback(MessageV2.Event.PartUpdated, (evt) => {
+          Queue.offerUnsafe(queue, { type: "upsert", part: evt.properties.part, time: evt.properties.time })
+        })
+        yield* bus.subscribeCallback(MessageV2.Event.PartRemoved, (evt) => {
+          Queue.offerUnsafe(queue, { type: "delete", partID: evt.properties.partID })
+        })
+
+        yield* Effect.forever(
+          Effect.gen(function* () {
+            const job = yield* Queue.take(queue)
+            yield* handle(job, resolver, enabled).pipe(
+              Effect.catchCause((cause) =>
+                Effect.sync(() => log.warn("write failed", { cause: String(cause) })),
+              ),
+            )
+          }),
+        ).pipe(Effect.forkScoped)
+
+        return { started: true }
+      }),
+    )
+
+    return Service.of({
+      init: Effect.fn("History.Writer.init")(function* () {
+        yield* InstanceState.get(state)
+      }),
+    })
+  }),
+)
+
+function handle(job: Job, resolver: Resolver, enabled: ReadonlySet<Kind>) {
+  if (job.type === "delete") {
+    return Effect.sync(() =>
+      Database.use((db) => db.delete(HistoryFtsTable).where(eq(HistoryFtsTable.part_id, job.partID)).run()),
+    )
+  }
+  return Effect.gen(function* () {
+    const part = job.part
+    const role = yield* resolver.role(part.messageID)
+    const extracted = extract(part, role, enabled)
+    if (!extracted) return
+    const projectID = yield* resolver.projectID(part.sessionID)
+
+    Database.use((db) =>
+      db
+        .insert(HistoryFtsTable)
+        .values({
+          part_id: part.id,
+          session_id: part.sessionID,
+          message_id: part.messageID,
+          project_id: projectID,
+          kind: extracted.kind,
+          tool_name: extracted.tool_name,
+          body: extracted.body,
+          time_created: job.time,
+        })
+        .onConflictDoUpdate({
+          target: HistoryFtsTable.part_id,
+          set: {
+            kind: extracted.kind,
+            tool_name: extracted.tool_name,
+            body: extracted.body,
+            time_created: job.time,
+          },
+        })
+        .run(),
+    )
+  })
+}
+

package/src/id/id.ts

@@ -0,0 +1,87 @@
+import z from "zod"
+import { randomBytes } from "crypto"
+
+const prefixes = {
+  event: "evt",
+  session: "ses",
+  message: "msg",
+  permission: "per",
+  question: "que",
+  user: "usr",
+  part: "prt",
+  pty: "pty",
+  tool: "tool",
+  workspace: "wrk",
+  entry: "ent",
+  workflow: "wf",
+} as const
+
+export function schema(prefix: keyof typeof prefixes) {
+  return z.string().startsWith(prefixes[prefix])
+}
+
+const LENGTH = 26
+
+// State for monotonic ID generation
+let lastTimestamp = 0
+let counter = 0
+
+export function ascending(prefix: keyof typeof prefixes, given?: string) {
+  return generateID(prefix, "ascending", given)
+}
+
+export function descending(prefix: keyof typeof prefixes, given?: string) {
+  return generateID(prefix, "descending", given)
+}
+
+function generateID(prefix: keyof typeof prefixes, direction: "descending" | "ascending", given?: string): string {
+  if (!given) {
+    return create(prefixes[prefix], direction)
+  }
+
+  if (!given.startsWith(prefixes[prefix])) {
+    throw new Error(`ID ${given} does not start with ${prefixes[prefix]}`)
+  }
+  return given
+}
+
+function randomBase62(length: number): string {
+  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+  let result = ""
+  const bytes = randomBytes(length)
+  for (let i = 0; i < length; i++) {
+    result += chars[bytes[i] % 62]
+  }
+  return result
+}
+
+export function create(prefix: string, direction: "descending" | "ascending", timestamp?: number): string {
+  const currentTimestamp = timestamp ?? Date.now()
+
+  if (currentTimestamp !== lastTimestamp) {
+    lastTimestamp = currentTimestamp
+    counter = 0
+  }
+  counter++
+
+  let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)
+
+  now = direction === "descending" ? ~now : now
+
+  const timeBytes = Buffer.alloc(6)
+  for (let i = 0; i < 6; i++) {
+    timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
+  }
+
+  return prefix + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
+}
+
+/** Extract timestamp from an ascending ID. Does not work with descending IDs. */
+export function timestamp(id: string): number {
+  const prefix = id.split("_")[0]
+  const hex = id.slice(prefix.length + 1, prefix.length + 13)
+  const encoded = BigInt("0x" + hex)
+  return Number(encoded / BigInt(0x1000))
+}
+
+export * as Identifier from "./id"