Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Predicate from "effect/Predicate";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";
import {
type AtomCommandOptions,
type AtomCommandReporter,
type AtomCommand,
} from "./atomRuntimeTypes.ts";
export type SettledAsyncResult<A, E> = AsyncResult.Success<A, E> | AsyncResult.Failure<A, E>;
export type AtomCommandResult<A, E> = SettledAsyncResult<A, E>;
export type AtomCommandSuccess<R> = R extends AtomCommandResult<infer A, infer _E> ? A : never;
export type AtomCommandFailure<R> = R extends AtomCommandResult<infer _A, infer E> ? E : never;
export async function settleAtomCommandResult<A, E>(
execute: () => Promise<AtomCommandResult<A, E>>,
): Promise<AtomCommandResult<A, E>> {
try {
return await execute();
} catch (defect) {
return AsyncResult.failure(Cause.die(defect));
}
}
export async function runAtomCommand<W, A, E>(
registry: AtomRegistry.AtomRegistry,
command: AtomCommand<W, A, E>,
input: W,
options: AtomCommandOptions = {},
reporter: AtomCommandReporter = console,
): Promise<AtomCommandResult<A, E>> {
const result = await settleAtomCommandResult(() => command.run(registry, input));
reportAtomCommandResult(result, { ...options, label: options.label ?? command.label }, reporter);
return result;
}
export function mapAtomCommandResult<A, E, B>(
result: AtomCommandResult<A, E>,
map: (value: A) => B,
): AtomCommandResult<B, E> {
return Predicate.isTagged(result, "Success")
? AsyncResult.success(map(result.value))
: AsyncResult.failure(result.cause);
}
export function isAtomCommandInterrupted(result: AtomCommandResult<unknown, unknown>): boolean {
return Predicate.isTagged(result, "Failure") && Cause.hasInterruptsOnly(result.cause);
}
export function squashAtomCommandFailure(result: { readonly cause: Cause.Cause<unknown> }) {
return Cause.squash(result.cause);
}
export async function settleAsyncResult<A, E>(
execute: () => Promise<Exit.Exit<A, E>>,
): Promise<SettledAsyncResult<A, E>> {
try {
return AsyncResult.fromExit(await execute());
} catch (defect) {
return AsyncResult.failure(Cause.die(defect));
}
}
export async function executeAtomCommand<A, E>(
execute: () => Promise<Exit.Exit<A, E>>,
options: AtomCommandOptions = {},
reporter: AtomCommandReporter = console,
): Promise<AtomCommandResult<A, E>> {
const result = await settleAsyncResult(execute);
reportAtomCommandResult(result, options, reporter);
return result;
}
export async function executeAtomQuery<A, E>(
registry: AtomRegistry.AtomRegistry,
atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>,
options: AtomCommandOptions = {},
reporter: AtomCommandReporter = console,
): Promise<AtomCommandResult<A, E>> {
const query = Effect.scoped(
Effect.gen(function* () {
yield* AtomRegistry.mount(registry, atom);
return yield* AtomRegistry.getResult(registry, atom, {
suspendOnWaiting: true,
});
}),
);
return executeAtomCommand(() => Effect.runPromiseExit(query), options, reporter);
}
export function reportAtomCommandResult(
result: AtomCommandResult<unknown, unknown>,
options: AtomCommandOptions = {},
reporter: AtomCommandReporter = console,
): void {
if (AsyncResult.isSuccess(result) || Cause.hasInterruptsOnly(result.cause)) {
return;
}
const label = options.label ?? "atom command";
if (Cause.hasDies(result.cause)) {
if (options.reportDefect ?? true) {
reporter.error(`[atom-command] ${label} defected`, result.cause);
}
} else if (options.reportFailure ?? true) {
reporter.warn(`[atom-command] ${label} failed`, result.cause);
}
}
export async function settlePromise<A>(
execute: () => Promise<A>,
): Promise<AtomCommandResult<A, never>> {
try {
return AsyncResult.success(await execute());
} catch (defect) {
return AsyncResult.failure(Cause.die(defect));
}
}