codeblog-app 2.3.0 → 2.3.1

package/drizzle/0000_init.sql

@@ -0,0 +1,34 @@
+CREATE TABLE IF NOT EXISTS `published_sessions` (
+  `id` text PRIMARY KEY NOT NULL,
+  `session_id` text NOT NULL,
+  `source` text NOT NULL,
+  `post_id` text NOT NULL,
+  `file_path` text NOT NULL,
+  `published_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS `cached_posts` (
+  `id` text PRIMARY KEY NOT NULL,
+  `title` text NOT NULL,
+  `content` text NOT NULL,
+  `summary` text,
+  `tags` text DEFAULT '[]' NOT NULL,
+  `upvotes` integer DEFAULT 0 NOT NULL,
+  `downvotes` integer DEFAULT 0 NOT NULL,
+  `author_name` text NOT NULL,
+  `fetched_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS `notifications_cache` (
+  `id` text PRIMARY KEY NOT NULL,
+  `type` text NOT NULL,
+  `message` text NOT NULL,
+  `read` integer DEFAULT 0 NOT NULL,
+  `post_id` text,
+  `created_at` integer DEFAULT (unixepoch()) NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS `idx_published_sessions_source` ON `published_sessions` (`source`);
+CREATE INDEX IF NOT EXISTS `idx_published_sessions_session_id` ON `published_sessions` (`session_id`);
+CREATE INDEX IF NOT EXISTS `idx_cached_posts_fetched_at` ON `cached_posts` (`fetched_at`);
+CREATE INDEX IF NOT EXISTS `idx_notifications_read` ON `notifications_cache` (`read`);

package/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "7",
+      "when": 1739520000000,
+      "tag": "0000_init",
+      "breakpoints": true
+    }
+  ]
+}

package/drizzle.config.ts

@@ -0,0 +1,10 @@
+import type { Config } from "drizzle-kit"
+
+export default {
+  schema: "./src/storage/schema.sql.ts",
+  out: "./drizzle",
+  dialect: "sqlite",
+  dbCredentials: {
+    url: process.env.DATABASE_URL || "~/.codeblog/data/codeblog.db",
+  },
+} satisfies Config

package/package.json

@@ -1,7 +1,9 @@
 {
+  "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
+  "type": "module",
   "license": "MIT",
   "author": "CodeBlog-ai",
   "homepage": "https://github.com/CodeBlog-ai/codeblog-app",
@@ -9,14 +11,77 @@
     "type": "git",
     "url": "https://github.com/CodeBlog-ai/codeblog-app"
   },
+  "bugs": {
+    "url": "https://github.com/CodeBlog-ai/codeblog-app/issues"
+  },
+  "keywords": [
+    "codeblog",
+    "cli",
+    "ai",
+    "coding",
+    "forum",
+    "ide",
+    "scanner",
+    "claude",
+    "cursor",
+    "windsurf",
+    "codex",
+    "copilot"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun test --timeout 30000",
+    "dev": "bun run --watch ./src/index.ts"
+  },
   "bin": {
-    "codeblog": "bin/codeblog"
+    "codeblog": "./bin/codeblog"
+  },
+  "files": [
+    "bin",
+    "src",
+    "drizzle",
+    "drizzle.config.ts",
+    "tsconfig.json",
+    "package.json",
+    "README.md"
+  ],
+  "exports": {
+    "./*": "./src/*.ts"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.28.4",
+    "@tsconfig/bun": "1.0.9",
+    "@types/babel__core": "^7.20.5",
+    "@types/bun": "1.3.9",
+    "@types/yargs": "17.0.33",
+    "drizzle-kit": "1.0.0-beta.12-a5629fb",
+    "typescript": "5.8.2"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "2.3.0",
-    "codeblog-app-darwin-x64": "2.3.0",
-    "codeblog-app-linux-arm64": "2.3.0",
-    "codeblog-app-linux-x64": "2.3.0",
-    "codeblog-app-windows-x64": "2.3.0"
+    "codeblog-app-darwin-arm64": "2.3.1",
+    "codeblog-app-darwin-x64": "2.3.1",
+    "codeblog-app-linux-arm64": "2.3.1",
+    "codeblog-app-linux-x64": "2.3.1",
+    "codeblog-app-windows-x64": "2.3.1"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.44",
+    "@ai-sdk/google": "^3.0.29",
+    "@ai-sdk/openai": "^3.0.29",
+    "@ai-sdk/openai-compatible": "^2.0.30",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@opentui/core": "^0.1.79",
+    "@opentui/solid": "^0.1.79",
+    "ai": "^6.0.86",
+    "codeblog-mcp": "2.2.0",
+    "drizzle-orm": "1.0.0-beta.12-a5629fb",
+    "fuzzysort": "^3.1.0",
+    "hono": "4.10.7",
+    "open": "10.1.2",
+    "remeda": "^2.33.6",
+    "solid-js": "^1.9.11",
+    "xdg-basedir": "5.1.0",
+    "yargs": "18.0.0",
+    "zod": "4.1.8"
   }
-}
+}

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

@@ -0,0 +1,188 @@
+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 }),
+)
+
+const mockListTools = mock(() =>
+  Promise.resolve({ tools: [] }),
+)
+
+mock.module("../../mcp/client", () => ({
+  McpBridge: {
+    callTool: mock((name: string, args: Record<string, unknown>) =>
+      Promise.resolve(JSON.stringify({ ok: true, tool: name })),
+    ),
+    callToolJSON: mockCallToolJSON,
+    listTools: mockListTools,
+    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" }
+    })(),
+  }
+}
+
+function makeToolCallStreamResult() {
+  return {
+    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 scanning." }
+    })(),
+  }
+}
+
+let streamFactory: () => { fullStream: AsyncGenerator<any, void, unknown> } = () => makeStreamResult()
+
+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(() => Promise.resolve({ id: "test-model" })),
+    resolveModelCompat: mock(() => Promise.resolve({
+      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("AIChat", () => {
+  beforeEach(() => {
+    mockCallToolJSON.mockClear()
+    streamFactory = () => makeStreamResult()
+  })
+
+  // ---------------------------------------------------------------------------
+  // Message interface
+  // ---------------------------------------------------------------------------
+
+  test("Message type accepts user, assistant, system roles", () => {
+    const messages = [
+      { 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
+  })
+
+  // ---------------------------------------------------------------------------
+  // stream() with tool calls
+  // ---------------------------------------------------------------------------
+
+  test("stream dispatches onToolCall and onToolResult callbacks", async () => {
+    streamFactory = () => makeToolCallStreamResult()
+
+    const toolCalls: Array<{ name: string; args: unknown }> = []
+    const toolResults: Array<{ name: string; result: unknown }> = []
+    const tokens: string[] = []
+
+    await AIChat.stream(
+      [{ role: "user", content: "scan my sessions" }],
+      {
+        onToken: (t) => tokens.push(t),
+        onToolCall: (name, args) => toolCalls.push({ name, args }),
+        onToolResult: (name, result) => toolResults.push({ name, result }),
+        onFinish: () => {},
+      },
+    )
+
+    expect(toolCalls).toEqual([{ name: "scan_sessions", args: { limit: 5 } }])
+    expect(toolResults).toEqual([{ name: "scan_sessions", result: { sessions: [] } }])
+    expect(tokens).toEqual(["Done scanning."])
+  })
+
+  // ---------------------------------------------------------------------------
+  // stream() error handling
+  // ---------------------------------------------------------------------------
+
+  test("stream calls onError when error event is received", async () => {
+    streamFactory = () => ({
+      fullStream: (async function* () {
+        yield { type: "error", error: new Error("test error") }
+      })(),
+    })
+
+    const errors: Error[] = []
+    await AIChat.stream(
+      [{ role: "user", content: "test" }],
+      {
+        onError: (err) => errors.push(err),
+        onFinish: () => {},
+      },
+    )
+
+    expect(errors).toHaveLength(1)
+    expect(errors[0]!.message).toBe("test error")
+  })
+
+  // ---------------------------------------------------------------------------
+  // 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__/compat.test.ts

@@ -0,0 +1,46 @@
+import { describe, test, expect } from "bun:test"
+import { patchRequestByCompat, resolveCompat } from "../types"
+
+describe("AI Compat", () => {
+  test("resolveCompat uses openai-compatible preset by default", () => {
+    const compat = resolveCompat({
+      providerID: "openai-compatible",
+      modelID: "deepseek-chat",
+    })
+    expect(compat.api).toBe("openai-compatible")
+    expect(compat.stripParallelToolCalls).toBe(true)
+    expect(compat.normalizeToolSchema).toBe(true)
+  })
+
+  test("resolveCompat honors provider config override", () => {
+    const compat = resolveCompat({
+      providerID: "openai-compatible",
+      modelID: "claude-sonnet-4-20250514",
+      providerConfig: { api_key: "x", api: "anthropic", compat_profile: "anthropic" },
+    })
+    expect(compat.api).toBe("anthropic")
+    expect(compat.compatProfile).toBe("anthropic")
+    expect(compat.stripParallelToolCalls).toBe(false)
+  })
+
+  test("patchRequestByCompat removes parallel_tool_calls and fixes schema", () => {
+    const compat = resolveCompat({
+      providerID: "openai-compatible",
+      modelID: "qwen3-coder",
+    })
+    const body = {
+      parallel_tool_calls: true,
+      tools: [
+        {
+          function: {
+            parameters: {},
+          },
+        },
+      ],
+    }
+    const patched = patchRequestByCompat(compat, body)
+    expect(patched.parallel_tool_calls).toBeUndefined()
+    expect(patched.tools[0]!.function.parameters.type).toBe("object")
+    expect(patched.tools[0]!.function.parameters.properties).toEqual({})
+  })
+})

package/src/ai/__tests__/home.ai-stream.integration.test.ts

@@ -0,0 +1,77 @@
+import { describe, test, expect, mock } from "bun:test"
+import { resolveAssistantContent } from "../../tui/ai-stream"
+
+const streamTextMock = mock(() => ({
+  fullStream: (async function* () {
+    yield { type: "tool-call", toolName: "scan_sessions", args: { limit: 1 } }
+    yield { type: "tool-result", toolName: "scan_sessions", result: { sessions: [{ id: "s1" }] } }
+  })(),
+}))
+
+mock.module("ai", () => ({
+  streamText: streamTextMock,
+  stepCountIs: (n: number) => ({ type: "step-count", count: n }),
+  tool: (config: any) => config,
+  jsonSchema: (schema: any) => schema,
+}))
+
+mock.module("../../mcp/client", () => ({
+  McpBridge: {
+    listTools: mock(async () => ({ tools: [] })),
+    callToolJSON: mock(async () => ({})),
+  },
+}))
+
+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("home ai stream integration (equivalent)", () => {
+  test("tool-only run stays single-stream and produces structured fallback content", async () => {
+    let finishText = ""
+    await AIChat.stream(
+      [{ role: "user", content: "scan now" }],
+      {
+        onFinish: (text) => { finishText = text },
+      },
+    )
+
+    expect(streamTextMock).toHaveBeenCalledTimes(1)
+    expect(finishText).toBe("(No response)")
+
+    const content = resolveAssistantContent({
+      finalText: "",
+      aborted: false,
+      abortByUser: false,
+      hasToolCalls: true,
+      toolResults: [{ name: "scan_sessions", result: "{\"sessions\":[{\"id\":\"s1\"}]}" }],
+    })
+    expect(content).toContain("Tool execution completed:")
+    expect(content).toContain("scan_sessions")
+  })
+
+  test("abort state is rendered consistently", () => {
+    const content = resolveAssistantContent({
+      finalText: "partial answer",
+      aborted: true,
+      abortByUser: true,
+      hasToolCalls: false,
+      toolResults: [],
+    })
+    expect(content).toContain("(interrupted)")
+  })
+})

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

@@ -0,0 +1,61 @@
+import { describe, test, expect, beforeEach } from "bun:test"
+import { routeModel } from "../provider-registry"
+
+describe("provider-registry", () => {
+  beforeEach(() => {
+    delete process.env.ANTHROPIC_API_KEY
+    delete process.env.OPENAI_API_KEY
+    delete process.env.GOOGLE_GENERATIVE_AI_API_KEY
+    delete process.env.OPENAI_COMPATIBLE_API_KEY
+  })
+
+  test("routes explicit provider/model first", async () => {
+    const route = await routeModel("openai/gpt-4o", {
+      api_url: "https://codeblog.ai",
+      providers: {
+        openai: { api_key: "sk-openai" },
+      },
+    })
+    expect(route.providerID).toBe("openai")
+    expect(route.modelID).toBe("gpt-4o")
+  })
+
+  test("routes by default_provider for unknown model", async () => {
+    const route = await routeModel("deepseek-chat", {
+      api_url: "https://codeblog.ai",
+      default_provider: "openai-compatible",
+      providers: {
+        "openai-compatible": {
+          api_key: "sk-compat",
+          base_url: "https://api.deepseek.com",
+          api: "openai-compatible",
+          compat_profile: "openai-compatible",
+        },
+      },
+    })
+    expect(route.providerID).toBe("openai-compatible")
+    expect(route.modelID).toBe("deepseek-chat")
+  })
+
+  test("unknown model throws deterministic actionable error", async () => {
+    await expect(routeModel("unknown-model-x", {
+      api_url: "https://codeblog.ai",
+      providers: {
+        openai: { api_key: "sk-openai" },
+      },
+    })).rejects.toThrow('Unknown model "unknown-model-x"')
+  })
+
+  test("multi-provider routing is deterministic by prefix", async () => {
+    const route = await routeModel("gpt-4o-mini", {
+      api_url: "https://codeblog.ai",
+      default_provider: "openai-compatible",
+      providers: {
+        openai: { api_key: "sk-openai" },
+        "openai-compatible": { api_key: "sk-compat", base_url: "https://api.deepseek.com" },
+      },
+    })
+    expect(route.providerID).toBe("openai")
+    expect(route.modelID).toBe("gpt-4o-mini")
+  })
+})