saeeol 1.0.8 → 1.1.0

package/src/tool/warpgrep.ts

@@ -1,107 +0,0 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import { WarpGrepClient } from "@morphllm/morphsdk/tools/warp-grep/client" 
-import { Telemetry } from "@saeeol/telemetry" 
-import { Instance } from "../project/instance"
-import { Bus } from "../bus"
-import { TuiEvent } from "../cli/cmd/tui/event"
-import DESCRIPTION from "./warpgrep.txt"
-
-// FREE_PERIOD_TODO: Remove SAEEOL_WARPGREP_PROXY_URL constant and the proxy
-// fallback below. After the free period ends, require MORPH_API_KEY and
-// return an error when it is missing.
-const SAEEOL_WARPGREP_PROXY_URL = "https://api.saeeol.ai/api/gateway"
-
-const Parameters = Schema.Struct({
-  query: Schema.String.annotate({
-    description: "Search query describing what code you are looking for. Be specific and descriptive for best results.", 
-  }),
-})
-
-export const CodebaseSearchTool = Tool.define(
-  "codebase_search",
-  Effect.gen(function* () {
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          yield* ctx.ask({
-            permission: "codebase_search",
-            patterns: [params.query],
-            always: ["*"],
-            metadata: { query: params.query },
-          })
-          Telemetry.trackToolUsed("codebase_search", ctx.sessionID) 
-
-          const apiKey = process.env["MORPH_API_KEY"]
-
-          // FREE_PERIOD_TODO: Remove proxy fallback — require apiKey, error if missing:
-          //   if (!apiKey) return { title: ..., output: "Set MORPH_API_KEY to use codebase search.", metadata: {} }
-          const client = new WarpGrepClient({
-            morphApiKey: apiKey ?? "saeeol-free",
-            ...(apiKey ? {} : { morphApiUrl: SAEEOL_WARPGREP_PROXY_URL }),
-            timeout: 60_000,
-          })
-
-          const result = yield* Effect.promise(() =>
-            client.execute({
-              searchTerm: params.query,
-              repoRoot: Instance.directory,
-            }),
-          )
-
-          if (!result.success || !result.contexts?.length) {
-            // FREE_PERIOD_TODO: When the proxy stops serving free requests, errors
-            // from the proxy (401/402/429) will surface here. The message below
-            // tells the user exactly what to do.
-            const isAuthOrRateLimit =
-              result.error && /401|402|429|rate.limit|free.period|unauthorized/i.test(result.error) 
-            const apiKeyMsg =
-              "Codebase search unavailable: free period ended. Set MORPH_API_KEY to continue. Get your key at https://www.morphllm.com/"
-            if (isAuthOrRateLimit) {
-              yield* Effect.promise(() =>
-                Bus.publish(TuiEvent.ToastShow, {
-                  title: "Codebase Search Unavailable",
-                  message: "Free period has ended. Set MORPH_API_KEY to continue. Get your key at morphllm.com",
-                  variant: "error",
-                  duration: 10000,
-                }).catch(() => {}),
-              )
-            }
-            return {
-              title: `Codebase Search: ${params.query}`,
-              output: isAuthOrRateLimit ? apiKeyMsg : (result.error ?? "No relevant code found."),
-              metadata: { count: 0 },
-            }
-          }
-
-          const MAX_OUTPUT_CHARS = 45_000
-          const fullOutput = result.contexts.map((c) => `### ${c.file}\n\`\`\`\n${c.content}\n\`\`\``).join("\n\n") 
-
-          let output: string
-          if (fullOutput.length > MAX_OUTPUT_CHARS) {
-            const summary = result.contexts
-              .map((c) => {
-                const lineInfo = !c.lines
-                  ? ""
-                  : c.lines === "*"
-                    ? " (full file)"
-                    : ` (lines ${c.lines.map((r) => r.join("-")).join(", ")})`
-                return `- ${c.file}${lineInfo}`
-              })
-              .join("\n")
-            output = `Results too large to show inline. Showing file paths and line ranges. Use Read tool to view specific files.\n\n${summary}`
-          } else {
-            output = fullOutput
-          }
-
-          return {
-            title: `Codebase Search: ${params.query}`,
-            output,
-            metadata: { count: result.contexts.length },
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/warpgrep.txt

@@ -1,10 +0,0 @@
-- Searches the codebase using a natural language search string
-- Takes a natural language search string as input: a question about something you want to understand, or a description of what you're looking for
-- This is not pattern matching or semantic search — it is an AI-powered search agent that performs intelligent multi-step searches across the repository, returning only the most relevant spans
-- Use this when you're looking for a feature or implementation, or trying to understand how something works in a large codebase but are unclear about the exact patterns to search for
-
-Usage notes:
-  - This does NOT accept regex or keyword dumps — use natural language
-  - Best practice is using this at the start of long codebase explorations when you haven't yet mapped out the relevant areas
-  - Firing two or three concurrent codebase_search calls at different angles helps go through a large codebase faster
-  - This tool is read-only and does not modify any files

package/src/tool/webfetch.ts

@@ -1,202 +0,0 @@
-import { Effect, Schema } from "effect"
-import { HttpClient, HttpClientRequest } from "effect/unstable/http"
-import * as Tool from "./tool"
-import TurndownService from "turndown"
-import DESCRIPTION from "./webfetch.txt"
-import { isImageAttachment } from "@/util/media"
-import { normalizeUrls } from "@/saeeol/util/url" 
-
-const MAX_RESPONSE_SIZE = 5 * 1024 * 1024 // 5MB
-const DEFAULT_TIMEOUT = 30 * 1000 // 30 seconds
-const MAX_TIMEOUT = 120 * 1000 // 2 minutes
-
-export const Parameters = Schema.Struct({
-  url: Schema.String.annotate({ description: "The URL to fetch content from" }),
-  format: Schema.Literals(["text", "markdown", "html"])
-    .pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed("markdown" as const)))
-    .annotate({
-      description: "The format to return the content in (text, markdown, or html). Defaults to markdown.",
-    }),
-  timeout: Schema.optional(Schema.Number).annotate({ description: "Optional timeout in seconds (max 120)" }),
-})
-
-export const WebFetchTool = Tool.define(
-  "webfetch",
-  Effect.gen(function* () {
-    const http = yield* HttpClient.HttpClient
-    const httpOk = HttpClient.filterStatusOk(http)
-
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          if (!params.url.startsWith("http://") && !params.url.startsWith("https://")) {
-            throw new Error("URL must start with http:// or https://")
-          }
-
-          const url = normalizeUrls(params.url) 
-
-          yield* ctx.ask({
-            permission: "webfetch",
-            patterns: [url], 
-            always: ["*"],
-            metadata: {
-              url, 
-              format: params.format,
-              timeout: params.timeout,
-            },
-          })
-
-          const timeout = Math.min((params.timeout ?? DEFAULT_TIMEOUT / 1000) * 1000, MAX_TIMEOUT)
-
-          // Build Accept header based on requested format with q parameters for fallbacks
-          let acceptHeader = "*/*"
-          switch (params.format) {
-            case "markdown":
-              acceptHeader = "text/markdown;q=1.0, text/x-markdown;q=0.9, text/plain;q=0.8, text/html;q=0.7, */*;q=0.1"
-              break
-            case "text":
-              acceptHeader = "text/plain;q=1.0, text/markdown;q=0.9, text/html;q=0.8, */*;q=0.1"
-              break
-            case "html":
-              acceptHeader =
-                "text/html;q=1.0, application/xhtml+xml;q=0.9, text/plain;q=0.8, text/markdown;q=0.7, */*;q=0.1"
-              break
-            default:
-              acceptHeader =
-                "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8"
-          }
-          const headers = {
-            "User-Agent":
-              "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
-            Accept: acceptHeader,
-            "Accept-Language": "en-US,en;q=0.9",
-          }
-
-          const request = HttpClientRequest.get(url).pipe(HttpClientRequest.setHeaders(headers)) 
-
-          // Retry with honest UA if blocked by Cloudflare bot detection (TLS fingerprint mismatch)
-          const response = yield* httpOk.execute(request).pipe(
-            Effect.catchIf(
-              (err) =>
-                err.reason._tag === "StatusCodeError" &&
-                err.reason.response.status === 403 &&
-                err.reason.response.headers["cf-mitigated"] === "challenge",
-              () =>
-                httpOk.execute(
-                  HttpClientRequest.get(url).pipe( 
-                    HttpClientRequest.setHeaders({ ...headers, "User-Agent": "saeeol" }), 
-                  ),
-                ),
-            ),
-            Effect.timeoutOrElse({ duration: timeout, orElse: () => Effect.die(new Error("Request timed out")) }),
-          )
-
-          // Check content length
-          const contentLength = response.headers["content-length"]
-          if (contentLength && parseInt(contentLength) > MAX_RESPONSE_SIZE) {
-            throw new Error("Response too large (exceeds 5MB limit)")
-          }
-
-          const arrayBuffer = yield* response.arrayBuffer
-          if (arrayBuffer.byteLength > MAX_RESPONSE_SIZE) {
-            throw new Error("Response too large (exceeds 5MB limit)")
-          }
-
-          const contentType = response.headers["content-type"] || ""
-          const mime = contentType.split(";")[0]?.trim().toLowerCase() || ""
-          const title = `${url} (${contentType})` 
-
-          if (isImageAttachment(mime)) {
-            const base64Content = Buffer.from(arrayBuffer).toString("base64")
-            return {
-              title,
-              output: "Image fetched successfully",
-              metadata: {},
-              attachments: [
-                {
-                  type: "file" as const,
-                  mime,
-                  url: `data:${mime};base64,${base64Content}`,
-                },
-              ],
-            }
-          }
-
-          const content = new TextDecoder().decode(arrayBuffer)
-
-          // Handle content based on requested format and actual content type
-          switch (params.format) {
-            case "markdown":
-              if (contentType.includes("text/html")) {
-                const markdown = convertHTMLToMarkdown(content)
-                return {
-                  output: markdown,
-                  title,
-                  metadata: {},
-                }
-              }
-              return { output: content, title, metadata: {} }
-
-            case "text":
-              if (contentType.includes("text/html")) {
-                const text = yield* Effect.promise(() => extractTextFromHTML(content))
-                return { output: text, title, metadata: {} }
-              }
-              return { output: content, title, metadata: {} }
-
-            case "html":
-              return { output: content, title, metadata: {} }
-
-            default:
-              return { output: content, title, metadata: {} }
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)
-
-async function extractTextFromHTML(html: string) {
-  let text = ""
-  let skipContent = false
-
-  const rewriter = new HTMLRewriter()
-    .on("script, style, noscript, iframe, object, embed", {
-      element() {
-        skipContent = true
-      },
-      text() {
-        // Skip text content inside these elements
-      },
-    })
-    .on("*", {
-      element(element) {
-        // Reset skip flag when entering other elements
-        if (!["script", "style", "noscript", "iframe", "object", "embed"].includes(element.tagName)) {
-          skipContent = false
-        }
-      },
-      text(input) {
-        if (!skipContent) {
-          text += input.text
-        }
-      },
-    })
-    .transform(new Response(html))
-
-  await rewriter.text()
-  return text.trim()
-}
-
-function convertHTMLToMarkdown(html: string): string {
-  const turndownService = new TurndownService({
-    headingStyle: "atx",
-    hr: "---",
-    bulletListMarker: "-",
-    codeBlockStyle: "fenced",
-    emDelimiter: "*",
-  })
-  turndownService.remove(["script", "style", "meta", "link"])
-  return turndownService.turndown(html)
-}

package/src/tool/webfetch.txt

@@ -1,13 +0,0 @@
-- Fetches content from a specified URL
-- Takes a URL and optional format as input
-- Fetches the URL content, converts to requested format (markdown by default)
-- Returns the content in the specified format
-- Use this tool when you need to retrieve and analyze web content
-
-Usage notes:
-  - IMPORTANT: if another tool is present that offers better web fetching capabilities, is more targeted to the task, or has fewer restrictions, prefer using that tool instead of this one.
-  - The URL must be a fully-formed valid URL
-  - HTTP URLs will be automatically upgraded to HTTPS
-  - Format options: "markdown" (default), "text", or "html"
-  - This tool is read-only and does not modify any files
-  - Results may be summarized if the content is very large

package/src/tool/websearch.ts

@@ -1,71 +0,0 @@
-import { Effect, Schema } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import * as Tool from "./tool"
-import * as McpExa from "./mcp-exa"
-import DESCRIPTION from "./websearch.txt"
-
-export const Parameters = Schema.Struct({
-  query: Schema.String.annotate({ description: "Websearch query" }),
-  numResults: Schema.optional(Schema.Number).annotate({
-    description: "Number of search results to return (default: 8)",
-  }),
-  livecrawl: Schema.optional(Schema.Literals(["fallback", "preferred"])).annotate({
-    description:
-      "Live crawl mode - 'fallback': use live crawling as backup if cached content unavailable, 'preferred': prioritize live crawling (default: 'fallback')",
-  }),
-  type: Schema.optional(Schema.Literals(["auto", "fast", "deep"])).annotate({
-    description: "Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search",
-  }),
-  contextMaxCharacters: Schema.optional(Schema.Number).annotate({
-    description: "Maximum characters for context string optimized for LLMs (default: 10000)",
-  }),
-})
-
-export const WebSearchTool = Tool.define(
-  "websearch",
-  Effect.gen(function* () {
-    const http = yield* HttpClient.HttpClient
-
-    return {
-      get description() {
-        return DESCRIPTION.replace("{{year}}", new Date().getFullYear().toString())
-      },
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          yield* ctx.ask({
-            permission: "websearch",
-            patterns: [params.query],
-            always: ["*"],
-            metadata: {
-              query: params.query,
-              numResults: params.numResults,
-              livecrawl: params.livecrawl,
-              type: params.type,
-              contextMaxCharacters: params.contextMaxCharacters,
-            },
-          })
-
-          const result = yield* McpExa.call(
-            http,
-            "web_search_exa",
-            McpExa.SearchArgs,
-            {
-              query: params.query,
-              type: params.type || "auto",
-              numResults: params.numResults || 8,
-              livecrawl: params.livecrawl || "fallback",
-              contextMaxCharacters: params.contextMaxCharacters,
-            },
-            "25 seconds",
-          )
-
-          return {
-            output: result ?? "No search results found. Please try a different query.",
-            title: `Web search: ${params.query}`,
-            metadata: {},
-          }
-        }).pipe(Effect.orDie),
-    }
-  }),
-)

package/src/tool/websearch.txt

@@ -1,14 +0,0 @@
-- Search the web using Exa AI - performs real-time web searches and can scrape content from specific URLs
-- Provides up-to-date information for current events and recent data
-- Supports configurable result counts and returns the content from the most relevant websites
-- Use this tool for accessing information beyond knowledge cutoff
-- Searches are performed automatically within a single API call
-
-Usage notes:
-  - Supports live crawling modes: 'fallback' (backup if cached unavailable) or 'preferred' (prioritize live crawling)
-  - Search types: 'auto' (balanced), 'fast' (quick results), 'deep' (comprehensive search)
-  - Configurable context length for optimal LLM integration
-  - Domain filtering and advanced search options available
-
-The current year is {{year}}. You MUST use this year when searching for recent information or current events
-- Example: If the current year is 2026 and the user asks for "latest AI news", search for "AI news 2026", NOT "AI news 2025"

package/src/tool/write.ts

@@ -1,114 +0,0 @@
-import { Schema } from "effect"
-import * as path from "path"
-import { Effect } from "effect"
-import * as Tool from "./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 "./external-directory"
-import { filterDiagnostics } from "./diagnostics" 
-import { ConfigValidation } from "../saeeol/config-validation" 
-import * as EncodedIO from "../saeeol/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/write.txt

@@ -1,8 +0,0 @@
-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/util/abort.ts

@@ -1 +0,0 @@
-export { cancelAfter as abortAfter, cancelAny as abortAfterAny } from "@saeeol/boxes/cancel"

package/src/util/archive.ts

@@ -1,17 +0,0 @@
-import path from "path"
-import * as Process from "./process"
-
-export async function extractZip(zipPath: string, destDir: string) {
-  if (process.platform === "win32") {
-    const winZipPath = path.resolve(zipPath)
-    const winDestDir = path.resolve(destDir)
-    // $global:ProgressPreference suppresses PowerShell's blue progress bar popup
-    const cmd = `$global:ProgressPreference = 'SilentlyContinue'; Expand-Archive -Path '${winZipPath}' -DestinationPath '${winDestDir}' -Force`
-    await Process.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd])
-    return
-  }
-
-  await Process.run(["unzip", "-o", "-q", zipPath, "-d", destDir])
-}
-
-export * as Archive from "./archive"

package/src/util/bom.ts

@@ -1,19 +0,0 @@
-export { split, join } from "@saeeol/boxes/bom"
-import { Effect } from "effect"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { split, join } from "@saeeol/boxes/bom"
-
-export const readFile = Effect.fn("Bom.readFile")(function* (fs: AppFileSystem.Interface, filePath: string) {
-  return split(new TextDecoder("utf-8", { ignoreBOM: true }).decode(yield* fs.readFile(filePath)))
-})
-
-export const syncFile = Effect.fn("Bom.syncFile")(function* (
-  fs: AppFileSystem.Interface,
-  filePath: string,
-  bom: boolean,
-) {
-  const current = yield* readFile(fs, filePath)
-  if (current.bom === bom) return current.text
-  yield* fs.writeWithDirs(filePath, join(current.text, bom))
-  return current.text
-})

package/src/util/color.ts

@@ -1,3 +0,0 @@
-export { valid as isValidHex, rgb as hexToRgb, bold as hexToAnsiBold } from "@saeeol/boxes/ansi"
-
-export * as Color from "./color"

package/src/util/data-url.ts

@@ -1 +0,0 @@
-export { decode as decodeDataUrl } from "@saeeol/boxes/dataurl"

package/src/util/defer.ts

@@ -1 +0,0 @@
-export { disposable as defer } from "@saeeol/boxes/disposable"

package/src/util/effect-http-client.ts

@@ -1,11 +0,0 @@
-import { Schedule } from "effect"
-import { HttpClient } from "effect/unstable/http"
-
-export const withTransientReadRetry = <E, R>(client: HttpClient.HttpClient.With<E, R>) =>
-  client.pipe(
-    HttpClient.retryTransient({
-      retryOn: "errors-and-responses",
-      times: 2,
-      schedule: Schedule.exponential(200).pipe(Schedule.jittered),
-    }),
-  )