codeblog-app 1.5.1 → 1.6.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",
@@ -56,11 +56,11 @@
     "typescript": "5.8.2"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "1.5.1",
-    "codeblog-app-darwin-x64": "1.5.1",
-    "codeblog-app-linux-arm64": "1.5.1",
-    "codeblog-app-linux-x64": "1.5.1",
-    "codeblog-app-windows-x64": "1.5.1"
+    "codeblog-app-darwin-arm64": "1.5.2",
+    "codeblog-app-darwin-x64": "1.5.2",
+    "codeblog-app-linux-arm64": "1.5.2",
+    "codeblog-app-linux-x64": "1.5.2",
+    "codeblog-app-windows-x64": "1.5.2"
   },
   "dependencies": {
     "@ai-sdk/amazon-bedrock": "^4.0.60",

package/src/ai/chat.ts

@@ -1,9 +1,26 @@
 import { streamText, type CoreMessage } from "ai"
 import { AIProvider } from "./provider"
+import { chatTools } 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"
@@ -14,23 +31,12 @@ export namespace AIChat {
     onToken?: (token: string) => void
     onFinish?: (text: string) => void
     onError?: (error: Error) => void
+    onToolCall?: (name: string, args: unknown) => void
+    onToolResult?: (name: string, result: unknown) => void
   }
 
-  const SYSTEM_PROMPT = `You are CodeBlog AI — an assistant for the CodeBlog developer forum (codeblog.ai).
-
-You help developers:
-- Write engaging blog posts from their coding sessions
-- Analyze code and explain technical concepts
-- Draft comments and debate arguments
-- Summarize posts and discussions
-- Generate tags and titles for posts
-
-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 async function stream(messages: Message[], callbacks: StreamCallbacks, modelID?: string) {
+  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: CoreMessage[] = messages.map((m) => ({
@@ -42,15 +48,43 @@ Use code examples when relevant. Think Juejin / HN / Linux.do vibes — not a co
       model,
       system: SYSTEM_PROMPT,
       messages: coreMessages,
+      tools: chatTools,
+      maxSteps: 5,
+      abortSignal: signal,
     })
 
     let full = ""
     try {
-      for await (const chunk of result.textStream) {
-        full += chunk
-        callbacks.onToken?.(chunk)
+      for await (const part of result.fullStream) {
+        switch (part.type) {
+          case "text-delta": {
+            // AI SDK v6 uses .text, older versions use .textDelta
+            const delta = (part as any).text ?? (part as any).textDelta ?? ""
+            if (delta) {
+              full += delta
+              callbacks.onToken?.(delta)
+            }
+            break
+          }
+          case "tool-call":
+            callbacks.onToolCall?.(part.toolName, part.args)
+            break
+          case "tool-result":
+            callbacks.onToolResult?.((part as any).toolName, (part as any).result ?? {})
+            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
+          }
+        }
+      }
+      // If fullStream text-delta didn't capture text, try result.text as fallback
+      if (!full.trim()) {
+        try { full = await result.text } catch {}
       }
-      callbacks.onFinish?.(full)
+      callbacks.onFinish?.(full || "(No response)")
     } catch (err) {
       const error = err instanceof Error ? err : new Error(String(err))
       log.error("stream error", { error: error.message })
@@ -63,13 +97,13 @@ Use code examples when relevant. Think Juejin / HN / Linux.do vibes — not a co
     return full
   }
 
-  export async function generate(prompt: string, modelID?: string): Promise<string> {
+  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): Promise<{ title: string; content: string; tags: string[]; summary: string }> {
+  export async function analyzeAndPost(sessionContent: string, modelID?: string) {
     const prompt = `Analyze this coding session and write a blog post about it.
 
 The post should:

package/src/ai/configure.ts

@@ -0,0 +1,89 @@
+// AI provider auto-detection and configuration
+
+function looksLikeApi(r: Response) {
+  const ct = r.headers.get("content-type") || ""
+  return ct.includes("json") || ct.includes("text/plain")
+}
+
+export async function probe(base: string, key: string): Promise<"openai" | "anthropic" | null> {
+  const clean = base.replace(/\/+$/, "")
+  try {
+    const r = await fetch(`${clean}/v1/models`, {
+      headers: { Authorization: `Bearer ${key}` },
+      signal: AbortSignal.timeout(8000),
+    })
+    if (r.ok || ((r.status === 401 || r.status === 403) && looksLikeApi(r))) return "openai"
+  } catch {}
+  try {
+    const r = await fetch(`${clean}/v1/messages`, {
+      method: "POST",
+      headers: { "x-api-key": key, "anthropic-version": "2023-06-01", "content-type": "application/json" },
+      body: JSON.stringify({ model: "test", max_tokens: 1, messages: [] }),
+      signal: AbortSignal.timeout(8000),
+    })
+    if (r.status !== 404 && looksLikeApi(r)) return "anthropic"
+  } catch {}
+  return null
+}
+
+const KEY_PREFIX_MAP: Record<string, string> = {
+  "sk-ant-": "anthropic",
+  "AIza": "google",
+  "xai-": "xai",
+  "gsk_": "groq",
+  "sk-or-": "openrouter",
+  "pplx-": "perplexity",
+}
+
+const ENV_MAP: Record<string, string> = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_GENERATIVE_AI_API_KEY",
+  xai: "XAI_API_KEY",
+  groq: "GROQ_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  perplexity: "PERPLEXITY_API_KEY",
+  "openai-compatible": "OPENAI_COMPATIBLE_API_KEY",
+}
+
+export function detectProvider(key: string) {
+  for (const [prefix, provider] of Object.entries(KEY_PREFIX_MAP)) {
+    if (key.startsWith(prefix)) return provider
+  }
+  return "openai"
+}
+
+export async function saveProvider(url: string, key: string): Promise<{ provider: string; error?: string }> {
+  const { Config } = await import("../config")
+
+  if (url) {
+    const detected = await probe(url, key)
+    if (!detected) return { provider: "", error: "Could not connect. Check URL and key." }
+
+    const provider = detected === "anthropic" ? "anthropic" : "openai-compatible"
+    const envKey = detected === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_COMPATIBLE_API_KEY"
+    const envBase = detected === "anthropic" ? "ANTHROPIC_BASE_URL" : "OPENAI_COMPATIBLE_BASE_URL"
+    process.env[envKey] = key
+    process.env[envBase] = url
+
+    const cfg = await Config.load()
+    const providers = cfg.providers || {}
+    providers[provider] = { api_key: key, base_url: url }
+    await Config.save({ providers })
+    return { provider: `${detected} format` }
+  }
+
+  const provider = detectProvider(key)
+  if (ENV_MAP[provider]) process.env[ENV_MAP[provider]] = key
+
+  const cfg = await Config.load()
+  const providers = cfg.providers || {}
+  providers[provider] = { api_key: key }
+  await Config.save({ providers })
+  return { provider }
+}
+
+export function mask(s: string) {
+  if (s.length <= 8) return s
+  return s.slice(0, 4) + "\u2022".repeat(Math.min(s.length - 8, 20)) + s.slice(-4)
+}

package/src/ai/provider.ts

@@ -173,14 +173,6 @@ export namespace AIProvider {
     return {}
   }
 
-  // Refresh models.dev in background (lazy, only on first use)
-  let modelsDevInitialized = false
-  function ensureModelsDev() {
-    if (modelsDevInitialized) return
-    modelsDevInitialized = true
-    fetchModelsDev().catch(() => {})
-  }
-
   // ---------------------------------------------------------------------------
   // Get API key for a provider
   // ---------------------------------------------------------------------------
@@ -255,13 +247,13 @@ export namespace AIProvider {
       return getLanguageModel(builtin.providerID, id, apiKey, undefined, base)
     }
 
-    // Try models.dev
+    // Try models.dev (only if the user has a key for that provider)
     const modelsDev = await fetchModelsDev()
     for (const [providerID, provider] of Object.entries(modelsDev)) {
       const p = provider as any
       if (p.models?.[id]) {
         const apiKey = await getApiKey(providerID)
-        if (!apiKey) throw noKeyError(providerID)
+        if (!apiKey) continue
         const npm = p.models[id].provider?.npm || p.npm || "@ai-sdk/openai-compatible"
         const base = await getBaseUrl(providerID)
         return getLanguageModel(providerID, id, apiKey, npm, base || p.api)
@@ -278,6 +270,19 @@ export namespace AIProvider {
       return getLanguageModel(providerID, mid, apiKey, undefined, base)
     }
 
+    // Fallback: try any configured provider that has a base_url (custom/openai-compatible)
+    const cfg = await Config.load()
+    if (cfg.providers) {
+      for (const [providerID, p] of Object.entries(cfg.providers)) {
+        if (!p.api_key) continue
+        const base = p.base_url || (await getBaseUrl(providerID))
+        if (base) {
+          log.info("fallback: sending unknown model to provider with base_url", { provider: providerID, model: id })
+          return getLanguageModel(providerID, id, p.api_key, undefined, base)
+        }
+      }
+    }
+
     throw new Error(`Unknown model: ${id}. Run: codeblog config --list`)
   }
 
@@ -291,8 +296,12 @@ export namespace AIProvider {
     if (!sdk) {
       const createFn = BUNDLED_PROVIDERS[pkg]
       if (!createFn) throw new Error(`No bundled provider for ${pkg}. Provider ${providerID} not supported.`)
-      const opts: Record<string, unknown> = { apiKey }
-      if (baseURL) opts.baseURL = baseURL
+      const opts: Record<string, unknown> = { apiKey, name: providerID }
+      if (baseURL) {
+        // @ai-sdk/openai-compatible expects baseURL to include /v1
+        const clean = baseURL.replace(/\/+$/, "")
+        opts.baseURL = clean.endsWith("/v1") ? clean : `${clean}/v1`
+      }
       if (providerID === "openrouter") {
         opts.headers = { "HTTP-Referer": "https://codeblog.ai/", "X-Title": "codeblog" }
       }
@@ -339,15 +348,109 @@ export namespace AIProvider {
     return false
   }
 
+  // ---------------------------------------------------------------------------
+  // Fetch models dynamically from a provider's /v1/models endpoint
+  // ---------------------------------------------------------------------------
+  export async function fetchModels(providerID: string): Promise<ModelInfo[]> {
+    const apiKey = await getApiKey(providerID)
+    if (!apiKey) return []
+    const base = await getBaseUrl(providerID)
+    if (!base) {
+      // For known providers without custom base URL, use models.dev
+      const modelsDev = await fetchModelsDev()
+      const p = modelsDev[providerID] as any
+      if (p?.models) {
+        return Object.entries(p.models).map(([id, m]: [string, any]) => ({
+          id,
+          providerID,
+          name: m.name || id,
+          contextWindow: m.limit?.context || 0,
+          outputTokens: m.limit?.output || 0,
+        }))
+      }
+      return []
+    }
+    // Try OpenAI-compatible /v1/models
+    try {
+      const url = `${base.replace(/\/+$/, "").replace(/\/v1$/, "")}/v1/models`
+      const r = await fetch(url, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(10000),
+      })
+      if (!r.ok) return []
+      const json = await r.json() as any
+      const models = json.data || json.models || []
+      return models.map((m: any) => ({
+        id: m.id || m.name || "",
+        providerID,
+        name: m.id || m.name || "",
+        contextWindow: m.context_length || m.context_window || 0,
+        outputTokens: m.max_output_tokens || m.max_tokens || 0,
+      })).filter((m: ModelInfo) => m.id)
+    } catch {
+      return []
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Fetch models for all configured providers
+  // ---------------------------------------------------------------------------
+  export async function fetchAllModels(): Promise<ModelInfo[]> {
+    const cfg = await Config.load()
+    const seen = new Set<string>()
+    const result: ModelInfo[] = []
+
+    // Collect configured provider IDs (check env vars + config in one pass)
+    const ids = new Set<string>()
+    for (const [providerID, envKeys] of Object.entries(PROVIDER_ENV)) {
+      if (envKeys.some((k) => process.env[k])) ids.add(providerID)
+      else if (cfg.providers?.[providerID]?.api_key) ids.add(providerID)
+    }
+    if (cfg.providers) {
+      for (const providerID of Object.keys(cfg.providers)) {
+        if (cfg.providers[providerID].api_key) ids.add(providerID)
+      }
+    }
+
+    const settled = await Promise.allSettled([...ids].map((id) => fetchModels(id)))
+    for (const entry of settled) {
+      if (entry.status !== "fulfilled") continue
+      for (const m of entry.value) {
+        const key = `${m.providerID}/${m.id}`
+        if (seen.has(key)) continue
+        seen.add(key)
+        result.push(m)
+      }
+    }
+
+    return result
+  }
+
   // ---------------------------------------------------------------------------
   // List available models with key status (for codeblog config --list)
   // ---------------------------------------------------------------------------
   export async function available(): Promise<Array<{ model: ModelInfo; hasKey: boolean }>> {
     const result: Array<{ model: ModelInfo; hasKey: boolean }> = []
+    const seen = new Set<string>()
+
+    // Dynamic models from configured providers (always have keys)
+    const dynamic = await fetchAllModels()
+    for (const model of dynamic) {
+      const key = `${model.providerID}/${model.id}`
+      if (seen.has(key)) continue
+      seen.add(key)
+      result.push({ model, hasKey: true })
+    }
+
+    // Merge builtin models (may or may not have keys)
     for (const model of Object.values(BUILTIN_MODELS)) {
-      const key = await getApiKey(model.providerID)
-      result.push({ model, hasKey: !!key })
+      const key = `${model.providerID}/${model.id}`
+      if (seen.has(key)) continue
+      seen.add(key)
+      const apiKey = await getApiKey(model.providerID)
+      result.push({ model, hasKey: !!apiKey })
     }
+
     return result
   }