@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/session/status.ts

@@ -1,89 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { InstanceState } from "@/effect"
-import { SessionID } from "./schema"
-import { Effect, Layer, Context } from "effect"
-import z from "zod"
-
-export const Info = z
-  .union([
-    z.object({
-      type: z.literal("idle"),
-    }),
-    z.object({
-      type: z.literal("retry"),
-      attempt: z.number(),
-      message: z.string(),
-      next: z.number(),
-    }),
-    z.object({
-      type: z.literal("busy"),
-      message: z.string().optional(),
-    }),
-  ])
-  .meta({
-    ref: "SessionStatus",
-  })
-export type Info = z.infer<typeof Info>
-
-export const Event = {
-  Status: BusEvent.define(
-    "session.status",
-    z.object({
-      sessionID: SessionID.zod,
-      status: Info,
-    }),
-  ),
-  // deprecated
-  Idle: BusEvent.define(
-    "session.idle",
-    z.object({
-      sessionID: SessionID.zod,
-    }),
-  ),
-}
-
-export interface Interface {
-  readonly get: (sessionID: SessionID) => Effect.Effect<Info>
-  readonly list: () => Effect.Effect<Map<SessionID, Info>>
-  readonly set: (sessionID: SessionID, status: Info) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionStatus") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-
-    const state = yield* InstanceState.make(
-      Effect.fn("SessionStatus.state")(() => Effect.succeed(new Map<SessionID, Info>())),
-    )
-
-    const get = Effect.fn("SessionStatus.get")(function* (sessionID: SessionID) {
-      const data = yield* InstanceState.get(state)
-      return data.get(sessionID) ?? { type: "idle" as const }
-    })
-
-    const list = Effect.fn("SessionStatus.list")(function* () {
-      return new Map(yield* InstanceState.get(state))
-    })
-
-    const set = Effect.fn("SessionStatus.set")(function* (sessionID: SessionID, status: Info) {
-      const data = yield* InstanceState.get(state)
-      yield* bus.publish(Event.Status, { sessionID, status })
-      if (status.type === "idle") {
-        yield* bus.publish(Event.Idle, { sessionID })
-        data.delete(sessionID)
-        return
-      }
-      data.set(sessionID, status)
-    })
-
-    return Service.of({ get, list, set })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
-
-export * as SessionStatus from "./status"

package/src/session/summary.ts

@@ -1,163 +0,0 @@
-import z from "zod"
-import { Effect, Layer, Context } from "effect"
-import { Bus } from "@/bus"
-import { Snapshot } from "@/snapshot"
-import { Storage } from "@/storage"
-import * as Session from "./session"
-import { MessageV2 } from "./message-v2"
-import { SessionID, MessageID } from "./schema"
-
-function unquoteGitPath(input: string) {
-  if (!input.startsWith('"')) return input
-  if (!input.endsWith('"')) return input
-  const body = input.slice(1, -1)
-  const bytes: number[] = []
-
-  for (let i = 0; i < body.length; i++) {
-    const char = body[i]!
-    if (char !== "\\") {
-      bytes.push(char.charCodeAt(0))
-      continue
-    }
-
-    const next = body[i + 1]
-    if (!next) {
-      bytes.push("\\".charCodeAt(0))
-      continue
-    }
-
-    if (next >= "0" && next <= "7") {
-      const chunk = body.slice(i + 1, i + 4)
-      const match = chunk.match(/^[0-7]{1,3}/)
-      if (!match) {
-        bytes.push(next.charCodeAt(0))
-        i++
-        continue
-      }
-      bytes.push(parseInt(match[0], 8))
-      i += match[0].length
-      continue
-    }
-
-    const escaped =
-      next === "n"
-        ? "\n"
-        : next === "r"
-          ? "\r"
-          : next === "t"
-            ? "\t"
-            : next === "b"
-              ? "\b"
-              : next === "f"
-                ? "\f"
-                : next === "v"
-                  ? "\v"
-                  : next === "\\" || next === '"'
-                    ? next
-                    : undefined
-
-    bytes.push((escaped ?? next).charCodeAt(0))
-    i++
-  }
-
-  return Buffer.from(bytes).toString()
-}
-
-export interface Interface {
-  readonly summarize: (input: { sessionID: SessionID; messageID: MessageID }) => Effect.Effect<void>
-  readonly diff: (input: { sessionID: SessionID; messageID?: MessageID }) => Effect.Effect<Snapshot.FileDiff[]>
-  readonly computeDiff: (input: { messages: MessageV2.WithParts[] }) => Effect.Effect<Snapshot.FileDiff[]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionSummary") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const sessions = yield* Session.Service
-    const snapshot = yield* Snapshot.Service
-    const storage = yield* Storage.Service
-    const bus = yield* Bus.Service
-
-    const computeDiff = Effect.fn("SessionSummary.computeDiff")(function* (input: { messages: MessageV2.WithParts[] }) {
-      let from: string | undefined
-      let to: string | undefined
-      for (const item of input.messages) {
-        if (!from) {
-          for (const part of item.parts) {
-            if (part.type === "step-start" && part.snapshot) {
-              from = part.snapshot
-              break
-            }
-          }
-        }
-        for (const part of item.parts) {
-          if (part.type === "step-finish" && part.snapshot) to = part.snapshot
-        }
-      }
-      if (from && to) return yield* snapshot.diffFull(from, to)
-      return []
-    })
-
-    const summarize = Effect.fn("SessionSummary.summarize")(function* (input: {
-      sessionID: SessionID
-      messageID: MessageID
-    }) {
-      const all = yield* sessions.messages({ sessionID: input.sessionID, agentID: "main" })
-      if (!all.length) return
-
-      const diffs = yield* computeDiff({ messages: all })
-      yield* sessions.setSummary({
-        sessionID: input.sessionID,
-        summary: {
-          additions: diffs.reduce((sum, x) => sum + x.additions, 0),
-          deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
-          files: diffs.length,
-        },
-      })
-      yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
-      yield* bus.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
-
-      const messages = all.filter(
-        (m) => m.info.id === input.messageID || (m.info.role === "assistant" && m.info.parentID === input.messageID),
-      )
-      const target = messages.find((m) => m.info.id === input.messageID)
-      if (!target || target.info.role !== "user") return
-      const msgDiffs = yield* computeDiff({ messages })
-      target.info.summary = { ...target.info.summary, diffs: msgDiffs }
-      yield* sessions.updateMessage(target.info)
-    })
-
-    const diff = Effect.fn("SessionSummary.diff")(function* (input: { sessionID: SessionID; messageID?: MessageID }) {
-      const diffs = yield* storage
-        .read<Snapshot.FileDiff[]>(["session_diff", input.sessionID])
-        .pipe(Effect.catch(() => Effect.succeed([] as Snapshot.FileDiff[])))
-      const next = diffs.map((item) => {
-        const file = unquoteGitPath(item.file)
-        if (file === item.file) return item
-        return { ...item, file }
-      })
-      const changed = next.some((item, i) => item.file !== diffs[i]?.file)
-      if (changed) yield* storage.write(["session_diff", input.sessionID], next).pipe(Effect.ignore)
-      return next
-    })
-
-    return Service.of({ summarize, diff, computeDiff })
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() =>
-  layer.pipe(
-    Layer.provide(Session.defaultLayer),
-    Layer.provide(Snapshot.defaultLayer),
-    Layer.provide(Storage.defaultLayer),
-    Layer.provide(Bus.layer),
-  ),
-)
-
-export const DiffInput = z.object({
-  sessionID: SessionID.zod,
-  messageID: MessageID.zod.optional(),
-})
-
-export * as SessionSummary from "./summary"

package/src/session/system.ts

@@ -1,96 +0,0 @@
-import { Context, Effect, Layer } from "effect"
-
-import { Instance } from "../project/instance"
-
-import PROMPT_ANTHROPIC from "./prompt/anthropic.txt"
-import PROMPT_DEFAULT from "./prompt/default.txt"
-import PROMPT_BEAST from "./prompt/beast.txt"
-import PROMPT_GEMINI from "./prompt/gemini.txt"
-import PROMPT_GPT from "./prompt/gpt.txt"
-import PROMPT_KIMI from "./prompt/kimi.txt"
-
-import PROMPT_CODEX from "./prompt/codex.txt"
-import PROMPT_DEEPSEEK from "./prompt/deepseek.txt"
-import PROMPT_GLM from "./prompt/glm.txt"
-import PROMPT_MINIMAX from "./prompt/minimax.txt"
-import PROMPT_TRINITY from "./prompt/trinity.txt"
-import type { Provider } from "@/provider"
-import type { Agent } from "@/agent/agent"
-import { Permission } from "@/permission"
-import { Skill } from "@/skill"
-
-export function provider(model: Provider.Model) {
-  if (model.api.id.includes("gpt-4") || model.api.id.includes("o1") || model.api.id.includes("o3"))
-    return [PROMPT_BEAST]
-  if (model.api.id.includes("gpt")) {
-    if (model.api.id.includes("codex")) {
-      return [PROMPT_CODEX]
-    }
-    return [PROMPT_GPT]
-  }
-  if (model.api.id.includes("gemini-")) return [PROMPT_GEMINI]
-  if (model.api.id.includes("claude")) return [PROMPT_ANTHROPIC]
-  if (model.api.id.toLowerCase().includes("trinity")) return [PROMPT_TRINITY]
-  if (model.api.id.toLowerCase().includes("kimi")) return [PROMPT_KIMI]
-  if (model.api.id.toLowerCase().includes("deepseek")) return [PROMPT_DEEPSEEK]
-  if (model.api.id.toLowerCase().includes("glm")) return [PROMPT_GLM]
-  if (model.api.id.toLowerCase().includes("minimax")) return [PROMPT_MINIMAX]
-  return [PROMPT_DEFAULT]
-}
-
-export interface Interface {
-  readonly environment: (model: Provider.Model, now: number) => string[]
-  readonly skills: (agent: Agent.Info) => Effect.Effect<string | undefined>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SystemPrompt") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const skill = yield* Skill.Service
-
-    return Service.of({
-      environment(model, now) {
-        const project = Instance.project
-        return [
-          [
-            `You are Sleepy Code Agent, built by Xiaomi Sleepy Team. You are an interactive agent that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.`,
-            `You are powered by the model named ${model.api.id}. The exact model ID is ${model.providerID}/${model.api.id}`,
-            `Here is some useful information about the environment you are running in:`,
-            `<env>`,
-            `  Working directory: ${Instance.directory}`,
-            `  Workspace root folder: ${Instance.worktree}`,
-            `  Is directory a git repo: ${project.vcs === "git" ? "yes" : "no"}`,
-            `  Platform: ${process.platform}`,
-            // Anchored to the session's creation time (not request time) so this block
-            // stays byte-identical across every turn of a session — including ones that
-            // cross midnight — keeping it inside the Anthropic cached system prefix.
-            // Both the runLoop and checkpoint prefix-capture paths pass the same value.
-            `  Today's date: ${new Date(now).toDateString()}`,
-            `</env>`,
-          ].join("\n"),
-          `IMPORTANT: Your response must ALWAYS strictly follow the same major language as the user.`,
-        ]
-      },
-
-      skills: Effect.fn("SystemPrompt.skills")(function* (agent: Agent.Info) {
-        if (Permission.disabled(["skill"], agent.permission).has("skill")) return
-
-        const list = yield* skill.available(agent)
-
-        return [
-          "Skills provide specialized instructions and workflows for specific tasks.",
-          "Use the skill tool to load a skill when a task matches its description.",
-          // the agents seem to ingest the information about skills a bit better if we present a more verbose
-          // version of them here and a less verbose version in tool description, rather than vice versa.
-          Skill.fmt(list, { verbose: true }),
-        ].join("\n")
-      }),
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Skill.defaultLayer))
-
-export * as SystemPrompt from "./system"

package/src/session/todo.ts

@@ -1,77 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { SessionID } from "./schema"
-import { Effect, Layer, Context } from "effect"
-import z from "zod"
-import { Database, eq, asc } from "../storage"
-import { TodoTable } from "./session.sql"
-
-export const Info = z
-  .object({
-    content: z.string().describe("Brief description of the task"),
-    status: z.string().describe("Current status of the task: pending, in_progress, completed, cancelled"),
-  })
-  .meta({ ref: "Todo" })
-export type Info = z.infer<typeof Info>
-
-export const Event = {
-  Updated: BusEvent.define(
-    "todo.updated",
-    z.object({
-      sessionID: SessionID.zod,
-      todos: z.array(Info),
-    }),
-  ),
-}
-
-export interface Interface {
-  readonly update: (input: { sessionID: SessionID; todos: Info[] }) => Effect.Effect<void>
-  readonly get: (sessionID: SessionID) => Effect.Effect<Info[]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionTodo") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-
-    const update = Effect.fn("Todo.update")(function* (input: { sessionID: SessionID; todos: Info[] }) {
-      yield* Effect.sync(() =>
-        Database.transaction((db) => {
-          db.delete(TodoTable).where(eq(TodoTable.session_id, input.sessionID)).run()
-          if (input.todos.length === 0) return
-          db.insert(TodoTable)
-            .values(
-              input.todos.map((todo, position) => ({
-                session_id: input.sessionID,
-                content: todo.content,
-                status: todo.status,
-                position,
-              })),
-            )
-            .run()
-        }),
-      )
-      yield* bus.publish(Event.Updated, input)
-    })
-
-    const get = Effect.fn("Todo.get")(function* (sessionID: SessionID) {
-      const rows = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db.select().from(TodoTable).where(eq(TodoTable.session_id, sessionID)).orderBy(asc(TodoTable.position)).all(),
-        ),
-      )
-      return rows.map((row) => ({
-        content: row.content,
-        status: row.status,
-      }))
-    })
-
-    return Service.of({ update, get })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
-
-export * as Todo from "./todo"

package/src/session/trajectory.ts

@@ -1,98 +0,0 @@
-import type { TrajectoryMessage, TrajectoryPart } from "@sleepy-ai/plugin"
-import { MessageV2 } from "./message-v2"
-
-/**
- * Replace `data:` URLs in file parts with a compact summary tag, leaving
- * non-data URLs (file paths, http(s) attachments) untouched. Keeps the
- * trajectory JSON-safe without exploding payload size on inline images.
- */
-function fileUrlSummary(url: string, mime: string, filename?: string) {
-  if (!url.startsWith("data:")) return url
-  return `[data-url:${mime}${filename ? `:${filename}` : ""}]`
-}
-
-function serializeFilePart(part: MessageV2.FilePart): MessageV2.FilePart {
-  return { ...part, url: fileUrlSummary(part.url, part.mime, part.filename) }
-}
-
-/**
- * Strip `data:` URLs from any FilePart attachments inside a tool result.
- * Mutation is shallow — original part is not modified.
- */
-function sanitizeToolState(state: MessageV2.ToolPart["state"]): MessageV2.ToolPart["state"] {
-  if (state.status === "completed" && state.attachments && state.attachments.length > 0) {
-    return { ...state, attachments: state.attachments.map(serializeFilePart) }
-  }
-  return state
-}
-
-/**
- * Serialize a MessageV2.Part for the trajectory wire format. Preserves every
- * field the runtime stores (ID, time, metadata, source, raw, attachments,
- * tokens, etc.) — only `data:` URLs are summarized to keep payloads tractable.
- * The result is a structural superset of MessageV2.Part and is safe to
- * round-trip through JSON.
- */
-export function serializePart(part: MessageV2.Part): TrajectoryPart {
-  if (part.type === "file") return serializeFilePart(part) as unknown as TrajectoryPart
-  if (part.type === "tool") return { ...part, state: sanitizeToolState(part.state) } as unknown as TrajectoryPart
-  return part as unknown as TrajectoryPart
-}
-
-/** Stringify an assistant error blob (NamedError, AbortedError, etc.) for plugin payloads. */
-export function sessionErrorText(error: MessageV2.Assistant["error"]): string | undefined {
-  if (!error) return undefined
-  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
-    return error.message
-  }
-  return JSON.stringify(error)
-}
-
-/** Concatenate non-synthetic, non-ignored user text parts (the visible user query). */
-export function userQueryText(parts: MessageV2.Part[]): string {
-  return parts
-    .filter((p): p is MessageV2.TextPart => p.type === "text" && !p.synthetic && !p.ignored)
-    .map((p) => p.text)
-    .join("\n")
-}
-
-/** Last non-synthetic assistant text, or stringified structured output if present. */
-export function assistantFinalText(message: MessageV2.Assistant, parts: MessageV2.Part[]): string | undefined {
-  if (message.structured !== undefined) return JSON.stringify(message.structured)
-  return parts.findLast((p): p is MessageV2.TextPart => p.type === "text" && !p.synthetic)?.text
-}
-
-/**
- * Serialize a slice of session messages into the wire trajectory format.
- *
- * Field-level fidelity:
- * - Spreads the full MessageV2 info (model, tools, format, tokens, cost,
- *   modelID, providerID, agent, agentID, error, finish, structured, summary,
- *   provenance, path, parentID, mode, variant, …) so a consumer can replay
- *   the conversation exactly as the runtime saw it.
- * - Spreads the full MessageV2.Part (PartID, time, metadata, source, raw,
- *   attachments, tokens, snapshot, …) for every part type — including unknown
- *   future types — without dropping fields.
- *
- * Slice-level fidelity is the caller's responsibility: pass the same slice the
- * agent actually saw (e.g. via MessageV2.filterCompactedEffect with the
- * session's contextFrom/contextWatermark) for replay parity.
- */
-export function serializeTrajectoryMessages(msgs: MessageV2.WithParts[]): TrajectoryMessage[] {
-  return msgs.map((msg) => ({
-    ...msg.info,
-    created: msg.info.time.created,
-    parts: msg.parts.map(serializePart),
-  })) as unknown as TrajectoryMessage[]
-}
-
-/** Replace the assistant entry in a message slice with freshly loaded parts. */
-export function withAssistantParts(
-  msgs: MessageV2.WithParts[],
-  assistant: MessageV2.Assistant,
-  parts: MessageV2.Part[],
-): MessageV2.WithParts[] {
-  const idx = msgs.findIndex((m) => m.info.id === assistant.id)
-  if (idx === -1) return [...msgs, { info: assistant, parts }]
-  return msgs.map((m, i) => (i === idx ? { info: assistant, parts } : m))
-}

package/src/share/index.ts

@@ -1,2 +0,0 @@
-export * as ShareNext from "./share-next"
-export * as SessionShare from "./session"

package/src/share/session.ts

@@ -1,57 +0,0 @@
-import { Session } from "@/session"
-import { SessionID } from "@/session/schema"
-import { SyncEvent } from "@/sync"
-import { Effect, Layer, Scope, Context } from "effect"
-import { Config } from "../config"
-import { Flag } from "../flag/flag"
-import * as ShareNext from "./share-next"
-
-export interface Interface {
-  readonly create: (input?: Session.CreateInput) => Effect.Effect<Session.Info>
-  readonly share: (sessionID: SessionID) => Effect.Effect<{ url: string }, unknown>
-  readonly unshare: (sessionID: SessionID) => Effect.Effect<void, unknown>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SessionShare") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const cfg = yield* Config.Service
-    const session = yield* Session.Service
-    const shareNext = yield* ShareNext.Service
-    const scope = yield* Scope.Scope
-
-    const share = Effect.fn("SessionShare.share")(function* (sessionID: SessionID) {
-      const conf = yield* cfg.get()
-      if (conf.share === "disabled") throw new Error("Sharing is disabled in configuration")
-      const result = yield* shareNext.create(sessionID)
-      yield* Effect.sync(() =>
-        SyncEvent.run(Session.Event.Updated, { sessionID, info: { share: { url: result.url } } }),
-      )
-      return result
-    })
-
-    const unshare = Effect.fn("SessionShare.unshare")(function* (sessionID: SessionID) {
-      yield* shareNext.remove(sessionID)
-      yield* Effect.sync(() => SyncEvent.run(Session.Event.Updated, { sessionID, info: { share: { url: null } } }))
-    })
-
-    const create = Effect.fn("SessionShare.create")(function* (input?: Session.CreateInput) {
-      const result = yield* session.create(input)
-      if (result.parentID) return result
-      const conf = yield* cfg.get()
-      if (!(Flag.SLEEPYCODE_AUTO_SHARE || conf.share === "auto")) return result
-      yield* share(result.id).pipe(Effect.ignore, Effect.forkIn(scope))
-      return result
-    })
-
-    return Service.of({ create, share, unshare })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(ShareNext.defaultLayer),
-  Layer.provide(Session.defaultLayer),
-  Layer.provide(Config.defaultLayer),
-)