codeblog-app 0.2.0 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",
@@ -56,9 +56,15 @@
     "typescript": "5.8.2"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.44",
+    "@ai-sdk/google": "^3.0.29",
+    "@ai-sdk/openai": "^3.0.29",
+    "ai": "^6.0.86",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
     "hono": "4.10.7",
+    "ink": "^6.7.0",
     "open": "10.1.2",
+    "react": "^19.2.4",
     "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,117 @@
+import { createAnthropic } from "@ai-sdk/anthropic"
+import { createOpenAI } from "@ai-sdk/openai"
+import { createGoogleGenerativeAI } from "@ai-sdk/google"
+import { type LanguageModel } from "ai"
+import { Config } from "../config"
+import { Log } from "../util/log"
+
+const log = Log.create({ service: "ai-provider" })
+
+export namespace AIProvider {
+  export type ProviderID = "anthropic" | "openai" | "google"
+
+  export interface ModelInfo {
+    id: string
+    providerID: ProviderID
+    name: string
+    contextWindow: number
+    outputTokens: number
+  }
+
+  export const 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,
+    },
+    "gemini-2.5-flash": {
+      id: "gemini-2.5-flash",
+      providerID: "google",
+      name: "Gemini 2.5 Flash",
+      contextWindow: 1048576,
+      outputTokens: 65536,
+    },
+  }
+
+  export const DEFAULT_MODEL = "claude-sonnet-4-20250514"
+
+  export async function getApiKey(providerID: ProviderID): Promise<string | undefined> {
+    const env: Record<ProviderID, string> = {
+      anthropic: "ANTHROPIC_API_KEY",
+      openai: "OPENAI_API_KEY",
+      google: "GOOGLE_GENERATIVE_AI_API_KEY",
+    }
+    const envKey = process.env[env[providerID]]
+    if (envKey) return envKey
+
+    const cfg = await Config.load()
+    const providers = (cfg as Record<string, unknown>).providers as Record<string, { api_key?: string }> | undefined
+    return providers?.[providerID]?.api_key
+  }
+
+  export async function getModel(modelID?: string): Promise<LanguageModel> {
+    const id = modelID || (await getConfiguredModel()) || DEFAULT_MODEL
+    const info = MODELS[id]
+    if (!info) throw new Error(`Unknown model: ${id}. Available: ${Object.keys(MODELS).join(", ")}`)
+
+    const apiKey = await getApiKey(info.providerID)
+    if (!apiKey) {
+      throw new Error(
+        `No API key for ${info.providerID}. Set ${info.providerID === "anthropic" ? "ANTHROPIC_API_KEY" : info.providerID === "openai" ? "OPENAI_API_KEY" : "GOOGLE_GENERATIVE_AI_API_KEY"} or run: codeblog config --provider ${info.providerID} --api-key <key>`,
+      )
+    }
+
+    log.info("loading model", { model: id, provider: info.providerID })
+
+    if (info.providerID === "anthropic") {
+      const provider = createAnthropic({ apiKey })
+      return provider(id)
+    }
+    if (info.providerID === "openai") {
+      const provider = createOpenAI({ apiKey })
+      return provider(id)
+    }
+    if (info.providerID === "google") {
+      const provider = createGoogleGenerativeAI({ apiKey })
+      return provider(id)
+    }
+    throw new Error(`Unsupported provider: ${info.providerID}`)
+  }
+
+  async function getConfiguredModel(): Promise<string | undefined> {
+    const cfg = await Config.load()
+    return (cfg as Record<string, unknown>).model as string | undefined
+  }
+
+  export async function available(): Promise<Array<{ model: ModelInfo; hasKey: boolean }>> {
+    const result: Array<{ model: ModelInfo; hasKey: boolean }> = []
+    for (const model of Object.values(MODELS)) {
+      const key = await getApiKey(model.providerID)
+      result.push({ model, hasKey: !!key })
+    }
+    return result
+  }
+}

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

package/src/cli/cmd/chat.ts

@@ -0,0 +1,175 @@
+import type { CommandModule } from "yargs"
+import { AIChat } from "../../ai/chat"
+import { AIProvider } from "../../ai/provider"
+import { UI } from "../ui"
+import readline from "readline"
+
+export const ChatCommand: CommandModule = {
+  command: "chat",
+  aliases: ["c"],
+  describe: "Interactive AI chat — write posts, analyze code, browse the forum",
+  builder: (yargs) =>
+    yargs
+      .option("model", {
+        alias: "m",
+        describe: "Model to use (e.g. claude-sonnet-4-20250514, gpt-4o)",
+        type: "string",
+      })
+      .option("prompt", {
+        alias: "p",
+        describe: "Single prompt (non-interactive mode)",
+        type: "string",
+      }),
+  handler: async (args) => {
+    const modelID = args.model as string | undefined
+
+    // Non-interactive: single prompt
+    if (args.prompt) {
+      try {
+        await AIChat.stream(
+          [{ role: "user", content: args.prompt as string }],
+          {
+            onToken: (token) => process.stdout.write(token),
+            onFinish: () => process.stdout.write("\n"),
+            onError: (err) => UI.error(err.message),
+          },
+          modelID,
+        )
+      } catch (err) {
+        UI.error(err instanceof Error ? err.message : String(err))
+        process.exitCode = 1
+      }
+      return
+    }
+
+    // Interactive REPL
+    const modelInfo = AIProvider.MODELS[modelID || AIProvider.DEFAULT_MODEL]
+    const modelName = modelInfo?.name || modelID || AIProvider.DEFAULT_MODEL
+
+    console.log("")
+    console.log(`  ${UI.Style.TEXT_HIGHLIGHT_BOLD}CodeBlog AI Chat${UI.Style.TEXT_NORMAL}`)
+    console.log(`  ${UI.Style.TEXT_DIM}Model: ${modelName}${UI.Style.TEXT_NORMAL}`)
+    console.log(`  ${UI.Style.TEXT_DIM}Type your message. Commands: /help /model /clear /exit${UI.Style.TEXT_NORMAL}`)
+    console.log("")
+
+    const messages: AIChat.Message[] = []
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: `${UI.Style.TEXT_HIGHLIGHT}❯ ${UI.Style.TEXT_NORMAL}`,
+    })
+
+    let currentModel = modelID
+
+    rl.prompt()
+
+    rl.on("line", async (line) => {
+      const input = line.trim()
+      if (!input) {
+        rl.prompt()
+        return
+      }
+
+      // Handle commands
+      if (input.startsWith("/")) {
+        const cmd = input.split(" ")[0]
+        const rest = input.slice(cmd.length).trim()
+
+        if (cmd === "/exit" || cmd === "/quit" || cmd === "/q") {
+          console.log("")
+          UI.info("Bye!")
+          rl.close()
+          return
+        }
+
+        if (cmd === "/clear") {
+          messages.length = 0
+          console.log(`  ${UI.Style.TEXT_DIM}Chat history cleared${UI.Style.TEXT_NORMAL}`)
+          rl.prompt()
+          return
+        }
+
+        if (cmd === "/model") {
+          if (rest) {
+            if (AIProvider.MODELS[rest]) {
+              currentModel = rest
+              console.log(`  ${UI.Style.TEXT_SUCCESS}Model: ${AIProvider.MODELS[rest].name}${UI.Style.TEXT_NORMAL}`)
+            } else {
+              console.log(`  ${UI.Style.TEXT_DANGER}Unknown model: ${rest}${UI.Style.TEXT_NORMAL}`)
+              console.log(`  ${UI.Style.TEXT_DIM}Available: ${Object.keys(AIProvider.MODELS).join(", ")}${UI.Style.TEXT_NORMAL}`)
+            }
+          } else {
+            const current = AIProvider.MODELS[currentModel || AIProvider.DEFAULT_MODEL]
+            console.log(`  ${UI.Style.TEXT_DIM}Current: ${current?.name || currentModel || AIProvider.DEFAULT_MODEL}${UI.Style.TEXT_NORMAL}`)
+            console.log(`  ${UI.Style.TEXT_DIM}Available: ${Object.keys(AIProvider.MODELS).join(", ")}${UI.Style.TEXT_NORMAL}`)
+          }
+          rl.prompt()
+          return
+        }
+
+        if (cmd === "/help") {
+          console.log("")
+          console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Commands${UI.Style.TEXT_NORMAL}`)
+          console.log(`  ${UI.Style.TEXT_DIM}/model [id]${UI.Style.TEXT_NORMAL}   Switch or show model`)
+          console.log(`  ${UI.Style.TEXT_DIM}/clear${UI.Style.TEXT_NORMAL}        Clear chat history`)
+          console.log(`  ${UI.Style.TEXT_DIM}/exit${UI.Style.TEXT_NORMAL}         Exit chat`)
+          console.log("")
+          console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Tips${UI.Style.TEXT_NORMAL}`)
+          console.log(`  ${UI.Style.TEXT_DIM}Ask me to write a blog post, analyze code, draft comments,${UI.Style.TEXT_NORMAL}`)
+          console.log(`  ${UI.Style.TEXT_DIM}summarize discussions, or generate tags and titles.${UI.Style.TEXT_NORMAL}`)
+          console.log("")
+          rl.prompt()
+          return
+        }
+
+        console.log(`  ${UI.Style.TEXT_DIM}Unknown command: ${cmd}. Type /help${UI.Style.TEXT_NORMAL}`)
+        rl.prompt()
+        return
+      }
+
+      // Send message to AI
+      messages.push({ role: "user", content: input })
+
+      console.log("")
+      process.stdout.write(`  ${UI.Style.TEXT_INFO}`)
+
+      try {
+        let response = ""
+        await AIChat.stream(
+          messages,
+          {
+            onToken: (token) => {
+              process.stdout.write(token)
+              response += token
+            },
+            onFinish: () => {
+              process.stdout.write(UI.Style.TEXT_NORMAL)
+              console.log("")
+              console.log("")
+            },
+            onError: (err) => {
+              process.stdout.write(UI.Style.TEXT_NORMAL)
+              console.log("")
+              UI.error(err.message)
+            },
+          },
+          currentModel,
+        )
+        messages.push({ role: "assistant", content: response })
+      } catch (err) {
+        process.stdout.write(UI.Style.TEXT_NORMAL)
+        console.log("")
+        UI.error(err instanceof Error ? err.message : String(err))
+      }
+
+      rl.prompt()
+    })
+
+    rl.on("close", () => {
+      process.exit(0)
+    })
+
+    // Keep process alive
+    await new Promise(() => {})
+  },
+}

package/src/cli/cmd/config.ts

@@ -0,0 +1,96 @@
+import type { CommandModule } from "yargs"
+import { Config } from "../../config"
+import { AIProvider } from "../../ai/provider"
+import { UI } from "../ui"
+
+export const ConfigCommand: CommandModule = {
+  command: "config",
+  describe: "Configure AI provider and model settings",
+  builder: (yargs) =>
+    yargs
+      .option("provider", {
+        describe: "AI provider: anthropic, openai, google",
+        type: "string",
+      })
+      .option("api-key", {
+        describe: "API key for the provider",
+        type: "string",
+      })
+      .option("model", {
+        describe: "Default model ID",
+        type: "string",
+      })
+      .option("list", {
+        describe: "List available models and their status",
+        type: "boolean",
+        default: false,
+      }),
+  handler: async (args) => {
+    try {
+      if (args.list) {
+        const models = await AIProvider.available()
+        console.log("")
+        console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Available Models${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+        for (const { model, hasKey } of models) {
+          const status = hasKey ? `${UI.Style.TEXT_SUCCESS}✓${UI.Style.TEXT_NORMAL}` : `${UI.Style.TEXT_DIM}✗${UI.Style.TEXT_NORMAL}`
+          console.log(`  ${status}  ${UI.Style.TEXT_NORMAL_BOLD}${model.name}${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(${model.id})${UI.Style.TEXT_NORMAL}`)
+          console.log(`       ${UI.Style.TEXT_DIM}${model.providerID} · ${(model.contextWindow / 1000).toFixed(0)}k context${UI.Style.TEXT_NORMAL}`)
+        }
+        console.log("")
+        console.log(`  ${UI.Style.TEXT_DIM}✓ = API key configured, ✗ = needs key${UI.Style.TEXT_NORMAL}`)
+        console.log(`  ${UI.Style.TEXT_DIM}Set key: codeblog config --provider anthropic --api-key sk-...${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+        return
+      }
+
+      if (args.provider && args.apiKey) {
+        const provider = args.provider as string
+        if (!["anthropic", "openai", "google"].includes(provider)) {
+          UI.error("Provider must be: anthropic, openai, or google")
+          process.exitCode = 1
+          return
+        }
+        const cfg = await Config.load() as Record<string, unknown>
+        const providers = (cfg.providers || {}) as Record<string, Record<string, string>>
+        providers[provider] = { ...providers[provider], api_key: args.apiKey as string }
+        await Config.save({ ...cfg, providers } as unknown as Config.CodeblogConfig)
+        UI.success(`${provider} API key saved`)
+        return
+      }
+
+      if (args.model) {
+        const model = args.model as string
+        if (!AIProvider.MODELS[model]) {
+          UI.error(`Unknown model: ${model}. Run: codeblog config --list`)
+          process.exitCode = 1
+          return
+        }
+        const cfg = await Config.load() as Record<string, unknown>
+        await Config.save({ ...cfg, model } as unknown as Config.CodeblogConfig)
+        UI.success(`Default model set to ${model}`)
+        return
+      }
+
+      // Show current config
+      const cfg = await Config.load() as Record<string, unknown>
+      const model = (cfg.model as string) || AIProvider.DEFAULT_MODEL
+      const providers = (cfg.providers || {}) as Record<string, Record<string, string>>
+
+      console.log("")
+      console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Current Config${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+      console.log(`  Model:     ${UI.Style.TEXT_HIGHLIGHT}${model}${UI.Style.TEXT_NORMAL}`)
+      console.log(`  API URL:   ${cfg.api_url || "https://codeblog.ai"}`)
+      console.log("")
+      for (const [id, p] of Object.entries(providers)) {
+        const masked = p.api_key ? p.api_key.slice(0, 8) + "..." : "not set"
+        console.log(`  ${id}: ${UI.Style.TEXT_DIM}${masked}${UI.Style.TEXT_NORMAL}`)
+      }
+      console.log("")
+    } catch (err) {
+      UI.error(`Config failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}

package/src/index.ts

@@ -27,8 +27,11 @@ import { FollowCommand } from "./cli/cmd/follow"
 import { MyPostsCommand } from "./cli/cmd/myposts"
 import { EditCommand } from "./cli/cmd/edit"
 import { DeleteCommand } from "./cli/cmd/delete"
+import { ChatCommand } from "./cli/cmd/chat"
+import { ConfigCommand } from "./cli/cmd/config"
+import { AIPublishCommand } from "./cli/cmd/ai-publish"
 
-const VERSION = "0.2.0"
+const VERSION = "0.3.0"
 
 process.on("unhandledRejection", (e) => {
   Log.Default.error("rejection", {
@@ -93,6 +96,10 @@ const cli = yargs(hideBin(process.argv))
   // Scan & Publish
   .command(ScanCommand)
   .command(PublishCommand)
+  .command(AIPublishCommand)
+  // AI
+  .command(ChatCommand)
+  .command(ConfigCommand)
   // Account
   .command(NotificationsCommand)
   .command(DashboardCommand)