codeblog-app 2.1.2 → 2.1.4

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.1.2",
+  "version": "2.1.4",
   "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,75 @@
     "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": {
+    "@tsconfig/bun": "1.0.9",
+    "@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.1.2",
-    "codeblog-app-darwin-x64": "2.1.2",
-    "codeblog-app-linux-arm64": "2.1.2",
-    "codeblog-app-linux-x64": "2.1.2",
-    "codeblog-app-windows-x64": "2.1.2"
+    "codeblog-app-darwin-arm64": "2.1.4",
+    "codeblog-app-darwin-x64": "2.1.4",
+    "codeblog-app-linux-arm64": "2.1.4",
+    "codeblog-app-linux-x64": "2.1.4",
+    "codeblog-app-windows-x64": "2.1.4"
+  },
+  "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.1.2",
+    "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,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,54 @@
+import { describe, test, expect } from "bun:test"
+import { getChatTools, TOOL_LABELS, clearChatToolsCache } from "../tools"
+
+describe("AI Tools (dynamic MCP discovery)", () => {
+  // These tests require a running MCP server subprocess.
+  // getChatTools() connects to codeblog-mcp via stdio and calls listTools().
+
+  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).toBeGreaterThanOrEqual(20)
+  })
+
+  test("each tool has parameters and execute", () => {
+    for (const [name, t] of Object.entries(chatTools)) {
+      const tool = t as any
+      expect(tool.parameters).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)
+    }
+  })
+
+  // ---------------------------------------------------------------------------
+  // 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
+  })
+})

package/src/ai/chat.ts

@@ -0,0 +1,170 @@
+import { streamText, type ModelMessage } from "ai"
+import { AIProvider } from "./provider"
+import { getChatTools } from "./tools"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "ai-chat" })
+
+const SYSTEM_PROMPT = `You are CodeBlog AI — an assistant for the CodeBlog developer forum (codeblog.ai).
+
+You help developers with everything on the platform:
+- Scan and analyze their local IDE coding sessions
+- Write and publish blog posts from coding sessions
+- Browse, search, read, comment, vote on forum posts
+- Manage bookmarks, notifications, debates, tags, trending topics
+- Manage agents, view dashboard, follow users
+- Generate weekly digests
+
+You have 20+ tools. Use them whenever the user's request matches. Chain multiple tools if needed.
+After a tool returns results, summarize them naturally for the user.
+
+Write casually like a dev talking to another dev. Be specific, opinionated, and genuine.
+Use code examples when relevant. Think Juejin / HN / Linux.do vibes — not a conference paper.`
+
+export namespace AIChat {
+  export interface Message {
+    role: "user" | "assistant" | "system"
+    content: string
+  }
+
+  export interface StreamCallbacks {
+    onToken?: (token: string) => void
+    onFinish?: (text: string) => void
+    onError?: (error: Error) => void
+    onToolCall?: (name: string, args: unknown) => void
+    onToolResult?: (name: string, result: unknown) => void
+  }
+
+  export async function stream(messages: Message[], callbacks: StreamCallbacks, modelID?: string, signal?: AbortSignal) {
+    const model = await AIProvider.getModel(modelID)
+    const tools = await getChatTools()
+    log.info("streaming", { model: modelID || AIProvider.DEFAULT_MODEL, messages: messages.length })
+
+    // 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 = ""
+
+    for (let step = 0; step < 5; step++) {
+      if (signal?.aborted) break
+
+      const result = streamText({
+        model,
+        system: SYSTEM_PROMPT,
+        messages: history,
+        tools,
+        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
+      }
+
+      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)")
+    return full
+  }
+
+  export async function generate(prompt: string, modelID?: string) {
+    let result = ""
+    await stream([{ role: "user", content: prompt }], { onFinish: (text) => (result = text) }, modelID)
+    return result
+  }
+
+  export async function analyzeAndPost(sessionContent: string, modelID?: string) {
+    const prompt = `Analyze this coding session and write a blog post about it.
+
+The post should:
+- Have a catchy, dev-friendly title (like HN or Juejin)
+- Tell a story: what you were doing, what went wrong/right, what you learned
+- Include relevant code snippets
+- Be casual and genuine, written in first person
+- End with key takeaways
+
+Also provide:
+- 3-8 relevant tags (lowercase, hyphenated)
+- A one-line summary/hook
+
+Session content:
+${sessionContent.slice(0, 50000)}
+
+Respond in this exact JSON format:
+{
+  "title": "...",
+  "content": "... (markdown)",
+  "tags": ["tag1", "tag2"],
+  "summary": "..."
+}`
+
+    const raw = await generate(prompt, modelID)
+    const jsonMatch = raw.match(/\{[\s\S]*\}/)
+    if (!jsonMatch) throw new Error("AI did not return valid JSON")
+    return JSON.parse(jsonMatch[0])
+  }
+}