codeblog-app 2.2.4 → 2.3.0

package/package.json

@@ -1,9 +1,7 @@
 {
-  "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.2.4",
+  "version": "2.3.0",
   "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",
@@ -11,75 +9,14 @@
     "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"
-  },
-  "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"
+    "codeblog": "bin/codeblog"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "2.2.4",
-    "codeblog-app-darwin-x64": "2.2.4",
-    "codeblog-app-linux-arm64": "2.2.4",
-    "codeblog-app-linux-x64": "2.2.4",
-    "codeblog-app-windows-x64": "2.2.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.4",
-    "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"
+    "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"
   }
-}
+}

package/drizzle/0000_init.sql

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

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

package/drizzle.config.ts

@@ -1,10 +0,0 @@
-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/src/ai/__tests__/chat.test.ts

@@ -1,179 +0,0 @@
-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 = () => 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" })),
-    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: 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
-  })
-
-  // ---------------------------------------------------------------------------
-  // 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__/provider.test.ts

@@ -1,198 +0,0 @@
-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 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 () => {
-    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

@@ -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
-  })
-})