tachibot-mcp 2.0.2

package/dist/src/sequential-thinking.js

@@ -0,0 +1,291 @@
+/**
+ * Sequential Thinking Implementation
+ * Based on the official MCP Sequential Thinking server
+ * Enhanced with multi-model orchestration capabilities
+ */
+import { z } from "zod";
+export class SequentialThinking {
+    constructor() {
+        this.sessions = new Map();
+        this.currentSessionId = null;
+    }
+    /**
+     * Start a new sequential thinking session
+     */
+    startSession(objective, estimatedThoughts = 5) {
+        const sessionId = this.generateSessionId();
+        const session = {
+            id: sessionId,
+            thoughts: [],
+            currentThought: 0,
+            totalThoughts: estimatedThoughts,
+            status: "active",
+            objective
+        };
+        this.sessions.set(sessionId, session);
+        this.currentSessionId = sessionId;
+        return sessionId;
+    }
+    /**
+     * Add a next thought to the session
+     */
+    nextThought(thought, nextThoughtNeeded, thoughtNumber, totalThoughts, isRevision, revisesThought, branchFromThought, model) {
+        const session = this.getCurrentSession();
+        if (!session) {
+            throw new Error("No active thinking session");
+        }
+        // Handle branching
+        if (branchFromThought !== undefined) {
+            return this.branchThinking(session, thought, branchFromThought, model);
+        }
+        // Create the thought object
+        const newThought = {
+            number: thoughtNumber || session.currentThought + 1,
+            content: thought,
+            model: model || "default",
+            timestamp: new Date(),
+            isRevision,
+            revisesThought
+        };
+        // Handle revision
+        if (isRevision && revisesThought !== undefined) {
+            // Mark the original thought as revised
+            const originalThought = session.thoughts.find(t => t.number === revisesThought);
+            if (originalThought) {
+                originalThought.metadata = {
+                    ...originalThought.metadata,
+                    revisedBy: newThought.number
+                };
+            }
+        }
+        // Add the thought
+        session.thoughts.push(newThought);
+        session.currentThought = newThought.number;
+        // Update total thoughts if provided
+        if (totalThoughts !== undefined) {
+            session.totalThoughts = totalThoughts;
+        }
+        // Check if we're done
+        if (!nextThoughtNeeded) {
+            session.status = "completed";
+        }
+        // Generate guidance for next step
+        const guidance = this.generateGuidance(session, nextThoughtNeeded);
+        return {
+            thoughtAdded: newThought,
+            sessionStatus: session,
+            guidance
+        };
+    }
+    /**
+     * Branch the thinking into an alternative path
+     */
+    branchThinking(session, thought, branchFromThought, model) {
+        // Create a new branch session
+        const branchId = `${session.id}_branch_${Date.now()}`;
+        // Copy thoughts up to branch point
+        const branchSession = {
+            id: branchId,
+            thoughts: session.thoughts
+                .filter(t => t.number <= branchFromThought)
+                .map(t => ({ ...t })),
+            currentThought: branchFromThought,
+            totalThoughts: session.totalThoughts,
+            status: "active",
+            objective: session.objective,
+            context: `Branch from thought ${branchFromThought}`
+        };
+        // Add the new branching thought
+        const newThought = {
+            number: branchFromThought + 1,
+            content: thought,
+            model: model || "default",
+            timestamp: new Date(),
+            branchFromThought
+        };
+        branchSession.thoughts.push(newThought);
+        branchSession.currentThought = newThought.number;
+        // Store the branch
+        if (!session.branches) {
+            session.branches = [];
+        }
+        session.branches.push(branchSession);
+        this.sessions.set(branchId, branchSession);
+        return {
+            thoughtAdded: newThought,
+            sessionStatus: branchSession,
+            guidance: `Branched from thought ${branchFromThought}. New branch ID: ${branchId}`
+        };
+    }
+    /**
+     * Generate guidance for the next thinking step
+     */
+    generateGuidance(session, continueThinking) {
+        if (!continueThinking) {
+            return this.generateSummary(session);
+        }
+        const progress = (session.currentThought / session.totalThoughts) * 100;
+        const thoughtsSoFar = session.thoughts.length;
+        let guidance = `## Thinking Progress: ${progress.toFixed(0)}%\n\n`;
+        guidance += `Thoughts completed: ${thoughtsSoFar}/${session.totalThoughts}\n\n`;
+        // Suggest next steps based on progress
+        if (progress < 30) {
+            guidance += "🔍 **Early Stage**: Focus on understanding and decomposing the problem.\n";
+            guidance += "Consider: What are the key components? What constraints exist?\n";
+        }
+        else if (progress < 60) {
+            guidance += "🔧 **Middle Stage**: Explore solutions and alternatives.\n";
+            guidance += "Consider: What approaches could work? What are the trade-offs?\n";
+            guidance += "You may want to branch to explore alternatives.\n";
+        }
+        else if (progress < 90) {
+            guidance += "🎯 **Late Stage**: Refine and validate your approach.\n";
+            guidance += "Consider: Are there edge cases? Can we optimize further?\n";
+            guidance += "You may want to revise earlier thoughts with new insights.\n";
+        }
+        else {
+            guidance += "✨ **Final Stage**: Synthesize and conclude.\n";
+            guidance += "Consider: What's the final solution? What are the next steps?\n";
+        }
+        // Check if revision might be helpful
+        if (thoughtsSoFar > 3 && !session.thoughts.some(t => t.isRevision)) {
+            guidance += "\n💡 **Tip**: Consider revising earlier thoughts if new insights emerged.\n";
+        }
+        return guidance;
+    }
+    /**
+     * Generate a summary of the thinking session
+     */
+    generateSummary(session) {
+        let summary = `## 🎯 Thinking Session Complete\n\n`;
+        summary += `**Objective**: ${session.objective || "Not specified"}\n`;
+        summary += `**Total Thoughts**: ${session.thoughts.length}\n`;
+        // Count revisions and branches
+        const revisions = session.thoughts.filter(t => t.isRevision).length;
+        const branches = session.branches?.length || 0;
+        if (revisions > 0) {
+            summary += `**Revisions Made**: ${revisions}\n`;
+        }
+        if (branches > 0) {
+            summary += `**Alternative Branches**: ${branches}\n`;
+        }
+        summary += `\n### Thought Progression:\n\n`;
+        // Group thoughts by model if multi-model
+        const modelGroups = new Map();
+        session.thoughts.forEach(thought => {
+            const model = thought.model || "default";
+            if (!modelGroups.has(model)) {
+                modelGroups.set(model, []);
+            }
+            modelGroups.get(model).push(thought);
+        });
+        if (modelGroups.size > 1) {
+            summary += "**Multi-Model Contributions**:\n";
+            modelGroups.forEach((thoughts, model) => {
+                summary += `- ${model}: ${thoughts.length} thoughts\n`;
+            });
+            summary += "\n";
+        }
+        // Key thoughts
+        summary += "### Key Insights:\n\n";
+        // First thought (problem understanding)
+        if (session.thoughts[0]) {
+            summary += `1. **Initial Understanding** (Thought 1):\n   ${session.thoughts[0].content.substring(0, 200)}...\n\n`;
+        }
+        // Middle insight (if exists)
+        const middleIdx = Math.floor(session.thoughts.length / 2);
+        if (session.thoughts[middleIdx] && session.thoughts.length > 2) {
+            summary += `2. **Mid-Process Insight** (Thought ${middleIdx + 1}):\n   ${session.thoughts[middleIdx].content.substring(0, 200)}...\n\n`;
+        }
+        // Final conclusion
+        const lastThought = session.thoughts[session.thoughts.length - 1];
+        if (lastThought) {
+            summary += `3. **Final Conclusion** (Thought ${lastThought.number}):\n   ${lastThought.content.substring(0, 300)}...\n\n`;
+        }
+        // Branches summary
+        if (session.branches && session.branches.length > 0) {
+            summary += "### Alternative Paths Explored:\n";
+            session.branches.forEach((branch, idx) => {
+                summary += `- Branch ${idx + 1}: ${branch.context || "Alternative approach"}\n`;
+            });
+        }
+        return summary;
+    }
+    /**
+     * Get current session
+     */
+    getCurrentSession() {
+        if (!this.currentSessionId)
+            return null;
+        return this.sessions.get(this.currentSessionId) || null;
+    }
+    /**
+     * List all sessions
+     */
+    listSessions() {
+        const all = Array.from(this.sessions.values());
+        return {
+            active: all.filter(s => s.status === "active"),
+            completed: all.filter(s => s.status === "completed")
+        };
+    }
+    /**
+     * Generate session ID
+     */
+    generateSessionId() {
+        return `think_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Create multi-model thinking chain
+     */
+    createMultiModelChain(objective, models) {
+        const sessionId = this.startSession(objective, models.length);
+        let plan = `## Multi-Model Sequential Thinking Plan\n\n`;
+        plan += `**Objective**: ${objective}\n`;
+        plan += `**Models**: ${models.join(" → ")}\n\n`;
+        plan += `### Execution Steps:\n\n`;
+        models.forEach((model, idx) => {
+            const stage = this.getStageDescription(idx, models.length);
+            plan += `${idx + 1}. **${model}**: ${stage}\n`;
+        });
+        plan += `\n### How to Execute:\n`;
+        plan += `Use \`nextThought\` with each model in sequence.\n`;
+        plan += `Each model builds on previous thoughts.\n`;
+        plan += `Revise or branch as insights emerge.\n`;
+        return { sessionId, plan };
+    }
+    /**
+     * Get stage description based on position
+     */
+    getStageDescription(index, total) {
+        const position = index / total;
+        if (position === 0) {
+            return "Initial analysis and problem decomposition";
+        }
+        else if (position < 0.3) {
+            return "Explore approaches and identify constraints";
+        }
+        else if (position < 0.6) {
+            return "Develop and evaluate solutions";
+        }
+        else if (position < 0.8) {
+            return "Refine and optimize approach";
+        }
+        else {
+            return "Synthesize insights and finalize solution";
+        }
+    }
+}
+// Export singleton instance
+export const sequentialThinking = new SequentialThinking();
+// Schema for tool parameters
+export const NextThoughtSchema = z.object({
+    thought: z.string(),
+    nextThoughtNeeded: z.boolean(),
+    thoughtNumber: z.number().optional(),
+    totalThoughts: z.number().optional(),
+    isRevision: z.boolean().optional(),
+    revisesThought: z.number().optional(),
+    branchFromThought: z.number().optional(),
+    model: z.string().optional()
+});

package/dist/src/server-diagnostic.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// IMMEDIATE DIAGNOSTIC - Log before ANY imports or operations
+console.error("🔴 DIAGNOSTIC: Script started at", new Date().toISOString());
+console.error("🔴 DIAGNOSTIC: Process info:", {
+    pid: process.pid,
+    cwd: process.cwd(),
+    argv: process.argv,
+    nodeVersion: process.version,
+    platform: process.platform
+});
+// Keep alive IMMEDIATELY
+process.stdin.resume();
+const keepAlive = setInterval(() => { }, 2147483647); // Max 32-bit int
+console.error("🔴 DIAGNOSTIC: Keepalive set");
+// Now try imports
+console.error("🔴 DIAGNOSTIC: Starting imports...");
+(async () => {
+    try {
+        // Test if we can even import
+        const { FastMCP } = await import("fastmcp");
+        const { z } = await import("zod");
+        console.error("🔴 DIAGNOSTIC: FastMCP imported successfully");
+        const server = new FastMCP({
+            name: "tachibot-mcp",
+            version: "2.0.0"
+        });
+        console.error("🔴 DIAGNOSTIC: FastMCP instance created");
+        // Add a simple tool
+        server.addTool({
+            name: "diagnostic_test",
+            description: "Test diagnostic tool",
+            parameters: z.object({
+                message: z.string()
+            }),
+            execute: async (args) => {
+                console.error("🔴 DIAGNOSTIC: Tool executed with:", args);
+                return `Diagnostic response: ${args.message}`;
+            }
+        });
+        console.error("🔴 DIAGNOSTIC: Tool added");
+        // Start server
+        console.error("🔴 DIAGNOSTIC: Starting server...");
+        server.start({
+            transportType: "stdio"
+        });
+        console.error("🔴 DIAGNOSTIC: Server.start() called");
+    }
+    catch (error) {
+        console.error("🔴 DIAGNOSTIC ERROR:", error);
+        console.error("🔴 DIAGNOSTIC: Keeping process alive despite error");
+    }
+})();
+// Add multiple safety nets
+process.on('SIGINT', () => {
+    console.error('🔴 DIAGNOSTIC: SIGINT received');
+    clearInterval(keepAlive);
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    console.error('🔴 DIAGNOSTIC: SIGTERM received');
+    clearInterval(keepAlive);
+    process.exit(0);
+});
+process.on('uncaughtException', (error) => {
+    console.error('🔴 DIAGNOSTIC: Uncaught Exception:', error);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('🔴 DIAGNOSTIC: Unhandled Rejection:', reason);
+});
+process.on('exit', (code) => {
+    console.error('🔴 DIAGNOSTIC: Process exiting with code:', code);
+});
+console.error("🔴 DIAGNOSTIC: All handlers set, process should stay alive");
+export {};

package/dist/src/server-raw.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+// IMMEDIATE LOG - Before ANY code execution
+process.stderr.write("🔥 RAW MCP: Process started PID=" + process.pid + "\n");
+// RAW MCP Server - No FastMCP dependency
+console.error("🟢 RAW MCP: Starting at", new Date().toISOString());
+// Keep process alive
+process.stdin.resume();
+setInterval(() => {
+    console.error("🟢 RAW MCP: Heartbeat", new Date().toISOString());
+}, 30000);
+console.error("🟢 RAW MCP: Setting up readline for JSON-RPC");
+import * as readline from 'readline';
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+});
+// Server capabilities
+const serverInfo = {
+    name: "tachibot-mcp",
+    version: "2.0.0"
+};
+const tools = {
+    test: {
+        description: "Test tool",
+        inputSchema: {
+            type: "object",
+            properties: {
+                message: { type: "string" }
+            }
+        }
+    },
+    think: {
+        description: "Log a thought",
+        inputSchema: {
+            type: "object",
+            properties: {
+                thought: { type: "string" }
+            }
+        }
+    }
+};
+// Send JSON-RPC response
+function sendResponse(id, result) {
+    const response = {
+        jsonrpc: "2.0",
+        id: id,
+        result: result
+    };
+    console.log(JSON.stringify(response));
+    console.error("🟢 RAW MCP: Sent response for id", id);
+}
+// Send JSON-RPC error
+function sendError(id, code, message) {
+    const response = {
+        jsonrpc: "2.0",
+        id: id,
+        error: {
+            code: code,
+            message: message
+        }
+    };
+    console.log(JSON.stringify(response));
+    console.error("🟢 RAW MCP: Sent error for id", id);
+}
+// Handle JSON-RPC requests
+rl.on('line', (line) => {
+    console.error("🟢 RAW MCP: Received line:", line.substring(0, 100) + "...");
+    try {
+        const request = JSON.parse(line);
+        console.error("🟢 RAW MCP: Parsed request method:", request.method);
+        if (request.method === "initialize") {
+            console.error("🟢 RAW MCP: Handling initialize");
+            // Match the client's protocol version
+            const clientVersion = request.params?.protocolVersion || "2024-11-05";
+            console.error("🟢 RAW MCP: Client protocol version:", clientVersion);
+            sendResponse(request.id, {
+                protocolVersion: clientVersion, // Echo back client's version
+                capabilities: {
+                    tools: {}
+                },
+                serverInfo: serverInfo
+            });
+        }
+        else if (request.method === "initialized") {
+            console.error("🟢 RAW MCP: Client initialized");
+            // No response needed for notification
+        }
+        else if (request.method === "tools/list") {
+            console.error("🟢 RAW MCP: Listing tools");
+            sendResponse(request.id, {
+                tools: Object.entries(tools).map(([name, tool]) => ({
+                    name: name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema
+                }))
+            });
+        }
+        else if (request.method === "tools/call") {
+            console.error("🟢 RAW MCP: Tool call:", request.params?.name);
+            const toolName = request.params?.name;
+            const args = request.params?.arguments || {};
+            if (toolName === "test") {
+                sendResponse(request.id, {
+                    content: [{
+                            type: "text",
+                            text: `Test response: ${args.message || "no message"}`
+                        }]
+                });
+            }
+            else if (toolName === "think") {
+                console.error("🟢 RAW MCP: Think:", args.thought);
+                sendResponse(request.id, {
+                    content: [{
+                            type: "text",
+                            text: `Thought recorded: ${args.thought || "no thought"}`
+                        }]
+                });
+            }
+            else {
+                sendError(request.id, -32601, `Unknown tool: ${toolName}`);
+            }
+        }
+        else {
+            console.error("🟢 RAW MCP: Unknown method:", request.method);
+            sendError(request.id, -32601, `Method not found: ${request.method}`);
+        }
+    }
+    catch (error) {
+        console.error("🟢 RAW MCP: Error processing request:", error);
+        // Try to send error response if we can parse the id
+        try {
+            const partial = JSON.parse(line);
+            if (partial.id) {
+                sendError(partial.id, -32700, "Parse error");
+            }
+        }
+        catch {
+            // Can't even parse id, ignore
+        }
+    }
+});
+// Handle errors and signals
+process.on('SIGINT', () => {
+    console.error('🟢 RAW MCP: SIGINT received');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    console.error('🟢 RAW MCP: SIGTERM received');
+    process.exit(0);
+});
+process.on('uncaughtException', (error) => {
+    console.error('🟢 RAW MCP: Uncaught Exception:', error);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error('🟢 RAW MCP: Unhandled Rejection:', reason);
+});
+console.error("🟢 RAW MCP: Server ready and listening");

package/dist/src/server-simple.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// Simplified server with guaranteed keepalive
+import { FastMCP } from "fastmcp";
+import { z } from "zod";
+// CRITICAL: Keep the process alive FIRST
+process.stdin.resume();
+setInterval(() => { }, 1 << 30); // Keepalive forever
+// Log to stderr only
+const log = (...args) => console.error(...args);
+log("🚀 TachiBot MCP Server (Simplified) Starting...");
+const server = new FastMCP({
+    name: "tachibot-mcp",
+    version: "2.0.0"
+});
+// Add minimal test tools
+server.addTool({
+    name: "think",
+    description: "Log a thought",
+    parameters: z.object({
+        thought: z.string()
+    }),
+    execute: async (args) => {
+        log("Think:", args.thought);
+        return `Thought recorded: ${args.thought}`;
+    }
+});
+server.addTool({
+    name: "test",
+    description: "Test tool",
+    parameters: z.object({
+        message: z.string()
+    }),
+    execute: async (args) => {
+        return `Test response: ${args.message}`;
+    }
+});
+// Start server
+log("Starting FastMCP server...");
+server.start({
+    transportType: "stdio"
+});
+log("✅ Server started and will stay alive");
+// Handle signals
+process.on('SIGINT', () => {
+    log('Received SIGINT, shutting down...');
+    process.exit(0);
+});
+process.on('SIGTERM', () => {
+    log('Received SIGTERM, shutting down...');
+    process.exit(0);
+});
+// Log any errors but don't crash
+process.on('uncaughtException', (error) => {
+    log('Uncaught Exception:', error);
+});
+process.on('unhandledRejection', (reason) => {
+    log('Unhandled Rejection:', reason);
+});