tachibot-mcp 2.0.2

package/dist/src/tools/perplexity-tools.js

@@ -0,0 +1,294 @@
+/**
+ * Perplexity Tools Implementation
+ * Provides web search and reasoning capabilities
+ * No need for separate perplexity-mcp server
+ */
+import { z } from "zod";
+// Perplexity API configuration
+const PERPLEXITY_API_URL = "https://api.perplexity.ai";
+// Function to get the API key (deferred reading)
+function getPerplexityApiKey() {
+    return process.env.PERPLEXITY_API_KEY;
+}
+// Debug logging function - call when needed
+function debugApiKey() {
+    const apiKey = getPerplexityApiKey();
+    console.error('[PERPLEXITY DEBUG] API Key present:', !!apiKey);
+    if (apiKey) {
+        console.error('[PERPLEXITY DEBUG] Key length:', apiKey.length);
+        console.error('[PERPLEXITY DEBUG] Key prefix:', apiKey.substring(0, 8) + '...');
+    }
+    else {
+        console.error('[PERPLEXITY DEBUG] process.env keys:', Object.keys(process.env).filter(k => k.includes('PERP') || k.includes('API')));
+    }
+}
+// Available Perplexity models (2025 latest)
+export var PerplexityModel;
+(function (PerplexityModel) {
+    // Models from Perplexity API docs
+    PerplexityModel["SONAR_PRO"] = "sonar";
+    PerplexityModel["SONAR_REASONING_PRO"] = "sonar-reasoning";
+    PerplexityModel["SONAR_DEEP_RESEARCH"] = "sonar-deep-research";
+    PerplexityModel["SONAR"] = "sonar";
+    PerplexityModel["SONAR_SMALL"] = "sonar-small";
+})(PerplexityModel || (PerplexityModel = {}));
+/**
+ * Call Perplexity API
+ */
+export async function callPerplexity(messages, model = PerplexityModel.SONAR_PRO, searchDomain, searchRecency) {
+    const apiKey = getPerplexityApiKey();
+    if (!apiKey) {
+        debugApiKey(); // Log debug info when key is missing
+        return `[Perplexity API key not configured. Add PERPLEXITY_API_KEY to .env file]`;
+    }
+    try {
+        const url = `${PERPLEXITY_API_URL}/chat/completions`;
+        const requestBody = {
+            model,
+            messages,
+            temperature: 0.2,
+            max_tokens: 16384, // Increased for comprehensive research responses
+            return_citations: true,
+            return_images: false
+        };
+        // Add search filters if provided
+        if (searchDomain) {
+            requestBody.search_domain = searchDomain;
+        }
+        if (searchRecency) {
+            requestBody.search_recency = searchRecency;
+        }
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+            throw new Error(`Perplexity API error: ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Extract the response and citations
+        let result = data.choices?.[0]?.message?.content || "No response from Perplexity";
+        // Add sources if available (Perplexity API changed from citations to search_results in 2025)
+        if (data.search_results && data.search_results.length > 0) {
+            result += "\n\n**Sources:**\n";
+            data.search_results.forEach((source, idx) => {
+                result += `${idx + 1}. ${source.title || 'Untitled'} - ${source.url}`;
+                if (source.date)
+                    result += ` (${source.date})`;
+                result += '\n';
+            });
+        }
+        return result;
+    }
+    catch (error) {
+        return `[Perplexity error: ${error instanceof Error ? error.message : String(error)}]`;
+    }
+}
+/**
+ * Perplexity Ask Tool
+ * Search the web and retrieve up-to-date information
+ */
+export const perplexityAskTool = {
+    name: "perplexity_ask",
+    description: "Web search",
+    parameters: z.object({
+        query: z.string(),
+        searchDomain: z.enum(["general", "academic", "news", "social"]).optional(),
+        searchRecency: z.enum(["hour", "day", "week", "month", "year"]).optional()
+    }),
+    execute: async (args, { log }) => {
+        const messages = [
+            {
+                role: "system",
+                content: "You are a helpful research assistant. Provide accurate, up-to-date information with sources."
+            },
+            {
+                role: "user",
+                content: args.query
+            }
+        ];
+        return await callPerplexity(messages, PerplexityModel.SONAR_PRO, args.searchDomain, args.searchRecency);
+    }
+};
+/**
+ * Perplexity Research Tool
+ * Deep research with multiple queries and synthesis
+ */
+export const perplexityResearchTool = {
+    name: "perplexity_research",
+    description: "Deep research",
+    parameters: z.object({
+        topic: z.string(),
+        questions: z.array(z.string()).optional(),
+        depth: z.enum(["quick", "standard", "deep"]).optional()
+    }),
+    execute: async (args, { log }) => {
+        const { topic, questions, depth = "standard" } = args;
+        // Generate research questions if not provided
+        const researchQuestions = questions || [
+            `What is the current state of ${topic}?`,
+            `What are the latest developments in ${topic}?`,
+            `What are the key challenges and opportunities in ${topic}?`,
+            `What do experts say about ${topic}?`
+        ];
+        // Adjust based on depth
+        const questionsToAsk = depth === "quick" ?
+            researchQuestions.slice(0, 2) :
+            depth === "deep" ?
+                [...researchQuestions,
+                    `What are the future predictions for ${topic}?`,
+                    `What are the best practices and recommendations for ${topic}?`] :
+                researchQuestions;
+        let research = `# Research Report: ${topic}\n\n`;
+        // Conduct research for each question
+        for (const question of questionsToAsk) {
+            const messages = [
+                {
+                    role: "system",
+                    content: "You are a research expert. Provide detailed, factual information with sources."
+                },
+                {
+                    role: "user",
+                    content: question
+                }
+            ];
+            const answer = await callPerplexity(messages, PerplexityModel.SONAR_PRO);
+            research += `## ${question}\n\n${answer}\n\n`;
+        }
+        // Add synthesis
+        const synthesisMessages = [
+            {
+                role: "system",
+                content: "You are a research synthesizer. Create a concise summary of the key findings."
+            },
+            {
+                role: "user",
+                content: `Synthesize these research findings into key insights:\n\n${research}`
+            }
+        ];
+        const synthesis = await callPerplexity(synthesisMessages, PerplexityModel.SONAR_PRO);
+        research += `## Synthesis\n\n${synthesis}`;
+        return research;
+    }
+};
+/**
+ * Perplexity Reason Tool
+ * Perform complex reasoning tasks
+ */
+export const perplexityReasonTool = {
+    name: "perplexity_reason",
+    description: "Reasoning with search",
+    parameters: z.object({
+        problem: z.string(),
+        context: z.string().optional(),
+        approach: z.enum(["analytical", "creative", "systematic", "comparative"]).optional()
+    }),
+    execute: async (args, { log }) => {
+        const { problem, context, approach = "analytical" } = args;
+        const approachPrompts = {
+            analytical: "Break down the problem systematically and analyze each component",
+            creative: "Think outside the box and consider unconventional solutions",
+            systematic: "Follow a step-by-step logical process",
+            comparative: "Compare different approaches and evaluate trade-offs"
+        };
+        const messages = [
+            {
+                role: "system",
+                content: `You are an expert reasoning system. ${approachPrompts[approach]}.
+Provide clear, logical reasoning with evidence and examples.
+${context ? `Context: ${context}` : ''}`
+            },
+            {
+                role: "user",
+                content: problem
+            }
+        ];
+        return await callPerplexity(messages, PerplexityModel.SONAR_REASONING_PRO);
+    }
+};
+/**
+ * Perplexity Fact Check Tool
+ * Verify claims with evidence
+ */
+export const perplexityFactCheckTool = {
+    name: "perplexity_fact_check",
+    description: `Fact-check claims`,
+    parameters: z.object({
+        claim: z.string(),
+        context: z.string().optional()
+    }),
+    execute: async (args, { log }) => {
+        const messages = [
+            {
+                role: "system",
+                content: `You are a fact-checking expert. Verify the following claim with evidence.
+Provide:
+1. Verdict: TRUE, FALSE, PARTIALLY TRUE, or UNVERIFIABLE
+2. Evidence supporting or refuting the claim
+3. Sources for verification
+4. Any important context or nuance
+${args.context ? `Additional context: ${args.context}` : ''}`
+            },
+            {
+                role: "user",
+                content: `Fact-check this claim: "${args.claim}"`
+            }
+        ];
+        return await callPerplexity(messages, PerplexityModel.SONAR_PRO, "general", "month");
+    }
+};
+/**
+ * Perplexity Code Search Tool
+ * Search for code examples and documentation
+ */
+export const perplexityCodeSearchTool = {
+    name: "perplexity_code_search",
+    description: `Code search`,
+    parameters: z.object({
+        query: z.string(),
+        language: z.string().optional(),
+        framework: z.string().optional()
+    }),
+    execute: async (args, { log }) => {
+        const searchQuery = `${args.language || ''} ${args.framework || ''} ${args.query} code example implementation`.trim();
+        const messages = [
+            {
+                role: "system",
+                content: `You are a programming expert. Find and explain code solutions.
+Focus on:
+1. Working code examples
+2. Best practices
+3. Common pitfalls to avoid
+4. Links to documentation`
+            },
+            {
+                role: "user",
+                content: searchQuery
+            }
+        ];
+        return await callPerplexity(messages, PerplexityModel.SONAR_PRO);
+    }
+};
+/**
+ * Check if Perplexity is available
+ */
+export function isPerplexityAvailable() {
+    return !!getPerplexityApiKey();
+}
+export function getAllPerplexityTools() {
+    if (!isPerplexityAvailable()) {
+        return [];
+    }
+    // Minimized tool set - keeping only essential Perplexity tools
+    return [
+        perplexityAskTool, // Web search
+        perplexityReasonTool, // Complex reasoning
+        perplexityResearchTool,
+        // Removed: perplexityFactCheckTool (can use verifier instead)
+        // Removed: perplexityCodeSearchTool (can use perplexity_ask)
+    ];
+}

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

@@ -0,0 +1,343 @@
+/**
+ * PingPong Tool - Customizable multi-model conversation
+ * Supports workflow-like YAML/JSON configuration
+ */
+import { z } from "zod";
+import * as yaml from 'yaml';
+import * as fs from 'fs';
+import * as path from 'path';
+import { collaborativeOrchestrator } from '../collaborative-orchestrator.js';
+import { TechnicalDomain } from '../reasoning-chain.js';
+// PingPong configuration schema
+const PingPongConfigSchema = z.object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    settings: z.object({
+        rounds: z.number().min(1).default(5), // No hardcoded max - validated against config.maxPingPongRounds
+        style: z.enum(['collaborative', 'debate', 'build-upon', 'competitive']).default('collaborative'),
+        temperature: z.number().min(0).max(2).default(0.7),
+        maxTokensPerRound: z.number().default(2000),
+        synthesis_every: z.number().optional(), // Synthesize every N rounds
+        save_session: z.boolean().default(true),
+        include_cost_analysis: z.boolean().default(true)
+    }).optional().default({}),
+    models: z.array(z.union([
+        z.string(), // Simple model name
+        z.object({
+            name: z.string(),
+            role: z.string().optional(),
+            prompt_style: z.string().optional(),
+            temperature: z.number().optional(),
+            maxTokens: z.number().optional()
+        })
+    ])).optional(),
+    flow: z.object({
+        type: z.enum(['sequential', 'parallel', 'conditional']).default('sequential'),
+        conditions: z.array(z.object({
+            round: z.number(),
+            if: z.string(),
+            then: z.string(),
+            else: z.string().optional()
+        })).optional()
+    }).optional(),
+    prompts: z.object({
+        system: z.string().optional(),
+        first_round: z.string().optional(),
+        subsequent_rounds: z.string().optional(),
+        synthesis: z.string().optional()
+    }).optional(),
+    output: z.object({
+        format: z.enum(['summary', 'detailed', 'json', 'structured']).default('structured'),
+        save_to_file: z.string().optional(),
+        include_metadata: z.boolean().default(true)
+    }).optional().default({})
+});
+/**
+ * Load configuration from YAML/JSON file or inline object
+ */
+async function loadPingPongConfig(config) {
+    if (typeof config === 'string') {
+        // Check if it's a file path
+        if (config.endsWith('.yaml') || config.endsWith('.yml') || config.endsWith('.json')) {
+            const configPath = path.resolve(config);
+            if (fs.existsSync(configPath)) {
+                const content = fs.readFileSync(configPath, 'utf8');
+                const parsed = config.endsWith('.json')
+                    ? JSON.parse(content)
+                    : yaml.parse(content);
+                return PingPongConfigSchema.parse(parsed);
+            }
+        }
+        // Try to parse as inline YAML/JSON
+        try {
+            const parsed = yaml.parse(config);
+            return PingPongConfigSchema.parse(parsed);
+        }
+        catch {
+            try {
+                const parsed = JSON.parse(config);
+                return PingPongConfigSchema.parse(parsed);
+            }
+            catch {
+                throw new Error('Invalid configuration format. Provide YAML, JSON, or file path.');
+            }
+        }
+    }
+    // It's already an object
+    return PingPongConfigSchema.parse(config);
+}
+/**
+ * Build custom model configuration
+ */
+function buildModelConfig(config, overrides) {
+    const settings = config.settings || {};
+    // Determine models to use
+    let models = overrides?.models || [];
+    if (models.length === 0 && config.models) {
+        models = config.models.map(m => typeof m === 'string' ? m : m.name);
+    }
+    if (models.length === 0) {
+        models = ['grok', 'gemini', 'openai', 'qwen']; // Default models
+    }
+    return {
+        models,
+        rounds: overrides?.rounds || settings.rounds || 5,
+        style: overrides?.style || settings.style || 'collaborative',
+        temperature: settings.temperature || 0.7,
+        maxTokensPerRound: settings.maxTokensPerRound || 2000,
+        saveSession: settings.save_session !== false,
+        includeCostAnalysis: settings.include_cost_analysis !== false,
+        synthesisEvery: settings.synthesis_every
+    };
+}
+/**
+ * Format output based on configuration
+ */
+function formatOutput(result, config, metadata) {
+    const outputConfig = config.output || {};
+    switch (outputConfig.format) {
+        case 'json':
+            return JSON.stringify({
+                result,
+                metadata: outputConfig.include_metadata ? metadata : undefined,
+                config: config.name ? { name: config.name, description: config.description } : undefined
+            }, null, 2);
+        case 'summary':
+            // Extract just the synthesis/summary section
+            const summaryMatch = result.match(/## .*Synthesis.*\n([\s\S]*?)(?=##|$)/);
+            return summaryMatch ? summaryMatch[1].trim() : result;
+        case 'detailed':
+            // Include everything
+            return result;
+        case 'structured':
+        default:
+            // Well-formatted markdown with sections
+            let structured = `# PingPong Conversation`;
+            if (config.name)
+                structured += `: ${config.name}`;
+            structured += '\n\n';
+            if (config.description)
+                structured += `*${config.description}*\n\n`;
+            structured += result;
+            return structured;
+    }
+}
+/**
+ * PingPong Tool Definition
+ */
+export const pingpongTool = {
+    name: "pingpong",
+    description: "Multi-model conversation",
+    parameters: z.object({
+        problem: z.string(),
+        config: z.union([
+            z.string(),
+            z.object({
+                name: z.string().optional(),
+                description: z.string().optional(),
+                settings: z.any().optional(),
+                models: z.any().optional(),
+                flow: z.any().optional(),
+                prompts: z.any().optional(),
+                output: z.any().optional()
+            })
+        ]).optional(),
+        models: z.array(z.string()).optional(),
+        rounds: z.number().min(1).optional(),
+        style: z.enum(['collaborative', 'debate', 'build-upon', 'competitive']).optional(),
+        domain: z.enum([
+            "architecture", "algorithms", "debugging", "security",
+            "performance", "api_design", "database", "frontend",
+            "backend", "devops", "testing"
+        ]).optional(),
+        customPrompts: z.record(z.string()).optional(),
+        template: z.string().optional()
+    }),
+    execute: async (args, { log }) => {
+        try {
+            // Load configuration
+            let config;
+            if (args.template) {
+                // Use predefined template
+                config = getPredefinedTemplate(args.template);
+            }
+            else if (args.config) {
+                config = await loadPingPongConfig(args.config);
+            }
+            else {
+                // Default configuration
+                config = {
+                    settings: {
+                        rounds: 5,
+                        style: 'collaborative',
+                        temperature: 0.7,
+                        maxTokensPerRound: 2000,
+                        save_session: true,
+                        include_cost_analysis: true
+                    },
+                    output: {
+                        format: 'structured',
+                        include_metadata: true
+                    }
+                };
+            }
+            // Build final configuration with overrides
+            const finalConfig = buildModelConfig(config, {
+                models: args.models,
+                rounds: args.rounds,
+                style: args.style
+            });
+            // Map domain string to TechnicalDomain enum
+            const domainMap = {
+                'architecture': TechnicalDomain.ARCHITECTURE,
+                'algorithms': TechnicalDomain.ALGORITHMS,
+                'debugging': TechnicalDomain.DEBUGGING,
+                'security': TechnicalDomain.SECURITY,
+                'performance': TechnicalDomain.PERFORMANCE,
+                'api_design': TechnicalDomain.API_DESIGN,
+                'database': TechnicalDomain.DATABASE,
+                'frontend': TechnicalDomain.FRONTEND,
+                'backend': TechnicalDomain.BACKEND,
+                'devops': TechnicalDomain.DEVOPS,
+                'testing': TechnicalDomain.TESTING
+            };
+            const domain = domainMap[args.domain || 'architecture'] || TechnicalDomain.ARCHITECTURE;
+            log?.info(`Starting PingPong: ${config.name || 'Custom'}, ${finalConfig.rounds} rounds, ${finalConfig.models.length} models`);
+            // Execute the pingpong conversation
+            const result = await collaborativeOrchestrator.executeAdvancedPingPong({
+                problem: args.problem,
+                domain: domain,
+                rounds: finalConfig.rounds,
+                models: finalConfig.models,
+                temperature: finalConfig.temperature,
+                maxTokensPerRound: finalConfig.maxTokensPerRound,
+                style: finalConfig.style,
+                saveSession: finalConfig.saveSession
+            });
+            // Format output
+            const formattedResult = formatOutput(result, config, {
+                rounds: finalConfig.rounds,
+                models: finalConfig.models,
+                style: finalConfig.style,
+                timestamp: new Date().toISOString()
+            });
+            // Save to file if configured
+            if (config.output?.save_to_file) {
+                const outputPath = path.resolve(config.output.save_to_file);
+                fs.writeFileSync(outputPath, formattedResult, 'utf8');
+                log?.info(`PingPong result saved to: ${outputPath}`);
+            }
+            return formattedResult;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log?.error('PingPong execution failed:', errorMessage);
+            return `PingPong Error: ${errorMessage}`;
+        }
+    }
+};
+/**
+ * Get predefined templates
+ */
+function getPredefinedTemplate(template) {
+    const templates = {
+        debate: {
+            name: 'Technical Debate',
+            description: 'Models debate different approaches',
+            settings: {
+                rounds: 6,
+                style: 'debate',
+                temperature: 0.8,
+                maxTokensPerRound: 2000,
+                save_session: true,
+                include_cost_analysis: true
+            },
+            models: [
+                { name: 'grok', role: 'challenger', prompt_style: 'Challenge assumptions aggressively' },
+                { name: 'openai', role: 'defender', prompt_style: 'Defend conventional wisdom' },
+                { name: 'gemini', role: 'mediator', prompt_style: 'Find middle ground' }
+            ],
+            output: { format: 'structured', include_metadata: true }
+        },
+        brainstorm: {
+            name: 'Creative Brainstorm',
+            description: 'Collaborative idea generation',
+            settings: {
+                rounds: 8,
+                style: 'build-upon',
+                temperature: 0.9,
+                maxTokensPerRound: 1500,
+                synthesis_every: 3,
+                save_session: true,
+                include_cost_analysis: false
+            },
+            models: [
+                { name: 'gemini', role: 'ideator' },
+                { name: 'grok', role: 'innovator' },
+                { name: 'qwen', role: 'implementer' },
+                { name: 'openai', role: 'synthesizer' }
+            ],
+            output: { format: 'structured', include_metadata: false }
+        },
+        review: {
+            name: 'Architecture Review',
+            description: 'Multi-perspective code/architecture review',
+            settings: {
+                rounds: 4,
+                style: 'collaborative',
+                temperature: 0.6,
+                maxTokensPerRound: 2500,
+                save_session: true,
+                include_cost_analysis: true
+            },
+            models: [
+                { name: 'grok', role: 'security reviewer' },
+                { name: 'openai', role: 'performance analyst' },
+                { name: 'gemini', role: 'best practices expert' }
+            ],
+            output: { format: 'detailed', include_metadata: true }
+        },
+        design: {
+            name: 'System Design',
+            description: 'Collaborative system design session',
+            settings: {
+                rounds: 10,
+                style: 'build-upon',
+                temperature: 0.7,
+                maxTokensPerRound: 3000,
+                synthesis_every: 5,
+                save_session: true,
+                include_cost_analysis: true
+            },
+            models: ['grok', 'gemini', 'openai', 'qwen'],
+            output: { format: 'structured', include_metadata: true }
+        }
+    };
+    return templates[template] || templates.brainstorm;
+}
+/**
+ * Check if pingpong tool is available
+ */
+export function isPingPongAvailable() {
+    return true; // Always available since it uses the collaborative orchestrator
+}