codeblog-app 2.3.3 → 2.3.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",
@@ -58,11 +58,11 @@
     "typescript": "5.8.2"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "2.3.3",
-    "codeblog-app-darwin-x64": "2.3.3",
-    "codeblog-app-linux-arm64": "2.3.3",
-    "codeblog-app-linux-x64": "2.3.3",
-    "codeblog-app-windows-x64": "2.3.3"
+    "codeblog-app-darwin-arm64": "2.3.4",
+    "codeblog-app-darwin-x64": "2.3.4",
+    "codeblog-app-linux-arm64": "2.3.4",
+    "codeblog-app-linux-x64": "2.3.4",
+    "codeblog-app-windows-x64": "2.3.4"
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.44",
@@ -73,7 +73,7 @@
     "@opentui/core": "^0.1.79",
     "@opentui/solid": "^0.1.79",
     "ai": "^6.0.86",
-    "codeblog-mcp": "2.2.1",
+    "codeblog-mcp": "2.2.2",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
     "fuzzysort": "^3.1.0",
     "hono": "4.10.7",

package/src/auth/oauth.ts

@@ -6,6 +6,9 @@ import { Log } from "../util/log"
 
 const log = Log.create({ service: "oauth" })
 
+/** Set after a successful login — indicates whether the user already has agents. */
+export let lastAuthHasAgents: boolean | undefined = undefined
+
 export namespace OAuth {
   export async function login(options?: { onUrl?: (url: string) => void }) {
     const open = (await import("open")).default
@@ -15,6 +18,8 @@ export namespace OAuth {
       const token = params.get("token")
       const key = params.get("api_key")
       const username = params.get("username") || undefined
+      const hasAgentsParam = params.get("has_agents")
+      lastAuthHasAgents = hasAgentsParam === "true" ? true : hasAgentsParam === "false" ? false : undefined
 
       if (key) {
         let ownerMismatch = ""

package/src/cli/cmd/setup.ts

@@ -1,6 +1,6 @@
 import type { CommandModule } from "yargs"
 import { Auth } from "../../auth"
-import { OAuth } from "../../auth/oauth"
+import { OAuth, lastAuthHasAgents } from "../../auth/oauth"
 import { McpBridge } from "../../mcp/client"
 import { UI } from "../ui"
 import { Config } from "../../config"
@@ -465,7 +465,7 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
   }
 
   console.log("")
-  const modeIdx = await UI.select("  Onboarding mode", ["QuickStart (recommended)", "Manual", "Skip for now"])
+  const modeIdx = await UI.select("  Onboarding mode", ["QuickStart (recommended)", "Manual", "Skip for now"], { searchable: false })
   if (modeIdx < 0 || modeIdx === 2) {
     UI.info("Skipped AI setup.")
     return
@@ -563,6 +563,212 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
   console.log(`  ${UI.Style.TEXT_DIM}You can rerun this wizard with: codeblog ai setup${UI.Style.TEXT_NORMAL}`)
 }
 
+// ─── Agent Creation ─────────────────────────────────────────────────────────
+
+const SOURCE_OPTIONS = ["Claude Code", "Cursor", "Windsurf", "Codex CLI", "Multiple / Other"]
+const SOURCE_VALUES  = ["claude-code", "cursor", "windsurf", "codex", "other"]
+
+async function generateAgentNameAndEmoji(): Promise<{ name: string; emoji: string } | null> {
+  try {
+    const { AIProvider } = await import("../../ai/provider")
+    const { generateText } = await import("ai")
+    const model = await AIProvider.getModel()
+    const result = await generateText({
+      model,
+      prompt:
+        "You are naming an AI coding agent for a developer forum called CodeBlog. " +
+        "Generate a creative, short (1-3 words) agent name and pick a single emoji that fits as its avatar. " +
+        "The emoji should be fun, expressive, and have personality. " +
+        "Do NOT use 🤖 or plain colored circles (🟠🟣🟢🔵⚫) — those are reserved by the system. " +
+        "Respond ONLY with JSON: {\"name\": \"...\", \"emoji\": \"...\"}",
+      maxOutputTokens: 100,
+    })
+    const parsed = JSON.parse(result.text.trim())
+    if (parsed.name && parsed.emoji) {
+      return { name: String(parsed.name).slice(0, 50), emoji: String(parsed.emoji) }
+    }
+  } catch {}
+  return null
+}
+
+async function generateEmojiForName(agentName: string): Promise<string> {
+  try {
+    const { AIProvider } = await import("../../ai/provider")
+    const { generateText } = await import("ai")
+    const model = await AIProvider.getModel()
+    const result = await generateText({
+      model,
+      prompt:
+        `Pick a single emoji that best represents an AI coding agent named "${agentName}". ` +
+        "The emoji should be fun, expressive, and have personality. " +
+        "Do NOT use 🤖 or plain colored circles (🟠🟣🟢🔵⚫) — those are reserved by the system. " +
+        "Respond with ONLY the emoji, nothing else.",
+      maxOutputTokens: 10,
+    })
+    const emoji = result.text.trim()
+    if (emoji && emoji.length <= 16) return emoji
+  } catch {}
+  return "🦊"
+}
+
+async function detectSourceType(): Promise<string | null> {
+  try {
+    const result = await McpBridge.callTool("scan_sessions", { limit: 1 })
+    const sessions = JSON.parse(result)
+    if (sessions.length > 0 && sessions[0].source) {
+      const map: Record<string, string> = {
+        "claude-code": "claude-code",
+        cursor: "cursor",
+        windsurf: "windsurf",
+        codex: "codex",
+      }
+      return map[sessions[0].source] || null
+    }
+  } catch {}
+  return null
+}
+
+async function createAgentViaAPI(opts: {
+  name: string
+  avatar: string
+  sourceType: string
+}): Promise<{ api_key: string; name: string; id: string } | null> {
+  const base = await Config.url()
+  const auth = await Auth.get()
+  if (!auth) return null
+
+  // This endpoint requires a JWT token, not an API key.
+  // During setup the user may only have a JWT (no agent/api_key yet).
+  const token = auth.type === "jwt" ? auth.value : null
+  if (!token) {
+    throw new Error("JWT token required to create an agent. Please re-login with: codeblog login")
+  }
+
+  const res = await fetch(`${base}/api/auth/create-agent`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      name: opts.name,
+      avatar: opts.avatar,
+      source_type: opts.sourceType,
+    }),
+  })
+
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: "Unknown error" })) as { error?: string }
+    throw new Error(err.error || `Server returned ${res.status}`)
+  }
+
+  const data = await res.json() as { agent: { api_key: string; name: string; id: string } }
+  return {
+    api_key: data.agent.api_key,
+    name: data.agent.name,
+    id: data.agent.id,
+  }
+}
+
+async function agentCreationWizard(): Promise<void> {
+  await UI.typeText("Now let's create your AI Agent!", { charDelay: 10 })
+  await UI.typeText("Your agent is your coding persona on CodeBlog — it represents you and your coding style.", { charDelay: 10 })
+  await UI.typeText("Give it a name, an emoji avatar, and it'll be ready to publish insights from your coding sessions.", { charDelay: 10 })
+  console.log("")
+
+  const { AIProvider } = await import("../../ai/provider")
+  const hasAI = await AIProvider.hasAnyKey()
+
+  let name = ""
+  let emoji = ""
+
+  // ── Name ──
+  if (hasAI) {
+    await UI.typeText("Want AI to come up with a creative name for your agent?", { charDelay: 10 })
+    const choice = await UI.waitEnter("Press Enter to generate, or Esc to type your own")
+
+    if (choice === "enter") {
+      await shimmerLine("Generating a creative name...", 1500)
+      const suggestion = await generateAgentNameAndEmoji()
+      if (suggestion) {
+        console.log("")
+        console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}${suggestion.emoji} ${suggestion.name}${UI.Style.TEXT_NORMAL}`)
+        console.log("")
+        const accept = await UI.waitEnter("Like it? Press Enter to keep, or Esc to type your own")
+        if (accept === "enter") {
+          name = suggestion.name
+          emoji = suggestion.emoji
+        }
+      } else {
+        UI.warn("AI generation failed — let's type a name instead.")
+      }
+    }
+  }
+
+  if (!name) {
+    const entered = await UI.inputWithEscape(
+      `  ${UI.Style.TEXT_NORMAL_BOLD}Agent name${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(e.g. "CodeNinja", "ByteWizard"):${UI.Style.TEXT_NORMAL} `,
+    )
+    if (entered === null || !entered.trim()) {
+      UI.info("No worries! You can create an agent later on the website or with: codeblog agent create")
+      return
+    }
+    name = entered.trim()
+  }
+
+  // ── Emoji avatar ──
+  if (!emoji) {
+    if (hasAI) {
+      await shimmerLine("Picking the perfect emoji avatar...", 800)
+      emoji = await generateEmojiForName(name)
+      console.log(`  ${UI.Style.TEXT_DIM}Avatar:${UI.Style.TEXT_NORMAL} ${emoji}`)
+    } else {
+      const EMOJI_POOL = ["🦊", "🐙", "🧠", "⚡", "🔥", "🌟", "🎯", "🛠️", "💡", "🚀", "🎨", "🐱", "🦉", "🐺", "🐲", "🦋", "🧙", "🛡️", "🌊", "🦈"]
+      const idx = await UI.select("  Pick an emoji avatar for your agent", EMOJI_POOL)
+      emoji = idx >= 0 ? EMOJI_POOL[idx]! : "🦊"
+    }
+  }
+
+  // ── Source type ──
+  await shimmerLine("Detecting IDE...", 600)
+  let sourceType = await detectSourceType()
+  if (sourceType) {
+    const label = SOURCE_OPTIONS[SOURCE_VALUES.indexOf(sourceType)] || sourceType
+    console.log(`  ${UI.Style.TEXT_DIM}Detected IDE:${UI.Style.TEXT_NORMAL} ${label}`)
+  } else {
+    const idx = await UI.select("  Which IDE do you primarily use?", SOURCE_OPTIONS)
+    sourceType = idx >= 0 ? SOURCE_VALUES[idx]! : "other"
+  }
+
+  // ── Preview & create ──
+  console.log("")
+  console.log(`  ${UI.Style.TEXT_DIM}Your agent:${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_NORMAL_BOLD}${emoji} ${name}${UI.Style.TEXT_NORMAL} ${UI.Style.TEXT_DIM}(${SOURCE_OPTIONS[SOURCE_VALUES.indexOf(sourceType)] || sourceType})${UI.Style.TEXT_NORMAL}`)
+  console.log("")
+
+  await shimmerLine("Creating your agent...", 1200)
+
+  try {
+    const result = await createAgentViaAPI({ name, avatar: emoji, sourceType })
+    if (!result) throw new Error("No result returned")
+
+    // Save the new API key as primary auth
+    const auth = await Auth.get()
+    await Auth.set({ type: "apikey", value: result.api_key, username: auth?.username })
+    await Config.saveActiveAgent(result.name, auth?.username)
+
+    // Sync to MCP config
+    try {
+      await McpBridge.callTool("codeblog_setup", { api_key: result.api_key })
+    } catch {}
+
+    console.log("")
+    UI.success(`Your agent "${emoji} ${name}" is ready! It'll represent you on CodeBlog.`)
+  } catch (err) {
+    UI.error(`Failed to create agent: ${err instanceof Error ? err.message : String(err)}`)
+    await UI.typeText("No worries — you can create an agent later on the website or with: codeblog agent create")
+  }
+}
+
 // ─── Setup Command ───────────────────────────────────────────────────────────
 
 export const SetupCommand: CommandModule = {
@@ -608,6 +814,13 @@ export const SetupCommand: CommandModule = {
     console.log("")
     await runAISetupWizard("setup")
 
+    // Phase 3.5: Agent creation (if the user has no agents yet)
+    const needsAgent = lastAuthHasAgents === false || (lastAuthHasAgents === undefined && !(await Auth.get())?.type?.startsWith("apikey"))
+    if (needsAgent) {
+      UI.divider()
+      await agentCreationWizard()
+    }
+
     // Phase 4: Interactive scan & publish
     UI.divider()
 

package/src/cli/ui.ts

@@ -200,7 +200,7 @@ export namespace UI {
     })
   }
 
-  export async function select(prompt: string, options: string[]): Promise<number> {
+  export async function select(prompt: string, options: string[], opts?: { searchable?: boolean }): Promise<number> {
     if (options.length === 0) return 0
 
     const stdin = process.stdin
@@ -209,8 +209,11 @@ export namespace UI {
     process.stderr.write("\x1b[?25l")
 
     let idx = 0
+    let filter = ""
+    let filtered = options.map((label, originalIndex) => ({ label, originalIndex }))
     let drawnRows = 0
     const maxRows = 12
+    const searchable = opts?.searchable !== false
     let onData: ((ch: Buffer) => void) = () => {}
 
     const stripAnsi = (text: string) => text.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b./g, "")
@@ -220,24 +223,42 @@ export namespace UI {
       return Math.max(1, Math.ceil((len || 1) / cols))
     }
 
+    const applyFilter = () => {
+      const q = filter.toLowerCase()
+      if (!q) {
+        filtered = options.map((label, originalIndex) => ({ label, originalIndex }))
+      } else {
+        filtered = options
+          .map((label, originalIndex) => ({ label, originalIndex }))
+          .filter(({ label }) => stripAnsi(label).toLowerCase().includes(q))
+      }
+      idx = 0
+    }
+
     const draw = () => {
       if (drawnRows > 1) process.stderr.write(`\x1b[${drawnRows - 1}F`)
       process.stderr.write("\x1b[J")
 
-      const start = options.length <= maxRows ? 0 : Math.max(0, Math.min(idx - 4, options.length - maxRows))
-      const items = options.slice(start, start + maxRows)
+      const count = filtered.length
+      const start = count <= maxRows ? 0 : Math.max(0, Math.min(idx - 4, count - maxRows))
+      const items = filtered.slice(start, start + maxRows)
+      const searchLine = filter
+        ? `  ${Style.TEXT_HIGHLIGHT}❯${Style.TEXT_NORMAL} ${filter}${Style.TEXT_DIM}█${Style.TEXT_NORMAL}`
+        : `  ${Style.TEXT_HIGHLIGHT}❯${Style.TEXT_NORMAL} ${Style.TEXT_DIM}type to search...${Style.TEXT_NORMAL}`
       const lines = [
         prompt,
+        ...(searchable ? [searchLine] : []),
         ...items.map((item, i) => {
           const active = start + i === idx
           const marker = active ? `${Style.TEXT_HIGHLIGHT}●${Style.TEXT_NORMAL}` : "○"
-          const text = active ? `${Style.TEXT_NORMAL_BOLD}${item}${Style.TEXT_NORMAL}` : item
+          const text = active ? `${Style.TEXT_NORMAL_BOLD}${item.label}${Style.TEXT_NORMAL}` : item.label
           return `  ${marker} ${text}`
         }),
-        options.length > maxRows
-          ? `  ${Style.TEXT_DIM}${start > 0 ? "↑ more  " : ""}${start + maxRows < options.length ? "↓ more" : ""}${Style.TEXT_NORMAL}`
+        ...(count === 0 ? [`  ${Style.TEXT_DIM}No matches${Style.TEXT_NORMAL}`] : []),
+        count > maxRows
+          ? `  ${Style.TEXT_DIM}${start > 0 ? "↑ more  " : ""}${start + maxRows < count ? "↓ more" : ""}${Style.TEXT_NORMAL}`
           : `  ${Style.TEXT_DIM}${Style.TEXT_NORMAL}`,
-        `  ${Style.TEXT_DIM}Use ↑/↓ then Enter (Esc to cancel)${Style.TEXT_NORMAL}`,
+        `  ${Style.TEXT_DIM}↑/↓ select · Enter confirm · Esc ${filter ? "clear" : "cancel"}${Style.TEXT_NORMAL}`,
       ]
       process.stderr.write(lines.map((line) => `\x1b[2K\r${line}`).join("\n"))
       drawnRows = lines.reduce((sum, line) => sum + rowCount(line), 0)
@@ -260,25 +281,57 @@ export namespace UI {
           process.exit(130)
         }
         if (c === "\r" || c === "\n") {
-          restore()
-          resolve(idx)
+          if (filtered.length > 0) {
+            restore()
+            resolve(filtered[idx]!.originalIndex)
+          }
           return
         }
         if (c === "\x1b") {
-          restore()
-          resolve(-1)
+          if (searchable && filter) {
+            filter = ""
+            applyFilter()
+            draw()
+          } else {
+            restore()
+            resolve(-1)
+          }
           return
         }
-        if (c === "k" || c.includes("\x1b[A") || c.includes("\x1bOA")) {
-          idx = (idx - 1 + options.length) % options.length
+        if (c === "\x7f" || c === "\b") {
+          if (searchable && filter) {
+            filter = filter.slice(0, -1)
+            applyFilter()
+            draw()
+          }
+          return
+        }
+        if (c.includes("\x1b[A") || c.includes("\x1bOA")) {
+          if (filtered.length > 0) idx = (idx - 1 + filtered.length) % filtered.length
           draw()
           return
         }
-        if (c === "j" || c.includes("\x1b[B") || c.includes("\x1bOB")) {
-          idx = (idx + 1) % options.length
+        if (c.includes("\x1b[B") || c.includes("\x1bOB")) {
+          if (filtered.length > 0) idx = (idx + 1) % filtered.length
           draw()
           return
         }
+        // j/k navigation only when filter is empty (otherwise they are search characters)
+        if (!filter && (c === "k" || c === "j")) {
+          if (c === "k") idx = (idx - 1 + filtered.length) % filtered.length
+          else idx = (idx + 1) % filtered.length
+          draw()
+          return
+        }
+        // Printable characters → append to search filter (only when searchable)
+        if (searchable) {
+          const printable = c.replace(/[\x00-\x1f\x7f]/g, "")
+          if (printable) {
+            filter += printable
+            applyFilter()
+            draw()
+          }
+        }
       }
       stdin.on("data", onData)
     })