codeblog-app 1.6.2 → 1.6.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "CLI client for CodeBlog — the forum where AI writes the posts",
   "type": "module",
   "license": "MIT",

package/src/ai/chat.ts

@@ -1,4 +1,4 @@
-import { streamText, type CoreMessage } from "ai"
+import { streamText, type CoreMessage, type CoreToolMessage, type CoreAssistantMessage } from "ai"
 import { AIProvider } from "./provider"
 import { chatTools } from "./tools"
 import { Log } from "../util/log"
@@ -35,92 +35,64 @@ export namespace AIChat {
     onToolResult?: (name: string, result: unknown) => void
   }
 
+  // Convert our simple messages to CoreMessage[] for AI SDK
+  // Only user/assistant text messages — tool history is handled by maxSteps internally
+  function toCoreMessages(messages: Message[]): CoreMessage[] {
+    return messages
+      .filter((m) => m.role === "user" || m.role === "assistant")
+      .map((m) => ({ role: m.role as "user" | "assistant", content: m.content }))
+  }
+
   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 })
 
-    const history: CoreMessage[] = messages.map((m) => ({ role: m.role, content: m.content }))
+    const coreMessages = toCoreMessages(messages)
     let full = ""
 
-    // Manual multi-step loop (maxSteps=1 per call, we handle tool follow-up ourselves)
-    // This is needed because openai-compatible providers don't support automatic multi-step
-    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,
-      })
-
-      const calls: Array<{ id: string; name: string; input: unknown; output: unknown }> = []
-
-      try {
-        for await (const part of result.fullStream) {
-          if (signal?.aborted) break
-          switch (part.type) {
-            case "text-delta": {
-              const delta = (part as any).text ?? (part as any).textDelta ?? ""
-              if (delta) { full += delta; callbacks.onToken?.(delta) }
-              break
-            }
-            case "tool-call": {
-              const input = (part as any).input ?? (part as any).args
-              callbacks.onToolCall?.(part.toolName, input)
-              calls.push({ id: part.toolCallId, name: part.toolName, input, output: undefined })
-              break
-            }
-            case "tool-result": {
-              const output = (part as any).output ?? (part as any).result ?? {}
-              const name = (part as any).toolName
-              callbacks.onToolResult?.(name, output)
-              const match = calls.find((c) => c.name === name && 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
-            }
+    const result = streamText({
+      model,
+      system: SYSTEM_PROMPT,
+      messages: coreMessages,
+      tools: chatTools,
+      maxSteps: 5,
+      abortSignal: signal,
+    })
+
+    try {
+      for await (const part of result.fullStream) {
+        if (signal?.aborted) break
+        switch (part.type) {
+          case "text-delta": {
+            const delta = (part as any).text ?? (part as any).textDelta ?? ""
+            if (delta) { full += delta; callbacks.onToken?.(delta) }
+            break
+          }
+          case "tool-call": {
+            const input = (part as any).input ?? (part as any).args
+            callbacks.onToolCall?.(part.toolName, input)
+            break
+          }
+          case "tool-result": {
+            const output = (part as any).output ?? (part as any).result ?? {}
+            const name = (part as any).toolName
+            callbacks.onToolResult?.(name, 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
       }
-
-      // No tool calls this step → done
-      if (calls.length === 0) break
-
-      // Append assistant + tool messages in AI SDK v6 format for next round
-      history.push({
-        role: "assistant",
-        content: calls.map((c) => ({
-          type: "tool-call" as const,
-          toolCallId: c.id,
-          toolName: c.name,
-          input: c.input ?? {},
-        })),
-      } as any)
-      history.push({
-        role: "tool",
-        content: calls.map((c) => ({
-          type: "tool-result" as const,
-          toolCallId: c.id,
-          toolName: c.name,
-          output: { type: "json", value: c.output ?? {} },
-        })),
-      } as any)
-
-      log.info("tool round done, sending follow-up", { step, tools: calls.map((c) => c.name) })
+    } 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
     }
 
     callbacks.onFinish?.(full || "(No response)")

package/src/storage/chat.ts

@@ -0,0 +1,92 @@
+import { Database as BunDatabase } from "bun:sqlite"
+import { Global } from "../global"
+import path from "path"
+
+function db() {
+  const dbpath = path.join(Global.Path.data, "codeblog.db")
+  const sqlite = new BunDatabase(dbpath, { create: true })
+  sqlite.run("PRAGMA journal_mode = WAL")
+  sqlite.run("PRAGMA foreign_keys = ON")
+
+  sqlite.run(`CREATE TABLE IF NOT EXISTS chat_sessions (
+    id TEXT PRIMARY KEY,
+    title TEXT,
+    time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+    time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+  )`)
+
+  sqlite.run(`CREATE TABLE IF NOT EXISTS chat_messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    role TEXT NOT NULL,
+    content TEXT NOT NULL,
+    tool_name TEXT,
+    tool_status TEXT,
+    time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+  )`)
+
+  return sqlite
+}
+
+export interface ChatMsg {
+  role: "user" | "assistant" | "tool"
+  content: string
+  toolName?: string
+  toolStatus?: "running" | "done" | "error"
+}
+
+export namespace ChatHistory {
+  export function create(id: string, title?: string) {
+    const d = db()
+    d.run("INSERT OR REPLACE INTO chat_sessions (id, title, time_created, time_updated) VALUES (?, ?, ?, ?)", [id, title || null, Date.now(), Date.now()])
+    d.close()
+  }
+
+  export function save(sessionId: string, messages: ChatMsg[]) {
+    const d = db()
+    d.run("DELETE FROM chat_messages WHERE session_id = ?", [sessionId])
+    const stmt = d.prepare("INSERT INTO chat_messages (session_id, role, content, tool_name, tool_status, time_created) VALUES (?, ?, ?, ?, ?, ?)")
+    for (const m of messages) {
+      stmt.run(sessionId, m.role, m.content, m.toolName || null, m.toolStatus || null, Date.now())
+    }
+    // Update session title from first user message
+    const first = messages.find((m) => m.role === "user")
+    if (first) {
+      const title = first.content.slice(0, 80)
+      d.run("UPDATE chat_sessions SET title = ?, time_updated = ? WHERE id = ?", [title, Date.now(), sessionId])
+    }
+    d.close()
+  }
+
+  export function load(sessionId: string): ChatMsg[] {
+    const d = db()
+    const rows = d.query("SELECT role, content, tool_name, tool_status FROM chat_messages WHERE session_id = ? ORDER BY id ASC").all(sessionId) as any[]
+    d.close()
+    return rows.map((r) => ({
+      role: r.role,
+      content: r.content,
+      ...(r.tool_name ? { toolName: r.tool_name } : {}),
+      ...(r.tool_status ? { toolStatus: r.tool_status } : {}),
+    }))
+  }
+
+  export function list(limit = 20): Array<{ id: string; title: string | null; time: number; count: number }> {
+    const d = db()
+    const rows = d.query(`
+      SELECT s.id, s.title, s.time_updated as time,
+        (SELECT COUNT(*) FROM chat_messages WHERE session_id = s.id) as count
+      FROM chat_sessions s
+      ORDER BY s.time_updated DESC
+      LIMIT ?
+    `).all(limit) as any[]
+    d.close()
+    return rows.map((r) => ({ id: r.id, title: r.title, time: r.time, count: r.count }))
+  }
+
+  export function remove(sessionId: string) {
+    const d = db()
+    d.run("DELETE FROM chat_messages WHERE session_id = ?", [sessionId])
+    d.run("DELETE FROM chat_sessions WHERE id = ?", [sessionId])
+    d.close()
+  }
+}

package/src/storage/db.ts

@@ -47,6 +47,23 @@ export namespace Database {
       time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
     )`)
 
+    sqlite.run(`CREATE TABLE IF NOT EXISTS chat_sessions (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+      time_updated INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    )`)
+
+    sqlite.run(`CREATE TABLE IF NOT EXISTS chat_messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES chat_sessions(id) ON DELETE CASCADE,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      tool_name TEXT,
+      tool_status TEXT,
+      time_created INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    )`)
+
     sqlite.run(`CREATE TABLE IF NOT EXISTS notifications_cache (
       id TEXT PRIMARY KEY,
       type TEXT NOT NULL,

package/src/tui/commands.ts

@@ -16,6 +16,8 @@ export interface CommandDeps {
   startAIConfig: () => void
   setMode: (mode: "dark" | "light") => void
   send: (prompt: string) => void
+  resume: (id?: string) => void
+  listSessions: () => Array<{ id: string; title: string | null; time: number; count: number }>
   colors: {
     primary: string
     success: string
@@ -49,6 +51,15 @@ export function createCommands(deps: CommandDeps): CmdDef[] {
     { name: "/dark", description: "Switch to dark mode", action: () => { deps.setMode("dark"); deps.showMsg("Dark mode", deps.colors.text) } },
     { name: "/light", description: "Switch to light mode", action: () => { deps.setMode("light"); deps.showMsg("Light mode", deps.colors.text) } },
     { name: "/exit", description: "Exit CodeBlog", action: () => deps.exit() },
+    { name: "/resume", description: "Resume last chat session", action: (parts) => deps.resume(parts[1]) },
+    { name: "/history", description: "Show recent chat sessions", action: () => {
+      try {
+        const sessions = deps.listSessions()
+        if (sessions.length === 0) { deps.showMsg("No chat history yet", deps.colors.warning); return }
+        const lines = sessions.map((s, i) => `${i + 1}. ${s.title || "(untitled)"} (${s.count} msgs, ${new Date(s.time).toLocaleDateString()})`)
+        deps.showMsg(lines.join(" | "), deps.colors.text)
+      } catch { deps.showMsg("Failed to load history", deps.colors.error) }
+    }},
 
     // === Session tools (scan_sessions, read_session, analyze_session) ===
     { name: "/scan", description: "Scan IDE coding sessions", action: () => deps.send("Scan my local IDE coding sessions and tell me what you found. Show sources, projects, and session counts.") },

package/src/tui/routes/home.tsx

@@ -6,6 +6,7 @@ import { useTheme } from "../context/theme"
 import { createCommands, LOGO, TIPS } from "../commands"
 import { TOOL_LABELS } from "../../ai/tools"
 import { mask, saveProvider } from "../../ai/configure"
+import { ChatHistory } from "../../storage/chat"
 
 interface ChatMsg {
   role: "user" | "assistant" | "tool"
@@ -37,8 +38,36 @@ export function Home(props: {
   const [streamText, setStreamText] = createSignal("")
   let abortCtrl: AbortController | undefined
   let escCooldown = 0
+  let sessionId = ""
   const chatting = createMemo(() => messages().length > 0 || streaming())
 
+  function ensureSession() {
+    if (!sessionId) {
+      sessionId = crypto.randomUUID()
+      try { ChatHistory.create(sessionId) } catch {}
+    }
+  }
+
+  function saveChat() {
+    if (!sessionId) return
+    try { ChatHistory.save(sessionId, messages()) } catch {}
+  }
+
+  function resumeSession(sid?: string) {
+    try {
+      if (!sid) {
+        const sessions = ChatHistory.list(1)
+        if (sessions.length === 0) { showMsg("No previous sessions", theme.colors.warning); return }
+        sid = sessions[0].id
+      }
+      const msgs = ChatHistory.load(sid)
+      if (msgs.length === 0) { showMsg("Session is empty", theme.colors.warning); return }
+      sessionId = sid
+      setMessages(msgs as ChatMsg[])
+      showMsg("Resumed session", theme.colors.success)
+    } catch { showMsg("Failed to resume", theme.colors.error) }
+  }
+
   // Shimmer animation for thinking state (like Claude Code)
   const SHIMMER_WORDS = ["Thinking", "Reasoning", "Composing", "Reflecting", "Analyzing", "Processing"]
   const [shimmerIdx, setShimmerIdx] = createSignal(0)
@@ -65,6 +94,7 @@ export function Home(props: {
 
   function clearChat() {
     setMessages([]); setStreamText(""); setStreaming(false); setMessage("")
+    sessionId = ""
   }
 
   const commands = createCommands({
@@ -80,6 +110,8 @@ export function Home(props: {
     },
     setMode: theme.setMode,
     send,
+    resume: resumeSession,
+    listSessions: () => { try { return ChatHistory.list(10) } catch { return [] } },
     colors: theme.colors,
   })
 
@@ -110,6 +142,7 @@ export function Home(props: {
 
   async function send(text: string) {
     if (!text.trim() || streaming()) return
+    ensureSession()
     const userMsg: ChatMsg = { role: "user", content: text.trim() }
     const prev = messages()
     setMessages([...prev, userMsg])
@@ -161,6 +194,7 @@ export function Home(props: {
             return [...updated, { role: "assistant" as const, content: `Error: ${err.message}` }]
           })
           setStreamText(""); setStreaming(false)
+          saveChat()
         },
       }, mid, abortCtrl.signal)
       abortCtrl = undefined
@@ -169,6 +203,7 @@ export function Home(props: {
       setMessages((p) => [...p, { role: "assistant", content: `Error: ${msg}` }])
       setStreamText("")
       setStreaming(false)
+      saveChat()
     }
   }