saeeol 1.2.4 → 1.2.7

package/test/saeeol/semantic-search.test.ts

@@ -1,186 +0,0 @@
-import { describe, expect, test, spyOn } from "bun:test"
-import path from "path"
-import { Effect, Layer, ManagedRuntime } from "effect"
-import { Agent } from "../../src/agent/agent"
-import { SemanticSearchTool } from "../../src/overlay/tool/semantic-search"
-import { SaeeolIndexing } from "../../src/overlay/indexing"
-import { Instance } from "../../src/project/instance"
-import { tmpdir } from "../fixture/fixture"
-import type { Permission } from "../../src/permission"
-import { SessionID, MessageID } from "../../src/session/schema"
-import { Tool } from "../../src/tool/tool"
-import { Truncate } from "../../src/tool/truncate"
-
-const rt = ManagedRuntime.make(Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer))
-
-async function initTool() {
-  return rt.runPromise(
-    Effect.gen(function* () {
-      const info = yield* SemanticSearchTool
-      return yield* Tool.init(info)
-    }),
-  )
-}
-
-const baseCtx = {
-  sessionID: SessionID.make("ses_test-semantic-search"),
-  messageID: MessageID.make(""),
-  callID: "",
-  agent: "code",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => Effect.void,
-  ask: () => Effect.void,
-} satisfies Tool.Context
-
-describe("tool.semantic_search", () => {
-  test("describes code snippet results", async () => {
-    const tool = await initTool()
-
-    expect(tool.description).toContain("Find code snippets by semantic meaning")
-    expect(tool.description).toContain("Search for an exact symbol")
-  })
-
-  test("throws when query is empty", async () => {
-    const tool = await initTool()
-    expect(rt.runPromise(tool.execute({ query: "" }, baseCtx))).rejects.toThrow("query is required")
-  })
-
-  test("asks permission and forwards normalized relative path to indexing search", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const requests: Array<Omit<Permission.Request, "id" | "sessionID" | "tool">> = []
-        const search = spyOn(SaeeolIndexing, "search").mockResolvedValue([])
-
-        try {
-          const tool = await initTool()
-          const result = await rt.runPromise(
-            tool.execute(
-              {
-                query: "authentication middleware",
-                path: "./src/../src/tool",
-              },
-              {
-                ...baseCtx,
-                ask: (req: Omit<Permission.Request, "id" | "sessionID" | "tool">) => {
-                  requests.push(req)
-                  return Effect.void
-                },
-              },
-            ),
-          )
-
-          expect(requests).toHaveLength(1)
-          expect(requests[0]?.permission).toBe("semantic_search")
-          expect(requests[0]?.metadata).toEqual({
-            query: "authentication middleware",
-            path: "./src/../src/tool",
-          })
-          expect(search).toHaveBeenCalledWith("authentication middleware", path.normalize("src/tool"))
-          expect(result.output).toBe('No relevant code found for "authentication middleware" in src/tool.')
-        } finally {
-          search.mockRestore()
-        }
-      },
-    })
-  })
-
-  test("searches entire workspace when path is omitted", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const search = spyOn(SaeeolIndexing, "search").mockResolvedValue([])
-
-        try {
-          const tool = await initTool()
-          const result = await rt.runPromise(tool.execute({ query: "database connection" }, baseCtx))
-
-          expect(search).toHaveBeenCalledWith("database connection", undefined)
-          expect(result.output).toBe('No relevant code found for "database connection".')
-          expect(result.metadata.results).toEqual([])
-        } finally {
-          search.mockRestore()
-        }
-      },
-    })
-  })
-
-  test("formats and normalizes search results", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const search = spyOn(SaeeolIndexing, "search").mockResolvedValue([
-          {
-            id: "1",
-            score: 0.812345,
-            payload: {
-              filePath: "src\\auth\\index.ts",
-              codeChunk: "export const verify = () => true",
-              startLine: 10,
-              endLine: 18,
-            },
-          },
-          {
-            id: "2",
-            score: 0.7,
-            payload: {
-              filePath: "src/invalid.ts",
-              codeChunk: 123,
-              startLine: 1,
-              endLine: 2,
-            },
-          },
-          {
-            id: "3",
-            score: 0.6,
-            payload: null,
-          },
-        ] as never)
-
-        try {
-          const tool = await initTool()
-          const result = await rt.runPromise(tool.execute({ query: "verify token" }, baseCtx))
-
-          expect(result.metadata.results).toEqual([
-            {
-              filePath: "src/auth/index.ts",
-              score: 0.812345,
-              startLine: 10,
-              endLine: 18,
-              codeChunk: "export const verify = () => true",
-            },
-          ])
-          expect(result.output).toContain('Found 1 result for "verify token".')
-          expect(result.output).toContain("1. src/auth/index.ts:10-18 (score 0.8123)")
-          expect(result.output).toContain("export const verify = () => true")
-        } finally {
-          search.mockRestore()
-        }
-      },
-    })
-  })
-
-  test("rejects paths outside the workspace", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const search = spyOn(SaeeolIndexing, "search").mockResolvedValue([])
-
-        try {
-          const tool = await initTool()
-          expect(rt.runPromise(tool.execute({ query: "auth", path: "../outside" }, baseCtx))).rejects.toThrow(
-            "path must be within the current workspace: ../outside",
-          )
-          expect(search).not.toHaveBeenCalled()
-        } finally {
-          search.mockRestore()
-        }
-      },
-    })
-  })
-})

package/test/saeeol/server/permission-allow-everything.test.ts

@@ -1,125 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Permission } from "../../../src/permission"
-import { PermissionID } from "../../../src/permission/schema"
-import { Instance } from "../../../src/project/instance"
-import { Server } from "../../../src/server/server"
-import { Session } from "../../../src/session/session"
-import { tmpdir } from "../../fixture/fixture"
-
-describe("permission.allowEverything endpoint", () => {
-  test("disables global allow-all and removes wildcard from config", async () => {
-    await using tmp = await tmpdir({ git: true })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const app = Server.Default().app
-
-        // Enable global auto-approve
-        const enable = await app.request("/permission/allow-everything", {
-          method: "POST",
-          headers: { "Content-Type": "application/json", "x-saeeol-directory": tmp.path },
-          body: JSON.stringify({ enable: true }),
-        })
-        expect(enable.status).toBe(200)
-
-        // Disable global auto-approve
-        const disable = await app.request("/permission/allow-everything", {
-          method: "POST",
-          headers: { "Content-Type": "application/json", "x-saeeol-directory": tmp.path },
-          body: JSON.stringify({ enable: false }),
-        })
-        expect(disable.status).toBe(200)
-        expect(await disable.json()).toBe(true)
-
-        // After disabling, permission requests should not be auto-approved
-        const session = await Session.create({})
-        const pending = Permission.ask({
-          id: PermissionID.make("permission_global_disable"),
-          sessionID: session.id,
-          permission: "bash",
-          patterns: ["ls"],
-          metadata: {},
-          always: [],
-          ruleset: [],
-        })
-
-        await Permission.reply({
-          requestID: PermissionID.make("permission_global_disable"),
-          reply: "reject",
-        })
-
-        await expect(pending).rejects.toBeInstanceOf(Permission.RejectedError)
-      },
-    })
-  })
-
-  test("disables session-scoped allow-all without touching global config", async () => {
-    await using tmp = await tmpdir({ git: true })
-
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const app = Server.Default().app
-        const session = await Session.create({
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-
-        await Permission.allowEverything({
-          enable: true,
-          sessionID: session.id,
-        })
-
-        const response = await app.request("/permission/allow-everything", {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "x-saeeol-directory": tmp.path,
-          },
-          body: JSON.stringify({ enable: false, sessionID: session.id }),
-        })
-
-        expect(response.status).toBe(200)
-        expect(await response.json()).toBe(true)
-
-        const next = await Session.get(session.id)
-        expect(next.permission ?? []).toEqual([])
-
-        const pending = Permission.ask({
-          id: PermissionID.make("permission_session_disable"),
-          sessionID: session.id,
-          permission: "bash",
-          patterns: ["ls"],
-          metadata: {},
-          always: [],
-          ruleset: [],
-        })
-
-        await Permission.reply({
-          requestID: PermissionID.make("permission_session_disable"),
-          reply: "reject",
-        })
-
-        await expect(pending).rejects.toBeInstanceOf(Permission.RejectedError)
-
-        const other = await Session.create({})
-        const blocked = Permission.ask({
-          id: PermissionID.make("permission_other_session"),
-          sessionID: other.id,
-          permission: "bash",
-          patterns: ["pwd"],
-          metadata: {},
-          always: [],
-          ruleset: [],
-        })
-
-        await Permission.reply({
-          requestID: PermissionID.make("permission_other_session"),
-          reply: "reject",
-        })
-
-        await expect(blocked).rejects.toBeInstanceOf(Permission.RejectedError)
-      },
-    })
-  })
-})

package/test/saeeol/session/instruction-substitution.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect } from "bun:test"
-import path from "node:path"
-import { Effect, FileSystem, Layer } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-import { NodeFileSystem } from "@effect/platform-node"
-import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Config } from "../../../src/config/config"
-import { emptyConsoleState } from "../../../src/config/console-state"
-import { Instruction } from "../../../src/session/instruction"
-import { MessageID } from "../../../src/session/schema"
-import { Global } from "@saeeol/core/global"
-import { provideTmpdirInstance } from "../../fixture/fixture"
-import { testEffect } from "../../lib/effect"
-
-const it = testEffect(Layer.mergeAll(CrossSpawnSpawner.defaultLayer, NodeFileSystem.layer))
-
-const configLayer = Layer.succeed(
-  Config.Service,
-  Config.Service.of({
-    get: () => Effect.succeed({}),
-    getGlobal: () => Effect.succeed({}),
-    getConsoleState: () => Effect.succeed(emptyConsoleState),
-    update: () => Effect.void,
-    updateGlobal: (config) => Effect.succeed(config),
-    invalidate: () => Effect.void,
-    directories: () => Effect.succeed([]),
-    waitForDependencies: () => Effect.void,
-    warnings: () => Effect.succeed([]),
-  }),
-)
-
-const layer = (dir: string) =>
-  Instruction.layer.pipe(
-    Layer.provide(configLayer),
-    Layer.provide(AppFileSystem.defaultLayer),
-    Layer.provide(FetchHttpClient.layer),
-    Layer.provide(Global.layerWith({ home: dir, config: dir })),
-  )
-
-const write = (filepath: string, content: string) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    yield* fs.makeDirectory(path.dirname(filepath), { recursive: true })
-    yield* fs.writeFileString(filepath, content)
-  })
-
-describe("instruction markdown substitutions", () => {
-  it.live("applies file and env substitutions to nearby AGENTS.md", () =>
-    provideTmpdirInstance((dir) =>
-      Effect.gen(function* () {
-        process.env.SAEEOL_INSTRUCTION_TEST = "env content"
-        yield* write(path.join(dir, "subdir", "guide.md"), "file content")
-        yield* write(
-          path.join(dir, "subdir", "AGENTS.md"),
-          ["# Instructions", "", "{file:guide.md}", "{env:SAEEOL_INSTRUCTION_TEST}"].join("\n"),
-        )
-        yield* write(path.join(dir, "subdir", "nested", "file.ts"), "const value = 1")
-
-        const svc = yield* Instruction.Service
-        const results = yield* svc.resolve([], path.join(dir, "subdir", "nested", "file.ts"), MessageID.ascending())
-
-        expect(results).toHaveLength(1)
-        expect(results[0].content).toContain("file content")
-        expect(results[0].content).toContain("env content")
-        expect(results[0].content).not.toContain("{file:")
-        expect(results[0].content).not.toContain("{env:")
-        delete process.env.SAEEOL_INSTRUCTION_TEST
-      }).pipe(Effect.provide(layer(dir))),
-    ),
-  )
-})

package/test/saeeol/session/platform-attribution.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import * as Log from "@saeeol/core/util/log"
-import { Session as SessionNs } from "@/session/session"
-import { AppRuntime } from "../../../src/effect/app-runtime"
-import { Bus } from "../../../src/bus"
-import { SaeeolSession } from "../../../src/overlay/session"
-import { Instance } from "../../../src/project/instance"
-import { MessageV2 } from "../../../src/session/message-v2"
-import { MessageID, PartID, type SessionID } from "../../../src/session/schema"
-
-const projectRoot = path.join(__dirname, "../../..")
-void Log.init({ print: false })
-
-function create(input?: SessionNs.CreateInput) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create(input)))
-}
-
-function remove(id: SessionID) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.remove(id)))
-}
-
-function updateMessage<T extends MessageV2.Info>(msg: T) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.updateMessage(msg)))
-}
-
-function updatePart<T extends MessageV2.Part>(part: T) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.updatePart(part)))
-}
-
-describe("session platform attribution", () => {
-  test("child sessions inherit the root platform override", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        const root = await create({ platform: "agent-manager" })
-        const child = await create({ parentID: root.id, title: "child" })
-        const attr = SaeeolSession.attribution(child.id)
-
-        expect(SaeeolSession.getPlatformOverride(root.id)).toBe("agent-manager")
-        expect(SaeeolSession.getPlatformOverride(child.id)).toBe("agent-manager")
-        expect(SaeeolSession.resolvePlatform(child.id)).toBe("agent-manager")
-        expect(attr.rootID).toBe(root.id)
-        expect(attr.feature).toBe("agent-manager")
-
-        await remove(root.id)
-      },
-    })
-  })
-})
-
-describe("step-finish token propagation via Bus event", () => {
-  test(
-    "non-zero tokens propagate through PartUpdated event",
-    async () => {
-      await Instance.provide({
-        directory: projectRoot,
-        fn: async () => {
-          const info = await create({})
-
-          const messageID = MessageID.ascending()
-          await updateMessage({
-            id: messageID,
-            sessionID: info.id,
-            role: "user",
-            time: { created: Date.now() },
-            agent: "user",
-            model: { providerID: "test", modelID: "test" },
-            tools: {},
-            mode: "",
-          } as unknown as MessageV2.Info)
-
-          let received: MessageV2.Part | undefined
-          const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, (event) => {
-            received = event.properties.part as MessageV2.Part
-          })
-
-          const tokens = {
-            total: 1500,
-            input: 500,
-            output: 800,
-            reasoning: 200,
-            cache: { read: 100, write: 50 },
-          }
-
-          const part = {
-            id: PartID.ascending(),
-            messageID,
-            sessionID: info.id,
-            type: "step-finish" as const,
-            reason: "stop",
-            cost: 0.005,
-            tokens,
-          }
-
-          await updatePart(part)
-          await new Promise((resolve) => setTimeout(resolve, 100))
-
-          expect(received).toBeDefined()
-          expect(received!.type).toBe("step-finish")
-          const finish = received as MessageV2.StepFinishPart
-          expect(finish.tokens.input).toBe(500)
-          expect(finish.tokens.output).toBe(800)
-          expect(finish.tokens.reasoning).toBe(200)
-          expect(finish.tokens.total).toBe(1500)
-          expect(finish.tokens.cache.read).toBe(100)
-          expect(finish.tokens.cache.write).toBe(50)
-          expect(finish.cost).toBe(0.005)
-          expect(received).not.toBe(part)
-
-          unsub()
-          await remove(info.id)
-        },
-      })
-    },
-    { timeout: 30000 },
-  )
-})

package/test/saeeol/session/session.test.ts

@@ -1,105 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import path from "path"
-import { Session as SessionNs } from "@/session/session"
-import { Bus } from "../../../src/bus"
-import * as Log from "@saeeol/core/util/log"
-import { Instance } from "../../../src/project/instance"
-import { AppRuntime } from "../../../src/effect/app-runtime"
-import { tmpdir } from "../../fixture/fixture"
-import type { SessionID } from "../../../src/session/schema"
-
-const projectRoot = path.join(__dirname, "../../..")
-void Log.init({ print: false })
-
-function create(input?: SessionNs.CreateInput) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.create(input)))
-}
-
-function get(id: SessionID) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.get(id)))
-}
-
-function remove(id: SessionID) {
-  return AppRuntime.runPromise(SessionNs.Service.use((svc) => svc.remove(id)))
-}
-
-describe("session.created event", () => {
-  test("should emit session.created event when session is created", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        let eventReceived = false
-        let receivedInfo: SessionNs.Info | undefined
-
-        const unsub = Bus.subscribe(SessionNs.Event.Created, (event) => {
-          eventReceived = true
-          receivedInfo = event.properties.info as SessionNs.Info
-        })
-
-        const info = await create({})
-        await new Promise((resolve) => setTimeout(resolve, 100))
-        unsub()
-
-        expect(eventReceived).toBe(true)
-        expect(receivedInfo).toBeDefined()
-        expect(receivedInfo?.id).toBe(info.id)
-        expect(receivedInfo?.projectID).toBe(info.projectID)
-        expect(receivedInfo?.directory).toBe(info.directory)
-        expect(receivedInfo?.path).toBe(info.path)
-        expect(receivedInfo?.title).toBe(info.title)
-
-        await remove(info.id)
-      },
-    })
-  })
-
-  test("session.created event should be emitted before session.updated", async () => {
-    await Instance.provide({
-      directory: projectRoot,
-      fn: async () => {
-        const events: string[] = []
-
-        const unsubCreated = Bus.subscribe(SessionNs.Event.Created, () => {
-          events.push("created")
-        })
-
-        const unsubUpdated = Bus.subscribe(SessionNs.Event.Updated, () => {
-          events.push("updated")
-        })
-
-        const info = await create({})
-        await new Promise((resolve) => setTimeout(resolve, 100))
-        unsubCreated()
-        unsubUpdated()
-
-        expect(events).toContain("created")
-        expect(events).toContain("updated")
-        expect(events.indexOf("created")).toBeLessThan(events.indexOf("updated"))
-
-        await remove(info.id)
-      },
-    })
-  })
-})
-
-describe("Session", () => {
-  test("remove works without an instance", async () => {
-    await using tmp = await tmpdir({ git: true })
-
-    const info = await Instance.provide({
-      directory: tmp.path,
-      fn: () => create({ title: "remove-without-instance" }),
-    })
-
-    await expect(async () => {
-      await remove(info.id)
-    }).not.toThrow()
-
-    let missing = false
-    await get(info.id).catch(() => {
-      missing = true
-    })
-
-    expect(missing).toBe(true)
-  })
-})