saeeol 1.2.4 → 1.2.7

package/test/saeeol/stats-subagent-cost.test.ts

@@ -1,123 +0,0 @@
-// Verifies `saeeol stats` does not double-count subagent cost while still
-// including child-session messages, tokens, tools, and model usage. The task
-// tool propagates each child session's total cost up to the parent's
-// tool-wrapper assistant message (#6321).
-
-import { afterEach, describe, expect, test } from "bun:test"
-import { aggregateSessionStats } from "../../src/cli/cmd/stats"
-import { MessageV2 } from "../../src/session/message-v2"
-import { Instance } from "../../src/project/instance"
-import { ProviderID, ModelID } from "../../src/provider/schema"
-import { Session } from "../../src/session/session"
-import { MessageID, PartID } from "../../src/session/schema"
-import * as Log from "@saeeol/core/util/log"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-
-Log.init({ print: false })
-
-afterEach(async () => {
-  await disposeAllInstances()
-})
-
-const ref = {
-  providerID: ProviderID.make("test"),
-  modelID: ModelID.make("test-model"),
-}
-
-function assistant(sessionID: string, parentID: string, cost: number): MessageV2.Assistant {
-  return {
-    id: MessageID.ascending(),
-    role: "assistant",
-    parentID: parentID as any,
-    sessionID: sessionID as any,
-    mode: "build",
-    agent: "build",
-    cost,
-    path: { cwd: "/tmp", root: "/tmp" },
-    tokens: { input: 10, output: 5, reasoning: 0, cache: { read: 0, write: 0 } },
-    modelID: ref.modelID,
-    providerID: ref.providerID,
-    time: { created: Date.now() },
-  }
-}
-
-async function step(sessionID: string, messageID: string, cost: number) {
-  await Session.updatePart({
-    id: PartID.ascending(),
-    messageID: messageID as any,
-    sessionID: sessionID as any,
-    type: "step-finish",
-    reason: "stop",
-    cost,
-    tokens: { total: 15, input: 10, output: 5, reasoning: 0, cache: { read: 0, write: 0 } },
-  })
-}
-
-async function tool(sessionID: string, messageID: string) {
-  const time = Date.now()
-  await Session.updatePart({
-    id: PartID.ascending(),
-    messageID: messageID as any,
-    sessionID: sessionID as any,
-    type: "tool",
-    callID: "call_1",
-    tool: "bash",
-    state: {
-      status: "completed",
-      input: {},
-      output: "ok",
-      title: "bash",
-      metadata: {},
-      time: { start: time, end: time },
-    },
-  })
-}
-
-describe("stats subagent cost", () => {
-  test("counts child usage without double-counting propagated cost", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const parent = await Session.create({ title: "root" })
-        const child = await Session.create({ parentID: parent.id, title: "subagent" })
-
-        const userMsg = await Session.updateMessage({
-          id: MessageID.ascending(),
-          role: "user",
-          sessionID: parent.id,
-          agent: "build",
-          model: ref,
-          time: { created: Date.now() },
-        } as any)
-        const parentMsg = await Session.updateMessage(assistant(parent.id, userMsg.id, 1.5))
-        await step(parent.id, parentMsg.id, 1)
-
-        const childUser = await Session.updateMessage({
-          id: MessageID.ascending(),
-          role: "user",
-          sessionID: child.id,
-          agent: "general",
-          model: ref,
-          time: { created: Date.now() },
-        } as any)
-        const childMsg = await Session.updateMessage(assistant(child.id, childUser.id, 0.5))
-        await step(child.id, childMsg.id, 0.5)
-        await tool(child.id, childMsg.id)
-
-        const stats = await aggregateSessionStats()
-        const model = stats.modelUsage["test/test-model"]!
-        expect(stats.totalCost).toBeCloseTo(1.5, 6)
-        expect(stats.totalSessions).toBe(2)
-        expect(stats.totalMessages).toBe(4)
-        expect(stats.totalTokens.input).toBe(20)
-        expect(stats.totalTokens.output).toBe(10)
-        expect(stats.toolUsage.bash).toBe(1)
-        expect(model.messages).toBe(2)
-        expect(model.tokens.input).toBe(20)
-        expect(model.tokens.output).toBe(10)
-        expect(model.cost).toBeCloseTo(1.5, 6)
-      },
-    })
-  })
-})

package/test/saeeol/suggestion/auto-dismiss.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { SaeeolSessionPromptQueue } from "../../../src/overlay/session/prompt-queue"
-import { Suggestion } from "../../../src/overlay/suggestion"
-import { Instance } from "../../../src/project/instance"
-import { MessageID, SessionID } from "../../../src/session/schema"
-import { tmpdir } from "../../fixture/fixture"
-
-describe("Suggestion.show auto-dismiss on queued followup", () => {
-  test("show rejects immediately when a followup is queued on the session", async () => {
-    // A tool that calls Suggestion.show after a queued prompt has arrived would
-    // otherwise block the turn on user input. Verify the pre-emptive
-    // hasFollowup check rejects with DismissedError before any pending entry
-    // is registered or a Shown event is published.
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const sessionID = SessionID.make("ses_auto_show")
-        const started = Promise.withResolvers<void>()
-        const release = Promise.withResolvers<void>()
-
-        // Slot 1 stays running so activeSince is pinned to its seq.
-        const first = Effect.runPromise(
-          SaeeolSessionPromptQueue.enqueue(
-            sessionID,
-            MessageID.make("message_show_1"),
-            Effect.gen(function* () {
-              started.resolve()
-              yield* Effect.promise(() => release.promise)
-              return "first" as const
-            }),
-            Effect.succeed("first-cancelled" as const),
-          ),
-        )
-        await started.promise
-
-        // Slot 2 arrives while slot 1 is active — latest > activeSince.
-        const second = Effect.runPromise(
-          SaeeolSessionPromptQueue.enqueue(
-            sessionID,
-            MessageID.make("message_show_2"),
-            Effect.succeed("second" as const),
-            Effect.succeed("second-cancelled" as const),
-          ),
-        )
-        await Bun.sleep(10)
-        expect(SaeeolSessionPromptQueue.hasFollowup(sessionID)).toBe(true)
-
-        await expect(
-          Suggestion.show({
-            sessionID,
-            text: "Run review?",
-            actions: [{ label: "Review", prompt: "/local-review-uncommitted" }],
-          }),
-        ).rejects.toBeInstanceOf(Suggestion.DismissedError)
-        expect(await Suggestion.list()).toEqual([])
-
-        release.resolve()
-        expect(await first).toBe("first")
-        expect(await second).toBe("second")
-      },
-    })
-  })
-})

package/test/saeeol/suggestion/suggestion.test.ts

@@ -1,145 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Instance } from "../../../src/project/instance"
-import { Suggestion } from "../../../src/overlay/suggestion"
-import { tmpdir } from "../../fixture/fixture"
-
-describe("suggestion", () => {
-  test("show adds pending request with blocking flag", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const pending = Suggestion.show({
-          sessionID: "ses_test",
-          text: "Run review?",
-          blocking: false,
-          actions: [{ label: "Start", description: "Run it", prompt: "/local-review-uncommitted" }],
-        })
-
-        const list = await Suggestion.list()
-        expect(list).toHaveLength(1)
-        expect(list[0]?.blocking).toBe(false)
-        expect(list[0]?.text).toBe("Run review?")
-
-        await Suggestion.dismiss(list[0]!.id)
-        await expect(pending).rejects.toBeInstanceOf(Suggestion.DismissedError)
-      },
-    })
-  })
-
-  test("accept resolves selected action and removes pending request", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const ask = Suggestion.show({
-          sessionID: "ses_test",
-          text: "Next step?",
-          actions: [
-            { label: "Review", description: "Start review", prompt: "/local-review-uncommitted" },
-            { label: "Test", description: "Run tests", prompt: "Run the relevant tests now." },
-          ],
-        })
-
-        const list = await Suggestion.list()
-        await Suggestion.accept({ requestID: list[0]!.id, index: 1 })
-
-        await expect(ask).resolves.toEqual({
-          label: "Test",
-          description: "Run tests",
-          prompt: "Run the relevant tests now.",
-        })
-        await expect(Suggestion.list()).resolves.toEqual([])
-      },
-    })
-  })
-
-  test("dismiss rejects pending request and removes it", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const ask = Suggestion.show({
-          sessionID: "ses_test",
-          text: "Review changes?",
-          actions: [{ label: "Start", prompt: "/local-review-uncommitted" }],
-        })
-
-        const list = await Suggestion.list()
-        await Suggestion.dismiss(list[0]!.id)
-
-        await expect(ask).rejects.toBeInstanceOf(Suggestion.DismissedError)
-        await expect(Suggestion.list()).resolves.toEqual([])
-      },
-    })
-  })
-
-  test("dismissAll clears all pending suggestions for the target session", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // Two suggestions for session A
-        const a1 = Suggestion.show({
-          sessionID: "ses_a",
-          text: "Review?",
-          actions: [{ label: "Go", prompt: "/review" }],
-        })
-        const a2 = Suggestion.show({
-          sessionID: "ses_a",
-          text: "Test?",
-          actions: [{ label: "Run", prompt: "/test" }],
-        })
-
-        // One suggestion for session B
-        const b1 = Suggestion.show({
-          sessionID: "ses_b",
-          text: "Deploy?",
-          actions: [{ label: "Ship", prompt: "/deploy" }],
-        })
-
-        expect(await Suggestion.list()).toHaveLength(3)
-
-        // Track whether B's promise settles
-        let settled = false
-        b1.then(() => {
-          settled = true
-        }).catch(() => {
-          settled = true
-        })
-
-        // Dismiss all for session A only
-        await Suggestion.dismissAll("ses_a")
-
-        // Both A promises should reject
-        await expect(a1).rejects.toBeInstanceOf(Suggestion.DismissedError)
-        await expect(a2).rejects.toBeInstanceOf(Suggestion.DismissedError)
-
-        // Flush microtasks to see if B settled
-        await new Promise((r) => setTimeout(r, 10))
-        expect(settled).toBe(false)
-
-        // Only B's suggestion remains
-        const remaining = await Suggestion.list()
-        expect(remaining).toHaveLength(1)
-        expect(remaining[0]?.sessionID).toBe("ses_b")
-
-        // Clean up B
-        await Suggestion.dismiss(remaining[0]!.id)
-        await expect(b1).rejects.toBeInstanceOf(Suggestion.DismissedError)
-      },
-    })
-  })
-
-  test("dismissAll is a no-op when no suggestions exist", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        // Should not throw
-        await Suggestion.dismissAll("ses_nonexistent")
-        expect(await Suggestion.list()).toEqual([])
-      },
-    })
-  })
-})

package/test/saeeol/suggestion/tool.test.ts

@@ -1,298 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, spyOn } from "bun:test"
-import { Effect, Layer, ManagedRuntime } from "effect"
-import { Command } from "../../../src/command"
-import { Suggestion } from "../../../src/overlay/suggestion"
-import { SuggestTool } from "../../../src/overlay/suggestion/tool"
-import { Tool } from "../../../src/tool/tool"
-import { Truncate } from "../../../src/tool/truncate"
-import { Agent } from "../../../src/agent/agent"
-import { SessionStatus } from "../../../src/session/status"
-
-const toolRuntime = ManagedRuntime.make(Layer.mergeAll(Truncate.defaultLayer, Agent.defaultLayer))
-
-async function initTool() {
-  return toolRuntime.runPromise(
-    Effect.gen(function* () {
-      const info = yield* SuggestTool
-      return yield* Tool.init(info)
-    }),
-  )
-}
-
-const ctx = {
-  sessionID: "ses_test",
-  messageID: "msg_assistant",
-  callID: "call_suggest",
-  agent: "code",
-  abort: AbortSignal.any([]),
-  messages: [
-    {
-      info: {
-        id: "msg_user",
-        role: "user",
-        sessionID: "ses_test",
-        time: { created: 1 },
-        agent: "code",
-        model: { providerID: "openai", modelID: "gpt-4" },
-      },
-      parts: [],
-    },
-  ],
-  metadata: () => {},
-  ask: () => Effect.void,
-}
-
-describe("tool.suggest", () => {
-  let show: ReturnType<typeof spyOn>
-  let cmdGet: ReturnType<typeof spyOn>
-  let statusSet: ReturnType<typeof spyOn>
-
-  beforeEach(() => {
-    show = spyOn(Suggestion, "show")
-    cmdGet = spyOn(Command, "get")
-    statusSet = spyOn(SessionStatus, "set").mockResolvedValue(undefined as any)
-  })
-
-  afterEach(() => {
-    show.mockRestore()
-    cmdGet.mockRestore()
-    statusSet.mockRestore()
-  })
-
-  test("returns dismissal result when suggestion is dismissed", async () => {
-    const tool = await initTool()
-    show.mockRejectedValueOnce(new Suggestion.DismissedError())
-
-    const result = await toolRuntime.runPromise(
-      tool.execute(
-        {
-          suggest: "Run review?",
-          actions: [{ label: "Start", prompt: "/local-review-uncommitted" }],
-        },
-        ctx as any,
-      ),
-    )
-
-    expect(result.title).toBe("Suggestion dismissed")
-    expect(result.output).toBe("User dismissed the suggestion.")
-    expect(result.metadata.dismissed).toBe(true)
-  })
-
-  test("resolves command template for slash-command action prompt", async () => {
-    const tool = await initTool()
-    show.mockResolvedValueOnce({
-      label: "Start review",
-      description: "Run a local review now",
-      prompt: "/local-review-uncommitted",
-    })
-    cmdGet.mockResolvedValueOnce({
-      name: "local-review-uncommitted",
-      description: "local review (uncommitted changes)",
-      template: Promise.resolve("Review these uncommitted changes:\n\n## Files Changed\n..."),
-      hints: [],
-    })
-
-    const result = await toolRuntime.runPromise(
-      tool.execute(
-        {
-          suggest: "Run review?",
-          actions: [{ label: "Start review", prompt: "/local-review-uncommitted" }],
-        },
-        ctx as any,
-      ),
-    )
-
-    expect(result.title).toBe("User accepted: Start review")
-    expect(result.output).toContain("Review these uncommitted changes:")
-    expect(result.output).toContain("Carry out the following request now")
-    expect(result.metadata.dismissed).toBe(false)
-    expect(result.metadata.accepted).toEqual({
-      label: "Start review",
-      description: "Run a local review now",
-      prompt: "/local-review-uncommitted",
-    })
-    expect(cmdGet).toHaveBeenCalledWith("local-review-uncommitted")
-  })
-
-  test("returns plain-text prompt directly for non-command actions", async () => {
-    const tool = await initTool()
-    show.mockResolvedValueOnce({
-      label: "Run tests",
-      prompt: "Run the test suite and fix any failures",
-    })
-
-    const result = await toolRuntime.runPromise(
-      tool.execute(
-        {
-          suggest: "Tests might need running",
-          actions: [{ label: "Run tests", prompt: "Run the test suite and fix any failures" }],
-        },
-        ctx as any,
-      ),
-    )
-
-    expect(result.title).toBe("User accepted: Run tests")
-    expect(result.output).toContain("Run the test suite and fix any failures")
-    expect(result.output).toContain("Carry out the following request now")
-    expect(result.metadata.dismissed).toBe(false)
-    expect(cmdGet).not.toHaveBeenCalled()
-  })
-
-  test("falls back to raw prompt when command is not found", async () => {
-    const tool = await initTool()
-    show.mockResolvedValueOnce({
-      label: "Unknown cmd",
-      prompt: "/nonexistent-command",
-    })
-    cmdGet.mockResolvedValueOnce(undefined)
-
-    const result = await toolRuntime.runPromise(
-      tool.execute(
-        {
-          suggest: "Try this?",
-          actions: [{ label: "Unknown cmd", prompt: "/nonexistent-command" }],
-        },
-        ctx as any,
-      ),
-    )
-
-    expect(result.title).toBe("User accepted: Unknown cmd")
-    expect(result.output).toContain("/nonexistent-command")
-    expect(result.metadata.dismissed).toBe(false)
-  })
-
-  test("falls back to raw prompt when template resolution fails", async () => {
-    const tool = await initTool()
-    show.mockResolvedValueOnce({
-      label: "Start review",
-      prompt: "/local-review-uncommitted",
-    })
-    cmdGet.mockResolvedValueOnce({
-      name: "local-review-uncommitted",
-      description: "local review (uncommitted changes)",
-      template: Promise.reject(new Error("git not found")),
-      hints: [],
-    })
-
-    const result = await toolRuntime.runPromise(
-      tool.execute(
-        {
-          suggest: "Run review?",
-          actions: [{ label: "Start review", prompt: "/local-review-uncommitted" }],
-        },
-        ctx as any,
-      ),
-    )
-
-    expect(result.title).toBe("User accepted: Start review")
-    expect(result.output).toContain("/local-review-uncommitted")
-    expect(result.metadata.dismissed).toBe(false)
-  })
-
-  // The suggest tool must emit non-blocking suggestions so the main CLI input
-  // stays focused and submittable while the picker is visible (matches the
-  // VS Code extension). Blocking suggestions hide the main prompt entirely.
-  test("emits non-blocking suggestions so the main input stays active", async () => {
-    const tool = await initTool()
-    show.mockRejectedValueOnce(new Suggestion.DismissedError())
-
-    await toolRuntime.runPromise(
-      tool.execute(
-        {
-          suggest: "Run review?",
-          actions: [{ label: "Start", prompt: "/local-review-uncommitted" }],
-        },
-        ctx as any,
-      ),
-    )
-
-    expect(show).toHaveBeenCalledWith(
-      expect.objectContaining({
-        sessionID: ctx.sessionID,
-        blocking: false,
-      }),
-    )
-  })
-
-  // Regression for https://github.com/SAEEOL/saeeol/pull/9199: while the
-  // suggest tool is blocked on user input the session status must be flipped
-  // to idle so a session left with an open suggestion (e.g. VS Code closed
-  // mid-prompt) does not appear stuck as busy.
-  test("marks session idle while waiting for user response", async () => {
-    const tool = await initTool()
-    let resolveShow: (action: Suggestion.Action) => void = () => {}
-    show.mockReturnValueOnce(
-      new Promise<Suggestion.Action>((resolve) => {
-        resolveShow = resolve
-      }),
-    )
-
-    const pending = toolRuntime.runPromise(
-      tool.execute(
-        {
-          suggest: "Run review?",
-          actions: [{ label: "Start", prompt: "do it" }],
-        },
-        ctx as any,
-      ),
-    )
-
-    // Wait for the tool to reach the await on the suggestion promise so the
-    // idle status call has been issued.
-    await new Promise((resolve) => setTimeout(resolve, 10))
-
-    expect(statusSet).toHaveBeenCalledWith(ctx.sessionID, { type: "idle" })
-    expect(statusSet).not.toHaveBeenCalledWith(ctx.sessionID, { type: "busy" })
-
-    resolveShow({ label: "Start", prompt: "do it" })
-    await pending
-  })
-
-  // Regression for https://github.com/SAEEOL/saeeol/pull/9199: once the
-  // user accepts a suggestion the session must be flipped back to busy
-  // immediately so there is no idle flash while the follow-up response is
-  // generated.
-  test("restores busy status after accept, in order (idle then busy)", async () => {
-    const tool = await initTool()
-    show.mockResolvedValueOnce({ label: "Go", prompt: "go" })
-
-    await toolRuntime.runPromise(
-      tool.execute(
-        {
-          suggest: "Go?",
-          actions: [{ label: "Go", prompt: "go" }],
-        },
-        ctx as any,
-      ),
-    )
-
-    const statuses = statusSet.mock.calls
-      .filter((call: unknown[]) => call[0] === ctx.sessionID)
-      .map((call: unknown[]) => (call[1] as { type: string }).type)
-    expect(statuses).toEqual(["idle", "busy"])
-  })
-
-  // Regression for https://github.com/SAEEOL/saeeol/pull/9199: a dismissed
-  // suggestion leaves the session idle — the runLoop will restore busy on the
-  // next iteration, so the tool must not flip busy itself when the user
-  // walked away.
-  test("leaves session idle when suggestion is dismissed", async () => {
-    const tool = await initTool()
-    show.mockRejectedValueOnce(new Suggestion.DismissedError())
-
-    await toolRuntime.runPromise(
-      tool.execute(
-        {
-          suggest: "Go?",
-          actions: [{ label: "Go", prompt: "go" }],
-        },
-        ctx as any,
-      ),
-    )
-
-    const statuses = statusSet.mock.calls
-      .filter((call: unknown[]) => call[0] === ctx.sessionID)
-      .map((call: unknown[]) => (call[1] as { type: string }).type)
-    expect(statuses).toEqual(["idle"])
-  })
-})

package/test/saeeol/summary-file-diff.test.ts

@@ -1,28 +0,0 @@
-import { test, expect } from "bun:test"
-import { Snapshot } from "../../src/snapshot"
-
-test("SummaryFileDiff does not contain the `patch` field", () => {
-  const keys = Object.keys(Snapshot.SummaryFileDiff.fields)
-  expect(keys).not.toContain("patch")
-  expect(keys.sort()).toEqual(["additions", "deletions", "file", "status"])
-})
-
-test("SummaryFileDiff parse strips `patch` when present on input", () => {
-  const full = {
-    file: "a.txt",
-    patch: "@@ -1 +1 @@\n-old\n+new\n",
-    additions: 1,
-    deletions: 1,
-    status: "modified" as const,
-  }
-  const parsed = Snapshot.SummaryFileDiff.zod.parse(full)
-  expect(parsed).not.toHaveProperty("patch")
-  expect(parsed).toEqual({ file: "a.txt", additions: 1, deletions: 1, status: "modified" })
-})
-
-test("SummaryFileDiff differs from FileDiff by exactly `patch`", () => {
-  const full = new Set(Object.keys(Snapshot.FileDiff.fields))
-  const summary = new Set(Object.keys(Snapshot.SummaryFileDiff.fields))
-  expect([...full].filter((k) => !summary.has(k))).toEqual(["patch"])
-  expect([...summary].filter((k) => !full.has(k))).toEqual([])
-})