@sleepy-ai/cli 0.1.5 → 0.1.7

package/src/effect/logger.ts

@@ -1,73 +0,0 @@
-import { Cause, Effect, Logger, References } from "effect"
-import { Log } from "@/util"
-
-type Fields = Record<string, unknown>
-
-const normalizeKey = (key: string) => (key === "sessionID" ? "session.id" : key)
-
-export interface Handle {
-  readonly debug: (msg?: unknown, extra?: Fields) => Effect.Effect<void>
-  readonly info: (msg?: unknown, extra?: Fields) => Effect.Effect<void>
-  readonly warn: (msg?: unknown, extra?: Fields) => Effect.Effect<void>
-  readonly error: (msg?: unknown, extra?: Fields) => Effect.Effect<void>
-  readonly with: (extra: Fields) => Handle
-}
-
-const clean = (input?: Fields): Fields =>
-  Object.fromEntries(
-    Object.entries(input ?? {})
-      .filter((entry) => entry[1] !== undefined && entry[1] !== null)
-      .map(([key, value]) => [normalizeKey(key), value]),
-  )
-
-const text = (input: unknown): string => {
-  // oxlint-disable-next-line no-base-to-string
-  if (Array.isArray(input)) return input.map((item) => String(item)).join(" ")
-  // oxlint-disable-next-line no-base-to-string
-  return input === undefined ? "" : String(input)
-}
-
-const call = (run: (msg?: unknown) => Effect.Effect<void>, base: Fields, msg?: unknown, extra?: Fields) => {
-  const ann = clean({ ...base, ...extra })
-  const fx = run(msg)
-  return Object.keys(ann).length ? Effect.annotateLogs(fx, ann) : fx
-}
-
-export const logger = Logger.make((opts) => {
-  const extra = clean(opts.fiber.getRef(References.CurrentLogAnnotations))
-  const now = opts.date.getTime()
-  for (const [key, start] of opts.fiber.getRef(References.CurrentLogSpans)) {
-    extra[`logSpan.${key}`] = `${now - start}ms`
-  }
-  if (opts.cause.reasons.length > 0) {
-    extra.cause = Cause.pretty(opts.cause)
-  }
-
-  const svc = typeof extra.service === "string" ? extra.service : undefined
-  if (svc) delete extra.service
-  const log = svc ? Log.create({ service: svc }) : Log.Default
-  const msg = text(opts.message)
-
-  switch (opts.logLevel) {
-    case "Trace":
-    case "Debug":
-      return log.debug(msg, extra)
-    case "Warn":
-      return log.warn(msg, extra)
-    case "Error":
-    case "Fatal":
-      return log.error(msg, extra)
-    default:
-      return log.info(msg, extra)
-  }
-})
-
-export const layer = Logger.layer([logger], { mergeWithExisting: false })
-
-export const create = (base: Fields = {}): Handle => ({
-  debug: (msg, extra) => call((item) => Effect.logDebug(item), base, msg, extra),
-  info: (msg, extra) => call((item) => Effect.logInfo(item), base, msg, extra),
-  warn: (msg, extra) => call((item) => Effect.logWarning(item), base, msg, extra),
-  error: (msg, extra) => call((item) => Effect.logError(item), base, msg, extra),
-  with: (extra) => create({ ...base, ...extra }),
-})

package/src/effect/memo-map.ts

@@ -1,3 +0,0 @@
-import { Layer } from "effect"
-
-export const memoMap = Layer.makeMemoMapUnsafe()

package/src/effect/observability.ts

@@ -1,107 +0,0 @@
-import { Effect, Layer, Logger } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { OtlpLogger, OtlpSerialization } from "effect/unstable/observability"
-import * as EffectLogger from "./logger"
-import { Flag } from "@/flag/flag"
-import { InstallationChannel, InstallationVersion } from "@/installation/version"
-import { ensureProcessMetadata } from "@/util/sleepy-process"
-
-const base = Flag.OTEL_EXPORTER_OTLP_ENDPOINT
-export const enabled = !!base
-const processID = crypto.randomUUID()
-
-const headers = Flag.OTEL_EXPORTER_OTLP_HEADERS
-  ? Flag.OTEL_EXPORTER_OTLP_HEADERS.split(",").reduce(
-      (acc, x) => {
-        const [key, ...value] = x.split("=")
-        acc[key] = value.join("=")
-        return acc
-      },
-      {} as Record<string, string>,
-    )
-  : undefined
-
-export function resource(): { serviceName: string; serviceVersion: string; attributes: Record<string, string> } {
-  const processMetadata = ensureProcessMetadata("main")
-  const attributes: Record<string, string> = (() => {
-    const value = process.env.OTEL_RESOURCE_ATTRIBUTES
-    if (!value) return {}
-    try {
-      return Object.fromEntries(
-        value.split(",").map((entry) => {
-          const index = entry.indexOf("=")
-          if (index < 1) throw new Error("Invalid OTEL_RESOURCE_ATTRIBUTES entry")
-          return [decodeURIComponent(entry.slice(0, index)), decodeURIComponent(entry.slice(index + 1))]
-        }),
-      )
-    } catch {
-      return {}
-    }
-  })()
-
-  return {
-    serviceName: "opencode",
-    serviceVersion: InstallationVersion,
-    attributes: {
-      ...attributes,
-      "deployment.environment.name": InstallationChannel,
-      "opencode.client": Flag.SLEEPYCODE_CLIENT,
-      "opencode.process_role": processMetadata.processRole,
-      "opencode.run_id": processMetadata.runID,
-      "service.instance.id": processID,
-    },
-  }
-}
-
-function logs() {
-  return Logger.layer(
-    [
-      EffectLogger.logger,
-      OtlpLogger.make({
-        url: `${base}/v1/logs`,
-        resource: resource(),
-        headers,
-      }),
-    ],
-    { mergeWithExisting: false },
-  ).pipe(Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer))
-}
-
-const traces = async () => {
-  const NodeSdk = await import("@effect/opentelemetry/NodeSdk")
-  const OTLP = await import("@opentelemetry/exporter-trace-otlp-http")
-  const SdkBase = await import("@opentelemetry/sdk-trace-base")
-
-  // @effect/opentelemetry creates a NodeTracerProvider but never calls
-  // register(), so the global @opentelemetry/api context manager stays
-  // as the no-op default. Non-Effect code (like the AI SDK) that calls
-  // tracer.startActiveSpan() relies on context.active() to find the
-  // parent span — without a real context manager every span starts a
-  // new trace. Registering AsyncLocalStorageContextManager fixes this.
-  const { AsyncLocalStorageContextManager } = await import("@opentelemetry/context-async-hooks")
-  const { context } = await import("@opentelemetry/api")
-  const mgr = new AsyncLocalStorageContextManager()
-  mgr.enable()
-  context.setGlobalContextManager(mgr)
-
-  return NodeSdk.layer(() => ({
-    resource: resource(),
-    spanProcessor: new SdkBase.BatchSpanProcessor(
-      new OTLP.OTLPTraceExporter({
-        url: `${base}/v1/traces`,
-        headers,
-      }),
-    ),
-  }))
-}
-
-export const layer = !base
-  ? EffectLogger.layer
-  : Layer.unwrap(
-      Effect.gen(function* () {
-        const trace = yield* Effect.promise(traces)
-        return Layer.mergeAll(trace, logs())
-      }),
-    )
-
-export const Observability = { enabled, layer }

package/src/effect/run-service.ts

@@ -1,52 +0,0 @@
-import { Effect, Layer, ManagedRuntime } from "effect"
-import * as Context from "effect/Context"
-import { Instance } from "@/project/instance"
-import { LocalContext } from "@/util"
-import { InstanceRef, WorkspaceRef } from "./instance-ref"
-import * as Observability from "./observability"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import type { InstanceContext } from "@/project/instance"
-import { memoMap } from "./memo-map"
-
-type Refs = {
-  instance?: InstanceContext
-  workspace?: string
-}
-
-export function attachWith<A, E, R>(effect: Effect.Effect<A, E, R>, refs: Refs): Effect.Effect<A, E, R> {
-  if (!refs.instance && !refs.workspace) return effect
-  if (!refs.instance) return effect.pipe(Effect.provideService(WorkspaceRef, refs.workspace))
-  if (!refs.workspace) return effect.pipe(Effect.provideService(InstanceRef, refs.instance))
-  return effect.pipe(
-    Effect.provideService(InstanceRef, refs.instance),
-    Effect.provideService(WorkspaceRef, refs.workspace),
-  )
-}
-
-export function attach<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> {
-  try {
-    return attachWith(effect, {
-      instance: Instance.current,
-      workspace: WorkspaceContext.workspaceID,
-    })
-  } catch (err) {
-    if (!(err instanceof LocalContext.NotFound)) throw err
-  }
-  return effect
-}
-
-export function makeRuntime<I, S, E>(service: Context.Service<I, S>, layer: Layer.Layer<I, E>) {
-  let rt: ManagedRuntime.ManagedRuntime<I, E> | undefined
-  const getRuntime = () => (rt ??= ManagedRuntime.make(Layer.provideMerge(layer, Observability.layer), { memoMap }))
-
-  return {
-    runSync: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runSync(attach(service.use(fn))),
-    runPromiseExit: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) =>
-      getRuntime().runPromiseExit(attach(service.use(fn)), options),
-    runPromise: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) =>
-      getRuntime().runPromise(attach(service.use(fn)), options),
-    runFork: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runFork(attach(service.use(fn))),
-    runCallback: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) =>
-      getRuntime().runCallback(attach(service.use(fn))),
-  }
-}

package/src/effect/runner.ts

@@ -1,210 +0,0 @@
-import { Cause, Deferred, Effect, Exit, Fiber, Schema, Scope, SynchronizedRef } from "effect"
-
-export interface Runner<A, E = never> {
-  readonly state: State<A, E>
-  readonly busy: boolean
-  readonly ensureRunning: (work: Effect.Effect<A, E>) => Effect.Effect<A, E>
-  readonly startShell: (work: Effect.Effect<A, E>) => Effect.Effect<A, E>
-  readonly cancel: Effect.Effect<void>
-}
-
-export class Cancelled extends Schema.TaggedErrorClass<Cancelled>()("RunnerCancelled", {}) {}
-
-interface RunHandle<A, E> {
-  id: number
-  done: Deferred.Deferred<A, E | Cancelled>
-  fiber: Fiber.Fiber<A, E>
-}
-
-interface ShellHandle<A, E> {
-  id: number
-  fiber: Fiber.Fiber<A, E>
-}
-
-interface PendingHandle<A, E> {
-  id: number
-  done: Deferred.Deferred<A, E | Cancelled>
-  work: Effect.Effect<A, E>
-}
-
-export type State<A, E> =
-  | { readonly _tag: "Idle" }
-  | { readonly _tag: "Running"; readonly run: RunHandle<A, E> }
-  | { readonly _tag: "Shell"; readonly shell: ShellHandle<A, E> }
-  | { readonly _tag: "ShellThenRun"; readonly shell: ShellHandle<A, E>; readonly run: PendingHandle<A, E> }
-
-export const make = <A, E = never>(
-  scope: Scope.Scope,
-  opts?: {
-    onIdle?: Effect.Effect<void>
-    onBusy?: Effect.Effect<void>
-    onInterrupt?: Effect.Effect<A, E>
-    busy?: () => never
-    label?: string
-    onReentryWarn?: (info: { label: string; existingRunId: number }) => Effect.Effect<void>
-  },
-): Runner<A, E> => {
-  const ref = SynchronizedRef.makeUnsafe<State<A, E>>({ _tag: "Idle" })
-  const idle = opts?.onIdle ?? Effect.void
-  const busy = opts?.onBusy ?? Effect.void
-  const onInterrupt = opts?.onInterrupt
-  let ids = 0
-
-  const state = () => SynchronizedRef.getUnsafe(ref)
-  const next = () => {
-    ids += 1
-    return ids
-  }
-
-  const complete = (done: Deferred.Deferred<A, E | Cancelled>, exit: Exit.Exit<A, E>) =>
-    Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)
-      ? Deferred.fail(done, new Cancelled()).pipe(Effect.asVoid)
-      : Deferred.done(done, exit).pipe(Effect.asVoid)
-
-  const idleIfCurrent = () =>
-    SynchronizedRef.modify(ref, (st) => [st._tag === "Idle" ? idle : Effect.void, st] as const).pipe(Effect.flatten)
-
-  const finishRun = (id: number, done: Deferred.Deferred<A, E | Cancelled>, exit: Exit.Exit<A, E>) =>
-    SynchronizedRef.modify(
-      ref,
-      (st) =>
-        [
-          Effect.gen(function* () {
-            if (st._tag === "Running" && st.run.id === id) yield* idle
-            yield* complete(done, exit)
-          }),
-          st._tag === "Running" && st.run.id === id ? ({ _tag: "Idle" } as const) : st,
-        ] as const,
-    ).pipe(Effect.flatten)
-
-  const startRun = (work: Effect.Effect<A, E>, done: Deferred.Deferred<A, E | Cancelled>) =>
-    Effect.gen(function* () {
-      const id = next()
-      const fiber = yield* work.pipe(
-        Effect.onExit((exit) => finishRun(id, done, exit)),
-        Effect.forkIn(scope),
-      )
-      return { id, done, fiber } satisfies RunHandle<A, E>
-    })
-
-  const finishShell = (id: number) =>
-    SynchronizedRef.modifyEffect(
-      ref,
-      Effect.fnUntraced(function* (st) {
-        if (st._tag === "Shell" && st.shell.id === id) return [idle, { _tag: "Idle" }] as const
-        if (st._tag === "ShellThenRun" && st.shell.id === id) {
-          const run = yield* startRun(st.run.work, st.run.done)
-          return [Effect.void, { _tag: "Running", run }] as const
-        }
-        return [Effect.void, st] as const
-      }),
-    ).pipe(Effect.flatten)
-
-  const stopShell = (shell: ShellHandle<A, E>) => Fiber.interrupt(shell.fiber)
-
-  const ensureRunning = (work: Effect.Effect<A, E>) =>
-    SynchronizedRef.modifyEffect(
-      ref,
-      Effect.fnUntraced(function* (st) {
-        switch (st._tag) {
-          case "Running":
-          case "ShellThenRun":
-            if (opts?.onReentryWarn)
-              yield* opts.onReentryWarn({ label: opts.label ?? "(unlabeled)", existingRunId: st.run.id })
-            return [Deferred.await(st.run.done), st] as const
-          case "Shell": {
-            const run = {
-              id: next(),
-              done: yield* Deferred.make<A, E | Cancelled>(),
-              work,
-            } satisfies PendingHandle<A, E>
-            return [Deferred.await(run.done), { _tag: "ShellThenRun", shell: st.shell, run }] as const
-          }
-          case "Idle": {
-            const done = yield* Deferred.make<A, E | Cancelled>()
-            const run = yield* startRun(work, done)
-            return [Deferred.await(done), { _tag: "Running", run }] as const
-          }
-        }
-      }),
-    ).pipe(
-      Effect.flatten,
-      Effect.catch(
-        (e): Effect.Effect<A, E> => (e instanceof Cancelled ? (onInterrupt ?? Effect.die(e)) : Effect.fail(e as E)),
-      ),
-    )
-
-  const startShell = (work: Effect.Effect<A, E>) =>
-    SynchronizedRef.modifyEffect(
-      ref,
-      Effect.fnUntraced(function* (st) {
-        if (st._tag !== "Idle") {
-          return [
-            Effect.sync(() => {
-              if (opts?.busy) opts.busy()
-              throw new Error("Runner is busy")
-            }),
-            st,
-          ] as const
-        }
-        yield* busy
-        const id = next()
-        const fiber = yield* work.pipe(Effect.ensuring(finishShell(id)), Effect.forkChild)
-        const shell = { id, fiber } satisfies ShellHandle<A, E>
-        return [
-          Effect.gen(function* () {
-            const exit = yield* Fiber.await(fiber)
-            if (Exit.isSuccess(exit)) return exit.value
-            if (Cause.hasInterruptsOnly(exit.cause) && onInterrupt) return yield* onInterrupt
-            return yield* Effect.failCause(exit.cause)
-          }),
-          { _tag: "Shell", shell },
-        ] as const
-      }),
-    ).pipe(Effect.flatten)
-
-  const cancel = SynchronizedRef.modify(ref, (st) => {
-    switch (st._tag) {
-      case "Idle":
-        return [Effect.void, st] as const
-      case "Running":
-        return [
-          Effect.gen(function* () {
-            yield* Fiber.interrupt(st.run.fiber)
-            yield* Deferred.await(st.run.done).pipe(Effect.exit, Effect.asVoid)
-            yield* idleIfCurrent()
-          }),
-          { _tag: "Idle" } as const,
-        ] as const
-      case "Shell":
-        return [
-          Effect.gen(function* () {
-            yield* stopShell(st.shell)
-            yield* idleIfCurrent()
-          }),
-          { _tag: "Idle" } as const,
-        ] as const
-      case "ShellThenRun":
-        return [
-          Effect.gen(function* () {
-            yield* Deferred.fail(st.run.done, new Cancelled()).pipe(Effect.asVoid)
-            yield* stopShell(st.shell)
-            yield* idleIfCurrent()
-          }),
-          { _tag: "Idle" } as const,
-        ] as const
-    }
-  }).pipe(Effect.flatten)
-
-  return {
-    get state() {
-      return state()
-    },
-    get busy() {
-      return state()._tag !== "Idle"
-    },
-    ensureRunning,
-    startShell,
-    cancel,
-  }
-}

package/src/effect/runtime.ts

@@ -1,19 +0,0 @@
-import { Observability } from "./observability"
-import { Layer, type Context, ManagedRuntime, type Effect } from "effect"
-import { memoMap } from "./memo-map"
-
-export function makeRuntime<I, S, E>(service: Context.Service<I, S>, layer: Layer.Layer<I, E>) {
-  let rt: ManagedRuntime.ManagedRuntime<I, E> | undefined
-  const getRuntime = () =>
-    (rt ??= ManagedRuntime.make(Layer.provideMerge(layer, Observability.layer) as Layer.Layer<I, E>, { memoMap }))
-
-  return {
-    runSync: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runSync(service.use(fn)),
-    runPromiseExit: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) =>
-      getRuntime().runPromiseExit(service.use(fn), options),
-    runPromise: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) =>
-      getRuntime().runPromise(service.use(fn), options),
-    runFork: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runFork(service.use(fn)),
-    runCallback: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => getRuntime().runCallback(service.use(fn)),
-  }
-}

package/src/env/index.ts

@@ -1,37 +0,0 @@
-import { Context, Effect, Layer } from "effect"
-import { InstanceState } from "@/effect"
-
-type State = Record<string, string | undefined>
-
-export interface Interface {
-  readonly get: (key: string) => Effect.Effect<string | undefined>
-  readonly all: () => Effect.Effect<State>
-  readonly set: (key: string, value: string) => Effect.Effect<void>
-  readonly remove: (key: string) => Effect.Effect<void>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Env") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const state = yield* InstanceState.make<State>(Effect.fn("Env.state")(() => Effect.succeed({ ...process.env })))
-
-    const get = Effect.fn("Env.get")((key: string) => InstanceState.use(state, (env) => env[key]))
-    const all = Effect.fn("Env.all")(() => InstanceState.get(state))
-    const set = Effect.fn("Env.set")(function* (key: string, value: string) {
-      const env = yield* InstanceState.get(state)
-      env[key] = value
-    })
-    const remove = Effect.fn("Env.remove")(function* (key: string) {
-      const env = yield* InstanceState.get(state)
-      delete env[key]
-    })
-
-    return Service.of({ get, all, set, remove })
-  }),
-)
-
-export const defaultLayer = layer
-
-export * as Env from "."

package/src/file/ignore.ts

@@ -1,81 +0,0 @@
-import { Glob } from "@sleepy-ai/shared/util/glob"
-
-const FOLDERS = new Set([
-  "node_modules",
-  "bower_components",
-  ".pnpm-store",
-  "vendor",
-  ".npm",
-  "dist",
-  "build",
-  "out",
-  ".next",
-  "target",
-  "bin",
-  "obj",
-  ".git",
-  ".svn",
-  ".hg",
-  ".vscode",
-  ".idea",
-  ".turbo",
-  ".output",
-  "desktop",
-  ".sst",
-  ".cache",
-  ".webkit-cache",
-  "__pycache__",
-  ".pytest_cache",
-  "mypy_cache",
-  ".history",
-  ".gradle",
-])
-
-const FILES = [
-  "**/*.swp",
-  "**/*.swo",
-
-  "**/*.pyc",
-
-  // OS
-  "**/.DS_Store",
-  "**/Thumbs.db",
-
-  // Logs & temp
-  "**/logs/**",
-  "**/tmp/**",
-  "**/temp/**",
-  "**/*.log",
-
-  // Coverage/test outputs
-  "**/coverage/**",
-  "**/.nyc_output/**",
-]
-
-export const PATTERNS = [...FILES, ...FOLDERS]
-
-export function match(
-  filepath: string,
-  opts?: {
-    extra?: string[]
-    whitelist?: string[]
-  },
-) {
-  for (const pattern of opts?.whitelist || []) {
-    if (Glob.match(pattern, filepath)) return false
-  }
-
-  const parts = filepath.split(/[/\\]/)
-  for (let i = 0; i < parts.length; i++) {
-    if (FOLDERS.has(parts[i])) return true
-  }
-
-  const extra = opts?.extra || []
-  for (const pattern of [...FILES, ...extra]) {
-    if (Glob.match(pattern, filepath)) return true
-  }
-
-  return false
-}
-
-export * as FileIgnore from "./ignore"