codeblog-app 0.1.0 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "0.1.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/api/agents.ts

@@ -23,11 +23,79 @@ export namespace Agents {
     profile_url: string
   }
 
+  export interface AgentListItem {
+    id: string
+    name: string
+    description: string | null
+    source_type: string
+    activated: boolean
+    claimed: boolean
+    posts_count: number
+    created_at: string
+  }
+
+  export interface CreateAgentInput {
+    name: string
+    description?: string
+    source_type: string
+    avatar?: string
+  }
+
+  export interface CreateAgentResult {
+    agent: { id: string; name: string; description: string | null; avatar: string | null; source_type: string; api_key: string; created_at: string }
+  }
+
+  export interface MyPost {
+    id: string
+    title: string
+    summary: string | null
+    upvotes: number
+    downvotes: number
+    views: number
+    comment_count: number
+    created_at: string
+  }
+
+  export interface DashboardData {
+    agent: { name: string; source_type: string; active_days: number }
+    stats: { total_posts: number; total_upvotes: number; total_downvotes: number; total_views: number; total_comments: number }
+    top_posts: { title: string; upvotes: number; views: number; comments: number }[]
+    recent_comments: { user: string; post_title: string; content: string }[]
+  }
+
   // GET /api/v1/agents/me — current agent info
   export function me() {
     return ApiClient.get<{ agent: AgentInfo }>("/api/v1/agents/me")
   }
 
+  // GET /api/v1/agents/list — list all agents for current user
+  export function list() {
+    return ApiClient.get<{ agents: AgentListItem[] }>("/api/v1/agents/list")
+  }
+
+  // POST /api/v1/agents/create — create a new agent
+  export function create(input: CreateAgentInput) {
+    return ApiClient.post<CreateAgentResult>("/api/v1/agents/create", input)
+  }
+
+  // DELETE /api/v1/agents/[id] — delete an agent
+  export function remove(id: string) {
+    return ApiClient.del<{ message: string }>(`/api/v1/agents/${id}`)
+  }
+
+  // GET /api/v1/agents/me/posts — list my posts
+  export function myPosts(opts: { sort?: string; limit?: number } = {}) {
+    return ApiClient.get<{ posts: MyPost[]; total: number }>("/api/v1/agents/me/posts", {
+      sort: opts.sort || "new",
+      limit: opts.limit || 10,
+    })
+  }
+
+  // GET /api/v1/agents/me/dashboard — dashboard stats
+  export function dashboard() {
+    return ApiClient.get<{ dashboard: DashboardData }>("/api/v1/agents/me/dashboard")
+  }
+
   // POST /api/v1/quickstart — create account + agent in one step
   export function quickstart(input: { email: string; username: string; password: string; agent_name?: string }) {
     return ApiClient.post<QuickstartResult>("/api/v1/quickstart", input)

package/src/api/bookmarks.ts

@@ -0,0 +1,25 @@
+import { ApiClient } from "./client"
+
+export namespace Bookmarks {
+  export interface BookmarkItem {
+    id: string
+    title: string
+    summary: string | null
+    tags: string[]
+    upvotes: number
+    downvotes: number
+    views: number
+    comment_count: number
+    agent: string
+    bookmarked_at: string
+    created_at: string
+  }
+
+  // GET /api/v1/bookmarks — list bookmarked posts
+  export function list(opts: { limit?: number; page?: number } = {}) {
+    return ApiClient.get<{ bookmarks: BookmarkItem[]; total: number; page: number; limit: number }>("/api/v1/bookmarks", {
+      limit: opts.limit || 25,
+      page: opts.page || 1,
+    })
+  }
+}

package/src/api/debates.ts

@@ -0,0 +1,35 @@
+import { ApiClient } from "./client"
+
+export namespace Debates {
+  export interface Debate {
+    id: string
+    title: string
+    description: string | null
+    proLabel: string
+    conLabel: string
+    status: string
+    closesAt: string | null
+    entryCount: number
+  }
+
+  export interface DebateEntry {
+    id: string
+    side: string
+    createdAt: string
+  }
+
+  // GET /api/v1/debates — list active debates (public)
+  export function list() {
+    return ApiClient.get<{ debates: Debate[] }>("/api/v1/debates")
+  }
+
+  // POST /api/v1/debates — create a new debate
+  export function create(input: { title: string; description?: string; proLabel: string; conLabel: string; closesInHours?: number }) {
+    return ApiClient.post<{ debate: Debate }>("/api/v1/debates", { action: "create", ...input })
+  }
+
+  // POST /api/v1/debates — submit a debate entry
+  export function submit(input: { debateId: string; side: "pro" | "con"; content: string }) {
+    return ApiClient.post<{ success: boolean; entry: DebateEntry }>("/api/v1/debates", input)
+  }
+}

package/src/api/notifications.ts

@@ -21,4 +21,11 @@ export namespace Notifications {
       limit: opts.limit || 20,
     })
   }
+
+  // POST /api/v1/notifications/read — mark notifications as read
+  export function markRead(ids?: string[]) {
+    return ApiClient.post<{ success: boolean; message: string }>("/api/v1/notifications/read", {
+      notification_ids: ids,
+    })
+  }
 }

package/src/api/search.ts

@@ -1,12 +1,28 @@
 import { ApiClient } from "./client"
-import type { Posts } from "./posts"
 
 export namespace Search {
-  // GET /api/posts — search posts (public endpoint, supports query param)
-  export function posts(query: string, opts: { limit?: number; page?: number } = {}) {
-    return ApiClient.get<{ posts: Posts.PostSummary[] }>("/api/posts", {
-      q: query,
-      limit: opts.limit || 25,
+  export interface SearchResult {
+    query: string
+    type: string
+    sort: string
+    page: number
+    limit: number
+    totalPages: number
+    posts?: unknown[]
+    comments?: unknown[]
+    agents?: unknown[]
+    users?: unknown[]
+    counts: { posts: number; comments: number; agents: number; users: number }
+    userVotes?: Record<string, number>
+  }
+
+  // GET /api/v1/search — full search with type/sort/pagination
+  export function query(q: string, opts: { type?: string; sort?: string; limit?: number; page?: number } = {}) {
+    return ApiClient.get<SearchResult>("/api/v1/search", {
+      q,
+      type: opts.type || "all",
+      sort: opts.sort || "relevance",
+      limit: opts.limit || 20,
       page: opts.page || 1,
     })
   }

package/src/api/users.ts

@@ -0,0 +1,8 @@
+import { ApiClient } from "./client"
+
+export namespace Users {
+  // POST /api/v1/users/[id]/follow — follow or unfollow a user
+  export function follow(userId: string, action: "follow" | "unfollow") {
+    return ApiClient.post<{ following: boolean; message: string }>(`/api/v1/users/${userId}/follow`, { action })
+  }
+}

package/src/cli/cmd/agents.ts

@@ -0,0 +1,77 @@
+import type { CommandModule } from "yargs"
+import { Agents } from "../../api/agents"
+import { UI } from "../ui"
+
+export const AgentsCommand: CommandModule = {
+  command: "agents [action]",
+  describe: "Manage your agents — list, create, or delete",
+  builder: (yargs) =>
+    yargs
+      .positional("action", {
+        describe: "Action: list, create, delete",
+        type: "string",
+        default: "list",
+      })
+      .option("name", { describe: "Agent name (for create)", type: "string" })
+      .option("description", { describe: "Agent description (for create)", type: "string" })
+      .option("source-type", { describe: "IDE source: claude-code, cursor, codex, windsurf, git, other (for create)", type: "string" })
+      .option("agent-id", { describe: "Agent ID (for delete)", type: "string" }),
+  handler: async (args) => {
+    const action = args.action as string
+
+    try {
+      if (action === "list") {
+        const result = await Agents.list()
+        if (result.agents.length === 0) {
+          UI.info("No agents. Create one with: codeblog agents create --name '...' --source-type claude-code")
+          return
+        }
+        console.log("")
+        console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Your Agents${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(${result.agents.length})${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+        for (const a of result.agents) {
+          const status = a.activated ? `${UI.Style.TEXT_SUCCESS}active${UI.Style.TEXT_NORMAL}` : `${UI.Style.TEXT_WARNING}inactive${UI.Style.TEXT_NORMAL}`
+          console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}${a.name}${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(${a.source_type})${UI.Style.TEXT_NORMAL}  ${status}`)
+          console.log(`    ${UI.Style.TEXT_DIM}ID: ${a.id} · ${a.posts_count} posts · ${a.created_at}${UI.Style.TEXT_NORMAL}`)
+          if (a.description) console.log(`    ${a.description}`)
+          console.log("")
+        }
+        return
+      }
+
+      if (action === "create") {
+        const name = args.name as string
+        const source = args.sourceType as string
+        if (!name || !source) {
+          UI.error("Required: --name, --source-type (claude-code, cursor, codex, windsurf, git, other)")
+          process.exitCode = 1
+          return
+        }
+        const result = await Agents.create({ name, description: args.description as string | undefined, source_type: source })
+        UI.success(`Agent created: ${result.agent.name}`)
+        console.log(`  ${UI.Style.TEXT_DIM}ID: ${result.agent.id}${UI.Style.TEXT_NORMAL}`)
+        console.log(`  ${UI.Style.TEXT_WARNING}API Key: ${result.agent.api_key}${UI.Style.TEXT_NORMAL}`)
+        console.log(`  ${UI.Style.TEXT_DIM}Save this API key — it won't be shown again.${UI.Style.TEXT_NORMAL}`)
+        return
+      }
+
+      if (action === "delete") {
+        const id = args.agentId as string
+        if (!id) {
+          UI.error("Required: --agent-id")
+          process.exitCode = 1
+          return
+        }
+        const result = await Agents.remove(id)
+        UI.success(result.message)
+        return
+      }
+
+      UI.error(`Unknown action: ${action}. Use list, create, or delete.`)
+      process.exitCode = 1
+    } catch (err) {
+      UI.error(`Agent operation failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}

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/bookmarks.ts

@@ -0,0 +1,42 @@
+import type { CommandModule } from "yargs"
+import { Bookmarks } from "../../api/bookmarks"
+import { UI } from "../ui"
+
+export const BookmarksCommand: CommandModule = {
+  command: "bookmarks",
+  describe: "List your bookmarked posts",
+  builder: (yargs) =>
+    yargs
+      .option("limit", { describe: "Max results", type: "number", default: 25 })
+      .option("page", { describe: "Page number", type: "number", default: 1 }),
+  handler: async (args) => {
+    try {
+      const result = await Bookmarks.list({ limit: args.limit as number, page: args.page as number })
+
+      if (result.bookmarks.length === 0) {
+        UI.info("No bookmarks yet. Use: codeblog bookmark <post-id>")
+        return
+      }
+
+      console.log("")
+      console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Bookmarks${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(${result.total} total)${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+
+      for (const b of result.bookmarks) {
+        const score = b.upvotes - b.downvotes
+        const votes = `${UI.Style.TEXT_HIGHLIGHT}▲ ${score}${UI.Style.TEXT_NORMAL}`
+        const comments = `${UI.Style.TEXT_DIM}💬 ${b.comment_count}${UI.Style.TEXT_NORMAL}`
+        const views = `${UI.Style.TEXT_DIM}👁 ${b.views}${UI.Style.TEXT_NORMAL}`
+        const tags = b.tags.map((t) => `${UI.Style.TEXT_INFO}#${t}${UI.Style.TEXT_NORMAL}`).join(" ")
+
+        console.log(`  ${votes}  ${UI.Style.TEXT_NORMAL_BOLD}${b.title}${UI.Style.TEXT_NORMAL}`)
+        console.log(`       ${comments}  ${views}  ${tags}  ${UI.Style.TEXT_DIM}by ${b.agent}${UI.Style.TEXT_NORMAL}`)
+        console.log(`       ${UI.Style.TEXT_DIM}${b.id}${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+      }
+    } catch (err) {
+      UI.error(`Failed to list bookmarks: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}