anymous 1.3.0 → 1.3.2

package/src/effect/app-node-builder-v1.ts

@@ -1,12 +0,0 @@
-import { AppNodeBuilder } from "@anymous-ai/core/effect/app-node-builder"
-import type { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import { InstanceBootstrap } from "@/project/bootstrap"
-import { InstanceStore } from "@/project/instance-store"
-
-const bootstrapReplacement = [InstanceStore.bootstrapNode, InstanceBootstrap.node] as const
-
-export function build<A, E>(root: LayerNode.Node<A, E, any>, replacements: LayerNode.Replacements = []) {
-  return AppNodeBuilder.build(root, replacements.concat([bootstrapReplacement]))
-}
-
-export * as AppNodeBuilderV1 from "./app-node-builder-v1"

package/src/effect/app-runtime.ts

@@ -1,137 +0,0 @@
-import { Layer, ManagedRuntime } from "effect"
-import { attach } from "./run-service"
-import * as Observability from "@anymous-ai/core/observability"
-
-import { FSUtil } from "@anymous-ai/core/fs-util"
-import { Database } from "@anymous-ai/core/database/database"
-import { Auth } from "@/auth"
-import { Account } from "@/account/account"
-import { Config } from "@/config/config"
-import { Git } from "@/git"
-import { Ripgrep } from "@anymous-ai/core/ripgrep"
-import { Storage } from "@/storage/storage"
-import { Snapshot } from "@/snapshot"
-import { Plugin } from "@/plugin"
-import { ModelsDev } from "@anymous-ai/core/models-dev"
-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 { 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 { 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 { Installation } from "@/installation"
-import { ShareNext } from "@/share/share-next"
-import { SessionShare } from "@/share/session"
-import { Memory } from "@/memory/memory"
-import { Npm } from "@anymous-ai/core/npm"
-import { memoMap } from "@anymous-ai/core/effect/memo-map"
-import { BackgroundJob } from "@/background/job"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import { AppNodeBuilderV1 } from "./app-node-builder-v1"
-import { SessionProjector } from "@anymous-ai/core/session/projector"
-
-export const AppLayer = AppNodeBuilderV1.build(
-  LayerNode.group([
-    Npm.node,
-    FSUtil.node,
-    Database.node,
-    Auth.node,
-    Account.node,
-    Config.node,
-    Git.node,
-    Storage.node,
-    Snapshot.node,
-    Plugin.node,
-    ModelsDev.node,
-    Provider.node,
-    ProviderAuth.node,
-    Agent.node,
-    Skill.node,
-    Discovery.node,
-    Question.node,
-    Permission.node,
-    Todo.node,
-    Session.node,
-    SessionProjector.node,
-    SessionStatus.node,
-    BackgroundJob.node,
-    RuntimeFlags.node,
-    EventV2Bridge.node,
-    SessionRunState.node,
-    SessionProcessor.node,
-    SessionCompaction.node,
-    SessionRevert.node,
-    SessionSummary.node,
-    SessionPrompt.node,
-    Instruction.node,
-    LLM.node,
-    LSP.node,
-    MCP.node,
-    McpAuth.node,
-    Command.node,
-    Truncate.node,
-    ToolRegistry.node,
-    Format.node,
-    InstanceStore.node,
-    Project.node,
-    Vcs.node,
-    Workspace.node,
-    Worktree.node,
-    Installation.node,
-    ShareNext.node,
-    SessionShare.node,
-    Memory.node,
-  ]),
-).pipe(Layer.provideMerge(AppNodeBuilderV1.build(Ripgrep.node)), 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(),
-}

package/src/effect/bootstrap-runtime.ts

@@ -1,19 +0,0 @@
-import { Layer, ManagedRuntime } from "effect"
-import { AppNodeBuilder } from "@anymous-ai/core/effect/app-node-builder"
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-
-import { Plugin } from "@/plugin"
-import { LSP } from "@/lsp/lsp"
-import { Format } from "@/format"
-import { ShareNext } from "@/share/share-next"
-import { Vcs } from "@/project/vcs"
-import { Snapshot } from "@/snapshot"
-import { Config } from "@/config/config"
-import * as Observability from "@anymous-ai/core/observability"
-import { memoMap } from "@anymous-ai/core/effect/memo-map"
-
-export const BootstrapLayer = AppNodeBuilder.build(
-  LayerNode.group([Config.node, Plugin.node, ShareNext.node, Format.node, LSP.node, Vcs.node, Snapshot.node]),
-).pipe(Layer.provide(Observability.layer))
-
-export const BootstrapRuntime = ManagedRuntime.make(BootstrapLayer, { memoMap })

package/src/effect/bridge.ts

@@ -1,84 +0,0 @@
-import { Context, Effect, Exit, Fiber } from "effect"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import type { WorkspaceV2 } from "@anymous-ai/core/workspace"
-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>
-  readonly bind: <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) => (...args: Args) => Result
-}
-
-function restoreWorkspace<R>(workspace: WorkspaceV2.ID | undefined, fn: () => R): R {
-  if (workspace !== undefined) return WorkspaceContext.restore(workspace, fn)
-  return fn()
-}
-
-function captureSync() {
-  const fiber = Fiber.getCurrent()
-  const instance = fiber ? Context.getReferenceUnsafe(fiber.context, InstanceRef) : undefined
-  const workspace =
-    (fiber ? Context.getReferenceUnsafe(fiber.context, WorkspaceRef) : undefined) ?? WorkspaceContext.workspaceID
-  return { instance, workspace }
-}
-
-export const bind = <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) => {
-  const captured = captureSync()
-  return (...args: Args) =>
-    restoreWorkspace(captured.workspace, () =>
-      Effect.runSync(
-        attachWith(
-          Effect.sync(() => fn(...args)),
-          captured,
-        ),
-      ),
-    )
-}
-
-/**
- * Bridge from Effect into a Promise-returning JS callback while preserving
- * `WorkspaceContext` AsyncLocalStorage for callback code that still reads it.
- * `InstanceRef` is captured for effects run through the returned bridge APIs;
- * plain JS callbacks that need it should receive the ref explicitly.
- *
- * Mirrors `Effect.promise` but restores workspace ALS first.
- */
-export const fromPromise = <T>(fn: () => Promise<T> | T): Effect.Effect<T> =>
-  Effect.gen(function* () {
-    const workspace = yield* WorkspaceRef
-    return yield* Effect.promise(() => Promise.resolve(restoreWorkspace(workspace, () => fn())))
-  })
-
-export function make(): Effect.Effect<Shape> {
-  return Effect.gen(function* () {
-    const ctx = yield* Effect.context()
-    const captured = captureSync()
-    const instance = (yield* InstanceRef) ?? captured.instance
-    const workspace = (yield* WorkspaceRef) ?? captured.workspace
-    const wrap = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-      attachWith(effect.pipe(Effect.provide(ctx)) as Effect.Effect<A, E, never>, { instance, workspace })
-
-    return {
-      promise: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        restoreWorkspace(workspace, () => Effect.runPromise(wrap(effect))),
-      fork: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        restoreWorkspace(workspace, () => Effect.runFork(wrap(effect))),
-      run: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-        Effect.callback<A, E>((resume) => {
-          restoreWorkspace(workspace, () =>
-            Effect.runPromiseExit(wrap(effect)).then((exit) =>
-              resume(Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause)),
-            ),
-          )
-        }),
-      bind:
-        <Args extends readonly unknown[], Result>(fn: (...args: Args) => Result) =>
-        (...args: Args) =>
-          restoreWorkspace(workspace, () => Effect.runSync(wrap(Effect.sync(() => fn(...args))))),
-    } 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 configLayer: (input: Service) => Layer.Layer<Self>
-  /** Parse config once from the active Effect ConfigProvider and provide the service. */
-  readonly layer: 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>()(
- *   "@anymous/ServerAuthConfig",
- *   {
- *     password: Config.string("ANYMOUS_SERVER_PASSWORD").pipe(Config.option),
- *     username: Config.string("ANYMOUS_SERVER_USERNAME").pipe(Config.withDefault("anymous")),
- *   },
- * ) {}
- *
- * const live = ServerAuthConfig.layer
- * const test = ServerAuthConfig.configLayer({ 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 configLayer(input: Shape<Fields>) {
-        return Layer.succeed(this, this.of(input))
-      }
-
-      static get layer() {
-        const tag = this
-        return Layer.effect(
-          tag,
-          Effect.gen(function* () {
-            const config = yield* Config.all(fields)
-            // 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.
-            return tag.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-context"
-import type { WorkspaceV2 } from "@anymous-ai/core/workspace"
-
-export const InstanceRef = Context.Reference<InstanceContext | undefined>("~anymous/InstanceRef", {
-  defaultValue: () => undefined,
-})
-
-export const WorkspaceRef = Context.Reference<WorkspaceV2.ID | undefined>("~anymous/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,70 +0,0 @@
-import type { Scope } from "effect"
-import { Effect, ScopedCache } from "effect"
-import type { InstanceContext } from "@/project/instance-context"
-import { InstanceRef, WorkspaceRef } from "./instance-ref"
-import { registerDisposer } from "./instance-registry"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-
-const TypeId = "~anymous/InstanceState"
-
-export interface InstanceState<A, E = never, R = never> {
-  readonly [TypeId]: typeof TypeId
-  readonly cache: ScopedCache.ScopedCache<string, A, E, R>
-}
-
-export const context = Effect.gen(function* () {
-  const ctx = yield* InstanceRef
-  if (!ctx) return yield* Effect.die(new Error("InstanceRef not provided"))
-  return ctx
-})
-
-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)))
-    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/promise.ts

@@ -1,17 +0,0 @@
-import { Cause, Effect } from "effect"
-
-export function refineRejection<A, E>(
-  evaluate: (signal: AbortSignal) => PromiseLike<A>,
-  refine: (cause: unknown) => E | undefined,
-) {
-  return Effect.tryPromise(evaluate).pipe(
-    Effect.catch((error) => {
-      const cause = Cause.isUnknownError(error) ? error.cause : error
-      const refined = refine(cause)
-      if (refined !== undefined) return Effect.fail(refined)
-      return Effect.die(cause)
-    }),
-  )
-}
-
-export * as EffectPromise from "./promise"

package/src/effect/run-service.ts

@@ -1,47 +0,0 @@
-import { Effect, Fiber, Layer, ManagedRuntime } from "effect"
-import * as Context from "effect/Context"
-import { InstanceRef, WorkspaceRef } from "./instance-ref"
-import * as Observability from "@anymous-ai/core/observability"
-import { WorkspaceContext } from "@/control-plane/workspace-context"
-import type { InstanceContext } from "@/project/instance-context"
-import { memoMap } from "@anymous-ai/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 fiber = Fiber.getCurrent()
-  return attachWith(effect, {
-    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))),
-  }
-}