saeeol 1.2.5 → 1.2.7

package/test/cli/auto-mode.test.ts

@@ -1,75 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-describe("Auto mode flag", () => {
-  test("auto mode should create session with allow-all permissions except questions", () => {
-    // When --auto flag is set, the session should be created with:
-    // 1. Wildcard allow rule for all permissions
-    // 2. Explicit deny rule for questions (to prevent user interaction)
-
-    const autoPermissions = [
-      {
-        permission: "*",
-        action: "allow" as const,
-        pattern: "*",
-      },
-      {
-        permission: "question",
-        action: "deny" as const,
-        pattern: "*",
-      },
-    ]
-
-    expect(autoPermissions).toHaveLength(2)
-
-    // First rule: allow all
-    expect(autoPermissions[0].permission).toBe("*")
-    expect(autoPermissions[0].action).toBe("allow")
-    expect(autoPermissions[0].pattern).toBe("*")
-
-    // Second rule: deny questions (comes after wildcard to override it)
-    expect(autoPermissions[1].permission).toBe("question")
-    expect(autoPermissions[1].action).toBe("deny")
-    expect(autoPermissions[1].pattern).toBe("*")
-  })
-
-  test("non-auto mode should not set allow-all permissions", () => {
-    // When --auto flag is NOT set, permissions should be undefined or default
-    const normalPermissions = undefined
-
-    expect(normalPermissions).toBeUndefined()
-  })
-
-  test("permission evaluation order matters (findLast behavior)", () => {
-    // The permission system uses findLast, so the last matching rule wins
-    // This test verifies that the question deny rule comes AFTER the wildcard
-
-    const autoPermissions = [
-      { permission: "*", action: "allow" as const, pattern: "*" },
-      { permission: "question", action: "deny" as const, pattern: "*" },
-    ]
-
-    // Simulate findLast behavior
-    const findLastMatch = (permission: string) => {
-      for (let i = autoPermissions.length - 1; i >= 0; i--) {
-        if (permission === autoPermissions[i].permission || autoPermissions[i].permission === "*") {
-          return autoPermissions[i]
-        }
-      }
-      return null
-    }
-
-    // Test that "question" permission resolves to "deny"
-    const questionRule = findLastMatch("question")
-    expect(questionRule?.action).toBe("deny")
-
-    // Test that other permissions resolve to "allow"
-    const bashRule = findLastMatch("bash")
-    expect(bashRule?.action).toBe("allow")
-
-    const editRule = findLastMatch("edit")
-    expect(editRule?.action).toBe("allow")
-
-    const externalDirRule = findLastMatch("external_directory")
-    expect(externalDirRule?.action).toBe("allow")
-  })
-})

package/test/cli/bin-saeeol.test.ts

@@ -1,8 +0,0 @@
-import { test, expect } from "bun:test"
-import path from "path"
-
-test("bin/saeeol parses", async () => {
-  const file = Bun.file(path.join(import.meta.dir, "..", "..", "bin", "saeeol"))
-  const code = (await file.text()).replace(/^#![^\n]*\n/, "")
-  expect(() => new Function(code)).not.toThrow()
-})

package/test/cli/cmd/tui/prompt-part.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { PromptInfo } from "../../../../src/cli/cmd/tui/component/prompt/history"
-import { assign, strip } from "../../../../src/cli/cmd/tui/component/prompt/part"
-
-describe("prompt part", () => {
-  test("strip removes persisted ids from reused file parts", () => {
-    const part = {
-      id: "prt_old",
-      sessionID: "ses_old",
-      messageID: "msg_old",
-      type: "file" as const,
-      mime: "image/png",
-      filename: "tiny.png",
-      url: "data:image/png;base64,abc",
-    }
-
-    expect(strip(part)).toEqual({
-      type: "file",
-      mime: "image/png",
-      filename: "tiny.png",
-      url: "data:image/png;base64,abc",
-    })
-  })
-
-  test("assign overwrites stale runtime ids", () => {
-    const part = {
-      id: "prt_old",
-      sessionID: "ses_old",
-      messageID: "msg_old",
-      type: "file" as const,
-      mime: "image/png",
-      filename: "tiny.png",
-      url: "data:image/png;base64,abc",
-    } as PromptInfo["parts"][number]
-
-    const next = assign(part)
-
-    expect(next.id).not.toBe("prt_old")
-    expect(next.id.startsWith("prt_")).toBe(true)
-    expect(next).toMatchObject({
-      type: "file",
-      mime: "image/png",
-      filename: "tiny.png",
-      url: "data:image/png;base64,abc",
-    })
-  })
-})

package/test/cli/cmd/tui/prompt-traits.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { computePromptTraits } from "../../../../src/cli/cmd/tui/component/prompt/traits"
-
-describe("computePromptTraits", () => {
-  test("normal mode without autocomplete only captures tab", () => {
-    const traits = computePromptTraits({ mode: "normal", disabled: false, autocompleteVisible: false })
-    expect(traits.capture).toEqual(["tab"])
-    expect(traits.suspend).toBe(false)
-    expect(traits.status).toBeUndefined()
-  })
-
-  test("normal mode with autocomplete captures navigation keys", () => {
-    const traits = computePromptTraits({ mode: "normal", disabled: false, autocompleteVisible: true })
-    expect(traits.capture).toEqual(["escape", "navigate", "submit", "tab"])
-    expect(traits.suspend).toBe(false)
-    expect(traits.status).toBeUndefined()
-  })
-
-  test("shell mode does not suspend the textarea", () => {
-    // Suspending the textarea would gate every keybinding action
-    // (backspace, delete-word-backward, arrow movement, etc.) — see
-    // @opentui/core 0.2.x TextareaRenderable.handleKeyPress. Shell mode is
-    // an active editing mode, so suspend must stay off.
-    const traits = computePromptTraits({ mode: "shell", disabled: false, autocompleteVisible: false })
-    expect(traits.suspend).toBe(false)
-  })
-
-  test("shell mode disables capture and labels the prompt", () => {
-    const traits = computePromptTraits({ mode: "shell", disabled: false, autocompleteVisible: false })
-    expect(traits.capture).toBeUndefined()
-    expect(traits.status).toBe("SHELL")
-  })
-
-  test("disabled suspends regardless of mode", () => {
-    expect(computePromptTraits({ mode: "normal", disabled: true, autocompleteVisible: false }).suspend).toBe(true)
-    expect(computePromptTraits({ mode: "shell", disabled: true, autocompleteVisible: false }).suspend).toBe(true)
-  })
-})

package/test/cli/cmd/tui/sync.test.tsx

@@ -1,159 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { describe, expect, test } from "bun:test"
-import { testRender } from "@opentui/solid"
-import { onMount } from "solid-js"
-import { Global } from "@saeeol/core/global"
-import { ArgsProvider } from "../../../../src/cli/cmd/tui/context/args"
-import { ExitProvider } from "../../../../src/cli/cmd/tui/context/exit"
-import { KVProvider, useKV } from "../../../../src/cli/cmd/tui/context/kv"
-import { ProjectProvider } from "../../../../src/cli/cmd/tui/context/project"
-import { SDKProvider, type EventSource } from "../../../../src/cli/cmd/tui/context/sdk"
-import { SyncProvider, useSync } from "../../../../src/cli/cmd/tui/context/sync"
-import { ToastProvider } from "../../../../src/cli/cmd/tui/ui/toast" 
-import { Instance } from "../../../../src/project/instance" 
-import { disposeAllInstances, tmpdir } from "../../../fixture/fixture"
-
-const worktree = "/tmp/saeeol"
-const directory = `${worktree}/packages/saeeol`
-
-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 json(data: unknown) {
-  return new Response(JSON.stringify(data), {
-    headers: { "content-type": "application/json" },
-  })
-}
-
-function eventSource(): EventSource {
-  return {
-    subscribe: async () => () => {},
-  }
-}
-
-function createFetch() {
-  const session = [] as URL[]
-  const fetch = (async (input: RequestInfo | URL) => {
-    const url = new URL(input instanceof Request ? input.url : String(input))
-    if (url.pathname === "/session") session.push(url)
-
-    switch (url.pathname) {
-      case "/agent":
-      case "/command":
-      case "/experimental/workspace":
-      case "/experimental/workspace/status":
-      case "/formatter":
-      case "/lsp":
-        return json([])
-      case "/config":
-      case "/experimental/resource":
-      case "/global/config": 
-      case "/mcp":
-      case "/provider/auth":
-      case "/session/status":
-        return json({})
-      case "/config/providers":
-        return json({ providers: {}, default: {} })
-      case "/experimental/console":
-        return json({ consoleManagedProviders: [], switchableOrgCount: 0 })
-      case "/path":
-        return json({ home: "", state: "", config: "", worktree, directory })
-      case "/project/current":
-        return json({ id: "proj_test" })
-      case "/provider":
-        return json({ all: [], default: {}, connected: [] })
-      case "/session":
-        return json([])
-      case "/vcs":
-        return json({ branch: "main" })
-    }
-
-    throw new Error(`unexpected request: ${url.pathname}`)
-  }) as typeof globalThis.fetch
-
-  return { fetch, session }
-}
-
-async function mount() {
-  const calls = createFetch()
-  let sync!: ReturnType<typeof useSync>
-  let kv!: ReturnType<typeof useKV>
-  let done!: () => void
-  const ready = new Promise<void>((resolve) => {
-    done = resolve
-  })
-
-  const app = await testRender(() => (
-    <ArgsProvider>
-      <ExitProvider>
-        <KVProvider>
-          
-          <ToastProvider>
-            
-            <SDKProvider url="http://test" directory={directory} fetch={calls.fetch} events={eventSource()}>
-              <ProjectProvider>
-                <SyncProvider>
-                  <Probe
-                    onReady={(ctx) => {
-                      sync = ctx.sync
-                      kv = ctx.kv
-                      done()
-                    }}
-                  />
-                </SyncProvider>
-              </ProjectProvider>
-            </SDKProvider>
-            
-          </ToastProvider>
-          
-        </KVProvider>
-      </ExitProvider>
-    </ArgsProvider>
-  ))
-
-  await ready
-  await wait(() => sync.status === "complete")
-  return { app, kv, sync, session: calls.session }
-}
-
-function Probe(props: { onReady: (ctx: { kv: ReturnType<typeof useKV>; sync: ReturnType<typeof useSync> }) => void }) {
-  const kv = useKV()
-  const sync = useSync()
-
-  onMount(() => {
-    props.onReady({ kv, sync })
-  })
-
-  return <box />
-}
-
-describe("tui sync", () => {
-  test("refresh scopes sessions by default and lists project sessions when disabled", async () => {
-    const previous = Global.Path.state
-    await using tmp = await tmpdir()
-    Global.Path.state = tmp.path
-    await Bun.write(`${tmp.path}/kv.json`, "{}")
-    const { app, kv, sync, session } = await Instance.provide({ directory: tmp.path, fn: mount }) 
-
-    try {
-      expect(kv.get("session_directory_filter_enabled", true)).toBe(true)
-      expect(session.at(-1)?.searchParams.get("scope")).toBeNull()
-      expect(session.at(-1)?.searchParams.get("path")).toBe("packages/saeeol")
-
-      kv.set("session_directory_filter_enabled", false)
-      await sync.session.refresh()
-
-      expect(session.at(-1)?.searchParams.get("scope")).toBe("project")
-      expect(session.at(-1)?.searchParams.get("path")).toBeNull()
-    } finally {
-      app.renderer.destroy()
-      await disposeAllInstances() 
-      Global.Path.state = previous
-    }
-  })
-})

package/test/cli/error.test.ts

@@ -1,18 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { AccountTransportError } from "../../src/account/schema"
-import { FormatError } from "../../src/cli/error"
-
-describe("cli.error", () => {
-  test("formats account transport errors clearly", () => {
-    const error = new AccountTransportError({
-      method: "POST",
-      url: "https://console.saeeol.ai/auth/device/code",
-    })
-
-    const formatted = FormatError(error)
-
-    expect(formatted).toContain("Could not reach POST https://console.saeeol.ai/auth/device/code.")
-    expect(formatted).toContain("This failed before the server returned an HTTP response.")
-    expect(formatted).toContain("Check your network, proxy, or VPN configuration and try again.")
-  })
-})

package/test/cli/github-action.test.ts

@@ -1,198 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { extractResponseText, formatPromptTooLargeError } from "../../src/cli/cmd/github"
-import type { MessageV2 } from "../../src/session/message-v2"
-import { SessionID, MessageID, PartID } from "../../src/session/schema"
-
-// Helper to create minimal valid parts
-function createTextPart(text: string): MessageV2.Part {
-  return {
-    id: PartID.ascending(),
-    sessionID: SessionID.make("s"),
-    messageID: MessageID.make("m"),
-    type: "text" as const,
-    text,
-  }
-}
-
-function createReasoningPart(text: string): MessageV2.Part {
-  return {
-    id: PartID.ascending(),
-    sessionID: SessionID.make("s"),
-    messageID: MessageID.make("m"),
-    type: "reasoning" as const,
-    text,
-    time: { start: 0 },
-  }
-}
-
-function createToolPart(tool: string, title: string, status: "completed" | "running" = "completed"): MessageV2.Part {
-  if (status === "completed") {
-    return {
-      id: PartID.ascending(),
-      sessionID: SessionID.make("s"),
-      messageID: MessageID.make("m"),
-      type: "tool" as const,
-      callID: "c1",
-      tool,
-      state: {
-        status: "completed",
-        input: {},
-        output: "",
-        title,
-        metadata: {},
-        time: { start: 0, end: 1 },
-      },
-    }
-  }
-  return {
-    id: PartID.ascending(),
-    sessionID: SessionID.make("s"),
-    messageID: MessageID.make("m"),
-    type: "tool" as const,
-    callID: "c1",
-    tool,
-    state: {
-      status: "running",
-      input: {},
-      time: { start: 0 },
-    },
-  }
-}
-
-function createStepStartPart(): MessageV2.Part {
-  return {
-    id: PartID.ascending(),
-    sessionID: SessionID.make("s"),
-    messageID: MessageID.make("m"),
-    type: "step-start" as const,
-  }
-}
-
-function createStepFinishPart(): MessageV2.Part {
-  return {
-    id: PartID.ascending(),
-    sessionID: SessionID.make("s"),
-    messageID: MessageID.make("m"),
-    type: "step-finish" as const,
-    reason: "done",
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-  }
-}
-
-describe("extractResponseText", () => {
-  test("returns text from text part", () => {
-    const parts = [createTextPart("Hello world")]
-    expect(extractResponseText(parts)).toBe("Hello world")
-  })
-
-  test("returns last text part when multiple exist", () => {
-    const parts = [createTextPart("First"), createTextPart("Last")]
-    expect(extractResponseText(parts)).toBe("Last")
-  })
-
-  test("returns text even when tool parts follow", () => {
-    const parts = [createTextPart("I'll help with that."), createToolPart("todowrite", "3 todos")]
-    expect(extractResponseText(parts)).toBe("I'll help with that.")
-  })
-
-  test("returns null for reasoning-only response (signals summary needed)", () => {
-    const parts = [createReasoningPart("Let me think about this...")]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("returns null for tool-only response (signals summary needed)", () => {
-    // This is the exact scenario from the bug report - todowrite with no text
-    const parts = [createToolPart("todowrite", "8 todos")]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("returns null for multiple completed tools", () => {
-    const parts = [
-      createToolPart("read", "src/file.ts"),
-      createToolPart("edit", "src/file.ts"),
-      createToolPart("bash", "bun test"),
-    ]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("returns null for running tool parts (signals summary needed)", () => {
-    const parts = [createToolPart("bash", "", "running")]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("throws on empty array", () => {
-    expect(() => extractResponseText([])).toThrow("no parts returned")
-  })
-
-  test("returns null for step-start only", () => {
-    const parts = [createStepStartPart()]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("returns null for step-finish only", () => {
-    const parts = [createStepFinishPart()]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("returns null for step-start and step-finish", () => {
-    const parts = [createStepStartPart(), createStepFinishPart()]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("returns text from multi-step response", () => {
-    const parts = [
-      createStepStartPart(),
-      createToolPart("read", "src/file.ts"),
-      createTextPart("Done"),
-      createStepFinishPart(),
-    ]
-    expect(extractResponseText(parts)).toBe("Done")
-  })
-
-  test("prefers text over reasoning when both present", () => {
-    const parts = [createReasoningPart("Internal thinking..."), createTextPart("Final answer")]
-    expect(extractResponseText(parts)).toBe("Final answer")
-  })
-
-  test("prefers text over tools when both present", () => {
-    const parts = [createToolPart("read", "src/file.ts"), createTextPart("Here's what I found")]
-    expect(extractResponseText(parts)).toBe("Here's what I found")
-  })
-})
-
-describe("formatPromptTooLargeError", () => {
-  test("formats error without files", () => {
-    const result = formatPromptTooLargeError([])
-    expect(result).toBe("PROMPT_TOO_LARGE: The prompt exceeds the model's context limit.")
-  })
-
-  test("formats error with files (base64 content)", () => {
-    // Base64 is ~33% larger than original, so we multiply by 0.75 to get original size
-    // 400 KB base64 = 300 KB original, 200 KB base64 = 150 KB original
-    const files = [
-      { filename: "screenshot.png", content: "a".repeat(400 * 1024) },
-      { filename: "diagram.png", content: "b".repeat(200 * 1024) },
-    ]
-    const result = formatPromptTooLargeError(files)
-
-    expect(result).toStartWith("PROMPT_TOO_LARGE: The prompt exceeds the model's context limit.")
-    expect(result).toInclude("Files in prompt:")
-    expect(result).toInclude("screenshot.png (300 KB)")
-    expect(result).toInclude("diagram.png (150 KB)")
-  })
-
-  test("lists all files when multiple present", () => {
-    // Base64 sizes: 4KB -> 3KB, 8KB -> 6KB, 12KB -> 9KB
-    const files = [
-      { filename: "img1.png", content: "x".repeat(4 * 1024) },
-      { filename: "img2.jpg", content: "y".repeat(8 * 1024) },
-      { filename: "img3.gif", content: "z".repeat(12 * 1024) },
-    ]
-    const result = formatPromptTooLargeError(files)
-
-    expect(result).toInclude("img1.png (3 KB)")
-    expect(result).toInclude("img2.jpg (6 KB)")
-    expect(result).toInclude("img3.gif (9 KB)")
-  })
-})

package/test/cli/github-remote.test.ts

@@ -1,85 +0,0 @@
-import { test, expect } from "bun:test"
-import { parseGitHubRemote } from "../../src/cli/cmd/github"
-test("parses https URL with .git suffix", () => {
-  expect(parseGitHubRemote("https://github.com/SAEEOL/saeeol.git")).toEqual({
-    owner: "SAEEOL",
-    repo: "saeeol",
-  })
-})
-
-test("parses https URL without .git suffix", () => {
-  expect(parseGitHubRemote("https://github.com/SAEEOL/saeeol")).toEqual({ owner: "SAEEOL", repo: "saeeol" })
-})
-
-test("parses git@ URL with .git suffix", () => {
-  expect(parseGitHubRemote("git@github.com:SAEEOL/saeeol.git")).toEqual({ owner: "SAEEOL", repo: "saeeol" })
-})
-
-test("parses git@ URL without .git suffix", () => {
-  expect(parseGitHubRemote("git@github.com:SAEEOL/saeeol")).toEqual({ owner: "SAEEOL", repo: "saeeol" })
-})
-
-test("parses ssh:// URL with .git suffix", () => {
-  expect(parseGitHubRemote("ssh://git@github.com/SAEEOL/saeeol.git")).toEqual({
-    owner: "SAEEOL",
-    repo: "saeeol",
-  })
-})
-
-test("parses ssh:// URL without .git suffix", () => {
-  expect(parseGitHubRemote("ssh://git@github.com/SAEEOL/saeeol")).toEqual({ owner: "SAEEOL", repo: "saeeol" })
-})
-
-test("parses http URL", () => {
-  expect(parseGitHubRemote("http://github.com/owner/repo")).toEqual({ owner: "owner", repo: "repo" })
-})
-
-test("parses URL with hyphenated owner and repo names", () => {
-  expect(parseGitHubRemote("https://github.com/my-org/my-repo.git")).toEqual({ owner: "my-org", repo: "my-repo" })
-})
-
-test("parses URL with underscores in names", () => {
-  expect(parseGitHubRemote("git@github.com:my_org/my_repo.git")).toEqual({ owner: "my_org", repo: "my_repo" })
-})
-
-test("parses URL with numbers in names", () => {
-  expect(parseGitHubRemote("https://github.com/org123/repo456")).toEqual({ owner: "org123", repo: "repo456" })
-})
-
-test("parses repos with dots in the name", () => {
-  expect(parseGitHubRemote("https://github.com/socketio/socket.io.git")).toEqual({
-    owner: "socketio",
-    repo: "socket.io",
-  })
-  expect(parseGitHubRemote("https://github.com/vuejs/vue.js")).toEqual({
-    owner: "vuejs",
-    repo: "vue.js",
-  })
-  expect(parseGitHubRemote("git@github.com:mrdoob/three.js.git")).toEqual({
-    owner: "mrdoob",
-    repo: "three.js",
-  })
-  expect(parseGitHubRemote("https://github.com/jashkenas/backbone.git")).toEqual({
-    owner: "jashkenas",
-    repo: "backbone",
-  })
-})
-
-test("returns null for non-github URLs", () => {
-  expect(parseGitHubRemote("https://gitlab.com/owner/repo.git")).toBeNull()
-  expect(parseGitHubRemote("git@gitlab.com:owner/repo.git")).toBeNull()
-  expect(parseGitHubRemote("https://bitbucket.org/owner/repo")).toBeNull()
-})
-
-test("returns null for invalid URLs", () => {
-  expect(parseGitHubRemote("not-a-url")).toBeNull()
-  expect(parseGitHubRemote("")).toBeNull()
-  expect(parseGitHubRemote("github.com")).toBeNull()
-  expect(parseGitHubRemote("https://github.com/")).toBeNull()
-  expect(parseGitHubRemote("https://github.com/owner")).toBeNull()
-})
-
-test("returns null for URLs with extra path segments", () => {
-  expect(parseGitHubRemote("https://github.com/owner/repo/tree/main")).toBeNull()
-  expect(parseGitHubRemote("https://github.com/owner/repo/blob/main/file.ts")).toBeNull()
-})