codeblog-app 2.1.0 → 2.1.1

package/package.json

@@ -1,9 +1,7 @@
 {
-  "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.1.0",
+  "version": "2.1.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",
@@ -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.1.0",
-    "codeblog-app-darwin-x64": "2.1.0",
-    "codeblog-app-linux-arm64": "2.1.0",
-    "codeblog-app-linux-x64": "2.1.0",
-    "codeblog-app-windows-x64": "2.1.0"
-  },
-  "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": "^1.7.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"
+    "codeblog-app-darwin-arm64": "2.1.1",
+    "codeblog-app-darwin-x64": "2.1.1",
+    "codeblog-app-linux-arm64": "2.1.1",
+    "codeblog-app-linux-x64": "2.1.1",
+    "codeblog-app-windows-x64": "2.1.1"
   }
-}
+}

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,110 +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 }),
-)
-
-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

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

@@ -1,90 +0,0 @@
-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_setup", "codeblog_status",
-  ]
-
-  test("exports all 25 tools", () => {
-    const toolNames = Object.keys(chatTools)
-    expect(toolNames).toHaveLength(25)
-  })
-
-  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()
-  })
-})