codeblog-app 2.0.2 → 2.1.0

package/src/ai/chat.ts

@@ -0,0 +1,169 @@
+import { streamText, type ModelMessage } 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"
+    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)
+    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: chatTools,
+        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])
+  }
+}

package/src/ai/configure.ts

@@ -0,0 +1,134 @@
+// 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",
+}
+
+async function fetchFirstModel(base: string, key: string): Promise<string | null> {
+  try {
+    const clean = base.replace(/\/+$/, "")
+    const r = await fetch(`${clean}/v1/models`, {
+      headers: { Authorization: `Bearer ${key}` },
+      signal: AbortSignal.timeout(8000),
+    })
+    if (!r.ok) return null
+    const data = await r.json() as { data?: Array<{ id: string }> }
+    if (!data.data || data.data.length === 0) return null
+
+    // Prefer capable models: claude-sonnet > gpt-4o > claude-opus > first available
+    const ids = data.data.map((m) => m.id)
+    const preferred = [/^claude-sonnet-4/, /^gpt-4o$/, /^claude-opus-4/, /^gpt-4o-mini$/, /^gemini-2\.5-flash$/]
+    for (const pattern of preferred) {
+      const match = ids.find((id) => pattern.test(id))
+      if (match) return match
+    }
+    return ids[0] ?? null
+  } catch {}
+  return null
+}
+
+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 }
+
+    // Auto-set model if not already configured
+    const update: Record<string, unknown> = { providers }
+    if (!cfg.model) {
+      if (detected === "anthropic") {
+        update.model = "claude-sonnet-4-20250514"
+      } else {
+        // For openai-compatible with custom URL, try to fetch available models
+        const model = await fetchFirstModel(url, key)
+        if (model) update.model = `openai-compatible/${model}`
+      }
+    }
+
+    await Config.save(update)
+    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 }
+
+  // Auto-set model for known providers
+  const update: Record<string, unknown> = { providers }
+  if (!cfg.model) {
+    const { AIProvider } = await import("./provider")
+    const models = Object.values(AIProvider.BUILTIN_MODELS).filter((m) => m.providerID === provider)
+    if (models.length > 0) update.model = models[0]!.id
+  }
+
+  await Config.save(update)
+  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

@@ -0,0 +1,238 @@
+import { createAnthropic } from "@ai-sdk/anthropic"
+import { createOpenAI } from "@ai-sdk/openai"
+import { createGoogleGenerativeAI } from "@ai-sdk/google"
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
+import { type LanguageModel, type Provider as SDK } from "ai"
+import { Config } from "../config"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "ai-provider" })
+
+export namespace AIProvider {
+  // ---------------------------------------------------------------------------
+  // Bundled providers (4 core)
+  // ---------------------------------------------------------------------------
+  const BUNDLED_PROVIDERS: Record<string, (options: any) => SDK> = {
+    "@ai-sdk/anthropic": createAnthropic as any,
+    "@ai-sdk/openai": createOpenAI as any,
+    "@ai-sdk/google": createGoogleGenerativeAI as any,
+    "@ai-sdk/openai-compatible": createOpenAICompatible as any,
+  }
+
+  // ---------------------------------------------------------------------------
+  // Provider env key mapping
+  // ---------------------------------------------------------------------------
+  const PROVIDER_ENV: Record<string, string[]> = {
+    anthropic: ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"],
+    openai: ["OPENAI_API_KEY"],
+    google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY"],
+    "openai-compatible": ["OPENAI_COMPATIBLE_API_KEY"],
+  }
+
+  // ---------------------------------------------------------------------------
+  // Provider base URL env mapping
+  // ---------------------------------------------------------------------------
+  const PROVIDER_BASE_URL_ENV: Record<string, string[]> = {
+    anthropic: ["ANTHROPIC_BASE_URL"],
+    openai: ["OPENAI_BASE_URL", "OPENAI_API_BASE"],
+    google: ["GOOGLE_API_BASE_URL"],
+    "openai-compatible": ["OPENAI_COMPATIBLE_BASE_URL"],
+  }
+
+  // ---------------------------------------------------------------------------
+  // Provider → npm package mapping
+  // ---------------------------------------------------------------------------
+  const PROVIDER_NPM: Record<string, string> = {
+    anthropic: "@ai-sdk/anthropic",
+    openai: "@ai-sdk/openai",
+    google: "@ai-sdk/google",
+    "openai-compatible": "@ai-sdk/openai-compatible",
+  }
+
+  // ---------------------------------------------------------------------------
+  // Model info type
+  // ---------------------------------------------------------------------------
+  export interface ModelInfo {
+    id: string
+    providerID: string
+    name: string
+    contextWindow: number
+    outputTokens: number
+  }
+
+  // ---------------------------------------------------------------------------
+  // Built-in model list
+  // ---------------------------------------------------------------------------
+  export const BUILTIN_MODELS: Record<string, ModelInfo> = {
+    "claude-sonnet-4-20250514": { id: "claude-sonnet-4-20250514", providerID: "anthropic", name: "Claude Sonnet 4", contextWindow: 200000, outputTokens: 16384 },
+    "claude-3-5-haiku-20241022": { id: "claude-3-5-haiku-20241022", providerID: "anthropic", name: "Claude 3.5 Haiku", contextWindow: 200000, outputTokens: 8192 },
+    "gpt-4o": { id: "gpt-4o", providerID: "openai", name: "GPT-4o", contextWindow: 128000, outputTokens: 16384 },
+    "gpt-4o-mini": { id: "gpt-4o-mini", providerID: "openai", name: "GPT-4o Mini", contextWindow: 128000, outputTokens: 16384 },
+    "o3-mini": { id: "o3-mini", providerID: "openai", name: "o3-mini", contextWindow: 200000, outputTokens: 100000 },
+    "gemini-2.5-flash": { id: "gemini-2.5-flash", providerID: "google", name: "Gemini 2.5 Flash", contextWindow: 1048576, outputTokens: 65536 },
+    "gemini-2.5-pro": { id: "gemini-2.5-pro", providerID: "google", name: "Gemini 2.5 Pro", contextWindow: 1048576, outputTokens: 65536 },
+  }
+
+  export const DEFAULT_MODEL = "claude-sonnet-4-20250514"
+
+  // ---------------------------------------------------------------------------
+  // Get API key for a provider
+  // ---------------------------------------------------------------------------
+  export async function getApiKey(providerID: string): Promise<string | undefined> {
+    const envKeys = PROVIDER_ENV[providerID] || []
+    for (const key of envKeys) {
+      if (process.env[key]) return process.env[key]
+    }
+    const cfg = await Config.load()
+    return cfg.providers?.[providerID]?.api_key
+  }
+
+  // ---------------------------------------------------------------------------
+  // Get base URL for a provider
+  // ---------------------------------------------------------------------------
+  export async function getBaseUrl(providerID: string): Promise<string | undefined> {
+    const envKeys = PROVIDER_BASE_URL_ENV[providerID] || []
+    for (const key of envKeys) {
+      if (process.env[key]) return process.env[key]
+    }
+    const cfg = await Config.load()
+    return cfg.providers?.[providerID]?.base_url
+  }
+
+  // ---------------------------------------------------------------------------
+  // List all available providers
+  // ---------------------------------------------------------------------------
+  export async function listProviders(): Promise<Record<string, { name: string; models: string[]; hasKey: boolean }>> {
+    const result: Record<string, { name: string; models: string[]; hasKey: boolean }> = {}
+    for (const model of Object.values(BUILTIN_MODELS)) {
+      if (!result[model.providerID]) {
+        const key = await getApiKey(model.providerID)
+        result[model.providerID] = { name: model.providerID, models: [], hasKey: !!key }
+      }
+      if (!result[model.providerID]!.models.includes(model.id)) {
+        result[model.providerID]!.models.push(model.id)
+      }
+    }
+    const compatKey = await getApiKey("openai-compatible")
+    if (compatKey) {
+      result["openai-compatible"] = { name: "OpenAI Compatible", models: [], hasKey: true }
+    }
+    return result
+  }
+
+  // ---------------------------------------------------------------------------
+  // Get a LanguageModel instance
+  // ---------------------------------------------------------------------------
+  const sdkCache = new Map<string, SDK>()
+
+  export async function getModel(modelID?: string): Promise<LanguageModel> {
+    const id = modelID || (await getConfiguredModel()) || DEFAULT_MODEL
+
+    const builtin = BUILTIN_MODELS[id]
+    if (builtin) {
+      const apiKey = await getApiKey(builtin.providerID)
+      if (!apiKey) throw noKeyError(builtin.providerID)
+      const base = await getBaseUrl(builtin.providerID)
+      return getLanguageModel(builtin.providerID, id, apiKey, undefined, base)
+    }
+
+    if (id.includes("/")) {
+      const [providerID, ...rest] = id.split("/")
+      const mid = rest.join("/")
+      const apiKey = await getApiKey(providerID!)
+      if (!apiKey) throw noKeyError(providerID!)
+      const base = await getBaseUrl(providerID!)
+      return getLanguageModel(providerID!, mid, apiKey, undefined, base)
+    }
+
+    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`)
+  }
+
+  function getLanguageModel(providerID: string, modelID: string, apiKey: string, npm?: string, baseURL?: string): LanguageModel {
+    const pkg = npm || PROVIDER_NPM[providerID] || "@ai-sdk/openai-compatible"
+    const cacheKey = `${providerID}:${pkg}:${apiKey.slice(0, 8)}`
+
+    log.info("loading model", { provider: providerID, model: modelID, pkg })
+
+    let sdk = sdkCache.get(cacheKey)
+    if (!sdk) {
+      const createFn = BUNDLED_PROVIDERS[pkg]
+      if (!createFn) throw new Error(`No bundled provider for ${pkg}. Use openai-compatible with a base URL instead.`)
+      const opts: Record<string, unknown> = { apiKey, name: providerID }
+      if (baseURL) {
+        const clean = baseURL.replace(/\/+$/, "")
+        opts.baseURL = clean.endsWith("/v1") ? clean : `${clean}/v1`
+      }
+      sdk = createFn(opts)
+      sdkCache.set(cacheKey, sdk)
+    }
+
+    if (pkg === "@ai-sdk/openai-compatible" && typeof (sdk as any).chatModel === "function") {
+      return (sdk as any).chatModel(modelID)
+    }
+    if (typeof (sdk as any).languageModel === "function") {
+      return (sdk as any).languageModel(modelID)
+    }
+    return (sdk as any)(modelID)
+  }
+
+  function noKeyError(providerID: string): Error {
+    const envKeys = PROVIDER_ENV[providerID] || []
+    const envHint = envKeys[0] || `${providerID.toUpperCase().replace(/-/g, "_")}_API_KEY`
+    return new Error(`No API key for ${providerID}. Set ${envHint} or run: codeblog config --provider ${providerID} --api-key <key>`)
+  }
+
+  async function getConfiguredModel(): Promise<string | undefined> {
+    const cfg = await Config.load()
+    return cfg.model
+  }
+
+  // ---------------------------------------------------------------------------
+  // Check if any AI provider has a key configured
+  // ---------------------------------------------------------------------------
+  export async function hasAnyKey(): Promise<boolean> {
+    for (const providerID of Object.keys(PROVIDER_ENV)) {
+      const key = await getApiKey(providerID)
+      if (key) return true
+    }
+    const cfg = await Config.load()
+    if (cfg.providers) {
+      for (const p of Object.values(cfg.providers)) {
+        if (p.api_key) return true
+      }
+    }
+    return false
+  }
+
+  // ---------------------------------------------------------------------------
+  // List available models with key status
+  // ---------------------------------------------------------------------------
+  export async function available(): Promise<Array<{ model: ModelInfo; hasKey: boolean }>> {
+    const result: Array<{ model: ModelInfo; hasKey: boolean }> = []
+    for (const model of Object.values(BUILTIN_MODELS)) {
+      const apiKey = await getApiKey(model.providerID)
+      result.push({ model, hasKey: !!apiKey })
+    }
+    return result
+  }
+
+  // ---------------------------------------------------------------------------
+  // Parse provider/model format
+  // ---------------------------------------------------------------------------
+  export function parseModel(model: string) {
+    const [providerID, ...rest] = model.split("/")
+    return { providerID, modelID: rest.join("/") }
+  }
+}