saeeol 1.2.5 → 1.2.7

package/test/cli/tui/transcript.test.ts

@@ -1,426 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  formatAssistantHeader,
-  formatMessage,
-  formatPart,
-  formatTranscript,
-} from "../../../src/cli/cmd/tui/util/transcript"
-import type { AssistantMessage, Part, Provider, UserMessage } from "@saeeol/sdk/v2"
-
-const providers: Provider[] = [
-  {
-    id: "anthropic",
-    name: "Anthropic",
-    source: "api",
-    env: [],
-    options: {},
-    models: {
-      "claude-sonnet-4-20250514": {
-        id: "claude-sonnet-4-20250514",
-        providerID: "anthropic",
-        api: {
-          id: "claude-sonnet-4-20250514",
-          url: "https://example.com/claude-sonnet-4-20250514",
-          npm: "@ai-sdk/anthropic",
-        },
-        name: "Claude Sonnet 4",
-        capabilities: {
-          temperature: true,
-          reasoning: true,
-          attachment: true,
-          toolcall: true,
-          input: {
-            text: true,
-            audio: false,
-            image: true,
-            video: false,
-            pdf: true,
-          },
-          output: {
-            text: true,
-            audio: false,
-            image: false,
-            video: false,
-            pdf: false,
-          },
-          interleaved: false,
-        },
-        cost: {
-          input: 0,
-          output: 0,
-          cache: {
-            read: 0,
-            write: 0,
-          },
-        },
-        limit: {
-          context: 200_000,
-          output: 8_192,
-        },
-        status: "active",
-        options: {},
-        headers: {},
-        release_date: "2025-05-14",
-      },
-    },
-  },
-]
-
-describe("transcript", () => {
-  describe("formatAssistantHeader", () => {
-    const baseMsg: AssistantMessage = {
-      id: "msg_123",
-      sessionID: "ses_123",
-      role: "assistant",
-      agent: "code", 
-      modelID: "claude-sonnet-4-20250514",
-      providerID: "anthropic",
-      mode: "",
-      parentID: "msg_parent",
-      path: { cwd: "/test", root: "/test" },
-      cost: 0.001,
-      tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-      time: { created: 1000000, completed: 1005400 },
-    }
-
-    test("includes metadata when enabled", () => {
-      const result = formatAssistantHeader(baseMsg, true)
-      expect(result).toBe("## Assistant (Code · claude-sonnet-4-20250514 · 5.4s)\n\n") 
-    })
-
-    test("uses model display name when available", () => {
-      const result = formatAssistantHeader(baseMsg, true, providers)
-      expect(result).toBe("## Assistant (Code · Claude Sonnet 4 · 5.4s)\n\n") 
-    })
-
-    test("excludes metadata when disabled", () => {
-      const result = formatAssistantHeader(baseMsg, false)
-      expect(result).toBe("## Assistant\n\n")
-    })
-
-    test("handles missing completed time", () => {
-      const msg = { ...baseMsg, time: { created: 1000000 } }
-      const result = formatAssistantHeader(msg as AssistantMessage, true)
-      expect(result).toBe("## Assistant (Code · claude-sonnet-4-20250514)\n\n") 
-    })
-
-    test("titlecases agent name", () => {
-      const msg = { ...baseMsg, agent: "plan" }
-      const result = formatAssistantHeader(msg, true)
-      expect(result).toContain("Plan")
-    })
-  })
-
-  describe("formatPart", () => {
-    const options = { thinking: true, toolDetails: true, assistantMetadata: true }
-
-    test("formats text part", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "text",
-        text: "Hello world",
-      }
-      const result = formatPart(part, options)
-      expect(result).toBe("Hello world\n\n")
-    })
-
-    test("skips synthetic text parts", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "text",
-        text: "Synthetic content",
-        synthetic: true,
-      }
-      const result = formatPart(part, options)
-      expect(result).toBe("")
-    })
-
-    test("formats reasoning when thinking enabled", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "reasoning",
-        text: "Let me think...",
-        time: { start: 1000 },
-      }
-      const result = formatPart(part, options)
-      expect(result).toBe("_Thinking:_\n\nLet me think...\n\n")
-    })
-
-    test("skips reasoning when thinking disabled", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "reasoning",
-        text: "Let me think...",
-        time: { start: 1000 },
-      }
-      const result = formatPart(part, { ...options, thinking: false })
-      expect(result).toBe("")
-    })
-
-    test("formats tool part with details", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "completed",
-          input: { command: "ls" },
-          output: "file1.txt\nfile2.txt",
-          title: "List files",
-          metadata: {},
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, options)
-      expect(result).toContain("**Tool: bash**")
-      expect(result).toContain("**Input:**")
-      expect(result).toContain('"command": "ls"')
-      expect(result).toContain("**Output:**")
-      expect(result).toContain("file1.txt")
-    })
-
-    test("formats tool output containing triple backticks without breaking markdown", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "completed",
-          input: { command: "echo '```hello```'" },
-          output: "```hello```",
-          title: "Echo backticks",
-          metadata: {},
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, options)
-      // The tool header should not be inside a code block
-      expect(result).toStartWith("**Tool: bash**\n")
-      // Input and output should each be in their own code blocks
-      expect(result).toContain("**Input:**\n```json")
-      expect(result).toContain("**Output:**\n```\n```hello```\n```")
-    })
-
-    test("formats tool part without details when disabled", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "completed",
-          input: { command: "ls" },
-          output: "file1.txt",
-          title: "List files",
-          metadata: {},
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, { ...options, toolDetails: false })
-      expect(result).toContain("**Tool: bash**")
-      expect(result).not.toContain("**Input:**")
-      expect(result).not.toContain("**Output:**")
-    })
-
-    test("formats tool error", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "error",
-          input: { command: "invalid" },
-          error: "Command failed",
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, options)
-      expect(result).toContain("**Error:**")
-      expect(result).toContain("Command failed")
-    })
-  })
-
-  describe("formatMessage", () => {
-    const options = { thinking: true, toolDetails: true, assistantMetadata: true, providers }
-
-    test("formats user message", () => {
-      const msg: UserMessage = {
-        id: "msg_123",
-        sessionID: "ses_123",
-        role: "user",
-        agent: "code", 
-        model: { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
-        time: { created: 1000000 },
-      }
-      const parts: Part[] = [{ id: "p1", sessionID: "ses_123", messageID: "msg_123", type: "text", text: "Hello" }]
-      const result = formatMessage(msg, parts, options)
-      expect(result).toContain("## User")
-      expect(result).toContain("Hello")
-    })
-
-    test("formats assistant message with metadata", () => {
-      const msg: AssistantMessage = {
-        id: "msg_123",
-        sessionID: "ses_123",
-        role: "assistant",
-        agent: "code", 
-        modelID: "claude-sonnet-4-20250514",
-        providerID: "anthropic",
-        mode: "",
-        parentID: "msg_parent",
-        path: { cwd: "/test", root: "/test" },
-        cost: 0.001,
-        tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-        time: { created: 1000000, completed: 1005400 },
-      }
-      const parts: Part[] = [{ id: "p1", sessionID: "ses_123", messageID: "msg_123", type: "text", text: "Hi there" }]
-      const result = formatMessage(msg, parts, options)
-      expect(result).toContain("## Assistant (Code · Claude Sonnet 4 · 5.4s)") 
-      expect(result).toContain("Hi there")
-    })
-  })
-
-  describe("formatTranscript", () => {
-    test("formats complete transcript", () => {
-      const session = {
-        id: "ses_abc123",
-        title: "Test Session",
-        time: { created: 1000000000000, updated: 1000000001000 },
-      }
-      const messages = [
-        {
-          info: {
-            id: "msg_1",
-            sessionID: "ses_abc123",
-            role: "user" as const,
-            agent: "code", 
-            model: { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
-            time: { created: 1000000000000 },
-          },
-          parts: [{ id: "p1", sessionID: "ses_abc123", messageID: "msg_1", type: "text" as const, text: "Hello" }],
-        },
-        {
-          info: {
-            id: "msg_2",
-            sessionID: "ses_abc123",
-            role: "assistant" as const,
-            agent: "code", 
-            modelID: "claude-sonnet-4-20250514",
-            providerID: "anthropic",
-            mode: "",
-            parentID: "msg_1",
-            path: { cwd: "/test", root: "/test" },
-            cost: 0.001,
-            tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-            time: { created: 1000000000100, completed: 1000000000600 },
-          },
-          parts: [{ id: "p2", sessionID: "ses_abc123", messageID: "msg_2", type: "text" as const, text: "Hi!" }],
-        },
-      ]
-      const options = {
-        thinking: false,
-        toolDetails: false,
-        assistantMetadata: true,
-        providers,
-      }
-
-      const result = formatTranscript(session, messages, options)
-
-      expect(result).toContain("# Test Session")
-      expect(result).toContain("**Session ID:** ses_abc123")
-      expect(result).toContain("## User")
-      expect(result).toContain("Hello")
-      expect(result).toContain("## Assistant (Code · Claude Sonnet 4 · 0.5s)") 
-      expect(result).toContain("Hi!")
-      expect(result).toContain("---")
-    })
-
-    test("falls back to raw model id when provider data is missing", () => {
-      const session = {
-        id: "ses_abc123",
-        title: "Test Session",
-        time: { created: 1000000000000, updated: 1000000001000 },
-      }
-      const messages = [
-        {
-          info: {
-            id: "msg_1",
-            sessionID: "ses_abc123",
-            role: "assistant" as const,
-            agent: "build",
-            modelID: "claude-sonnet-4-20250514",
-            providerID: "anthropic",
-            mode: "",
-            parentID: "msg_0",
-            path: { cwd: "/test", root: "/test" },
-            cost: 0.001,
-            tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-            time: { created: 1000000000100, completed: 1000000000600 },
-          },
-          parts: [{ id: "p1", sessionID: "ses_abc123", messageID: "msg_1", type: "text" as const, text: "Response" }],
-        },
-      ]
-
-      const result = formatTranscript(session, messages, {
-        thinking: false,
-        toolDetails: false,
-        assistantMetadata: true,
-      })
-
-      expect(result).toContain("## Assistant (Build · claude-sonnet-4-20250514 · 0.5s)")
-    })
-
-    test("formats transcript without assistant metadata", () => {
-      const session = {
-        id: "ses_abc123",
-        title: "Test Session",
-        time: { created: 1000000000000, updated: 1000000001000 },
-      }
-      const messages = [
-        {
-          info: {
-            id: "msg_1",
-            sessionID: "ses_abc123",
-            role: "assistant" as const,
-            agent: "code", 
-            modelID: "claude-sonnet-4-20250514",
-            providerID: "anthropic",
-            mode: "",
-            parentID: "msg_0",
-            path: { cwd: "/test", root: "/test" },
-            cost: 0.001,
-            tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-            time: { created: 1000000000100, completed: 1000000000600 },
-          },
-          parts: [{ id: "p1", sessionID: "ses_abc123", messageID: "msg_1", type: "text" as const, text: "Response" }],
-        },
-      ]
-      const options = { thinking: false, toolDetails: false, assistantMetadata: false }
-
-      const result = formatTranscript(session, messages, options)
-
-      expect(result).toContain("## Assistant\n\n")
-      expect(result).not.toContain("Code") 
-      expect(result).not.toContain("claude-sonnet-4-20250514")
-    })
-  })
-})

package/test/cli/tui/usage.test.ts

@@ -1,60 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { AssistantMessage, Message, UserMessage } from "@saeeol/sdk/v2"
-import { formatCount, getUsage } from "../../../src/cli/cmd/tui/routes/session/usage"
-
-function assistant(id: string, input: number, output: number, read: number): AssistantMessage {
-  return {
-    id,
-    sessionID: "ses_1",
-    role: "assistant",
-    time: { created: 1 },
-    parentID: "msg_parent",
-    modelID: "claude-sonnet",
-    providerID: "anthropic",
-    mode: "code",
-    agent: "code",
-    path: { cwd: "/tmp", root: "/tmp" },
-    cost: 0,
-    tokens: {
-      input,
-      output,
-      reasoning: 99,
-      cache: {
-        read,
-        write: 7,
-      },
-    },
-  }
-}
-
-function user(): UserMessage {
-  return {
-    id: "msg_user",
-    sessionID: "ses_1",
-    role: "user",
-    time: { created: 0 },
-    agent: "code",
-    model: {
-      providerID: "anthropic",
-      modelID: "claude-sonnet",
-    },
-  }
-}
-
-describe("session usage", () => {
-  test("sums input, output, and cache read across assistant messages only", () => {
-    const msg: Message[] = [user(), assistant("a", 1200, 45, 300), assistant("b", 800, 55, 700)]
-
-    expect(getUsage(msg)).toEqual({
-      input: 2000,
-      output: 100,
-      cached: 1000,
-    })
-  })
-
-  test("formats full counts with thousands separators", () => {
-    expect(formatCount(0)).toBe("0")
-    expect(formatCount(12345)).toBe("12,345")
-    expect(formatCount(9876543)).toBe("9,876,543")
-  })
-})

package/test/cli/tui/use-event.test.tsx

@@ -1,175 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { describe, expect, test } from "bun:test"
-import { testRender } from "@opentui/solid"
-import type { Event, GlobalEvent } from "@saeeol/sdk/v2"
-import { onMount } from "solid-js"
-import { ProjectProvider, useProject } from "../../../src/cli/cmd/tui/context/project"
-import { SDKProvider } from "../../../src/cli/cmd/tui/context/sdk"
-import { useEvent } from "../../../src/cli/cmd/tui/context/event"
-
-async function wait(fn: () => boolean, timeout = 2000) {
-  const start = Date.now()
-  while (!fn()) {
-    if (Date.now() - start > timeout) throw new Error("timed out waiting for condition")
-    await Bun.sleep(10)
-  }
-}
-
-function event(payload: Event, input: { directory: string; workspace?: string }): GlobalEvent {
-  return {
-    directory: input.directory,
-    workspace: input.workspace,
-    payload,
-  }
-}
-
-function vcs(branch: string): Event {
-  return {
-    type: "vcs.branch.updated",
-    properties: {
-      branch,
-    },
-  }
-}
-
-function update(version: string): Event {
-  return {
-    type: "installation.update-available",
-    properties: {
-      version,
-    },
-  }
-}
-
-function createSource() {
-  let fn: ((event: GlobalEvent) => void) | undefined
-
-  return {
-    source: {
-      subscribe: async (handler: (event: GlobalEvent) => void) => {
-        fn = handler
-        return () => {
-          if (fn === handler) fn = undefined
-        }
-      },
-    },
-    emit(evt: GlobalEvent) {
-      if (!fn) throw new Error("event source not ready")
-      fn(evt)
-    },
-  }
-}
-
-async function mount() {
-  const source = createSource()
-  const seen: Event[] = []
-  let project!: ReturnType<typeof useProject>
-  let done!: () => void
-  const ready = new Promise<void>((resolve) => {
-    done = resolve
-  })
-
-  const app = await testRender(() => (
-    <SDKProvider url="http://test" directory="/tmp/root" events={source.source}>
-      <ProjectProvider>
-        <Probe
-          onReady={(ctx) => {
-            project = ctx.project
-            done()
-          }}
-          seen={seen}
-        />
-      </ProjectProvider>
-    </SDKProvider>
-  ))
-
-  await ready
-  return { app, emit: source.emit, project, seen }
-}
-
-function Probe(props: { seen: Event[]; onReady: (ctx: { project: ReturnType<typeof useProject> }) => void }) {
-  const project = useProject()
-  const event = useEvent()
-
-  onMount(() => {
-    event.subscribe((evt) => {
-      props.seen.push(evt)
-    })
-    props.onReady({ project })
-  })
-
-  return <box />
-}
-
-describe("useEvent", () => {
-  test("delivers matching directory events without an active workspace", async () => {
-    const { app, emit, seen } = await mount()
-
-    try {
-      emit(event(vcs("main"), { directory: "/tmp/root" }))
-
-      await wait(() => seen.length === 1)
-
-      expect(seen).toEqual([vcs("main")])
-    } finally {
-      app.renderer.destroy()
-    }
-  })
-
-  test("ignores non-matching directory events without an active workspace", async () => {
-    const { app, emit, seen } = await mount()
-
-    try {
-      emit(event(vcs("other"), { directory: "/tmp/other" }))
-      await Bun.sleep(30)
-
-      expect(seen).toHaveLength(0)
-    } finally {
-      app.renderer.destroy()
-    }
-  })
-
-  test("delivers matching workspace events when a workspace is active", async () => {
-    const { app, emit, project, seen } = await mount()
-
-    try {
-      project.workspace.set("ws_a")
-      emit(event(vcs("ws"), { directory: "/tmp/other", workspace: "ws_a" }))
-
-      await wait(() => seen.length === 1)
-
-      expect(seen).toEqual([vcs("ws")])
-    } finally {
-      app.renderer.destroy()
-    }
-  })
-
-  test("ignores non-matching workspace events when a workspace is active", async () => {
-    const { app, emit, project, seen } = await mount()
-
-    try {
-      project.workspace.set("ws_a")
-      emit(event(vcs("ws"), { directory: "/tmp/root", workspace: "ws_b" }))
-      await Bun.sleep(30)
-
-      expect(seen).toHaveLength(0)
-    } finally {
-      app.renderer.destroy()
-    }
-  })
-
-  test("delivers truly global events even when a workspace is active", async () => {
-    const { app, emit, project, seen } = await mount()
-
-    try {
-      project.workspace.set("ws_a")
-      emit(event(update("1.2.3"), { directory: "global" }))
-
-      await wait(() => seen.length === 1)
-
-      expect(seen).toEqual([update("1.2.3")])
-    } finally {
-      app.renderer.destroy()
-    }
-  })
-})