saeeol 1.4.2 → 1.4.4

package/src/effect/app-runtime.ts

@@ -1,148 +0,0 @@
-import { Effect, Layer, ManagedRuntime } from "effect"
-import { attach } from "./run-service"
-import * as Observability from "@saeeol/core/effect/observability"
-
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Bus } from "@/bus"
-import { Auth } from "@/auth"
-import { Account } from "@/account/account"
-import { Config } from "@/config/config"
-import { Git } from "@/git"
-import { Ripgrep } from "@/file/ripgrep"
-import { File } from "@/file"
-import { FileWatcher } from "@/file/watcher"
-import { Storage } from "@/storage/storage"
-import { Snapshot } from "@/snapshot"
-import { Plugin } from "@/plugin"
-import { ModelsDev } from "@/provider/models"
-import { Provider } from "@/provider/provider"
-import { ProviderAuth } from "@/provider/auth"
-import { Agent } from "@/agent/agent"
-import { Skill } from "@/skill"
-import { Discovery } from "@/skill/discovery"
-import { Question } from "@/question"
-import { Permission } from "@/permission"
-import { Todo } from "@/session/todo"
-import { Session } from "@/session/session"
-import { SessionStatus } from "@/session/status"
-import { SessionRunState } from "@/session/run-state"
-import { SessionProcessor } from "@/session/processor"
-import { SessionCompaction } from "@/session/compaction"
-import { SessionRevert } from "@/session/revert"
-import { SessionSummary } from "@/session/summary"
-import { SessionPrompt } from "@/session/prompt"
-import { defaultLayer as subtaskLayer } from "@/session/subtask"
-import { defaultLayer as shellLayer } from "@/session/shell-exec"
-import { Instruction } from "@/session/instruction"
-import { LLM } from "@/session/llm"
-import { LSP } from "@/lsp/lsp"
-import { MCP } from "@/mcp"
-import { McpAuth } from "@/mcp/auth"
-import { Command } from "@/command"
-import { Truncate } from "@/tool/truncate"
-import { ToolRegistry } from "@/tool/registry"
-import { Format } from "@/format"
-import { InstanceBootstrap } from "@/project/bootstrap"
-import { InstanceStore } from "@/project/instance-store"
-import { Project } from "@/project/project"
-import { Vcs } from "@/project/vcs"
-import { Workspace } from "@/control-plane/workspace"
-import { Worktree } from "@/worktree"
-import { Pty } from "@/pty"
-import { Installation } from "@/installation"
-import { ShareNext } from "@/share/share-next"
-import { SessionShare } from "@/share/session"
-import { SyncEvent } from "@/sync"
-import { Npm } from "@saeeol/core/npm"
-import { memoMap } from "@saeeol/core/effect/memo-map"
-
-export const AppLayer = Layer.mergeAll(
-  Npm.defaultLayer,
-  AppFileSystem.defaultLayer,
-  Bus.defaultLayer,
-  Auth.defaultLayer,
-  Account.defaultLayer,
-  Config.defaultLayer,
-  Git.defaultLayer,
-  Ripgrep.defaultLayer,
-  File.defaultLayer,
-  FileWatcher.defaultLayer,
-  Storage.defaultLayer,
-  Snapshot.defaultLayer,
-  Plugin.defaultLayer,
-  ModelsDev.defaultLayer,
-  Provider.defaultLayer,
-  ProviderAuth.defaultLayer,
-  Agent.defaultLayer,
-  Skill.defaultLayer,
-  Discovery.defaultLayer,
-  Question.defaultLayer,
-  Permission.defaultLayer,
-  Todo.defaultLayer,
-  Session.defaultLayer,
-  SessionStatus.defaultLayer,
-  SessionRunState.defaultLayer,
-  SessionProcessor.defaultLayer,
-  SessionCompaction.defaultLayer,
-  SessionRevert.defaultLayer,
-  SessionSummary.defaultLayer,
-  SessionPrompt.defaultLayer.pipe(Layer.provide(subtaskLayer), Layer.provide(shellLayer)),
-  Instruction.defaultLayer,
-  LLM.defaultLayer,
-  LSP.defaultLayer,
-  MCP.defaultLayer,
-  McpAuth.defaultLayer,
-  Command.defaultLayer,
-  Truncate.defaultLayer,
-  ToolRegistry.defaultLayer,
-  Format.defaultLayer,
-  InstanceBootstrap.defaultLayer,
-  InstanceStore.defaultLayer,
-  Project.defaultLayer,
-  Vcs.defaultLayer,
-  Workspace.defaultLayer,
-  Worktree.defaultLayer,
-  Pty.defaultLayer,
-  Installation.defaultLayer,
-  ShareNext.defaultLayer,
-  SessionShare.defaultLayer,
-  SyncEvent.defaultLayer,
-).pipe(Layer.provideMerge(Observability.layer))
-
-const rt = ManagedRuntime.make(AppLayer, { memoMap })
-type Runtime = Pick<typeof rt, "runSync" | "runPromise" | "runPromiseExit" | "runFork" | "runCallback" | "dispose">
-
-/** Services provided by AppRuntime — i.e. what an Effect run via AppRuntime.runPromise can yield. */
-export type AppServices = ManagedRuntime.ManagedRuntime.Services<typeof rt>
-const wrap = (effect: Parameters<typeof rt.runSync>[0]) => attach(effect as never) as never
-
-export const AppRuntime: Runtime = {
-  runSync(effect) {
-    return rt.runSync(wrap(effect))
-  },
-  runPromise(effect, options) {
-    return rt.runPromise(wrap(effect), options)
-  },
-  runPromiseExit(effect, options) {
-    return rt.runPromiseExit(wrap(effect), options)
-  },
-  runFork(effect) {
-    return rt.runFork(wrap(effect))
-  },
-  runCallback(effect) {
-    return rt.runCallback(wrap(effect))
-  },
-  dispose: () => rt.dispose(),
-}
-
-let bootstrapRun: Promise<Effect.Effect<void>>
-export function getBootstrapRunEffect(): Promise<Effect.Effect<void>> {
-  if (!bootstrapRun) {
-    bootstrapRun = AppRuntime.runPromise(
-      Effect.gen(function* () {
-        return (yield* InstanceBootstrap.Service).run
-      }),
-    )
-  }
-  return bootstrapRun
-}

package/src/effect/bootstrap-runtime.ts

@@ -1,29 +0,0 @@
-import { Layer, ManagedRuntime } from "effect"
-
-import { Plugin } from "@/plugin"
-import { LSP } from "@/lsp/lsp"
-import { FileWatcher } from "@/file/watcher"
-import { Format } from "@/format"
-import { ShareNext } from "@/share/share-next"
-import { File } from "@/file"
-import { Vcs } from "@/project/vcs"
-import { Snapshot } from "@/snapshot"
-import { Bus } from "@/bus"
-import { Config } from "@/config/config"
-import * as Observability from "@saeeol/core/effect/observability"
-import { memoMap } from "@saeeol/core/effect/memo-map"
-
-export const BootstrapLayer = Layer.mergeAll(
-  Config.defaultLayer,
-  Plugin.defaultLayer,
-  ShareNext.defaultLayer,
-  Format.defaultLayer,
-  LSP.defaultLayer,
-  File.defaultLayer,
-  FileWatcher.defaultLayer,
-  Vcs.defaultLayer,
-  Snapshot.defaultLayer,
-  Bus.defaultLayer,
-).pipe(Layer.provide(Observability.layer))
-
-export const BootstrapRuntime = ManagedRuntime.make(BootstrapLayer, { memoMap })

package/src/effect/bridge.ts

@@ -1,78 +0,0 @@
-import { Effect, Exit, Fiber } from "effect"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import { Instance, type InstanceContext } from "@/project/instance"
-import type { WorkspaceID } from "@/control-plane/schema"
-import { LocalContext } from "@/util/local-context"
-import { InstanceRef, WorkspaceRef } from "./instance-ref"
-import { attachWith } from "./run-service"
-
-export interface Shape {
-  readonly promise: <A, E, R>(effect: Effect.Effect<A, E, R>) => Promise<A>
-  readonly fork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Fiber.Fiber<A, E>
-  readonly run: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E>
-}
-
-function restore<R>(instance: InstanceContext | undefined, workspace: WorkspaceID | undefined, fn: () => R): R {
-  if (instance && workspace !== undefined) {
-    return WorkspaceContext.restore(workspace, () => Instance.restore(instance, fn))
-  }
-  if (instance) return Instance.restore(instance, fn)
-  if (workspace !== undefined) return WorkspaceContext.restore(workspace, fn)
-  return fn()
-}
-
-/**
- * Bridge from Effect into a Promise-returning JS callback while installing
- * legacy `Instance.context` and `WorkspaceContext` AsyncLocalStorage for
- * the duration of the callback. Effect's `InstanceRef`/`WorkspaceRef` do
- * not propagate across async/await boundaries inside `Effect.promise(() =>
- * async fn)` callbacks that re-enter Effect via `AppRuntime.runPromise`,
- * but Node's AsyncLocalStorage does. Use this whenever an Effect crosses
- * into JS that may itself spawn new Effect runtimes (workspace adapters,
- * legacy plugins, etc.).
- *
- * Mirrors `Effect.promise` but restores legacy ALS first.
- */
-export const fromPromise = <T>(fn: () => Promise<T> | T): Effect.Effect<T> =>
-  Effect.gen(function* () {
-    const instance = yield* InstanceRef
-    const workspace = yield* WorkspaceRef
-    return yield* Effect.promise(() => Promise.resolve(restore(instance, workspace, () => fn())))
-  })
-
-export function make(): Effect.Effect<Shape> {
-  return Effect.gen(function* () {
-    const ctx = yield* Effect.context()
-    const value = yield* InstanceRef
-    const instance =
-      value ??
-      (() => {
-        try {
-          return Instance.current
-        } catch (err) {
-          if (!(err instanceof LocalContext.NotFound)) throw err
-        }
-      })()
-    const workspace = (yield* WorkspaceRef) ?? WorkspaceContext.workspaceID
-    const attach = <A, E, R>(effect: Effect.Effect<A, E, R>) => attachWith(effect, { instance, workspace })
-    const wrap = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-      attach(effect).pipe(Effect.provide(ctx)) as Effect.Effect<A, E, never>
-
-    return {
-      promise: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        restore(instance, workspace, () => Effect.runPromise(wrap(effect))),
-      fork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        restore(instance, workspace, () => Effect.runFork(wrap(effect))),
-      run: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        Effect.callback<A, E>((resume) => {
-          restore(instance, workspace, () =>
-            Effect.runPromiseExit(wrap(effect)).then((exit) =>
-              resume(Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause)),
-            ),
-          )
-        }),
-    } satisfies Shape
-  })
-}
-
-export * as EffectBridge from "./bridge"

package/src/effect/config-service.ts

@@ -1,67 +0,0 @@
-import { Config, Context, Effect, Layer } from "effect"
-
-type ConfigMap = Record<string, Config.Config<unknown>>
-
-/**
- * The service shape inferred from an object of Effect `Config` definitions.
- */
-export type Shape<Fields extends ConfigMap> = {
-  readonly [Key in keyof Fields]: Config.Success<Fields[Key]>
-}
-
-/**
- * A Context service class with generated layers for config-backed services.
- */
-export type ServiceClass<Self, Id extends string, Service> = Context.ServiceClass<Self, Id, Service> & {
-  /** Provide already-parsed config, useful in tests. */
-  readonly layer: (input: Service) => Layer.Layer<Self>
-  /** Parse config once from the active Effect ConfigProvider and provide the service. */
-  readonly defaultLayer: Layer.Layer<Self, Config.ConfigError>
-}
-
-/**
- * Create a Context service whose implementation is derived from Effect `Config`.
- *
- * This keeps Effect `Config` as the source of truth for env names, defaults, and
- * validation while generating a typed service plus convenient production/test
- * layers.
- *
- * ```ts
- * class ServerAuthConfig extends ConfigService.Service<ServerAuthConfig>()(
- *   "@saeeol/ServerAuthConfig",
- *   {
- *     password: Config.string("SAEEOL_SERVER_PASSWORD").pipe(Config.option),
- *     username: Config.string("SAEEOL_SERVER_USERNAME").pipe(Config.withDefault("saeeol")),
- *   },
- * ) {}
- *
- * const live = ServerAuthConfig.defaultLayer
- * const test = ServerAuthConfig.layer({ password: Option.some("secret"), username: "kit" })
- * ```
- */
-export const Service =
-  <Self>() =>
-  <const Id extends string, const Fields extends ConfigMap>(id: Id, fields: Fields) => {
-    class ConfigTag extends Context.Service<Self, Shape<Fields>>()(id) {
-      static layer(input: Shape<Fields>) {
-        return Layer.succeed(this, this.of(input))
-      }
-
-      static get defaultLayer() {
-        return Layer.effect(
-          this,
-          Config.all(fields)
-            .asEffect()
-            .pipe(
-              // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Config.all preserves the field shape, but its conditional return type also supports iterable inputs.
-              Effect.map((config) => this.of(config as Shape<Fields>)),
-            ),
-        )
-      }
-    }
-
-    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- The generated class carries typed static helpers.
-    return ConfigTag as ServiceClass<Self, Id, Shape<Fields>>
-  }
-
-export * as ConfigService from "./config-service"

package/src/effect/instance-ref.ts

@@ -1,11 +0,0 @@
-import { Context } from "effect"
-import type { InstanceContext } from "@/project/instance"
-import type { WorkspaceID } from "@/control-plane/schema"
-
-export const InstanceRef = Context.Reference<InstanceContext | undefined>("~saeeol/InstanceRef", {
-  defaultValue: () => undefined,
-})
-
-export const WorkspaceRef = Context.Reference<WorkspaceID | undefined>("~saeeol/WorkspaceRef", {
-  defaultValue: () => undefined,
-})

package/src/effect/instance-registry.ts

@@ -1,12 +0,0 @@
-const disposers = new Set<(directory: string) => Promise<void>>()
-
-export function registerDisposer(disposer: (directory: string) => Promise<void>) {
-  disposers.add(disposer)
-  return () => {
-    disposers.delete(disposer)
-  }
-}
-
-export async function disposeInstance(directory: string) {
-  await Promise.allSettled([...disposers].map((disposer) => disposer(directory)))
-}

package/src/effect/instance-state.ts

@@ -1,83 +0,0 @@
-import { Effect, Fiber, ScopedCache, Scope, Context } from "effect"
-import * as EffectLogger from "@saeeol/core/effect/logger"
-import { Instance, type InstanceContext } from "@/project/instance"
-import { LocalContext } from "@/util/local-context"
-import { InstanceRef, WorkspaceRef } from "./instance-ref"
-import { registerDisposer } from "./instance-registry"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-
-const TypeId = "~saeeol/InstanceState"
-
-export interface InstanceState<A, E = never, R = never> {
-  readonly [TypeId]: typeof TypeId
-  readonly cache: ScopedCache.ScopedCache<string, A, E, R>
-}
-
-export const bind = <F extends (...args: any[]) => any>(fn: F): F => {
-  try {
-    return Instance.bind(fn)
-  } catch (err) {
-    if (!(err instanceof LocalContext.NotFound)) throw err
-  }
-  const fiber = Fiber.getCurrent()
-  const ctx = fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined
-  if (!ctx) return fn
-  return ((...args: any[]) => Instance.restore(ctx, () => fn(...args))) as F
-}
-
-export const context = Effect.gen(function* () {
-  return (yield* InstanceRef) ?? Instance.current
-})
-
-export const workspaceID = Effect.gen(function* () {
-  return (yield* WorkspaceRef) ?? WorkspaceContext.workspaceID
-})
-
-export const directory = Effect.map(context, (ctx) => ctx.directory)
-
-export const make = <A, E = never, R = never>(
-  init: (ctx: InstanceContext) => Effect.Effect<A, E, R | Scope.Scope>,
-): Effect.Effect<InstanceState<A, E, Exclude<R, Scope.Scope>>, never, R | Scope.Scope> =>
-  Effect.gen(function* () {
-    const cache = yield* ScopedCache.make<string, A, E, R>({
-      capacity: Number.POSITIVE_INFINITY,
-      lookup: () =>
-        Effect.gen(function* () {
-          return yield* init(yield* context)
-        }),
-    })
-
-    const off = registerDisposer((directory) =>
-      Effect.runPromise(ScopedCache.invalidate(cache, directory).pipe(Effect.provide(EffectLogger.layer))),
-    )
-    yield* Effect.addFinalizer(() => Effect.sync(off))
-
-    return {
-      [TypeId]: TypeId,
-      cache,
-    }
-  })
-
-export const get = <A, E, R>(self: InstanceState<A, E, R>) =>
-  Effect.gen(function* () {
-    return yield* ScopedCache.get(self.cache, yield* directory)
-  })
-
-export const use = <A, E, R, B>(self: InstanceState<A, E, R>, select: (value: A) => B) => Effect.map(get(self), select)
-
-export const useEffect = <A, E, R, B, E2, R2>(
-  self: InstanceState<A, E, R>,
-  select: (value: A) => Effect.Effect<B, E2, R2>,
-) => Effect.flatMap(get(self), select)
-
-export const has = <A, E, R>(self: InstanceState<A, E, R>) =>
-  Effect.gen(function* () {
-    return yield* ScopedCache.has(self.cache, yield* directory)
-  })
-
-export const invalidate = <A, E, R>(self: InstanceState<A, E, R>) =>
-  Effect.gen(function* () {
-    return yield* ScopedCache.invalidate(self.cache, yield* directory)
-  })
-
-export * as InstanceState from "./instance-state"

package/src/effect/run-service.ts

@@ -1,57 +0,0 @@
-import { Effect, Fiber, Layer, ManagedRuntime } from "effect"
-import * as Context from "effect/Context"
-import { Instance } from "@/project/instance"
-import { LocalContext } from "@/util/local-context"
-import { InstanceRef, WorkspaceRef } from "./instance-ref"
-import * as Observability from "@saeeol/core/effect/observability"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import type { InstanceContext } from "@/project/instance"
-import { memoMap } from "@saeeol/core/effect/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> {
-  const workspace = WorkspaceContext.workspaceID
-  const instance = (() => {
-    try {
-      return Instance.current
-    } catch (err) {
-      if (!(err instanceof LocalContext.NotFound)) throw err
-    }
-  })()
-  if (instance && workspace !== undefined) return attachWith(effect, { instance, workspace })
-  const fiber = Fiber.getCurrent()
-  return attachWith(effect, {
-    instance: instance ?? (fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined),
-    workspace: workspace ?? (fiber ? Context.getReferenceUnsafe(fiber.context, WorkspaceRef) : undefined),
-  })
-}
-
-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))),
-  }
-}