saeeol 1.2.5 → 1.2.8

package/test/saeeol/config-validation.test.ts

@@ -1,183 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import path from "path"
-import { ConfigValidation } from "../../src/overlay/config-validation"
-import { Instance } from "../../src/project/instance"
-import { Config } from "../../src/config/config"
-import { Filesystem } from "../../src/util/filesystem"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-describe("ConfigValidation.check", () => {
-  test("returns empty string for non-config files", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const filepath = path.join(tmp.path, "src", "index.ts")
-    await Filesystem.write(filepath, "export const x = 1")
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: () => ConfigValidation.check(filepath),
-    })
-    expect(result).toBe("")
-  })
-
-  test("validates valid JSONC config", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const filepath = path.join(tmp.path, "saeeol.json")
-    await Filesystem.write(filepath, JSON.stringify({ model: "anthropic/claude-sonnet-4-20250514" }))
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: () => ConfigValidation.check(filepath),
-    })
-    expect(result).toContain("config_validation")
-    expect(result).toContain("validated successfully")
-  })
-
-  test("reports JSONC syntax errors", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const filepath = path.join(tmp.path, "saeeol.json")
-    await Filesystem.write(filepath, '{ "model": "test/model" "extra": true }')
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: () => ConfigValidation.check(filepath),
-    })
-    expect(result).toContain("config_validation")
-    expect(result).toContain("ERROR")
-    expect(result).toContain("not valid JSON(C)")
-  })
-
-  test("reports schema validation errors for unknown fields", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const filepath = path.join(tmp.path, "saeeol.json")
-    // Config.Info uses .strict() so unknown fields produce errors
-    await Filesystem.write(filepath, JSON.stringify({ notAField: true }))
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: () => ConfigValidation.check(filepath),
-    })
-    expect(result).toContain("config_validation")
-    expect(result).toContain("WARNING")
-    expect(result).toContain("invalid")
-  })
-
-  test("validates valid markdown command", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const filepath = path.join(tmp.path, ".saeeol", "command", "test-cmd.md")
-    await Filesystem.write(
-      filepath,
-      `---
-description: A test command
----
-Do something useful`,
-    )
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: () => ConfigValidation.check(filepath),
-    })
-    expect(result).toContain("config_validation")
-    expect(result).toContain("validated successfully")
-  })
-
-  test("reports schema error for command with invalid field types", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const filepath = path.join(tmp.path, ".saeeol", "command", "bad.md")
-    // agent expects string but gets number — schema validation fails
-    await Filesystem.write(
-      filepath,
-      `---
-agent: 123
-subtask: "not-a-boolean"
----
-Do something`,
-    )
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: () => ConfigValidation.check(filepath),
-    })
-    expect(result).toContain("config_validation")
-    expect(result).toContain("WARNING")
-    expect(result).toContain("invalid")
-  })
-
-  test("validates valid markdown agent", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const filepath = path.join(tmp.path, ".saeeol", "agent", "helper.md")
-    await Filesystem.write(
-      filepath,
-      `---
-model: anthropic/claude-sonnet-4-20250514
-description: A helper agent
----
-You are a helpful agent.`,
-    )
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: () => ConfigValidation.check(filepath),
-    })
-    expect(result).toContain("config_validation")
-    expect(result).toContain("validated successfully")
-  })
-
-  test("skips AGENTS.md (root md file not in config subdir)", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const filepath = path.join(tmp.path, "AGENTS.md")
-    await Filesystem.write(filepath, "# Project agents")
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: () => ConfigValidation.check(filepath),
-    })
-    expect(result).toBe("")
-  })
-
-  test("skips plan files (excluded subdir)", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const filepath = path.join(tmp.path, ".saeeol", "plans", "plan.md")
-    await Filesystem.write(filepath, "# Plan")
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: () => ConfigValidation.check(filepath),
-    })
-    expect(result).toBe("")
-  })
-
-  test("includes pre-existing warnings when present", async () => {
-    await using tmp = await tmpdir({
-      git: true,
-      init: async (dir) => {
-        // Create a broken agent config that produces a warning at session start
-        await Filesystem.write(
-          path.join(dir, ".saeeol", "agent", "broken.md"),
-          `---
-mode: "banana"
----
-Broken agent`,
-        )
-      },
-    })
-
-    const filepath = path.join(tmp.path, "saeeol.json")
-    await Filesystem.write(filepath, JSON.stringify({ model: "anthropic/claude-sonnet-4-20250514" }))
-
-    const result = await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // Force config load to populate warnings
-        await Config.get()
-        return ConfigValidation.check(filepath)
-      },
-    })
-    expect(result).toContain("Pre-existing config issues")
-    expect(result).toContain("broken.md")
-    expect(result).toContain("Post-edit validation")
-  })
-})

package/test/saeeol/cost-propagation.test.ts

@@ -1,94 +0,0 @@
-// Verifies SaeeolCostPropagation.propagate() serializes concurrent writes to
-// the same parent assistant message. Without the internal lock, parallel
-// subagent completions race on read-modify-write and lose deltas (#6321).
-
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Bus } from "../../src/bus"
-import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
-import { SaeeolCostPropagation } from "../../src/overlay/session/cost-propagation"
-import { Instance } from "../../src/project/instance"
-import { ProviderID, ModelID } from "../../src/provider/schema"
-import { Session } from "../../src/session/session"
-import { MessageV2 } from "../../src/session/message-v2"
-import { MessageID } from "../../src/session/schema"
-import * as Log from "@saeeol/core/util/log"
-import { disposeAllInstances, provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-Log.init({ print: false })
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-const ref = {
-  providerID: ProviderID.make("test"),
-  modelID: ModelID.make("test-model"),
-}
-
-const it = testEffect(Layer.mergeAll(Session.defaultLayer, Bus.layer, CrossSpawnSpawner.defaultLayer))
-
-const seed = Effect.fn("CostPropagationTest.seed")(function* () {
-  const sessions = yield* Session.Service
-  const chat = yield* sessions.create({ title: "parent" })
-  const user = yield* sessions.updateMessage({
-    id: MessageID.ascending(),
-    role: "user",
-    sessionID: chat.id,
-    agent: "build",
-    model: ref,
-    time: { created: Date.now() },
-  })
-  const assistant: MessageV2.Assistant = {
-    id: MessageID.ascending(),
-    role: "assistant",
-    parentID: user.id,
-    sessionID: chat.id,
-    mode: "build",
-    agent: "build",
-    cost: 0,
-    path: { cwd: "/tmp", root: "/tmp" },
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    modelID: ref.modelID,
-    providerID: ref.providerID,
-    time: { created: Date.now() },
-  }
-  yield* sessions.updateMessage(assistant)
-  return { chat, assistant }
-})
-
-describe("SaeeolCostPropagation.propagate", () => {
-  it.live("sums deltas correctly under parallel execution", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const sessions = yield* Session.Service
-        const { chat, assistant } = yield* seed()
-        const deltas = [0.01, 0.02, 0.04, 0.08, 0.16, 0.32, 0.64, 1.28]
-        yield* Effect.all(
-          deltas.map((d) => SaeeolCostPropagation.propagate(sessions, chat.id, assistant.id, d)),
-          { concurrency: "unbounded" },
-        )
-        const parent = yield* Effect.sync(() => MessageV2.get({ sessionID: chat.id, messageID: assistant.id }))
-        expect(parent.info.role).toBe("assistant")
-        if (parent.info.role !== "assistant") return
-        const total = deltas.reduce((a, b) => a + b, 0)
-        expect(parent.info.cost).toBeCloseTo(total, 6)
-      }),
-    ),
-  )
-
-  it.live("is a no-op when amount is non-positive", () =>
-    provideTmpdirInstance(() =>
-      Effect.gen(function* () {
-        const sessions = yield* Session.Service
-        const { chat, assistant } = yield* seed()
-        yield* SaeeolCostPropagation.propagate(sessions, chat.id, assistant.id, 0)
-        yield* SaeeolCostPropagation.propagate(sessions, chat.id, assistant.id, -1.5)
-        const parent = yield* Effect.sync(() => MessageV2.get({ sessionID: chat.id, messageID: assistant.id }))
-        if (parent.info.role !== "assistant") return
-        expect(parent.info.cost).toBe(0)
-      }),
-    ),
-  )
-})

package/test/saeeol/cost-tracker-extended.test.ts

@@ -1,141 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import * as State from "@/saeeol/cost-tracker/state"
-import { formatCost, formatTotalCost } from "@/saeeol/cost-tracker/format"
-
-describe("CostTracker reset isolation", () => {
-  test("reset clears all accumulated state", () => {
-    State.addSessionCost(5, { input_tokens: 100, output_tokens: 50 }, "model-x")
-    State.addLines(10, 5)
-    State.addAPIDuration(1000, 800)
-    State.addToolDuration(500)
-    State.reset()
-    expect(State.getTotalCost()).toBe(0)
-    expect(State.getLines()).toEqual({ added: 0, removed: 0 })
-    expect(State.getAPIDuration()).toBe(0)
-    expect(State.getDuration()).toBe(0)
-    expect(Object.keys(State.getModelUsage()).length).toBe(0)
-  })
-})
-
-describe("CostTracker addAPIDuration", () => {
-  test("accumulates API durations", () => {
-    State.reset()
-    State.addAPIDuration(500, 400)
-    State.addAPIDuration(300, 250)
-    expect(State.getAPIDuration()).toBe(800)
-  })
-})
-
-describe("CostTracker addToolDuration", () => {
-  test("accumulates tool durations", () => {
-    State.reset()
-    State.addToolDuration(100)
-    State.addToolDuration(200)
-    // tool duration is tracked internally, verified via formatTotalCost
-    const report = formatTotalCost()
-    expect(report).toContain("Total duration")
-  })
-})
-
-describe("CostTracker getUsageForModel", () => {
-  test("returns undefined for unknown model", () => {
-    State.reset()
-    expect(State.getUsageForModel("nonexistent")).toBeUndefined()
-  })
-
-  test("returns usage for known model", () => {
-    State.reset()
-    State.addSessionCost(0.1, { input_tokens: 500, output_tokens: 200 }, "known-model")
-    const usage = State.getUsageForModel("known-model")
-    expect(usage).toBeDefined()
-    expect(usage!.inputTokens).toBe(500)
-    expect(usage!.outputTokens).toBe(200)
-    expect(usage!.costUSD).toBe(0.1)
-  })
-})
-
-describe("CostTracker edge cases", () => {
-  test("zero cost does not break accumulation", () => {
-    State.reset()
-    const returned = State.addSessionCost(0, { input_tokens: 0, output_tokens: 0 }, "free-model")
-    expect(returned).toBe(0)
-    expect(State.getTotalCost()).toBe(0)
-  })
-
-  test("negative lines are handled", () => {
-    State.reset()
-    State.addLines(-5, -2)
-    // internal state tracks raw numbers; no clamping
-    expect(State.getLines()).toEqual({ added: -5, removed: -2 })
-  })
-
-  test("web search requests counted", () => {
-    State.reset()
-    State.addSessionCost(0.01, {
-      input_tokens: 100,
-      output_tokens: 50,
-      server_tool_use: { web_search_requests: 3 },
-    }, "search-model")
-    const usage = State.getUsageForModel("search-model")
-    expect(usage!.webSearchRequests).toBe(3)
-  })
-
-  test("cache tokens accumulated", () => {
-    State.reset()
-    State.addSessionCost(0.01, {
-      input_tokens: 100,
-      output_tokens: 50,
-      cache_read_input_tokens: 80,
-      cache_creation_input_tokens: 20,
-    }, "cache-model")
-    const usage = State.getUsageForModel("cache-model")
-    expect(usage!.cacheReadInputTokens).toBe(80)
-    expect(usage!.cacheCreationInputTokens).toBe(20)
-  })
-
-  test("same model accumulated across calls", () => {
-    State.reset()
-    State.addSessionCost(0.01, { input_tokens: 100, output_tokens: 50 }, "model-a")
-    State.addSessionCost(0.02, { input_tokens: 200, output_tokens: 100 }, "model-a")
-    const usage = State.getUsageForModel("model-a")
-    expect(usage!.inputTokens).toBe(300)
-    expect(usage!.outputTokens).toBe(150)
-    expect(usage!.costUSD).toBeCloseTo(0.03)
-    expect(State.getTotalCost()).toBeCloseTo(0.03)
-  })
-})
-
-describe("formatCost edge cases", () => {
-  test("zero cost", () => {
-    expect(formatCost(0)).toBe("$0.0000")
-  })
-
-  test("boundary at 0.5", () => {
-    // 0.5 is not > 0.5, so uses 4 decimals
-    expect(formatCost(0.5)).toBe("$0.5000")
-  })
-
-  test("just above boundary", () => {
-    expect(formatCost(0.5001)).toBe("$0.50")
-  })
-
-  test("just below boundary", () => {
-    expect(formatCost(0.4999)).toBe("$0.4999")
-  })
-
-  test("very small cost", () => {
-    expect(formatCost(0.0001)).toBe("$0.0001")
-  })
-})
-
-describe("formatTotalCost with multiple models", () => {
-  test("includes all models in report", () => {
-    State.reset()
-    State.addSessionCost(0.1, { input_tokens: 1000, output_tokens: 500 }, "model-alpha")
-    State.addSessionCost(0.2, { input_tokens: 2000, output_tokens: 1000 }, "model-beta")
-    const report = formatTotalCost()
-    expect(report).toContain("model-alpha")
-    expect(report).toContain("model-beta")
-    expect(report).toContain("$0.30")
-  })
-})

package/test/saeeol/cost-tracker.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import * as State from "@/saeeol/cost-tracker/state"
-import { formatCost, formatTotalCost } from "@/saeeol/cost-tracker/format"
-
-describe("CostTracker State", () => {
-  test("starts at zero", () => {
-    State.reset()
-    expect(State.getTotalCost()).toBe(0)
-    expect(State.getAPIDuration()).toBe(0)
-    expect(State.getLines()).toEqual({ added: 0, removed: 0 })
-  })
-
-  test("accumulates cost per model", () => {
-    State.reset()
-    const usage = {
-      input_tokens: 100,
-      output_tokens: 50,
-      cache_read_input_tokens: 10,
-      cache_creation_input_tokens: 5,
-    }
-    State.addSessionCost(0.01, usage, "gpt-4")
-    expect(State.getTotalCost()).toBe(0.01)
-
-    const m = State.getModelUsage()["gpt-4"]
-    expect(m.inputTokens).toBe(100)
-    expect(m.outputTokens).toBe(50)
-    expect(m.costUSD).toBe(0.01)
-  })
-
-  test("accumulates across multiple calls", () => {
-    State.reset()
-    State.addSessionCost(0.02, { input_tokens: 100, output_tokens: 50 }, "model-a")
-    State.addSessionCost(0.03, { input_tokens: 200, output_tokens: 100 }, "model-b")
-    expect(State.getTotalCost()).toBeCloseTo(0.05)
-    expect(Object.keys(State.getModelUsage()).length).toBe(2)
-  })
-
-  test("tracks lines changed", () => {
-    State.reset()
-    State.addLines(10, 3)
-    State.addLines(5, 1)
-    expect(State.getLines()).toEqual({ added: 15, removed: 4 })
-  })
-})
-
-describe("formatCost", () => {
-  test("formats small costs with 4 decimals", () => {
-    expect(formatCost(0.0123)).toBe("$0.0123")
-  })
-
-  test("formats large costs with 2 decimals", () => {
-    expect(formatCost(1.234)).toBe("$1.23")
-  })
-})
-
-describe("formatTotalCost", () => {
-  test("formats complete report", () => {
-    State.reset()
-    State.addSessionCost(0.05, { input_tokens: 1000, output_tokens: 500 }, "test-model")
-    const report = formatTotalCost()
-    expect(report).toContain("$0.05")
-    expect(report).toContain("test-model")
-  })
-})

package/test/saeeol/custom-provider-delete.test.ts

@@ -1,149 +0,0 @@
-//
-// Regression tests for https://github.com/SAEEOL/saeeol/issues/9186
-//
-// When the user removes a model or a variant from a custom provider and saves,
-// the removed entry must disappear from the config on disk. The save path
-// relies on `null` sentinels being allowed in the Provider models record and
-// in the Model variants record so that `mergeConfig` (merge + stripNulls) can
-// delete them cleanly.
-
-import { describe, expect, it } from "bun:test"
-import * as Config from "../../src/config/config"
-import { SaeeolConfig } from "../../src/overlay/config/config"
-
-describe("Config.Info — null sentinels for custom provider deletes", () => {
-  it("accepts a null model value inside a provider", () => {
-    const parsed = Config.Info.zod.safeParse({
-      provider: {
-        myprovider: {
-          name: "My Provider",
-          models: {
-            "model-gone": null,
-          },
-        },
-      },
-    })
-    expect(parsed.success).toBe(true)
-  })
-
-  it("accepts a null provider value", () => {
-    const parsed = Config.Info.zod.safeParse({
-      provider: {
-        myprovider: null,
-      },
-    })
-    expect(parsed.success).toBe(true)
-  })
-
-  it("accepts a null variant value inside a model", () => {
-    const parsed = Config.Info.zod.safeParse({
-      provider: {
-        myprovider: {
-          name: "My Provider",
-          models: {
-            "model-1": {
-              variants: {
-                low: null,
-              },
-            },
-          },
-        },
-      },
-    })
-    expect(parsed.success).toBe(true)
-  })
-})
-
-describe("SaeeolConfig.mergeConfig — custom provider model/variant deletion", () => {
-  it("drops a model from an existing provider when the patch sets it to null", () => {
-    const existing = {
-      provider: {
-        myprovider: {
-          name: "My Provider",
-          models: {
-            "model-keep": { name: "Keep" },
-            "model-gone": { name: "Gone" },
-          },
-        },
-      },
-    } as unknown as Config.Info
-    const patch = {
-      provider: {
-        myprovider: {
-          models: {
-            "model-keep": { name: "Keep" },
-            "model-gone": null,
-          },
-        },
-      },
-    } as unknown as Config.Info
-
-    const merged = SaeeolConfig.mergeConfig(existing, patch)
-    const models = (merged.provider as Record<string, { models: Record<string, unknown> }>).myprovider.models
-    expect(models["model-keep"]).toBeDefined()
-    expect("model-gone" in models).toBe(false)
-  })
-
-  it("drops a provider when the patch sets it to null", () => {
-    const existing = {
-      provider: {
-        myprovider: {
-          name: "My Provider",
-          models: { keep: { name: "Keep" } },
-        },
-        openai: {
-          name: "OpenAI",
-        },
-      },
-    } as unknown as Config.Info
-    const patch = {
-      provider: {
-        myprovider: null,
-      },
-    } as unknown as Config.Info
-
-    const merged = SaeeolConfig.mergeConfig(existing, patch)
-    expect(merged.provider?.openai).toBeDefined()
-    expect("myprovider" in (merged.provider ?? {})).toBe(false)
-  })
-
-  it("drops a variant from an existing model when the patch sets it to null", () => {
-    const existing = {
-      provider: {
-        myprovider: {
-          name: "My Provider",
-          models: {
-            "model-1": {
-              name: "Model One",
-              variants: {
-                high: { reasoningEffort: "high" },
-                low: { reasoningEffort: "low" },
-              },
-            },
-          },
-        },
-      },
-    } as unknown as Config.Info
-    const patch = {
-      provider: {
-        myprovider: {
-          models: {
-            "model-1": {
-              variants: {
-                high: { reasoningEffort: "high" },
-                low: null,
-              },
-            },
-          },
-        },
-      },
-    } as unknown as Config.Info
-
-    const merged = SaeeolConfig.mergeConfig(existing, patch)
-    const variants = (
-      merged.provider as Record<string, { models: Record<string, { variants: Record<string, unknown> }> }>
-    ).myprovider.models["model-1"].variants
-    expect(variants.high).toBeDefined()
-    expect("low" in variants).toBe(false)
-  })
-})