saeeol 1.2.5 → 1.2.8

package/test/saeeol/cli/dev-setup.test.ts

@@ -1,74 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import path from "path"
-import fs from "fs/promises"
-import { tmpdir } from "../../fixture/fixture"
-import { detectRepo, findRepoFrom } from "../../../src/overlay/cli/dev-setup"
-
-// Simulate a repo root by writing the sentinel file detectRepo looks for.
-async function makeSynthRepo(dir: string) {
-  const pkg = path.join(dir, "packages", "saeeol")
-  await fs.mkdir(pkg, { recursive: true })
-  await Bun.write(path.join(pkg, "package.json"), JSON.stringify({ name: "synth" }))
-  return dir
-}
-
-async function withEnv<T>(name: string, value: string | undefined, fn: () => Promise<T>): Promise<T> {
-  const prev = process.env[name]
-  if (value === undefined) delete process.env[name]
-  else process.env[name] = value
-  try {
-    return await fn()
-  } finally {
-    if (prev === undefined) delete process.env[name]
-    else process.env[name] = prev
-  }
-}
-
-describe("findRepoFrom", () => {
-  test("returns the repo root when started from a nested path", async () => {
-    await using tmp = await tmpdir()
-    await makeSynthRepo(tmp.path)
-    const nested = path.join(tmp.path, "packages", "saeeol", "src", "saeeol", "cli")
-    await fs.mkdir(nested, { recursive: true })
-
-    const found = await findRepoFrom(nested)
-    expect(found).toBe(tmp.path)
-  })
-
-  test("returns the repo root when started from the root itself", async () => {
-    await using tmp = await tmpdir()
-    await makeSynthRepo(tmp.path)
-
-    const found = await findRepoFrom(tmp.path)
-    expect(found).toBe(tmp.path)
-  })
-
-  test("returns undefined when no sentinel is found up to filesystem root", async () => {
-    await using tmp = await tmpdir()
-    // No packages/saeeol/package.json anywhere under tmp, and the filesystem
-    // above tmp does not contain a saeeol repo at its own root.
-    const found = await findRepoFrom(tmp.path)
-    expect(found).toBeUndefined()
-  })
-})
-
-describe("detectRepo", () => {
-  test("honours SAEEOL_DEV_REPO without touching the filesystem", async () => {
-    // Pointing at a path that does not exist — the hint must be returned as-is
-    // (this proves no walk happens when SAEEOL_DEV_REPO is set).
-    const hint = "/definitely/does/not/exist/saeeol-repo"
-    const got = await withEnv("SAEEOL_DEV_REPO", hint, () => detectRepo())
-    expect(got).toBe(hint)
-  })
-
-  test("SAEEOL_DEV_REPO wins over the filesystem walk", async () => {
-    // Build a synthetic repo, point SAEEOL_DEV_REPO at it, and run from an
-    // unrelated cwd. Even though the walk from cwd (inside the real saeeol
-    // checkout) would succeed, the hint must take priority.
-    await using tmp = await tmpdir()
-    await makeSynthRepo(tmp.path)
-
-    const got = await withEnv("SAEEOL_DEV_REPO", tmp.path, () => detectRepo())
-    expect(got).toBe(tmp.path)
-  })
-})

package/test/saeeol/cli/roll-call.test.ts

@@ -1,161 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { Provider } from "../../../src/provider/provider"
-import { formatTable, formatMarkdown, handle, isTextModel } from "../../../src/overlay/cli/cmd/roll-call"
-
-const base = {
-  input: { text: false, audio: false, image: false, video: false, pdf: false },
-  output: { text: false, audio: false, image: false, video: false, pdf: false },
-}
-
-function caps(opts: { input?: Partial<typeof base.input>; output?: Partial<typeof base.output> }) {
-  return {
-    capabilities: {
-      ...base,
-      input: { ...base.input, ...opts.input },
-      output: { ...base.output, ...opts.output },
-    },
-  } as Provider.Model
-}
-
-describe("formatTable", () => {
-  test("formats simple table correctly", () => {
-    const rows = [
-      ["saeeol/test-model", "YES", "Hello!", "1000ms"],
-      ["saeeol/another-model", "NO", "(Error)", "500ms"],
-    ]
-    const result = formatTable(rows, 120)
-
-    expect(result.header).toContain("Model")
-    expect(result.header).toContain("Access")
-    expect(result.header).toContain("Snippet")
-    expect(result.header).toContain("Latency")
-    expect(result.separator).toMatch(/^-+$/)
-    expect(result.rows).toHaveLength(2)
-  })
-
-  test("truncates long snippets", () => {
-    const rows = [["model", "YES", "A".repeat(200), "100ms"]]
-    const result = formatTable(rows, 80)
-    const start = result.rows[0].indexOf("AAA")
-
-    expect(start).toBeGreaterThanOrEqual(0)
-  })
-
-  test("strips ANSI codes from cells", () => {
-    const rows = [["\x1b[31mmodel\x1b[0m", "YES", "text", "100ms"]]
-    const result = formatTable(rows, 120)
-
-    expect(result.rows[0]).not.toContain("\x1b[")
-    expect(result.rows[0]).toContain("model")
-  })
-
-  test("handles empty rows", () => {
-    const result = formatTable([], 120)
-
-    expect(result.rows).toHaveLength(0)
-    expect(result.header).toContain("Model")
-  })
-
-  test("handles special characters in cells", () => {
-    const rows = [
-      ["model\nwith\nnewlines", "YES", "text\ttab", "100ms"],
-      ["model\r\nwindows", "YES", "text", "100ms"],
-    ]
-    const result = formatTable(rows, 120)
-
-    expect(result.rows[0]).not.toContain("\n")
-    expect(result.rows[0]).not.toContain("\t")
-    expect(result.rows[1]).not.toContain("\r")
-  })
-
-  test("adjusts column widths for terminal", () => {
-    const rows = [["very-long-model-name-here", "YES", "short", "100ms"]]
-    const wide = formatTable(rows, 200)
-    const narrow = formatTable(rows, 60)
-
-    expect(wide.header.indexOf("Snippet")).toBeGreaterThanOrEqual(0)
-    expect(narrow.header.indexOf("Snippet")).toBeGreaterThanOrEqual(0)
-  })
-})
-
-describe("isTextModel", () => {
-  test("accepts text-in text-out model", () => {
-    expect(isTextModel(caps({ input: { text: true }, output: { text: true } }))).toBe(true)
-  })
-
-  test("accepts multimodal model with text capability", () => {
-    expect(isTextModel(caps({ input: { text: true, image: true }, output: { text: true } }))).toBe(true)
-  })
-
-  test("rejects audio-in text-out model", () => {
-    expect(isTextModel(caps({ input: { audio: true }, output: { text: true } }))).toBe(false)
-  })
-
-  test("rejects text-in image-out model", () => {
-    expect(isTextModel(caps({ input: { text: true }, output: { image: true } }))).toBe(false)
-  })
-
-  test("rejects embedding model", () => {
-    expect(isTextModel(caps({ input: { text: true } }))).toBe(false)
-  })
-})
-
-describe("formatMarkdown", () => {
-  test("produces valid markdown table", () => {
-    const rows = [
-      ["openai/gpt-4o", "YES", "Hello!", "500ms"],
-      ["openai/gpt-3.5", "NO", "(timeout)", "25000ms"],
-    ]
-    const md = formatMarkdown(rows)
-    const lines = md.split("\n")
-
-    expect(lines[0]).toMatch(/^\|.*Model.*\|.*Access.*\|.*Snippet.*\|.*Latency.*\|$/)
-    expect(lines[1]).toMatch(/^\| -+ \| -+ \| -+ \| -+ \|$/)
-    expect(lines).toHaveLength(4)
-  })
-
-  test("handles empty rows", () => {
-    const md = formatMarkdown([])
-    const lines = md.split("\n")
-
-    expect(lines).toHaveLength(2)
-  })
-
-  test("escapes pipe characters in cells", () => {
-    const rows = [["model", "YES", "hello | world", "100ms"]]
-    const md = formatMarkdown(rows)
-
-    expect(md).toContain("hello \\| world")
-    expect(md.split("\n")[2].match(/(?<!\\)\|/g)?.length).toBe(5)
-  })
-})
-
-describe("handle", () => {
-  test("does not print progress before markdown output", async () => {
-    const logs: string[] = []
-    const print = console.log
-    const code = process.exitCode
-
-    console.log = (msg?: unknown) => {
-      logs.push(String(msg))
-    }
-
-    try {
-      await handle({
-        prompt: "Hello",
-        timeout: 1,
-        filter: "test",
-        parallel: 1,
-        output: "md",
-        verbose: true,
-        quiet: false,
-        list: async () => ({}),
-      })
-    } finally {
-      console.log = print
-      process.exitCode = code
-    }
-
-    expect(logs).toEqual([formatMarkdown([])])
-  })
-})

package/test/saeeol/cli-run-auto-helper.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { SaeeolRunAuto } from "../../src/overlay/cli/run-auto"
-
-describe("SaeeolRunAuto", () => {
-  test("tracks task child sessions without allowing unrelated sessions", () => {
-    const state = SaeeolRunAuto.create("ses_root")
-
-    expect(SaeeolRunAuto.allowed(state, "ses_root")).toBe(true)
-    expect(SaeeolRunAuto.allowed(state, "ses_child")).toBe(false)
-
-    SaeeolRunAuto.track(state, {
-      type: "tool",
-      tool: "task",
-      sessionID: "ses_root",
-      state: {
-        metadata: {
-          sessionId: "ses_child",
-        },
-      },
-    })
-
-    expect(SaeeolRunAuto.allowed(state, "ses_child")).toBe(true)
-    expect(SaeeolRunAuto.allowed(state, "ses_other")).toBe(false)
-  })
-
-  test("ignores malformed or non-root task metadata", () => {
-    const state = SaeeolRunAuto.create("ses_root")
-
-    SaeeolRunAuto.track(state, {
-      type: "tool",
-      tool: "task",
-      sessionID: "ses_root",
-      state: {
-        metadata: {
-          sessionId: "",
-        },
-      },
-    })
-    SaeeolRunAuto.track(state, {
-      type: "tool",
-      tool: "task",
-      sessionID: "ses_other",
-      state: {
-        metadata: {
-          sessionId: "ses_wrong",
-        },
-      },
-    })
-    SaeeolRunAuto.track(state, {
-      type: "text",
-      sessionID: "ses_root",
-      state: {},
-    })
-
-    expect(SaeeolRunAuto.allowed(state, "ses_wrong")).toBe(false)
-    expect(SaeeolRunAuto.allowed(state, "")).toBe(false)
-  })
-})

package/test/saeeol/codex-auth-refresh.test.ts

@@ -1,124 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { CodexAuthExpiredError, refreshCodexAuth } from "../../src/overlay/provider/codex-refresh"
-import type { PluginInput } from "@saeeol/plugin"
-import { MessageV2 } from "../../src/session/message-v2"
-import { ProviderID } from "../../src/provider/schema"
-
-type Auth = {
-  type: "oauth"
-  refresh: string
-  access: string
-  expires: number
-  accountId?: string
-}
-
-const expired = (): Auth => ({
-  type: "oauth",
-  access: "old-access",
-  refresh: "old-refresh",
-  expires: 0,
-})
-
-function plugin(persist: (auth: Auth) => void): PluginInput {
-  const set = async (req: { body: Auth }) => {
-    persist(req.body)
-  }
-  return {
-    client: {
-      auth: { set },
-    },
-  } as unknown as PluginInput
-}
-
-describe("Codex auth refresh", () => {
-  test("serializes expired Codex auth as ProviderAuthError", () => {
-    const result = MessageV2.fromError(new CodexAuthExpiredError(), { providerID: ProviderID.make("openai") })
-
-    expect(result).toStrictEqual({
-      name: "ProviderAuthError",
-      data: {
-        providerID: "openai",
-        message:
-          "Your ChatGPT sign-in expired or was revoked. Sign in with ChatGPT again to continue using Codex models.",
-      },
-    })
-  })
-
-  test("coalesces concurrent refreshes and persists rotated tokens", async () => {
-    const calls: string[] = []
-    const writes: Auth[] = []
-    const first = expired()
-    const second = expired()
-    const refresh = async (token: string) => {
-      calls.push(token)
-      await new Promise((resolve) => setTimeout(resolve, 1))
-      return { id_token: "", access_token: "next-access", refresh_token: "next-refresh", expires_in: 60 }
-    }
-
-    const [a, b] = await Promise.all([
-      refreshCodexAuth({
-        input: plugin((auth) => writes.push(auth)),
-        getAuth: async () => first,
-        auth: first,
-        refresh,
-        account: () => undefined,
-      }),
-      refreshCodexAuth({
-        input: plugin((auth) => writes.push(auth)),
-        getAuth: async () => second,
-        auth: second,
-        refresh,
-        account: () => undefined,
-      }),
-    ])
-
-    expect(calls).toEqual(["old-refresh"])
-    expect(writes).toHaveLength(1)
-    expect(a.access).toBe("next-access")
-    expect(b.refresh).toBe("next-refresh")
-    expect(first.access).toBe("next-access")
-    expect(second.access).toBe("next-access")
-  })
-
-  test("uses a newer stored token after refresh 401", async () => {
-    const fresh = {
-      type: "oauth" as const,
-      access: "fresh-access",
-      refresh: "fresh-refresh",
-      expires: Date.now() + 60_000,
-    }
-    const auth = expired()
-    let count = 0
-    const getAuth = async () => {
-      count++
-      return count === 1 ? auth : fresh
-    }
-
-    const result = await refreshCodexAuth({
-      input: plugin(() => {}),
-      getAuth,
-      auth,
-      refresh: async () => {
-        throw new Error("Token refresh failed: 401")
-      },
-      account: () => undefined,
-    })
-
-    expect(result).toBe(fresh)
-  })
-
-  test("throws reauth error when refresh 401 has no newer stored token", async () => {
-    const auth = expired()
-    await expect(
-      refreshCodexAuth({
-        input: plugin(() => {}),
-        getAuth: async () => auth,
-        auth,
-        refresh: async () => {
-          throw new Error("Token refresh failed: 401")
-        },
-        account: () => undefined,
-      }),
-    ).rejects.toBeInstanceOf(CodexAuthExpiredError)
-  })
-})

package/test/saeeol/commit-message/generate.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, test, mock, beforeEach } from "bun:test"
-import type { GitContext } from "@/saeeol/commit-message/types"
-
-// Mock dependencies before importing the module under test.
-// IMPORTANT: Bun's mock.module() is process-wide and permanent. To avoid
-// breaking other test files, we spread real exports and only override what
-// this test needs.
-
-const realLog = await import("@saeeol/core/util/log")
-const realProvider = await import("@/provider/provider")
-const realLLM = await import("@/session/llm")
-const realAgent = await import("@/agent/agent")
-const realGitContext = await import("@/saeeol/commit-message/git-context")
-
-let mockStreamText = "feat(src): add hello world logging"
-
-const defaultGitContext: GitContext = {
-  branch: "main",
-  recentCommits: ["abc1234 initial commit"],
-  files: [
-    {
-      status: "modified",
-      path: "src/index.ts",
-      diff: "+console.log('hello')",
-    },
-  ],
-}
-
-let mockGitContext: GitContext = { ...defaultGitContext }
-let captured: { path: string; selected?: string[] } = { path: "" }
-
-mock.module("@/saeeol/commit-message/git-context", () => ({
-  ...realGitContext,
-  getGitContext: async (repoPath: string, selectedFiles?: string[]) => {
-    captured = { path: repoPath, selected: selectedFiles }
-    return mockGitContext
-  },
-}))
-
-mock.module("@/provider/provider", () => ({
-  ...realProvider,
-  Provider: {
-    ...realProvider.Provider,
-    defaultModel: async () => ({ providerID: "test", modelID: "test-model" }),
-    getSmallModel: async () => ({
-      providerID: "test",
-      id: "test-small-model",
-    }),
-    getModel: async () => ({ providerID: "test", id: "test-model" }),
-  },
-}))
-
-mock.module("@/session/llm", () => ({
-  ...realLLM,
-  LLM: {
-    ...realLLM.LLM,
-    stream: async () => ({
-      textStream: (async function* () {
-        yield mockStreamText
-      })(),
-      text: Promise.resolve(mockStreamText),
-    }),
-  },
-}))
-
-mock.module("@/agent/agent", () => ({
-  ...realAgent,
-  Agent: {},
-}))
-
-mock.module("@saeeol/core/util/log", () => ({
-  ...realLog,
-  create: () => ({
-    info: () => {},
-    error: () => {},
-    warn: () => {},
-    debug: () => {},
-  }),
-}))
-
-import { generateCommitMessage } from "../../../src/overlay/commit-message/generate"
-
-describe("commit-message.generate", () => {
-  beforeEach(() => {
-    mockStreamText = "feat(src): add hello world logging"
-    mockGitContext = { ...defaultGitContext }
-    captured = { path: "" }
-  })
-
-  describe("prompt construction", () => {
-    test("passes path to getGitContext", async () => {
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBeTruthy()
-      expect(captured.path).toBe("/repo")
-    })
-
-    test("generates message from git context with multiple files", async () => {
-      mockStreamText = "feat(api): add api module"
-      mockGitContext = {
-        branch: "main",
-        recentCommits: ["abc1234 initial commit"],
-        files: [
-          { status: "added", path: "src/api.ts", diff: "+export function api() {}" },
-          { status: "modified", path: "src/index.ts", diff: "+import { api } from './api'" },
-        ],
-      }
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBe("feat(api): add api module")
-    })
-  })
-
-  describe("response cleaning", () => {
-    test("strips code block markers from response", async () => {
-      mockStreamText = "```\nfeat: add feature\n```"
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBe("feat: add feature")
-    })
-
-    test("strips code block markers with language tag", async () => {
-      mockStreamText = "```text\nfix(auth): resolve token refresh\n```"
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBe("fix(auth): resolve token refresh")
-    })
-
-    test("strips surrounding double quotes", async () => {
-      mockStreamText = '"feat: add new feature"'
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBe("feat: add new feature")
-    })
-
-    test("strips surrounding single quotes", async () => {
-      mockStreamText = "'fix: resolve bug'"
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBe("fix: resolve bug")
-    })
-
-    test("strips whitespace around the message", async () => {
-      mockStreamText = "  \n  chore: update deps  \n  "
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBe("chore: update deps")
-    })
-
-    test("strips code blocks AND quotes together", async () => {
-      mockStreamText = '```\n"refactor: simplify logic"\n```'
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBe("refactor: simplify logic")
-    })
-
-    test("returns clean message when no markers present", async () => {
-      mockStreamText = "docs: update readme"
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBe("docs: update readme")
-    })
-  })
-
-  describe("error on no changes", () => {
-    test("throws when no git changes are found", async () => {
-      mockGitContext = { branch: "main", recentCommits: [], files: [] }
-      await expect(generateCommitMessage({ path: "/repo" })).rejects.toThrow(
-        "No changes found to generate a commit message for",
-      )
-    })
-  })
-
-  describe("selectedFiles pass-through", () => {
-    test("passes selectedFiles to getGitContext", async () => {
-      const result = await generateCommitMessage({
-        path: "/repo",
-        selectedFiles: ["src/a.ts"],
-      })
-      expect(result.message).toBeTruthy()
-      expect(captured.path).toBe("/repo")
-      expect(captured.selected).toEqual(["src/a.ts"])
-    })
-  })
-
-  describe("custom prompt", () => {
-    test("uses default prompt when no custom prompt provided", async () => {
-      const result = await generateCommitMessage({ path: "/repo" })
-      expect(result.message).toBeTruthy()
-    })
-
-    test("uses custom prompt when provided", async () => {
-      const result = await generateCommitMessage({ path: "/repo", prompt: "Write a haiku commit message." })
-      expect(result.message).toBeTruthy()
-    })
-  })
-})