@sleepy-ai/cli 0.1.16 → 0.1.17

package/src/sync/index.ts

@@ -1,278 +0,0 @@
-import z from "zod"
-import type { ZodObject } from "zod"
-import { Database, eq } from "@/storage"
-import { GlobalBus } from "@/bus/global"
-import { Bus as ProjectBus } from "@/bus"
-import { BusEvent } from "@/bus/bus-event"
-import { Instance } from "@/project/instance"
-import { EventSequenceTable, EventTable } from "./event.sql"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { EventID } from "./schema"
-import { Flag } from "@/flag/flag"
-
-export type Definition = {
-  type: string
-  version: number
-  aggregate: string
-  schema: z.ZodObject
-
-  // This is temporary and only exists for compatibility with bus
-  // event definitions
-  properties: z.ZodObject
-}
-
-export type Event<Def extends Definition = Definition> = {
-  id: string
-  seq: number
-  aggregateID: string
-  data: z.infer<Def["schema"]>
-}
-
-export type SerializedEvent<Def extends Definition = Definition> = Event<Def> & { type: string }
-
-type ProjectorFunc = (db: Database.TxOrDb, data: unknown) => void
-
-export const registry = new Map<string, Definition>()
-let projectors: Map<Definition, ProjectorFunc> | undefined
-const versions = new Map<string, number>()
-let frozen = false
-let convertEvent: (type: string, event: Event["data"]) => Promise<Record<string, unknown>> | Record<string, unknown>
-
-export function reset() {
-  frozen = false
-  projectors = undefined
-  convertEvent = (_, data) => data
-}
-
-export function init(input: { projectors: Array<[Definition, ProjectorFunc]>; convertEvent?: typeof convertEvent }) {
-  projectors = new Map(input.projectors)
-
-  // Install all the latest event defs to the bus. We only ever emit
-  // latest versions from code, and keep around old versions for
-  // replaying. Replaying does not go through the bus, and it
-  // simplifies the bus to only use unversioned latest events
-  for (let [type, version] of versions.entries()) {
-    let def = registry.get(versionedType(type, version))!
-
-    BusEvent.define(def.type, def.properties || def.schema)
-  }
-
-  // Freeze the system so it clearly errors if events are defined
-  // after `init` which would cause bugs
-  frozen = true
-  convertEvent = input.convertEvent || ((_, data) => data)
-}
-
-export function versionedType<A extends string>(type: A): A
-export function versionedType<A extends string, B extends number>(type: A, version: B): `${A}/${B}`
-export function versionedType(type: string, version?: number) {
-  return version ? `${type}.${version}` : type
-}
-
-export function define<
-  Type extends string,
-  Agg extends string,
-  Schema extends ZodObject<Record<Agg, z.ZodType<string>>>,
-  BusSchema extends ZodObject = Schema,
->(input: { type: Type; version: number; aggregate: Agg; schema: Schema; busSchema?: BusSchema }) {
-  if (frozen) {
-    throw new Error("Error defining sync event: sync system has been frozen")
-  }
-
-  const def = {
-    type: input.type,
-    version: input.version,
-    aggregate: input.aggregate,
-    schema: input.schema,
-    properties: input.busSchema ? input.busSchema : input.schema,
-  }
-
-  versions.set(def.type, Math.max(def.version, versions.get(def.type) || 0))
-
-  registry.set(versionedType(def.type, def.version), def)
-
-  return def
-}
-
-export function project<Def extends Definition>(
-  def: Def,
-  func: (db: Database.TxOrDb, data: Event<Def>["data"]) => void,
-): [Definition, ProjectorFunc] {
-  return [def, func as ProjectorFunc]
-}
-
-function process<Def extends Definition>(def: Def, event: Event<Def>, options: { publish: boolean }) {
-  if (projectors == null) {
-    throw new Error("No projectors available. Call `SyncEvent.init` to install projectors")
-  }
-
-  const projector = projectors.get(def)
-  if (!projector) {
-    throw new Error(`Projector not found for event: ${def.type}`)
-  }
-
-  // idempotent: need to ignore any events already logged
-
-  Database.transaction((tx) => {
-    projector(tx, event.data)
-
-    if (Flag.SLEEPYCODE_EXPERIMENTAL_WORKSPACES) {
-      tx.insert(EventSequenceTable)
-        .values({
-          aggregate_id: event.aggregateID,
-          seq: event.seq,
-        })
-        .onConflictDoUpdate({
-          target: EventSequenceTable.aggregate_id,
-          set: { seq: event.seq },
-        })
-        .run()
-      tx.insert(EventTable)
-        .values({
-          id: event.id,
-          seq: event.seq,
-          aggregate_id: event.aggregateID,
-          type: versionedType(def.type, def.version),
-          data: event.data as Record<string, unknown>,
-        })
-        .run()
-    }
-
-    Database.effect(() => {
-      if (options?.publish) {
-        const result = convertEvent(def.type, event.data)
-        if (result instanceof Promise) {
-          void result.then((data) => {
-            void ProjectBus.publish({ type: def.type, properties: def.schema }, data)
-          })
-        } else {
-          void ProjectBus.publish({ type: def.type, properties: def.schema }, result)
-        }
-
-        GlobalBus.emit("event", {
-          directory: Instance.directory,
-          project: Instance.project.id,
-          workspace: WorkspaceContext.workspaceID,
-          payload: {
-            type: "sync",
-            syncEvent: {
-              type: versionedType(def.type, def.version),
-              ...event,
-            },
-          },
-        })
-      }
-    })
-  })
-}
-
-export function replay(event: SerializedEvent, options?: { publish: boolean }) {
-  const def = registry.get(event.type)
-  if (!def) {
-    throw new Error(`Unknown event type: ${event.type}`)
-  }
-
-  const row = Database.use((db) =>
-    db
-      .select({ seq: EventSequenceTable.seq })
-      .from(EventSequenceTable)
-      .where(eq(EventSequenceTable.aggregate_id, event.aggregateID))
-      .get(),
-  )
-
-  const latest = row?.seq ?? -1
-  if (event.seq <= latest) {
-    return
-  }
-
-  const expected = latest + 1
-  if (event.seq !== expected) {
-    throw new Error(`Sequence mismatch for aggregate "${event.aggregateID}": expected ${expected}, got ${event.seq}`)
-  }
-
-  process(def, event, { publish: !!options?.publish })
-}
-
-export function replayAll(events: SerializedEvent[], options?: { publish: boolean }) {
-  const source = events[0]?.aggregateID
-  if (!source) return
-  if (events.some((item) => item.aggregateID !== source)) {
-    throw new Error("Replay events must belong to the same session")
-  }
-  const start = events[0].seq
-  for (const [i, item] of events.entries()) {
-    const seq = start + i
-    if (item.seq !== seq) {
-      throw new Error(`Replay sequence mismatch at index ${i}: expected ${seq}, got ${item.seq}`)
-    }
-  }
-  for (const item of events) {
-    replay(item, options)
-  }
-  return source
-}
-
-export function run<Def extends Definition>(def: Def, data: Event<Def>["data"], options?: { publish?: boolean }) {
-  const agg = (data as Record<string, string>)[def.aggregate]
-  // This should never happen: we've enforced it via typescript in
-  // the definition
-  if (agg == null) {
-    throw new Error(`SyncEvent.run: "${def.aggregate}" required but not found: ${JSON.stringify(data)}`)
-  }
-
-  if (def.version !== versions.get(def.type)) {
-    throw new Error(`SyncEvent.run: running old versions of events is not allowed: ${def.type}`)
-  }
-
-  const { publish = true } = options || {}
-
-  // Note that this is an "immediate" transaction which is critical.
-  // We need to make sure we can safely read and write with nothing
-  // else changing the data from under us
-  Database.transaction(
-    (tx) => {
-      const id = EventID.ascending()
-      const row = tx
-        .select({ seq: EventSequenceTable.seq })
-        .from(EventSequenceTable)
-        .where(eq(EventSequenceTable.aggregate_id, agg))
-        .get()
-      const seq = row?.seq != null ? row.seq + 1 : 0
-
-      const event = { id, seq, aggregateID: agg, data }
-      process(def, event, { publish })
-    },
-    {
-      behavior: "immediate",
-    },
-  )
-}
-
-export function remove(aggregateID: string) {
-  Database.transaction((tx) => {
-    tx.delete(EventSequenceTable).where(eq(EventSequenceTable.aggregate_id, aggregateID)).run()
-    tx.delete(EventTable).where(eq(EventTable.aggregate_id, aggregateID)).run()
-  })
-}
-
-export function payloads() {
-  return registry
-    .entries()
-    .map(([type, def]) => {
-      return z
-        .object({
-          type: z.literal("sync"),
-          name: z.literal(type),
-          id: z.string(),
-          seq: z.number(),
-          aggregateID: z.literal(def.aggregate),
-          data: def.schema,
-        })
-        .meta({
-          ref: `SyncEvent.${def.type}`,
-        })
-    })
-    .toArray()
-}
-
-export * as SyncEvent from "."

package/src/sync/schema.ts

@@ -1,14 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-
-import { Identifier } from "@/id/id"
-import { ZodOverride } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export const EventID = Schema.String.annotate({ [ZodOverride]: Identifier.schema("event") }).pipe(
-  Schema.brand("EventID"),
-  withStatics((s) => ({
-    ascending: (id?: string) => s.make(Identifier.ascending("event", id)),
-    zod: Identifier.schema("event").pipe(z.custom<Schema.Schema.Type<typeof s>>()),
-  })),
-)

package/src/task/events.ts

@@ -1,28 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import { SessionID } from "@/session/schema"
-import z from "zod"
-import { Task, TaskEventKind } from "./schema"
-
-export const Created = BusEvent.define(
-  "task.created",
-  z.object({
-    sessionID: SessionID.zod,
-    task: Task,
-  }),
-)
-
-// `kind` narrows the lifecycle transition that produced this event. `created`
-// is excluded — new rows ride [[Created]] so external consumers can split
-// "row appeared" from "row mutated" without an if-kind branch (matching
-// actor.registered vs actor.status).
-export const UpdatedKind = TaskEventKind.exclude(["created"])
-export type UpdatedKind = z.infer<typeof UpdatedKind>
-
-export const Updated = BusEvent.define(
-  "task.updated",
-  z.object({
-    sessionID: SessionID.zod,
-    task: Task,
-    kind: UpdatedKind,
-  }),
-)

package/src/task/gate-state.ts

@@ -1,54 +0,0 @@
-import { Context, Effect, Layer } from "effect"
-import { InstanceState } from "@/effect"
-import type { SessionID } from "@/session/schema"
-
-/**
- * Per-session ReAct counter for the main-path task stop gate. Mirrors
- * Goal.bumpReact (session/goal.ts) — same pattern, different signal: this
- * counts re-entries triggered by non-terminal tasks rather than an unmet
- * goal condition. State lives in InstanceState (per project instance);
- * cleared on instance teardown.
- */
-
-export interface Interface {
-  readonly get: (sessionID: SessionID) => Effect.Effect<number>
-  /** Increment counter, return new value. */
-  readonly bump: (sessionID: SessionID) => Effect.Effect<number>
-  readonly clear: (sessionID: SessionID) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/TaskGateState") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const state = yield* InstanceState.make(
-      Effect.fn("TaskGateState.state")(function* () {
-        return { counts: new Map<string, number>() }
-      }),
-    )
-
-    const get = Effect.fn("TaskGateState.get")(function* (sessionID: SessionID) {
-      const data = yield* InstanceState.get(state)
-      return data.counts.get(sessionID) ?? 0
-    })
-
-    const bump = Effect.fn("TaskGateState.bump")(function* (sessionID: SessionID) {
-      const data = yield* InstanceState.get(state)
-      const next = (data.counts.get(sessionID) ?? 0) + 1
-      data.counts.set(sessionID, next)
-      return next
-    })
-
-    const clear = Effect.fn("TaskGateState.clear")(function* (sessionID: SessionID) {
-      const data = yield* InstanceState.get(state)
-      data.counts.delete(sessionID)
-    })
-
-    return Service.of({ get, bump, clear })
-  }),
-)
-
-export const defaultLayer = layer
-
-export * as TaskGateState from "./gate-state"

package/src/task/gate.ts

@@ -1,116 +0,0 @@
-import { Effect } from "effect"
-import { TaskRegistry } from "./registry"
-import type { SessionID } from "@/session/schema"
-
-/**
- * Cap on stop-gate ReAct re-entries when a subagent finishes with
- * non-terminal tasks on the board. Lower than the main-session cap because
- * subagents have shorter lifetimes; if 2 nudges don't close the work, the
- * actor returns "partial"/"blocked" and the main session picks it up.
- */
-export const MAX_TASK_GATE_SUBAGENT_REACT = 2
-
-/**
- * Cap on stop-gate ReAct re-entries on the main session loop. Higher than
- * the subagent cap because a main session is long-lived and the gate is the
- * last defense before stop. Lower than MAX_GOAL_REACT (12) because there is
- * no judge model — only DB state — so we can't disambiguate "model is still
- * working" from "model is stalling".
- */
-export const MAX_TASK_GATE_MAIN_REACT = 3
-
-export type GateMode = "subagent" | "main"
-
-export type Decision =
-  | { needReentry: false; capExceeded: false; incompleteTasks: [] }
-  | { needReentry: true; reentryText: string; incompleteTasks: string[]; capExceeded: false }
-  | { needReentry: false; capExceeded: true; incompleteTasks: string[] }
-
-export interface DecideInput {
-  session_id: SessionID
-  /**
-   * Subagent path: actorID — only that actor's tasks count.
-   * Main path: undefined — every non-terminal task in the session counts
-   * (catches subagent-orphaned tasks; see spec "Owner semantics").
-   */
-  owner?: string
-  reactCount: number
-  maxReact: number
-  mode: GateMode
-}
-
-const buildReentryText = (
-  incomplete: { id: string; status: string; summary: string }[],
-  mode: GateMode,
-): string => {
-  // Headline shifts with mode because owner semantics differ:
-  //   subagent: owner=actorID — every listed task IS owned by the recipient
-  //     ("you own" is literally true).
-  //   main:     owner=undefined — list spans all session tasks, including
-  //     subagent-orphaned ones the recipient never created. Saying "you own"
-  //     would mislead main into preferring `task abandon` over completing
-  //     orphan work, defeating the safety-net purpose.
-  const headline =
-    mode === "subagent"
-      ? "You are about to finish, but these tasks you own are still unfinished:"
-      : "You are about to finish, but these tasks in this session are still unfinished:"
-  const closingLine =
-    mode === "subagent"
-      ? "Then re-emit your final message starting with the **Status**/**Summary** header."
-      : "Then continue or respond."
-  return [
-    "<system-reminder>",
-    headline,
-    ...incomplete.map((t) => `- ${t.id} (${t.status}): ${t.summary}`),
-    "For EACH: complete the work then `task done <id> <summary>`, or `task abandon <id> <reason>` if it is genuinely not needed.",
-    closingLine,
-    "</system-reminder>",
-  ].join("\n")
-}
-
-/**
- * Pure decision: list non-terminal tasks for (session, owner), return
- * one of three branches (empty / nudge-text / cap-exceeded). Caller owns
- * synthetic-message injection and cap-state management.
- *
- * orElseSucceed on registry failure: a transient DB error must NEVER trap
- * the agent in the gate — fail open by reporting empty so the caller stops
- * cleanly. Mirrors actor/spawn.ts:412 today.
- */
-export const decide = Effect.fn("TaskGate.decide")(function* (input: DecideInput) {
-  const reg = yield* TaskRegistry.Service
-  const tasks = yield* reg
-    .list({
-      session_id: input.session_id,
-      owner: input.owner,
-      include_terminal: false,
-    })
-    .pipe(Effect.orElseSucceed(() => []))
-
-  // include_terminal:false keeps `blocked` (it's non-terminal). Drop it here:
-  // a blocked task is one the actor genuinely can't proceed on, so nudging
-  // "complete or abandon" would loop unanswerable. Mirrors the original
-  // actor/spawn.ts gate filter that this helper preserves.
-  const actionable = tasks.filter((t) => t.status === "open" || t.status === "in_progress")
-
-  if (actionable.length === 0) {
-    return { needReentry: false, capExceeded: false, incompleteTasks: [] } satisfies Decision
-  }
-
-  if (input.reactCount >= input.maxReact) {
-    return {
-      needReentry: false,
-      capExceeded: true,
-      incompleteTasks: actionable.map((t) => t.id),
-    } satisfies Decision
-  }
-
-  return {
-    needReentry: true,
-    capExceeded: false,
-    reentryText: buildReentryText(actionable, input.mode),
-    incompleteTasks: actionable.map((t) => t.id),
-  } satisfies Decision
-})
-
-export * as TaskGate from "./gate"

package/src/task/index.ts

@@ -1 +0,0 @@
-export * as TaskRegistry from "./registry"