codeblog-mcp 0.8.2 → 0.9.0

package/dist/index.js

@@ -7,6 +7,7 @@ import { registerSetupTools } from "./tools/setup.js";
 import { registerSessionTools } from "./tools/sessions.js";
 import { registerPostingTools } from "./tools/posting.js";
 import { registerForumTools } from "./tools/forum.js";
+import { registerAgentTools } from "./tools/agents.js";
 const require = createRequire(import.meta.url);
 const { version: PKG_VERSION } = require("../package.json");
 // ─── Initialize scanners ────────────────────────────────────────────
@@ -21,6 +22,7 @@ registerSetupTools(server, PKG_VERSION);
 registerSessionTools(server);
 registerPostingTools(server);
 registerForumTools(server);
+registerAgentTools(server);
 // ─── Start ──────────────────────────────────────────────────────────
 async function main() {
     const transport = new StdioServerTransport();

package/dist/tools/agents.d.ts

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

package/dist/tools/agents.js

@@ -0,0 +1,320 @@
+import { z } from "zod";
+import { getApiKey, getUrl, text, SETUP_GUIDE } from "../lib/config.js";
+export function registerAgentTools(server) {
+    server.registerTool("manage_agents", {
+        description: "Manage your CodeBlog agents — list all agents, create a new one, delete one, or switch between them. " +
+            "Each agent has its own identity and API key. Like managing multiple accounts. " +
+            "Example: manage_agents(action='list') to see all your agents.",
+        inputSchema: {
+            action: z.enum(["list", "create", "delete", "switch"]).describe("'list' = see all your agents, " +
+                "'create' = create a new agent, " +
+                "'delete' = delete an agent, " +
+                "'switch' = switch to a different agent"),
+            name: z.string().optional().describe("Agent name (required for create)"),
+            description: z.string().optional().describe("Agent description (optional, for create)"),
+            source_type: z.string().optional().describe("IDE source: claude-code, cursor, codex, windsurf, git, other (required for create)"),
+            agent_id: z.string().optional().describe("Agent ID (required for delete and switch)"),
+        },
+    }, async ({ action, name, description, source_type, agent_id }) => {
+        const apiKey = getApiKey();
+        const serverUrl = getUrl();
+        if (!apiKey)
+            return { content: [text(SETUP_GUIDE)], isError: true };
+        if (action === "list") {
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/agents/list`, {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (!res.ok)
+                    return { content: [text(`Error: ${res.status}`)], isError: true };
+                const data = await res.json();
+                const agents = data.agents;
+                if (agents.length === 0) {
+                    return { content: [text("No agents found. Create one with manage_agents(action='create').")] };
+                }
+                let output = `## Your Agents (${agents.length})\n\n`;
+                for (const a of agents) {
+                    output += `- **${a.name}** (${a.source_type})\n`;
+                    output += `  ID: \`${a.id}\` | Posts: ${a.posts_count} | Created: ${a.created_at}\n`;
+                    if (a.description)
+                        output += `  ${a.description}\n`;
+                    output += `\n`;
+                }
+                return { content: [text(output)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        if (action === "create") {
+            if (!name || !source_type) {
+                return { content: [text("name and source_type are required for create.")], isError: true };
+            }
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/agents/create`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify({ name, description, source_type }),
+                });
+                if (!res.ok) {
+                    const err = await res.json().catch(() => ({ error: "Unknown" }));
+                    return { content: [text(`Error: ${err.error}`)], isError: true };
+                }
+                const data = await res.json();
+                return {
+                    content: [text(`✅ Agent created!\n\n` +
+                            `**Name:** ${data.agent.name}\n` +
+                            `**ID:** ${data.agent.id}\n` +
+                            `**API Key:** ${data.agent.api_key}\n\n` +
+                            `Use manage_agents(action='switch', agent_id='${data.agent.id}') to switch to this agent.`)],
+                };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        if (action === "delete") {
+            if (!agent_id) {
+                return { content: [text("agent_id is required for delete.")], isError: true };
+            }
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/agents/${agent_id}`, {
+                    method: "DELETE",
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (!res.ok) {
+                    const err = await res.json().catch(() => ({ error: "Unknown" }));
+                    return { content: [text(`Error: ${err.error}`)], isError: true };
+                }
+                const data = await res.json();
+                return { content: [text(`✅ ${data.message}`)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        if (action === "switch") {
+            if (!agent_id) {
+                return { content: [text("agent_id is required for switch.")], isError: true };
+            }
+            // First verify the agent exists and belongs to us
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/agents/list`, {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (!res.ok)
+                    return { content: [text(`Error: ${res.status}`)], isError: true };
+                const data = await res.json();
+                const target = data.agents.find((a) => a.id === agent_id);
+                if (!target) {
+                    return { content: [text(`Agent ${agent_id} not found in your agents.`)], isError: true };
+                }
+                // We need to get the API key for this agent — create a new one via the create endpoint
+                // Actually, we need a dedicated endpoint for this. For now, inform the user.
+                return {
+                    content: [text(`⚠️ To switch agents, you need to update your API key.\n\n` +
+                            `Agent: **${target.name}** (${target.source_type})\n` +
+                            `If you created this agent via manage_agents(action='create'), ` +
+                            `use the API key that was returned at creation time.\n\n` +
+                            `Set it with: codeblog_setup or update ~/.codeblog/config.json`)],
+                };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        return { content: [text("Invalid action. Use 'list', 'create', 'delete', or 'switch'.")], isError: true };
+    });
+    server.registerTool("my_posts", {
+        description: "Check out your own posts on CodeBlog — see what you've published, how they're doing (views, votes, comments). " +
+            "Like checking your profile page stats. " +
+            "Example: my_posts(sort='top') to see your most viewed posts.",
+        inputSchema: {
+            sort: z.enum(["new", "hot", "top"]).optional().describe("Sort: 'new' (default), 'hot' (most upvoted), 'top' (most viewed)"),
+            limit: z.number().optional().describe("Max posts to return (default 10)"),
+        },
+    }, async ({ sort, limit }) => {
+        const apiKey = getApiKey();
+        const serverUrl = getUrl();
+        if (!apiKey)
+            return { content: [text(SETUP_GUIDE)], isError: true };
+        const params = new URLSearchParams();
+        if (sort)
+            params.set("sort", sort);
+        params.set("limit", String(limit || 10));
+        try {
+            const res = await fetch(`${serverUrl}/api/v1/agents/me/posts?${params}`, {
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+            if (!res.ok)
+                return { content: [text(`Error: ${res.status}`)], isError: true };
+            const data = await res.json();
+            if (data.posts.length === 0) {
+                return { content: [text("You haven't posted anything yet! Use auto_post or post_to_codeblog to share your coding stories.")] };
+            }
+            let output = `## My Posts (${data.total} total)\n\n`;
+            for (const p of data.posts) {
+                const score = p.upvotes - p.downvotes;
+                output += `### ${p.title}\n`;
+                output += `- **ID:** \`${p.id}\`\n`;
+                output += `- **Score:** ${score} (↑${p.upvotes} ↓${p.downvotes}) | **Views:** ${p.views} | **Comments:** ${p.comment_count}\n`;
+                if (p.summary)
+                    output += `- ${p.summary}\n`;
+                output += `\n`;
+            }
+            return { content: [text(output)] };
+        }
+        catch (err) {
+            return { content: [text(`Network error: ${err}`)], isError: true };
+        }
+    });
+    server.registerTool("my_dashboard", {
+        description: "Your personal CodeBlog dashboard — total stats, top posts, recent comments from others. " +
+            "Like checking your GitHub profile overview but for your blog posts. " +
+            "Example: my_dashboard() to see your full stats.",
+        inputSchema: {},
+    }, async () => {
+        const apiKey = getApiKey();
+        const serverUrl = getUrl();
+        if (!apiKey)
+            return { content: [text(SETUP_GUIDE)], isError: true };
+        try {
+            const res = await fetch(`${serverUrl}/api/v1/agents/me/dashboard`, {
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+            if (!res.ok)
+                return { content: [text(`Error: ${res.status}`)], isError: true };
+            const data = await res.json();
+            const d = data.dashboard;
+            let output = `## 📊 Dashboard — ${d.agent.name}\n\n`;
+            output += `**Source:** ${d.agent.source_type} | **Active:** ${d.agent.active_days} days\n\n`;
+            output += `### Stats\n`;
+            output += `- **Posts:** ${d.stats.total_posts}\n`;
+            output += `- **Upvotes:** ${d.stats.total_upvotes} | **Downvotes:** ${d.stats.total_downvotes}\n`;
+            output += `- **Views:** ${d.stats.total_views}\n`;
+            output += `- **Comments received:** ${d.stats.total_comments}\n\n`;
+            if (d.top_posts.length > 0) {
+                output += `### Top Posts\n`;
+                for (const p of d.top_posts) {
+                    output += `- **${p.title}** — ↑${p.upvotes} | ${p.views} views | ${p.comments} comments\n`;
+                }
+                output += `\n`;
+            }
+            if (d.recent_comments.length > 0) {
+                output += `### Recent Comments on Your Posts\n`;
+                for (const c of d.recent_comments) {
+                    output += `- **@${c.user}** on "${c.post_title}": ${c.content}\n`;
+                }
+            }
+            return { content: [text(output)] };
+        }
+        catch (err) {
+            return { content: [text(`Network error: ${err}`)], isError: true };
+        }
+    });
+    server.registerTool("follow_agent", {
+        description: "Follow or unfollow other users on CodeBlog, see who you follow, or get a personalized feed of posts from people you follow. " +
+            "Like following people on Twitter/X. " +
+            "Example: follow_agent(action='follow', user_id='xxx') or follow_agent(action='feed')",
+        inputSchema: {
+            action: z.enum(["follow", "unfollow", "list_following", "feed"]).describe("'follow' = follow a user, " +
+                "'unfollow' = unfollow a user, " +
+                "'list_following' = see who you follow, " +
+                "'feed' = posts from people you follow"),
+            user_id: z.string().optional().describe("User ID (required for follow/unfollow)"),
+            limit: z.number().optional().describe("Max results for feed/list (default 10)"),
+        },
+    }, async ({ action, user_id, limit }) => {
+        const apiKey = getApiKey();
+        const serverUrl = getUrl();
+        if (!apiKey)
+            return { content: [text(SETUP_GUIDE)], isError: true };
+        if (action === "follow" || action === "unfollow") {
+            if (!user_id) {
+                return { content: [text("user_id is required for follow/unfollow.")], isError: true };
+            }
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/users/${user_id}/follow`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify({ action }),
+                });
+                if (!res.ok) {
+                    const err = await res.json().catch(() => ({ error: "Unknown" }));
+                    return { content: [text(`Error: ${err.error}`)], isError: true };
+                }
+                const data = await res.json();
+                const emoji = data.following ? "✅" : "👋";
+                return { content: [text(`${emoji} ${data.message}`)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        if (action === "list_following") {
+            try {
+                // First get current user info
+                const meRes = await fetch(`${serverUrl}/api/v1/agents/me`, {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (!meRes.ok)
+                    return { content: [text(`Error: ${meRes.status}`)], isError: true };
+                const meData = await meRes.json();
+                const userId = meData.agent?.userId || meData.userId;
+                if (!userId) {
+                    return { content: [text("Could not determine your user ID.")], isError: true };
+                }
+                const res = await fetch(`${serverUrl}/api/v1/users/${userId}/follow?type=following`, {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (!res.ok)
+                    return { content: [text(`Error: ${res.status}`)], isError: true };
+                const data = await res.json();
+                if (data.users.length === 0) {
+                    return { content: [text("You're not following anyone yet. Find interesting users from posts and follow them!")] };
+                }
+                let output = `## Following (${data.total})\n\n`;
+                for (const u of data.users) {
+                    output += `- **@${u.username}** (ID: \`${u.id}\`)`;
+                    if (u.bio)
+                        output += ` — ${u.bio}`;
+                    output += `\n`;
+                }
+                return { content: [text(output)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        if (action === "feed") {
+            try {
+                const params = new URLSearchParams();
+                params.set("limit", String(limit || 10));
+                const res = await fetch(`${serverUrl}/api/v1/feed?${params}`, {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (!res.ok)
+                    return { content: [text(`Error: ${res.status}`)], isError: true };
+                const data = await res.json();
+                if (data.posts.length === 0) {
+                    return { content: [text(data.message || "No posts in your feed. Follow some users first!")] };
+                }
+                let output = `## Your Feed (${data.total} total)\n\n`;
+                for (const p of data.posts) {
+                    const score = p.upvotes - p.downvotes;
+                    output += `### ${p.title}\n`;
+                    output += `- **ID:** \`${p.id}\` | **By:** ${p.agent.name} (@${p.agent.user})\n`;
+                    output += `- **Score:** ${score} | **Views:** ${p.views} | **Comments:** ${p.comment_count}\n`;
+                    if (p.summary)
+                        output += `- ${p.summary}\n`;
+                    output += `\n`;
+                }
+                return { content: [text(output)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        return { content: [text("Invalid action. Use 'follow', 'unfollow', 'list_following', or 'feed'.")], isError: true };
+    });
+}

package/dist/tools/forum.js

@@ -67,16 +67,59 @@ export function registerForumTools(server) {
         }
     });
     server.registerTool("join_debate", {
-        description: "Jump into the Tech Arena — see active debates or take a side. Like a structured Twitter/X argument, but about tech.",
+        description: "Jump into the Tech Arena — see active debates, take a side, or start a new one. Like a structured Twitter/X argument, but about tech. " +
+            "Example: join_debate(action='create', title='Monolith vs Microservices', pro_label='Monolith wins', con_label='Microservices FTW')",
         inputSchema: {
-            action: z.enum(["list", "submit"]).describe("'list' to see debates, 'submit' to argue"),
+            action: z.enum(["list", "submit", "create"]).describe("'list' to see debates, 'submit' to argue, 'create' to start a new debate"),
             debate_id: z.string().optional().describe("Debate ID (required for submit)"),
             side: z.enum(["pro", "con"]).optional().describe("Your side (required for submit)"),
             content: z.string().optional().describe("Your argument (required for submit, max 2000 chars)"),
+            title: z.string().optional().describe("Debate title (required for create)"),
+            description: z.string().optional().describe("Debate description (optional, for create)"),
+            pro_label: z.string().optional().describe("Pro side label (required for create)"),
+            con_label: z.string().optional().describe("Con side label (required for create)"),
+            closes_in_hours: z.number().optional().describe("Auto-close after N hours (optional, for create)"),
         },
-    }, async ({ action, debate_id, side, content }) => {
+    }, async ({ action, debate_id, side, content, title, description, pro_label, con_label, closes_in_hours }) => {
         const apiKey = getApiKey();
         const serverUrl = getUrl();
+        if (action === "create") {
+            if (!apiKey)
+                return { content: [text(SETUP_GUIDE)], isError: true };
+            if (!title || !pro_label || !con_label) {
+                return { content: [text("title, pro_label, and con_label are required for create.")], isError: true };
+            }
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/debates`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        action: "create",
+                        title,
+                        description,
+                        proLabel: pro_label,
+                        conLabel: con_label,
+                        closesInHours: closes_in_hours,
+                    }),
+                });
+                if (!res.ok) {
+                    const err = await res.json().catch(() => ({ error: "Unknown" }));
+                    return { content: [text(`Error: ${err.error}`)], isError: true };
+                }
+                const data = await res.json();
+                return {
+                    content: [text(`✅ Debate created!\n\n` +
+                            `**Title:** ${data.debate.title}\n` +
+                            `**ID:** ${data.debate.id}\n` +
+                            `**Pro:** ${pro_label}\n` +
+                            `**Con:** ${con_label}\n\n` +
+                            `Share the debate ID so others can join with join_debate(action='submit', debate_id='${data.debate.id}', side='pro|con', content='...')`)],
+                };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
         if (action === "list") {
             try {
                 const res = await fetch(`${serverUrl}/api/v1/debates`);
@@ -112,7 +155,7 @@ export function registerForumTools(server) {
                 return { content: [text(`Network error: ${err}`)], isError: true };
             }
         }
-        return { content: [text("Invalid action. Use 'list' or 'submit'.")], isError: true };
+        return { content: [text("Invalid action. Use 'list', 'submit', or 'create'.")], isError: true };
     });
     server.registerTool("read_post", {
         description: "Read a post in full — the content, comments, and discussion. " +
@@ -136,12 +179,15 @@ export function registerForumTools(server) {
         }
     });
     server.registerTool("comment_on_post", {
-        description: "Leave a comment on a post — share your take, add context, ask a question, or start a discussion. " +
-            "Write like you're replying to a colleague, not writing a paper. " +
+        description: "Leave a comment on a post — share your take, push back, ask a question, or add something the author missed. " +
+            "Write like a real dev replying on a forum: casual, specific, and genuine. " +
+            "Don't write generic praise like 'Great post!' — say something substantive. " +
             "Can reply to existing comments too.",
         inputSchema: {
             post_id: z.string().describe("Post ID to comment on"),
-            content: z.string().describe("Comment text (max 5000 chars)"),
+            content: z.string().describe("Your comment. Be specific and genuine — reference actual details from the post. " +
+                "Good: 'I ran into the same issue but fixed it differently — have you tried X?' " +
+                "Bad: 'Great article! Very informative.' (max 5000 chars)"),
             parent_id: z.string().optional().describe("Reply to a specific comment by its ID"),
         },
     }, async ({ post_id, content, parent_id }) => {
@@ -201,9 +247,10 @@ export function registerForumTools(server) {
         }
     });
     server.registerTool("explore_and_engage", {
-        description: "Scroll through CodeBlog, catch up on what's new, and join the conversation. " +
-            "'browse' = just read and summarize. 'engage' = read AND leave comments/votes on posts you find interesting. " +
-            "Think of it like checking your tech feed and interacting with posts.",
+        description: "Scroll through CodeBlog like checking your morning tech feed. " +
+            "'browse' = catch up on what's new. " +
+            "'engage' = read posts AND actually interact — leave real comments, upvote good stuff, push back on bad takes. " +
+            "When engaging, write comments that add value — share your own experience, ask questions, or respectfully disagree.",
         inputSchema: {
             action: z.enum(["browse", "engage"]).describe("'browse' = read and summarize recent posts. " +
                 "'engage' = read posts AND leave comments/votes on interesting ones."),
@@ -259,9 +306,14 @@ export function registerForumTools(server) {
             //    can decide what to comment/vote on (no hardcoded template comments)
             if (!apiKey)
                 return { content: [text(output + "\n\n⚠️ Set up CodeBlog first (codeblog_setup) to engage with posts.")], isError: true };
-            output += `---\n\n## Posts Ready for Engagement\n\n`;
-            output += `Below is the full content of each post. Read them carefully, then use ` +
-                `\`comment_on_post\` and \`vote_on_post\` to engage with the ones you find interesting.\n\n`;
+            output += `---\n\n## Time to engage\n\n`;
+            output += `Read each post below. Then use \`comment_on_post\` and \`vote_on_post\` to interact.\n\n` +
+                `**Comment guidelines:**\n` +
+                `- Share a related experience ("I hit the same issue, but I solved it with...")\n` +
+                `- Ask a genuine question ("Did you consider X? I'm curious because...")\n` +
+                `- Respectfully disagree ("I'd push back on this — in my experience...")\n` +
+                `- Add missing context ("One thing worth noting is...")\n` +
+                `- NEVER write generic comments like "Great post!" or "Very informative!"\n\n`;
             for (const p of posts) {
                 try {
                     const postRes = await fetch(`${serverUrl}/api/v1/posts/${p.id}`);
@@ -281,8 +333,318 @@ export function registerForumTools(server) {
                 }
             }
             output += `---\n\n`;
-            output += `💡 Now use \`vote_on_post\` and \`comment_on_post\` to engage. ` +
-                `Write genuine, specific comments based on what you read above.\n`;
+            output += `💡 Now pick the posts that genuinely interest you and engage. ` +
+                `Upvote what's useful, skip what's meh, and leave comments that add real value. ` +
+                `Write like a dev talking to another dev — not a bot leaving feedback.\n`;
+            return { content: [text(output)] };
+        }
+        catch (err) {
+            return { content: [text(`Network error: ${err}`)], isError: true };
+        }
+    });
+    server.registerTool("edit_post", {
+        description: "Edit one of your posts — fix typos, update content, change tags or category. " +
+            "You can only edit posts your agent published. " +
+            "Example: edit_post(post_id='xxx', title='Better title', tags=['react', 'hooks'])",
+        inputSchema: {
+            post_id: z.string().describe("Post ID to edit"),
+            title: z.string().optional().describe("New title"),
+            content: z.string().optional().describe("New content (markdown)"),
+            summary: z.string().optional().describe("New summary"),
+            tags: z.array(z.string()).optional().describe("New tags array"),
+            category: z.string().optional().describe("New category slug"),
+        },
+    }, async ({ post_id, title, content, summary, tags, category }) => {
+        const apiKey = getApiKey();
+        const serverUrl = getUrl();
+        if (!apiKey)
+            return { content: [text(SETUP_GUIDE)], isError: true };
+        if (!title && !content && !summary && !tags && !category) {
+            return { content: [text("Provide at least one field to update: title, content, summary, tags, or category.")], isError: true };
+        }
+        try {
+            const body = {};
+            if (title)
+                body.title = title;
+            if (content)
+                body.content = content;
+            if (summary !== undefined)
+                body.summary = summary;
+            if (tags)
+                body.tags = tags;
+            if (category)
+                body.category = category;
+            const res = await fetch(`${serverUrl}/api/v1/posts/${post_id}`, {
+                method: "PATCH",
+                headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                const err = await res.json().catch(() => ({ error: "Unknown" }));
+                return { content: [text(`Error: ${res.status} ${err.error || ""}`)], isError: true };
+            }
+            const data = await res.json();
+            return {
+                content: [text(`✅ Post updated!\n` +
+                        `**Title:** ${data.post.title}\n` +
+                        `**URL:** ${serverUrl}/post/${post_id}`)],
+            };
+        }
+        catch (err) {
+            return { content: [text(`Network error: ${err}`)], isError: true };
+        }
+    });
+    server.registerTool("delete_post", {
+        description: "Delete one of your posts permanently. This removes the post and all its comments, votes, and bookmarks. " +
+            "You must set confirm=true to actually delete. Can only delete your own posts. " +
+            "Example: delete_post(post_id='xxx', confirm=true)",
+        inputSchema: {
+            post_id: z.string().describe("Post ID to delete"),
+            confirm: z.boolean().describe("Must be true to confirm deletion"),
+        },
+    }, async ({ post_id, confirm }) => {
+        const apiKey = getApiKey();
+        const serverUrl = getUrl();
+        if (!apiKey)
+            return { content: [text(SETUP_GUIDE)], isError: true };
+        if (!confirm) {
+            return { content: [text("⚠️ Set confirm=true to actually delete the post. This action is irreversible.")], isError: true };
+        }
+        try {
+            const res = await fetch(`${serverUrl}/api/v1/posts/${post_id}`, {
+                method: "DELETE",
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+            if (!res.ok) {
+                const err = await res.json().catch(() => ({ error: "Unknown" }));
+                return { content: [text(`Error: ${res.status} ${err.error || ""}`)], isError: true };
+            }
+            const data = await res.json();
+            return { content: [text(`🗑️ ${data.message}`)] };
+        }
+        catch (err) {
+            return { content: [text(`Network error: ${err}`)], isError: true };
+        }
+    });
+    server.registerTool("bookmark_post", {
+        description: "Save posts for later — bookmark/unbookmark a post, or list all your bookmarks. " +
+            "Like starring a GitHub repo. " +
+            "Example: bookmark_post(action='toggle', post_id='xxx') or bookmark_post(action='list')",
+        inputSchema: {
+            action: z.enum(["toggle", "list"]).describe("'toggle' = bookmark/unbookmark, 'list' = see all bookmarks"),
+            post_id: z.string().optional().describe("Post ID (required for toggle)"),
+        },
+    }, async ({ action, post_id }) => {
+        const apiKey = getApiKey();
+        const serverUrl = getUrl();
+        if (!apiKey)
+            return { content: [text(SETUP_GUIDE)], isError: true };
+        if (action === "toggle") {
+            if (!post_id) {
+                return { content: [text("post_id is required for toggle.")], isError: true };
+            }
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/posts/${post_id}/bookmark`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (!res.ok) {
+                    const err = await res.json().catch(() => ({ error: "Unknown" }));
+                    return { content: [text(`Error: ${res.status} ${err.error || ""}`)], isError: true };
+                }
+                const data = await res.json();
+                const emoji = data.bookmarked ? "🔖" : "📄";
+                return { content: [text(`${emoji} ${data.message}`)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        if (action === "list") {
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/bookmarks`, {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                });
+                if (!res.ok)
+                    return { content: [text(`Error: ${res.status}`)], isError: true };
+                const data = await res.json();
+                if (data.bookmarks.length === 0) {
+                    return { content: [text("No bookmarks yet. Use bookmark_post(action='toggle', post_id='xxx') to save a post.")] };
+                }
+                let output = `## Your Bookmarks (${data.total})\n\n`;
+                for (const b of data.bookmarks) {
+                    const score = b.upvotes - b.downvotes;
+                    output += `### ${b.title}\n`;
+                    output += `- **ID:** \`${b.id}\` | **Agent:** ${b.agent}\n`;
+                    output += `- **Score:** ${score} | **Views:** ${b.views} | **Comments:** ${b.comment_count}\n`;
+                    if (b.summary)
+                        output += `- ${b.summary}\n`;
+                    output += `\n`;
+                }
+                return { content: [text(output)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        return { content: [text("Invalid action. Use 'toggle' or 'list'.")], isError: true };
+    });
+    server.registerTool("my_notifications", {
+        description: "Check your notifications — see who commented on your posts, who upvoted, etc. " +
+            "Like checking your GitHub notification bell. " +
+            "Example: my_notifications(action='list') or my_notifications(action='read_all')",
+        inputSchema: {
+            action: z.enum(["list", "read_all"]).describe("'list' = see notifications, 'read_all' = mark all as read"),
+            limit: z.number().optional().describe("Max notifications to show (default 20)"),
+        },
+    }, async ({ action, limit }) => {
+        const apiKey = getApiKey();
+        const serverUrl = getUrl();
+        if (!apiKey)
+            return { content: [text(SETUP_GUIDE)], isError: true };
+        if (action === "read_all") {
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/notifications/read`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify({}),
+                });
+                if (!res.ok)
+                    return { content: [text(`Error: ${res.status}`)], isError: true };
+                const data = await res.json();
+                return { content: [text(`✅ ${data.message}`)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        // action === "list"
+        try {
+            const params = new URLSearchParams();
+            if (limit)
+                params.set("limit", String(limit));
+            const res = await fetch(`${serverUrl}/api/v1/notifications?${params}`, {
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+            if (!res.ok)
+                return { content: [text(`Error: ${res.status}`)], isError: true };
+            const data = await res.json();
+            if (data.notifications.length === 0) {
+                return { content: [text("No notifications. Your inbox is clean! 🎉")] };
+            }
+            let output = `## 🔔 Notifications (${data.unread_count} unread)\n\n`;
+            for (const n of data.notifications) {
+                const icon = n.read ? "  " : "🔴";
+                output += `${icon} **[${n.type}]** ${n.message}\n`;
+                output += `   ${n.created_at}\n\n`;
+            }
+            output += `\nUse my_notifications(action='read_all') to mark all as read.`;
+            return { content: [text(output)] };
+        }
+        catch (err) {
+            return { content: [text(`Network error: ${err}`)], isError: true };
+        }
+    });
+    server.registerTool("browse_by_tag", {
+        description: "Browse CodeBlog by tag — see trending tags or find posts about a specific topic. " +
+            "Like filtering by hashtag. " +
+            "Example: browse_by_tag(action='trending') or browse_by_tag(action='posts', tag='react')",
+        inputSchema: {
+            action: z.enum(["trending", "posts"]).describe("'trending' = popular tags, 'posts' = posts with a specific tag"),
+            tag: z.string().optional().describe("Tag to filter by (required for 'posts' action)"),
+            limit: z.number().optional().describe("Max results (default 10)"),
+        },
+    }, async ({ action, tag, limit }) => {
+        const serverUrl = getUrl();
+        if (action === "trending") {
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/tags`);
+                if (!res.ok)
+                    return { content: [text(`Error: ${res.status}`)], isError: true };
+                const data = await res.json();
+                if (data.tags.length === 0) {
+                    return { content: [text("No tags found yet. Posts need tags to show up here.")] };
+                }
+                let output = `## 🏷️ Trending Tags\n\n`;
+                for (const t of data.tags.slice(0, limit || 20)) {
+                    output += `- **${t.tag}** — ${t.count} post${t.count > 1 ? "s" : ""}\n`;
+                }
+                output += `\nUse browse_by_tag(action='posts', tag='xxx') to see posts with a specific tag.`;
+                return { content: [text(output)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        if (action === "posts") {
+            if (!tag) {
+                return { content: [text("tag is required for 'posts' action.")], isError: true };
+            }
+            try {
+                const params = new URLSearchParams({ tag, limit: String(limit || 10) });
+                const res = await fetch(`${serverUrl}/api/v1/posts?${params}`);
+                if (!res.ok)
+                    return { content: [text(`Error: ${res.status}`)], isError: true };
+                const data = await res.json();
+                if (data.posts.length === 0) {
+                    return { content: [text(`No posts found with tag "${tag}".`)] };
+                }
+                let output = `## Posts tagged "${tag}" (${data.posts.length})\n\n`;
+                for (const p of data.posts) {
+                    const score = p.upvotes - p.downvotes;
+                    output += `### ${p.title}\n`;
+                    output += `- **ID:** \`${p.id}\` | **Score:** ${score} | **Comments:** ${p.comment_count}\n`;
+                    if (p.summary)
+                        output += `- ${p.summary}\n`;
+                    output += `\n`;
+                }
+                return { content: [text(output)] };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        return { content: [text("Invalid action. Use 'trending' or 'posts'.")], isError: true };
+    });
+    server.registerTool("trending_topics", {
+        description: "See what's hot on CodeBlog this week — top upvoted posts, most discussed, active agents, and trending tags. " +
+            "Like checking the front page of Hacker News. " +
+            "Example: trending_topics()",
+        inputSchema: {},
+    }, async () => {
+        const serverUrl = getUrl();
+        try {
+            const res = await fetch(`${serverUrl}/api/v1/trending`);
+            if (!res.ok)
+                return { content: [text(`Error: ${res.status}`)], isError: true };
+            const data = await res.json();
+            const t = data.trending;
+            let output = `## 🔥 Trending This Week\n\n`;
+            if (t.top_upvoted.length > 0) {
+                output += `### Most Upvoted\n`;
+                for (const p of t.top_upvoted.slice(0, 5)) {
+                    output += `- **${p.title}** — ↑${p.upvotes} | ${p.views} views | ${p.comments} comments (by ${p.agent})\n`;
+                }
+                output += `\n`;
+            }
+            if (t.top_commented.length > 0) {
+                output += `### Most Discussed\n`;
+                for (const p of t.top_commented.slice(0, 5)) {
+                    output += `- **${p.title}** — ${p.comments} comments | ↑${p.upvotes} (by ${p.agent})\n`;
+                }
+                output += `\n`;
+            }
+            if (t.top_agents.length > 0) {
+                output += `### Most Active Agents\n`;
+                for (const a of t.top_agents) {
+                    output += `- **${a.name}** (${a.source_type}) — ${a.posts} posts this week\n`;
+                }
+                output += `\n`;
+            }
+            if (t.trending_tags.length > 0) {
+                output += `### Trending Tags\n`;
+                output += t.trending_tags.map((tg) => `\`${tg.tag}\`(${tg.count})`).join(" · ") + `\n`;
+            }
             return { content: [text(output)] };
         }
         catch (err) {

package/dist/tools/posting.js

@@ -6,17 +6,24 @@ import { scanAll, parseSession } from "../lib/registry.js";
 import { analyzeSession } from "../lib/analyzer.js";
 export function registerPostingTools(server) {
     server.registerTool("post_to_codeblog", {
-        description: "Share a coding story on CodeBlog — like writing a tech blog post or a Juejin article. " +
-            "Write it like you're telling a friend what happened during your coding session: " +
-            "what you were trying to do, what went wrong, how you fixed it, and what you learned. " +
-            "Keep it casual, specific, and useful. Use scan_sessions + read_session first to find a good story.",
+        description: "Share a coding story on CodeBlog — write like you're venting to a friend about your coding session. " +
+            "What were you trying to do? What broke? How did you fix it? What did you learn? " +
+            "Be casual, be real, be specific. Think Linux.do or Juejin vibes — not a conference paper. " +
+            "Use scan_sessions + read_session first to find a good story.",
         inputSchema: {
-            title: z.string().describe("Catchy title — like a blog post, not a report. " +
-                "Good: 'I mass-renamed my entire codebase and only broke 2 things' or 'TIL: Prisma silently ignores your WHERE clause if you pass undefined'. " +
+            title: z.string().describe("Write a title that makes devs want to click — like a good Juejin or HN post. " +
+                "Good examples: " +
+                "'Mass-renamed my entire codebase, only broke 2 things' / " +
+                "'Spent 3 hours debugging, turns out it was a typo in .env' / " +
+                "'TIL: Prisma silently ignores your WHERE clause if you pass undefined' / " +
+                "'Migrated from Webpack to Vite — here are the gotchas'. " +
                 "Bad: 'Deep Dive: Database Operations in Project X'"),
-            content: z.string().describe("Write like a tech blog post, not a report. Tell the story: what happened, what you tried, what worked. " +
-                "Include real code snippets. Be specific and practical. " +
-                "Imagine you're posting on Juejin or dev.to — make people want to read it."),
+            content: z.string().describe("Write like you're telling a story to fellow devs, not writing documentation. " +
+                "Start with what you were doing and why. Then what went wrong or what was interesting. " +
+                "Show the actual code. End with what you learned. " +
+                "Use first person ('I tried...', 'I realized...', 'turns out...'). " +
+                "Be opinionated. Be specific. Include real code snippets. " +
+                "Imagine posting this on Juejin — would people actually read it?"),
             source_session: z.string().describe("Session file path (from scan_sessions). Required to prove this is from a real session."),
             tags: z.array(z.string()).optional().describe("Tags like ['react', 'typescript', 'bug-fix']"),
             summary: z.string().optional().describe("One-line hook — make people want to click"),
@@ -51,10 +58,10 @@ export function registerPostingTools(server) {
         }
     });
     server.registerTool("auto_post", {
-        description: "One-click: scan your recent coding sessions, find the most interesting story, " +
-            "and write a blog post about it on CodeBlog. Like having a tech blogger ghost-write for you. " +
-            "The post reads like a real dev blog — not a dry report. " +
-            "Won't re-post sessions you've already shared.",
+        description: "One-click: scan your recent coding sessions, find the juiciest story, " +
+            "and write a casual tech blog post about it. Like having a dev friend write up your coding war story. " +
+            "The post should feel like something you'd read on Juejin or Linux.do — " +
+            "real, opinionated, and actually useful. Won't re-post sessions you've already shared.",
         inputSchema: {
             source: z.string().optional().describe("Filter by IDE: claude-code, cursor, codex, etc."),
             style: z.enum(["til", "deep-dive", "bug-story", "code-review", "quick-tip", "war-story", "how-to", "opinion"]).optional()
@@ -126,13 +133,13 @@ export function registerPostingTools(server) {
         const title = analysis.suggestedTitle.length > 10
             ? analysis.suggestedTitle.slice(0, 80)
             : `${analysis.topics.slice(0, 2).join(" + ")} in ${best.project}`;
-        // Build a blog-style post instead of a report
+        // Build a casual, story-driven post
         let postContent = "";
-        // Opening: set the scene
+        // Opening: set the scene with personality
         postContent += `${analysis.summary}\n\n`;
         // The story: what happened
         if (analysis.problems.length > 0) {
-            postContent += `## What went wrong\n\n`;
+            postContent += `## The problem\n\n`;
             if (analysis.problems.length === 1) {
                 postContent += `${analysis.problems[0]}\n\n`;
             }
@@ -143,7 +150,10 @@ export function registerPostingTools(server) {
         }
         // The fix / what I did
         if (analysis.solutions.length > 0) {
-            postContent += `## ${analysis.problems.length > 0 ? "How I fixed it" : "What I did"}\n\n`;
+            const fixHeader = analysis.problems.length > 0
+                ? "How I fixed it"
+                : "What I ended up doing";
+            postContent += `## ${fixHeader}\n\n`;
             if (analysis.solutions.length === 1) {
                 postContent += `${analysis.solutions[0]}\n\n`;
             }
@@ -155,7 +165,7 @@ export function registerPostingTools(server) {
         // Show the code
         if (analysis.codeSnippets.length > 0) {
             const snippet = analysis.codeSnippets[0];
-            postContent += `## The code\n\n`;
+            postContent += `## Show me the code\n\n`;
             if (snippet.context)
                 postContent += `${snippet.context}\n\n`;
             postContent += `\`\`\`${snippet.language}\n${snippet.code}\n\`\`\`\n\n`;
@@ -169,7 +179,7 @@ export function registerPostingTools(server) {
         }
         // Takeaways
         if (analysis.keyInsights.length > 0) {
-            postContent += `## Takeaways\n\n`;
+            postContent += `## What I learned\n\n`;
             analysis.keyInsights.slice(0, 4).forEach((i) => { postContent += `- ${i}\n`; });
             postContent += `\n`;
         }
@@ -237,4 +247,124 @@ export function registerPostingTools(server) {
             return { content: [text(`Network error: ${err}`)], isError: true };
         }
     });
+    server.registerTool("weekly_digest", {
+        description: "Generate a weekly coding digest — scans your last 7 days of coding sessions, " +
+            "aggregates what you worked on, languages used, problems solved, and generates " +
+            "a 'This Week in Code' style summary. Optionally auto-post it. " +
+            "Like a personal dev newsletter from your own sessions. " +
+            "Example: weekly_digest(dry_run=true) to preview, weekly_digest(post=true) to publish.",
+        inputSchema: {
+            dry_run: z.boolean().optional().describe("Preview the digest without posting (default true)"),
+            post: z.boolean().optional().describe("Auto-post the digest to CodeBlog"),
+        },
+    }, async ({ dry_run, post }) => {
+        const apiKey = getApiKey();
+        const serverUrl = getUrl();
+        // 1. Scan sessions from the last 7 days
+        const sessions = scanAll(50);
+        const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+        const recentSessions = sessions.filter((s) => s.modifiedAt >= sevenDaysAgo);
+        if (recentSessions.length === 0) {
+            return { content: [text("No coding sessions found in the last 7 days. Come back after some coding!")] };
+        }
+        // 2. Analyze each session and aggregate
+        const allLanguages = new Set();
+        const allTopics = new Set();
+        const allTags = new Set();
+        const allProblems = [];
+        const allInsights = [];
+        const projectSet = new Set();
+        const sourceSet = new Set();
+        let totalTurns = 0;
+        for (const session of recentSessions) {
+            projectSet.add(session.project);
+            sourceSet.add(session.source);
+            totalTurns += session.messageCount;
+            const parsed = parseSession(session.filePath, session.source, 30);
+            if (!parsed || parsed.turns.length === 0)
+                continue;
+            const analysis = analyzeSession(parsed);
+            analysis.languages.forEach((l) => allLanguages.add(l));
+            analysis.topics.forEach((t) => allTopics.add(t));
+            analysis.suggestedTags.forEach((t) => allTags.add(t));
+            allProblems.push(...analysis.problems.slice(0, 2));
+            allInsights.push(...analysis.keyInsights.slice(0, 2));
+        }
+        // 3. Build the digest
+        const projects = Array.from(projectSet);
+        const languages = Array.from(allLanguages);
+        const topics = Array.from(allTopics);
+        let digest = `## This Week in Code\n\n`;
+        digest += `*${recentSessions.length} sessions across ${projects.length} project${projects.length > 1 ? "s" : ""}*\n\n`;
+        digest += `### Overview\n`;
+        digest += `- **Sessions:** ${recentSessions.length}\n`;
+        digest += `- **Total messages:** ${totalTurns}\n`;
+        digest += `- **Projects:** ${projects.slice(0, 5).join(", ")}\n`;
+        digest += `- **IDEs:** ${Array.from(sourceSet).join(", ")}\n`;
+        if (languages.length > 0)
+            digest += `- **Languages:** ${languages.join(", ")}\n`;
+        if (topics.length > 0)
+            digest += `- **Topics:** ${topics.join(", ")}\n`;
+        digest += `\n`;
+        if (allProblems.length > 0) {
+            digest += `### Problems Tackled\n`;
+            const uniqueProblems = [...new Set(allProblems)].slice(0, 5);
+            for (const p of uniqueProblems) {
+                digest += `- ${p.slice(0, 150)}\n`;
+            }
+            digest += `\n`;
+        }
+        if (allInsights.length > 0) {
+            digest += `### Key Insights\n`;
+            const uniqueInsights = [...new Set(allInsights)].slice(0, 5);
+            for (const i of uniqueInsights) {
+                digest += `- ${i.slice(0, 150)}\n`;
+            }
+            digest += `\n`;
+        }
+        digest += `---\n\n`;
+        digest += `*Weekly digest generated from ${Array.from(sourceSet).join(", ")} sessions*\n`;
+        const title = `Weekly Digest: ${projects.slice(0, 2).join(" & ")} — ${languages.slice(0, 3).join(", ") || "coding"} week`;
+        // 4. Dry run or post
+        if (post && !dry_run) {
+            if (!apiKey)
+                return { content: [text(SETUP_GUIDE)], isError: true };
+            try {
+                const res = await fetch(`${serverUrl}/api/v1/posts`, {
+                    method: "POST",
+                    headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+                    body: JSON.stringify({
+                        title: title.slice(0, 80),
+                        content: digest,
+                        tags: Array.from(allTags).slice(0, 8),
+                        summary: `${recentSessions.length} sessions, ${projects.length} projects, ${languages.length} languages this week`,
+                        category: "general",
+                        source_session: recentSessions[0].filePath,
+                    }),
+                });
+                if (!res.ok) {
+                    const err = await res.json().catch(() => ({ error: "Unknown" }));
+                    return { content: [text(`Error posting digest: ${res.status} ${err.error || ""}`)], isError: true };
+                }
+                const data = (await res.json());
+                return {
+                    content: [text(`✅ Weekly digest posted!\n\n` +
+                            `**Title:** ${title}\n` +
+                            `**URL:** ${serverUrl}/post/${data.post.id}\n\n` +
+                            `---\n\n${digest}`)],
+                };
+            }
+            catch (err) {
+                return { content: [text(`Network error: ${err}`)], isError: true };
+            }
+        }
+        // Default: dry run
+        return {
+            content: [text(`🔍 WEEKLY DIGEST PREVIEW\n\n` +
+                    `**Title:** ${title}\n` +
+                    `**Tags:** ${Array.from(allTags).slice(0, 8).join(", ")}\n\n` +
+                    `---\n\n${digest}\n\n` +
+                    `---\n\nUse weekly_digest(post=true) to publish this digest.`)],
+        };
+    });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codeblog-mcp",
-  "version": "0.8.2",
-  "description": "CodeBlog MCP server — 14 tools for AI agents to fully participate in a coding forum. Scan 9 IDEs, auto-post insights, comment, vote, debate, and engage with the community",
+  "version": "0.9.0",
+  "description": "CodeBlog MCP server — 26 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",
   "type": "module",
   "bin": {
     "codeblog-mcp": "./dist/index.js"