codeblog-app 2.3.0 → 2.3.1

package/src/ai/__tests__/provider.test.ts

@@ -0,0 +1,238 @@
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+import { describe, test, expect, beforeAll, beforeEach, afterEach, afterAll } from "bun:test"
+import { Config } from "../../config"
+
+describe("AIProvider", () => {
+  const originalEnv = { ...process.env }
+  const testHome = path.join(os.tmpdir(), `codeblog-provider-test-${process.pid}-${Date.now()}`)
+  const configFile = path.join(testHome, ".config", "codeblog", "config.json")
+  const xdgData = path.join(testHome, ".local", "share")
+  const xdgCache = path.join(testHome, ".cache")
+  const xdgConfig = path.join(testHome, ".config")
+  const xdgState = path.join(testHome, ".local", "state")
+  const envKeys = [
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_AUTH_TOKEN",
+    "OPENAI_API_KEY",
+    "GOOGLE_GENERATIVE_AI_API_KEY",
+    "GOOGLE_API_KEY",
+    "OPENAI_COMPATIBLE_API_KEY",
+    "ANTHROPIC_BASE_URL",
+    "OPENAI_BASE_URL",
+    "OPENAI_API_BASE",
+    "GOOGLE_API_BASE_URL",
+    "OPENAI_COMPATIBLE_BASE_URL",
+  ]
+  let AIProvider: (typeof import("../provider"))["AIProvider"]
+
+  beforeAll(async () => {
+    process.env.CODEBLOG_TEST_HOME = testHome
+    process.env.XDG_DATA_HOME = xdgData
+    process.env.XDG_CACHE_HOME = xdgCache
+    process.env.XDG_CONFIG_HOME = xdgConfig
+    process.env.XDG_STATE_HOME = xdgState
+    process.env.CODEBLOG_AI_PROVIDER_REGISTRY_V2 = "0"
+    await fs.mkdir(path.dirname(configFile), { recursive: true })
+    await fs.writeFile(configFile, "{}\n")
+    ;({ AIProvider } = await import("../provider"))
+  })
+
+  beforeEach(async () => {
+    process.env.CODEBLOG_TEST_HOME = testHome
+    process.env.XDG_DATA_HOME = xdgData
+    process.env.XDG_CACHE_HOME = xdgCache
+    process.env.XDG_CONFIG_HOME = xdgConfig
+    process.env.XDG_STATE_HOME = xdgState
+    process.env.CODEBLOG_AI_PROVIDER_REGISTRY_V2 = "0"
+    for (const key of envKeys) delete process.env[key]
+    await fs.writeFile(configFile, "{}\n")
+  })
+
+  afterEach(() => {
+    for (const key of Object.keys(process.env)) {
+      if (!(key in originalEnv)) delete process.env[key]
+    }
+    for (const [key, val] of Object.entries(originalEnv)) {
+      if (val !== undefined) process.env[key] = val
+    }
+  })
+
+  afterAll(async () => {
+    await fs.rm(testHome, { recursive: true, force: true })
+  })
+
+  // ---------------------------------------------------------------------------
+  // BUILTIN_MODELS
+  // ---------------------------------------------------------------------------
+
+  test("BUILTIN_MODELS has 7 models", () => {
+    expect(Object.keys(AIProvider.BUILTIN_MODELS)).toHaveLength(7)
+  })
+
+  test("each model has required fields", () => {
+    for (const [id, model] of Object.entries(AIProvider.BUILTIN_MODELS)) {
+      expect(model.id).toBe(id)
+      expect(model.providerID).toBeTruthy()
+      expect(model.name).toBeTruthy()
+      expect(model.contextWindow).toBeGreaterThan(0)
+      expect(model.outputTokens).toBeGreaterThan(0)
+    }
+  })
+
+  test("DEFAULT_MODEL is a valid builtin model", () => {
+    expect(AIProvider.BUILTIN_MODELS[AIProvider.DEFAULT_MODEL]).toBeDefined()
+  })
+
+  test("all providers are covered: anthropic, openai, google", () => {
+    const providerIDs = new Set(Object.values(AIProvider.BUILTIN_MODELS).map((m) => m.providerID))
+    expect(providerIDs.has("anthropic")).toBe(true)
+    expect(providerIDs.has("openai")).toBe(true)
+    expect(providerIDs.has("google")).toBe(true)
+  })
+
+  // ---------------------------------------------------------------------------
+  // getApiKey
+  // ---------------------------------------------------------------------------
+
+  test("getApiKey returns env var when set", async () => {
+    process.env.ANTHROPIC_API_KEY = "sk-ant-test123"
+    const key = await AIProvider.getApiKey("anthropic")
+    expect(key).toBe("sk-ant-test123")
+  })
+
+  test("getApiKey checks secondary env var", async () => {
+    process.env.ANTHROPIC_AUTH_TOKEN = "token-test"
+    const key = await AIProvider.getApiKey("anthropic")
+    expect(key).toBe("token-test")
+  })
+
+  test("getApiKey returns undefined when no key set", async () => {
+    const key = await AIProvider.getApiKey("anthropic")
+    // May return undefined or a config value — just check it doesn't crash
+    expect(key === undefined || typeof key === "string").toBe(true)
+  })
+
+  test("getApiKey works for openai", async () => {
+    process.env.OPENAI_API_KEY = "sk-openai-test"
+    const key = await AIProvider.getApiKey("openai")
+    expect(key).toBe("sk-openai-test")
+  })
+
+  test("getApiKey works for google", async () => {
+    process.env.GOOGLE_GENERATIVE_AI_API_KEY = "aiza-test"
+    const key = await AIProvider.getApiKey("google")
+    expect(key).toBe("aiza-test")
+  })
+
+  // ---------------------------------------------------------------------------
+  // getBaseUrl
+  // ---------------------------------------------------------------------------
+
+  test("getBaseUrl returns env var when set", async () => {
+    process.env.ANTHROPIC_BASE_URL = "https://custom.api.com"
+    const url = await AIProvider.getBaseUrl("anthropic")
+    expect(url).toBe("https://custom.api.com")
+  })
+
+  test("getBaseUrl returns undefined when no env var set", async () => {
+    const url = await AIProvider.getBaseUrl("anthropic")
+    expect(url === undefined || typeof url === "string").toBe(true)
+  })
+
+  // ---------------------------------------------------------------------------
+  // hasAnyKey
+  // ---------------------------------------------------------------------------
+
+  test("hasAnyKey returns true when any key is set", async () => {
+    process.env.OPENAI_API_KEY = "sk-test"
+    const has = await AIProvider.hasAnyKey()
+    expect(has).toBe(true)
+  })
+
+  // ---------------------------------------------------------------------------
+  // parseModel
+  // ---------------------------------------------------------------------------
+
+  test("parseModel splits provider/model", () => {
+    const result = AIProvider.parseModel("anthropic/claude-sonnet-4-20250514")
+    expect(result.providerID).toBe("anthropic")
+    expect(result.modelID).toBe("claude-sonnet-4-20250514")
+  })
+
+  test("parseModel handles nested slashes", () => {
+    const result = AIProvider.parseModel("openai/gpt-4o/latest")
+    expect(result.providerID).toBe("openai")
+    expect(result.modelID).toBe("gpt-4o/latest")
+  })
+
+  test("parseModel handles no slash", () => {
+    const result = AIProvider.parseModel("gpt-4o")
+    expect(result.providerID).toBe("gpt-4o")
+    expect(result.modelID).toBe("")
+  })
+
+  // ---------------------------------------------------------------------------
+  // available
+  // ---------------------------------------------------------------------------
+
+  test("available returns at least builtin models with hasKey status", async () => {
+    const models = await AIProvider.available()
+    expect(models.length).toBeGreaterThanOrEqual(7)
+    for (const entry of models) {
+      expect(entry.model).toBeDefined()
+      expect(typeof entry.hasKey).toBe("boolean")
+    }
+    // The first 7 should always be builtins
+    const builtinCount = models.filter((m) => AIProvider.BUILTIN_MODELS[m.model.id]).length
+    expect(builtinCount).toBe(7)
+  })
+
+  test("available includes openai-compatible remote models when configured", async () => {
+    // With a valid key and base URL from config, remote models should be fetched.
+    // This test verifies that available() attempts to include openai-compatible models.
+    // Use localhost to ensure fast failure (connection refused) instead of DNS timeout.
+    process.env.OPENAI_COMPATIBLE_API_KEY = "sk-test"
+    process.env.OPENAI_COMPATIBLE_BASE_URL = "http://127.0.0.1:1"
+    const models = await AIProvider.available()
+    // Should still return at least builtins even if remote fetch fails
+    expect(models.length).toBeGreaterThanOrEqual(7)
+  })
+
+  // ---------------------------------------------------------------------------
+  // getModel
+  // ---------------------------------------------------------------------------
+
+  test("getModel throws when no API key for builtin model", async () => {
+    const load = Config.load
+    Config.load = async () => ({ api_url: "https://codeblog.ai" })
+    try {
+      await expect(AIProvider.getModel("gpt-4o")).rejects.toThrow("No API key for openai")
+    } finally {
+      Config.load = load
+    }
+  })
+
+  test("getModel falls back to provider with base_url for unknown model", async () => {
+    // When a provider with base_url is configured, unknown models get sent there
+    // instead of throwing. This test verifies the fallback behavior.
+    // If no provider has a base_url, it would throw.
+    const result = AIProvider.getModel("nonexistent-model-xyz")
+    // Either resolves (provider with base_url available) or rejects
+    const settled = await Promise.allSettled([result])
+    expect(settled[0]!.status).toBeDefined()
+  })
+
+  // ---------------------------------------------------------------------------
+  // listProviders
+  // ---------------------------------------------------------------------------
+
+  test("listProviders returns provider info", async () => {
+    process.env.OPENAI_API_KEY = "sk-test"
+    const providers = await AIProvider.listProviders()
+    expect(providers.openai).toBeDefined()
+    expect(providers.openai!.hasKey).toBe(true)
+    expect(providers.openai!.models.length).toBeGreaterThan(0)
+  })
+})

package/src/ai/__tests__/stream-events.test.ts

@@ -0,0 +1,152 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test"
+
+const mockListTools = mock(async () => ({ tools: [] }))
+
+mock.module("../../mcp/client", () => ({
+  McpBridge: {
+    listTools: mockListTools,
+    callToolJSON: mock(async () => ({})),
+  },
+}))
+
+let streamFactory: () => { fullStream: AsyncGenerator<any, void, unknown> } = () => ({
+  fullStream: (async function* () {
+    yield { type: "text-delta", textDelta: "hello" }
+  })(),
+})
+
+mock.module("ai", () => ({
+  streamText: () => streamFactory(),
+  stepCountIs: (n: number) => ({ type: "step-count", count: n }),
+  tool: (config: any) => config,
+  jsonSchema: (schema: any) => schema,
+}))
+
+mock.module("../provider", () => ({
+  AIProvider: {
+    getModel: mock(async () => ({ id: "test-model" })),
+    resolveModelCompat: mock(async () => ({
+      providerID: "openai-compatible",
+      modelID: "test-model",
+      api: "openai-compatible",
+      compatProfile: "openai-compatible",
+      cacheKey: "openai-compatible:openai-compatible",
+      stripParallelToolCalls: true,
+      normalizeToolSchema: true,
+    })),
+    DEFAULT_MODEL: "test-model",
+  },
+}))
+
+const { AIChat } = await import("../chat")
+
+describe("stream events", () => {
+  beforeEach(() => {
+    mockListTools.mockClear()
+  })
+
+  test("emits ordered run-start -> deltas -> run-finish sequence", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "text-delta", textDelta: "Hello " }
+        yield { type: "text-delta", textDelta: "World" }
+      })(),
+    })
+
+    const events: any[] = []
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "hi" }])) {
+      events.push(event)
+    }
+
+    expect(events.map((e: any) => e.type)).toEqual(["run-start", "text-delta", "text-delta", "run-finish"])
+    expect(events.every((e: any) => e.runId === events[0]!.runId)).toBe(true)
+    expect(events.map((e: any) => e.seq)).toEqual([1, 2, 3, 4])
+  })
+
+  test("tool-start and tool-result are paired", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "tool-call", toolName: "scan_sessions", args: { limit: 5 } }
+        yield { type: "tool-result", toolName: "scan_sessions", result: { sessions: [] } }
+        yield { type: "text-delta", textDelta: "done" }
+      })(),
+    })
+
+    const starts: string[] = []
+    const results: string[] = []
+    const ids: Array<{ start?: string; result?: string }> = []
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "scan" }])) {
+      if (event.type === "tool-start") {
+        starts.push(event.name)
+        ids.push({ start: event.callID })
+      }
+      if (event.type === "tool-result") {
+        results.push(event.name)
+        ids[0] = { ...ids[0], result: event.callID }
+      }
+    }
+
+    expect(starts).toEqual(["scan_sessions"])
+    expect(results).toEqual(["scan_sessions"])
+    expect(ids[0]?.start).toBe(ids[0]?.result)
+  })
+
+  test("abort keeps lifecycle consistent and marks run-finish.aborted", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "text-delta", textDelta: "partial" }
+        await Bun.sleep(40)
+        yield { type: "text-delta", textDelta: " late" }
+      })(),
+    })
+
+    const ctrl = new AbortController()
+    let seenFinish = false
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "stop test" }], undefined, ctrl.signal)) {
+      if (event.type === "text-delta") ctrl.abort()
+      if (event.type === "run-finish") {
+        seenFinish = true
+        expect(event.aborted).toBe(true)
+      }
+    }
+
+    expect(seenFinish).toBe(true)
+  })
+
+  test("error part is surfaced and lifecycle still finishes", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "error", error: new Error("boom") }
+      })(),
+    })
+
+    const types: string[] = []
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "error path" }])) {
+      types.push(event.type)
+      if (event.type === "error") expect(event.error.message).toBe("boom")
+    }
+
+    expect(types).toContain("error")
+    expect(types[types.length - 1]).toBe("run-finish")
+  })
+
+  test("tool timeout emits error and still reaches run-finish", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "tool-call", toolName: "scan_sessions", args: { limit: 1 } }
+        await Bun.sleep(40)
+      })(),
+    })
+
+    const seen: string[] = []
+    for await (const event of AIChat.streamEvents([{ role: "user", content: "scan" }], undefined, undefined, {
+      toolTimeoutMs: 15,
+      idleTimeoutMs: 1000,
+    })) {
+      seen.push(event.type)
+    }
+
+    expect(seen).toContain("error")
+    expect(seen[seen.length - 1]).toBe("run-finish")
+  })
+})

package/src/ai/__tests__/tools.test.ts

@@ -0,0 +1,93 @@
+import { describe, test, expect, mock } from "bun:test"
+
+// Mock MCP bridge so tests don't need a running MCP server
+const MOCK_MCP_TOOLS = [
+  {
+    name: "scan_sessions",
+    description: "Scan IDE sessions for coding activity",
+    inputSchema: { type: "object", properties: { limit: { type: "number" } } },
+  },
+  {
+    name: "my_dashboard",
+    description: "Show the user dashboard with stats",
+    inputSchema: {},
+  },
+  {
+    name: "browse_posts",
+    description: "Browse posts on the forum with filters",
+    inputSchema: { type: "object", properties: { page: { type: "number" }, tag: { type: "string" } } },
+  },
+]
+
+mock.module("../../mcp/client", () => ({
+  McpBridge: {
+    listTools: mock(() => Promise.resolve({ tools: MOCK_MCP_TOOLS })),
+    callToolJSON: mock((name: string) => Promise.resolve({ ok: true, tool: name })),
+  },
+}))
+
+mock.module("ai", () => ({
+  tool: (config: any) => config,
+  jsonSchema: (schema: any) => schema,
+}))
+
+const { getChatTools, TOOL_LABELS, clearChatToolsCache } = await import("../tools")
+
+describe("AI Tools (dynamic MCP discovery)", () => {
+  let chatTools: Record<string, any>
+
+  test("getChatTools() discovers tools from MCP server", async () => {
+    clearChatToolsCache()
+    chatTools = await getChatTools()
+    const names = Object.keys(chatTools)
+    expect(names.length).toBe(MOCK_MCP_TOOLS.length)
+    expect(names).toContain("scan_sessions")
+    expect(names).toContain("my_dashboard")
+    expect(names).toContain("browse_posts")
+  })
+
+  test("each tool has inputSchema and execute", () => {
+    for (const [name, t] of Object.entries(chatTools)) {
+      const tool = t as any
+      expect(tool.inputSchema).toBeDefined()
+      expect(tool.execute).toBeDefined()
+      expect(typeof tool.execute).toBe("function")
+    }
+  })
+
+  test("each tool has a description", () => {
+    for (const [name, t] of Object.entries(chatTools)) {
+      const tool = t as any
+      expect(tool.description).toBeDefined()
+      expect(typeof tool.description).toBe("string")
+      expect(tool.description.length).toBeGreaterThan(10)
+    }
+  })
+
+  test("normalizeToolSchema adds type:object to empty schemas", async () => {
+    // my_dashboard has empty inputSchema {} — should be normalized
+    const dashboard = chatTools["my_dashboard"] as any
+    expect(dashboard.inputSchema.type).toBe("object")
+    expect(dashboard.inputSchema.properties).toEqual({})
+  })
+
+  // ---------------------------------------------------------------------------
+  // TOOL_LABELS tests (static fallback map)
+  // ---------------------------------------------------------------------------
+
+  test("TOOL_LABELS values are non-empty strings", () => {
+    for (const [key, label] of Object.entries(TOOL_LABELS)) {
+      expect(label.length).toBeGreaterThan(0)
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // Caching
+  // ---------------------------------------------------------------------------
+
+  test("getChatTools() returns cached result on second call", async () => {
+    const tools1 = await getChatTools()
+    const tools2 = await getChatTools()
+    expect(tools1).toBe(tools2) // same reference
+  })
+})