alchemy 2.0.0-beta.4 → 2.0.0-beta.41

package/src/Agent/process/driver.ts

@@ -1,168 +0,0 @@
-// @ts-nocheck - uncomment this once we are working on AI again
-import * as Effect from "effect/Effect";
-import * as S from "effect/Schema";
-import * as Stream from "effect/Stream";
-import * as util from "node:util";
-import * as vm from "node:vm";
-import { schemaToType } from "../../Util/schema-to-type.ts";
-import { Agent, AgentId } from "../Agent.ts";
-import { AspectGraph } from "../AspectGraph.ts";
-import { Chat } from "../chat/service.ts";
-import { Thread } from "../chat/thread.ts";
-import { LLM } from "../llm/llm.ts";
-import { lastMessageText } from "../llm/stream-collectors.ts";
-import { Tool } from "../tool/tool.ts";
-
-/**
- * Called whenever a message is sent by a user to a Thread.
- *
- * This uses an LLM to choose which agents should respond to the message.
- */
-export const driveThread = Effect.fn("driveThread")(function* (thread: Thread) {
-  const graph = yield* AspectGraph;
-  const {
-    exprs: [env],
-    types,
-  } = schemaToType(graph.schema);
-  class code extends Tool.input("code")`
-JavaScript code to evaluate (must be a valid JavaScript module.
-Using modern ESM syntax only.
-The code is running in a Bun REPL environment.
-Use arbitrary JavaScript code to explore the environment and` {}
-
-  class evaluate extends Tool("eval")`
-Evaluates ${code} in a REPL in an Agent's environment and returns the console.log
-output and result of the evaluation as a ${S.String}.
-Use this tool to explore the Chat environment and find relevant information.
-\`\`\`typescript
-${types}
-/** The environment of the Agent. */
-declare const env: ${env};
-/** The current issue
-declare const issue: Issue;
-/** The current prompt to the Agent. */
-declare const query: string;
-/** A function that can be used to recursively call the LLM to explore the environment. */
-declare function recursiveLLM(subQuery: string): Promise<string>;
-\`\`\`
-`(function* ({ code }) {
-    const logs: string[] = [];
-    const capture = (...args: unknown[]) =>
-      logs.push(
-        args
-          .map((a) =>
-            typeof a === "string" ? a : util.inspect(a, { depth: null }),
-          )
-          .join(" "),
-      );
-    const context = vm.createContext({
-      env: graph.aspects,
-      issue: undefined, // TODO(sam): provide the current issue
-      console: {
-        log: capture,
-        info: capture,
-        warn: capture,
-        error: capture,
-        debug: capture,
-      },
-    });
-    try {
-      const script = new vm.Script(code);
-      const result = script.runInContext(context);
-      return `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}${typeof result === "string" ? result : util.inspect(result, { depth: null })}`;
-    } catch (err) {
-      const error = err instanceof Error ? err.message : String(err);
-      return `${logs.join("\n")}${logs.length > 0 ? "\n" : ""}${error}`;
-    }
-  }) {}
-
-  // TODO(sam): use examples of agents in the graph, agents.map((a) => a.id).slice(0, 3).join(", ")
-  // or -> make it a literal type of all agent IDs
-  class agentId extends Tool.input("agentId", AgentId)`
-  The ID of the Agent to create a Task for, e.g. @ceo, @sde, @cfo.` {}
-
-  class prompt extends Tool.input("prompt")`
-  The prompt to start the Task with.` {}
-
-  class query extends Tool("query")`
-  You are a Recursive Language Model. You interact with context through a JavaScript Bun REPL environment.
-
-  The Aspect environment is stored in the variable \`env\`. 
-  IMPORTANT: You cannot see the context directly. You MUST write JavaScript code to search and explore it.
-  
-  Available in environment:
-  \`\`\`typescript
-  ${types}
-  /** The environment of the Agent. */
-  declare const env: ${env};
-  // The current Issue (similar to a GitHub Issue)
-  declare const issue: Issue;
-  /** The current query to answer. */
-  declare const query: string;
-  /** A function that can be used to recursively call the LLM to explore the environment. */
-  declare function query(subQuery: string): Promise<string>;
-  \`\`\`
-  
-  Write JavaScript code to answer the query. The last expression and all console.log() output will be shown to you.
-  
-  Examples:
-  - console.log(issue.messages[issue.messages.length-1]) // See the last message in the issue
-  - issue.messages[issue.messages.length-1] // Print the last message in the issue (because this is the last expression in the code)
-  - matches = re.findall(r'keyword.*', context); print(matches[:5])
-  - idx = context.find('search term'); print(context[idx:idx+200])
-  
-  CRITICAL: Do NOT guess or make up answers. You MUST search the context first to find the actual information.
-  Only finish your response after you have found concrete evidence in the context.
-  Finish by providing a detailed textual answer to the query.
-  
-  Depth: {depth}`(function* () {}) {}
-
-  class reply extends Tool("reply")`
-  Prompt an Agent (by ${agentId}) to reply in a Thread. 
-  The agent is given a ${prompt} to orient the direction of the task, but is otherwise free to choose how to complete the task.
-  Available agents: ${Object.keys(graph.aspects.agent).join(", ")}
-  If the reply fails, a ${S.String} message will be returned.
-  Use the ${recursiveLLM} tool to explore and query the contextual encironment you are operating in.
-  `(function* ({ agentId, prompt }) {
-    // TODO(sam): look up in the graph?
-    const agent = graph.aspects.agent[agentId] as Agent | undefined;
-
-    if (!agent) {
-      return `Agent '${agentId}' not found, available agents: ${Object.keys(graph.aspects.agent).join(", ")}`;
-    }
-
-    const task = yield* Chat.createTask({
-      threadId: thread.threadId,
-      agentId,
-    });
-
-    const lastMessage = yield* LLM.stream({
-      model: "anthropic/claude-opus-4.5",
-      system: ``,
-      messages: [{ role: "user", content: prompt }],
-      tools: [],
-    }).pipe(
-      Stream.tapSink(Chat.sinkTask(task.taskId)),
-      Stream.run(lastMessageText),
-    );
-
-    if (!lastMessage) {
-      return yield* Effect.die(`No message returned from agent '${agentId}'`);
-    }
-
-    // TODO(sam): submit the result message to the issue
-    return lastMessage;
-  }) {}
-
-  const stream = Effect.gen(function* () {
-    const llm = yield* LLM;
-    const chat = yield* Chat;
-    return yield* llm
-      .stream({
-        system: "You are a helpful assistant.",
-        messages: [],
-        tools: [evaluate, reply],
-      })
-      .pipe(Stream.tapSink(chat.sinkThreadDriver(thread.threadId)));
-  });
-});

package/src/Agent/process/issue-service.ts

@@ -1,48 +0,0 @@
-import * as Context from "effect/Context";
-import type { Effect } from "effect/Effect";
-import * as S from "effect/Schema";
-import { Issue, IssueId } from "./issue.ts";
-import { Reply, ReplyId } from "./reply.ts";
-
-export class CreateIssueRequest extends S.Class<CreateIssueRequest>(
-  "CreateIssueRequest",
-)({
-  title: S.String,
-  description: S.String,
-}) {}
-
-export class UpdateIssueRequest extends S.Class<UpdateIssueRequest>(
-  "UpdateIssueRequest",
-)({
-  issueId: IssueId,
-  title: S.String.pipe(S.optional),
-  description: S.String.pipe(S.optional),
-}) {}
-
-export class SendReplyRequest extends S.Class<SendReplyRequest>(
-  "SendReplyRequest",
-)({
-  issueId: IssueId,
-  content: S.String,
-}) {}
-
-export class UpdateReplyRequest extends S.Class<UpdateReplyRequest>(
-  "UpdateReplyRequest",
-)({
-  replyId: ReplyId,
-  content: S.String.pipe(S.optional),
-}) {}
-
-export class Issues extends Context.Service<
-  Issues,
-  {
-    listIssues: () => Effect<Issue[]>;
-    readIssue: (issueId: IssueId) => Effect<Issue>;
-    createIssue: (input: CreateIssueRequest) => Effect<Issue>;
-    updateIssue: (input: UpdateIssueRequest) => Effect<Issue>;
-    closeIssue: (issueId: IssueId) => Effect<Issue>;
-    sendReply: (input: SendReplyRequest) => Effect<Reply>;
-    updateReply: (input: UpdateReplyRequest) => Effect<Reply>;
-    deleteReply: (replyId: ReplyId) => Effect<void>;
-  }
->()("Issues") {}

package/src/Agent/process/issue-tools.ts

@@ -1,33 +0,0 @@
-// @ts-nocheck - uncomment this once we are working on AI again
-
-import { Tool } from "../tool/tool.ts";
-import { Issues } from "./issue-service.ts";
-import { Issue, IssueId } from "./issue.ts";
-
-export class title extends Tool.input("title")`
-The title of the Issue.` {}
-
-export class description extends Tool.input(
-  "description",
-)`The description of the Issue.` {}
-
-export class issueId extends Tool.input(
-  "issueId",
-  IssueId,
-)`The ID of the Issue.` {}
-
-export class readIssue extends Tool("readIssue")`
-Read an ${Issue} in the Thread with its ${issueId}.
-`(({ issueId }) => Issues.readIssue(issueId)) {}
-
-export class createIssue extends Tool("createIssue")`
-Create an Issue in the Thread with a ${title} and ${description}.
-`(Issues.createIssue) {}
-
-export class updateIssue extends Tool("updateIssue")`
-Update an ${Issue}'s ${title} and/or ${description} referenced by its ${issueId}.
-`(Issues.updateIssue) {}
-
-export class closeIssue extends Tool("closeIssue")`
-Close an Issue in the Thread referenced by its ${issueId}.
-`(({ issueId }) => Issues.closeIssue(issueId)) {}

package/src/Agent/process/issue.ts

@@ -1,22 +0,0 @@
-import * as S from "effect/Schema";
-
-export type IssueId = number;
-export const IssueId = S.Int.check(S.isGreaterThan(0)).annotate({
-  description: "The ID of the issue",
-});
-
-export type IssueDescription = string;
-export const IssueDescription = S.String.annotate({
-  description: "The description of the issue",
-});
-
-export type IssueTitle = string;
-export const IssueTitle = S.String.annotate({
-  description: "The title of the issue",
-});
-
-export class Issue extends S.Class<Issue>("Issue")({
-  issueId: IssueId,
-  title: IssueTitle,
-  description: IssueDescription,
-}) {}

package/src/Agent/process/organization.ts

@@ -1,16 +0,0 @@
-import { type Aspect, defineAspect } from "../Aspect.ts";
-
-export type Organization<
-  Name extends string = string,
-  References extends any[] = any[],
-> = Aspect<Organization, "organization", Name, References>;
-
-export const Organization =
-  defineAspect<
-    <const Name extends string>(
-      name: Name,
-    ) => <References extends any[]>(
-      template: TemplateStringsArray,
-      ...references: References
-    ) => Organization<Name, References>
-  >("organization");

package/src/Agent/process/process.ts

@@ -1,16 +0,0 @@
-import { defineAspect, type Aspect } from "../Aspect";
-
-export interface Process<
-  Name extends string = string,
-  References extends any[] = any[],
-> extends Aspect<Process, "process", Name, References> {}
-
-export const Process =
-  defineAspect<
-    <const Name extends string>(
-      name: Name,
-    ) => <References extends any[]>(
-      template: TemplateStringsArray,
-      ...references: References
-    ) => Process<Name, References>
-  >("process");

package/src/Agent/process/reply.ts

@@ -1,21 +0,0 @@
-import * as S from "effect/Schema";
-import { CreatedAt, UpdatedAt } from "../../Schema.ts";
-import { IssueId } from "./issue.ts";
-
-export type ReplyId = number;
-export const ReplyId = S.Int.check(S.isGreaterThan(0)).annotate({
-  description: "The ID of the reply",
-});
-
-export type ReplyContent = string;
-export const ReplyContent = S.String.annotate({
-  description: "The content of the reply",
-});
-
-export class Reply extends S.Class<Reply>("Reply")({
-  replyId: ReplyId,
-  issueId: IssueId,
-  content: ReplyContent,
-  createdAt: CreatedAt,
-  updatedAt: UpdatedAt,
-}) {}

package/src/Agent/process/task.ts

@@ -1,34 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as S from "effect/Schema";
-import { AgentId } from "../Agent.ts";
-import { ThreadId } from "../chat/thread.ts";
-
-export type TaskId = string;
-export const TaskId = S.String.annotate({
-  description: "The ID of the task",
-});
-
-export class Task extends S.Class<Task>("Task")({
-  taskId: TaskId,
-  threadId: ThreadId.annotate({
-    description: "The thread that the task belongs to",
-  }),
-  agent: AgentId.annotate({
-    description: "The agent that is working on the task",
-  }),
-}) {}
-
-export class CreateTaskRequest extends S.Class<CreateTaskRequest>(
-  "CreateTaskRequest",
-)({
-  threadId: ThreadId,
-  agentId: AgentId,
-}) {}
-
-export class Tasks extends Context.Service<
-  Tasks,
-  {
-    createTask: (input: CreateTaskRequest) => Effect.Effect<Task>;
-  }
->()("Tasks") {}

package/src/Agent/tool/index.ts

@@ -1,3 +0,0 @@
-export * from "./parameter.ts";
-export * from "./result.ts";
-export * from "./tool.ts";

package/src/Agent/tool/parameter.ts

@@ -1,35 +0,0 @@
-import * as S from "effect/Schema";
-import { Field } from "../../Schema.ts";
-import { defineAspect, type Aspect } from "../Aspect.ts";
-
-export const isParameter = (artifact: any): artifact is Parameter =>
-  artifact?.type === "param";
-
-export type Parameter<
-  ID extends string = string,
-  References extends any[] = any[],
-  T extends Field = Field,
-> = Aspect<Parameter, "param", ID, References, T>;
-
-export const Parameter = defineAspect<
-  <const Name extends string, Schema extends Field = typeof S.String>(
-    name: Name,
-    schema?: Schema,
-  ) => <References extends any[]>(
-    template: TemplateStringsArray,
-    ...references: References
-  ) => Parameter<Name, References, Schema>
->("param", Field);
-
-export declare namespace Parameters {
-  export type Of<
-    References extends any[],
-    Fields extends S.Struct.Fields = {},
-  > = References extends []
-    ? S.Struct<Fields>["Type"]
-    : References extends [infer Artifact, ...infer Rest]
-      ? Artifact extends Parameter<infer ID extends string, any[], infer Field>
-        ? Parameters.Of<Rest, Fields & { [name in ID]: Field }>
-        : Parameters.Of<Rest, Fields>
-      : [];
-}

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;
-});