alchemy 2.0.0-beta.37 → 2.0.0-beta.38

package/src/Agent/lsp/manager.ts

@@ -1,213 +0,0 @@
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as HashMap from "effect/HashMap";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Ref from "effect/Ref";
-import { type Diagnostic, type LSPClient, makeLSPClient } from "./client.ts";
-import { type ServerConfig, DefaultServers } from "./servers.ts";
-
-/**
- * Create an LSPManager layer.
- *
- * @param servers - List of servers to use. Defaults to DefaultServers.
- */
-export const LSPManagerLive = (servers: ServerConfig[] = DefaultServers) =>
-  Layer.effect(LSPManager, makeLSPManager(servers));
-
-/**
- * LSP Manager interface.
- */
-export interface LSPManager {
-  /**
-   * Initialize all available LSP servers.
-   */
-  initialize(root: string): Effect.Effect<void, never, never>;
-
-  /**
-   * Notify all servers that a file has changed.
-   */
-  notifyFileChanged(
-    path: string,
-    content: string,
-  ): Effect.Effect<void, never, never>;
-
-  /**
-   * Wait for diagnostics from all servers and return aggregated results.
-   */
-  waitForDiagnostics(
-    path: string,
-    timeout?: number,
-  ): Effect.Effect<Diagnostic[], never, never>;
-
-  /**
-   * Get current diagnostics for a file (without waiting).
-   */
-  getDiagnostics(path: string): Effect.Effect<Diagnostic[], never, never>;
-
-  /**
-   * Shutdown all servers.
-   */
-  readonly shutdown: Effect.Effect<void, never, never>;
-}
-
-export const LSPManager = Context.Service<LSPManager>("LSPManager");
-
-/**
- * Create an LSPManager implementation.
- */
-const makeLSPManager = (servers: ServerConfig[]) =>
-  Effect.gen(function* () {
-    // Map of serverId -> LSPClient
-    const clients = yield* Ref.make(HashMap.empty<string, LSPClient>());
-
-    // Aggregated diagnostics: uri -> Map<serverId, Diagnostic[]>
-    const diagnosticsMap = yield* Ref.make(
-      HashMap.empty<string, HashMap.HashMap<string, Diagnostic[]>>(),
-    );
-
-    // Initialization state
-    const initialized = yield* Ref.make(false);
-
-    return LSPManager.of({
-      initialize: Effect.fnUntraced(function* (root: string) {
-        const alreadyInitialized = yield* Ref.get(initialized);
-        if (alreadyInitialized) return;
-
-        yield* Effect.logDebug("[LSPManager] Initializing LSP servers...");
-
-        // Spawn all available servers in parallel
-        yield* Effect.forEach(
-          servers,
-          (config) =>
-            Effect.gen(function* () {
-              yield* Effect.logDebug(
-                `[LSPManager] Starting ${config.id} server...`,
-              );
-
-              const proc = yield* spawnServer(config, root);
-              if (!proc) {
-                yield* Effect.logWarning(
-                  `[LSPManager] ${config.id} server not available`,
-                );
-                return;
-              }
-
-              const client = yield* makeLSPClient(config.id, proc, root);
-
-              // Wire up diagnostics aggregation
-              yield* client.onDiagnostics((uri, diags) =>
-                Ref.update(diagnosticsMap, (m) => {
-                  const existing = HashMap.get(m, uri).pipe(
-                    Option.getOrElse(() =>
-                      HashMap.empty<string, Diagnostic[]>(),
-                    ),
-                  );
-                  const updated = HashMap.set(existing, config.id, diags);
-                  return HashMap.set(m, uri, updated);
-                }),
-              );
-
-              yield* Ref.update(clients, (m) =>
-                HashMap.set(m, config.id, client),
-              );
-              yield* Effect.logDebug(
-                `[LSPManager] ${config.id} server started`,
-              );
-            }).pipe(
-              Effect.catch((e) =>
-                Effect.logWarning(
-                  `[LSPManager] Failed to start ${config.id}: ${e}`,
-                ),
-              ),
-            ),
-          { concurrency: "unbounded" },
-        );
-
-        yield* Ref.set(initialized, true);
-        yield* Effect.logDebug("[LSPManager] All LSP servers initialized");
-      }),
-
-      notifyFileChanged: Effect.fnUntraced(function* (
-        path: string,
-        content: string,
-      ) {
-        yield* Effect.logDebug(`[LSPManager] Notifying ${path} of changes`);
-        const allClients = yield* Ref.get(clients);
-        yield* Effect.forEach(
-          HashMap.values(allClients),
-          (client) => client.notifyFileChanged(path, content),
-          { concurrency: "unbounded" },
-        ).pipe(Effect.catch(() => Effect.void));
-      }),
-
-      waitForDiagnostics: Effect.fnUntraced(function* (
-        path: string,
-        timeout = 3000,
-      ) {
-        yield* Effect.logDebug(
-          `[LSPManager] Waiting for diagnostics for ${path}`,
-        );
-        const allClients = yield* Ref.get(clients);
-        const uri = `file://${path}`;
-
-        // Wait for all servers to report diagnostics
-        yield* Effect.forEach(
-          HashMap.values(allClients),
-          (client) => client.waitForDiagnostics(path, timeout),
-          { concurrency: "unbounded" },
-        ).pipe(Effect.catch(() => Effect.void));
-
-        // Aggregate diagnostics from all servers
-        const allDiagnostics = yield* Ref.get(diagnosticsMap).pipe(
-          Effect.map((m) => {
-            const byServer = HashMap.get(m, uri).pipe(
-              Option.getOrElse(() => HashMap.empty<string, Diagnostic[]>()),
-            );
-            return Array.from(HashMap.values(byServer)).flat();
-          }),
-        );
-
-        return allDiagnostics;
-      }),
-
-      getDiagnostics: Effect.fnUntraced(function* (path: string) {
-        const uri = `file://${path}`;
-        const allDiagnostics = yield* Ref.get(diagnosticsMap).pipe(
-          Effect.map((m) => {
-            const byServer = HashMap.get(m, uri).pipe(
-              Option.getOrElse(() => HashMap.empty<string, Diagnostic[]>()),
-            );
-            return Array.from(HashMap.values(byServer)).flat();
-          }),
-        );
-        return allDiagnostics;
-      }),
-
-      shutdown: Effect.gen(function* () {
-        yield* Effect.logDebug("[LSPManager] Shutting down LSP servers...");
-        const allClients = yield* Ref.get(clients);
-        yield* Effect.forEach(
-          HashMap.values(allClients),
-          (client) => client.shutdown,
-          { concurrency: "unbounded" },
-        ).pipe(Effect.catch(() => Effect.void));
-        yield* Ref.set(clients, HashMap.empty());
-        yield* Ref.set(initialized, false);
-        yield* Effect.logDebug("[LSPManager] All LSP servers shut down");
-      }),
-    });
-  });
-
-/**
- * Spawn an LSP server process.
- */
-const spawnServer = (config: ServerConfig, cwd: string) =>
-  Effect.sync(() =>
-    Bun.spawn(config.command, {
-      cwd,
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "inherit",
-    }),
-  );

package/src/Agent/lsp/servers.ts

@@ -1,37 +0,0 @@
-/**
- * Configuration for an LSP server.
- */
-export interface ServerConfig {
-  /**
-   * Unique identifier for the server.
-   */
-  id: string;
-
-  /**
-   * Command to run (e.g. ["typescript-language-server", "--stdio"])
-   */
-  command: string[];
-}
-
-/**
- * TypeScript Language Server configuration.
- * Uses typescript-language-server which wraps tsserver.
- */
-export const TypeScriptServer: ServerConfig = {
-  id: "typescript",
-  command: ["typescript-language-server", "--stdio"],
-};
-
-/**
- * oxlint Language Server configuration.
- * Uses oxlint --lsp for fast linting.
- */
-export const OxlintServer: ServerConfig = {
-  id: "oxlint",
-  command: ["bun", "oxlint", "--lsp"],
-};
-
-/**
- * Default LSP servers.
- */
-export const DefaultServers: ServerConfig[] = [TypeScriptServer, OxlintServer];

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>
-      : [];
-}