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

package/src/Agent/coding/grep.ts

@@ -1,143 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Option from "effect/Option";
-import * as S from "effect/Schema";
-import { ChildProcess } from "effect/unstable/process";
-import { AspectConfig } from "../Aspect.ts";
-import { Tool } from "../tool/tool.ts";
-import { exec } from "../util/exec.ts";
-
-const MAX_LINE_LENGTH = 2000;
-
-class pattern extends Tool.input(
-  "pattern",
-)`The regex pattern to search for in file contents.
-Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+", etc.)` {}
-
-class path extends Tool.input(
-  "path",
-  S.optional(S.String),
-)`The directory to search in. Defaults to cwd if not specified.` {}
-
-class include extends Tool.input(
-  "include",
-  S.optional(S.String),
-)`File pattern to include in the search (e.g., "*.js", "*.{ts,tsx}")` {}
-
-class matches extends Tool.output(
-  "matches",
-)`The search results showing file paths and matching lines, sorted by modification time.` {}
-
-export class grep extends Tool(
-  "grep",
-)`Fast content search tool that works with any codebase size.
-Returns ${matches} with file paths and line numbers.
-
-Given a ${pattern} and optional ${path} and ${include}:
-- Searches file contents using regular expressions
-- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+", etc.)
-- Filter files by pattern with the include parameter (e.g., "*.js", "*.{ts,tsx}")
-- Returns file paths and line numbers with at least one match sorted by modification time
-- Use this tool when you need to find files containing specific patterns
-- If you need to identify/count the number of matches within files, use the Bash tool with \`rg\` (ripgrep) directly. Do NOT use \`grep\`.
-- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
-`(function* ({ pattern, path: searchDir, include }) {
-  yield* Effect.logDebug(`[grep] pattern=${pattern} path=${searchDir}`);
-
-  const config = yield* Effect.serviceOption(AspectConfig).pipe(
-    Effect.map(Option.getOrElse(() => ({ cwd: process.cwd() }))),
-  );
-  const fs = yield* FileSystem.FileSystem;
-  const searchPath = searchDir || config.cwd;
-
-  const rgArgs = ["-nH", "--field-match-separator=|", "--regexp", pattern];
-  if (include) {
-    rgArgs.push("--glob", include);
-  }
-  rgArgs.push(searchPath);
-
-  const { stdout, stderr, exitCode } = yield* exec(
-    ChildProcess.make("rg", rgArgs),
-  ).pipe(
-    Effect.catch(() => Effect.succeed({ stdout: "", stderr: "", exitCode: 1 })),
-  );
-
-  if (exitCode === 1) {
-    return {
-      matches: `No matches found for pattern "${pattern}" in ${searchPath}`,
-    };
-  } else if (exitCode !== 0) {
-    return { matches: `ripgrep failed with exit code ${exitCode}: ${stderr}` };
-  }
-
-  const lines = stdout.split(/\r?\n/);
-  const matchList: {
-    path: string;
-    modTime: number;
-    lineNum: number;
-    lineText: string;
-  }[] = [];
-
-  for (const line of lines) {
-    if (!line) continue;
-
-    const [filePath, lineNumStr, ...lineTextParts] = line.split("|");
-    if (!filePath || !lineNumStr || lineTextParts.length === 0) continue;
-
-    const lineNum = parseInt(lineNumStr, 10);
-    const lineText = lineTextParts.join("|");
-
-    const stats = yield* fs
-      .stat(filePath)
-      .pipe(Effect.catch(() => Effect.succeed(null)));
-    if (!stats) continue;
-
-    const modTime = stats.mtime;
-    if (!modTime) continue;
-    matchList.push({
-      path: filePath,
-      modTime: modTime.pipe(Option.getOrElse(() => new Date(0))).getTime(),
-      lineNum,
-      lineText,
-    });
-  }
-
-  matchList.sort((a, b) => b.modTime - a.modTime);
-
-  const limit = 100;
-  const truncated = matchList.length > limit;
-  const finalMatches = truncated ? matchList.slice(0, limit) : matchList;
-
-  if (finalMatches.length === 0) {
-    return {
-      matches: `No matches found for pattern "${pattern}" in ${searchPath}`,
-    };
-  }
-
-  const outputLines = [`Found ${finalMatches.length} matches`];
-
-  let currentFile = "";
-  for (const match of finalMatches) {
-    if (currentFile !== match.path) {
-      if (currentFile !== "") {
-        outputLines.push("");
-      }
-      currentFile = match.path;
-      outputLines.push(`${match.path}:`);
-    }
-    const truncatedLineText =
-      match.lineText.length > MAX_LINE_LENGTH
-        ? match.lineText.substring(0, MAX_LINE_LENGTH) + "..."
-        : match.lineText;
-    outputLines.push(`  Line ${match.lineNum}: ${truncatedLineText}`);
-  }
-
-  if (truncated) {
-    outputLines.push("");
-    outputLines.push(
-      "(Results are truncated. Consider using a more specific path or pattern.)",
-    );
-  }
-
-  return { matches: outputLines.join("\n") };
-}) {}

package/src/Agent/coding/index.ts

@@ -1,7 +0,0 @@
-export * from "./bash.ts";
-export * from "./edit.ts";
-export * from "./glob.ts";
-export * from "./grep.ts";
-export * from "./read.ts";
-export * from "./readlints.ts";
-export * from "./write.ts";

package/src/Agent/coding/read.ts

@@ -1,119 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as S from "effect/Schema";
-import { AspectConfig } from "../Aspect.ts";
-import { Tool } from "../tool/tool.ts";
-
-class filePath extends Tool.input(
-  "filePath",
-)`The path to the file to read. Use relative paths from the current working directory (e.g., "src/index.ts", "test/fixtures/math.ts"). Do NOT use paths starting with "/" - use relative paths instead.` {}
-
-class offset extends Tool.input(
-  "offset",
-  S.optional(S.Number),
-)`The line number to start reading from (0-based). Defaults to 0.` {}
-
-class limit extends Tool.input(
-  "limit",
-  S.optional(S.Number),
-)`The number of lines to read. Defaults to 2000.` {}
-
-class content extends Tool.output(
-  "content",
-)`The file content, or an error message if the file cannot be read.` {}
-
-export class read extends Tool("read")`Reads a file from the local filesystem.
-Returns the ${content} of the file.
-
-Given a ${filePath} and optional ${offset} and ${limit}:
-- Use relative paths from the current working directory (e.g., "src/index.ts", "test/fixtures/math.ts")
-- Do NOT use paths starting with "/" - use relative paths instead
-- By default, it reads up to 2000 lines starting from the beginning of the file
-- You can optionally specify a line offset and limit for long files
-`(function* ({ filePath: _filePath, offset: _offset, limit: _limit }) {
-  yield* Effect.logDebug(`[read] filePath=${_filePath}`);
-
-  const config = yield* Effect.serviceOption(AspectConfig).pipe(
-    Effect.map(Option.getOrElse(() => ({ cwd: process.cwd() }))),
-  );
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-
-  const offset = _offset ?? 0;
-  const limit = _limit ?? 2000;
-
-  if (_filePath.includes(".env")) {
-    return {
-      content: "Environment files (.env) are not readable for security reasons",
-    };
-  }
-
-  const filePath = path.isAbsolute(_filePath)
-    ? _filePath
-    : path.join(config.cwd, _filePath);
-
-  const exists = yield* fs
-    .exists(filePath)
-    .pipe(Effect.catch(() => Effect.succeed(false)));
-
-  if (!exists) {
-    // Try to get suggestions from parent directory
-    const dir = path.dirname(filePath);
-    const base = path.basename(filePath);
-    const dirExists = yield* fs
-      .exists(dir)
-      .pipe(Effect.catch(() => Effect.succeed(false)));
-
-    if (dirExists) {
-      const files = yield* fs
-        .readDirectory(dir)
-        .pipe(Effect.catch(() => Effect.succeed([] as string[])));
-      const suggestions = files
-        .filter(
-          (entry) =>
-            entry.toLowerCase().includes(base.toLowerCase()) ||
-            base.toLowerCase().includes(entry.toLowerCase()),
-        )
-        .map((entry) => path.join(dir, entry))
-        .slice(0, 3);
-
-      if (suggestions.length > 0) {
-        return {
-          content: `File not found: ${filePath}. Did you mean one of these?\n${suggestions.join("\n")}`,
-        };
-      }
-    }
-    return { content: `File not found: ${filePath}` };
-  }
-
-  // Check if it's a directory
-  const stat = yield* fs
-    .stat(filePath)
-    .pipe(Effect.catch(() => Effect.succeed(null)));
-
-  if (stat?.type === "Directory") {
-    const entries = yield* fs
-      .readDirectory(filePath)
-      .pipe(Effect.catch(() => Effect.succeed([] as string[])));
-    return {
-      content: `Cannot read directory as a file: ${filePath}\nThis is a directory. Contents:\n${entries.slice(0, 10).join("\n")}${entries.length > 10 ? "\n..." : ""}`,
-    };
-  }
-
-  const fileContent = yield* fs
-    .readFileString(filePath)
-    .pipe(
-      Effect.catch((e) =>
-        Effect.succeed(`Failed to read file ${filePath}: ${e}`),
-      ),
-    );
-
-  return {
-    content: fileContent
-      .split("\n")
-      .slice(offset, offset + limit)
-      .join("\n"),
-  };
-}) {}

package/src/Agent/coding/readlints.ts

@@ -1,78 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as S from "effect/Schema";
-import { AspectConfig } from "../Aspect.ts";
-import { formatDiagnostic } from "../lsp/diagnostics.ts";
-import { LSPManager } from "../lsp/manager.ts";
-import { Tool } from "../tool/tool.ts";
-
-export class paths extends Tool.input(
-  "paths",
-  S.optional(S.Array(S.String)),
-)`Optional array of paths to files or directories to read linter errors for. If not provided, returns diagnostics for all files in the workspace.` {}
-
-export class diagnostics extends Tool.output(
-  "diagnostics",
-)`The linter errors and diagnostics for the specified paths.` {}
-
-export class readlints extends Tool(
-  "readlints",
-)`Read and display linter errors from the workspace.
-Returns ${diagnostics} for the specified files.
-
-Given optional ${paths}:
-- If a file path is provided, returns diagnostics for that file only
-- If a directory path is provided, returns diagnostics for all files within that directory
-- If no paths are provided, returns diagnostics for all files in the workspace
-- This tool can return linter errors that were already present before your edits, so avoid calling it with a very wide scope of files
-- NEVER call this tool on a file unless you've edited it or are about to edit it
-`(function* ({ paths: inputPaths }) {
-  yield* Effect.logDebug(`[readlints] paths=${JSON.stringify(inputPaths)}`);
-
-  const config = yield* Effect.serviceOption(AspectConfig).pipe(
-    Effect.map(Option.getOrElse(() => ({ cwd: process.cwd() }))),
-  );
-  const pathService = yield* Path.Path;
-  const lspManager = yield* LSPManager;
-
-  const resolvedPaths = (inputPaths ?? []).map((p) =>
-    pathService.isAbsolute(p) ? p : pathService.join(config.cwd, p),
-  );
-
-  // Get diagnostics for each path
-  const allDiagnostics = yield* Effect.forEach(
-    resolvedPaths,
-    (filePath) =>
-      lspManager
-        .getDiagnostics(filePath)
-        .pipe(Effect.map((diags) => ({ filePath, diags }))),
-    { concurrency: "unbounded" },
-  );
-
-  // Format output grouped by file
-  const results: string[] = [];
-  for (const { filePath, diags } of allDiagnostics) {
-    if (diags.length > 0) {
-      results.push(`${filePath}:`);
-      for (const d of diags) {
-        results.push(`  ${formatDiagnostic(d)}`);
-      }
-    }
-  }
-
-  yield* Effect.logDebug(
-    `[readlints] found ${results.length} files with diagnostics`,
-  );
-
-  if (results.length === 0) {
-    return {
-      diagnostics:
-        resolvedPaths.length > 0
-          ? `No linter errors found in specified paths`
-          : `No linter errors found`,
-    };
-  }
-
-  return { diagnostics: results.join("\n") };
-}) {}

package/src/Agent/coding/write.ts

@@ -1,79 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import { AspectConfig } from "../Aspect.ts";
-import {
-  formatDiagnostics,
-  getDiagnosticsIfAvailable,
-} from "../lsp/diagnostics.ts";
-import { Tool } from "../tool/tool.ts";
-
-class filePath extends Tool.input(
-  "filePath",
-)`The path to the file to write. Use relative paths from the current working directory (e.g., "src/index.ts", "test/fixtures/math.test.ts"). Do NOT use paths starting with "/" - use relative paths instead.` {}
-
-class content extends Tool.input(
-  "content",
-)`The content to write to the file.` {}
-
-class output extends Tool.output(
-  "result",
-)`The result of the write operation, including any diagnostics from LSP.` {}
-
-export class write extends Tool("write")`Writes a file to the local filesystem.
-Returns the ${output} of the operation.
-
-Given a ${filePath} and ${content}:
-- Use relative paths from the current working directory (e.g., "src/index.ts", "test/fixtures/math.test.ts")
-- Do NOT use paths starting with "/" - use relative paths instead
-- This tool will overwrite the existing file if there is one at the provided path.
-- Parent directories are created automatically if they don't exist.
-`(function* ({ filePath: _filePath, content }) {
-  yield* Effect.logDebug(
-    `[write] filePath=${_filePath} content.length=${content.length}`,
-  );
-
-  const config = yield* Effect.serviceOption(AspectConfig).pipe(
-    Effect.map(Option.getOrElse(() => ({ cwd: process.cwd() }))),
-  );
-  const path = yield* Path.Path;
-  const fs = yield* FileSystem.FileSystem;
-
-  const filePath = path.isAbsolute(_filePath)
-    ? _filePath
-    : path.join(config.cwd, _filePath);
-
-  // Ensure parent directory exists
-  const dir = path.dirname(filePath);
-  yield* fs
-    .makeDirectory(dir, { recursive: true })
-    .pipe(Effect.catch(() => Effect.void));
-
-  const writeResult = yield* fs
-    .writeFileString(filePath, content)
-    .pipe(
-      Effect.catch((e) =>
-        Effect.succeed(`Failed to write file ${filePath}: ${e}`),
-      ),
-    );
-
-  if (typeof writeResult === "string") {
-    yield* Effect.logDebug(`[write] ${writeResult}`);
-    return { result: writeResult };
-  }
-
-  // Get diagnostics from LSP servers
-  const diagnostics = yield* getDiagnosticsIfAvailable(filePath, content);
-  const formatted = formatDiagnostics(diagnostics);
-
-  yield* Effect.logDebug(
-    `[write] diagnostics for ${filePath}: ${formatted || "(none)"}`,
-  );
-
-  return {
-    result: formatted
-      ? `Wrote file: ${filePath}\n\n${formatted}`
-      : `Wrote file: ${filePath}`,
-  };
-}) {}

package/src/Agent/fs/file.ts

@@ -1,22 +0,0 @@
-import * as S from "effect/Schema";
-import { defineAspect, type Aspect } from "../Aspect.ts";
-
-export interface File<
-  Name extends string = string,
-  References extends any[] = any[],
-  Props extends FileProps = FileProps,
-> extends Aspect<File, "file", Name, References, Props> {}
-
-export class FileProps extends S.Class<FileProps>("FileProps")({
-  language: S.String,
-}) {}
-
-export const File = defineAspect<
-  <const Name extends string, const Props extends FileProps>(
-    name: Name,
-    props: Props,
-  ) => <References extends any[]>(
-    template: TemplateStringsArray,
-    ...references: References
-  ) => File<Name, References, Props>
->("file", FileProps);

package/src/Agent/fs/folder.ts

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

package/src/Agent/index.ts

@@ -1,9 +0,0 @@
-export * from "./Agent.ts";
-export * from "./Aspect.ts";
-export * from "./AspectGraph.ts";
-export * from "./process/organization.ts";
-export * from "./process/process.ts";
-export * from "./tool/index.ts";
-
-export * as Coding from "./coding/index.ts";
-export * as LLM from "./llm/index.ts";