saeeol 1.2.5 → 1.2.8

package/test/saeeol/session-fork-remap.test.ts

@@ -1,251 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Instance } from "../../src/project/instance"
-import { Session } from "../../src/session/session"
-import { MessageV2 } from "../../src/session/message-v2"
-import { MessageID, PartID, SessionID } from "../../src/session/schema"
-import * as Log from "@saeeol/core/util/log"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-
-Log.init({ print: false })
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-function taskPart(input: { messageID: string; sessionID: string; childSessionID: string }): MessageV2.ToolPart {
-  return {
-    id: PartID.ascending(),
-    messageID: MessageID.make(input.messageID),
-    sessionID: SessionID.make(input.sessionID),
-    type: "tool",
-    callID: "call_1",
-    tool: "task",
-    state: {
-      status: "completed",
-      input: { description: "test task", prompt: "do something" },
-      output: `task_id: ${input.childSessionID}`,
-      title: "test task",
-      metadata: {
-        sessionId: input.childSessionID,
-        model: { modelID: "test", providerID: "test" },
-      },
-      time: { start: Date.now(), end: Date.now() },
-    },
-  }
-}
-
-async function userMsg(sid: string) {
-  const id = MessageID.ascending()
-  await Session.updateMessage({
-    id,
-    sessionID: SessionID.make(sid),
-    role: "user",
-    time: { created: Date.now() },
-    agent: "test",
-    model: { providerID: "test", modelID: "test" },
-    tools: {},
-  } as MessageV2.User)
-  return id
-}
-
-async function asstMsg(sid: string, parent: string) {
-  const id = MessageID.ascending()
-  await Session.updateMessage({
-    id,
-    sessionID: SessionID.make(sid),
-    role: "assistant",
-    time: { created: Date.now() },
-    parentID: MessageID.make(parent),
-    modelID: "test",
-    providerID: "test",
-    mode: "",
-    agent: "test",
-    path: { cwd: "/tmp", root: "/tmp" },
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-  } as MessageV2.Assistant)
-  return id
-}
-
-describe("Session.fork child session remapping", () => {
-  test(
-    "forked session gets its own copy of child sessions",
-    async () => {
-      await using tmp = await tmpdir({ git: true })
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const parent = await Session.create({ title: "parent" })
-          const child = await Session.create({ parentID: parent.id, title: "child subagent" })
-
-          // Add a user message to the child so it has content
-          const childMsgId = await userMsg(child.id)
-          await Session.updatePart({
-            id: PartID.ascending(),
-            messageID: childMsgId,
-            sessionID: child.id,
-            type: "text",
-            text: "child message content",
-          } as MessageV2.TextPart)
-
-          // Add a user message then an assistant message with a task tool part referencing the child
-          const parentUserMsg = await userMsg(parent.id)
-          await Session.updatePart({
-            id: PartID.ascending(),
-            messageID: parentUserMsg,
-            sessionID: parent.id,
-            type: "text",
-            text: "do something",
-          } as MessageV2.TextPart)
-
-          const parentAsstMsg = await asstMsg(parent.id, parentUserMsg)
-          await Session.updatePart(
-            taskPart({
-              messageID: parentAsstMsg,
-              sessionID: parent.id,
-              childSessionID: child.id,
-            }),
-          )
-
-          // Fork the parent session
-          const forked = await Session.fork({ sessionID: parent.id })
-          expect(forked.id).not.toBe(parent.id)
-
-          // Check that the forked session's task part references a DIFFERENT child session
-          const forkedMsgs = await Session.messages({ sessionID: forked.id })
-          const parts = forkedMsgs.flatMap((m) => m.parts)
-          const tools = parts.filter((p) => p.type === "tool" && p.tool === "task") as MessageV2.ToolPart[]
-
-          expect(tools).toHaveLength(1)
-          const meta = (tools[0].state as unknown as { metadata: { sessionId: string } }).metadata
-          expect(meta.sessionId).not.toBe(child.id)
-
-          // Verify the forked child session actually exists and has content
-          const forkedChild = await Session.get(SessionID.make(meta.sessionId))
-          expect(forkedChild).toBeDefined()
-          expect(forkedChild.id).not.toBe(child.id)
-
-          const forkedChildMsgs = await Session.messages({ sessionID: forkedChild.id })
-          expect(forkedChildMsgs).toHaveLength(1)
-          expect(forkedChildMsgs[0].parts[0].type).toBe("text")
-        },
-      })
-    },
-    { timeout: 30000 },
-  )
-
-  test(
-    "nested child sessions are also remapped",
-    async () => {
-      await using tmp = await tmpdir({ git: true })
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          // grandchild -> child -> parent
-          const parent = await Session.create({ title: "parent" })
-          const child = await Session.create({ parentID: parent.id, title: "child" })
-          const grandchild = await Session.create({ parentID: child.id, title: "grandchild" })
-
-          // grandchild has a text message
-          const gcMsgId = await userMsg(grandchild.id)
-          await Session.updatePart({
-            id: PartID.ascending(),
-            messageID: gcMsgId,
-            sessionID: grandchild.id,
-            type: "text",
-            text: "grandchild content",
-          } as MessageV2.TextPart)
-
-          // child references grandchild via task part
-          const childUserMsg = await userMsg(child.id)
-          await Session.updatePart({
-            id: PartID.ascending(),
-            messageID: childUserMsg,
-            sessionID: child.id,
-            type: "text",
-            text: "question",
-          } as MessageV2.TextPart)
-          const childAsstMsg = await asstMsg(child.id, childUserMsg)
-          await Session.updatePart(
-            taskPart({
-              messageID: childAsstMsg,
-              sessionID: child.id,
-              childSessionID: grandchild.id,
-            }),
-          )
-
-          // parent references child via task part
-          const parentUserMsg = await userMsg(parent.id)
-          await Session.updatePart({
-            id: PartID.ascending(),
-            messageID: parentUserMsg,
-            sessionID: parent.id,
-            type: "text",
-            text: "request",
-          } as MessageV2.TextPart)
-          const parentAsstMsg = await asstMsg(parent.id, parentUserMsg)
-          await Session.updatePart(
-            taskPart({
-              messageID: parentAsstMsg,
-              sessionID: parent.id,
-              childSessionID: child.id,
-            }),
-          )
-
-          const forked = await Session.fork({ sessionID: parent.id })
-
-          // Verify parent-level remap
-          const forkedMsgs = await Session.messages({ sessionID: forked.id })
-          const tools = forkedMsgs
-            .flatMap((m) => m.parts)
-            .filter((p) => p.type === "tool" && p.tool === "task") as MessageV2.ToolPart[]
-          const forkedChildID = (tools[0].state as unknown as { metadata: { sessionId: string } }).metadata.sessionId
-          expect(forkedChildID).not.toBe(child.id)
-
-          // Verify child-level remap (grandchild)
-          const forkedChildMsgs = await Session.messages({ sessionID: SessionID.make(forkedChildID) })
-          const childTools = forkedChildMsgs
-            .flatMap((m) => m.parts)
-            .filter((p) => p.type === "tool" && p.tool === "task") as MessageV2.ToolPart[]
-          expect(childTools).toHaveLength(1)
-          const forkedGrandchildID = (childTools[0].state as unknown as { metadata: { sessionId: string } }).metadata
-            .sessionId
-          expect(forkedGrandchildID).not.toBe(grandchild.id)
-
-          // Verify grandchild content was copied
-          const gcMsgs = await Session.messages({ sessionID: SessionID.make(forkedGrandchildID) })
-          expect(gcMsgs).toHaveLength(1)
-        },
-      })
-    },
-    { timeout: 30000 },
-  )
-
-  test(
-    "non-task tool parts are not affected",
-    async () => {
-      await using tmp = await tmpdir({ git: true })
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const parent = await Session.create({ title: "parent" })
-          const parentUserMsg = await userMsg(parent.id)
-          await Session.updatePart({
-            id: PartID.ascending(),
-            messageID: parentUserMsg,
-            sessionID: parent.id,
-            type: "text",
-            text: "hello",
-          } as MessageV2.TextPart)
-
-          const forked = await Session.fork({ sessionID: parent.id })
-          const forkedMsgs = await Session.messages({ sessionID: forked.id })
-          expect(forkedMsgs).toHaveLength(1)
-          expect(forkedMsgs[0].parts[0].type).toBe("text")
-          expect((forkedMsgs[0].parts[0] as MessageV2.TextPart).text).toBe("hello")
-        },
-      })
-    },
-    { timeout: 30000 },
-  )
-})

package/test/saeeol/session-import-service.test.ts

@@ -1,114 +0,0 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test"
-import { Database } from "../../src/storage/db"
-import { SessionImportService } from "../../src/overlay/session-import/service"
-
-let spy: ReturnType<typeof spyOn>
-
-const db = {
-  select() {
-    return {
-      from() {
-        return {
-          where() {
-            return {
-              get() {
-                return rows.session
-              },
-            }
-          },
-        }
-      },
-    }
-  },
-  delete() {
-    return {
-      where() {
-        return {
-          run() {
-            deletes.push("session")
-            rows.session = undefined
-            rows.messages = []
-            rows.parts = []
-          },
-        }
-      },
-    }
-  },
-  insert() {
-    return {
-      values(input: Record<string, unknown>) {
-        return {
-          onConflictDoUpdate() {
-            return {
-              run() {
-                rows.session = { ...input }
-              },
-            }
-          },
-          run() {
-            rows.session = { ...input }
-          },
-        }
-      },
-    }
-  },
-}
-
-const rows = {
-  session: undefined as Record<string, unknown> | undefined,
-  messages: [] as string[],
-  parts: [] as string[],
-}
-
-const deletes: string[] = []
-
-function input(force?: boolean) {
-  return {
-    id: "ses_migrated_test",
-    projectID: "proj_test",
-    slug: "legacy-task",
-    directory: "/workspace/testing",
-    title: force ? "Reimported task" : "Legacy task",
-    version: "v2",
-    timeCreated: 1,
-    timeUpdated: 1,
-    ...(force ? { force: true } : {}),
-  }
-}
-
-describe("SessionImportService.session", () => {
-  beforeEach(() => {
-    spy = spyOn(Database, "use").mockImplementation((fn: any) => fn(db))
-    deletes.length = 0
-    rows.session = undefined
-    rows.messages = []
-    rows.parts = []
-  })
-
-  afterEach(() => {
-    spy.mockRestore()
-  })
-
-  test("returns skipped when the session already exists and force is false", async () => {
-    rows.session = { id: "ses_migrated_test", title: "Legacy task" }
-
-    const result = await SessionImportService.session(input())
-
-    expect(result).toEqual({ ok: true, id: "ses_migrated_test", skipped: true })
-    expect(deletes).toEqual([])
-  })
-
-  test("deletes and recreates the session when force is true", async () => {
-    rows.session = { id: "ses_migrated_test", title: "Legacy task" }
-    rows.messages = ["msg_test"]
-    rows.parts = ["prt_test"]
-
-    const result = await SessionImportService.session(input(true))
-
-    expect(result).toEqual({ ok: true, id: "ses_migrated_test" })
-    expect(deletes).toEqual(["session"])
-    expect(rows.messages).toEqual([])
-    expect(rows.parts).toEqual([])
-    expect(rows.session).toMatchObject({ title: "Reimported task" })
-  })
-})

package/test/saeeol/session-list.test.ts

@@ -1,47 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Instance } from "../../src/project/instance"
-import { ProjectTable } from "../../src/project/project.sql"
-import { ProjectID } from "../../src/project/schema"
-import { AppRuntime } from "../../src/effect/app-runtime"
-import { Session } from "../../src/session/session"
-import { SessionTable } from "../../src/session/session.sql"
-import { Database, eq } from "../../src/storage/db"
-import * as Log from "@saeeol/core/util/log"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-
-Log.init({ print: false })
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-describe("Saeeol Session.list", () => {
-  test("includes directory matches from legacy project ids", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await Session.create({ title: "legacy-session" })
-        const project = ProjectID.make("legacy-project")
-        Database.use((db) => {
-          db.insert(ProjectTable)
-            .values({
-              id: project,
-              worktree: tmp.path,
-              vcs: "git",
-              time_created: Date.now(),
-              time_updated: Date.now(),
-              sandboxes: [],
-            })
-            .run()
-          db.update(SessionTable).set({ project_id: project }).where(eq(SessionTable.id, session.id)).run()
-        })
-
-        const sessions = await AppRuntime.runPromise(Session.Service.use((svc) => svc.list({ directory: tmp.path })))
-        const ids = sessions.map((item) => item.id)
-
-        expect(ids).toContain(session.id)
-      },
-    })
-  })
-})

package/test/saeeol/session-message-metadata.test.ts

@@ -1,128 +0,0 @@
-
-import { describe, expect, test } from "bun:test"
-import { MessageV2 } from "../../src/session/message-v2"
-import { SessionID, MessageID, PartID } from "../../src/session/schema"
-import { Snapshot } from "../../src/snapshot"
-
-const sessionID = SessionID.make("session")
-const patch =
-  "Index: a.ts\n===================================================================\n--- a.ts\t\n+++ a.ts\t\n@@ -1,2 +1,2 @@\n one\n-two\n+three\n"
-
-function blob(size: number) {
-  return "x".repeat(size)
-}
-
-function part(tool: string, metadata: Record<string, unknown>): MessageV2.Part {
-  return {
-    id: PartID.make(`p-${tool}`),
-    sessionID,
-    messageID: MessageID.make("m-assistant"),
-    type: "tool",
-    callID: `call-${tool}`,
-    tool,
-    state: {
-      status: "completed",
-      input: {},
-      output: "ok",
-      title: tool,
-      metadata,
-      time: { start: 0, end: 1 },
-    },
-  } as MessageV2.Part
-}
-
-describe("session message metadata stripping", () => {
-  test("keeps bounded edit filediff patches and strips heavy fields", () => {
-    const input = part("edit", {
-      diff: blob(200_000),
-      filediff: {
-        file: "a.ts",
-        patch,
-        before: blob(200_000),
-        after: blob(200_000),
-        additions: 1,
-        deletions: 1,
-      },
-      diagnostics: {},
-    })
-    const stripped = MessageV2.stripPartMetadata(input) as Extract<MessageV2.Part, { type: "tool" }>
-    const meta = stripped.state.status === "completed" ? stripped.state.metadata : {}
-
-    expect(meta.diff).toBeUndefined()
-    expect(meta.filediff.before).toBeUndefined()
-    expect(meta.filediff.after).toBeUndefined()
-    expect(meta.filediff.patch).toBe(patch)
-    expect(JSON.stringify(stripped).length).toBeLessThan(10_000)
-  })
-
-  test("keeps bounded write filediff patches and strips heavy fields", () => {
-    const input = part("write", {
-      diff: blob(200_000),
-      filediff: {
-        file: "README.md",
-        patch,
-        before: blob(200_000),
-        after: blob(200_000),
-        additions: 1,
-        deletions: 1,
-      },
-      diagnostics: {},
-    })
-    const stripped = MessageV2.stripPartMetadata(input) as Extract<MessageV2.Part, { type: "tool" }>
-    const meta = stripped.state.status === "completed" ? stripped.state.metadata : {}
-
-    expect(meta.diff).toBeUndefined()
-    expect(meta.filediff.before).toBeUndefined()
-    expect(meta.filediff.after).toBeUndefined()
-    expect(meta.filediff.patch).toBe(patch)
-    expect(JSON.stringify(stripped).length).toBeLessThan(10_000)
-  })
-
-  test("keeps bounded apply_patch per-file patches and strips heavy fields", () => {
-    const input = part("apply_patch", {
-      diff: blob(200_000),
-      files: [
-        {
-          filePath: "/tmp/a.ts",
-          relativePath: "a.ts",
-          type: "update",
-          patch,
-          before: blob(200_000),
-          after: blob(200_000),
-          additions: 1,
-          deletions: 1,
-        },
-      ],
-      diagnostics: {},
-    })
-    const stripped = MessageV2.stripPartMetadata(input) as Extract<MessageV2.Part, { type: "tool" }>
-    const meta = stripped.state.status === "completed" ? stripped.state.metadata : {}
-
-    expect(meta.diff).toBeUndefined()
-    expect(meta.files[0].before).toBeUndefined()
-    expect(meta.files[0].after).toBeUndefined()
-    expect(meta.files[0].patch).toBe(patch)
-    expect(JSON.stringify(stripped).length).toBeLessThan(10_000)
-  })
-
-  test("drops oversized tool patches from hydrated session metadata", () => {
-    const wide = `Index: a.ts\n--- a.ts\n+++ a.ts\n@@ -1,1 +1,1 @@\n-${blob(Snapshot.MAX_DIFF_SIZE)}\n+${blob(Snapshot.MAX_DIFF_SIZE)}\n`
-    const input = part("apply_patch", {
-      files: [
-        {
-          filePath: "/tmp/a.ts",
-          relativePath: "a.ts",
-          type: "update",
-          patch: wide,
-          additions: 1,
-          deletions: 1,
-        },
-      ],
-    })
-    const stripped = MessageV2.stripPartMetadata(input) as Extract<MessageV2.Part, { type: "tool" }>
-    const meta = stripped.state.status === "completed" ? stripped.state.metadata : {}
-
-    expect(meta.files[0].patch).toBeUndefined()
-    expect(JSON.stringify(stripped).length).toBeLessThan(10_000)
-  })
-})

package/test/saeeol/session-overflow.test.ts

@@ -1,78 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Config } from "@/config/config"
-import type { Provider } from "@/provider/provider"
-import type { MessageV2 } from "@/session/message-v2"
-import { isOverflow } from "@/session/overflow"
-
-function cfg(compaction?: Config.Info["compaction"]) {
-  return Config.Info.zod.parse({ compaction })
-}
-
-function model(opts: { context: number; output: number; input?: number }): Provider.Model {
-  return {
-    id: "test-model",
-    providerID: "test",
-    name: "Test",
-    limit: {
-      context: opts.context,
-      input: opts.input,
-      output: opts.output,
-    },
-    cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
-    capabilities: {
-      toolcall: true,
-      attachment: false,
-      reasoning: false,
-      temperature: true,
-      input: { text: true, image: false, audio: false, video: false },
-      output: { text: true, image: false, audio: false, video: false },
-    },
-    api: { npm: "@ai-sdk/anthropic" },
-    options: {},
-  } as Provider.Model
-}
-
-function tokens(count: number): MessageV2.Assistant["tokens"] {
-  return { input: count, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
-}
-
-describe("Saeeol auto-compaction threshold", () => {
-  test("triggers at the configured context percentage", () => {
-    const conf = cfg({ threshold_percent: 75 })
-    const mdl = model({ context: 200_000, output: 32_000 })
-
-    expect(isOverflow({ cfg: conf, model: mdl, tokens: tokens(149_999) })).toBe(false)
-    expect(isOverflow({ cfg: conf, model: mdl, tokens: tokens(150_000) })).toBe(true)
-  })
-
-  test("keeps the reserved safety trigger when it is lower", () => {
-    const conf = cfg({ threshold_percent: 95 })
-    const mdl = model({ context: 200_000, output: 32_000 })
-
-    expect(isOverflow({ cfg: conf, model: mdl, tokens: tokens(167_999) })).toBe(false)
-    expect(isOverflow({ cfg: conf, model: mdl, tokens: tokens(168_000) })).toBe(true)
-  })
-
-  test("uses a model input limit when present", () => {
-    const conf = cfg({ threshold_percent: 75 })
-    const mdl = model({ context: 400_000, input: 200_000, output: 32_000 })
-
-    expect(isOverflow({ cfg: conf, model: mdl, tokens: tokens(149_999) })).toBe(false)
-    expect(isOverflow({ cfg: conf, model: mdl, tokens: tokens(150_000) })).toBe(true)
-  })
-
-  test("ignores a cleared threshold", () => {
-    const conf = cfg({ threshold_percent: null })
-    const mdl = model({ context: 200_000, output: 32_000 })
-
-    expect(isOverflow({ cfg: conf, model: mdl, tokens: tokens(150_000) })).toBe(false)
-    expect(isOverflow({ cfg: conf, model: mdl, tokens: tokens(168_000) })).toBe(true)
-  })
-
-  test("still respects disabled auto-compaction", () => {
-    const conf = cfg({ auto: false, threshold_percent: 75 })
-    const mdl = model({ context: 200_000, output: 32_000 })
-
-    expect(isOverflow({ cfg: conf, model: mdl, tokens: tokens(150_000) })).toBe(false)
-  })
-})