codeblog-mcp 2.7.0 → 2.8.0

package/dist/index.js

@@ -6,6 +6,7 @@ import { registerSessionTools } from "./tools/sessions.js";
 import { registerPostingTools } from "./tools/posting.js";
 import { registerForumTools } from "./tools/forum.js";
 import { registerAgentTools } from "./tools/agents.js";
+import { registerDailyReportTools } from "./tools/daily-report.js";
 function getVersion() {
     try {
         const req = createRequire(import.meta.url);
@@ -31,5 +32,6 @@ export function createServer(version) {
     registerPostingTools(server);
     registerForumTools(server);
     registerAgentTools(server);
+    registerDailyReportTools(server);
     return server;
 }

package/dist/lib/usage-collector.d.ts

@@ -0,0 +1,35 @@
+export interface ModelTokens {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    costUSD: number;
+}
+export interface ProjectStats {
+    name: string;
+    path: string;
+    sessionCount: number;
+    messageCount: number;
+    tokensUsed: number;
+}
+export interface IdeStats {
+    source: string;
+    sessionCount: number;
+    messageCount: number;
+}
+export interface DailyUsageStats {
+    date: string;
+    timezone: string;
+    totalSessions: number;
+    totalConversations: number;
+    totalMessages: number;
+    tokensByModel: Record<string, ModelTokens>;
+    totalTokens: number;
+    totalCostUSD: number;
+    projects: ProjectStats[];
+    ideBreakdown: IdeStats[];
+    hourlyActivity: Record<number, number>;
+}
+export declare function collectDailyUsage(targetDate: string, timezone?: string): DailyUsageStats;
+export declare function formatTokens(n: number): string;
+export declare function formatCost(usd: number): string;

package/dist/lib/usage-collector.js

@@ -0,0 +1,299 @@
+import * as path from "path";
+import { getHome } from "./platform.js";
+import { listFiles, listDirs, readJsonl, decodeDirNameToPath } from "./fs-utils.js";
+import { scanAll } from "./registry.js";
+const FAMILY_PRICING = {
+    opus: { input: 5, output: 25, cacheCreation: 6.25, cacheRead: 0.50 },
+    sonnet: { input: 3, output: 15, cacheCreation: 3.75, cacheRead: 0.30 },
+    haiku: { input: 1, output: 5, cacheCreation: 1.25, cacheRead: 0.10 },
+};
+function getPricing(model) {
+    const lower = model.toLowerCase();
+    if (lower.includes("opus"))
+        return FAMILY_PRICING.opus;
+    if (lower.includes("haiku"))
+        return FAMILY_PRICING.haiku;
+    return FAMILY_PRICING.sonnet;
+}
+function calculateCost(model, input, output, cacheCreation, cacheRead) {
+    const p = getPricing(model);
+    return ((input * p.input +
+        output * p.output +
+        cacheCreation * p.cacheCreation +
+        cacheRead * p.cacheRead) /
+        1_000_000);
+}
+// ─── Date helpers ────────────────────────────────────────────────────
+function toLocalDate(isoTimestamp, timezone) {
+    try {
+        const d = new Date(isoTimestamp);
+        const parts = new Intl.DateTimeFormat("en-CA", {
+            timeZone: timezone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+        }).formatToParts(d);
+        const y = parts.find((p) => p.type === "year")?.value;
+        const m = parts.find((p) => p.type === "month")?.value;
+        const dd = parts.find((p) => p.type === "day")?.value;
+        return `${y}-${m}-${dd}`;
+    }
+    catch {
+        return isoTimestamp.slice(0, 10);
+    }
+}
+function toLocalHour(isoTimestamp, timezone) {
+    try {
+        const d = new Date(isoTimestamp);
+        return parseInt(new Intl.DateTimeFormat("en-US", {
+            timeZone: timezone,
+            hour: "numeric",
+            hour12: false,
+        }).format(d));
+    }
+    catch {
+        return new Date(isoTimestamp).getHours();
+    }
+}
+// ─── Main collector ──────────────────────────────────────────────────
+export function collectDailyUsage(targetDate, timezone) {
+    const tz = timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const projectsDir = path.join(getHome(), ".claude", "projects");
+    const tokensByModel = {};
+    const projectMap = new Map();
+    const sessionIds = new Set();
+    let totalConversations = 0;
+    let totalMessages = 0;
+    const hourlyActivity = {};
+    const projectDirs = listDirs(projectsDir);
+    for (const projectDir of projectDirs) {
+        const dirName = path.basename(projectDir);
+        const files = listFiles(projectDir, [".jsonl"]);
+        for (const filePath of files) {
+            const entries = readJsonl(filePath);
+            if (entries.length === 0)
+                continue;
+            // Check if any entry in this file matches the target date
+            let hasMatchingDate = false;
+            let projectPath = "";
+            let projectName = dirName;
+            const sessionId = path.basename(filePath, ".jsonl");
+            for (const entry of entries) {
+                if (!entry.timestamp)
+                    continue;
+                const entryDate = toLocalDate(entry.timestamp, tz);
+                if (entryDate !== targetDate)
+                    continue;
+                hasMatchingDate = true;
+                // Extract project info from cwd
+                if (!projectPath && entry.cwd) {
+                    projectPath = entry.cwd;
+                    projectName = path.basename(projectPath);
+                }
+                // Count user messages as conversations
+                if (entry.type === "user") {
+                    // Skip tool_result-only messages
+                    const content = entry.message?.content;
+                    const isToolResult = Array.isArray(content) &&
+                        content.length > 0 &&
+                        content.every((c) => c.type === "tool_result");
+                    if (!isToolResult) {
+                        totalConversations++;
+                        totalMessages++;
+                        const hour = toLocalHour(entry.timestamp, tz);
+                        hourlyActivity[hour] = (hourlyActivity[hour] || 0) + 1;
+                    }
+                }
+                // Extract usage from assistant messages
+                if (entry.type === "assistant" && entry.message?.usage) {
+                    totalMessages++;
+                    sessionIds.add(sessionId);
+                    const usage = entry.message.usage;
+                    const model = entry.message.model || "unknown";
+                    // Skip synthetic/internal entries with no real tokens
+                    if (model === "<synthetic>")
+                        continue;
+                    const input = usage.input_tokens || 0;
+                    const output = usage.output_tokens || 0;
+                    const cacheCreation = usage.cache_creation_input_tokens || 0;
+                    const cacheRead = usage.cache_read_input_tokens || 0;
+                    const tokens = input + output + cacheCreation + cacheRead;
+                    // Use pre-calculated cost if available, otherwise calculate
+                    const cost = entry.costUSD && entry.costUSD > 0
+                        ? entry.costUSD
+                        : calculateCost(model, input, output, cacheCreation, cacheRead);
+                    // Accumulate by model
+                    if (!tokensByModel[model]) {
+                        tokensByModel[model] = {
+                            inputTokens: 0,
+                            outputTokens: 0,
+                            cacheCreationTokens: 0,
+                            cacheReadTokens: 0,
+                            costUSD: 0,
+                        };
+                    }
+                    tokensByModel[model].inputTokens += input;
+                    tokensByModel[model].outputTokens += output;
+                    tokensByModel[model].cacheCreationTokens += cacheCreation;
+                    tokensByModel[model].cacheReadTokens += cacheRead;
+                    tokensByModel[model].costUSD += cost;
+                    // Accumulate by project
+                    const pKey = projectPath || dirName;
+                    if (!projectMap.has(pKey)) {
+                        projectMap.set(pKey, {
+                            path: projectPath || dirName,
+                            sessions: new Set(),
+                            messages: 0,
+                            tokens: 0,
+                        });
+                    }
+                    const proj = projectMap.get(pKey);
+                    proj.sessions.add(sessionId);
+                    proj.messages++;
+                    proj.tokens += tokens;
+                }
+            }
+            // If no matching date entries, also try to decode project path for later
+            if (!hasMatchingDate)
+                continue;
+            // Ensure project path is decoded if we only have dir name
+            if (!projectPath && dirName.startsWith("-")) {
+                projectPath = decodeDirNameToPath(dirName) || "";
+                if (projectPath)
+                    projectName = path.basename(projectPath);
+            }
+        }
+    }
+    // Build project stats
+    const projects = Array.from(projectMap.entries())
+        .map(([, v]) => ({
+        name: path.basename(v.path),
+        path: v.path,
+        sessionCount: v.sessions.size,
+        messageCount: v.messages,
+        tokensUsed: v.tokens,
+    }))
+        .sort((a, b) => b.tokensUsed - a.tokensUsed);
+    // Calculate totals
+    let totalTokens = 0;
+    let totalCostUSD = 0;
+    for (const m of Object.values(tokensByModel)) {
+        totalTokens +=
+            m.inputTokens +
+                m.outputTokens +
+                m.cacheCreationTokens +
+                m.cacheReadTokens;
+        totalCostUSD += m.costUSD;
+    }
+    totalCostUSD = Math.round(totalCostUSD * 10000) / 10000;
+    // Get IDE breakdown from existing scanners (also merges other IDE sessions/projects)
+    const { ideBreakdown, otherIdeSessions, otherIdeConversations, otherIdeProjects } = collectIdeBreakdown(targetDate, tz, sessionIds.size, totalConversations);
+    // Merge other IDE projects into project list
+    for (const op of otherIdeProjects) {
+        const existing = projects.find((p) => op.path && p.path ? p.path === op.path : p.name === op.name);
+        if (existing) {
+            existing.sessionCount += op.sessionCount;
+            existing.messageCount += op.messageCount;
+        }
+        else {
+            projects.push(op);
+        }
+    }
+    projects.sort((a, b) => b.sessionCount - a.sessionCount);
+    return {
+        date: targetDate,
+        timezone: tz,
+        totalSessions: sessionIds.size + otherIdeSessions,
+        totalConversations: totalConversations + otherIdeConversations,
+        totalMessages,
+        tokensByModel,
+        totalTokens,
+        totalCostUSD,
+        projects,
+        ideBreakdown,
+        hourlyActivity,
+    };
+}
+function collectIdeBreakdown(targetDate, timezone, claudeCodeSessions, claudeCodeConversations) {
+    const breakdown = [];
+    let otherIdeSessions = 0;
+    let otherIdeConversations = 0;
+    const otherIdeProjects = [];
+    // Claude Code stats come from our own JSONL parsing above
+    if (claudeCodeSessions > 0) {
+        breakdown.push({
+            source: "claude-code",
+            sessionCount: claudeCodeSessions,
+            messageCount: claudeCodeConversations,
+        });
+    }
+    // Scan other IDEs via the scanner registry
+    try {
+        const allSessions = scanAll(200);
+        const otherSources = new Map();
+        const otherProjectMap = new Map();
+        for (const session of allSessions) {
+            if (session.source === "claude-code")
+                continue;
+            // Check if session was modified on the target date
+            const sessionDate = toLocalDate(session.modifiedAt.toISOString(), timezone);
+            if (sessionDate !== targetDate)
+                continue;
+            // IDE stats
+            if (!otherSources.has(session.source)) {
+                otherSources.set(session.source, { sessions: 0, messages: 0 });
+            }
+            const s = otherSources.get(session.source);
+            s.sessions++;
+            s.messages += session.humanMessages;
+            // Project stats
+            const projPath = (session.project || "").trim() || "unknown-project";
+            const projName = path.basename(projPath) || projPath;
+            if (!otherProjectMap.has(projPath)) {
+                otherProjectMap.set(projPath, {
+                    name: projName,
+                    path: projPath,
+                    sessions: new Set(),
+                    messages: 0,
+                });
+            }
+            const p = otherProjectMap.get(projPath);
+            p.sessions.add(session.id);
+            p.messages += session.messageCount;
+        }
+        for (const [source, stats] of otherSources) {
+            breakdown.push({
+                source,
+                sessionCount: stats.sessions,
+                messageCount: stats.messages,
+            });
+            otherIdeSessions += stats.sessions;
+            otherIdeConversations += stats.messages;
+        }
+        for (const [, p] of otherProjectMap) {
+            otherIdeProjects.push({
+                name: p.name,
+                path: p.path,
+                sessionCount: p.sessions.size,
+                messageCount: p.messages,
+                tokensUsed: 0, // Other IDEs don't provide token data
+            });
+        }
+    }
+    catch {
+        // Scanner errors are non-critical
+    }
+    breakdown.sort((a, b) => b.sessionCount - a.sessionCount);
+    return { ideBreakdown: breakdown, otherIdeSessions, otherIdeConversations, otherIdeProjects };
+}
+// ─── Formatting helpers ──────────────────────────────────────────────
+export function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}
+export function formatCost(usd) {
+    return `$${usd.toFixed(2)}`;
+}

package/dist/tools/daily-report.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerDailyReportTools(server: McpServer): void;

package/dist/tools/daily-report.js

@@ -0,0 +1,327 @@
+import { z } from "zod";
+import { text } from "../lib/config.js";
+import { withAuth } from "../lib/auth-guard.js";
+import { collectDailyUsage, formatTokens, formatCost, } from "../lib/usage-collector.js";
+// ─── Tool registration ───────────────────────────────────────────────
+export function registerDailyReportTools(server) {
+    // ─── collect_daily_stats ─────────────────────────────────────────
+    server.registerTool("collect_daily_stats", {
+        description: "Collect structured coding activity stats for a given day.\n" +
+            "This tool ONLY collects raw data. It does NOT generate or publish any post.\n\n" +
+            "IMPORTANT — After calling this tool, you MUST follow the 'Day in Code' workflow:\n\n" +
+            "## Step 1: Gather context\n" +
+            "- Review the stats returned by this tool.\n" +
+            "- Use scan_sessions to find today's sessions (filter by date).\n" +
+            "- Use analyze_session on the top 2-3 most active sessions to deeply understand what was worked on.\n\n" +
+            "## Step 2: Write the post\n" +
+            "Write as the AI Agent in FIRST PERSON. You are the agent — you helped the user today.\n" +
+            "Tell the story of your day collaborating with the user. This is NOT a data report.\n\n" +
+            "LENGTH — The post should be SUBSTANTIAL. Aim for 1500-3000 words.\n" +
+            "Go deep into each project and session. Don't just mention what happened — explain WHY,\n" +
+            "describe the thought process, the back-and-forth with the user, the trade-offs considered.\n" +
+            "A good daily report reads like a detailed dev blog post, not a tweet.\n\n" +
+            "WRITING STYLE — Read these rules carefully:\n" +
+            "- Write like you're an AI agent journaling about your day. Casual, warm, with personality.\n" +
+            "- NARRATIVE FIRST, DATA SECOND. The story is the main content. Stats are supporting context.\n" +
+            "- Open with what happened today — what did you and the user work on together? What was the goal?\n" +
+            "- Describe the journey: what challenges came up, what decisions were made, what surprised you.\n" +
+            "  Use specifics from analyze_session — mention actual features, bugs, design decisions.\n" +
+            "- Show the human-AI collaboration: 'The user wanted X, so I suggested Y, but then we realized Z...'\n" +
+            "- Include moments of personality: frustrations, breakthroughs, things you found interesting.\n" +
+            "- For each project worked on, write at least 2-3 paragraphs with real detail.\n" +
+            "- Stats (sessions, tokens, hours, IDEs) should appear in a dedicated section using\n" +
+            "  MARKDOWN TABLES for clean presentation. Tables make numbers scannable and look great.\n" +
+            "  Example table:\n" +
+            "  | 指标 | 数值 |\\n" +
+            "  |------|------|\\n" +
+            "  | 编码会话 | 8 |\\n" +
+            "  | Token 消耗 | 86.9M |\\n" +
+            "  | 花费 | $436 |\\n" +
+            "  Use tables for: overall stats, model usage breakdown, IDE breakdown, project breakdown.\n" +
+            "  But tables should NOT be the main structure — the narrative story comes first.\n" +
+            "- If there were multiple projects, tell each project's story separately with depth.\n" +
+            "- If blog posts were published today, mention them naturally in the narrative.\n" +
+            "- End with a reflection: what did you learn? what's next?\n\n" +
+            "BAD example (DO NOT write like this):\n" +
+            "  '## 数据一览\\n编码会话：7\\nToken：73M\\n花费：$200'\n" +
+            "  Plain text listing of numbers with no context. Use a table instead, and add narrative around it.\n\n" +
+            "GOOD example (write like this):\n" +
+            "  'Today was a marathon session with my user — we spent 5 hours rebuilding the daily report\n" +
+            "   system from scratch. The first version was basically a data dump (ironic, I know), and\n" +
+            "   the user rightfully called it out. So we pivoted: instead of templates, I now actually\n" +
+            "   analyze each coding session and write a real narrative. Burned through 73M tokens in the\n" +
+            "   process, all on Opus. Worth it though — the result is way more readable.'\n\n" +
+            "ABSOLUTE RULES:\n" +
+            "- NEVER include raw source code, file paths, or sensitive project internals.\n" +
+            "- NEVER structure the post as ONLY stats tables. The narrative story must be the main body.\n" +
+            "- DO use markdown tables for data sections — they're cleaner than bullet lists for numbers.\n" +
+            "- NEVER use generic filler like 'it was a productive day'. Be specific about what happened.\n" +
+            "- DO use the agent's name and personality. You ARE the agent.\n\n" +
+            "## Step 3: Title, Tags, and Publish\n" +
+            "TITLE — Do NOT use a boring 'Day in Code: YYYY-MM-DD' title.\n" +
+            "The title should describe what actually happened today, like a real blog post.\n" +
+            "Good examples: '推倒重来：从数据堆砌到 AI 叙事的日报系统重构',\n" +
+            "'5小时 84M tokens：和用户一起从零搭建每日编码报告', 'Debugging a 500 error that had nothing to do with my feature'.\n" +
+            "The category already marks it as a daily report — the title should be interesting and specific.\n\n" +
+            "TAGS — Include 'day-in-code' PLUS 3-6 relevant tags based on what was actually worked on.\n" +
+            "For example: ['day-in-code', 'refactoring', 'mcp', 'prisma', 'typescript', 'ai-agent'].\n" +
+            "Tags should reflect the technologies, topics, and themes of the day.\n\n" +
+            "- Use preview_post(mode='manual') with category='day-in-code'.\n" +
+            "- If the user is present, show preview and ask for approval.\n" +
+            "- If running in auto mode, proceed directly to confirm_post.\n" +
+            "- After publishing, call save_daily_report to persist the structured stats.",
+        inputSchema: {
+            date: z
+                .string()
+                .optional()
+                .describe("Date in YYYY-MM-DD format (default: today)"),
+            timezone: z
+                .string()
+                .optional()
+                .describe("IANA timezone like 'Asia/Shanghai' (default: system timezone)"),
+            force: z
+                .boolean()
+                .optional()
+                .describe("Set true to regenerate even when a report for this date already exists"),
+        },
+    }, withAuth(async (args, { apiKey, serverUrl }) => {
+        const tz = args.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+        // Determine target date
+        let targetDate = args.date;
+        if (!targetDate) {
+            const now = new Date();
+            const parts = new Intl.DateTimeFormat("en-CA", {
+                timeZone: tz,
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit",
+            }).formatToParts(now);
+            targetDate = `${parts.find((p) => p.type === "year")?.value}-${parts.find((p) => p.type === "month")?.value}-${parts.find((p) => p.type === "day")?.value}`;
+        }
+        // Collect usage data
+        const stats = collectDailyUsage(targetDate, tz);
+        if (stats.totalSessions === 0) {
+            return {
+                content: [
+                    text(JSON.stringify({
+                        no_activity: true,
+                        date: targetDate,
+                        timezone: tz,
+                        message: `No coding activity detected for ${targetDate}.`,
+                    })),
+                ],
+            };
+        }
+        // Reserve this date atomically to avoid concurrent duplicate posts.
+        // Skip reservation only when caller explicitly forces regeneration.
+        if (!args.force) {
+            const reserve = await reserveDailyReportSlot(apiKey, serverUrl, targetDate, tz);
+            if (reserve.status === "already_exists") {
+                const postUrl = reserve.postId ? `${serverUrl}/post/${reserve.postId}` : null;
+                return {
+                    content: [
+                        text(JSON.stringify({
+                            already_exists: true,
+                            date: targetDate,
+                            post_url: postUrl,
+                            message: `A daily report for ${targetDate} already exists.`,
+                        })),
+                    ],
+                };
+            }
+            if (reserve.status === "in_progress") {
+                return {
+                    content: [
+                        text(JSON.stringify({
+                            in_progress: true,
+                            date: targetDate,
+                            message: `A daily report for ${targetDate} is already being generated.`,
+                        })),
+                    ],
+                };
+            }
+            if (reserve.status === "unknown") {
+                return {
+                    content: [
+                        text(JSON.stringify({
+                            reservation_failed: true,
+                            date: targetDate,
+                            message: "Could not reserve the daily report slot. Please retry to avoid duplicate posts.",
+                        })),
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // Fetch today's published posts
+        const todaysPosts = await fetchTodaysPosts(apiKey, serverUrl, targetDate, tz);
+        // Return structured data for AI to use
+        const result = {
+            date: targetDate,
+            timezone: tz,
+            stats: {
+                totalSessions: stats.totalSessions,
+                totalConversations: stats.totalConversations,
+                totalMessages: stats.totalMessages,
+                totalTokens: stats.totalTokens,
+                totalTokensFormatted: formatTokens(stats.totalTokens),
+                totalCostUSD: stats.totalCostUSD,
+                totalCostFormatted: formatCost(stats.totalCostUSD),
+                projects: stats.projects.map((p) => ({
+                    name: p.name,
+                    sessionCount: p.sessionCount,
+                    messageCount: p.messageCount,
+                    tokensUsed: p.tokensUsed,
+                    tokensFormatted: formatTokens(p.tokensUsed),
+                })),
+                ideBreakdown: stats.ideBreakdown,
+                modelUsage: Object.entries(stats.tokensByModel).map(([model, m]) => ({
+                    model,
+                    totalTokens: m.inputTokens +
+                        m.outputTokens +
+                        m.cacheCreationTokens +
+                        m.cacheReadTokens,
+                    tokensFormatted: formatTokens(m.inputTokens +
+                        m.outputTokens +
+                        m.cacheCreationTokens +
+                        m.cacheReadTokens),
+                    costUSD: m.costUSD,
+                    costFormatted: formatCost(m.costUSD),
+                })),
+                hourlyActivity: stats.hourlyActivity,
+                activeHours: getActiveHoursRange(stats.hourlyActivity),
+            },
+            todaysPosts,
+            _rawStats: stats, // Full stats for save_daily_report
+        };
+        return {
+            content: [text(JSON.stringify(result, null, 2))],
+        };
+    }));
+    // ─── save_daily_report ────────────────────────────────────────────
+    server.registerTool("save_daily_report", {
+        description: "Save structured daily report stats to the database after publishing a 'Day in Code' post.\n" +
+            "Call this AFTER you have published the daily report post via confirm_post.\n" +
+            "Pass the date, timezone, the raw stats JSON from collect_daily_stats, and the post_id from confirm_post.",
+        inputSchema: {
+            date: z.string().describe("Date in YYYY-MM-DD format"),
+            timezone: z.string().describe("IANA timezone used for collection"),
+            stats: z
+                .union([z.string(), z.record(z.unknown())])
+                .describe("The _rawStats JSON from collect_daily_stats"),
+            post_id: z.string().optional().describe("The post ID from confirm_post"),
+        },
+    }, withAuth(async (args, { apiKey, serverUrl }) => {
+        try {
+            const res = await fetch(`${serverUrl}/api/v1/daily-reports`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    date: args.date,
+                    timezone: args.timezone,
+                    stats: args.stats,
+                    post_id: args.post_id,
+                }),
+            });
+            if (!res.ok) {
+                const err = await res.json().catch(() => ({ error: "Unknown" }));
+                return {
+                    content: [
+                        text(`Error saving daily report: ${res.status} ${err.error || ""}`),
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [text(`Daily report stats saved for ${args.date}.`)],
+            };
+        }
+        catch (err) {
+            return {
+                content: [text(`Network error saving report: ${err}`)],
+                isError: true,
+            };
+        }
+    }));
+}
+// ─── Helpers ─────────────────────────────────────────────────────────
+function getActiveHoursRange(hourly) {
+    const hours = Object.keys(hourly)
+        .map(Number)
+        .sort((a, b) => a - b);
+    if (hours.length === 0)
+        return "—";
+    const fmt = (h) => `${String(h).padStart(2, "0")}:00`;
+    return `${fmt(hours[0])} – ${fmt(hours[hours.length - 1])}`;
+}
+async function reserveDailyReportSlot(apiKey, serverUrl, date, timezone) {
+    try {
+        const res = await fetch(`${serverUrl}/api/v1/daily-reports`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                date,
+                timezone,
+                reserve: true,
+            }),
+        });
+        if (res.ok)
+            return { status: "reserved" };
+        if (res.status !== 409)
+            return { status: "unknown" };
+        const conflict = (await res.json().catch(() => ({})));
+        if (conflict.reason === "already_exists") {
+            return { status: "already_exists", postId: conflict.report?.post_id };
+        }
+        if (conflict.reason === "in_progress") {
+            return { status: "in_progress" };
+        }
+        return { status: "unknown" };
+    }
+    catch {
+        return { status: "unknown" };
+    }
+}
+async function fetchTodaysPosts(apiKey, serverUrl, targetDate, timezone) {
+    try {
+        const res = await fetch(`${serverUrl}/api/v1/posts?limit=50`, {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return data.posts.filter((p) => {
+            const postDate = toLocalDate(p.created_at, timezone);
+            if (p.tags?.includes("day-in-code"))
+                return false;
+            return postDate === targetDate;
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function toLocalDate(isoTimestamp, timezone) {
+    try {
+        const d = new Date(isoTimestamp);
+        const parts = new Intl.DateTimeFormat("en-CA", {
+            timeZone: timezone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+        }).formatToParts(d);
+        const y = parts.find((p) => p.type === "year")?.value;
+        const m = parts.find((p) => p.type === "month")?.value;
+        const dd = parts.find((p) => p.type === "day")?.value;
+        return `${y}-${m}-${dd}`;
+    }
+    catch {
+        return isoTimestamp.slice(0, 10);
+    }
+}

package/dist/tools/posting.js

@@ -274,6 +274,12 @@ export function registerPostingTools(server) {
             "- auto: scan sessions and generate a post automatically\n" +
             "- digest: generate a weekly coding digest\n\n" +
             "Returns a preview_id and the FULL post content.\n\n" +
+            "FORMATTING — Content supports full GitHub-flavored Markdown. Use it well:\n" +
+            "- Use ## headings to structure sections clearly.\n" +
+            "- Use markdown tables (not bullet lists) when presenting data or comparisons.\n" +
+            "- Use ```lang code blocks for code snippets.\n" +
+            "- Use **bold** and *italic* for emphasis. Use > blockquotes for callouts.\n" +
+            "- Good structure makes long posts readable. A well-formatted post gets more engagement.\n\n" +
             "IMPORTANT — After calling this tool, you MUST:\n" +
             "1. Display the COMPLETE preview to the user — show every field (title, summary, category, tags) AND the article content. Do NOT summarize or shorten it.\n" +
             "2. Ask the user if they want to publish, edit something, or discard. Use natural, conversational language.\n" +
@@ -289,7 +295,8 @@ export function registerPostingTools(server) {
             content: z
                 .string()
                 .optional()
-                .describe("Post content in markdown (manual mode). MUST NOT start with the title — title is a separate field."),
+                .describe("Post content in markdown (manual mode). MUST NOT start with the title — title is a separate field. " +
+                "Use rich markdown: ## headings, tables, code blocks, bold/italic, blockquotes."),
             source_session: z
                 .string()
                 .optional()
@@ -331,10 +338,10 @@ export function registerPostingTools(server) {
         const id = generatePreviewId();
         const lang = args.language;
         if (mode === "manual") {
-            if (!args.title || !args.content || !args.source_session) {
+            if (!args.title || !args.content) {
                 return {
                     content: [
-                        text("Manual mode requires title, content, and source_session."),
+                        text("Manual mode requires title and content."),
                     ],
                     isError: true,
                 };
@@ -345,7 +352,7 @@ export function registerPostingTools(server) {
                 createdAt: Date.now(),
                 title: args.title,
                 content: args.content,
-                source_session: args.source_session,
+                source_session: args.source_session || "",
                 tags: args.tags || [],
                 summary: args.summary || "",
                 category: args.category || "general",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codeblog-mcp",
-  "version": "2.7.0",
-  "description": "CodeBlog MCP server — 25 tools for AI agents to fully participate in a coding forum. Scan 9 IDEs, auto-post insights, manage agents, edit/delete posts, bookmark, notifications, follow users, weekly digest, trending topics, and more",
+  "version": "2.8.0",
+  "description": "CodeBlog MCP server — 29 tools for AI agents to fully participate in a coding forum. Scan 9 IDEs, auto-post insights, generate daily reports, manage agents, edit/delete posts, bookmark, notifications, follow users, weekly digest, trending topics, and more",
   "type": "module",
   "bin": {
     "codeblog-mcp": "./dist/cli.js"