alchemy-effect 0.5.0 → 0.6.2

package/src/Agent/coding/edit.ts

@@ -0,0 +1,152 @@
+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 {
+  formatDiagnostics,
+  getDiagnosticsIfAvailable,
+} from "../lsp/diagnostics.ts";
+import { Tool } from "../tool/tool.ts";
+import { replace } from "../util/replace.ts";
+
+export class filePath extends Tool.input(
+  "filePath",
+)`The absolute path to the file to modify` {}
+
+export class oldString extends Tool.input(
+  "oldString",
+)`The text to replace. Use an empty string "" to create a new file.` {}
+
+export class newString extends Tool.input(
+  "newString",
+)`The text to replace it with (must be different from oldString)` {}
+
+export class replaceAll extends Tool.input(
+  "replaceAll",
+  S.Boolean,
+)`Replace all occurrences of oldString (default false). Use this when renaming variables or updating repeated patterns.` {}
+
+export class output extends Tool.output(
+  "result",
+)`The result of the edit operation, including any diagnostics from LSP.` {}
+
+export class edit extends Tool(
+  "edit",
+)`Performs exact string replacements in files.
+Returns the ${output} of the operation.
+
+Given a ${filePath}, ${oldString}, and ${newString}:
+- Replaces the first occurrence of ${oldString} with ${newString}
+- Use ${replaceAll} to replace all occurrences (defaults to false)
+- Use empty ${oldString} ("") to create a new file with ${newString} as content
+`(function* ({
+  filePath: _filePath,
+  oldString,
+  newString,
+  replaceAll: doReplaceAll,
+}) {
+  const config = yield* Effect.serviceOption(AspectConfig).pipe(
+    Effect.map(Option.getOrElse(() => ({ cwd: process.cwd() }))),
+  );
+  const pathService = yield* Path.Path;
+  const fs = yield* FileSystem.FileSystem;
+
+  const filePath = pathService.isAbsolute(_filePath)
+    ? _filePath
+    : pathService.join(config.cwd, _filePath);
+
+  // Determine new content and whether this is a create operation
+  let newContent: string;
+
+  if (oldString === "") {
+    // Create new file
+    newContent = newString;
+  } else {
+    // Edit existing file - validate it exists
+    const stat = yield* fs
+      .stat(filePath)
+      .pipe(Effect.catch(() => Effect.succeed(null)));
+
+    if (!stat) {
+      return { result: `File not found: ${filePath}` };
+    }
+    if (stat.type === "Directory") {
+      return { result: `Path is a directory, not a file: ${filePath}` };
+    }
+
+    // Read existing content
+    const oldContent = yield* fs
+      .readFileString(filePath)
+      .pipe(Effect.catch((e) => Effect.succeed(`Failed to read file: ${e}`)));
+    if (oldContent.startsWith("Failed to read")) {
+      return { result: oldContent };
+    }
+
+    // Perform replacement
+    const replaceResult = yield* replace(
+      oldContent,
+      oldString,
+      newString,
+      doReplaceAll ?? false,
+    ).pipe(
+      Effect.catchTag("ReplaceSameStringError", () =>
+        Effect.succeed("oldString and newString must be different"),
+      ),
+      Effect.catchTag("ReplaceNotFoundError", (e) =>
+        Effect.succeed(
+          `Could not find oldString in file. The text "${e.oldString.slice(0, 100)}${e.oldString.length > 100 ? "..." : ""}" was not found in ${filePath}.`,
+        ),
+      ),
+      Effect.catchTag("ReplaceMultipleMatchesError", (e) =>
+        Effect.succeed(
+          `Found multiple matches for oldString "${e.oldString.slice(0, 50)}${e.oldString.length > 50 ? "..." : ""}". Provide more surrounding context to identify the correct match, or use replaceAll=true to replace all occurrences.`,
+        ),
+      ),
+    );
+
+    // Check for replace errors
+    if (
+      replaceResult.startsWith("Could not find") ||
+      replaceResult.startsWith("Found multiple") ||
+      replaceResult.startsWith("oldString and newString")
+    ) {
+      yield* Effect.logDebug(`[edit] ${replaceResult}`);
+      return { result: replaceResult };
+    }
+    newContent = replaceResult;
+  }
+
+  const isCreate = oldString === "";
+
+  // Write file
+  const writeResult = yield* fs
+    .writeFileString(filePath, newContent)
+    .pipe(
+      Effect.catch((e) =>
+        Effect.succeed(
+          `Failed to ${isCreate ? "create" : "write"} file: ${e.message}`,
+        ),
+      ),
+    );
+  if (typeof writeResult === "string") {
+    yield* Effect.logDebug(`[edit] ${writeResult}`);
+    return { result: writeResult };
+  }
+
+  // Get diagnostics from LSP servers
+  const diagnostics = yield* getDiagnosticsIfAvailable(filePath, newContent);
+  const formatted = formatDiagnostics(diagnostics);
+
+  yield* Effect.logDebug(
+    `[edit] diagnostics for ${filePath}: ${formatted || "(none)"}`,
+  );
+
+  const action = isCreate ? "Created" : "Edited";
+  return {
+    result: formatted
+      ? `${action} file: ${filePath}\n\n${formatted}`
+      : `${action} file: ${filePath}`,
+  };
+}) {}

package/src/Agent/coding/glob.ts

@@ -0,0 +1,97 @@
+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 { cwd } from "../../Config.ts";
+import { AspectConfig } from "../Aspect.ts";
+import { Tool } from "../tool/tool.ts";
+import * as Ripgrep from "../util/ripgrep.ts";
+
+export class pattern extends Tool.input(
+  "pattern",
+)`The glob pattern to match files against.
+Patterns not starting with "**/" are automatically prepended with "**/" to enable recursive searching.
+
+Examples:
+  - "*.js" (becomes "**/*.js") - find all .js files
+  - "**/node_modules/**" - find all node_modules directories
+  - "**/test/**/test_*.ts" - find all test_*.ts files in any test directory` {}
+
+export class path extends Tool.input(
+  "path",
+  S.optional(S.String),
+)`The directory to search in. Defaults to ${cwd} if not specified.` {}
+
+export class files extends Tool.output(
+  "files",
+)`The list of matching file paths, sorted by modification time (most recent first). Returns a message if no files are found.` {}
+
+export class glob extends Tool(
+  "glob",
+)`Fast file pattern matching tool that works with any codebase size.
+Returns matching ${files} sorted by modification time.
+
+Given a ${pattern} and optional ${path}:
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
+- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.
+`(function* ({ pattern, path: searchDir }) {
+  yield* Effect.logDebug(`[glob] pattern=${pattern} path=${searchDir}`);
+
+  const config = yield* Effect.serviceOption(AspectConfig).pipe(
+    Effect.map(Option.getOrElse(() => ({ cwd: process.cwd() }))),
+  );
+  const pathService = yield* Path.Path;
+  const fs = yield* FileSystem.FileSystem;
+
+  let searchPath = searchDir || config.cwd;
+  searchPath = pathService.isAbsolute(searchPath)
+    ? searchPath
+    : pathService.resolve(config.cwd, searchPath);
+
+  const fileList: { path: string; mtime: number }[] = [];
+  const limit = 100;
+  let truncated = false;
+
+  const foundFiles = yield* Ripgrep.findFiles({
+    cwd: searchPath,
+    glob: [pattern],
+  }).pipe(Effect.catch(() => Effect.succeed([] as string[])));
+
+  for (const filePath of foundFiles) {
+    if (fileList.length >= limit) {
+      truncated = true;
+      break;
+    }
+    const stats = yield* fs
+      .stat(filePath)
+      .pipe(Effect.catch(() => Effect.succeed(null)));
+    if (!stats) continue;
+    fileList.push({
+      path: filePath,
+      mtime: stats.mtime.pipe(Option.getOrElse(() => new Date(0))).getTime(),
+    });
+  }
+
+  fileList.sort((a, b) => b.mtime - a.mtime);
+  const output = fileList.map((f) => f.path);
+
+  if (output.length === 0) {
+    return {
+      files: `No files found matching pattern "${pattern}" in ${searchPath}`,
+    };
+  }
+
+  if (truncated) {
+    return {
+      files: `${output.join("\n")}\n\n(${output.length} files found. Results are truncated, consider using a more specific pattern.)`,
+    };
+  }
+
+  return {
+    files: output.join("\n"),
+  };
+}) {}

package/src/Agent/coding/grep.ts

@@ -0,0 +1,144 @@
+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 { cwd } from "../../Config.ts";
+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

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

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

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

@@ -0,0 +1,79 @@
+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}`,
+  };
+}) {}