saeeol 1.2.5 → 1.2.7

package/test/saeeol/model-info-panel-utils.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { avgPrice, fmtCachedPrice, fmtContext, fmtPrice } from "../../src/overlay/components/model-info-panel-utils"
-
-describe("model info panel price formatting", () => {
-  test("fmtPrice returns Free for zero", () => {
-    expect(fmtPrice(0)).toBe("Free")
-  })
-
-  test("fmtPrice uses four decimals for very small prices", () => {
-    expect(fmtPrice(0.0095)).toBe("$0.0095/1M")
-  })
-
-  test("fmtPrice uses two decimals for standard prices", () => {
-    expect(fmtPrice(3)).toBe("$3.00/1M")
-  })
-
-  test("fmtCachedPrice returns cache read price when available", () => {
-    expect(fmtCachedPrice({ input: 3, output: 15, cache: { read: 0.3, write: 0 } })).toBe("$0.30/1M")
-  })
-
-  test("fmtCachedPrice returns Free for free models", () => {
-    expect(fmtCachedPrice({ input: 0, output: 0, cache: { read: 0, write: 0 } })).toBe("Free")
-  })
-
-  test("fmtCachedPrice returns null without cache read", () => {
-    expect(fmtCachedPrice({ input: 3, output: 15, cache: { read: 0, write: 0 } })).toBeNull()
-  })
-
-  test("avgPrice uses cache weighted formula when cache read exists", () => {
-    const val = avgPrice({ input: 3, output: 15, cache: { read: 0.3, write: 0 } })
-    expect(val).toBe(2.31)
-  })
-
-  test("avgPrice uses input and output weighted formula without cache read", () => {
-    const val = avgPrice({ input: 3, output: 15, cache: { read: 0, write: 0 } })
-    expect(val).toBe(4.2)
-  })
-})
-
-describe("model info panel context formatting", () => {
-  test("formats thousands as K", () => {
-    expect(fmtContext(128000)).toBe("128K")
-  })
-
-  test("formats millions as M", () => {
-    expect(fmtContext(1000000)).toBe("1M")
-  })
-
-  test("returns exact value for small contexts", () => {
-    expect(fmtContext(800)).toBe("800")
-  })
-})

package/test/saeeol/model-info-panel.types.test.ts

@@ -1,7 +0,0 @@
-import type { Model as SDKModel } from "@saeeol/sdk/v2"
-import { ModelInfoPanel } from "@/saeeol/components/model-info-panel"
-
-type Assert<T extends true> = T
-type Props = Parameters<typeof ModelInfoPanel>[0]
-
-type _SyncModelMatchesPanel = Assert<SDKModel extends Props["model"] ? true : false>

package/test/saeeol/models-401-fallback.test.ts

@@ -1,52 +0,0 @@
-// Integration: when fetchSaeeolModels returns a 401 error result, ModelCache
-// surfaces the failure and caches empty models (allowing re-auth via /connect).
-// The real 401-fallback unit test lives in packages/gateway/test/api/models.test.ts.
-
-import { test, expect, mock } from "bun:test"
-import path from "path"
-import * as Log from "@saeeol/core/util/log"
-
-Log.init({ print: false })
-
-// Simulate a 401 typed error result from the gateway
-mock.module("@saeeol/gateway", () => ({
-  fetchSaeeolModels: async () => ({
-    models: {},
-    error: { kind: "unauthorized", status: 401 },
-  }),
-  SAEEOL_OPENROUTER_BASE: "https://api.saeeol.ai/api/openrouter",
-}))
-
-mock.module("saeeol-copilot-auth", () => ({ default: () => ({}) }))
-mock.module("saeeol-anthropic-auth", () => ({ default: () => ({}) }))
-mock.module("@gitlab/saeeol-gitlab-auth", () => ({ default: () => ({}) }))
-
-import { tmpdir } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-import { ModelCache } from "../../src/provider/model-cache"
-
-const CONFIG = JSON.stringify({ $schema: "https://app.saeeol.ai/config.json" })
-
-async function withInstance<T>(fn: () => Promise<T>): Promise<T> {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(path.join(dir, "saeeol.json"), CONFIG)
-    },
-  })
-  return Instance.provide({ directory: tmp.path, fn })
-}
-
-test("401 from gateway sets provider as failed in ModelCache", async () => {
-  ModelCache.clear("saeeol")
-  await withInstance(() => ModelCache.fetch("saeeol"))
-  expect(ModelCache.failedProviders()).toContain("saeeol")
-  expect(ModelCache.getFailure("saeeol")).toMatchObject({ kind: "unauthorized", status: 401 })
-})
-
-test("401 from gateway caches empty models (not undefined)", async () => {
-  ModelCache.clear("saeeol")
-  await withInstance(() => ModelCache.fetch("saeeol"))
-  const cached = ModelCache.get("saeeol")
-  expect(cached).toBeDefined()
-  expect(Object.keys(cached!)).toHaveLength(0)
-})

package/test/saeeol/modes-migrator.test.ts

@@ -1,320 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { ModesMigrator } from "../../src/overlay/modes-migrator"
-import { tmpdir } from "../fixture/fixture"
-import path from "path"
-
-describe("ModesMigrator", () => {
-  describe("isDefaultMode", () => {
-    test("returns true for default modes", () => {
-      expect(ModesMigrator.isDefaultMode("code")).toBe(true)
-      expect(ModesMigrator.isDefaultMode("architect")).toBe(true)
-      expect(ModesMigrator.isDefaultMode("ask")).toBe(true)
-      expect(ModesMigrator.isDefaultMode("debug")).toBe(true)
-      expect(ModesMigrator.isDefaultMode("orchestrator")).toBe(true)
-    })
-
-    test("returns false for custom modes", () => {
-      expect(ModesMigrator.isDefaultMode("translate")).toBe(false)
-      expect(ModesMigrator.isDefaultMode("my-custom-mode")).toBe(false)
-      expect(ModesMigrator.isDefaultMode("reviewer")).toBe(false)
-    })
-  })
-
-  describe("convertPermissions", () => {
-    test("converts simple groups to permissions and denies missing", () => {
-      const groups = ["read", "edit", "command"]
-      const permissions = ModesMigrator.convertPermissions(groups)
-
-      expect(permissions.read).toBe("allow")
-      expect(permissions.edit).toBe("allow")
-      expect(permissions.bash).toBe("allow")
-      expect(permissions.mcp).toBe("deny") // Not in groups, should be denied
-    })
-
-    test("maps browser group to bash permission", () => {
-      const groups = ["browser"]
-      const permissions = ModesMigrator.convertPermissions(groups)
-
-      expect(permissions.bash).toBe("allow")
-      expect(permissions.read).toBe("deny")
-      expect(permissions.edit).toBe("deny")
-      expect(permissions.mcp).toBe("deny")
-    })
-
-    test("maps mcp group to mcp permission", () => {
-      const groups = ["mcp"]
-      const permissions = ModesMigrator.convertPermissions(groups)
-
-      expect(permissions.mcp).toBe("allow")
-      expect(permissions.read).toBe("deny")
-      expect(permissions.edit).toBe("deny")
-      expect(permissions.bash).toBe("deny")
-    })
-
-    test("converts fileRegex groups to restricted permissions", () => {
-      const groups: ModesMigrator.SaeeolMode["groups"] = [
-        "read",
-        ["edit", { fileRegex: "\\.md$", description: "Markdown only" }],
-      ]
-      const permissions = ModesMigrator.convertPermissions(groups)
-
-      expect(permissions.read).toBe("allow")
-      expect(permissions.edit).toEqual({
-        "\\.md$": "allow",
-        "*": "deny",
-      })
-      expect(permissions.bash).toBe("deny")
-      expect(permissions.mcp).toBe("deny")
-    })
-
-    test("handles tuple without fileRegex", () => {
-      const groups: ModesMigrator.SaeeolMode["groups"] = [["edit", {}]]
-      const permissions = ModesMigrator.convertPermissions(groups)
-
-      expect(permissions.edit).toBe("allow")
-      expect(permissions.read).toBe("deny")
-      expect(permissions.bash).toBe("deny")
-      expect(permissions.mcp).toBe("deny")
-    })
-
-    test("passes through unknown groups but still denies standard permissions", () => {
-      const groups = ["custom-group"]
-      const permissions = ModesMigrator.convertPermissions(groups)
-
-      expect(permissions["custom-group"]).toBe("allow")
-      expect(permissions.read).toBe("deny")
-      expect(permissions.edit).toBe("deny")
-      expect(permissions.bash).toBe("deny")
-      expect(permissions.mcp).toBe("deny")
-    })
-
-    test("denies bash and mcp when only read and edit are allowed", () => {
-      const groups = ["read", "edit"]
-      const permissions = ModesMigrator.convertPermissions(groups)
-
-      expect(permissions.read).toBe("allow")
-      expect(permissions.edit).toBe("allow")
-      expect(permissions.bash).toBe("deny")
-      expect(permissions.mcp).toBe("deny")
-    })
-  })
-
-  describe("convertMode", () => {
-    test("converts full mode to agent config", () => {
-      const mode: ModesMigrator.SaeeolMode = {
-        slug: "translate",
-        name: "Translate",
-        roleDefinition: "You are a translator...",
-        customInstructions: "Translate accurately.",
-        groups: ["read", ["edit", { fileRegex: "\\.json$" }]],
-      }
-
-      const agent = ModesMigrator.convertMode(mode)
-
-      expect(agent.mode).toBe("primary")
-      expect(agent.prompt).toBe("You are a translator...\n\nTranslate accurately.")
-      expect(agent.permission?.read).toBe("allow")
-      expect(agent.permission?.edit).toEqual({
-        "\\.json$": "allow",
-        "*": "deny",
-      })
-    })
-
-    test("uses description when available", () => {
-      const mode: ModesMigrator.SaeeolMode = {
-        slug: "test",
-        name: "Test",
-        roleDefinition: "Role",
-        description: "Custom description",
-        groups: [],
-      }
-
-      const agent = ModesMigrator.convertMode(mode)
-      expect(agent.description).toBe("Custom description")
-    })
-
-    test("falls back to whenToUse for description", () => {
-      const mode: ModesMigrator.SaeeolMode = {
-        slug: "test",
-        name: "Test",
-        roleDefinition: "Role",
-        whenToUse: "When to use this mode",
-        groups: [],
-      }
-
-      const agent = ModesMigrator.convertMode(mode)
-      expect(agent.description).toBe("When to use this mode")
-    })
-
-    test("falls back to name for description", () => {
-      const mode: ModesMigrator.SaeeolMode = {
-        slug: "test",
-        name: "Test Mode",
-        roleDefinition: "Role",
-        groups: [],
-      }
-
-      const agent = ModesMigrator.convertMode(mode)
-      expect(agent.description).toBe("Test Mode")
-    })
-
-    test("handles mode without customInstructions", () => {
-      const mode: ModesMigrator.SaeeolMode = {
-        slug: "test",
-        name: "Test",
-        roleDefinition: "You are a test agent.",
-        groups: ["read"],
-      }
-
-      const agent = ModesMigrator.convertMode(mode)
-      expect(agent.prompt).toBe("You are a test agent.")
-    })
-  })
-
-  describe("readModesFile", () => {
-    test("returns empty array for non-existent file", async () => {
-      const modes = await ModesMigrator.readModesFile("/non/existent/path.yaml")
-      expect(modes).toEqual([])
-    })
-
-    test("reads and parses yaml file", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(
-            path.join(dir, "modes.yaml"),
-            `customModes:
-  - slug: translate
-    name: Translate
-    roleDefinition: You are a translator
-    groups:
-      - read
-      - edit`,
-          )
-        },
-      })
-
-      const modes = await ModesMigrator.readModesFile(path.join(tmp.path, "modes.yaml"))
-      expect(modes).toHaveLength(1)
-      expect(modes[0].slug).toBe("translate")
-      expect(modes[0].name).toBe("Translate")
-    })
-
-    test("returns empty array for file without customModes", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(path.join(dir, "modes.yaml"), "someOtherKey: value")
-        },
-      })
-
-      const modes = await ModesMigrator.readModesFile(path.join(tmp.path, "modes.yaml"))
-      expect(modes).toEqual([])
-    })
-  })
-
-  describe("migrate", () => {
-    test("skips default modes", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(
-            path.join(dir, ".saeeolmodes"),
-            `customModes:
-  - slug: code
-    name: Code
-    roleDefinition: Default code mode
-    groups:
-      - read
-      - edit
-  - slug: translate
-    name: Translate
-    roleDefinition: Custom translator
-    groups:
-      - read`,
-          )
-        },
-      })
-
-      const result = await ModesMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
-
-      expect(result.skipped).toHaveLength(1)
-      expect(result.skipped[0].slug).toBe("code")
-      expect(result.agents).toHaveProperty("translate")
-      expect(result.agents).not.toHaveProperty("code")
-    })
-
-    test("deduplicates modes by slug with later entries winning", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          // Create global settings dir
-          const globalDir = path.join(dir, "global-settings")
-          await Bun.write(
-            path.join(globalDir, "custom_modes.yaml"),
-            `customModes:
-  - slug: translate
-    name: Translate Global
-    roleDefinition: Global translator
-    groups:
-      - read`,
-          )
-
-          // Create project .saeeolmodes (should win)
-          await Bun.write(
-            path.join(dir, ".saeeolmodes"),
-            `customModes:
-  - slug: translate
-    name: Translate Project
-    roleDefinition: Project translator
-    groups:
-      - read
-      - edit`,
-          )
-
-          return globalDir
-        },
-      })
-
-      const result = await ModesMigrator.migrate({
-        projectDir: tmp.path,
-        globalSettingsDir: tmp.extra,
-      })
-
-      expect(result.agents.translate.prompt).toBe("Project translator")
-    })
-
-    test("returns empty agents when no custom modes exist", async () => {
-      await using tmp = await tmpdir()
-
-      const result = await ModesMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
-
-      expect(Object.keys(result.agents)).toHaveLength(0)
-      expect(result.skipped).toHaveLength(0)
-    })
-
-    test("migrates multiple custom modes", async () => {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Bun.write(
-            path.join(dir, ".saeeolmodes"),
-            `customModes:
-  - slug: translate
-    name: Translate
-    roleDefinition: Translator
-    groups:
-      - read
-  - slug: reviewer
-    name: Reviewer
-    roleDefinition: Code reviewer
-    groups:
-      - read
-      - edit`,
-          )
-        },
-      })
-
-      const result = await ModesMigrator.migrate({ projectDir: tmp.path, skipGlobalPaths: true })
-
-      expect(Object.keys(result.agents)).toHaveLength(2)
-      expect(result.agents).toHaveProperty("translate")
-      expect(result.agents).toHaveProperty("reviewer")
-    })
-  })
-})

package/test/saeeol/nvidia-headers.test.ts

@@ -1,74 +0,0 @@
-import { expect } from "bun:test"
-import path from "path"
-import { Effect, Layer } from "effect"
-import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { Env } from "../../src/env"
-import { Provider } from "../../src/provider/provider"
-import { ProviderID } from "../../src/provider/schema"
-
-const it = testEffect(Layer.mergeAll(Provider.defaultLayer, Env.defaultLayer, CrossSpawnSpawner.defaultLayer))
-
-function withNvidiaKey<A, E, R>(self: Effect.Effect<A, E, R>) {
-  return Effect.gen(function* () {
-    const env = yield* Env.Service
-    yield* env.set("NVIDIA_API_KEY", "test-api-key")
-    yield* Effect.addFinalizer(() => env.remove("NVIDIA_API_KEY"))
-    return yield* self
-  })
-}
-
-it.live("nvidia provider includes saeeol billing origin header", () =>
-  provideTmpdirInstance(() =>
-    withNvidiaKey(
-      Provider.Service.use((provider) =>
-        Effect.gen(function* () {
-          const providers = yield* provider.list()
-          const headers = providers[ProviderID.make("nvidia")].options.headers
-
-          expect(headers["HTTP-Referer"]).toBe("https://saeeol.ai/")
-          expect(headers["X-Title"]).toBe("SAEEOL")
-          expect(headers["X-BILLING-INVOKE-ORIGIN"]).toBe("saeeol")
-        }),
-      ),
-    ),
-  ),
-)
-
-it.live("nvidia billing origin header can be overridden from config", () =>
-  provideTmpdirInstance((dir) =>
-    Effect.gen(function* () {
-      yield* Effect.promise(() =>
-        Bun.write(
-          path.join(dir, "saeeol.json"),
-          JSON.stringify({
-            $schema: "https://app.saeeol.ai/config.json",
-            provider: {
-              nvidia: {
-                options: {
-                  headers: {
-                    "X-BILLING-INVOKE-ORIGIN": "CustomOrigin",
-                  },
-                },
-              },
-            },
-          }),
-        ),
-      )
-
-      return yield* withNvidiaKey(
-        Provider.Service.use((provider) =>
-          Effect.gen(function* () {
-            const providers = yield* provider.list()
-            const headers = providers[ProviderID.make("nvidia")].options.headers
-
-            expect(headers["HTTP-Referer"]).toBe("https://saeeol.ai/")
-            expect(headers["X-Title"]).toBe("SAEEOL")
-            expect(headers["X-BILLING-INVOKE-ORIGIN"]).toBe("CustomOrigin")
-          }),
-        ),
-      )
-    }),
-  ),
-)

package/test/saeeol/patch-jsonc.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { applyEdits, modify, findNodeAtLocation, parseTree } from "jsonc-parser"
-
-// Replicate patchJsonc logic locally to test it in isolation
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === "object" && !Array.isArray(value)
-}
-
-function patchJsonc(input: string, patch: unknown, path: string[] = []): string {
-  if (!isRecord(patch)) {
-    const edits = modify(input, path, patch === null ? undefined : patch, {
-      formattingOptions: { insertSpaces: true, tabSize: 2 },
-    })
-    return applyEdits(input, edits)
-  }
-
-  if (path.length > 0) {
-    const tree = parseTree(input)
-    const node = tree && findNodeAtLocation(tree, path)
-    if (node && node.type !== "object") {
-      const edits = modify(input, path, patch, {
-        formattingOptions: { insertSpaces: true, tabSize: 2 },
-      })
-      return applyEdits(input, edits)
-    }
-  }
-
-  return Object.entries(patch).reduce((result, [key, value]) => {
-    if (value === undefined) return result
-    return patchJsonc(result, value, [...path, key])
-  }, input)
-}
-
-describe("patchJsonc scalar-to-object transition", () => {
-  test("sets object when node does not yet exist", () => {
-    const input = `{ "permission": {} }`
-    const result = patchJsonc(input, { permission: { bash: { "*": "ask", uname: "allow" } } })
-    const parsed = JSON.parse(result)
-    expect(parsed.permission.bash).toEqual({ "*": "ask", uname: "allow" })
-  })
-
-  test("transitions permission rule from string to object (the bug scenario)", () => {
-    // bash is stored as a plain string "ask" in the JSONC file
-    const input = `{ "permission": { "bash": "ask" } }`
-    // User adds exception "uname" → "allow"; this would previously throw:
-    // "Can not add index to parent of type string"
-    const result = patchJsonc(input, { permission: { bash: { "*": "ask", uname: "allow" } } })
-    const parsed = JSON.parse(result)
-    expect(parsed.permission.bash).toEqual({ "*": "ask", uname: "allow" })
-  })
-
-  test("does not disturb sibling keys when replacing scalar", () => {
-    const input = `{ "permission": { "bash": "ask", "glob": "allow" } }`
-    const result = patchJsonc(input, { permission: { bash: { "*": "ask", uname: "allow" } } })
-    const parsed = JSON.parse(result)
-    expect(parsed.permission.glob).toBe("allow")
-    expect(parsed.permission.bash).toEqual({ "*": "ask", uname: "allow" })
-  })
-
-  test("updates existing object permission by adding a new key", () => {
-    const input = `{ "permission": { "bash": { "*": "ask" } } }`
-    const result = patchJsonc(input, { permission: { bash: { "*": "ask", uname: "allow" } } })
-    const parsed = JSON.parse(result)
-    expect(parsed.permission.bash).toEqual({ "*": "ask", uname: "allow" })
-  })
-
-  test("plain string permission update still works", () => {
-    const input = `{ "permission": { "bash": "allow" } }`
-    const result = patchJsonc(input, { permission: { bash: "ask" } })
-    const parsed = JSON.parse(result)
-    expect(parsed.permission.bash).toBe("ask")
-  })
-})