@sleepy-ai/cli 0.1.6 → 0.1.8

package/src/session/message.ts

@@ -1,191 +0,0 @@
-import z from "zod"
-import { SessionID } from "./schema"
-import { ModelID, ProviderID } from "../provider/schema"
-import { NamedError } from "@sleepy-ai/shared/util/error"
-
-export const OutputLengthError = NamedError.create("MessageOutputLengthError", z.object({}))
-export const AuthError = NamedError.create(
-  "ProviderAuthError",
-  z.object({
-    providerID: z.string(),
-    message: z.string(),
-  }),
-)
-
-export const ToolCall = z
-  .object({
-    state: z.literal("call"),
-    step: z.number().optional(),
-    toolCallId: z.string(),
-    toolName: z.string(),
-    args: z.custom<Required<unknown>>(),
-  })
-  .meta({
-    ref: "ToolCall",
-  })
-export type ToolCall = z.infer<typeof ToolCall>
-
-export const ToolPartialCall = z
-  .object({
-    state: z.literal("partial-call"),
-    step: z.number().optional(),
-    toolCallId: z.string(),
-    toolName: z.string(),
-    args: z.custom<Required<unknown>>(),
-  })
-  .meta({
-    ref: "ToolPartialCall",
-  })
-export type ToolPartialCall = z.infer<typeof ToolPartialCall>
-
-export const ToolResult = z
-  .object({
-    state: z.literal("result"),
-    step: z.number().optional(),
-    toolCallId: z.string(),
-    toolName: z.string(),
-    args: z.custom<Required<unknown>>(),
-    result: z.string(),
-  })
-  .meta({
-    ref: "ToolResult",
-  })
-export type ToolResult = z.infer<typeof ToolResult>
-
-export const ToolInvocation = z.discriminatedUnion("state", [ToolCall, ToolPartialCall, ToolResult]).meta({
-  ref: "ToolInvocation",
-})
-export type ToolInvocation = z.infer<typeof ToolInvocation>
-
-export const TextPart = z
-  .object({
-    type: z.literal("text"),
-    text: z.string(),
-  })
-  .meta({
-    ref: "TextPart",
-  })
-export type TextPart = z.infer<typeof TextPart>
-
-export const ReasoningPart = z
-  .object({
-    type: z.literal("reasoning"),
-    text: z.string(),
-    providerMetadata: z.record(z.string(), z.any()).optional(),
-  })
-  .meta({
-    ref: "ReasoningPart",
-  })
-export type ReasoningPart = z.infer<typeof ReasoningPart>
-
-export const ToolInvocationPart = z
-  .object({
-    type: z.literal("tool-invocation"),
-    toolInvocation: ToolInvocation,
-  })
-  .meta({
-    ref: "ToolInvocationPart",
-  })
-export type ToolInvocationPart = z.infer<typeof ToolInvocationPart>
-
-export const SourceUrlPart = z
-  .object({
-    type: z.literal("source-url"),
-    sourceId: z.string(),
-    url: z.string(),
-    title: z.string().optional(),
-    providerMetadata: z.record(z.string(), z.any()).optional(),
-  })
-  .meta({
-    ref: "SourceUrlPart",
-  })
-export type SourceUrlPart = z.infer<typeof SourceUrlPart>
-
-export const FilePart = z
-  .object({
-    type: z.literal("file"),
-    mediaType: z.string(),
-    filename: z.string().optional(),
-    url: z.string(),
-  })
-  .meta({
-    ref: "FilePart",
-  })
-export type FilePart = z.infer<typeof FilePart>
-
-export const StepStartPart = z
-  .object({
-    type: z.literal("step-start"),
-  })
-  .meta({
-    ref: "StepStartPart",
-  })
-export type StepStartPart = z.infer<typeof StepStartPart>
-
-export const MessagePart = z
-  .discriminatedUnion("type", [TextPart, ReasoningPart, ToolInvocationPart, SourceUrlPart, FilePart, StepStartPart])
-  .meta({
-    ref: "MessagePart",
-  })
-export type MessagePart = z.infer<typeof MessagePart>
-
-export const Info = z
-  .object({
-    id: z.string(),
-    role: z.enum(["user", "assistant"]),
-    parts: z.array(MessagePart),
-    metadata: z
-      .object({
-        time: z.object({
-          created: z.number(),
-          completed: z.number().optional(),
-        }),
-        error: z
-          .discriminatedUnion("name", [AuthError.Schema, NamedError.Unknown.Schema, OutputLengthError.Schema])
-          .optional(),
-        sessionID: SessionID.zod,
-        tool: z.record(
-          z.string(),
-          z
-            .object({
-              title: z.string(),
-              snapshot: z.string().optional(),
-              time: z.object({
-                start: z.number(),
-                end: z.number(),
-              }),
-            })
-            .catchall(z.any()),
-        ),
-        assistant: z
-          .object({
-            system: z.string().array(),
-            modelID: ModelID.zod,
-            providerID: ProviderID.zod,
-            path: z.object({
-              cwd: z.string(),
-              root: z.string(),
-            }),
-            cost: z.number(),
-            summary: z.boolean().optional(),
-            tokens: z.object({
-              input: z.number(),
-              output: z.number(),
-              reasoning: z.number(),
-              cache: z.object({
-                read: z.number(),
-                write: z.number(),
-              }),
-            }),
-          })
-          .optional(),
-        snapshot: z.string().optional(),
-      })
-      .meta({ ref: "MessageMetadata" }),
-  })
-  .meta({
-    ref: "Message",
-  })
-export type Info = z.infer<typeof Info>
-
-export * as Message from "./message"

package/src/session/opencode-import.ts

@@ -1,281 +0,0 @@
-import { existsSync } from "fs"
-import { Log } from "../util"
-import { Database, eq, and, inArray } from "../storage"
-import { openReadonly, type ReadonlyDb } from "../storage/read-sqlite"
-import { ProjectTable } from "../project/project.sql"
-import { ProjectID } from "../project/schema"
-import { resolveMainGitDir, resolveProjectId } from "../project/project-id"
-import { SessionTable, MessageTable, PartTable } from "./session.sql"
-import { ExternalImportTable } from "./external-import.sql"
-import type { SessionID, MessageID, PartID } from "./schema"
-
-const log = Log.create({ service: "opencode-import" })
-
-export const DEFAULT_DB_PATH = (() => {
-  const xdg = process.env.XDG_DATA_HOME
-  const base = xdg || `${process.env.HOME || process.env.USERPROFILE}/.local/share`
-  return `${base}/opencode/opencode.db`
-})()
-
-function resolveProject(cwd: string): { id: ProjectID; worktree: string; vcs: string | null } {
-  if (!cwd || !existsSync(cwd)) return { id: ProjectID.global, worktree: cwd || "/", vcs: null }
-  if (!resolveMainGitDir(cwd)) return { id: ProjectID.global, worktree: cwd, vcs: null }
-  return { id: resolveProjectId(cwd), worktree: cwd, vcs: "git" }
-}
-
-type OcSession = {
-  id: string
-  project_id: string
-  parent_id: string | null
-  slug: string
-  directory: string
-  title: string
-  version: string
-  share_url: string | null
-  summary_additions: number | null
-  summary_deletions: number | null
-  summary_files: number | null
-  summary_diffs: string | null
-  revert: string | null
-  permission: string | null
-  time_created: number
-  time_updated: number
-  time_compacting: number | null
-  time_archived: number | null
-  workspace_id: string | null
-}
-
-type OcMessage = {
-  id: string
-  session_id: string
-  time_created: number
-  time_updated: number
-  data: string
-}
-
-type OcPart = {
-  id: string
-  message_id: string
-  session_id: string
-  time_created: number
-  time_updated: number
-  data: string
-}
-
-export type ImportStats = {
-  scanned: number
-  imported: number
-  resynced: number
-  skipped: number
-  errors: string[]
-}
-
-const BATCH = 200
-
-export async function run(opts?: { force?: boolean; dbPath?: string }): Promise<ImportStats> {
-  const dbPath = opts?.dbPath ?? DEFAULT_DB_PATH
-  const stats: ImportStats = { scanned: 0, imported: 0, resynced: 0, skipped: 0, errors: [] }
-  if (!existsSync(dbPath)) return stats
-
-  let srcDb: ReadonlyDb
-  try {
-    srcDb = openReadonly(dbPath)
-  } catch (e) {
-    stats.errors.push(`failed to open ${dbPath}: ${e}`)
-    return stats
-  }
-
-  try {
-    const hasSessionTable = srcDb.get("SELECT name FROM sqlite_master WHERE type='table' AND name='session'")
-    if (!hasSessionTable) {
-      stats.errors.push(`${dbPath}: missing 'session' table`)
-      return stats
-    }
-
-    const sessions = srcDb.all("SELECT * FROM session ORDER BY time_created DESC") as OcSession[]
-
-    for (const sess of sessions) {
-      stats.scanned++
-      try {
-        const sourceKey = sess.id
-        let existing = Database.use((db) =>
-          db
-            .select()
-            .from(ExternalImportTable)
-            .where(and(eq(ExternalImportTable.source, "opencode"), eq(ExternalImportTable.source_key, sourceKey)))
-            .get(),
-        )
-        // Skip only when the source session is unchanged since last import. We
-        // store time_updated as source_mtime, so a re-edited opencode session
-        // (newer time_updated) is picked up automatically — matching the cc/codex
-        // mtime-based resync behavior. force overrides the staleness check.
-        if (existing && existing.source_mtime === sess.time_updated && !opts?.force) {
-          stats.skipped++
-          continue
-        }
-
-        // If this import previously created a sleepycode session that the user has
-        // since deleted, drop the stale mapping and re-import fresh (otherwise the
-        // update below touches zero rows and the message FK insert fails). When it
-        // still exists, remember its time_updated so a re-sync never moves the
-        // session backward past sleepycode-native activity (cc/codex parity).
-        let existingUpdated: number | undefined
-        if (existing) {
-          const sleepySess = Database.use((db) =>
-            db.select({ updated: SessionTable.time_updated }).from(SessionTable).where(eq(SessionTable.id, existing!.session_id)).get(),
-          )
-          if (!sleepySess) {
-            Database.use((db) =>
-              db.delete(ExternalImportTable).where(and(eq(ExternalImportTable.source, "opencode"), eq(ExternalImportTable.source_key, sourceKey))).run(),
-            )
-            existing = undefined
-          } else {
-            existingUpdated = sleepySess.updated
-          }
-        }
-
-        const project = resolveProject(sess.directory)
-        const now = Date.now()
-
-        const messages = srcDb.all("SELECT * FROM message WHERE session_id = ? ORDER BY id", sess.id) as OcMessage[]
-        if (messages.length === 0) {
-          stats.skipped++
-          continue
-        }
-
-        const messageIds = messages.map((m) => m.id as MessageID)
-
-        const parts: OcPart[] = []
-        for (let i = 0; i < messageIds.length; i += BATCH) {
-          const batch = messageIds.slice(i, i + BATCH)
-          const placeholders = batch.map(() => "?").join(",")
-          const batchParts = srcDb.all(
-            `SELECT * FROM part WHERE session_id = ? AND message_id IN (${placeholders}) ORDER BY id`,
-            sess.id,
-            ...batch,
-          ) as OcPart[]
-          parts.push(...batchParts)
-        }
-
-        Database.transaction((tx) => {
-          tx.insert(ProjectTable)
-            .values({
-              id: project.id,
-              worktree: project.worktree,
-              vcs: project.vcs,
-              sandboxes: [],
-              time_created: sess.time_created,
-              time_updated: sess.time_updated,
-            })
-            .onConflictDoNothing()
-            .run()
-
-          if (existing) {
-            if (existing.message_ids?.length) {
-              for (let i = 0; i < existing.message_ids.length; i += 500)
-                tx.delete(MessageTable)
-                  .where(inArray(MessageTable.id, existing.message_ids.slice(i, i + 500)))
-                  .run()
-            } else {
-              tx.delete(MessageTable).where(eq(MessageTable.session_id, sess.id as SessionID)).run()
-            }
-            tx.update(SessionTable)
-              .set({
-                project_id: project.id,
-                directory: sess.directory,
-                version: sess.version,
-                time_updated: Math.max(existingUpdated ?? 0, sess.time_updated),
-              })
-              .where(eq(SessionTable.id, sess.id as SessionID))
-              .run()
-          } else {
-            tx.insert(SessionTable)
-              .values({
-                id: sess.id as SessionID,
-                project_id: project.id,
-                parent_id: sess.parent_id as SessionID | null,
-                slug: sess.slug,
-                directory: sess.directory,
-                title: sess.title,
-                version: sess.version,
-                time_created: sess.time_created,
-                time_updated: sess.time_updated,
-              })
-              .onConflictDoUpdate({
-                target: SessionTable.id,
-                set: {
-                  project_id: project.id,
-                  directory: sess.directory,
-                  time_updated: sess.time_updated,
-                },
-              })
-              .run()
-          }
-
-          for (const m of messages) {
-            const data = typeof m.data === "string" ? JSON.parse(m.data) : m.data
-            tx.insert(MessageTable)
-              .values({
-                id: m.id as MessageID,
-                session_id: sess.id as SessionID,
-                agent_id: "main",
-                time_created: m.time_created,
-                data,
-              })
-              .onConflictDoUpdate({
-                target: MessageTable.id,
-                set: { data, time_created: m.time_created },
-              })
-              .run()
-          }
-
-          for (const p of parts) {
-            const data = typeof p.data === "string" ? JSON.parse(p.data) : p.data
-            tx.insert(PartTable)
-              .values({
-                id: p.id as PartID,
-                message_id: p.message_id as MessageID,
-                session_id: sess.id as SessionID,
-                time_created: p.time_created,
-                data,
-              })
-              .onConflictDoUpdate({
-                target: PartTable.id,
-                set: { data, time_created: p.time_created },
-              })
-              .run()
-          }
-
-          tx.insert(ExternalImportTable)
-            .values({
-              source: "opencode",
-              source_key: sourceKey,
-              session_id: sess.id as SessionID,
-              source_path: dbPath,
-              source_mtime: sess.time_updated,
-              time_imported: now,
-              message_ids: messageIds,
-            })
-            .onConflictDoUpdate({
-              target: [ExternalImportTable.source, ExternalImportTable.source_key],
-              set: { source_mtime: sess.time_updated, time_imported: now, message_ids: messageIds },
-            })
-            .run()
-        })
-
-        if (existing) stats.resynced++
-        else stats.imported++
-      } catch (e) {
-        stats.errors.push(`session ${sess.id}: ${e}`)
-      }
-    }
-  } finally {
-    srcDb.close()
-  }
-
-  if (stats.imported + stats.resynced > 0 || stats.errors.length > 0)
-    log.info("opencode import", { ...stats, errors: stats.errors.length })
-  return stats
-}
-
-export * as OpencodeImport from "./opencode-import"

package/src/session/overflow.ts

@@ -1,53 +0,0 @@
-import type { Config } from "@/config"
-import type { Provider } from "@/provider"
-import { ProviderTransform } from "@/provider"
-import type { MessageV2 } from "./message-v2"
-
-const COMPACTION_BUFFER = 20_000
-
-// Cap the output reservation so models with large output windows (e.g. 32K, 64K)
-// don't strangle the usable input window. 20K covers >99.99% of compaction
-// summary outputs based on production telemetry of summary token counts.
-const OUTPUT_CAP = 20_000
-
-export function usable(input: { cfg: Config.Info; model: Provider.Model }) {
-  const context = input.model.limit.context
-  if (context === 0) return 0
-
-  const reserved =
-    input.cfg.compaction?.reserved ?? Math.min(COMPACTION_BUFFER, ProviderTransform.maxOutputTokens(input.model))
-  const outputReserve = Math.min(ProviderTransform.maxOutputTokens(input.model), OUTPUT_CAP)
-
-  return input.model.limit.input
-    ? Math.max(0, input.model.limit.input - reserved)
-    : Math.max(0, context - outputReserve - reserved)
-}
-
-export function isOverflow(input: { cfg: Config.Info; tokens: MessageV2.Assistant["tokens"]; model: Provider.Model }) {
-  if (input.cfg.compaction?.auto === false) return false
-  if (input.model.limit.context === 0) return false
-
-  const count =
-    input.tokens.total || input.tokens.input + input.tokens.output + input.tokens.cache.read + input.tokens.cache.write
-  return count >= usable(input)
-}
-
-export function pressureLevel(input: {
-  cfg: Config.Info
-  tokens: MessageV2.Assistant["tokens"]
-  model: Provider.Model
-}): 0 | 1 | 2 | 3 {
-  if (input.cfg.compaction?.auto === false) return 0
-  if (input.model.limit.context === 0) return 0
-
-  const count =
-    input.tokens.total || input.tokens.input + input.tokens.output + input.tokens.cache.read + input.tokens.cache.write
-  const limit = usable(input)
-  if (limit === 0) return 0
-
-  const ratio = count / limit
-  if (ratio < 0.50) return 0
-  if (ratio < 0.70) return 1
-  if (ratio < 0.85) return 2
-  return 3
-}

package/src/session/prefix-capture-ref.ts

@@ -1,48 +0,0 @@
-// Late-bound reference to a pre-wired prefix-capture helper.
-//
-// tryStartCheckpointWriter (in SessionCheckpoint) needs to call
-// buildLLMRequestPrefix, which requires LLM.Service and ToolRegistry.Service.
-// But ToolRegistry depends on SessionCheckpoint, so these cannot be added as
-// normal Layer deps without creating a cycle:
-//
-//   ToolRegistry → SessionCheckpoint → ToolRegistry
-//
-// The same late-binding pattern used by spawn-ref.ts is applied here.
-// SessionPrompt.layer (which already holds all needed services) populates
-// this ref on initialisation; tryStartCheckpointWriter reads it at call time.
-//
-// Missing ref at call time → tryStartCheckpointWriter logs a warning and
-// proceeds without forkContext (same guard as a missing spawnRef).
-import type { Effect } from "effect"
-import type { SessionID } from "./schema"
-import type { ModelMessage, Tool as AITool } from "ai"
-import type { Permission } from "../permission"
-
-export interface PrefixCaptureResult {
-  readonly system: string[]
-  readonly tools: Record<string, AITool>
-  readonly inheritedMessages: ModelMessage[]
-  readonly parentPermission: Permission.Ruleset
-}
-
-/**
- * Accepts providerID/modelID strings rather than a full Provider.Model so
- * SessionCheckpoint (which does not have Provider.Service) can call this.
- * The closure inside SessionPrompt.layer resolves the full model internally.
- *
- * The caller (checkpoint.ts) passes already-sliced msgs and wraps the result
- * into a ForkContext that adds watermarkMsgID as a boundary marker. The
- * watermark is NOT threaded through this closure.
- */
-export type PrefixCaptureFn = (input: {
-  sessionID: SessionID
-  agentName: string
-  providerID: string
-  modelID: string
-  // Typed as `unknown[]` to break the import cycle — caller passes
-  // `MessageV2.WithParts[]` but importing that type here would
-  // re-introduce the SessionCheckpoint↔ToolRegistry cycle.
-  msgs: unknown[]
-}) => Effect.Effect<PrefixCaptureResult, never>
-
-export const prefixCaptureRef: { current: PrefixCaptureFn | undefined } = { current: undefined }