saeeol 1.3.0 → 1.4.0

package/test/saeeol/instruction.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect } from "bun:test"
+import path from "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 "@/config/config"
+import { emptyConsoleState } from "@/config/console-state"
+import { Instruction } from "../../src/session/instruction"
+import { Global } from "@saeeol/core/global"
+import { provideInstance, tmpdirScoped } 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 instructionLayer = (global: Partial<Global.Interface>) =>
+  Instruction.layer.pipe(
+    Layer.provide(configLayer),
+    Layer.provide(AppFileSystem.defaultLayer),
+    Layer.provide(FetchHttpClient.layer),
+    Layer.provide(Global.layerWith(global)),
+  )
+
+const provideInstruction =
+  (global: Partial<Global.Interface>) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>) =>
+    self.pipe(Effect.provide(instructionLayer(global)))
+
+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)
+  })
+
+const writeFiles = (dir: string, files: Record<string, string>) =>
+  Effect.all(
+    Object.entries(files).map(([file, content]) => write(path.join(dir, file), content)),
+    { discard: true },
+  )
+
+const tmpWithFiles = (files: Record<string, string>) =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped()
+    yield* writeFiles(dir, files)
+    return dir
+  })
+
+const withConfigDir =
+  (value: string | undefined) =>
+  <A, E, R>(self: Effect.Effect<A, E, R>) =>
+    Effect.gen(function* () {
+      const original = process.env["SAEEOL_CONFIG_DIR"]
+      if (value === undefined) delete process.env["SAEEOL_CONFIG_DIR"]
+      else process.env["SAEEOL_CONFIG_DIR"] = value
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => {
+          if (original === undefined) delete process.env["SAEEOL_CONFIG_DIR"]
+          else process.env["SAEEOL_CONFIG_DIR"] = original
+        }),
+      )
+      return yield* self
+    })
+
+describe("Instruction.systemPaths SAEEOL_CONFIG_DIR profile fallback", () => {
+  it.live("prefers SAEEOL_CONFIG_DIR AGENTS.md over global when both exist", () =>
+    Effect.gen(function* () {
+      const profileTmp = yield* tmpWithFiles({ "AGENTS.md": "# Profile Instructions" })
+      const globalTmp = yield* tmpWithFiles({ "AGENTS.md": "# Global Instructions" })
+      const projectTmp = yield* tmpdirScoped()
+
+      yield* Effect.gen(function* () {
+        const svc = yield* Instruction.Service
+        const paths = yield* svc.systemPaths()
+        expect(paths.has(path.join(profileTmp, "AGENTS.md"))).toBe(true)
+        expect(paths.has(path.join(globalTmp, "AGENTS.md"))).toBe(false)
+      }).pipe(
+        provideInstance(projectTmp),
+        provideInstruction({ home: globalTmp, config: globalTmp }),
+        withConfigDir(profileTmp),
+      )
+    }),
+  )
+
+  it.live("falls back to global AGENTS.md when SAEEOL_CONFIG_DIR has no AGENTS.md", () =>
+    Effect.gen(function* () {
+      const profileTmp = yield* tmpdirScoped()
+      const globalTmp = yield* tmpWithFiles({ "AGENTS.md": "# Global Instructions" })
+      const projectTmp = yield* tmpdirScoped()
+
+      yield* Effect.gen(function* () {
+        const svc = yield* Instruction.Service
+        const paths = yield* svc.systemPaths()
+        expect(paths.has(path.join(profileTmp, "AGENTS.md"))).toBe(false)
+        expect(paths.has(path.join(globalTmp, "AGENTS.md"))).toBe(true)
+      }).pipe(
+        provideInstance(projectTmp),
+        provideInstruction({ home: globalTmp, config: globalTmp }),
+        withConfigDir(profileTmp),
+      )
+    }),
+  )
+
+  it.live("uses global AGENTS.md when SAEEOL_CONFIG_DIR is not set", () =>
+    Effect.gen(function* () {
+      const globalTmp = yield* tmpWithFiles({ "AGENTS.md": "# Global Instructions" })
+      const projectTmp = yield* tmpdirScoped()
+
+      yield* Effect.gen(function* () {
+        const svc = yield* Instruction.Service
+        const paths = yield* svc.systemPaths()
+        expect(paths.has(path.join(globalTmp, "AGENTS.md"))).toBe(true)
+      }).pipe(
+        provideInstance(projectTmp),
+        provideInstruction({ home: globalTmp, config: globalTmp }),
+        withConfigDir(undefined),
+      )
+    }),
+  )
+})

package/test/saeeol/lancedb-runtime.test.ts

@@ -0,0 +1,116 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test"
+
+const entry = "file:///tmp/saeeol-cache/node_modules/@lancedb/lancedb/dist/index.js"
+const add = mock(async () => ({ directory: "/tmp/saeeol-cache", entrypoint: entry }))
+const real = await import("@saeeol/core/npm")
+
+mock.module("@saeeol/core/npm", () => ({
+  ...real,
+  Npm: {
+    ...real.Npm,
+    add,
+  },
+}))
+
+const env = "SAEEOL_LANCEDB_PATH"
+const prev = process.env[env]
+
+describe("LanceDBRuntime", () => {
+  beforeEach(async () => {
+    const { LanceDBRuntime } = await import("../../src/overlay/lancedb")
+    LanceDBRuntime.clear()
+    add.mockClear()
+    add.mockImplementation(async () => ({ directory: "/tmp/saeeol-cache", entrypoint: entry }))
+  })
+
+  afterEach(async () => {
+    const { LanceDBRuntime } = await import("../../src/overlay/lancedb")
+    LanceDBRuntime.clear()
+    if (prev === undefined) delete process.env[env]
+    if (prev !== undefined) process.env[env] = prev
+  })
+
+  test("skips installation for non-lancedb backends", async () => {
+    const { LanceDBRuntime } = await import("../../src/overlay/lancedb")
+
+    await LanceDBRuntime.ensure("qdrant")
+
+    expect(add).not.toHaveBeenCalled()
+    expect(process.env[env]).toBeUndefined()
+  })
+
+  test("installs the pinned package and exports a file URL for lancedb", async () => {
+    const { LanceDBRuntime } = await import("../../src/overlay/lancedb")
+
+    await LanceDBRuntime.ensure("lancedb")
+
+    expect(add).toHaveBeenCalledWith("@lancedb/lancedb@0.26.2")
+    expect(process.env[env]).toBe(entry)
+  })
+
+  test("exposes every LanceDB package that must stay external to bun compile", async () => {
+    const { LanceDBRuntime } = await import("../../src/overlay/lancedb")
+
+    expect(LanceDBRuntime.external).toEqual([
+      "@lancedb/lancedb",
+      "@lancedb/lancedb-darwin-arm64",
+      "@lancedb/lancedb-linux-arm64-gnu",
+      "@lancedb/lancedb-linux-arm64-musl",
+      "@lancedb/lancedb-linux-x64-gnu",
+      "@lancedb/lancedb-linux-x64-musl",
+      "@lancedb/lancedb-win32-arm64-msvc",
+      "@lancedb/lancedb-win32-x64-msvc",
+    ])
+  })
+
+  test("skips install when runtime path is already set", async () => {
+    const { LanceDBRuntime } = await import("../../src/overlay/lancedb")
+    process.env[env] = "file:///already/set.js"
+
+    await LanceDBRuntime.ensure("lancedb")
+
+    expect(add).not.toHaveBeenCalled()
+    expect(process.env[env]).toBe("file:///already/set.js")
+  })
+
+  test("dedupes concurrent ensure calls", async () => {
+    const { LanceDBRuntime } = await import("../../src/overlay/lancedb")
+
+    await Promise.all([
+      LanceDBRuntime.ensure("lancedb"),
+      LanceDBRuntime.ensure("lancedb"),
+      LanceDBRuntime.ensure("lancedb"),
+    ])
+
+    expect(add).toHaveBeenCalledTimes(1)
+    expect(process.env[env]).toBe(entry)
+  })
+
+  test("surfaces install failures without swallowing them", async () => {
+    const { LanceDBRuntime } = await import("../../src/overlay/lancedb")
+    add.mockImplementationOnce(async () => {
+      throw new Error("registry unavailable")
+    })
+
+    await expect(LanceDBRuntime.ensure("lancedb")).rejects.toThrow("registry unavailable")
+    expect(process.env[env]).toBeUndefined()
+  })
+
+  test("retries after a failed install", async () => {
+    const { LanceDBRuntime } = await import("../../src/overlay/lancedb")
+    add
+      .mockImplementationOnce(async () => {
+        throw new Error("install failed")
+      })
+      .mockImplementationOnce(async () => ({ directory: "/tmp/saeeol-cache", entrypoint: entry }))
+
+    await expect(LanceDBRuntime.ensure("lancedb")).rejects.toThrow("install failed")
+    expect(process.env[env]).toBeUndefined()
+    expect(add).toHaveBeenCalledTimes(1)
+
+    await LanceDBRuntime.ensure("lancedb")
+
+    expect(add).toHaveBeenCalledTimes(2)
+    expect(process.env[env]).toBe(entry)
+  })
+})

package/test/saeeol/loader-auth.test.ts

@@ -0,0 +1,168 @@
+//
+// Tests that the saeeol custom loader keeps paid models visible without authentication.
+// Mocks fetchSaeeolModels from @saeeol/gateway to avoid real network
+// calls (which fail on Windows CI).
+
+import { test, expect, mock } from "bun:test"
+import path from "path"
+import { unlink } from "fs/promises"
+
+// Bun's mock.module() is process-wide and permanent — it replaces the module
+// for ALL test files in the same runner process. To avoid breaking other tests
+// that import @saeeol/gateway, we spread the real exports and only
+// override fetchSaeeolModels with a stub that returns both free and paid models.
+const real = await import("@saeeol/gateway")
+
+mock.module("@saeeol/gateway", () => ({
+  ...real,
+  fetchSaeeolModels: async () => ({
+    models: {
+      "free-model": {
+        id: "free-model",
+        name: "Free Model",
+        cost: { input: 0, output: 0 },
+        limit: { context: 128000, output: 4096 },
+      },
+      "paid-model": {
+        id: "paid-model",
+        name: "Paid Model",
+        cost: { input: 1.0, output: 2.0 },
+        limit: { context: 128000, output: 4096 },
+      },
+    },
+  }),
+}))
+
+import { tmpdir } from "../fixture/fixture"
+import { Global } from "@saeeol/core/global"
+import { Instance } from "../../src/project/instance"
+import { Provider } from "../../src/provider/provider"
+import { ProviderID } from "../../src/provider/schema"
+import { Filesystem } from "../../src/util/filesystem"
+import { ModelCache } from "../../src/provider/model-cache"
+import { Auth } from "../../src/auth"
+
+function paid(providers: Awaited<ReturnType<typeof Provider.list>>) {
+  const item = providers[ProviderID.saeeol]
+  expect(item).toBeDefined()
+  return Object.values(item.models).filter((model) => model.cost.input > 0).length
+}
+
+test("saeeol loader keeps paid models without auth and when config apiKey is present", async () => {
+  // Reset state that may be stale from other test files sharing this process.
+  // Auth.set from other tests persists in the shared auth.json,
+  // and ModelCache keeps fetched models in a TTL map.
+  // ModelsDev.Data was removed in v1.14.33 — instance-store disposal handles cache invalidation.
+  await Auth.remove("saeeol")
+  ModelCache.clear("saeeol")
+
+  await using base = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "saeeol.json"),
+        JSON.stringify({
+          $schema: "https://app.saeeol.ai/config.json",
+        }),
+      )
+    },
+  })
+
+  const none = await Instance.provide({
+    directory: base.path,
+    fn: async () => paid(await Provider.list()),
+  })
+
+  await using keyed = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "saeeol.json"),
+        JSON.stringify({
+          $schema: "https://app.saeeol.ai/config.json",
+          provider: {
+            saeeol: {
+              options: {
+                apiKey: "test-key",
+              },
+            },
+          },
+        }),
+      )
+    },
+  })
+
+  const count = await Instance.provide({
+    directory: keyed.path,
+    fn: async () => paid(await Provider.list()),
+  })
+
+  expect(none).toBeGreaterThan(0)
+  expect(count).toBeGreaterThan(0)
+})
+
+test("saeeol loader keeps paid models without auth and when auth exists", async () => {
+  await Auth.remove("saeeol")
+  ModelCache.clear("saeeol")
+
+  await using base = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "saeeol.json"),
+        JSON.stringify({
+          $schema: "https://app.saeeol.ai/config.json",
+        }),
+      )
+    },
+  })
+
+  const none = await Instance.provide({
+    directory: base.path,
+    fn: async () => paid(await Provider.list()),
+  })
+
+  await using keyed = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        path.join(dir, "saeeol.json"),
+        JSON.stringify({
+          $schema: "https://app.saeeol.ai/config.json",
+        }),
+      )
+    },
+  })
+
+  const authPath = path.join(Global.Path.data, "auth.json")
+  let prev: string | undefined
+
+  try {
+    prev = await Filesystem.readText(authPath)
+  } catch {}
+
+  try {
+    await Filesystem.write(
+      authPath,
+      JSON.stringify({
+        saeeol: {
+          type: "api",
+          key: "test-key",
+        },
+      }),
+    )
+
+    const count = await Instance.provide({
+      directory: keyed.path,
+      fn: async () => paid(await Provider.list()),
+    })
+
+    expect(none).toBeGreaterThan(0)
+    expect(count).toBeGreaterThan(0)
+  } finally {
+    if (prev !== undefined) {
+      await Filesystem.write(authPath, prev)
+    }
+    if (prev === undefined) {
+      try {
+        await unlink(authPath)
+      } catch {}
+    }
+  }
+})