@sleepy-ai/cli 0.1.5 → 0.1.7

package/src/history/extract.ts

@@ -1,67 +0,0 @@
-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

@@ -1,15 +0,0 @@
-// 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

@@ -1,20 +0,0 @@
-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

@@ -1,10 +0,0 @@
-// 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

@@ -1,65 +0,0 @@
-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

@@ -1,258 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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"