saeeol 1.2.0 → 1.2.2

package/src/tool/read.ts

@@ -1,389 +1 @@
-import { lstat } from "fs/promises" 
-import { Effect, Option, Schema, Scope } from "effect"
-import { NonNegativeInt } from "@/util/schema"
-import * as path from "path"
-import type { Readable } from "stream" 
-import { createInterface } from "readline"
-import * as Tool from "./tool"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { LSP } from "@/lsp/lsp"
-import DESCRIPTION from "./read.txt"
-import { InstanceState } from "@/effect/instance-state"
-import { assertExternalDirectoryEffect } from "./external-directory"
-import { Instruction } from "../session/instruction"
-import { isPdfAttachment, sniffAttachmentMime } from "@/util/media"
-import * as Encoding from "../overlay/encoding"
-import * as TextStream from "../overlay/text-stream"
-
-const DEFAULT_READ_LIMIT = 2000
-const MAX_LINE_LENGTH = 2000
-const MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`
-const MAX_BYTES = 50 * 1024
-const MAX_BYTES_LABEL = `${MAX_BYTES / 1024} KB`
-const SAMPLE_BYTES = 4096
-const DIRECTORY_CONCURRENCY = 8 
-const SUPPORTED_IMAGE_MIMES = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"])
-
-// `offset` and `limit` were originally `z.coerce.number()` — the runtime
-// coercion was useful when the tool was called from a shell but serves no
-// purpose in the LLM tool-call path (the model emits typed JSON). The JSON
-// Schema output is identical (`type: "number"`), so the LLM view is
-// unchanged; purely CLI-facing uses must now send numbers rather than strings.
-export const Parameters = Schema.Struct({
-  filePath: Schema.String.annotate({ description: "The absolute path to the file or directory to read" }),
-  offset: Schema.optional(NonNegativeInt).annotate({
-    description: "The line number to start reading from (1-indexed)",
-  }),
-  limit: Schema.optional(NonNegativeInt).annotate({
-    description: "The maximum number of lines to read (defaults to 2000)",
-  }),
-})
-
-export const ReadTool = Tool.define(
-  "read",
-  Effect.gen(function* () {
-    const fs = yield* AppFileSystem.Service
-    const instruction = yield* Instruction.Service
-    const lsp = yield* LSP.Service
-    const scope = yield* Scope.Scope
-
-    const miss = Effect.fn("ReadTool.miss")(function* (filepath: string) {
-      const dir = path.dirname(filepath)
-      const base = path.basename(filepath)
-      const items = yield* fs.readDirectory(dir).pipe(
-        Effect.map((items) =>
-          items
-            .filter(
-              (item) =>
-                item.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(item.toLowerCase()),
-            )
-            .map((item) => path.join(dir, item))
-            .slice(0, 3),
-        ),
-        Effect.catch(() => Effect.succeed([] as string[])),
-      )
-
-      if (items.length > 0) {
-        return yield* Effect.fail(
-          new Error(`File not found: ${filepath}\n\nDid you mean one of these?\n${items.join("\n")}`),
-        )
-      }
-
-      return yield* Effect.fail(new Error(`File not found: ${filepath}`))
-    })
-
-    const list = Effect.fn("ReadTool.list")(function* (filepath: string) {
-      const items = yield* fs.readDirectoryEntries(filepath)
-      return yield* Effect.forEach(
-        items,
-        Effect.fnUntraced(function* (item) {
-          if (item.type === "directory") return item.name + "/"
-          if (item.type !== "symlink") return item.name
-
-          const target = yield* fs.stat(path.join(filepath, item.name)).pipe(Effect.catch(() => Effect.void))
-          if (target?.type === "Directory") return item.name + "/"
-          return item.name
-        }),
-        { concurrency: "unbounded" },
-      ).pipe(Effect.map((items: string[]) => items.sort((a, b) => a.localeCompare(b))))
-    })
-
-    const warm = Effect.fn("ReadTool.warm")(function* (filepath: string) {
-      yield* lsp.touchFile(filepath).pipe(Effect.ignore, Effect.forkIn(scope))
-    })
-
-    const readSample = Effect.fn("ReadTool.readSample")(function* (
-      filepath: string,
-      fileSize: number,
-      sampleSize: number,
-    ) {
-      if (fileSize === 0) return new Uint8Array()
-
-      return yield* Effect.scoped(
-        Effect.gen(function* () {
-          const file = yield* fs.open(filepath, { flag: "r" })
-          return Option.getOrElse(yield* file.readAlloc(Math.min(sampleSize, fileSize)), () => new Uint8Array())
-        }),
-      )
-    })
-
-    const isBinaryFile = (filepath: string, bytes: Uint8Array) => {
-      const ext = path.extname(filepath).toLowerCase()
-      switch (ext) {
-        case ".zip":
-        case ".tar":
-        case ".gz":
-        case ".exe":
-        case ".dll":
-        case ".so":
-        case ".class":
-        case ".jar":
-        case ".war":
-        case ".7z":
-        case ".doc":
-        case ".docx":
-        case ".xls":
-        case ".xlsx":
-        case ".ppt":
-        case ".pptx":
-        case ".odt":
-        case ".ods":
-        case ".odp":
-        case ".bin":
-        case ".dat":
-        case ".obj":
-        case ".o":
-        case ".a":
-        case ".lib":
-        case ".wasm":
-        case ".pyc":
-        case ".pyo":
-          return true
-      }
-
-      if (bytes.length === 0) return false
-      const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)
-      if (Encoding.hasUtf16Bom(buf, bytes.length) || Encoding.hasUtf32Bom(buf, bytes.length)) return false
-
-      let nonPrintableCount = 0
-      for (let i = 0; i < bytes.length; i++) {
-        if (bytes[i] === 0) return true
-        if (bytes[i] < 9 || (bytes[i] > 13 && bytes[i] < 32)) {
-          nonPrintableCount++
-        }
-      }
-
-      return nonPrintableCount / bytes.length > 0.3
-    }
-    type DirectoryFile = {
-      filepath: string
-      content: string
-    }
-    const readDirectoryFiles = Effect.fn("ReadTool.readDirectoryFiles")(function* (
-      filepath: string,
-      items: string[],
-      directory: string,
-    ) {
-      const entries = yield* fs.readDirectoryEntries(filepath).pipe(Effect.catch(() => Effect.succeed([])))
-      const types = new Map(entries.map((entry) => [entry.name, entry.type]))
-      const files = yield* Effect.forEach(
-        items.filter((item) => !item.endsWith("/") && types.get(item) === "file"),
-        Effect.fnUntraced(function* (item) {
-          const child = path.join(filepath, item)
-          const info = yield* Effect.promise(() => lstat(child)).pipe(Effect.catch(() => Effect.void))
-          if (!info?.isFile()) return
-          const sample = yield* readSample(child, Number(info.size), SAMPLE_BYTES).pipe(
-            Effect.catch(() => Effect.succeed(new Uint8Array())),
-          )
-          if (isBinaryFile(child, sample)) return
-          const file = yield* Effect.promise(() => lines(child, { limit: DEFAULT_READ_LIMIT, offset: 1 })).pipe(
-            Effect.catch(() => Effect.void),
-          )
-          if (!file) return
-          const rel = path.relative(directory, child).replaceAll("\\", "/")
-          const note = file.cut || file.more ? "\n\n(File truncated)" : ""
-          return {
-            filepath: child,
-            content: `<file_content path="${rel}">\n${file.raw.join("\n")}${note}\n</file_content>`,
-          }
-        }),
-        { concurrency: DIRECTORY_CONCURRENCY },
-      )
-      return files.filter((item): item is DirectoryFile => item !== undefined)
-    })
-
-    const run = Effect.fn("ReadTool.execute")(function* (
-      params: Schema.Schema.Type<typeof Parameters>,
-      ctx: Tool.Context,
-    ) {
-      const instance = yield* InstanceState.context
-      let filepath = params.filePath
-      if (!path.isAbsolute(filepath)) {
-        filepath = path.resolve(instance.directory, filepath)
-      }
-      if (process.platform === "win32") {
-        filepath = AppFileSystem.normalizePath(filepath)
-      }
-      const title = path.relative(instance.worktree, filepath)
-
-      const stat = yield* fs.stat(filepath).pipe(
-        Effect.catchIf(
-          (err) => "reason" in err && err.reason._tag === "NotFound",
-          () => Effect.succeed(undefined),
-        ),
-      )
-
-      yield* assertExternalDirectoryEffect(ctx, filepath, {
-        bypass: Boolean(ctx.extra?.["bypassCwdCheck"]),
-        kind: stat?.type === "Directory" ? "directory" : "file",
-      })
-
-      yield* ctx.ask({
-        permission: "read",
-        patterns: [filepath],
-        always: ["*"],
-        metadata: {},
-      })
-
-      if (!stat) return yield* miss(filepath)
-
-      if (stat.type === "Directory") {
-        const items = yield* list(filepath)
-        const limit = params.limit ?? DEFAULT_READ_LIMIT
-        const offset = params.offset || 1
-        const start = offset - 1
-        const sliced = items.slice(start, start + limit)
-        const truncated = start + sliced.length < items.length
-        const expand = Boolean(ctx.extra?.["includeDirectoryFiles"])
-        const loaded = expand ? yield* readDirectoryFiles(filepath, sliced, instance.directory) : []
-        const content = loaded.map((item) => item.content).join("\n\n")
-
-        return {
-          title,
-          output: [
-            `<path>${filepath}</path>`,
-            `<type>directory</type>`,
-            `<entries>`,
-            sliced.join("\n"),
-            truncated
-              ? `\n(Showing ${sliced.length} of ${items.length} entries. Use 'offset' parameter to read beyond entry ${offset + sliced.length})`
-              : `\n(${items.length} entries)`,
-            `</entries>`,
-            ...(content ? [`\n${content}`] : []),
-          ].join("\n"),
-          metadata: {
-            preview: sliced.slice(0, 20).join("\n"),
-            truncated,
-            loaded: loaded.map((item) => item.filepath),
-          },
-        }
-      }
-
-      const loaded = yield* instruction.resolve(ctx.messages, filepath, ctx.messageID)
-      const sample = yield* readSample(filepath, Number(stat.size), SAMPLE_BYTES)
-
-      const mime = sniffAttachmentMime(sample, AppFileSystem.mimeType(filepath))
-      const isImage = SUPPORTED_IMAGE_MIMES.has(mime)
-
-      if (isImage || isPdfAttachment(mime)) {
-        const bytes = yield* fs.readFile(filepath)
-        const msg = isPdfAttachment(mime) ? "PDF read successfully" : "Image read successfully"
-        return {
-          title,
-          output: msg,
-          metadata: {
-            preview: msg,
-            truncated: false,
-            loaded: loaded.map((item) => item.filepath),
-          },
-          attachments: [
-            {
-              type: "file" as const,
-              mime,
-              url: `data:${mime};base64,${Buffer.from(bytes).toString("base64")}`,
-            },
-          ],
-        }
-      }
-
-      if (isBinaryFile(filepath, sample)) {
-        return yield* Effect.fail(new Error(`Cannot read binary file: ${filepath}`))
-      }
-
-      const file = yield* Effect.promise(() =>
-        lines(filepath, { limit: params.limit ?? DEFAULT_READ_LIMIT, offset: params.offset || 1 }),
-      )
-      if (file.count < file.offset && !(file.count === 0 && file.offset === 1)) {
-        return yield* Effect.fail(
-          new Error(`Offset ${file.offset} is out of range for this file (${file.count} lines)`),
-        )
-      }
-
-      let output = [`<path>${filepath}</path>`, `<type>file</type>`, "<content>\n"].join("\n")
-      output += file.raw.map((line, i) => `${i + file.offset}: ${line}`).join("\n")
-
-      const last = file.offset + file.raw.length - 1
-      const next = last + 1
-      const truncated = file.more || file.cut
-      if (file.cut) {
-        output += `\n\n(Output capped at ${MAX_BYTES_LABEL}. Showing lines ${file.offset}-${last}. Use offset=${next} to continue.)`
-      } else if (file.more) {
-        output += `\n\n(Showing lines ${file.offset}-${last} of ${file.count}. Use offset=${next} to continue.)`
-      } else {
-        output += `\n\n(End of file - total ${file.count} lines)`
-      }
-      output += "\n</content>"
-
-      yield* warm(filepath)
-
-      if (loaded.length > 0) {
-        output += `\n\n<system-reminder>\n${loaded.map((item) => item.content).join("\n\n")}\n</system-reminder>`
-      }
-
-      return {
-        title,
-        output,
-        metadata: {
-          preview: file.raw.slice(0, 20).join("\n"),
-          truncated,
-          loaded: loaded.map((item) => item.filepath),
-        },
-      }
-    })
-
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        run(params, ctx).pipe(Effect.orDie),
-    }
-  }),
-)
-// routed through TextStream.withFallback so non-UTF-8 files are decoded via
-// iconv. The body otherwise matches upstream.
-export async function lines(filepath: string, opts: { limit: number; offset: number }) {
-  return TextStream.withFallback(filepath, (stream) => readLines(stream, opts))
-}
-
-async function readLines(stream: Readable, opts: { limit: number; offset: number }) {
-  const rl = createInterface({
-    input: stream,
-    // Note: we use the crlfDelay option to recognize all instances of CR LF
-    // ('\r\n') in file as a single line break.
-    crlfDelay: Infinity,
-  })
-
-  const start = opts.offset - 1
-  const raw: string[] = []
-  let bytes = 0
-  let count = 0
-  let cut = false
-  let more = false
-  try {
-    for await (const text of rl) {
-      count += 1
-      if (count <= start) continue
-
-      if (raw.length >= opts.limit) {
-        more = true
-        continue
-      }
-
-      const line = text.length > MAX_LINE_LENGTH ? text.substring(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : text
-      const size = Buffer.byteLength(line, "utf-8") + (raw.length > 0 ? 1 : 0)
-      if (bytes + size > MAX_BYTES) {
-        cut = true
-        more = true
-        break
-      }
-
-      raw.push(line)
-      bytes += size
-    }
-  } finally {
-    rl.close()
-    stream.destroy()
-  }
-
-  return { raw, count, cut, more, offset: opts.offset }
-}
+export * from "./file/read"

package/src/tool/recall.ts

@@ -1,164 +1 @@
-import { Effect, Schema } from "effect"
-import * as Tool from "./tool"
-import { Instance } from "../project/instance"
-import { Locale } from "../util/locale"
-import { Filesystem } from "../util/filesystem" 
-import { WorktreeFamily } from "../overlay/worktree-family" 
-import DESCRIPTION from "./recall.txt"
-
-const Parameters = Schema.Struct({
-  mode: Schema.Literals(["search", "read"]).annotate({
-    description: "'search' to find sessions by title, 'read' to get a session transcript",
-  }),
-  query: Schema.optional(Schema.String).annotate({
-    description: "Search query to match against session titles (required for search mode)",
-  }),
-  sessionID: Schema.optional(Schema.String).annotate({
-    description: "Session ID to read the transcript of (required for read mode)",
-  }),
-  limit: Schema.optional(Schema.Number).annotate({
-    description: "Maximum number of search results to return (default: 20, max: 50)",
-  }),
-})
-
-export const RecallTool = Tool.define(
-  "saeeol_local_recall",
-  Effect.gen(function* () {
-    return {
-      description: DESCRIPTION,
-      parameters: Parameters,
-      execute: (params: Schema.Schema.Type<typeof Parameters>, ctx: Tool.Context) =>
-        Effect.gen(function* () {
-          if (params.mode === "search") {
-            return yield* Effect.promise(() => search(params, ctx))
-          }
-          return yield* Effect.promise(() => read(params, ctx))
-        }).pipe(Effect.orDie),
-    }
-  }),
-)
-
-async function search(params: { query?: string; limit?: number }, ctx: Tool.Context) {
-  if (!params.query) {
-    throw new Error("The 'query' parameter is required when mode is 'search'")
-  }
-
-  await ctx.ask({
-    permission: "recall",
-    patterns: ["search"],
-    always: ["search"],
-    metadata: {
-      mode: "search",
-      query: params.query,
-    },
-  })
-
-  const limit = Math.min(params.limit ?? 20, 50)
-  const dirs = await WorktreeFamily.list() 
-  const { Session } = await import("../session/session") 
-
-  const results: Array<{
-    id: string
-    title: string
-    directory: string
-    updated: string
-  }> = []
-
-  for (const session of Session.listGlobal({
-    projectID: Instance.project.id, 
-    directories: dirs, 
-    search: params.query,
-    roots: true,
-    limit,
-  })) {
-    results.push({
-      id: session.id,
-      title: session.title,
-      directory: session.directory,
-      updated: Locale.todayTimeOrDateTime(session.time.updated),
-    })
-  }
-
-  if (results.length === 0) {
-    return {
-      title: `Search: "${params.query}" (no results)`,
-      output: `No sessions found matching "${params.query}".`,
-      metadata: {},
-    }
-  }
-
-  const lines = results.map((r) => `- **${r.title}**\n  ID: ${r.id} | Updated: ${r.updated} | Dir: ${r.directory}`)
-
-  return {
-    title: `Search: "${params.query}" (${results.length} results)`,
-    output: lines.join("\n"),
-    metadata: {},
-  }
-}
-
-async function read(params: { sessionID?: string }, ctx: Tool.Context) {
-  if (!params.sessionID) {
-    throw new Error("The 'sessionID' parameter is required when mode is 'read'")
-  }
-
-  const { Session } = await import("../session/session") 
-  const { SessionID } = await import("../session/schema") 
-  const session = await Session.get(SessionID.make(params.sessionID)).catch(() => {
-    throw new Error(`Session "${params.sessionID}" not found. Use search mode first to find valid session IDs.`)
-  })
-  const dirs = await WorktreeFamily.list() 
-  const dir = Filesystem.resolve(session.directory)
-  if (!dirs.some((root) => Filesystem.contains(root, dir))) {
-    throw new Error(
-      `Session "${params.sessionID}" belongs to a different workspace and cannot be read from this directory.`,
-    )
-  }
-
-  const cross = session.projectID !== Instance.project.id
-  if (cross) {
-    await ctx.ask({
-      permission: "recall",
-      patterns: [session.directory],
-      always: [session.directory],
-      metadata: {
-        sessionID: session.id,
-        title: session.title,
-        directory: session.directory,
-      },
-    })
-  }
-
-  const msgs = await Session.messages({ sessionID: session.id })
-  const lines: string[] = [
-    `# Session: ${session.title}`,
-    `Directory: ${session.directory}`,
-    `Created: ${Locale.todayTimeOrDateTime(session.time.created)}`,
-    "",
-  ]
-
-  for (const msg of msgs) {
-    if (msg.info.role === "user") {
-      lines.push("## User")
-      for (const part of msg.parts) {
-        if (part.type === "text") lines.push(part.text)
-      }
-      lines.push("")
-    }
-    if (msg.info.role === "assistant") {
-      lines.push("## Assistant")
-      for (const part of msg.parts) {
-        if (part.type === "text") lines.push(part.text)
-        if (part.type === "tool" && part.state.status === "completed") {
-          lines.push(`[Tool: ${part.tool}] ${part.state.title}`)
-        }
-      }
-      lines.push("")
-    }
-  }
-
-  return {
-    title: `Read: ${session.title}`,
-    output: lines.join("\n"),
-    metadata: {},
-  }
-}
+export * from "./core/recall"