@lucianfialho/build-in-public-mcp 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lucian Fialho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,218 @@
+# Build in Public MCP Server
+
+> ✅ **v0.3.0 - AI-Powered Tweet Suggestions!**
+
+MCP (Model Context Protocol) server for Build in Public - automatically share your dev progress on Twitter directly from Claude Code.
+
+## 🎯 What is this?
+
+**The idea is simple:** If Claude Code is already helping you build, why not use it to document the journey too?
+
+This MCP server analyzes your coding sessions and generates intelligent tweet suggestions about what you accomplished. Share your dev journey without breaking flow!
+
+**Features:**
+- 🤖 **AI-powered tweet suggestions** - Analyzes your coding session and suggests tweets
+- 🔄 **Retrospective mode** (`/bp retro`) - Review entire session and extract achievements
+- 🐦 Post tweets immediately with `/bp` command
+- 🧵 Create threads about your dev progress
+- 🔐 OAuth authentication (tokens stored locally)
+- 💯 100% local - no external servers needed
+- ⚡ Fast STDIO transport
+
+## 📦 Installation
+
+### Method 1: NPX (Recommended)
+
+```bash
+claude mcp add --transport stdio build-in-public npx -y @lucianfialho/build-in-public-mcp
+```
+
+### Method 2: Global Install
+
+```bash
+npm install -g @lucianfialho/build-in-public-mcp
+claude mcp add --transport stdio build-in-public build-in-public-mcp
+```
+
+## 📖 How It Works
+
+**The Philosophy:** If Claude Code is already helping you code, why not help you share your journey too?
+
+1. **You code** - Claude Code assists you with development
+2. **Context is captured** - Files changed, commands run, achievements unlocked
+3. **AI analyzes** - When you run `/bp retro`, AI extracts meaningful insights
+4. **Suggestions generated** - Get tweet ideas about what you actually accomplished
+5. **One-click post** - Choose a suggestion and post to Twitter instantly
+
+## 🚀 Quick Start
+
+### 1. Setup Twitter Authentication
+
+You have **two options** for authentication:
+
+#### Option A: Interactive OAuth (Recommended)
+
+First time only:
+```
+You: How do I setup build in public?
+Claude: Let me help you setup Twitter authentication
+> Calls: mcp__bip__setup_auth
+> Opens browser for OAuth
+> You authorize the app
+> Copy PIN from Twitter
+> Paste in terminal
+✅ Done! Tokens saved to ~/.build-in-public/auth.json
+```
+
+#### Option B: Environment Variables
+
+Set these environment variables before starting Claude Code:
+
+```bash
+export TWITTER_API_KEY="your_api_key"
+export TWITTER_API_SECRET="your_api_secret"
+export TWITTER_ACCESS_TOKEN="your_access_token"
+export TWITTER_ACCESS_SECRET="your_access_secret"
+```
+
+**Where to get these credentials:**
+1. Go to [Twitter Developer Portal](https://developer.twitter.com/en/portal/dashboard)
+2. Create an app (or use existing)
+3. Go to "Keys and tokens"
+4. Copy API Key & Secret (Consumer Keys)
+5. Generate Access Token & Secret
+
+**Priority:** If both methods are configured, environment variables take precedence over `~/.build-in-public/auth.json`.
+
+### 2. Start Posting!
+
+#### Option 1: Quick Tweet
+Post immediately with a custom message:
+```
+/bp Just launched my new feature! 🚀
+```
+
+#### Option 2: AI-Powered Retro (Recommended!)
+Let AI analyze your entire coding session and suggest tweets:
+```
+/bp retro
+```
+
+Claude will:
+- Review everything you did this session
+- Extract achievements, learnings, and challenges
+- Generate multiple tweet suggestions with confidence scores
+- Let you choose or customize before posting
+
+**Example output:**
+```
+📊 Session Analysis Complete!
+
+Achievements:
+✅ Implemented OAuth authentication system
+✅ Fixed 3 critical bugs
+✅ Shipped v2.0 with new dashboard
+
+Based on your session, here are tweet suggestions:
+
+1. [85% confidence] "Just shipped v2.0! 🚀
+   New features: OAuth login, redesigned dashboard, 3 bugs squashed.
+   4 hours of flow state → production ready ✨ #BuildInPublic"
+
+2. [75% confidence] "💡 TIL: OAuth token refresh is trickier than I thought..."
+
+Which one would you like to post? (1-2, or provide custom message)
+```
+
+#### Option 3: AI Suggestions from Current Context
+```
+/bp
+```
+Gets suggestions based on what the hooks have captured so far.
+
+## 🛠️ Architecture
+
+```
+Claude Code → STDIO → MCP Server (local) → HTTPS → Twitter API
+                           ↓
+                 ~/.build-in-public/
+                 - auth.json (OAuth tokens)
+                 - context.json (Session context)
+                 - history.json (Tweet history)
+```
+
+**100% local, zero external infrastructure!**
+
+## 📚 Available Tools
+
+### `mcp__bip__tweet`
+Post a tweet immediately.
+
+**Input:**
+```json
+{
+  "message": "Your tweet message here (max 280 chars)"
+}
+```
+
+**Returns:** Tweet URL
+
+### `mcp__bip__thread`
+Create a Twitter thread from multiple messages. Posts tweets in reply chain.
+
+**Input:**
+```json
+{
+  "messages": ["Tweet 1", "Tweet 2", "Tweet 3"]
+}
+```
+
+**Returns:** Array of tweet URLs
+
+### `mcp__bip__setup_auth`
+Setup Twitter OAuth authentication via PIN-based flow.
+
+**Input:** None (interactive flow)
+
+**Returns:** Auth status and username
+
+### `mcp__bip__status`
+Check authentication status and show storage location.
+
+**Input:** None
+
+**Returns:** Status info including authenticated user
+
+## 🔐 Privacy & Security
+
+- ✅ OAuth tokens stored locally in `~/.build-in-public/auth.json`
+- ✅ Never sent to external servers (except Twitter API)
+- ✅ No analytics, no tracking, no telemetry
+- ✅ Open source - inspect the code yourself
+
+## 🗺️ Roadmap
+
+- [x] v0.1.0 - Basic MCP server + STDIO transport
+- [x] v0.2.0 - Twitter OAuth + tweet posting + thread creation ✅
+- [ ] v0.3.0 - MCP prompts + better error handling
+- [ ] v1.0.0 - Production ready + comprehensive docs
+- [ ] v1.1.0 - Skill for automatic context tracking
+- [ ] v2.0.0 - Optional Apify backend for analytics
+
+## 🤝 Contributing
+
+This is an early alpha! Contributions, issues, and feedback welcome.
+
+**Repository:** [github.com/lucianfialho/build-in-public-mcp](https://github.com/lucianfialho/build-in-public-mcp)
+
+## 📄 License
+
+MIT License - see LICENSE file for details
+
+## 🙏 Credits
+
+Built with [Claude Code](https://claude.com/code) and inspired by the #BuildInPublic community.
+
+---
+
+**Made with ❤️ for developers who build in public**

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Build in Public MCP Server
+ * Entry point for STDIO transport
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;GAGG"}

package/dist/index.js

@@ -0,0 +1,425 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Build in Public MCP Server
+ * Entry point for STDIO transport
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const oauth_js_1 = require("./utils/oauth.js");
+const twitter_js_1 = require("./services/twitter.js");
+const storage_js_1 = require("./services/storage.js");
+const suggestion_engine_js_1 = require("./services/suggestion-engine.js");
+// MCP Server instance
+const server = new index_js_1.Server({
+    name: 'build-in-public',
+    version: '0.3.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+/**
+ * List available tools
+ */
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'mcp__bip__tweet',
+                description: 'Post a tweet immediately for build in public. Requires authentication.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        message: {
+                            type: 'string',
+                            description: 'The tweet message to post (max 280 characters)',
+                        },
+                    },
+                    required: ['message'],
+                },
+            },
+            {
+                name: 'mcp__bip__thread',
+                description: 'Create a Twitter thread from multiple messages. Posts tweets in reply chain.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        messages: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Array of tweet messages for the thread',
+                        },
+                        replyToTweetId: {
+                            type: 'string',
+                            description: 'Optional: Tweet ID to reply to (creates thread as replies to this tweet)',
+                        },
+                    },
+                    required: ['messages'],
+                },
+            },
+            {
+                name: 'mcp__bip__setup_auth',
+                description: 'Setup Twitter authentication via OAuth 1.0a (PIN-based flow)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'mcp__bip__status',
+                description: 'Check authentication status and storage location',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'mcp__bip__suggest',
+                description: 'Generate intelligent tweet suggestions based on session context',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        contextId: {
+                            type: 'string',
+                            description: 'Optional context ID (uses current session if not provided)',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'mcp__bip__save_context',
+                description: 'Save session context for later analysis and suggestions',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        context: {
+                            type: 'object',
+                            description: 'Session context data',
+                        },
+                    },
+                    required: ['context'],
+                },
+            },
+            {
+                name: 'mcp__bip__get_context',
+                description: 'Retrieve current session context',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        contextId: {
+                            type: 'string',
+                            description: 'Optional context ID (uses current session if not provided)',
+                        },
+                    },
+                },
+            },
+        ],
+    };
+});
+/**
+ * Handle tool calls
+ */
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'mcp__bip__tweet': {
+                const { message } = args;
+                if (!message) {
+                    throw new Error('Message is required');
+                }
+                if (message.length > 280) {
+                    throw new Error(`Tweet is too long (${message.length} characters, max 280)`);
+                }
+                // Check authentication
+                if (!(0, twitter_js_1.isAuthenticated)()) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: '❌ Not authenticated\n\n' +
+                                    'Please run mcp__bip__setup_auth first to authenticate with Twitter.',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Post tweet
+                const result = await (0, twitter_js_1.postTweet)(message);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Tweet posted successfully!\n\n` +
+                                `🔗 ${result.url}\n\n` +
+                                `Message: "${message}"`,
+                        },
+                    ],
+                };
+            }
+            case 'mcp__bip__thread': {
+                const { messages, replyToTweetId } = args;
+                if (!messages || messages.length === 0) {
+                    throw new Error('Thread must have at least one message');
+                }
+                // Validate message lengths
+                for (let i = 0; i < messages.length; i++) {
+                    if (messages[i].length > 280) {
+                        throw new Error(`Message ${i + 1} is too long (${messages[i].length} characters, max 280)`);
+                    }
+                }
+                // Check authentication
+                if (!(0, twitter_js_1.isAuthenticated)()) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: '❌ Not authenticated\n\n' +
+                                    'Please run mcp__bip__setup_auth first to authenticate with Twitter.',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                // Post thread
+                const result = await (0, twitter_js_1.postThread)(messages, replyToTweetId);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Thread posted successfully!\n\n` +
+                                `🧵 ${messages.length} tweets in thread\n` +
+                                `🔗 Thread starts at: ${result.urls[0]}\n\n` +
+                                `All tweet URLs:\n${result.urls.map((url, i) => `  ${i + 1}. ${url}`).join('\n')}`,
+                        },
+                    ],
+                };
+            }
+            case 'mcp__bip__setup_auth': {
+                console.error('\n🔐 Starting OAuth setup...\n');
+                console.error('⚠️  IMPORTANT: This is an interactive flow.');
+                console.error('   Make sure you are running this in a terminal (not via Claude Code UI).\n');
+                try {
+                    const tokens = await (0, oauth_js_1.performOAuthFlow)();
+                    // Verify credentials
+                    const user = await (0, twitter_js_1.verifyCredentials)();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `✅ Authentication successful!\n\n` +
+                                    `👤 Authenticated as: @${user.username} (${user.name})\n` +
+                                    `💾 Tokens saved to: ${(0, storage_js_1.getStorageDir)()}/auth.json\n\n` +
+                                    `You can now use:\n` +
+                                    `  - mcp__bip__tweet to post tweets\n` +
+                                    `  - mcp__bip__thread to create threads`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ OAuth setup failed\n\n` +
+                                    `Error: ${errorMessage}\n\n` +
+                                    `Make sure you:\n` +
+                                    `  1. Have valid Twitter API credentials\n` +
+                                    `  2. Authorized the app on Twitter\n` +
+                                    `  3. Entered the correct PIN code`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            }
+            case 'mcp__bip__status': {
+                const authenticated = (0, twitter_js_1.isAuthenticated)();
+                let statusText = `📊 Build in Public MCP Server Status\n\n`;
+                statusText += `Version: 0.3.0\n`;
+                statusText += `Storage: ${(0, storage_js_1.getStorageDir)()}\n\n`;
+                // Debug: Show env vars status
+                statusText += `🔍 Environment Variables:\n`;
+                statusText += `  TWITTER_API_KEY: ${process.env.TWITTER_API_KEY ? '✅ Set' : '❌ Not set'}\n`;
+                statusText += `  TWITTER_API_SECRET: ${process.env.TWITTER_API_SECRET ? '✅ Set' : '❌ Not set'}\n`;
+                statusText += `  TWITTER_ACCESS_TOKEN: ${process.env.TWITTER_ACCESS_TOKEN ? '✅ Set' : '❌ Not set'}\n`;
+                statusText += `  TWITTER_ACCESS_SECRET: ${process.env.TWITTER_ACCESS_SECRET ? '✅ Set' : '❌ Not set'}\n\n`;
+                if (authenticated) {
+                    try {
+                        const user = await (0, twitter_js_1.verifyCredentials)();
+                        statusText += `✅ Authenticated as: @${user.username} (${user.name})\n\n`;
+                        statusText += `Available tools:\n`;
+                        statusText += `  - mcp__bip__tweet - Post immediate tweets\n`;
+                        statusText += `  - mcp__bip__thread - Create Twitter threads\n`;
+                    }
+                    catch (error) {
+                        statusText += `⚠️  Authentication file exists but credentials are invalid\n`;
+                        statusText += `   Run mcp__bip__setup_auth to re-authenticate\n`;
+                    }
+                }
+                else {
+                    statusText += `❌ Not authenticated\n\n`;
+                    statusText += `Run mcp__bip__setup_auth to authenticate with Twitter\n`;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: statusText,
+                        },
+                    ],
+                };
+            }
+            case 'mcp__bip__suggest': {
+                // Load session context
+                const context = (0, storage_js_1.loadSessionContext)();
+                if (!context) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: '⚠️  No session context found\n\n' +
+                                    'Start coding and the system will automatically track your session. ' +
+                                    'Or save context manually using mcp__bip__save_context.',
+                            },
+                        ],
+                    };
+                }
+                // Generate suggestions
+                const suggestions = (0, suggestion_engine_js_1.generateSuggestions)(context);
+                const confidence = (0, suggestion_engine_js_1.scoreConfidence)(context);
+                if (suggestions.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: '💡 No strong suggestions yet\n\n' +
+                                    `Session confidence: ${(confidence * 100).toFixed(0)}%\n\n` +
+                                    'Keep working! Suggestions will appear when:\n' +
+                                    '  - You commit code to git\n' +
+                                    '  - You modify multiple files\n' +
+                                    '  - You log achievements or learnings',
+                            },
+                        ],
+                    };
+                }
+                let responseText = `💡 Tweet Suggestions (${suggestions.length})\n\n`;
+                responseText += `Overall confidence: ${(confidence * 100).toFixed(0)}%\n\n`;
+                suggestions.forEach((suggestion, index) => {
+                    responseText += `${index + 1}. [${(suggestion.confidence * 100).toFixed(0)}% confidence] ${suggestion.type}\n`;
+                    responseText += `   ${suggestion.reason}\n\n`;
+                    responseText += `   "${suggestion.message}"\n\n`;
+                });
+                responseText += `\nUse mcp__bip__tweet to post any of these suggestions!`;
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: responseText,
+                        },
+                    ],
+                };
+            }
+            case 'mcp__bip__save_context': {
+                const { context } = args;
+                if (!context) {
+                    throw new Error('Context is required');
+                }
+                // Save the context
+                (0, storage_js_1.saveSessionContext)(context);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '💾 Session context saved successfully!\n\n' +
+                                `Files modified: ${context.filesModified?.length || 0}\n` +
+                                `Commands run: ${context.commandsRun?.length || 0}\n` +
+                                `Commits: ${context.commits?.length || 0}\n\n` +
+                                'Use mcp__bip__suggest to generate tweet suggestions based on this context.',
+                        },
+                    ],
+                };
+            }
+            case 'mcp__bip__get_context': {
+                const context = (0, storage_js_1.loadSessionContext)();
+                if (!context) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: '⚠️  No session context found\n\n' +
+                                    'Context will be automatically created as you work, or you can save context manually using mcp__bip__save_context.',
+                            },
+                        ],
+                    };
+                }
+                let contextText = `📊 Session Context\n\n`;
+                contextText += `Session ID: ${context.sessionId}\n`;
+                contextText += `Started: ${new Date(context.startTime).toLocaleString()}\n`;
+                if (context.lastUpdated) {
+                    contextText += `Last updated: ${new Date(context.lastUpdated).toLocaleString()}\n`;
+                }
+                contextText += `\n`;
+                contextText += `📁 Files modified: ${context.filesModified?.length || 0}\n`;
+                contextText += `⚙️  Commands run: ${context.commandsRun?.length || 0}\n`;
+                contextText += `🔧 Tools used: ${context.toolsUsed?.length || 0}\n`;
+                contextText += `💬 User messages: ${context.userMessages?.length || 0}\n`;
+                contextText += `📝 Git commits: ${context.commits?.length || 0}\n`;
+                contextText += `✅ Achievements: ${context.achievements?.length || 0}\n`;
+                contextText += `🎯 Challenges: ${context.challenges?.length || 0}\n`;
+                contextText += `💡 Learnings: ${context.learnings?.length || 0}\n\n`;
+                if (context.shouldTweet) {
+                    contextText += `🐦 Ready to tweet: Yes\n`;
+                    if (context.triggerMessage) {
+                        contextText += `Trigger: "${context.triggerMessage}"\n`;
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: contextText,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `❌ Error: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+/**
+ * Start the server using STDIO transport
+ */
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    // Log to stderr (stdout is used for MCP protocol)
+    console.error('🚀 Build in Public MCP Server started');
+    console.error('📍 Version: 0.2.0');
+    console.error('🔗 Transport: STDIO');
+    console.error('💾 Storage:', (0, storage_js_1.getStorageDir)());
+    console.error('');
+}
+main().catch((error) => {
+    console.error('❌ Failed to start server:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map