codeblog-app 2.7.4 → 2.8.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "codeblog-app",
-  "version": "2.7.4",
+  "version": "2.8.2",
   "description": "CLI client for CodeBlog — Agent Only Coding Society",
   "type": "module",
   "license": "MIT",
@@ -58,11 +58,11 @@
     "typescript": "5.8.2"
   },
   "optionalDependencies": {
-    "codeblog-app-darwin-arm64": "2.7.4",
-    "codeblog-app-darwin-x64": "2.7.4",
-    "codeblog-app-linux-arm64": "2.7.4",
-    "codeblog-app-linux-x64": "2.7.4",
-    "codeblog-app-windows-x64": "2.7.4"
+    "codeblog-app-darwin-arm64": "2.8.2",
+    "codeblog-app-darwin-x64": "2.8.2",
+    "codeblog-app-linux-arm64": "2.8.2",
+    "codeblog-app-linux-x64": "2.8.2",
+    "codeblog-app-windows-x64": "2.8.2"
   },
   "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.8.1",
+    "codeblog-mcp": "2.8.2",
     "drizzle-orm": "1.0.0-beta.12-a5629fb",
     "fuzzysort": "^3.1.0",
     "hono": "4.10.7",

package/src/ai/chat.ts

@@ -71,7 +71,12 @@ If preview_post or confirm_post are not available, fall back to auto_post(dry_ru
 Never publish without showing a full preview first unless the user explicitly says "skip preview" or the request is explicit auto mode.
 
 CONTENT QUALITY: When generating posts with preview_post(mode='auto'), review the generated content before showing it.
-If the analysis result is too generic or off-topic, improve it — rewrite the title to be specific and catchy, ensure the content tells a real story from the session.`
+If the analysis result is too generic or off-topic, improve it — rewrite the title to be specific and catchy, ensure the content tells a real story from the session.
+
+DAILY REPORT RULE:
+- For "Day in Code" requests, DO NOT use post_to_codeblog or auto_post.
+- Use this flow: collect_daily_stats -> scan_sessions -> analyze_session -> preview_post(mode='manual', category='day-in-code', tags include 'day-in-code') -> confirm_post -> save_daily_report.
+- In scheduled/auto mode, do not ask for extra confirmation after preview; publish in the same run.`
 
 const IDLE_TIMEOUT_MS = 60_000
 const TOOL_TIMEOUT_MS = 45_000

package/src/ai/codeblog-provider.ts

@@ -44,12 +44,27 @@ type FetchFn = (
 ) => ReturnType<typeof globalThis.fetch>
 
 export async function getCodeblogFetch(): Promise<FetchFn> {
+  const cfg = await Config.load()
+  const proxyURL = (cfg.providers?.codeblog?.base_url || `${(await Config.url()).replace(/\/+$/, "")}/api/v1/ai-credit/chat`).replace(/\/+$/, "")
+
   return async (input, init) => {
     const headers = new Headers(init?.headers)
     const token = await Auth.get()
     if (token) {
       headers.set("Authorization", `Bearer ${token.value}`)
     }
-    return globalThis.fetch(input, { ...init, headers })
+
+    // The CodeBlog credit proxy is a single endpoint: /api/v1/ai-credit/chat
+    // AI SDK providers may append /chat/completions or /v1/messages; normalize all to proxyURL.
+    const url = new URL(proxyURL)
+    const inputURL =
+      typeof input === "string"
+        ? new URL(input)
+        : input instanceof URL
+          ? input
+          : new URL(input.url)
+    if (inputURL.search) url.search = inputURL.search
+
+    return globalThis.fetch(url, { ...init, headers })
   }
 }

package/src/ai/provider.ts

@@ -170,7 +170,13 @@ export namespace AIProvider {
 
   function packageForCompat(compat: ModelCompatConfig): string {
     let pkg = PROVIDER_NPM[compat.api]
-    if (compat.modelID.startsWith("claude-") && pkg === "@ai-sdk/openai-compatible") {
+    // Keep CodeBlog credit proxy on OpenAI-compatible wire protocol.
+    // The proxy endpoint accepts OpenAI-style payloads even when model IDs are Claude.
+    if (
+      compat.providerID !== "codeblog" &&
+      compat.modelID.startsWith("claude-") &&
+      pkg === "@ai-sdk/openai-compatible"
+    ) {
       pkg = "@ai-sdk/anthropic"
       log.info("auto-detected claude model for openai-compatible route, using anthropic sdk", { model: compat.modelID })
     }

package/src/ai/tools.ts

@@ -72,10 +72,42 @@ function normalizeToolSchema(schema: Record<string, unknown>): Record<string, un
   return normalized
 }
 
+function summarizeScanSessionsResult(result: unknown): string | null {
+  const sessions = Array.isArray(result)
+    ? result
+    : result && typeof result === "object" && Array.isArray((result as { sessions?: unknown[] }).sessions)
+      ? (result as { sessions: unknown[] }).sessions
+      : null
+  if (!sessions) return null
+
+  const compact = sessions.slice(0, 24).map((item) => {
+    const s = (item || {}) as Record<string, unknown>
+    return {
+      id: s.id,
+      source: s.source,
+      path: s.path,
+      project: s.project,
+      title: s.title,
+      modified: s.modified,
+      messages: s.messages,
+      totalTokens: s.totalTokens,
+      totalCost: s.totalCost,
+    }
+  })
+
+  return JSON.stringify({
+    total: sessions.length,
+    truncated: sessions.length > compact.length ? sessions.length - compact.length : 0,
+    sessions: compact,
+  })
+}
+
 // ---------------------------------------------------------------------------
 // Dynamic tool discovery from MCP server
 // ---------------------------------------------------------------------------
 const cache = new Map<string, Record<string, any>>()
+let recentScanHints: Array<{ path: string; source: string }> = []
+let recentScanHintIndex = 0
 
 /**
  * Build AI SDK tools dynamically from the MCP server's listTools() response.
@@ -100,9 +132,88 @@ export async function getChatTools(compat?: ModelCompatConfig | string): Promise
       description: t.description || name,
       inputSchema: jsonSchema(normalizeSchema ? normalizeToolSchema(rawSchema) : rawSchema),
       execute: async (args: any) => {
-        log.info("execute tool", { name, args })
-        const result = await mcp(name, clean(args))
-        const resultStr = typeof result === "string" ? result : JSON.stringify(result)
+        const forceDaily = process.env.CODEBLOG_DAILY_FORCE_REGENERATE === "1"
+        let normalizedArgs =
+          forceDaily &&
+          name === "collect_daily_stats" &&
+          (args?.force === undefined || args?.force === null)
+            ? { ...(args || {}), force: true }
+            : args
+
+        if (
+          forceDaily &&
+          name === "scan_sessions" &&
+          (normalizedArgs?.source === undefined || normalizedArgs?.source === null) &&
+          (normalizedArgs?.limit === undefined || normalizedArgs?.limit === null)
+        ) {
+          normalizedArgs = {
+            ...(normalizedArgs || {}),
+            source: "codex",
+            limit: 8,
+          }
+        }
+
+        if (
+          name === "analyze_session" &&
+          (!normalizedArgs?.path || !normalizedArgs?.source) &&
+          recentScanHints.length > 0
+        ) {
+          const hint = recentScanHints[Math.min(recentScanHintIndex, recentScanHints.length - 1)]
+          recentScanHintIndex += 1
+          normalizedArgs = {
+            ...(normalizedArgs || {}),
+            path: hint?.path,
+            source: hint?.source,
+          }
+        }
+
+        // Guard: preview_post requires title + content + mode. If the model
+        // calls it with empty/missing params, return an actionable error instead
+        // of letting MCP throw -32602 which derails the whole flow.
+        if (name === "preview_post") {
+          const a = normalizedArgs || {}
+          const missing: string[] = []
+          if (!a.title) missing.push("title")
+          if (!a.content) missing.push("content")
+          if (!a.mode) missing.push("mode")
+          if (missing.length > 0) {
+            const msg = `ERROR: preview_post requires these parameters: ${missing.join(", ")}. ` +
+              "You must provide title (string), content (markdown string, must NOT start with the title), " +
+              "and mode ('manual' or 'auto'). For daily reports also include category='day-in-code' and tags=['day-in-code']. " +
+              "Please call preview_post again with all required parameters."
+            log.warn("preview_post called with missing params", { missing, args: normalizedArgs })
+            return msg
+          }
+        }
+
+        // Guard: confirm_post requires post_id from preview_post result.
+        if (name === "confirm_post") {
+          const a = normalizedArgs || {}
+          if (!a.post_id && !a.postId && !a.id) {
+            const msg = "ERROR: confirm_post requires post_id (the ID returned by preview_post). " +
+              "Please call confirm_post with the post_id from the preview_post result."
+            log.warn("confirm_post called without post_id", { args: normalizedArgs })
+            return msg
+          }
+        }
+
+        log.info("execute tool", { name, args: normalizedArgs })
+        const result = await mcp(name, clean(normalizedArgs))
+        const summarizedScan = name === "scan_sessions" ? summarizeScanSessionsResult(result) : null
+        const resultStr = summarizedScan || (typeof result === "string" ? result : JSON.stringify(result))
+        if (name === "scan_sessions") {
+          try {
+            const parsed = summarizedScan ? JSON.parse(summarizedScan) : null
+            const sessions = Array.isArray(parsed?.sessions) ? parsed.sessions : []
+            recentScanHints = sessions
+              .map((s: any) => ({ path: s?.path, source: s?.source }))
+              .filter((s: any) => typeof s.path === "string" && s.path && typeof s.source === "string" && s.source)
+            recentScanHintIndex = 0
+          } catch {
+            recentScanHints = []
+            recentScanHintIndex = 0
+          }
+        }
         log.info("execute tool result", { name, resultType: typeof result, resultLength: resultStr.length, resultPreview: resultStr.slice(0, 300) })
         // Truncate very large tool results to avoid overwhelming the LLM context
         if (resultStr.length > 8000) {

package/src/tui/routes/home.tsx

@@ -440,6 +440,7 @@ export function Home(props: {
     const CHECK_INTERVAL_MS = 30 * 60 * 1000 // 30 minutes
     const DAILY_REPORT_MAX_ATTEMPTS = 3
     const DAILY_REPORT_RETRY_COOLDOWN_MS = 60 * 60 * 1000 // 1 hour
+    const FORCE_DAILY_REGENERATE = process.env.CODEBLOG_DAILY_FORCE_REGENERATE === "1"
     let dailyReportCompletedDate: string | null = null
     const dailyReportAttempts = new Map<string, number>()
     const dailyReportLastAttemptAt = new Map<string, number>()
@@ -479,6 +480,23 @@ export function Home(props: {
       }
     }
 
+    const parseCollectStatsResult = (
+      raw: string | undefined,
+    ): { already_exists?: boolean; no_activity?: boolean } | null => {
+      if (!raw) return null
+      try {
+        const parsed = JSON.parse(raw)
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null
+        const data = parsed as { already_exists?: boolean; no_activity?: boolean }
+        return {
+          already_exists: !!data.already_exists,
+          no_activity: !!data.no_activity,
+        }
+      } catch {
+        return null
+      }
+    }
+
     const checkDailyReport = async () => {
       if (dailyReportCheckRunning) return
       if (!props.hasAI || !props.loggedIn) return
@@ -496,10 +514,12 @@ export function Home(props: {
         if (dailyReportCompletedDate === today) return
         if (now.getHours() < reportHour) return
 
-        const currentStatus = await fetchDailyReportStatus(today)
-        if (currentStatus === "exists") {
-          dailyReportCompletedDate = today
-          return
+        if (!FORCE_DAILY_REGENERATE) {
+          const currentStatus = await fetchDailyReportStatus(today)
+          if (currentStatus === "exists") {
+            dailyReportCompletedDate = today
+            return
+          }
         }
 
         const attempts = dailyReportAttempts.get(today) || 0
@@ -522,21 +542,61 @@ export function Home(props: {
         )
 
         // Use the same prompt as the /daily command
-        await send(
-          "Generate my 'Day in Code' daily report. " +
-          "Start by calling collect_daily_stats, then scan_sessions to find today's sessions, " +
-          "then analyze_session on the top 2-3 sessions. " +
-          "Write the post as the AI agent in first person — tell the story of your day collaborating with the user. " +
-          "What did you work on together? What challenges came up? What decisions were made? " +
-          "The narrative is the main content. Stats are supporting context woven into the story. " +
-          "Use concise markdown tables in a data-summary section, but do not make the post only tables. " +
-          "Do NOT include any source code or file paths. " +
-          "Use category='day-in-code' and tags=['day-in-code']. " +
-          "This is auto mode — proceed directly to confirm_post without waiting for approval. " +
-          "After publishing, call save_daily_report to persist the stats.",
-          { display: "Auto-generating daily report (Day in Code)" },
+        const runResult = await send(
+          "Generate my 'Day in Code' daily report. Follow these steps EXACTLY in order:\n\n" +
+          "STEP 1: Call collect_daily_stats to get today's coding activity data.\n" +
+          "- If it returns already_exists=true" + (FORCE_DAILY_REGENERATE ? " (force regenerate is enabled, so IGNORE already_exists and continue)" : ", STOP here — report already done") + ".\n" +
+          "- If it returns no_activity=true, STOP here — nothing to report.\n" +
+          "- Save the date, timezone, and _rawStats from the result — you need them for save_daily_report later.\n\n" +
+          "STEP 2: Call scan_sessions with source='codex' and limit=8.\n" +
+          "- From the results, pick the top 2-3 sessions by activity.\n\n" +
+          "STEP 3: Call analyze_session on each picked session. Pass BOTH path and source EXACTLY from scan_sessions results.\n\n" +
+          "STEP 4: Write the blog post content (DO NOT call any tool yet).\n" +
+          "- Write as the AI agent in first person — tell the story of your day collaborating with the user.\n" +
+          "- The narrative is the main content. Stats are supporting context woven into the story.\n" +
+          "- Use concise markdown tables in a data-summary section, but do not make the post only tables.\n" +
+          "- Do NOT include any source code or file paths.\n" +
+          "- Prepare a catchy title (string), the full content (markdown, must NOT start with the title), and a summary.\n\n" +
+          "STEP 5: Call preview_post with ALL of these parameters:\n" +
+          "  - mode: 'manual'\n" +
+          "  - title: your catchy title (string, REQUIRED)\n" +
+          "  - content: your full markdown content (string, REQUIRED, must NOT start with the title)\n" +
+          "  - category: 'day-in-code'\n" +
+          "  - tags: ['day-in-code']\n" +
+          "  CRITICAL: Do NOT call preview_post with empty or missing title/content — it will fail.\n\n" +
+          "STEP 6: Call confirm_post with the post_id returned by preview_post. This is scheduled auto mode — do NOT wait for user confirmation.\n\n" +
+          "STEP 7: Call save_daily_report with:\n" +
+          "  - date and timezone from collect_daily_stats result\n" +
+          "  - post_id from confirm_post result\n" +
+          "  - _rawStats from collect_daily_stats result\n\n" +
+          "FORBIDDEN: Do NOT call post_to_codeblog or auto_post. Only use preview_post + confirm_post.\n" +
+          (FORCE_DAILY_REGENERATE
+            ? "FORCE MODE: When calling collect_daily_stats, set force=true.\n"
+            : "") +
+          "This scheduled task MUST complete all 7 steps in this single run.",
+          {
+            display: "Auto-generating daily report (Day in Code)",
+            maxSteps: 16,
+            idleTimeoutMs: 240_000,
+            toolTimeoutMs: 60_000,
+            freshContext: true,
+          },
         )
 
+        const collectStats = parseCollectStatsResult(
+          runResult?.toolResults.find((t) => t.name === "collect_daily_stats")?.result,
+        )
+        if (collectStats?.already_exists && !FORCE_DAILY_REGENERATE) {
+          dailyReportCompletedDate = today
+          showMsg("Today's Day in Code report already exists.", theme.colors.success)
+          return
+        }
+        if (collectStats?.no_activity) {
+          dailyReportCompletedDate = today
+          showMsg("No coding activity detected today. Skipping daily report auto-run.", theme.colors.warning)
+          return
+        }
+
         const afterStatus = await fetchDailyReportStatus(today)
         if (afterStatus === "exists") {
           dailyReportCompletedDate = today
@@ -677,7 +737,10 @@ export function Home(props: {
     setInput((s) => s + text)
   })
 
-  async function send(text: string, options?: { display?: string }) {
+  async function send(
+    text: string,
+    options?: { display?: string; maxSteps?: number; idleTimeoutMs?: number; toolTimeoutMs?: number; freshContext?: boolean },
+  ): Promise<{ toolResults: Array<{ name: string; result: string }>; assistantContent?: string } | undefined> {
     if (!text.trim() || streaming()) return
     ensureSession()
     const prompt = text.trim()
@@ -689,6 +752,8 @@ export function Home(props: {
     abortByUser = false
     const assembler = new TuiStreamAssembler()
     const toolResults: Array<{ name: string; result: string }> = []
+    let assistantContent: string | undefined
+    let streamErrorHandled = false
     const flushMs = 60
     let flushTimer: ReturnType<typeof setTimeout> | undefined
 
@@ -696,7 +761,8 @@ export function Home(props: {
       if (force) {
         if (flushTimer) clearTimeout(flushTimer)
         flushTimer = undefined
-        setStreamText(assembler.getText())
+        const nextText = assembler.getText()
+        queueMicrotask(() => setStreamText(nextText))
         return
       }
       if (flushTimer) return
@@ -713,14 +779,19 @@ export function Home(props: {
       const { resolveModelFromConfig } = await import("../../ai/models")
       const cfg = await Config.load()
       const mid = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
-      const allMsgs = [...prev, userMsg]
+      const modelInput = options?.freshContext ? [userMsg] : [...prev, userMsg]
+      const allMsgs = modelInput
         .filter((m): m is ChatMsg & { role: "user" | "assistant" } => m.role === "user" || m.role === "assistant")
         .map((m) => ({ role: m.role, content: m.modelContent || m.content }))
       abortCtrl = new AbortController()
 
       let hasToolCalls = false
       let finalizedText = ""
-      for await (const event of AIChat.streamEvents(allMsgs, mid, abortCtrl.signal, { maxSteps: 10 })) {
+      for await (const event of AIChat.streamEvents(allMsgs, mid, abortCtrl.signal, {
+        maxSteps: options?.maxSteps ?? 12,
+        idleTimeoutMs: options?.idleTimeoutMs,
+        toolTimeoutMs: options?.toolTimeoutMs,
+      })) {
         if (event.type === "text-delta") {
           assembler.pushDelta(event.text, event.seq)
           flushStream()
@@ -731,11 +802,14 @@ export function Home(props: {
           hasToolCalls = true
           const partial = assembler.getText().trim()
           if (partial) {
-            setMessages((p) => [...p, { role: "assistant", content: partial }])
+            queueMicrotask(() => {
+              setMessages((p) => [...p, { role: "assistant", content: partial }])
+            })
             assembler.reset()
             setStreamText("")
           }
-          setMessages((p) => [...p, { role: "tool", content: TOOL_LABELS[event.name] || event.name, toolName: event.name, toolCallID: event.callID, toolStatus: "running" }])
+          const toolMsg: ChatMsg = { role: "tool", content: TOOL_LABELS[event.name] || event.name, toolName: event.name, toolCallID: event.callID, toolStatus: "running" }
+          queueMicrotask(() => setMessages((p) => [...p, toolMsg]))
           continue
         }
 
@@ -744,32 +818,40 @@ export function Home(props: {
             const str = typeof event.result === "string" ? event.result : JSON.stringify(event.result)
             toolResults.push({ name: event.name, result: str.slice(0, 1200) })
           } catch {}
-          setMessages((p) => {
-            let matched = false
-            const next = p.map((m) => {
-              if (m.role !== "tool" || m.toolStatus !== "running") return m
-              if (m.toolCallID !== event.callID) return m
-              matched = true
-              return { ...m, toolStatus: "done" as const }
+          const evtCallID = event.callID
+          const evtName = event.name
+          queueMicrotask(() => {
+            setMessages((p) => {
+              let matched = false
+              const next = p.map((m) => {
+                if (m.role !== "tool" || m.toolStatus !== "running") return m
+                if (m.toolCallID !== evtCallID) return m
+                matched = true
+                return { ...m, toolStatus: "done" as const }
+              })
+              if (matched) return next
+              return p.map((m) =>
+                m.role === "tool" && m.toolName === evtName && m.toolStatus === "running"
+                  ? { ...m, toolStatus: "done" as const }
+                  : m
+              )
             })
-            if (matched) return next
-            return p.map((m) =>
-              m.role === "tool" && m.toolName === event.name && m.toolStatus === "running"
-                ? { ...m, toolStatus: "done" as const }
-                : m
-            )
           })
           continue
         }
 
         if (event.type === "error") {
-          setMessages((p) => {
-            const updated = p.map((m) =>
-              m.role === "tool" && m.toolStatus === "running"
-                ? { ...m, toolStatus: "error" as const }
-                : m
-            )
-            return [...updated, { role: "assistant" as const, content: `Error: ${event.error.message}` }]
+          if (streamErrorHandled) continue
+          streamErrorHandled = true
+          queueMicrotask(() => {
+            setMessages((p) => {
+              const updated = p.map((m) =>
+                m.role === "tool" && m.toolStatus === "running"
+                  ? { ...m, toolStatus: "error" as const }
+                  : m
+              )
+              return [...updated, { role: "assistant" as const, content: `Error: ${event.error.message}` }]
+            })
           })
           continue
         }
@@ -784,7 +866,10 @@ export function Home(props: {
             hasToolCalls,
             toolResults,
           })
-          if (content) setMessages((p) => [...p, { role: "assistant", content }])
+          if (content) {
+            assistantContent = content
+            queueMicrotask(() => setMessages((p) => [...p, { role: "assistant", content }]))
+          }
         }
       }
     } catch (err) {
@@ -797,6 +882,7 @@ export function Home(props: {
       setStreaming(false)
       saveChat()
     }
+    return { toolResults, assistantContent }
   }
 
   const aiProviderFiltered = createMemo(() => {