saeeol 1.1.1 → 1.2.1

package/src/session/summary.ts

@@ -1,173 +1 @@
-import { Effect, Layer, Context, Schema } from "effect"
-import { Bus } from "@/bus"
-import { Snapshot } from "@/snapshot"
-import { Storage } from "@/storage/storage"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-import * as Session from "./session"
-import { MessageV2 } from "./message-v2"
-import { SessionID, MessageID } from "./schema"
-import { makeRuntime } from "@/effect/run-service" 
-
-function unquoteGitPath(input: string) {
-  if (!input.startsWith('"')) return input
-  if (!input.endsWith('"')) return input
-  const body = input.slice(1, -1)
-  const bytes: number[] = []
-
-  for (let i = 0; i < body.length; i++) {
-    const char = body[i]!
-    if (char !== "\\") {
-      bytes.push(char.charCodeAt(0))
-      continue
-    }
-
-    const next = body[i + 1]
-    if (!next) {
-      bytes.push("\\".charCodeAt(0))
-      continue
-    }
-
-    if (next >= "0" && next <= "7") {
-      const chunk = body.slice(i + 1, i + 4)
-      const match = chunk.match(/^[0-7]{1,3}/)
-      if (!match) {
-        bytes.push(next.charCodeAt(0))
-        i++
-        continue
-      }
-      bytes.push(parseInt(match[0], 8))
-      i += match[0].length
-      continue
-    }
-
-    const escaped =
-      next === "n"
-        ? "\n"
-        : next === "r"
-          ? "\r"
-          : next === "t"
-            ? "\t"
-            : next === "b"
-              ? "\b"
-              : next === "f"
-                ? "\f"
-                : next === "v"
-                  ? "\v"
-                  : next === "\\" || next === '"'
-                    ? next
-                    : undefined
-
-    bytes.push((escaped ?? next).charCodeAt(0))
-    i++
-  }
-
-  return Buffer.from(bytes).toString()
-}
-
-export interface Interface {
-  readonly summarize: (input: { sessionID: SessionID; messageID: MessageID }) => Effect.Effect<void>
-  readonly diff: (input: { sessionID: SessionID; messageID?: MessageID }) => Effect.Effect<Snapshot.FileDiff[]>
-  readonly computeDiff: (input: { messages: MessageV2.WithParts[] }) => Effect.Effect<Snapshot.FileDiff[]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionSummary") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const sessions = yield* Session.Service
-    const snapshot = yield* Snapshot.Service
-    const storage = yield* Storage.Service
-    const bus = yield* Bus.Service
-
-    const computeDiff = Effect.fn("SessionSummary.computeDiff")(function* (input: { messages: MessageV2.WithParts[] }) {
-      let from: string | undefined
-      let to: string | undefined
-      for (const item of input.messages) {
-        if (!from) {
-          for (const part of item.parts) {
-            if (part.type === "step-start" && part.snapshot) {
-              from = part.snapshot
-              break
-            }
-          }
-        }
-        for (const part of item.parts) {
-          if (part.type === "step-finish" && part.snapshot) to = part.snapshot
-        }
-      }
-      if (from && to) return yield* snapshot.diffFull(from, to)
-      return []
-    })
-
-    const summarize = Effect.fn("SessionSummary.summarize")(function* (input: {
-      sessionID: SessionID
-      messageID: MessageID
-    }) {
-      const all = yield* sessions.messages({ sessionID: input.sessionID })
-      if (!all.length) return
-
-      const diffs = yield* computeDiff({ messages: all })
-      yield* sessions.setSummary({
-        sessionID: input.sessionID,
-        summary: {
-          additions: diffs.reduce((sum, x) => sum + x.additions, 0),
-          deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
-          files: diffs.length,
-        },
-      })
-      yield* storage.write(["session_diff", input.sessionID], diffs).pipe(Effect.ignore)
-      yield* bus.publish(Session.Event.Diff, { sessionID: input.sessionID, diff: diffs })
-
-      const messages = all.filter(
-        (m) => m.info.id === input.messageID || (m.info.role === "assistant" && m.info.parentID === input.messageID),
-      )
-      const target = messages.find((m) => m.info.id === input.messageID)
-      if (!target || target.info.role !== "user") return
-      const msgDiffs = yield* computeDiff({ messages })
-      target.info.summary = { ...target.info.summary, diffs: msgDiffs }
-      yield* sessions.updateMessage(target.info)
-    })
-
-    const diff = Effect.fn("SessionSummary.diff")(function* (input: { sessionID: SessionID; messageID?: MessageID }) {
-      const diffs = yield* storage
-        .read<Snapshot.FileDiff[]>(["session_diff", input.sessionID])
-        .pipe(Effect.catch(() => Effect.succeed([] as Snapshot.FileDiff[])))
-      const next = diffs.map((item) => {
-        const file = unquoteGitPath(item.file)
-        const oversized = Buffer.byteLength(item.patch) > Snapshot.MAX_DIFF_SIZE
-        if (file === item.file && !oversized) return item
-        return {
-          ...item,
-          file,
-          patch: oversized ? "" : item.patch,
-        }
-      })
-      const changed = next.some((item, i) => item.file !== diffs[i]?.file)
-      if (changed) yield* storage.write(["session_diff", input.sessionID], next).pipe(Effect.ignore)
-      return next
-    })
-
-    return Service.of({ summarize, diff, computeDiff })
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() =>
-  layer.pipe(
-    Layer.provide(Session.defaultLayer),
-    Layer.provide(Snapshot.defaultLayer),
-    Layer.provide(Storage.defaultLayer),
-    Layer.provide(Bus.layer),
-  ),
-)
-
-export const DiffInput = Schema.Struct({
-  sessionID: SessionID,
-  messageID: Schema.optional(MessageID),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type DiffInput = Schema.Schema.Type<typeof DiffInput>
-const { runPromise } = makeRuntime(Service, defaultLayer)
-export const diff = (input: { sessionID: SessionID; messageID?: MessageID }) => runPromise((svc) => svc.diff(input))
-
-export * as SessionSummary from "./summary"
+export * from "./core/summary"

package/src/session/system.ts

@@ -1,114 +1 @@
-import { Context, Effect, Layer } from "effect"
-
-import { InstanceState } from "@/effect/instance-state"
-
-import PROMPT_ANTHROPIC from "./prompt/anthropic.txt"
-import PROMPT_DEFAULT from "./prompt/default.txt"
-import PROMPT_BEAST from "./prompt/beast.txt"
-import PROMPT_GEMINI from "./prompt/gemini.txt"
-import PROMPT_GPT from "./prompt/gpt.txt"
-import PROMPT_GPT55 from "./prompt/saeeol-gpt-5.5.txt" 
-import PROMPT_KIMI from "./prompt/kimi.txt"
-import PROMPT_LING from "./prompt/ling.txt" 
-
-import PROMPT_CODEX from "./prompt/codex.txt"
-import PROMPT_TRINITY from "./prompt/trinity.txt"
-import type { Provider } from "@/provider/provider"
-import type { Agent } from "@/agent/agent"
-import { Permission } from "@/permission"
-import { Skill } from "@/skill"
-import SOUL from "../saeeol/soul.txt"
-import type { EditorContext } from "../saeeol/editor-context"
-import { SaeeolSystemPrompt } from "../saeeol/system-prompt"
-import { isLing } from "../saeeol/model-match"
-export function instructions() {
-  return PROMPT_CODEX.trim()
-}
-
-export function soul() {
-  return SOUL.trim()
-}
-
-export function provider(model: Provider.Model) {
-  function prompt() {
-    switch ((model as any).prompt) {
-      case "anthropic":
-        return [PROMPT_ANTHROPIC]
-      case "anthropic_without_todo":
-        return [PROMPT_DEFAULT]
-      case "beast":
-        return [PROMPT_BEAST]
-      case "codex":
-        return [PROMPT_CODEX]
-      case "gemini":
-        return [PROMPT_GEMINI]
-      case "gpt55":
-        return [PROMPT_GPT55]
-      case "ling":
-        return [PROMPT_LING]
-      case "trinity":
-        return [PROMPT_TRINITY]
-    }
-    return undefined
-  }
-
-  const saeeol = prompt()
-  if (saeeol) return saeeol
-
-  if (model.api.id.includes("gpt-4") || model.api.id.includes("o1") || model.api.id.includes("o3"))
-    return [PROMPT_BEAST]
-  if (model.api.id.includes("gpt")) {
-    if (model.api.id.includes("codex")) {
-      return [PROMPT_CODEX]
-    }
-    return [PROMPT_GPT]
-  }
-  if (model.api.id.includes("gemini-")) return [PROMPT_GEMINI]
-  if (model.api.id.includes("claude")) return [PROMPT_ANTHROPIC]
-  if (model.api.id.toLowerCase().includes("trinity")) return [PROMPT_TRINITY]
-  if (model.api.id.toLowerCase().includes("kimi")) return [PROMPT_KIMI]
-  if (isLing(model.api.id)) return [PROMPT_LING] 
-  return [PROMPT_DEFAULT]
-}
-
-export interface Interface {
-  readonly environment: (model: Provider.Model, editorContext?: EditorContext) => Effect.Effect<string[]> 
-  readonly skills: (agent: Agent.Info) => Effect.Effect<string | undefined>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SystemPrompt") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const skill = yield* Skill.Service
-
-    return Service.of({
-      environment: Effect.fn("SystemPrompt.environment")(function* (
-        model: Provider.Model,
-        editorContext?: EditorContext,
-      ) {
-        const ctx = yield* InstanceState.context
-        return SaeeolSystemPrompt.environment({ ctx, model, editor: editorContext })
-      }),
-
-      skills: Effect.fn("SystemPrompt.skills")(function* (agent: Agent.Info) {
-        if (Permission.disabled(["skill"], agent.permission).has("skill")) return
-
-        const list = yield* skill.available(agent)
-
-        return [
-          "Skills provide specialized instructions and workflows for specific tasks.",
-          "Use the skill tool to load a skill when a task matches its description.",
-          // the agents seem to ingest the information about skills a bit better if we present a more verbose
-          // version of them here and a less verbose version in tool description, rather than vice versa.
-          Skill.fmt(list, { verbose: true }),
-        ].join("\n")
-      }),
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Skill.defaultLayer))
-
-export * as SystemPrompt from "./system"
+export * from "./core/system"

package/src/session/todo.ts

@@ -1,86 +1 @@
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { SessionID } from "./schema"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-import { Effect, Layer, Context, Schema } from "effect"
-import z from "zod"
-import { Database } from "@/storage/db"
-import { eq } from "drizzle-orm"
-import { asc } from "drizzle-orm"
-import { TodoTable } from "./session.sql"
-
-export const Info = Schema.Struct({
-  content: Schema.String.annotate({ description: "Brief description of the task" }),
-  status: Schema.String.annotate({
-    description: "Current status of the task: pending, in_progress, completed, cancelled",
-  }),
-  priority: Schema.String.annotate({ description: "Priority level of the task: high, medium, low" }),
-})
-  .annotate({ identifier: "Todo" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Info = Schema.Schema.Type<typeof Info>
-
-export const Event = {
-  Updated: BusEvent.define(
-    "todo.updated",
-    Schema.Struct({
-      sessionID: SessionID,
-      todos: Schema.Array(Info),
-    }),
-  ),
-}
-
-export interface Interface {
-  readonly update: (input: { sessionID: SessionID; todos: Info[] }) => Effect.Effect<void>
-  readonly get: (sessionID: SessionID) => Effect.Effect<Info[]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionTodo") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-
-    const update = Effect.fn("Todo.update")(function* (input: { sessionID: SessionID; todos: Info[] }) {
-      yield* Effect.sync(() =>
-        Database.transaction((db) => {
-          db.delete(TodoTable).where(eq(TodoTable.session_id, input.sessionID)).run()
-          if (input.todos.length === 0) return
-          db.insert(TodoTable)
-            .values(
-              input.todos.map((todo, position) => ({
-                session_id: input.sessionID,
-                content: todo.content,
-                status: todo.status,
-                priority: todo.priority,
-                position,
-              })),
-            )
-            .run()
-        }),
-      )
-      yield* bus.publish(Event.Updated, input)
-    })
-
-    const get = Effect.fn("Todo.get")(function* (sessionID: SessionID) {
-      const rows = yield* Effect.sync(() =>
-        Database.use((db) =>
-          db.select().from(TodoTable).where(eq(TodoTable.session_id, sessionID)).orderBy(asc(TodoTable.position)).all(),
-        ),
-      )
-      return rows.map((row) => ({
-        content: row.content,
-        status: row.status,
-        priority: row.priority,
-      }))
-    })
-
-    return Service.of({ update, get })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Bus.layer))
-
-export * as Todo from "./todo"
+export * from "./core/todo"

package/src/session/user-part.ts

@@ -1,293 +1 @@
-import { fileURLToPath } from "url"
-import { Effect, Context, Layer, Exit, Cause, Scope, Types } from "effect"
-import { SessionID, PartID } from "./schema"
-import { MessageV2 } from "./message-v2"
-import * as Session from "./session"
-import { Provider } from "@/provider/provider"
-import { Bus } from "../bus"
-import { ToolRegistry } from "@/tool/registry"
-import { MCP } from "../mcp"
-import { LSP } from "@/lsp/lsp"
-import { Plugin } from "../plugin"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { decodeDataUrl } from "@/util/data-url"
-import { Permission } from "@/permission"
-import { NamedError } from "@saeeol/core/util/error"
-import * as Log from "@saeeol/core/util/log"
-import type { PromptInput } from "./prompt-schemas"
-
-const log = Log.create({ service: "session.user-part" })
-
-export interface ResolveUserPartDeps {
-  sessionID: SessionID
-  messageID: ReturnType<typeof MessageV2.Info.make>["id"]
-  agent: string
-  agentPermission: any
-  model: { providerID: any; modelID: any }
-}
-
-export interface Interface {
-  readonly resolve: (
-    part: PromptInput["parts"][number],
-    deps: ResolveUserPartDeps,
-  ) => Effect.Effect<any[], never, Scope.Scope>
-}
-export class Service extends Context.Service<Service, Interface>()("@saeeol/SessionUserPart") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const fsys = yield* AppFileSystem.Service
-    const mcp = yield* MCP.Service
-    const lsp = yield* LSP.Service
-    const registry = yield* ToolRegistry.Service
-    const plugin = yield* Plugin.Service
-    const provider = yield* Provider.Service
-    const bus = yield* Bus.Service
-
-    const resolve = Effect.fn("SessionUserPart.resolve")(function* (
-      part: PromptInput["parts"][number],
-      deps: ResolveUserPartDeps,
-    ) {
-      const { sessionID, messageID, agent, agentPermission, model } = deps
-
-      if (part.type === "file") {
-        if (part.source?.type === "resource") {
-          const { clientName, uri } = part.source
-          log.info("mcp resource", { clientName, uri, mime: part.mime })
-          const pieces: any[] = [
-            {
-              messageID, sessionID,
-              type: "text", synthetic: true,
-              text: `Reading MCP resource: ${part.filename} (${uri})`,
-            },
-          ]
-          const exit = yield* mcp.readResource(clientName, uri).pipe(Effect.exit)
-          if (Exit.isSuccess(exit)) {
-            const content = exit.value
-            if (!content) throw new Error(`Resource not found: ${clientName}/${uri}`)
-            const items = Array.isArray(content.contents) ? content.contents : [content.contents]
-            for (const c of items) {
-              if ("text" in c && c.text) {
-                pieces.push({
-                  messageID, sessionID,
-                  type: "text", synthetic: true, text: c.text,
-                })
-              } else if ("blob" in c && c.blob) {
-                const mime = "mimeType" in c ? c.mimeType : part.mime
-                pieces.push({
-                  messageID, sessionID,
-                  type: "text", synthetic: true,
-                  text: `[Binary content: ${mime}]`,
-                })
-              }
-            }
-            pieces.push({ ...part, messageID, sessionID })
-          } else {
-            const error = Cause.squash(exit.cause)
-            log.error("failed to read MCP resource", { error, clientName, uri })
-            const message = error instanceof Error ? error.message : String(error)
-            pieces.push({
-              messageID, sessionID,
-              type: "text", synthetic: true,
-              text: `Failed to read MCP resource ${part.filename}: ${message}`,
-            })
-          }
-          return pieces
-        }
-
-        const url = new URL(part.url)
-        switch (url.protocol) {
-          case "data:":
-            if (part.mime === "text/plain") {
-              return [
-                {
-                  messageID, sessionID,
-                  type: "text", synthetic: true,
-                  text: `Called the Read tool with the following input: ${JSON.stringify({ filePath: part.filename })}`,
-                },
-                {
-                  messageID, sessionID,
-                  type: "text", synthetic: true,
-                  text: decodeDataUrl(part.url),
-                },
-                { ...part, messageID, sessionID },
-              ]
-            }
-            break
-          case "file:": {
-            log.info("file", { mime: part.mime })
-            const filepath = fileURLToPath(part.url)
-            const mime = (yield* fsys.isDir(filepath)) ? "application/x-directory" : part.mime
-
-            const { read } = yield* registry.named()
-            const execRead = (args: Parameters<typeof read.execute>[0], extra?: any) => {
-              const controller = new AbortController()
-              return read
-                .execute(args, {
-                  sessionID, abort: controller.signal,
-                  agent, messageID,
-                  extra: { bypassCwdCheck: true, ...extra },
-                  messages: [], metadata: () => Effect.void, ask: () => Effect.void,
-                })
-                .pipe(Effect.onInterrupt(() => Effect.sync(() => controller.abort())))
-            }
-
-            if (mime === "text/plain") {
-              let offset: number | undefined
-              let limit: number | undefined
-              const range = { start: url.searchParams.get("start"), end: url.searchParams.get("end") }
-              if (range.start != null) {
-                const filePathURI = part.url.split("?")[0]
-                let start = parseInt(range.start)
-                let end = range.end ? parseInt(range.end) : undefined
-                if (start === end) {
-                  const symbols = yield* lsp.documentSymbol(filePathURI).pipe(Effect.catch(() => Effect.succeed([])))
-                  for (const symbol of symbols) {
-                    let r: LSP.Range | undefined
-                    if ("range" in symbol) r = symbol.range
-                    else if ("location" in symbol) r = symbol.location.range
-                    if (r?.start?.line && r?.start?.line === start) {
-                      start = r.start.line
-                      end = r?.end?.line ?? start
-                      break
-                    }
-                  }
-                }
-                offset = Math.max(start, 1)
-                if (end) limit = end - (offset - 1)
-              }
-              const args = { filePath: filepath, offset, limit }
-          const pieces: any[] = [
-                {
-                  messageID, sessionID,
-                  type: "text", synthetic: true,
-                  text: `Called the Read tool with the following input: ${JSON.stringify(args)}`,
-                },
-              ]
-              const exit = yield* provider.getModel(model.providerID, model.modelID).pipe(
-                Effect.flatMap((mdl) => execRead(args, { model: mdl })),
-                Effect.exit,
-              )
-              if (Exit.isSuccess(exit)) {
-                const result = exit.value
-                pieces.push({
-                  messageID, sessionID,
-                  type: "text", synthetic: true, text: result.output,
-                })
-                if (result.attachments?.length) {
-                  pieces.push(
-                    ...result.attachments.map((a: any) => ({
-                      ...a, synthetic: true,
-                      filename: a.filename ?? part.filename,
-                      messageID, sessionID,
-                    })),
-                  )
-                } else {
-                  pieces.push({ ...part, mime, messageID, sessionID })
-                }
-              } else {
-                const error = Cause.squash(exit.cause)
-                log.error("failed to read file", { error })
-                const message = error instanceof Error ? error.message : String(error)
-                yield* bus.publish(Session.Event.Error, {
-                  sessionID,
-                  error: new NamedError.Unknown({ message }).toObject(),
-                })
-                pieces.push({
-                  messageID, sessionID,
-                  type: "text", synthetic: true,
-                  text: `Read tool failed to read ${filepath} with the following error: ${message}`,
-                })
-              }
-              return pieces
-            }
-
-            if (mime === "application/x-directory") {
-              const args = { filePath: filepath }
-              const exit = yield* execRead(args, { includeDirectoryFiles: true }).pipe(Effect.exit)
-              if (Exit.isFailure(exit)) {
-                const error = Cause.squash(exit.cause)
-                log.error("failed to read directory", { error })
-                const message = error instanceof Error ? error.message : String(error)
-                yield* bus.publish(Session.Event.Error, {
-                  sessionID,
-                  error: new NamedError.Unknown({ message }).toObject(),
-                })
-                return [
-                  {
-                    messageID, sessionID,
-                    type: "text", synthetic: true,
-                    text: `Read tool failed to read ${filepath} with the following error: ${message}`,
-                  },
-                ]
-              }
-              return [
-                {
-                  messageID, sessionID,
-                  type: "text", synthetic: true,
-                  text: `Called the Read tool with the following input: ${JSON.stringify(args)}`,
-                },
-                {
-                  messageID, sessionID,
-                  type: "text", synthetic: true,
-                  text: exit.value.output,
-                },
-                { ...part, mime, messageID, sessionID },
-              ]
-            }
-
-            return [
-              {
-                messageID, sessionID,
-                type: "text", synthetic: true,
-                text: `Called the Read tool with the following input: {"filePath":"${filepath}"}`,
-              },
-              {
-                id: part.id, messageID, sessionID,
-                type: "file",
-                url:
-                  `data:${mime};base64,` +
-                  Buffer.from(yield* fsys.readFile(filepath).pipe(Effect.catch(Effect.die))).toString("base64"),
-                mime,
-                filename: part.filename!,
-                source: part.source,
-              },
-            ]
-          }
-        }
-      }
-
-      if (part.type === "agent") {
-        const perm = Permission.evaluate("task", part.name, agentPermission)
-        const hint = perm.action === "deny" ? " . Invoked by user; guaranteed to exist." : ""
-        return [
-          { ...part, messageID, sessionID } as any,
-          {
-            messageID, sessionID,
-            type: "text", synthetic: true,
-            text:
-              " Use the above message and context to generate a prompt and call the task tool with subagent: " +
-              part.name + hint,
-          },
-        ]
-      }
-
-      return [{ ...part, messageID, sessionID } as any]
-    })
-
-    return { resolve }
-  }),
-)
-
-export const defaultLayer = Layer.suspend(() =>
-  layer.pipe(
-    Layer.provide(AppFileSystem.defaultLayer),
-    Layer.provide(MCP.defaultLayer),
-    Layer.provide(LSP.defaultLayer),
-    Layer.provide(ToolRegistry.defaultLayer),
-    Layer.provide(Plugin.defaultLayer),
-    Layer.provide(Provider.defaultLayer),
-    Layer.provide(Bus.layer),
-  ),
-)
+export * from "./core/user-part"

package/src/skill/index.ts

@@ -19,7 +19,7 @@ import { Glob } from "@saeeol/core/util/glob"
 import * as Log from "@saeeol/core/util/log"
 import { Discovery } from "./discovery"
 import { rm } from "fs/promises" 
-import { BUILTIN_SKILLS } from "../saeeol/skills/builtin" 
+import { BUILTIN_SKILLS } from "../overlay/skills/builtin" 
 
 const log = Log.create({ service: "skill" })
 const CLAUDE_EXTERNAL_DIR = ".claude"

package/src/suggestion/index.ts

@@ -1 +1 @@
-export { Suggestion } from "../saeeol/suggestion/index"
+export { Suggestion } from "../overlay/suggestion/index"