saeeol 1.1.1 → 1.2.1

package/src/session/core/summary.ts

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

package/src/session/core/system.ts

@@ -0,0 +1,114 @@
+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 "../../overlay/soul.txt"
+import type { EditorContext } from "../../overlay/editor-context"
+import { SaeeolSystemPrompt } from "../../overlay/system-prompt"
+import { isLing } from "../../overlay/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"

package/src/session/core/todo.ts

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

package/src/session/core/user-part.ts

@@ -0,0 +1,293 @@
+import { fileURLToPath } from "url"
+import { Effect, Context, Layer, Exit, Cause, Scope, Types } from "effect"
+import { SessionID, PartID } from "./schema"
+import { MessageV2 } from "../message/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/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),
+  ),
+)