codeblog-app 0.2.0 → 0.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",
@@ -56,9 +56,35 @@
     "typescript": "5.8.2"
   },
   "dependencies": {
+    "@ai-sdk/amazon-bedrock": "^4.0.60",
+    "@ai-sdk/anthropic": "^3.0.44",
+    "@ai-sdk/azure": "^3.0.30",
+    "@ai-sdk/cerebras": "^2.0.33",
+    "@ai-sdk/cohere": "^3.0.21",
+    "@ai-sdk/deepinfra": "^2.0.34",
+    "@ai-sdk/gateway": "^3.0.46",
+    "@ai-sdk/google": "^3.0.29",
+    "@ai-sdk/google-vertex": "^4.0.58",
+    "@ai-sdk/groq": "^3.0.24",
+    "@ai-sdk/mistral": "^3.0.20",
+    "@ai-sdk/openai": "^3.0.29",
+    "@ai-sdk/openai-compatible": "^2.0.30",
+    "@ai-sdk/perplexity": "^3.0.19",
+    "@ai-sdk/togetherai": "^2.0.33",
+    "@ai-sdk/vercel": "^2.0.32",
+    "@ai-sdk/xai": "^3.0.56",
+    "@openrouter/ai-sdk-provider": "^2.2.3",
+    "@opentui/core": "^0.1.79",
+    "@opentui/solid": "^0.1.79",
+    "ai": "^6.0.86",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
+    "fuzzysort": "^3.1.0",
     "hono": "4.10.7",
+    "ink": "^6.7.0",
     "open": "10.1.2",
+    "react": "^19.2.4",
+    "remeda": "^2.33.6",
+    "solid-js": "^1.9.11",
     "xdg-basedir": "5.1.0",
     "yargs": "18.0.0",
     "zod": "4.1.8"

package/src/ai/chat.ts

@@ -0,0 +1,92 @@
+import { streamText, type CoreMessage } from "ai"
+import { AIProvider } from "./provider"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "ai-chat" })
+
+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
+  }
+
+  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) {
+    const model = await AIProvider.getModel(modelID)
+
+    log.info("streaming", { model: modelID || AIProvider.DEFAULT_MODEL, messages: messages.length })
+
+    const coreMessages: CoreMessage[] = messages.map((m) => ({
+      role: m.role,
+      content: m.content,
+    }))
+
+    const result = streamText({
+      model,
+      system: SYSTEM_PROMPT,
+      messages: coreMessages,
+    })
+
+    let full = ""
+    for await (const chunk of result.textStream) {
+      full += chunk
+      callbacks.onToken?.(chunk)
+    }
+    callbacks.onFinish?.(full)
+    return full
+  }
+
+  export async function generate(prompt: string, modelID?: string): Promise<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 }> {
+    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/provider.ts

@@ -0,0 +1,311 @@
+import { createAnthropic } from "@ai-sdk/anthropic"
+import { createOpenAI } from "@ai-sdk/openai"
+import { createGoogleGenerativeAI } from "@ai-sdk/google"
+import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock"
+import { createAzure } from "@ai-sdk/azure"
+import { createGoogleGenerativeAI as createVertex } from "@ai-sdk/google"
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
+import { createOpenRouter } from "@openrouter/ai-sdk-provider"
+import { createXai } from "@ai-sdk/xai"
+import { createMistral } from "@ai-sdk/mistral"
+import { createGroq } from "@ai-sdk/groq"
+import { createDeepInfra } from "@ai-sdk/deepinfra"
+import { createCerebras } from "@ai-sdk/cerebras"
+import { createCohere } from "@ai-sdk/cohere"
+import { createGateway } from "@ai-sdk/gateway"
+import { createTogetherAI } from "@ai-sdk/togetherai"
+import { createPerplexity } from "@ai-sdk/perplexity"
+import { createVercel } from "@ai-sdk/vercel"
+import { type LanguageModel, type Provider as SDK } from "ai"
+import { Config } from "../config"
+import { Log } from "../util/log"
+import { Global } from "../global"
+import path from "path"
+
+const log = Log.create({ service: "ai-provider" })
+
+export namespace AIProvider {
+  // ---------------------------------------------------------------------------
+  // Bundled providers — same mapping as opencode
+  // ---------------------------------------------------------------------------
+  const BUNDLED_PROVIDERS: Record<string, (options: any) => SDK> = {
+    "@ai-sdk/amazon-bedrock": createAmazonBedrock,
+    "@ai-sdk/anthropic": createAnthropic,
+    "@ai-sdk/azure": createAzure,
+    "@ai-sdk/google": createGoogleGenerativeAI,
+    "@ai-sdk/google-vertex": createVertex as any,
+    "@ai-sdk/openai": createOpenAI,
+    "@ai-sdk/openai-compatible": createOpenAICompatible,
+    "@openrouter/ai-sdk-provider": createOpenRouter as any,
+    "@ai-sdk/xai": createXai,
+    "@ai-sdk/mistral": createMistral,
+    "@ai-sdk/groq": createGroq,
+    "@ai-sdk/deepinfra": createDeepInfra,
+    "@ai-sdk/cerebras": createCerebras,
+    "@ai-sdk/cohere": createCohere,
+    "@ai-sdk/gateway": createGateway,
+    "@ai-sdk/togetherai": createTogetherAI,
+    "@ai-sdk/perplexity": createPerplexity,
+    "@ai-sdk/vercel": createVercel,
+  }
+
+  // ---------------------------------------------------------------------------
+  // Provider env key mapping
+  // ---------------------------------------------------------------------------
+  const PROVIDER_ENV: Record<string, string[]> = {
+    anthropic: ["ANTHROPIC_API_KEY"],
+    openai: ["OPENAI_API_KEY"],
+    google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY"],
+    "amazon-bedrock": ["AWS_ACCESS_KEY_ID"],
+    azure: ["AZURE_API_KEY", "AZURE_OPENAI_API_KEY"],
+    xai: ["XAI_API_KEY"],
+    mistral: ["MISTRAL_API_KEY"],
+    groq: ["GROQ_API_KEY"],
+    deepinfra: ["DEEPINFRA_API_KEY"],
+    cerebras: ["CEREBRAS_API_KEY"],
+    cohere: ["COHERE_API_KEY"],
+    togetherai: ["TOGETHER_AI_API_KEY", "TOGETHERAI_API_KEY"],
+    perplexity: ["PERPLEXITY_API_KEY"],
+    openrouter: ["OPENROUTER_API_KEY"],
+    "openai-compatible": ["OPENAI_COMPATIBLE_API_KEY"],
+  }
+
+  // ---------------------------------------------------------------------------
+  // Provider → npm package mapping
+  // ---------------------------------------------------------------------------
+  const PROVIDER_NPM: Record<string, string> = {
+    anthropic: "@ai-sdk/anthropic",
+    openai: "@ai-sdk/openai",
+    google: "@ai-sdk/google",
+    "amazon-bedrock": "@ai-sdk/amazon-bedrock",
+    azure: "@ai-sdk/azure",
+    "google-vertex": "@ai-sdk/google-vertex",
+    xai: "@ai-sdk/xai",
+    mistral: "@ai-sdk/mistral",
+    groq: "@ai-sdk/groq",
+    deepinfra: "@ai-sdk/deepinfra",
+    cerebras: "@ai-sdk/cerebras",
+    cohere: "@ai-sdk/cohere",
+    gateway: "@ai-sdk/gateway",
+    togetherai: "@ai-sdk/togetherai",
+    perplexity: "@ai-sdk/perplexity",
+    vercel: "@ai-sdk/vercel",
+    openrouter: "@openrouter/ai-sdk-provider",
+    "openai-compatible": "@ai-sdk/openai-compatible",
+  }
+
+  // ---------------------------------------------------------------------------
+  // Model info type
+  // ---------------------------------------------------------------------------
+  export interface ModelInfo {
+    id: string
+    providerID: string
+    name: string
+    contextWindow: number
+    outputTokens: number
+    npm?: string
+  }
+
+  // ---------------------------------------------------------------------------
+  // Built-in model list (fallback when models.dev is unavailable)
+  // ---------------------------------------------------------------------------
+  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 },
+    "grok-3": { id: "grok-3", providerID: "xai", name: "Grok 3", contextWindow: 131072, outputTokens: 16384 },
+    "grok-3-mini": { id: "grok-3-mini", providerID: "xai", name: "Grok 3 Mini", contextWindow: 131072, outputTokens: 16384 },
+    "mistral-large-latest": { id: "mistral-large-latest", providerID: "mistral", name: "Mistral Large", contextWindow: 128000, outputTokens: 8192 },
+    "codestral-latest": { id: "codestral-latest", providerID: "mistral", name: "Codestral", contextWindow: 256000, outputTokens: 8192 },
+    "llama-3.3-70b-versatile": { id: "llama-3.3-70b-versatile", providerID: "groq", name: "Llama 3.3 70B (Groq)", contextWindow: 128000, outputTokens: 32768 },
+    "deepseek-chat": { id: "deepseek-chat", providerID: "deepinfra", name: "DeepSeek V3", contextWindow: 64000, outputTokens: 8192 },
+    "command-a-03-2025": { id: "command-a-03-2025", providerID: "cohere", name: "Command A", contextWindow: 256000, outputTokens: 16384 },
+    "sonar-pro": { id: "sonar-pro", providerID: "perplexity", name: "Sonar Pro", contextWindow: 200000, outputTokens: 8192 },
+  }
+
+  export const DEFAULT_MODEL = "claude-sonnet-4-20250514"
+
+  // ---------------------------------------------------------------------------
+  // models.dev dynamic loading (same as opencode)
+  // ---------------------------------------------------------------------------
+  let modelsDevCache: Record<string, any> | null = null
+
+  async function fetchModelsDev(): Promise<Record<string, any>> {
+    if (modelsDevCache) return modelsDevCache
+    const cachePath = path.join(Global.Path.cache, "models.json")
+    const file = Bun.file(cachePath)
+    const cached = await file.json().catch(() => null)
+    if (cached) {
+      modelsDevCache = cached
+      return cached
+    }
+    try {
+      const resp = await fetch("https://models.dev/api.json", { signal: AbortSignal.timeout(5000) })
+      if (resp.ok) {
+        const data = await resp.json()
+        modelsDevCache = data as Record<string, any>
+        await Bun.write(file, JSON.stringify(data)).catch(() => {})
+        return modelsDevCache!
+      }
+    } catch {
+      log.info("models.dev fetch failed, using builtin models")
+    }
+    return {}
+  }
+
+  // Refresh models.dev in background
+  if (typeof globalThis.setTimeout !== "undefined") {
+    fetchModelsDev().catch(() => {})
+    setInterval(() => fetchModelsDev().catch(() => {}), 60 * 60 * 1000).unref?.()
+  }
+
+  // ---------------------------------------------------------------------------
+  // 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() as Record<string, unknown>
+    const providers = (cfg.providers || {}) as Record<string, { api_key?: string }>
+    return providers[providerID]?.api_key
+  }
+
+  // ---------------------------------------------------------------------------
+  // List all available providers with their models
+  // ---------------------------------------------------------------------------
+  export async function listProviders(): Promise<Record<string, { name: string; models: string[]; hasKey: boolean }>> {
+    const result: Record<string, { name: string; models: string[]; hasKey: boolean }> = {}
+    const modelsDev = await fetchModelsDev()
+
+    // From models.dev
+    for (const [providerID, provider] of Object.entries(modelsDev)) {
+      const p = provider as any
+      if (!p.models || typeof p.models !== "object") continue
+      const key = await getApiKey(providerID)
+      result[providerID] = {
+        name: p.name || providerID,
+        models: Object.keys(p.models),
+        hasKey: !!key,
+      }
+    }
+
+    // Ensure builtin providers are always listed
+    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)
+      }
+    }
+
+    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
+
+    // Try builtin first
+    const builtin = BUILTIN_MODELS[id]
+    if (builtin) {
+      const apiKey = await getApiKey(builtin.providerID)
+      if (!apiKey) throw noKeyError(builtin.providerID)
+      return getLanguageModel(builtin.providerID, id, apiKey)
+    }
+
+    // Try models.dev
+    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)
+        const npm = p.models[id].provider?.npm || p.npm || "@ai-sdk/openai-compatible"
+        return getLanguageModel(providerID, id, apiKey, npm, p.api)
+      }
+    }
+
+    // Try provider/model format
+    if (id.includes("/")) {
+      const [providerID, ...rest] = id.split("/")
+      const mid = rest.join("/")
+      const apiKey = await getApiKey(providerID)
+      if (!apiKey) throw noKeyError(providerID)
+      return getLanguageModel(providerID, mid, apiKey)
+    }
+
+    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}. Provider ${providerID} not supported.`)
+      const opts: Record<string, unknown> = { apiKey }
+      if (baseURL) opts.baseURL = baseURL
+      if (providerID === "openrouter") {
+        opts.headers = { "HTTP-Referer": "https://codeblog.ai/", "X-Title": "codeblog" }
+      }
+      if (providerID === "cerebras") {
+        opts.headers = { "X-Cerebras-3rd-Party-Integration": "codeblog" }
+      }
+      sdk = createFn(opts)
+      sdkCache.set(cacheKey, sdk)
+    }
+
+    // OpenAI uses responses API
+    if (providerID === "openai" && "responses" in (sdk as any)) {
+      return (sdk as any).responses(modelID)
+    }
+    return (sdk as any).languageModel?.(modelID) ?? (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() as Record<string, unknown>
+    return cfg.model as string | undefined
+  }
+
+  // ---------------------------------------------------------------------------
+  // 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 }> = []
+    for (const model of Object.values(BUILTIN_MODELS)) {
+      const key = await getApiKey(model.providerID)
+      result.push({ model, hasKey: !!key })
+    }
+    return result
+  }
+
+  // ---------------------------------------------------------------------------
+  // Parse provider/model format
+  // ---------------------------------------------------------------------------
+  export function parseModel(model: string) {
+    const [providerID, ...rest] = model.split("/")
+    return { providerID, modelID: rest.join("/") }
+  }
+}

package/src/cli/cmd/ai-publish.ts

@@ -0,0 +1,95 @@
+import type { CommandModule } from "yargs"
+import { AIChat } from "../../ai/chat"
+import { Posts } from "../../api/posts"
+import { scanAll, parseSession, registerAllScanners } from "../../scanner"
+import { UI } from "../ui"
+
+export const AIPublishCommand: CommandModule = {
+  command: "ai-publish",
+  aliases: ["ap"],
+  describe: "AI-powered publish — scan sessions, let AI write the post",
+  builder: (yargs) =>
+    yargs
+      .option("model", {
+        alias: "m",
+        describe: "AI model to use",
+        type: "string",
+      })
+      .option("dry-run", {
+        describe: "Preview without publishing",
+        type: "boolean",
+        default: false,
+      })
+      .option("limit", {
+        describe: "Max sessions to scan",
+        type: "number",
+        default: 10,
+      }),
+  handler: async (args) => {
+    try {
+      UI.info("Scanning IDE sessions...")
+      registerAllScanners()
+      const sessions = scanAll(args.limit as number)
+
+      if (sessions.length === 0) {
+        UI.warn("No IDE sessions found.")
+        return
+      }
+
+      console.log(`  Found ${UI.Style.TEXT_HIGHLIGHT}${sessions.length}${UI.Style.TEXT_NORMAL} sessions`)
+      console.log("")
+
+      // Pick the best session
+      const best = sessions[0]
+      console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Selected:${UI.Style.TEXT_NORMAL} ${best.title}`)
+      console.log(`  ${UI.Style.TEXT_DIM}${best.source} · ${best.project}${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+
+      // Parse session content
+      const parsed = parseSession(best.filePath, best.source, 50)
+      if (!parsed || parsed.turns.length < 2) {
+        UI.warn("Session too short to generate a post.")
+        return
+      }
+
+      const content = parsed.turns
+        .map((t) => `[${t.role}]: ${t.content.slice(0, 2000)}`)
+        .join("\n\n")
+
+      UI.info("AI is writing your post...")
+      console.log("")
+
+      process.stdout.write(`  ${UI.Style.TEXT_DIM}`)
+      const result = await AIChat.analyzeAndPost(content, args.model as string | undefined)
+      process.stdout.write(UI.Style.TEXT_NORMAL)
+
+      console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Title:${UI.Style.TEXT_NORMAL} ${result.title}`)
+      console.log(`  ${UI.Style.TEXT_DIM}Tags: ${result.tags.join(", ")}${UI.Style.TEXT_NORMAL}`)
+      console.log(`  ${UI.Style.TEXT_DIM}Summary: ${result.summary}${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+
+      if (args.dryRun) {
+        console.log(`  ${UI.Style.TEXT_WARNING}[DRY RUN]${UI.Style.TEXT_NORMAL} Preview:`)
+        console.log("")
+        console.log(result.content.slice(0, 1000))
+        if (result.content.length > 1000) console.log(`  ${UI.Style.TEXT_DIM}... (${result.content.length} chars total)${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+        return
+      }
+
+      UI.info("Publishing to CodeBlog...")
+      const post = await Posts.create({
+        title: result.title,
+        content: result.content,
+        tags: result.tags,
+        summary: result.summary,
+        source_session: best.filePath,
+      })
+
+      UI.success(`Published! Post ID: ${post.post.id}`)
+    } catch (err) {
+      UI.error(`AI publish failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}