anymous 1.3.0 → 1.3.2

package/src/effect/runner.ts

@@ -1,218 +0,0 @@
-import type { Latch, Scope } from "effect"
-import { Cause, Deferred, Effect, Exit, Fiber, Schema, 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>, ready?: Latch.Latch) => Effect.Effect<A, E | Busy>
-  readonly cancel: Effect.Effect<void>
-}
-
-export class Cancelled extends Schema.TaggedErrorClass<Cancelled>()("RunnerCancelled", {}) {}
-export class Busy extends Schema.TaggedErrorClass<Busy>()("RunnerBusy", {}) {}
-
-interface RunHandle<A, E> {
-  id: number
-  done: Deferred.Deferred<A, E | Cancelled>
-  fiber: Fiber.Fiber<A, E>
-}
-
-interface ShellHandle<A, E> {
-  id: number
-  cancelled: Deferred.Deferred<void>
-  ready?: Latch.Latch
-  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>
-  },
-): Runner<A, E> => {
-  const ref = SynchronizedRef.makeUnsafe<State<A, E>>({ _tag: "Idle" })
-  const idle = opts?.onIdle ?? Effect.void
-  const onBusy = 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 awaitDone = (done: Deferred.Deferred<A, E | Cancelled>) =>
-    Deferred.await(done).pipe(Effect.catchTag("RunnerCancelled", (e) => onInterrupt ?? Effect.die(e)))
-
-  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>) =>
-    Effect.gen(function* () {
-      if (shell.ready) yield* shell.ready.await.pipe(Effect.exit, Effect.asVoid)
-      yield* Deferred.succeed(shell.cancelled, undefined).pipe(Effect.asVoid)
-      yield* 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":
-            return [awaitDone(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 [awaitDone(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 [awaitDone(done), { _tag: "Running", run }] as const
-          }
-        }
-      }),
-    ).pipe(Effect.flatten)
-
-  const startShell = (work: Effect.Effect<A, E>, ready?: Latch.Latch): Effect.Effect<A, E | Busy> =>
-    SynchronizedRef.modifyEffect(
-      ref,
-      Effect.fnUntraced(function* (st) {
-        if (st._tag !== "Idle") {
-          const reject: Effect.Effect<A, E | Busy> = Effect.fail(new Busy())
-          return [reject, st] as const
-        }
-        yield* onBusy
-        const id = next()
-        const cancelled = yield* Deferred.make<void>()
-        const fiber = yield* work.pipe(Effect.ensuring(finishShell(id)), Effect.forkChild)
-        const shell = { id, cancelled, ready, 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) ||
-              ((yield* Deferred.isDone(cancelled)) && Cause.hasInterrupts(exit.cause) && !Cause.hasDies(exit.cause))
-            ) {
-              if (onInterrupt) return yield* onInterrupt
-              return yield* Effect.die(new Cancelled())
-            }
-            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.fail(st.run.done, new Cancelled()).pipe(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* stopShell(st.shell)
-            yield* Deferred.fail(st.run.done, new Cancelled()).pipe(Effect.asVoid)
-            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,
-  }
-}
-
-export * as Runner from "./runner"

package/src/effect/runtime-flags.ts

@@ -1,80 +0,0 @@
-import type { Context } from "effect"
-import { Config, ConfigProvider, Effect, Layer, Option } from "effect"
-import { ConfigService } from "@/effect/config-service"
-
-const bool = (name: string) => Config.boolean(name).pipe(Config.withDefault(false))
-const positiveInteger = (name: string) =>
-  Config.number(name).pipe(
-    Config.map((value) => (Number.isInteger(value) && value > 0 ? value : undefined)),
-    Config.orElse(() => Config.succeed(undefined)),
-  )
-const experimental = bool("ANYMOUS_EXPERIMENTAL")
-const enabledByExperimental = (name: string) =>
-  Config.all({ experimental, enabled: Config.boolean(name).pipe(Config.option) }).pipe(
-    Config.map((flags) => Option.getOrElse(flags.enabled, () => flags.experimental)),
-  )
-
-export class Service extends ConfigService.Service<Service>()("@anymous/RuntimeFlags", {
-  autoShare: bool("ANYMOUS_AUTO_SHARE"),
-  pure: bool("ANYMOUS_PURE"),
-  disableDefaultPlugins: bool("ANYMOUS_DISABLE_DEFAULT_PLUGINS"),
-  fastBoot: bool("ANYMOUS_FAST_BOOT"),
-  disableEmbeddedWebUi: bool("ANYMOUS_DISABLE_EMBEDDED_WEB_UI"),
-  disableExternalSkills: bool("ANYMOUS_DISABLE_EXTERNAL_SKILLS"),
-  disableLspDownload: bool("ANYMOUS_DISABLE_LSP_DOWNLOAD"),
-  disableClaudeCodePrompt: Config.all({
-    broad: bool("ANYMOUS_DISABLE_CLAUDE_CODE"),
-    direct: bool("ANYMOUS_DISABLE_CLAUDE_CODE_PROMPT"),
-  }).pipe(Config.map((flags) => flags.broad || flags.direct)),
-  disableClaudeCodeSkills: Config.all({
-    broad: bool("ANYMOUS_DISABLE_CLAUDE_CODE"),
-    direct: bool("ANYMOUS_DISABLE_CLAUDE_CODE_SKILLS"),
-  }).pipe(Config.map((flags) => flags.broad || flags.direct)),
-  enableExa: Config.all({
-    experimental,
-    enabled: bool("ANYMOUS_ENABLE_EXA"),
-    legacy: bool("ANYMOUS_EXPERIMENTAL_EXA"),
-  }).pipe(Config.map((flags) => flags.experimental || flags.enabled || flags.legacy)),
-  enableParallel: Config.all({
-    enabled: bool("ANYMOUS_ENABLE_PARALLEL"),
-    legacy: bool("ANYMOUS_EXPERIMENTAL_PARALLEL"),
-  }).pipe(Config.map((flags) => flags.enabled || flags.legacy)),
-  enableExperimentalModels: bool("ANYMOUS_ENABLE_EXPERIMENTAL_MODELS"),
-  enableQuestionTool: bool("ANYMOUS_ENABLE_QUESTION_TOOL"),
-  experimentalReferences: enabledByExperimental("ANYMOUS_EXPERIMENTAL_REFERENCES"),
-  experimentalBackgroundSubagents: enabledByExperimental("ANYMOUS_EXPERIMENTAL_BACKGROUND_SUBAGENTS"),
-  experimentalLspTy: bool("ANYMOUS_EXPERIMENTAL_LSP_TY"),
-  experimentalLspTool: enabledByExperimental("ANYMOUS_EXPERIMENTAL_LSP_TOOL"),
-  experimentalOxfmt: enabledByExperimental("ANYMOUS_EXPERIMENTAL_OXFMT"),
-  experimentalPlanMode: enabledByExperimental("ANYMOUS_EXPERIMENTAL_PLAN_MODE"),
-  experimentalCodeMode: enabledByExperimental("ANYMOUS_EXPERIMENTAL_CODE_MODE"),
-  experimentalEventSystem: enabledByExperimental("ANYMOUS_EXPERIMENTAL_EVENT_SYSTEM"),
-  experimentalWorkspaces: enabledByExperimental("ANYMOUS_EXPERIMENTAL_WORKSPACES"),
-  experimentalIconDiscovery: enabledByExperimental("ANYMOUS_EXPERIMENTAL_ICON_DISCOVERY"),
-  outputTokenMax: positiveInteger("ANYMOUS_EXPERIMENTAL_OUTPUT_TOKEN_MAX"),
-  bashDefaultTimeoutMs: positiveInteger("ANYMOUS_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS"),
-  experimentalNativeLlm: bool("ANYMOUS_EXPERIMENTAL_NATIVE_LLM"),
-  experimentalWebSockets: bool("ANYMOUS_EXPERIMENTAL_WEBSOCKETS"),
-  client: Config.string("ANYMOUS_CLIENT").pipe(Config.withDefault("cli")),
-}) {}
-
-export type Info = Context.Service.Shape<typeof Service>
-
-const emptyConfigLayer = Service.layer.pipe(
-  Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({}))),
-  Layer.orDie,
-)
-
-export const layer = (overrides: Partial<Info> = {}) =>
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const flags = yield* Service
-      return Service.of({ ...flags, ...overrides })
-    }),
-  ).pipe(Layer.provide(emptyConfigLayer))
-
-export const node = LayerNode.make({ service: Service, layer: Service.layer.pipe(Layer.orDie), deps: [] })
-
-export * as RuntimeFlags from "./runtime-flags"
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"

package/src/env/index.ts

@@ -1,41 +0,0 @@
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import { Context, Effect, Layer } from "effect"
-import { serviceUse } from "@anymous-ai/core/effect/service-use"
-import { InstanceState } from "@/effect/instance-state"
-
-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>()("@anymous/Env") {}
-
-export const use = serviceUse(Service)
-
-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 node = LayerNode.make({ service: Service, layer: layer, deps: [] })
-
-export * as Env from "."

package/src/event-manifest.ts

@@ -1,3 +0,0 @@
-export * as EventManifest from "./event-manifest"
-
-export { Definitions, Durable, Latest } from "@anymous-ai/schema/event-manifest"

package/src/event-v2-bridge.ts

@@ -1,71 +0,0 @@
-// anymous publish boundary for core events. Attach routed instance location
-// so direct EventV2 consumers can isolate directory/workspace streams.
-import { LayerNode } from "@anymous-ai/core/effect/layer-node"
-import { InstanceRef, WorkspaceRef } from "@/effect/instance-ref"
-import { GlobalBus } from "@/bus/global"
-import { EventV2 } from "@anymous-ai/core/event"
-import { Location } from "@anymous-ai/core/location"
-import { Project } from "@anymous-ai/core/project"
-import { AbsolutePath } from "@anymous-ai/core/schema"
-import { Context, Effect, Layer } from "effect"
-
-export class Service extends Context.Service<Service, EventV2.Interface>()("@anymous/EventV2Bridge") {}
-
-const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const events = yield* EventV2.Service
-
-    const publish: EventV2.Interface["publish"] = (definition, data, options) =>
-      Effect.gen(function* () {
-        if (options?.location) return yield* events.publish(definition, data, options)
-        const ctx = yield* InstanceRef
-        if (!ctx) return yield* events.publish(definition, data, options)
-        const workspaceID = yield* WorkspaceRef
-        return yield* events.publish(definition, data, {
-          ...options,
-          location: new Location.Info({
-            directory: AbsolutePath.make(ctx.directory),
-            ...(workspaceID ? { workspaceID } : {}),
-            project: { id: Project.ID.make(ctx.project.id), directory: AbsolutePath.make(ctx.worktree) },
-          }),
-        })
-      })
-
-    const unsubscribe = yield* events.listen((event) =>
-      Effect.gen(function* () {
-        const ctx = yield* InstanceRef
-        const workspaceID = (yield* WorkspaceRef) ?? event.location?.workspaceID
-        GlobalBus.emit("event", {
-          directory: event.location?.directory ?? ctx?.directory,
-          project: ctx?.project.id,
-          workspace: workspaceID,
-          payload: { id: event.id, type: event.type, properties: event.data },
-        })
-        if (event.durable === undefined) return
-        GlobalBus.emit("event", {
-          directory: event.location?.directory ?? ctx?.directory,
-          project: ctx?.project.id,
-          workspace: workspaceID,
-          payload: {
-            type: "sync",
-            syncEvent: {
-              id: event.id,
-              type: EventV2.versionedType(event.type, event.durable.version),
-              seq: event.durable.seq,
-              aggregateID: event.durable.aggregateID,
-              data: event.data,
-            },
-          },
-        })
-      }),
-    )
-    yield* Effect.addFinalizer(() => unsubscribe)
-
-    return Service.of({ ...events, publish })
-  }),
-)
-
-export const node = LayerNode.make({ service: Service, layer: layer, deps: [EventV2.node] })
-
-export * as EventV2Bridge from "./event-v2-bridge"