tachibot-mcp 2.0.2

package/dist/src/tools/qwen-wrapper.js

@@ -0,0 +1,74 @@
+/**
+ * Wrapper tool to access OpenRouter/Qwen tools
+ * Since they don't show in Claude's UI, this provides a single entry point
+ */
+import { z } from "zod";
+import { qwenCoderTool, qwqReasoningTool, qwenGeneralTool, qwenCompetitiveTool, openRouterMultiModelTool } from "./openrouter-tools.js";
+/**
+ * Unified Qwen tool that wraps all OpenRouter tools
+ */
+export const qwenTool = {
+    name: "qwen",
+    description: "Access Qwen3-Coder, QwQ reasoning, and other OpenRouter models",
+    parameters: z.object({
+        tool: z.enum(["coder", "reason", "general", "competitive", "multi"]),
+        // Coder parameters
+        task: z.enum(["generate", "review", "optimize", "debug", "refactor", "explain"]).optional(),
+        code: z.string().optional(),
+        requirements: z.string().optional(),
+        language: z.string().optional(),
+        // Reasoning parameters
+        problem: z.string().optional(),
+        approach: z.enum(["logical", "mathematical", "systematic", "critical"]).optional(),
+        // General/Multi parameters
+        query: z.string().optional(),
+        model: z.string().optional(),
+        // Common
+        useFree: z.boolean().optional().default(false)
+    }),
+    execute: async (args, { log }) => {
+        log?.info(`Using Qwen tool: ${args.tool}`);
+        switch (args.tool) {
+            case "coder":
+                return await qwenCoderTool.execute({
+                    task: args.task || "generate",
+                    code: args.code,
+                    requirements: args.requirements || args.query || "",
+                    language: args.language,
+                    useFree: args.useFree
+                }, { log });
+            case "reason":
+                return await qwqReasoningTool.execute({
+                    problem: args.problem || args.query || args.requirements || "",
+                    approach: args.approach,
+                    useFree: args.useFree
+                }, { log });
+            case "general":
+                return await qwenGeneralTool.execute({
+                    query: args.query || args.requirements || args.problem || "",
+                    mode: "general",
+                    useFree: args.useFree
+                }, { log });
+            case "competitive":
+                return await qwenCompetitiveTool.execute({
+                    problem: args.problem || args.query || args.requirements || "",
+                    language: args.language,
+                    optimize: true
+                }, { log });
+            case "multi":
+                return await openRouterMultiModelTool.execute({
+                    query: args.query || args.requirements || args.problem || "",
+                    model: args.model || "qwen/qwen3-coder",
+                    temperature: 0.7
+                }, { log });
+            default:
+                return "Unknown tool. Use: coder, reason, general, competitive, or multi";
+        }
+    }
+};
+/**
+ * Export the wrapper tool
+ */
+export function getQwenWrapperTool() {
+    return qwenTool;
+}

package/dist/src/tools/tool-router.js

@@ -0,0 +1,444 @@
+/**
+ * Smart Tool Router for Focus MCP Server
+ * Manages tool selection based on availability, preferences, and capabilities
+ */
+// Tool capability categories
+export var ToolCategory;
+(function (ToolCategory) {
+    ToolCategory["REASONING"] = "reasoning";
+    ToolCategory["CODE"] = "code";
+    ToolCategory["BRAINSTORM"] = "brainstorm";
+    ToolCategory["SEARCH"] = "search";
+    ToolCategory["ANALYSIS"] = "analysis";
+    ToolCategory["DEBUG"] = "debug";
+})(ToolCategory || (ToolCategory = {}));
+// Tool provider types
+export var ToolProvider;
+(function (ToolProvider) {
+    ToolProvider["OPENAI"] = "openai";
+    ToolProvider["GROK"] = "grok";
+    ToolProvider["PERPLEXITY"] = "perplexity";
+    ToolProvider["GEMINI"] = "gemini";
+    ToolProvider["OPENROUTER"] = "openrouter";
+    ToolProvider["LMSTUDIO"] = "lmstudio";
+    ToolProvider["INTERNAL"] = "internal";
+})(ToolProvider || (ToolProvider = {}));
+/**
+ * Smart Tool Router Class
+ */
+export class ToolRouter {
+    constructor(preferences = {}) {
+        this.preferences = {
+            fallbackEnabled: true,
+            costOptimization: false,
+            speedPriority: false,
+            qualityPriority: true,
+            verboseLogging: false,
+            ...preferences
+        };
+        this.registry = this.initializeRegistry();
+        this.toolCache = new Map();
+    }
+    /**
+     * Initialize the tool registry with all available tools
+     */
+    initializeRegistry() {
+        return {
+            [ToolCategory.REASONING]: [
+                {
+                    name: "gpt5_reason",
+                    provider: ToolProvider.OPENAI,
+                    categories: [ToolCategory.REASONING],
+                    priority: 1,
+                    costTier: "high",
+                    speedTier: "medium",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.OPENAI_API_KEY && process.env.ENABLE_GPT5 === 'true'
+                },
+                {
+                    name: "gpt5_mini_reason",
+                    provider: ToolProvider.OPENAI,
+                    categories: [ToolCategory.REASONING],
+                    priority: 2,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                },
+                {
+                    name: "qwq_reason",
+                    provider: ToolProvider.OPENROUTER,
+                    categories: [ToolCategory.REASONING],
+                    priority: 3,
+                    costTier: "medium",
+                    speedTier: "medium",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.OPENROUTER_API_KEY
+                },
+                {
+                    name: "grok_reason",
+                    provider: ToolProvider.GROK,
+                    categories: [ToolCategory.REASONING],
+                    priority: 4,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.GROK_API_KEY
+                },
+                {
+                    name: "perplexity_reason",
+                    provider: ToolProvider.PERPLEXITY,
+                    categories: [ToolCategory.REASONING, ToolCategory.SEARCH],
+                    priority: 5,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "good",
+                    checkAvailability: () => !!process.env.PERPLEXITY_API_KEY
+                },
+                {
+                    name: "gemini_query",
+                    provider: ToolProvider.GEMINI,
+                    categories: [ToolCategory.REASONING],
+                    priority: 6,
+                    costTier: "low",
+                    speedTier: "fast",
+                    qualityTier: "good",
+                    checkAvailability: () => !!process.env.GOOGLE_API_KEY
+                }
+            ],
+            [ToolCategory.CODE]: [
+                {
+                    name: "qwen_coder",
+                    provider: ToolProvider.OPENROUTER,
+                    categories: [ToolCategory.CODE],
+                    priority: 1,
+                    costTier: "medium",
+                    speedTier: "medium",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.OPENROUTER_API_KEY
+                },
+                {
+                    name: "grok_code",
+                    provider: ToolProvider.GROK,
+                    categories: [ToolCategory.CODE, ToolCategory.ANALYSIS],
+                    priority: 2,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.GROK_API_KEY
+                },
+                {
+                    name: "gpt5_code",
+                    provider: ToolProvider.OPENAI,
+                    categories: [ToolCategory.CODE, ToolCategory.ANALYSIS],
+                    priority: 3,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                },
+                {
+                    name: "gemini_analyze_code",
+                    provider: ToolProvider.GEMINI,
+                    categories: [ToolCategory.CODE, ToolCategory.ANALYSIS],
+                    priority: 4,
+                    costTier: "low",
+                    speedTier: "fast",
+                    qualityTier: "good",
+                    checkAvailability: () => !!process.env.GOOGLE_API_KEY
+                }
+            ],
+            [ToolCategory.BRAINSTORM]: [
+                {
+                    name: "grok_brainstorm",
+                    provider: ToolProvider.GROK,
+                    categories: [ToolCategory.BRAINSTORM],
+                    priority: 1,
+                    costTier: "medium",
+                    speedTier: "medium",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.GROK_API_KEY
+                },
+                {
+                    name: "openai_brainstorm",
+                    provider: ToolProvider.OPENAI,
+                    categories: [ToolCategory.BRAINSTORM],
+                    priority: 2,
+                    costTier: "high",
+                    speedTier: "medium",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                },
+                {
+                    name: "gemini_brainstorm",
+                    provider: ToolProvider.GEMINI,
+                    categories: [ToolCategory.BRAINSTORM],
+                    priority: 3,
+                    costTier: "low",
+                    speedTier: "fast",
+                    qualityTier: "good",
+                    checkAvailability: () => !!process.env.GOOGLE_API_KEY
+                }
+            ],
+            [ToolCategory.SEARCH]: [
+                {
+                    name: "perplexity_ask",
+                    provider: ToolProvider.PERPLEXITY,
+                    categories: [ToolCategory.SEARCH],
+                    priority: 1,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.PERPLEXITY_API_KEY
+                },
+                {
+                    name: "perplexity_research",
+                    provider: ToolProvider.PERPLEXITY,
+                    categories: [ToolCategory.SEARCH, ToolCategory.ANALYSIS],
+                    priority: 2,
+                    costTier: "medium",
+                    speedTier: "medium",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.PERPLEXITY_API_KEY
+                }
+            ],
+            [ToolCategory.ANALYSIS]: [
+                {
+                    name: "gpt5_mini_analyze",
+                    provider: ToolProvider.OPENAI,
+                    categories: [ToolCategory.ANALYSIS],
+                    priority: 1,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                },
+                {
+                    name: "openai_compare",
+                    provider: ToolProvider.OPENAI,
+                    categories: [ToolCategory.ANALYSIS],
+                    priority: 2,
+                    costTier: "medium",
+                    speedTier: "medium",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                },
+                {
+                    name: "gemini_analyze_text",
+                    provider: ToolProvider.GEMINI,
+                    categories: [ToolCategory.ANALYSIS],
+                    priority: 3,
+                    costTier: "low",
+                    speedTier: "fast",
+                    qualityTier: "good",
+                    checkAvailability: () => !!process.env.GOOGLE_API_KEY
+                }
+            ],
+            [ToolCategory.DEBUG]: [
+                {
+                    name: "grok_debug",
+                    provider: ToolProvider.GROK,
+                    categories: [ToolCategory.DEBUG],
+                    priority: 1,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.GROK_API_KEY
+                },
+                {
+                    name: "gpt5_code",
+                    provider: ToolProvider.OPENAI,
+                    categories: [ToolCategory.DEBUG, ToolCategory.CODE],
+                    priority: 2,
+                    costTier: "medium",
+                    speedTier: "fast",
+                    qualityTier: "excellent",
+                    checkAvailability: () => !!process.env.OPENAI_API_KEY
+                }
+            ]
+        };
+    }
+    /**
+     * Set user preferences
+     */
+    setPreferences(preferences) {
+        this.preferences = { ...this.preferences, ...preferences };
+    }
+    /**
+     * Get the best tool for a category
+     */
+    getBestTool(category, userPreference) {
+        const tools = this.registry[category] || [];
+        const availableTools = tools.filter(t => t.checkAvailability());
+        if (availableTools.length === 0) {
+            if (this.preferences.verboseLogging) {
+                console.error(`No available tools for category: ${category}`);
+            }
+            return null;
+        }
+        // Check for user preference
+        if (userPreference) {
+            const preferredTool = availableTools.find(t => t.name === userPreference ||
+                t.provider === userPreference);
+            if (preferredTool) {
+                if (this.preferences.verboseLogging) {
+                    console.error(`Using preferred tool: ${preferredTool.name}`);
+                }
+                return preferredTool;
+            }
+        }
+        // Check for provider preference
+        if (this.preferences.preferredProvider) {
+            const providerTools = availableTools.filter(t => t.provider === this.preferences.preferredProvider);
+            if (providerTools.length > 0) {
+                return this.selectByPriority(providerTools);
+            }
+        }
+        // Apply optimization preferences
+        let sortedTools = [...availableTools];
+        if (this.preferences.costOptimization) {
+            sortedTools.sort((a, b) => {
+                const costOrder = { "free": 0, "low": 1, "medium": 2, "high": 3 };
+                return costOrder[a.costTier] - costOrder[b.costTier];
+            });
+        }
+        else if (this.preferences.speedPriority) {
+            sortedTools.sort((a, b) => {
+                const speedOrder = { "fast": 0, "medium": 1, "slow": 2 };
+                return speedOrder[a.speedTier] - speedOrder[b.speedTier];
+            });
+        }
+        else if (this.preferences.qualityPriority) {
+            sortedTools.sort((a, b) => {
+                const qualityOrder = { "excellent": 0, "good": 1, "basic": 2 };
+                return qualityOrder[a.qualityTier] - qualityOrder[b.qualityTier];
+            });
+        }
+        // Return best by priority within the sorted group
+        return this.selectByPriority(sortedTools);
+    }
+    /**
+     * Select tool by priority from a list
+     */
+    selectByPriority(tools) {
+        if (tools.length === 0)
+            return null;
+        tools.sort((a, b) => a.priority - b.priority);
+        const selected = tools[0];
+        if (this.preferences.verboseLogging) {
+            console.error(`Selected tool: ${selected.name} (${selected.provider})`);
+        }
+        return selected;
+    }
+    /**
+     * Get fallback chain for a category
+     */
+    getFallbackChain(category) {
+        const tools = this.registry[category] || [];
+        const availableTools = tools
+            .filter(t => t.checkAvailability())
+            .sort((a, b) => a.priority - b.priority);
+        if (this.preferences.verboseLogging) {
+            console.error(`Fallback chain for ${category}:`, availableTools.map(t => t.name).join(" -> "));
+        }
+        return availableTools;
+    }
+    /**
+     * Get all available tools
+     */
+    getAllAvailableTools() {
+        const allTools = [];
+        Object.values(this.registry).forEach(categoryTools => {
+            categoryTools.forEach(tool => {
+                if (tool.checkAvailability() && !allTools.some(t => t.name === tool.name)) {
+                    allTools.push(tool);
+                }
+            });
+        });
+        return allTools;
+    }
+    /**
+     * Get tool by name
+     */
+    getToolByName(name) {
+        // Check cache first
+        if (this.toolCache.has(name)) {
+            return this.toolCache.get(name);
+        }
+        // Search in registry
+        for (const categoryTools of Object.values(this.registry)) {
+            const tool = categoryTools.find(t => t.name === name);
+            if (tool) {
+                this.toolCache.set(name, tool);
+                return tool;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get status report
+     */
+    getStatus() {
+        const providers = new Set();
+        const categories = Object.keys(this.registry);
+        let totalAvailable = 0;
+        let totalTools = 0;
+        const report = ["# Tool Router Status\n"];
+        categories.forEach(category => {
+            const tools = this.registry[category];
+            const available = tools.filter(t => t.checkAvailability());
+            report.push(`\n## ${category.toUpperCase()}`);
+            report.push(`Available: ${available.length}/${tools.length}`);
+            available.forEach(tool => {
+                providers.add(tool.provider);
+                report.push(`  ✓ ${tool.name} (${tool.provider})`);
+            });
+            const unavailable = tools.filter(t => !t.checkAvailability());
+            if (unavailable.length > 0) {
+                unavailable.forEach(tool => {
+                    report.push(`  ✗ ${tool.name} (${tool.provider}) - Not configured`);
+                });
+            }
+            totalAvailable += available.length;
+            totalTools += tools.length;
+        });
+        report.unshift(`\nTotal: ${totalAvailable}/${totalTools} tools available`);
+        report.unshift(`Providers: ${Array.from(providers).join(", ")}`);
+        return report.join("\n");
+    }
+    /**
+     * Get recommendation for a task
+     */
+    getRecommendation(task) {
+        // Simple keyword-based category detection
+        const taskLower = task.toLowerCase();
+        let category;
+        if (taskLower.includes("code") || taskLower.includes("implement") || taskLower.includes("function")) {
+            category = ToolCategory.CODE;
+        }
+        else if (taskLower.includes("debug") || taskLower.includes("fix") || taskLower.includes("error")) {
+            category = ToolCategory.DEBUG;
+        }
+        else if (taskLower.includes("brainstorm") || taskLower.includes("idea") || taskLower.includes("creative")) {
+            category = ToolCategory.BRAINSTORM;
+        }
+        else if (taskLower.includes("search") || taskLower.includes("find") || taskLower.includes("research")) {
+            category = ToolCategory.SEARCH;
+        }
+        else if (taskLower.includes("analyze") || taskLower.includes("compare") || taskLower.includes("review")) {
+            category = ToolCategory.ANALYSIS;
+        }
+        else {
+            category = ToolCategory.REASONING;
+        }
+        const tool = this.getBestTool(category);
+        const alternatives = this.getFallbackChain(category).slice(1, 4); // Top 3 alternatives
+        return {
+            category,
+            tool,
+            alternatives
+        };
+    }
+}
+// Export singleton instance with default preferences
+export const toolRouter = new ToolRouter();