codeblog-app 2.0.1 → 2.0.2

package/src/ai/chat.ts

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

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

@@ -1,238 +0,0 @@
-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("/") }
-  }
-}