saeeol 1.2.1 → 1.2.3

package/src/tool/file/write.ts

@@ -0,0 +1,114 @@
+import { Schema } from "effect"
+import * as path from "path"
+import { Effect } from "effect"
+import * as Tool from "../core/tool"
+import { LSP } from "@/lsp/lsp"
+import { createTwoFilesPatch } from "diff"
+import DESCRIPTION from "./write.txt"
+import { Bus } from "../../bus"
+import { File } from "../../file"
+import { FileWatcher } from "../../file/watcher"
+import { Format } from "../../format"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+import { InstanceState } from "@/effect/instance-state"
+import { trimDiff, buildFileDiff } from "./edit" 
+import { assertExternalDirectoryEffect } from "../core/external-directory"
+import { filterDiagnostics } from "../integration/diagnostics" 
+import { ConfigValidation } from "../../overlay/config-validation" 
+import * as EncodedIO from "../../overlay/tool/encoded-io" 
+import * as Bom from "@/util/bom"
+
+const MAX_PROJECT_DIAGNOSTICS_FILES = 5
+
+export const Parameters = Schema.Struct({
+  content: Schema.String.annotate({ description: "The content to write to the file" }),
+  filePath: Schema.String.annotate({
+    description: "The absolute path to the file to write (must be absolute, not relative)",
+  }),
+})
+
+export const WriteTool = Tool.define(
+  "write",
+  Effect.gen(function* () {
+    const lsp = yield* LSP.Service
+    const fs = yield* AppFileSystem.Service
+    const bus = yield* Bus.Service
+    const format = yield* Format.Service
+
+    return {
+      description: DESCRIPTION,
+      parameters: Parameters,
+      execute: (params: { content: string; filePath: string }, ctx: Tool.Context) =>
+        Effect.gen(function* () {
+          const instance = yield* InstanceState.context
+          const filepath = path.isAbsolute(params.filePath)
+            ? params.filePath
+            : path.join(instance.directory, params.filePath)
+          yield* assertExternalDirectoryEffect(ctx, filepath)
+
+          const exists = yield* fs.existsSafe(filepath)
+          // derive the BOM flag from the detected encoding label instead of the decoded text.
+          const pre = exists ? yield* EncodedIO.read(filepath) : { text: "", encoding: "utf-8" }
+          const source = { bom: pre.encoding === "utf-8-bom", text: pre.text, encoding: pre.encoding }
+          const next = Bom.split(params.content)
+          const desiredBom = source.bom || next.bom
+          const contentOld = source.text
+          const contentNew = next.text
+
+          const diff = trimDiff(createTwoFilesPatch(filepath, filepath, contentOld, contentNew))
+          const filediff = buildFileDiff(filepath, contentOld, contentNew) 
+          yield* ctx.ask({
+            permission: "edit",
+            patterns: [path.relative(instance.worktree, filepath)],
+            always: ["*"],
+            metadata: {
+              filepath,
+              diff,
+              filediff, 
+            },
+          })
+
+          yield* EncodedIO.write(filepath, Bom.join(contentNew, desiredBom), source.encoding) 
+          if (yield* format.file(filepath)) {
+            yield* Bom.syncFile(fs, filepath, desiredBom)
+          }
+          yield* bus.publish(File.Event.Edited, { file: filepath })
+          yield* bus.publish(FileWatcher.Event.Updated, {
+            file: filepath,
+            event: exists ? "change" : "add",
+          })
+
+          let output = "Wrote file successfully."
+          yield* lsp.touchFile(filepath, "document")
+          const diagnostics = yield* lsp.diagnostics()
+          const normalizedFilepath = AppFileSystem.normalizePath(filepath)
+          let projectDiagnosticsCount = 0
+          for (const [file, issues] of Object.entries(diagnostics)) {
+            const current = file === normalizedFilepath
+            if (!current && projectDiagnosticsCount >= MAX_PROJECT_DIAGNOSTICS_FILES) continue
+            const block = LSP.Diagnostic.report(current ? filepath : file, issues)
+            if (!block) continue
+            if (current) {
+              output += `\n\nLSP errors detected in this file, please fix:\n${block}`
+              continue
+            }
+            projectDiagnosticsCount++
+            output += `\n\nLSP errors detected in other files:\n${block}`
+          }
+          output += yield* Effect.promise(() => ConfigValidation.check(filepath)) 
+
+          return {
+            title: path.relative(instance.worktree, filepath),
+            metadata: {
+              diagnostics: filterDiagnostics(diagnostics, [normalizedFilepath]), 
+              filepath,
+              exists: exists,
+              diff, 
+              filediff, 
+            },
+            output,
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/file/write.txt

@@ -0,0 +1,8 @@
+Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.

package/src/tool/glob.ts

@@ -1,115 +1 @@
-import path from "path"
-import { Effect, Option, Schema } from "effect"
-import * as Stream from "effect/Stream"
-import { InstanceState } from "@/effect/instance-state"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Ripgrep } from "../file/ripgrep"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import DESCRIPTION from "./glob.txt"
-import * as Tool from "./tool"
-function normalize(p: string) {
-  return p.replaceAll("\\", "/")
-}
-
-function split(pattern: string) {
-  const normalized = normalize(pattern)
-  if (!path.isAbsolute(normalized)) return
-  const index = normalized.search(/[*?{[]/)
-  if (index === -1) return { dir: normalized, pattern: "*" }
-  const slice = normalized.slice(0, index)
-  const cut = slice.lastIndexOf("/")
-  const dir = cut > 0 ? slice.slice(0, cut) : "/"
-  const next = normalized.slice(cut + 1)
-  return { dir, pattern: next || "*" }
-}
-
-export const Parameters = Schema.Struct({
-  pattern: Schema.String.annotate({ description: "The glob pattern to match files against" }),
-  path: Schema.optional(Schema.String).annotate({
-    description: `The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.`,
-  }),
-})
-
-export const GlobTool = Tool.define(
-  "glob",
-  Effect.gen(function* () {
-    const rg = yield* Ripgrep.Service
-    const fs = yield* AppFileSystem.Service
-
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: { pattern: string; path?: string }, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const ins = yield* InstanceState.context
-          const absolute = split(params.pattern) 
-          yield* ctx.ask({
-            permission: "glob",
-            patterns: [params.pattern],
-            always: ["*"],
-            metadata: {
-              pattern: params.pattern,
-              path: params.path,
-            },
-          })
-
-          const base = absolute?.dir ?? params.path ?? ins.directory 
-          const search = path.isAbsolute(base) ? base : path.resolve(ins.directory, base)
-          const info = yield* fs.stat(search).pipe(Effect.catch(() => Effect.succeed(undefined)))
-          if (info?.type === "File") {
-            throw new Error(`glob path must be a directory: ${search}`)
-          }
-          yield* assertExternalDirectoryEffect(ctx, search, { kind: "directory" })
-
-          const limit = 100
-          let truncated = false
-          const files = yield* rg
-            .files({ cwd: search, glob: [absolute?.pattern ?? params.pattern], signal: ctx.abort }) 
-            .pipe(
-              Stream.mapEffect((file) =>
-                Effect.gen(function* () {
-                  const full = path.resolve(search, file)
-                  const info = yield* fs.stat(full).pipe(Effect.catch(() => Effect.succeed(undefined)))
-                  const mtime =
-                    info?.mtime.pipe(
-                      Option.map((date) => date.getTime()),
-                      Option.getOrElse(() => 0),
-                    ) ?? 0
-                  return { path: full, mtime }
-                }),
-              ),
-              Stream.take(limit + 1),
-              Stream.runCollect,
-              Effect.map((chunk) => [...chunk]),
-            )
-
-          if (files.length > limit) {
-            truncated = true
-            files.length = limit
-          }
-          files.sort((a, b) => b.mtime - a.mtime)
-
-          const output = []
-          if (files.length === 0) output.push("No files found")
-          if (files.length > 0) {
-            output.push(...files.map((file) => file.path))
-            if (truncated) {
-              output.push("")
-              output.push(
-                `(Results are truncated: showing first ${limit} results. Consider using a more specific path or pattern.)`,
-              )
-            }
-          }
-
-          return {
-            title: path.relative(ins.worktree, search),
-            metadata: {
-              count: files.length,
-              truncated,
-            },
-            output: output.join("\n"),
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)
+export * from "./search/glob"

package/src/tool/grep.ts

@@ -1,151 +1 @@
-import path from "path"
-import { Schema } from "effect"
-import { Effect, Option } from "effect"
-import { InstanceState } from "@/effect/instance-state"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Ripgrep } from "../file/ripgrep"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import DESCRIPTION from "./grep.txt"
-import * as Tool from "./tool"
-
-const MAX_LINE_LENGTH = 2000
-
-export const Parameters = Schema.Struct({
-  pattern: Schema.String.annotate({ description: "The regex pattern to search for in file contents" }),
-  path: Schema.optional(Schema.String).annotate({
-    description: "The directory to search in. Defaults to the current working directory.",
-  }),
-  include: Schema.optional(Schema.String).annotate({
-    description: 'File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")',
-  }),
-})
-
-export const GrepTool = Tool.define(
-  "grep",
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-    const rg = yield* Ripgrep.Service
-
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: { pattern: string; path?: string; include?: string }, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          const empty = {
-            title: params.pattern,
-            metadata: { matches: 0, truncated: false },
-            output: "No files found",
-          }
-          if (!params.pattern) {
-            throw new Error("pattern is required")
-          }
-
-          yield* ctx.ask({
-            permission: "grep",
-            patterns: [params.pattern],
-            always: ["*"],
-            metadata: {
-              pattern: params.pattern,
-              path: params.path,
-              include: params.include,
-            },
-          })
-
-          const ins = yield* InstanceState.context
-          const search = AppFileSystem.resolve(
-            path.isAbsolute(params.path ?? ins.directory)
-              ? (params.path ?? ins.directory)
-              : path.join(ins.directory, params.path ?? "."),
-          )
-          const info = yield* fs.stat(search).pipe(Effect.catch(() => Effect.succeed(undefined)))
-          const cwd = info?.type === "Directory" ? search : path.dirname(search)
-          const file = info?.type === "Directory" ? undefined : [path.relative(cwd, search)]
-          yield* assertExternalDirectoryEffect(ctx, search, {
-            kind: info?.type === "Directory" ? "directory" : "file",
-          })
-
-          const result = yield* rg.search({
-            cwd,
-            pattern: params.pattern,
-            glob: params.include ? [params.include] : undefined,
-            file,
-            signal: ctx.abort,
-          })
-          if (result.items.length === 0) return empty
-
-          const rows = result.items.map((item) => ({
-            path: AppFileSystem.resolve(
-              path.isAbsolute(item.path.text) ? item.path.text : path.join(cwd, item.path.text),
-            ),
-            line: item.line_number,
-            text: item.lines.text,
-          }))
-          const times = new Map(
-            (yield* Effect.forEach(
-              [...new Set(rows.map((row) => row.path))],
-              Effect.fnUntraced(function* (file) {
-                const info = yield* fs.stat(file).pipe(Effect.catch(() => Effect.succeed(undefined)))
-                if (!info || info.type === "Directory") return undefined
-                return [
-                  file,
-                  info.mtime.pipe(
-                    Option.map((time) => time.getTime()),
-                    Option.getOrElse(() => 0),
-                  ) ?? 0,
-                ] as const
-              }),
-              { concurrency: 16 },
-            )).filter((entry): entry is readonly [string, number] => Boolean(entry)),
-          )
-          const matches = rows.flatMap((row) => {
-            const mtime = times.get(row.path)
-            if (mtime === undefined) return []
-            return [{ ...row, mtime }]
-          })
-
-          matches.sort((a, b) => b.mtime - a.mtime)
-
-          const limit = 100
-          const truncated = matches.length > limit
-          const final = truncated ? matches.slice(0, limit) : matches
-          if (final.length === 0) return empty
-
-          const total = matches.length
-          const output = [`Found ${total} matches${truncated ? ` (showing first ${limit})` : ""}`]
-
-          let current = ""
-          for (const match of final) {
-            if (current !== match.path) {
-              if (current !== "") output.push("")
-              current = match.path
-              output.push(`${match.path}:`)
-            }
-            const text =
-              match.text.length > MAX_LINE_LENGTH ? match.text.substring(0, MAX_LINE_LENGTH) + "..." : match.text
-            output.push(`  Line ${match.line}: ${text}`)
-          }
-
-          if (truncated) {
-            output.push("")
-            output.push(
-              `(Results truncated: showing ${limit} of ${total} matches (${total - limit} hidden). Consider using a more specific path or pattern.)`,
-            )
-          }
-
-          if (result.partial) {
-            output.push("")
-            output.push("(Some paths were inaccessible and skipped)")
-          }
-
-          return {
-            title: params.pattern,
-            metadata: {
-              matches: total,
-              truncated,
-            },
-            output: output.join("\n"),
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)
+export * from "./search/grep"

package/src/tool/integration/diagnostics.ts

@@ -0,0 +1,20 @@
+import type { LSPClient } from "@/lsp/client"
+
+/**
+ * Filter diagnostics to only include entries for the specified files.
+ * Tools like edit, write, and apply_patch receive diagnostics for ALL project files
+ * from the LSP, but only the edited files' diagnostics are relevant for storage
+ * and display. Storing all files' diagnostics bloats session payloads significantly
+ * (100KB+ per tool call in large projects).
+ */
+export function filterDiagnostics(
+  diagnostics: Record<string, LSPClient.Diagnostic[]>,
+  files: string[],
+): Record<string, LSPClient.Diagnostic[]> {
+  const result: Record<string, LSPClient.Diagnostic[]> = {}
+  for (const file of files) {
+    const items = diagnostics[file]
+    if (items) result[file] = items
+  }
+  return result
+}

package/src/tool/integration/lsp.ts

@@ -0,0 +1,113 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "../core/tool"
+import path from "path"
+import { LSP } from "@/lsp/lsp"
+import DESCRIPTION from "./lsp.txt"
+import { InstanceState } from "@/effect/instance-state"
+import { pathToFileURL } from "url"
+import { assertExternalDirectoryEffect } from "../core/external-directory"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+
+const operations = [
+  "goToDefinition",
+  "findReferences",
+  "hover",
+  "documentSymbol",
+  "workspaceSymbol",
+  "goToImplementation",
+  "prepareCallHierarchy",
+  "incomingCalls",
+  "outgoingCalls",
+] as const
+
+export const Parameters = Schema.Struct({
+  operation: Schema.Literals(operations).annotate({ description: "The LSP operation to perform" }),
+  filePath: Schema.String.annotate({ description: "The absolute or relative path to the file" }),
+  line: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).annotate({
+    description: "The line number (1-based, as shown in editors)",
+  }),
+  character: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).annotate({
+    description: "The character offset (1-based, as shown in editors)",
+  }),
+  query: Schema.optional(Schema.String).annotate({
+    description: "Search query for workspaceSymbol. Empty string requests all symbols.",
+  }),
+})
+
+export const LspTool = Tool.define(
+  "lsp",
+  Effect.gen(function* () {
+    const lsp = yield* LSP.Service
+    const fs = yield* AppFileSystem.Service
+    return {
+      description: DESCRIPTION,
+      parameters: Parameters,
+      execute: (args: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
+        Effect.gen(function* () {
+          const instance = yield* InstanceState.context
+          const file = path.isAbsolute(args.filePath) ? args.filePath : path.join(instance.directory, args.filePath)
+          yield* assertExternalDirectoryEffect(ctx, file)
+          const meta =
+            args.operation === "workspaceSymbol"
+              ? { operation: args.operation }
+              : args.operation === "documentSymbol"
+                ? { operation: args.operation, filePath: file }
+                : { operation: args.operation, filePath: file, line: args.line, character: args.character }
+          yield* ctx.ask({
+            permission: "lsp",
+            patterns: ["*"],
+            always: ["*"],
+            metadata: meta,
+          })
+
+          const uri = pathToFileURL(file).href
+          const position = { file, line: args.line - 1, character: args.character - 1 }
+          const relPath = path.relative(instance.worktree, file)
+          const detail =
+            args.operation === "workspaceSymbol"
+              ? ""
+              : args.operation === "documentSymbol"
+                ? relPath
+                : `${relPath}:${args.line}:${args.character}`
+          const title = detail ? `${args.operation} ${detail}` : args.operation
+
+          const exists = yield* fs.existsSafe(file)
+          if (!exists) throw new Error(`File not found: ${file}`)
+
+          const available = yield* lsp.hasClients(file)
+          if (!available) throw new Error("No LSP server available for this file type.")
+
+          yield* lsp.touchFile(file, "document")
+
+          const result: unknown[] = yield* (() => {
+            switch (args.operation) {
+              case "goToDefinition":
+                return lsp.definition(position)
+              case "findReferences":
+                return lsp.references(position)
+              case "hover":
+                return lsp.hover(position)
+              case "documentSymbol":
+                return lsp.documentSymbol(uri)
+              case "workspaceSymbol":
+                return lsp.workspaceSymbol(args.query ?? "")
+              case "goToImplementation":
+                return lsp.implementation(position)
+              case "prepareCallHierarchy":
+                return lsp.prepareCallHierarchy(position)
+              case "incomingCalls":
+                return lsp.incomingCalls(position)
+              case "outgoingCalls":
+                return lsp.outgoingCalls(position)
+            }
+          })()
+
+          return {
+            title,
+            metadata: { result },
+            output: result.length === 0 ? `No results found for ${args.operation}` : JSON.stringify(result, null, 2),
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/integration/lsp.txt

@@ -0,0 +1,24 @@
+Interact with Language Server Protocol (LSP) servers to get code intelligence features.
+
+Supported operations:
+- goToDefinition: Find where a symbol is defined
+- findReferences: Find all references to a symbol
+- hover: Get hover information (documentation, type info) for a symbol
+- documentSymbol: Get all symbols (functions, classes, variables) in a document
+- workspaceSymbol: List project-wide symbols matching a query string
+- goToImplementation: Find implementations of an interface or abstract method
+- prepareCallHierarchy: Get call hierarchy item at a position (functions/methods)
+- incomingCalls: Find all functions/methods that call the function at a position
+- outgoingCalls: Find all functions/methods called by the function at a position
+
+All operations require:
+- filePath: The file to operate on
+- line: The line number (1-based, as shown in editors)
+- character: The character offset (1-based, as shown in editors)
+
+workspaceSymbol also accepts:
+- query: A query string to filter symbols by. Empty string requests all symbols.
+
+For workspaceSymbol, filePath is not sent in the LSP workspace/symbol request. It is used by saeeol to select and start the matching LSP server.
+
+Note: LSP servers must be configured for the file type. If no server is available, an error will be returned.

package/src/tool/integration/mcp-exa.ts

@@ -0,0 +1,73 @@
+import { Duration, Effect, Schema } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+
+const URL = process.env.EXA_API_KEY
+  ? `https://mcp.exa.ai/mcp?exaApiKey=${encodeURIComponent(process.env.EXA_API_KEY)}`
+  : "https://mcp.exa.ai/mcp"
+
+const McpResult = Schema.Struct({
+  result: Schema.Struct({
+    content: Schema.Array(
+      Schema.Struct({
+        type: Schema.String,
+        text: Schema.String,
+      }),
+    ),
+  }),
+})
+
+const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(McpResult))
+
+const parseSse = Effect.fn("McpExa.parseSse")(function* (body: string) {
+  for (const line of body.split("\n")) {
+    if (!line.startsWith("data: ")) continue
+    const data = yield* decode(line.substring(6))
+    if (data.result.content[0]?.text) return data.result.content[0].text
+  }
+  return undefined
+})
+
+export const SearchArgs = Schema.Struct({
+  query: Schema.String,
+  type: Schema.String,
+  numResults: Schema.Number,
+  livecrawl: Schema.String,
+  contextMaxCharacters: Schema.optional(Schema.Number),
+})
+
+const McpRequest = <F extends Schema.Struct.Fields>(args: Schema.Struct<F>) =>
+  Schema.Struct({
+    jsonrpc: Schema.Literal("2.0"),
+    id: Schema.Literal(1),
+    method: Schema.Literal("tools/call"),
+    params: Schema.Struct({
+      name: Schema.String,
+      arguments: args,
+    }),
+  })
+
+export const call = <F extends Schema.Struct.Fields>(
+  http: HttpClient.HttpClient,
+  tool: string,
+  args: Schema.Struct<F>,
+  value: Schema.Struct.Type<F>,
+  timeout: Duration.Input,
+) =>
+  Effect.gen(function* () {
+    const request = yield* HttpClientRequest.post(URL).pipe(
+      HttpClientRequest.accept("application/json, text/event-stream"),
+      HttpClientRequest.schemaBodyJson(McpRequest(args))({
+        jsonrpc: "2.0" as const,
+        id: 1 as const,
+        method: "tools/call" as const,
+        params: { name: tool, arguments: value },
+      }),
+    )
+    const response = yield* HttpClient.filterStatusOk(http)
+      .execute(request)
+      .pipe(
+        Effect.timeoutOrElse({ duration: timeout, orElse: () => Effect.die(new Error(`${tool} request timed out`)) }),
+      )
+    const body = yield* response.text
+    return yield* parseSse(body)
+  })