saeeol 1.3.0 → 1.3.1

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

@@ -0,0 +1,183 @@
+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

@@ -0,0 +1,94 @@
+// 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

@@ -0,0 +1,141 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,149 @@
+//
+// 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)
+  })
+})