@toolkit-cli/toolkode 1.3.7 → 1.3.9

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,80 +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/sst/opencode.git")).toEqual({ owner: "sst", repo: "opencode" })
-})
-
-test("parses https URL without .git suffix", () => {
-  expect(parseGitHubRemote("https://github.com/sst/opencode")).toEqual({ owner: "sst", repo: "opencode" })
-})
-
-test("parses git@ URL with .git suffix", () => {
-  expect(parseGitHubRemote("git@github.com:sst/opencode.git")).toEqual({ owner: "sst", repo: "opencode" })
-})
-
-test("parses git@ URL without .git suffix", () => {
-  expect(parseGitHubRemote("git@github.com:sst/opencode")).toEqual({ owner: "sst", repo: "opencode" })
-})
-
-test("parses ssh:// URL with .git suffix", () => {
-  expect(parseGitHubRemote("ssh://git@github.com/sst/opencode.git")).toEqual({ owner: "sst", repo: "opencode" })
-})
-
-test("parses ssh:// URL without .git suffix", () => {
-  expect(parseGitHubRemote("ssh://git@github.com/sst/opencode")).toEqual({ owner: "sst", repo: "opencode" })
-})
-
-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()
-})

package/test/cli/import.test.ts

@@ -1,54 +0,0 @@
-import { test, expect } from "bun:test"
-import {
-  parseShareUrl,
-  shouldAttachShareAuthHeaders,
-  transformShareData,
-  type ShareData,
-} from "../../src/cli/cmd/import"
-
-// parseShareUrl tests
-test("parses valid share URLs", () => {
-  expect(parseShareUrl("https://toolkode.com/share/Jsj3hNIW")).toBe("Jsj3hNIW")
-  expect(parseShareUrl("https://custom.example.com/share/abc123")).toBe("abc123")
-  expect(parseShareUrl("http://localhost:3000/share/test_id-123")).toBe("test_id-123")
-})
-
-test("rejects invalid URLs", () => {
-  expect(parseShareUrl("https://toolkode.com/s/Jsj3hNIW")).toBeNull() // legacy format
-  expect(parseShareUrl("https://toolkode.com/share/")).toBeNull()
-  expect(parseShareUrl("https://toolkode.com/share/id/extra")).toBeNull()
-  expect(parseShareUrl("not-a-url")).toBeNull()
-})
-
-test("only attaches share auth headers for same-origin URLs", () => {
-  expect(shouldAttachShareAuthHeaders("https://control.example.com/share/abc", "https://control.example.com")).toBe(
-    true,
-  )
-  expect(shouldAttachShareAuthHeaders("https://other.example.com/share/abc", "https://control.example.com")).toBe(false)
-  expect(shouldAttachShareAuthHeaders("https://control.example.com:443/share/abc", "https://control.example.com")).toBe(
-    true,
-  )
-  expect(shouldAttachShareAuthHeaders("not-a-url", "https://control.example.com")).toBe(false)
-})
-
-// transformShareData tests
-test("transforms share data to storage format", () => {
-  const data: ShareData[] = [
-    { type: "session", data: { id: "sess-1", title: "Test" } as any },
-    { type: "message", data: { id: "msg-1", sessionID: "sess-1" } as any },
-    { type: "part", data: { id: "part-1", messageID: "msg-1" } as any },
-    { type: "part", data: { id: "part-2", messageID: "msg-1" } as any },
-  ]
-
-  const result = transformShareData(data)!
-
-  expect(result.info.id).toBe("sess-1")
-  expect(result.messages).toHaveLength(1)
-  expect(result.messages[0].parts).toHaveLength(2)
-})
-
-test("returns null for invalid share data", () => {
-  expect(transformShareData([])).toBeNull()
-  expect(transformShareData([{ type: "message", data: {} as any }])).toBeNull()
-  expect(transformShareData([{ type: "session", data: { id: "s" } as any }])).toBeNull() // no messages
-})

package/test/cli/plugin-auth-picker.test.ts

@@ -1,120 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { resolvePluginProviders } from "../../src/cli/cmd/providers"
-import type { Hooks } from "@toolkit-cli/plugin"
-
-function hookWithAuth(provider: string): Hooks {
-  return {
-    auth: {
-      provider,
-      methods: [],
-    },
-  }
-}
-
-function hookWithoutAuth(): Hooks {
-  return {}
-}
-
-describe("resolvePluginProviders", () => {
-  test("returns plugin providers not in models.dev", () => {
-    const result = resolvePluginProviders({
-      hooks: [hookWithAuth("portkey")],
-      existingProviders: {},
-      disabled: new Set(),
-      providerNames: {},
-    })
-    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
-  })
-
-  test("skips providers already in models.dev", () => {
-    const result = resolvePluginProviders({
-      hooks: [hookWithAuth("anthropic")],
-      existingProviders: { anthropic: {} },
-      disabled: new Set(),
-      providerNames: {},
-    })
-    expect(result).toEqual([])
-  })
-
-  test("deduplicates across plugins", () => {
-    const result = resolvePluginProviders({
-      hooks: [hookWithAuth("portkey"), hookWithAuth("portkey")],
-      existingProviders: {},
-      disabled: new Set(),
-      providerNames: {},
-    })
-    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
-  })
-
-  test("respects disabled_providers", () => {
-    const result = resolvePluginProviders({
-      hooks: [hookWithAuth("portkey")],
-      existingProviders: {},
-      disabled: new Set(["portkey"]),
-      providerNames: {},
-    })
-    expect(result).toEqual([])
-  })
-
-  test("respects enabled_providers when provider is absent", () => {
-    const result = resolvePluginProviders({
-      hooks: [hookWithAuth("portkey")],
-      existingProviders: {},
-      disabled: new Set(),
-      enabled: new Set(["anthropic"]),
-      providerNames: {},
-    })
-    expect(result).toEqual([])
-  })
-
-  test("includes provider when in enabled set", () => {
-    const result = resolvePluginProviders({
-      hooks: [hookWithAuth("portkey")],
-      existingProviders: {},
-      disabled: new Set(),
-      enabled: new Set(["portkey"]),
-      providerNames: {},
-    })
-    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
-  })
-
-  test("resolves name from providerNames", () => {
-    const result = resolvePluginProviders({
-      hooks: [hookWithAuth("portkey")],
-      existingProviders: {},
-      disabled: new Set(),
-      providerNames: { portkey: "Portkey AI" },
-    })
-    expect(result).toEqual([{ id: "portkey", name: "Portkey AI" }])
-  })
-
-  test("falls back to id when no name configured", () => {
-    const result = resolvePluginProviders({
-      hooks: [hookWithAuth("portkey")],
-      existingProviders: {},
-      disabled: new Set(),
-      providerNames: {},
-    })
-    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
-  })
-
-  test("skips hooks without auth", () => {
-    const result = resolvePluginProviders({
-      hooks: [hookWithoutAuth(), hookWithAuth("portkey"), hookWithoutAuth()],
-      existingProviders: {},
-      disabled: new Set(),
-      providerNames: {},
-    })
-    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
-  })
-
-  test("returns empty for no hooks", () => {
-    const result = resolvePluginProviders({
-      hooks: [],
-      existingProviders: {},
-      disabled: new Set(),
-      providerNames: {},
-    })
-    expect(result).toEqual([])
-  })
-})

package/test/cli/tui/keybind-plugin.test.ts

@@ -1,90 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import type { ParsedKey } from "@opentui/core"
-import { createPluginKeybind } from "../../../src/cli/cmd/tui/context/plugin-keybinds"
-
-describe("createPluginKeybind", () => {
-  const defaults = {
-    open: "ctrl+o",
-    close: "escape",
-  }
-
-  test("uses defaults when overrides are missing", () => {
-    const api = {
-      match: () => false,
-      print: (key: string) => key,
-    }
-    const bind = createPluginKeybind(api, defaults)
-
-    expect(bind.all).toEqual(defaults)
-    expect(bind.get("open")).toBe("ctrl+o")
-    expect(bind.get("close")).toBe("escape")
-  })
-
-  test("applies valid overrides", () => {
-    const api = {
-      match: () => false,
-      print: (key: string) => key,
-    }
-    const bind = createPluginKeybind(api, defaults, {
-      open: "ctrl+alt+o",
-      close: "q",
-    })
-
-    expect(bind.all).toEqual({
-      open: "ctrl+alt+o",
-      close: "q",
-    })
-  })
-
-  test("ignores invalid overrides", () => {
-    const api = {
-      match: () => false,
-      print: (key: string) => key,
-    }
-    const bind = createPluginKeybind(api, defaults, {
-      open: "   ",
-      close: 1,
-      extra: "ctrl+x",
-    })
-
-    expect(bind.all).toEqual(defaults)
-    expect(bind.get("extra")).toBe("extra")
-  })
-
-  test("resolves names for match", () => {
-    const list: string[] = []
-    const api = {
-      match: (key: string) => {
-        list.push(key)
-        return true
-      },
-      print: (key: string) => key,
-    }
-    const bind = createPluginKeybind(api, defaults, {
-      open: "ctrl+shift+o",
-    })
-
-    bind.match("open", { name: "x" } as ParsedKey)
-    bind.match("ctrl+k", { name: "x" } as ParsedKey)
-
-    expect(list).toEqual(["ctrl+shift+o", "ctrl+k"])
-  })
-
-  test("resolves names for print", () => {
-    const list: string[] = []
-    const api = {
-      match: () => false,
-      print: (key: string) => {
-        list.push(key)
-        return `print:${key}`
-      },
-    }
-    const bind = createPluginKeybind(api, defaults, {
-      close: "q",
-    })
-
-    expect(bind.print("close")).toBe("print:q")
-    expect(bind.print("ctrl+p")).toBe("print:ctrl+p")
-    expect(list).toEqual(["q", "ctrl+p"])
-  })
-})

package/test/cli/tui/plugin-add.test.ts

@@ -1,61 +0,0 @@
-import { expect, spyOn, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { pathToFileURL } from "url"
-import { tmpdir } from "../../fixture/fixture"
-import { createTuiPluginApi } from "../../fixture/tui-plugin"
-import { TuiConfig } from "../../../src/config/tui"
-
-const { TuiPluginRuntime } = await import("../../../src/cli/cmd/tui/plugin/runtime")
-
-test("adds tui plugin at runtime from spec", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      const file = path.join(dir, "add-plugin.ts")
-      const spec = pathToFileURL(file).href
-      const marker = path.join(dir, "add.txt")
-
-      await Bun.write(
-        file,
-        `export default {
-  id: "demo.add",
-  tui: async () => {
-    await Bun.write(${JSON.stringify(marker)}, "called")
-  },
-}
-`,
-      )
-
-      return { spec, marker }
-    },
-  })
-
-  process.env.OPENCODE_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
-  const get = spyOn(TuiConfig, "get").mockResolvedValue({
-    plugin: [],
-    plugin_meta: undefined,
-  })
-  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
-  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
-
-  try {
-    await TuiPluginRuntime.init(createTuiPluginApi())
-
-    await expect(TuiPluginRuntime.addPlugin(tmp.extra.spec)).resolves.toBe(true)
-    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("called")
-    expect(TuiPluginRuntime.list().find((item) => item.id === "demo.add")).toEqual({
-      id: "demo.add",
-      source: "file",
-      spec: tmp.extra.spec,
-      target: tmp.extra.spec,
-      enabled: true,
-      active: true,
-    })
-  } finally {
-    await TuiPluginRuntime.dispose()
-    cwd.mockRestore()
-    get.mockRestore()
-    wait.mockRestore()
-    delete process.env.OPENCODE_PLUGIN_META_FILE
-  }
-})