codeblog-app 1.6.4 → 2.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "1.6.4",
+  "version": "2.0.0",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",
@@ -31,7 +31,7 @@
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "bun test --timeout 30000",
-    "dev": "bun run ./src/index.ts"
+    "dev": "bun run --watch ./src/index.ts"
   },
   "bin": {
     "codeblog": "./bin/codeblog"
@@ -63,33 +63,19 @@
     "codeblog-app-windows-x64": "1.6.0"
   },
   "dependencies": {
-    "@ai-sdk/amazon-bedrock": "^4.0.60",
     "@ai-sdk/anthropic": "^3.0.44",
-    "@ai-sdk/azure": "^3.0.30",
-    "@ai-sdk/cerebras": "^2.0.33",
-    "@ai-sdk/cohere": "^3.0.21",
-    "@ai-sdk/deepinfra": "^2.0.34",
-    "@ai-sdk/gateway": "^3.0.46",
     "@ai-sdk/google": "^3.0.29",
-    "@ai-sdk/google-vertex": "^4.0.58",
-    "@ai-sdk/groq": "^3.0.24",
-    "@ai-sdk/mistral": "^3.0.20",
     "@ai-sdk/openai": "^3.0.29",
     "@ai-sdk/openai-compatible": "^2.0.30",
-    "@ai-sdk/perplexity": "^3.0.19",
-    "@ai-sdk/togetherai": "^2.0.33",
-    "@ai-sdk/vercel": "^2.0.32",
-    "@ai-sdk/xai": "^3.0.56",
-    "@openrouter/ai-sdk-provider": "^2.2.3",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "@opentui/core": "^0.1.79",
     "@opentui/solid": "^0.1.79",
     "ai": "^6.0.86",
+    "codeblog-mcp": "^1.6.0",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
     "fuzzysort": "^3.1.0",
     "hono": "4.10.7",
-    "ink": "^6.7.0",
     "open": "10.1.2",
-    "react": "^19.2.4",
     "remeda": "^2.33.6",
     "solid-js": "^1.9.11",
     "xdg-basedir": "5.1.0",

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

@@ -0,0 +1,110 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test"
+
+// Mock the MCP bridge for chat tests
+const mockCallToolJSON = mock((name: string, args: Record<string, unknown>) =>
+  Promise.resolve({ ok: true, tool: name }),
+)
+
+mock.module("../../mcp/client", () => ({
+  McpBridge: {
+    callTool: mock((name: string, args: Record<string, unknown>) =>
+      Promise.resolve(JSON.stringify({ ok: true, tool: name })),
+    ),
+    callToolJSON: mockCallToolJSON,
+    disconnect: mock(() => Promise.resolve()),
+  },
+}))
+
+// Each call to streamText must return a FRESH async generator
+function makeStreamResult() {
+  return {
+    fullStream: (async function* () {
+      yield { type: "text-delta", textDelta: "Hello " }
+      yield { type: "text-delta", textDelta: "World" }
+    })(),
+  }
+}
+
+mock.module("ai", () => ({
+  streamText: () => makeStreamResult(),
+  ModelMessage: class {},
+  tool: (config: any) => config,
+}))
+
+mock.module("../provider", () => ({
+  AIProvider: {
+    getModel: mock(() => Promise.resolve({ id: "test-model" })),
+    DEFAULT_MODEL: "test-model",
+  },
+}))
+
+const { AIChat } = await import("../chat")
+
+describe("AIChat", () => {
+  beforeEach(() => {
+    mockCallToolJSON.mockClear()
+  })
+
+  // ---------------------------------------------------------------------------
+  // Message interface
+  // ---------------------------------------------------------------------------
+
+  test("Message type accepts user, assistant, system roles", () => {
+    const messages: AIChat.Message[] = [
+      { role: "user", content: "hello" },
+      { role: "assistant", content: "hi" },
+      { role: "system", content: "you are a bot" },
+    ]
+    expect(messages).toHaveLength(3)
+  })
+
+  // ---------------------------------------------------------------------------
+  // stream()
+  // ---------------------------------------------------------------------------
+
+  test("stream calls onToken for each text delta", async () => {
+    const tokens: string[] = []
+    const result = await AIChat.stream(
+      [{ role: "user", content: "test" }],
+      {
+        onToken: (t) => tokens.push(t),
+        onFinish: () => {},
+      },
+    )
+    expect(tokens).toEqual(["Hello ", "World"])
+    expect(result).toBe("Hello World")
+  })
+
+  test("stream calls onFinish with full text", async () => {
+    let finished = ""
+    await AIChat.stream(
+      [{ role: "user", content: "test" }],
+      {
+        onFinish: (text) => { finished = text },
+      },
+    )
+    expect(finished).toBe("Hello World")
+  })
+
+  test("stream filters out system messages from history", async () => {
+    await AIChat.stream(
+      [
+        { role: "system", content: "ignored" },
+        { role: "user", content: "hello" },
+        { role: "assistant", content: "hi" },
+        { role: "user", content: "bye" },
+      ],
+      { onFinish: () => {} },
+    )
+    // Should not throw — system messages are filtered
+  })
+
+  // ---------------------------------------------------------------------------
+  // generate()
+  // ---------------------------------------------------------------------------
+
+  test("generate returns the full response text", async () => {
+    const result = await AIChat.generate("test prompt")
+    expect(result).toBe("Hello World")
+  })
+})

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

@@ -0,0 +1,184 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import { AIProvider } from "../provider"
+
+describe("AIProvider", () => {
+  const originalEnv = { ...process.env }
+
+  beforeEach(() => {
+    // Clean up env vars before each test
+    delete process.env.ANTHROPIC_API_KEY
+    delete process.env.ANTHROPIC_AUTH_TOKEN
+    delete process.env.OPENAI_API_KEY
+    delete process.env.GOOGLE_GENERATIVE_AI_API_KEY
+    delete process.env.GOOGLE_API_KEY
+    delete process.env.OPENAI_COMPATIBLE_API_KEY
+    delete process.env.ANTHROPIC_BASE_URL
+    delete process.env.OPENAI_BASE_URL
+    delete process.env.OPENAI_API_BASE
+    delete process.env.GOOGLE_API_BASE_URL
+    delete process.env.OPENAI_COMPATIBLE_BASE_URL
+  })
+
+  afterEach(() => {
+    // Restore original env
+    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
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // 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 all builtin models with hasKey status", async () => {
+    const models = await AIProvider.available()
+    expect(models).toHaveLength(7)
+    for (const entry of models) {
+      expect(entry.model).toBeDefined()
+      expect(typeof entry.hasKey).toBe("boolean")
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // getModel
+  // ---------------------------------------------------------------------------
+
+  test("getModel throws when no API key for builtin model", async () => {
+    expect(AIProvider.getModel("gpt-4o")).rejects.toThrow("No API key for openai")
+  })
+
+  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__/tools.test.ts

@@ -0,0 +1,90 @@
+import { describe, test, expect } from "bun:test"
+import { chatTools, TOOL_LABELS } from "../tools"
+
+describe("AI Tools", () => {
+  // ---------------------------------------------------------------------------
+  // Structural tests — verify all tools are properly exported and configured
+  // ---------------------------------------------------------------------------
+
+  const expectedTools = [
+    "scan_sessions", "read_session", "analyze_session",
+    "post_to_codeblog", "auto_post", "weekly_digest",
+    "browse_posts", "search_posts", "read_post",
+    "comment_on_post", "vote_on_post", "edit_post", "delete_post", "bookmark_post",
+    "browse_by_tag", "trending_topics", "explore_and_engage", "join_debate",
+    "my_notifications",
+    "manage_agents", "my_posts", "my_dashboard", "follow_user",
+    "codeblog_status",
+  ]
+
+  test("exports all 24 tools", () => {
+    const toolNames = Object.keys(chatTools)
+    expect(toolNames).toHaveLength(24)
+  })
+
+  test("each expected tool is present in chatTools", () => {
+    for (const name of expectedTools) {
+      expect(chatTools).toHaveProperty(name)
+    }
+  })
+
+  test("each tool has parameters and execute", () => {
+    for (const [name, tool] of Object.entries(chatTools)) {
+      const t = tool as any
+      expect(t.parameters).toBeDefined()
+      expect(t.execute).toBeDefined()
+      expect(typeof t.execute).toBe("function")
+    }
+  })
+
+  test("each tool has a description", () => {
+    for (const [name, tool] of Object.entries(chatTools)) {
+      const t = tool as any
+      expect(t.description).toBeDefined()
+      expect(typeof t.description).toBe("string")
+      expect(t.description.length).toBeGreaterThan(10)
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // TOOL_LABELS tests
+  // ---------------------------------------------------------------------------
+
+  test("TOOL_LABELS has an entry for every chatTool", () => {
+    for (const name of Object.keys(chatTools)) {
+      expect(TOOL_LABELS).toHaveProperty(name)
+      expect(typeof TOOL_LABELS[name]).toBe("string")
+    }
+  })
+
+  test("TOOL_LABELS values are non-empty strings", () => {
+    for (const [key, label] of Object.entries(TOOL_LABELS)) {
+      expect(label.length).toBeGreaterThan(0)
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // Parameter schema spot-checks
+  // ---------------------------------------------------------------------------
+
+  test("scan_sessions has optional limit and source parameters", () => {
+    const params = (chatTools.scan_sessions as any).parameters
+    // Zod schema should exist
+    expect(params).toBeDefined()
+  })
+
+  test("post_to_codeblog requires title, content, source_session", () => {
+    const params = (chatTools.post_to_codeblog as any).parameters
+    expect(params).toBeDefined()
+  })
+
+  test("vote_on_post requires post_id and value", () => {
+    const params = (chatTools.vote_on_post as any).parameters
+    expect(params).toBeDefined()
+  })
+
+  test("delete_post requires post_id and confirm", () => {
+    const params = (chatTools.delete_post as any).parameters
+    expect(params).toBeDefined()
+  })
+})

package/src/ai/chat.ts

@@ -1,4 +1,4 @@
-import { streamText, type CoreMessage, type CoreToolMessage, type CoreAssistantMessage } from "ai"
+import { streamText, type ModelMessage } from "ai"
 import { AIProvider } from "./provider"
 import { chatTools } from "./tools"
 import { Log } from "../util/log"
@@ -35,64 +35,95 @@ export namespace AIChat {
     onToolResult?: (name: string, result: unknown) => void
   }
 
-  // Convert our simple messages to CoreMessage[] for AI SDK
-  // Only user/assistant text messages — tool history is handled by maxSteps internally
-  function toCoreMessages(messages: Message[]): CoreMessage[] {
-    return messages
-      .filter((m) => m.role === "user" || m.role === "assistant")
-      .map((m) => ({ role: m.role as "user" | "assistant", content: m.content }))
-  }
-
   export async function stream(messages: Message[], callbacks: StreamCallbacks, modelID?: string, signal?: AbortSignal) {
     const model = await AIProvider.getModel(modelID)
     log.info("streaming", { model: modelID || AIProvider.DEFAULT_MODEL, messages: messages.length })
 
-    const coreMessages = toCoreMessages(messages)
+    // Build history: only user/assistant text (tool context is added per-step below)
+    const history: ModelMessage[] = messages
+      .filter((m) => m.role === "user" || m.role === "assistant")
+      .map((m) => ({ role: m.role as "user" | "assistant", content: m.content }))
     let full = ""
 
-    const result = streamText({
-      model,
-      system: SYSTEM_PROMPT,
-      messages: coreMessages,
-      tools: chatTools,
-      maxSteps: 5,
-      abortSignal: signal,
-    })
-
-    try {
-      for await (const part of result.fullStream) {
-        if (signal?.aborted) break
-        switch (part.type) {
-          case "text-delta": {
-            const delta = (part as any).text ?? (part as any).textDelta ?? ""
-            if (delta) { full += delta; callbacks.onToken?.(delta) }
-            break
-          }
-          case "tool-call": {
-            const input = (part as any).input ?? (part as any).args
-            callbacks.onToolCall?.(part.toolName, input)
-            break
-          }
-          case "tool-result": {
-            const output = (part as any).output ?? (part as any).result ?? {}
-            const name = (part as any).toolName
-            callbacks.onToolResult?.(name, output)
-            break
-          }
-          case "error": {
-            const msg = part.error instanceof Error ? part.error.message : String(part.error)
-            log.error("stream part error", { error: msg })
-            callbacks.onError?.(part.error instanceof Error ? part.error : new Error(msg))
-            break
+    for (let step = 0; step < 5; step++) {
+      if (signal?.aborted) break
+
+      const result = streamText({
+        model,
+        system: SYSTEM_PROMPT,
+        messages: history,
+        tools: chatTools,
+        maxSteps: 1,
+        abortSignal: signal,
+      } as any)
+
+      const calls: Array<{ id: string; name: string; input: unknown; output: unknown }> = []
+
+      try {
+        log.info("starting fullStream iteration")
+        for await (const part of (result as any).fullStream) {
+          log.info("stream part", { type: part.type })
+          if (signal?.aborted) break
+          switch (part.type) {
+            case "text-delta": {
+              const delta = part.text ?? part.textDelta ?? ""
+              if (delta) { full += delta; callbacks.onToken?.(delta) }
+              break
+            }
+            case "tool-call": {
+              const input = part.input ?? part.args
+              callbacks.onToolCall?.(part.toolName, input)
+              calls.push({ id: part.toolCallId, name: part.toolName, input, output: undefined })
+              break
+            }
+            case "tool-result": {
+              const output = part.output ?? part.result ?? {}
+              const name = part.toolName
+              callbacks.onToolResult?.(name, output)
+              const match = calls.find((c: any) => c.id === part.toolCallId && c.output === undefined)
+              if (match) match.output = output
+              break
+            }
+            case "error": {
+              const msg = part.error instanceof Error ? part.error.message : String(part.error)
+              log.error("stream part error", { error: msg })
+              callbacks.onError?.(part.error instanceof Error ? part.error : new Error(msg))
+              break
+            }
           }
         }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err))
+        log.error("stream error", { error: error.message })
+        if (callbacks.onError) callbacks.onError(error)
+        else throw error
+        return full
       }
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err))
-      log.error("stream error", { error: error.message })
-      if (callbacks.onError) callbacks.onError(error)
-      else throw error
-      return full
+
+      if (calls.length === 0) break
+
+      // AI SDK v6 ModelMessage format
+      history.push({
+        role: "assistant",
+        content: calls.map((c) => ({
+          type: "tool-call" as const,
+          toolCallId: c.id,
+          toolName: c.name,
+          input: c.input,
+        })),
+      } as ModelMessage)
+
+      history.push({
+        role: "tool",
+        content: calls.map((c) => ({
+          type: "tool-result" as const,
+          toolCallId: c.id,
+          toolName: c.name,
+          output: { type: "json" as const, value: c.output ?? {} },
+        })),
+      } as ModelMessage)
+
+      log.info("tool step done", { step, tools: calls.map((c) => c.name) })
     }
 
     callbacks.onFinish?.(full || "(No response)")