alchemy-effect 0.6.0 → 0.6.2

package/src/Agent/lsp/manager.ts

@@ -0,0 +1,213 @@
+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 * as ServiceMap from "effect/ServiceMap";
+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 = ServiceMap.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

@@ -0,0 +1,37 @@
+/**
+ * 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

@@ -0,0 +1,168 @@
+// @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

@@ -0,0 +1,48 @@
+import type { Effect } from "effect/Effect";
+import * as S from "effect/Schema";
+import * as ServiceMap from "effect/ServiceMap";
+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 ServiceMap.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

@@ -0,0 +1,33 @@
+// @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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,34 @@
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as ServiceMap from "effect/ServiceMap";
+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 ServiceMap.Service<
+  Tasks,
+  {
+    createTask: (input: CreateTaskRequest) => Effect.Effect<Task>;
+  }
+>()("Tasks") {}

package/src/Agent/tool/index.ts

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

package/src/Agent/tool/parameter.ts

@@ -0,0 +1,35 @@
+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>
+      : [];
+}