codeblog-app 2.3.1 → 2.3.2

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

@@ -1,238 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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
-  })
-})