alchemy 2.0.0-beta.37 → 2.0.0-beta.39

package/src/Agent/tool/result.ts

@@ -1,51 +0,0 @@
-import * as S from "effect/Schema";
-import type { IsNever } from "../..//Util/types.ts";
-import { Field } from "../../Schema.ts";
-import { defineAspect, type Aspect } from "../Aspect.ts";
-
-export const isResult = (artifact: any): artifact is Result =>
-  artifact?.type === "result";
-
-export type Result<
-  ID extends string = string,
-  References extends any[] = any[],
-  T extends Field = Field,
-> = Aspect<Result, "result", ID, References, T>;
-
-export const Result = defineAspect<
-  <const Name extends string, T extends Field = typeof S.String>(
-    name: Name,
-    props?: T,
-  ) => <References extends any[]>(
-    template: TemplateStringsArray,
-    ...references: References
-  ) => Result<Name, References, T>
->("result", Field);
-
-export declare namespace Result {
-  export type Of<
-    References extends readonly any[],
-    Outputs = never,
-    Primitives = never,
-  > = References extends []
-    ? Outputs | Primitives extends never
-      ? void
-      : Outputs | Primitives
-    : References extends readonly [infer Ref, ...infer Rest]
-      ? Ref extends {
-          type: "result";
-          props: infer Schema;
-          id: infer Name extends string;
-        }
-        ? Result.Of<
-            Rest,
-            (IsNever<Outputs> extends true ? {} : Outputs) & {
-              [name in Name]: S.Schema.Type<Schema>;
-            },
-            Primitives
-          >
-        : Ref extends S.Schema<infer T>
-          ? Result.Of<Rest, Outputs, Primitives | T>
-          : Result.Of<Rest, Outputs, Primitives>
-      : never;
-}

package/src/Agent/tool/tool.ts

@@ -1,74 +0,0 @@
-import type { Yieldable } from "effect/Effect";
-import * as Effect from "effect/Effect";
-import * as S from "effect/Schema";
-import { Function } from "../../Schema.ts";
-import { defineAspect, type Aspect } from "../Aspect.ts";
-import { Parameter, type Parameters } from "./parameter.ts";
-import { Result } from "./result.ts";
-
-export const isTool = (artifact: any): artifact is Tool =>
-  artifact?.type === "tool";
-
-export class ToolProps extends S.Class<ToolProps>("ToolProps")({
-  alias: S.optional(Function<(model: string) => string | undefined>()),
-}) {}
-
-export type ToolHandler<References extends any[], Err = any, Req = any> = (
-  params: Parameters.Of<References>,
-) => Effect.Effect<Result.Of<References>, Err, Req>;
-
-export type Tool<
-  ID extends string = string,
-  References extends any[] = any[],
-  Props extends ToolProps = ToolProps,
-  Handler extends ToolHandler<References> = any,
-> = Aspect<Tool, "tool", ID, References, Props, Handler> & {};
-
-export declare namespace Tool {
-  export type Success<T extends Tool> = Result.Of<T["references"]>;
-  export type Error<T extends Tool> = Effect.Error<ReturnType<T["handle"]>>;
-  export type Context<T extends Tool> = Effect.Services<
-    ReturnType<T["handle"]>
-  >;
-}
-
-export const Tool = defineAspect<
-  <const ID extends string, Props extends ToolProps = ToolProps>(
-    id: ID,
-    props?: Props,
-  ) => <const References extends any[]>(
-    template: TemplateStringsArray,
-    ...references: References
-  ) => (<Handler extends ToolHandler<References>>(
-    handler: Handler,
-  ) => Aspect<Tool, "tool", ID, References, Props, Handler>) &
-    (<Eff extends Yieldable<any, any, any, any>>(
-      handler: (
-        input: Parameters.Of<References>,
-      ) => Generator<Eff, NoInfer<Result.Of<References>>, never>,
-    ) => Aspect<
-      Tool,
-      "tool",
-      ID,
-      References,
-      Props,
-      (
-        input: Parameters.Of<References>,
-      ) => Effect.Effect<
-        NoInfer<Result.Of<References>>,
-        [Eff] extends [never]
-          ? never
-          : [Eff] extends [Yieldable<any, infer _A, infer E, infer _R>]
-            ? E
-            : never,
-        [Eff] extends [never]
-          ? never
-          : [Eff] extends [Yieldable<any, infer _A, infer _E, infer R>]
-            ? R
-            : never
-      >
-    >)
->("tool", ToolProps).with({
-  input: Parameter,
-  output: Result,
-});

package/src/Agent/util/command-validator.ts

@@ -1,98 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as Stream from "effect/Stream";
-import { ChildProcess } from "effect/unstable/process";
-import { AspectConfig } from "../Aspect.ts";
-import { loadParser } from "./parser.ts";
-
-export class CommandValidator extends Context.Service<
-  CommandValidator,
-  {
-    validate: (command: string) => Effect.Effect<void, string>;
-  }
->()("CommandValidator") {}
-
-export const commandValidator = Layer.effect(
-  CommandValidator,
-  // @ts-expect-error
-  Effect.gen(function* () {
-    const path = yield* Path.Path;
-    const parser = yield* loadParser("tree-sitter-bash/tree-sitter-bash.wasm");
-    return {
-      validate: Effect.fn(function* (command: string) {
-        const tree = parser.parse(command);
-        if (!tree) {
-          return yield* Effect.fail("Failed to parse command");
-        }
-        for (const node of tree.rootNode.descendantsOfType("command")) {
-          if (!node) continue;
-          const command = [];
-          for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (!child) continue;
-            if (
-              child.type !== "command_name" &&
-              child.type !== "word" &&
-              child.type !== "string" &&
-              child.type !== "raw_string" &&
-              child.type !== "concatenation"
-            ) {
-              continue;
-            }
-            command.push(child.text);
-          }
-
-          // not an exhaustive list, but covers most common cases
-          if (
-            [
-              "cd",
-              "rm",
-              "cp",
-              "mv",
-              "mkdir",
-              "touch",
-              "chmod",
-              "chown",
-            ].includes(command[0])
-          ) {
-            for (const arg of command.slice(1)) {
-              if (
-                arg.startsWith("-") ||
-                (command[0] === "chmod" && arg.startsWith("+"))
-              )
-                continue;
-              const resolved = yield* Effect.scoped(
-                Effect.gen(function* () {
-                  const handle = yield* ChildProcess.make("realpath", [arg], {
-                    shell: true,
-                  });
-                  return yield* Stream.mkString(
-                    Stream.decodeText(handle.stdout),
-                  );
-                }),
-              ).pipe(
-                Effect.map((x) => x.trim()),
-                Effect.catch(() => Effect.void),
-              );
-
-              if (resolved) {
-                const config = yield* Effect.serviceOption(AspectConfig).pipe(
-                  Effect.map(Option.getOrElse(() => ({ cwd: process.cwd() }))),
-                );
-                const relative = path.relative(config.cwd, resolved);
-                if (relative.startsWith("..")) {
-                  return yield* Effect.fail(
-                    `Cannot ${command[0]} file: ${arg} is outside the current working directory: ${config.cwd}`,
-                  );
-                }
-              }
-            }
-          }
-        }
-      }),
-    };
-  }),
-);

package/src/Agent/util/parser.ts

@@ -1,39 +0,0 @@
-import * as Effect from "effect/Effect";
-import { fileURLToPath } from "node:url";
-import { Language, Parser } from "web-tree-sitter";
-
-export const resolveWasm = (asset: string) => {
-  if (asset.startsWith("file://")) return fileURLToPath(asset);
-  if (asset.startsWith("/") || /^[a-z]:/i.test(asset)) return asset;
-  const url = new URL(asset, import.meta.url);
-  return fileURLToPath(url);
-};
-
-export const loadParser = Effect.fn("loadParser")(function* (wasmPath: string) {
-  const treeWasm = yield* Effect.promise(
-    () =>
-      // @ts-expect-error
-      import("web-tree-sitter/tree-sitter.wasm", {
-        with: { type: "wasm" },
-      }),
-  );
-  const treePath = resolveWasm(treeWasm);
-  yield* Effect.promise(() =>
-    Parser.init({
-      locateFile() {
-        return treePath;
-      },
-    }),
-  );
-  const { default: wasm } = yield* Effect.promise(
-    () =>
-      import(wasmPath, {
-        with: { type: "wasm" },
-      }),
-  );
-  const bashPath = resolveWasm(wasm);
-  const bashLanguage = yield* Effect.promise(() => Language.load(bashPath));
-  const p = new Parser();
-  p.setLanguage(bashLanguage);
-  return p;
-});