tachibot-mcp 2.0.2

package/dist/src/tools/consolidated/environment-detector.js

@@ -0,0 +1,80 @@
+/**
+ * Environment Detector
+ * Detects the current environment and available providers
+ */
+export function detectEnvironment() {
+    const env = {
+        type: 'standalone',
+        nativeProviders: [],
+        availableProviders: {},
+        apiKeys: {},
+        skipNativeAPIs: []
+    };
+    // Detect environment type
+    if (process.env.CLAUDE_CODE_SESSION || process.env.ANTHROPIC_SESSION_ID) {
+        env.type = 'claude-code';
+        env.nativeProviders.push('claude');
+        env.skipNativeAPIs.push('anthropic');
+    }
+    else if (process.env.CURSOR_SESSION || process.env.CURSOR_IDE) {
+        env.type = 'cursor';
+        env.nativeProviders.push('openai');
+        env.skipNativeAPIs.push('openai');
+    }
+    else if (process.env.CODEX_SESSION) {
+        env.type = 'codex';
+        env.nativeProviders.push('openai');
+        env.skipNativeAPIs.push('openai');
+    }
+    else if (process.env.VSCODE_PID) {
+        env.type = 'vscode';
+    }
+    // Check available API keys
+    const providers = {
+        openai: process.env.OPENAI_API_KEY,
+        anthropic: process.env.ANTHROPIC_API_KEY,
+        grok: process.env.GROK_API_KEY,
+        perplexity: process.env.PERPLEXITY_API_KEY,
+        gemini: process.env.GOOGLE_API_KEY,
+        deepseek: process.env.DEEPSEEK_API_KEY,
+        openrouter: process.env.OPENROUTER_API_KEY
+    };
+    for (const [provider, key] of Object.entries(providers)) {
+        env.availableProviders[provider] = !!key;
+        env.apiKeys[provider] = key;
+    }
+    // Check GPT-5 feature flag
+    if (process.env.ENABLE_GPT5 === 'true' && env.availableProviders.openai) {
+        env.availableProviders['gpt5'] = true;
+    }
+    return env;
+}
+export function getBestAvailableProvider(env, taskType) {
+    // Task-specific routing
+    const preferences = {
+        reason: ['grok', 'openai', 'gemini', 'anthropic', 'deepseek'],
+        search: ['perplexity', 'grok', 'openai'],
+        code: ['openai', 'anthropic', 'deepseek', 'gemini'],
+        analyze: ['gemini', 'openai', 'anthropic', 'grok'],
+        brainstorm: ['gemini', 'grok', 'openai', 'anthropic'],
+        general: ['openai', 'anthropic', 'gemini', 'grok', 'perplexity']
+    };
+    const preferred = preferences[taskType] || preferences.general;
+    for (const provider of preferred) {
+        // Check if we should use native provider
+        if (env.nativeProviders.includes(provider)) {
+            return provider;
+        }
+        // Check if API key is available and not skipped
+        if (env.availableProviders[provider] && !env.skipNativeAPIs.includes(provider)) {
+            return provider;
+        }
+    }
+    // Try any available provider
+    for (const [provider, available] of Object.entries(env.availableProviders)) {
+        if (available && !env.skipNativeAPIs.includes(provider)) {
+            return provider;
+        }
+    }
+    return null;
+}

package/dist/src/tools/consolidated/index.js

@@ -0,0 +1,50 @@
+/**
+ * Consolidated Tools Export
+ * 12 smart tools replacing 62 individual tools
+ * Target: 6,500 tokens (from 13,400)
+ */
+// Core tools are defined directly in server.ts, not here
+// export { thinkTool } from '../core/think-tool.js';
+// export { focusTool } from '../core/focus-tool.js';
+// New consolidated tools
+export { aiTool } from './ai-tool.js';
+export { searchTool } from './search-tool.js';
+export { brainstormTool } from './brainstorm-tool.js';
+export { workflowTool } from './workflow-tool.js';
+// Additional consolidated tools (to be implemented - commented out for now)
+// export { analyzeTool } from './analyze-tool.js';
+// export { generateTool } from './generate-tool.js';
+// export { reasonTool } from './reason-tool.js';
+// export { verifyTool } from './verify-tool.js';
+// export { challengeTool } from './challenge-tool.js';
+// export { orchestrateTool } from './orchestrate-tool.js';
+// Export all as array for easy registration
+export const consolidatedTools = [
+    'think',
+    'focus',
+    'workflow',
+    'ai',
+    'search',
+    'analyze',
+    'generate',
+    'reason',
+    'brainstorm',
+    'verify',
+    'challenge',
+    'orchestrate'
+];
+// Tool descriptions for documentation
+export const toolDescriptions = {
+    think: 'Internal reasoning and caching',
+    focus: 'Multi-mode orchestration (16+ modes)',
+    workflow: 'Execute YAML workflows',
+    ai: 'Universal AI query',
+    search: 'Web search (auto-selects provider)',
+    analyze: 'Any analysis type',
+    generate: 'Code/text generation',
+    reason: 'Complex reasoning',
+    brainstorm: 'Creative ideation',
+    verify: 'Multi-model verification',
+    challenge: 'Critical thinking',
+    orchestrate: 'Custom workflows/PingPong'
+};

package/dist/src/tools/consolidated/search-tool.js

@@ -0,0 +1,110 @@
+/**
+ * Consolidated Search Tool
+ * Smart web search with provider selection
+ */
+import { z } from "zod";
+import { detectEnvironment } from './environment-detector.js';
+import { callPerplexity, PerplexityModel } from '../perplexity-tools.js';
+import { callGrok } from '../grok-tools.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+/**
+ * Unified Search Tool
+ * Replaces: perplexity_ask, perplexity_research, grok_search, perplexity_code_search, perplexity_fact_check
+ * Token cost: ~200 tokens (vs 1000+ for individual tools)
+ */
+export const searchTool = {
+    name: "search",
+    description: "Web search", // Ultra-short description
+    parameters: z.object({
+        query: z.string(),
+        type: z.enum(["general", "research", "code", "fact", "latest"])
+            .default("general"),
+        provider: z.enum(["auto", "perplexity", "grok"])
+            .default("auto"),
+        live: z.boolean()
+            .optional(),
+        maxSources: z.number()
+            .optional(),
+        recency: z.enum(["hour", "day", "week", "month", "year"])
+            .optional(),
+        saveAs: z.string()
+            .optional()
+    }),
+    execute: async (args, { log }) => {
+        const env = detectEnvironment();
+        // Determine provider
+        let selectedProvider = args.provider || 'auto';
+        if (selectedProvider === 'auto') {
+            // Auto-select based on type and availability
+            if (args.type === 'latest' || args.live) {
+                // Prefer Grok for latest/live search
+                selectedProvider = env.availableProviders.grok ? 'grok' : 'perplexity';
+            }
+            else {
+                // Prefer Perplexity for general search
+                selectedProvider = env.availableProviders.perplexity ? 'perplexity' : 'grok';
+            }
+            // Fallback if neither available
+            if (!env.availableProviders[selectedProvider]) {
+                return '[No search providers available. Please set PERPLEXITY_API_KEY or GROK_API_KEY]';
+            }
+        }
+        log?.info(`Search: provider=${selectedProvider}, type=${args.type}, live=${args.live}`);
+        try {
+            let result;
+            if (selectedProvider === 'grok' && env.availableProviders.grok) {
+                // Use Grok search
+                const grokOptions = {
+                    live: args.live,
+                    maxSources: args.maxSources
+                };
+                const messages = [{
+                        role: 'user',
+                        content: args.query
+                    }];
+                result = await callGrok(messages, grokOptions);
+            }
+            else if (selectedProvider === 'perplexity' && env.availableProviders.perplexity) {
+                // Use Perplexity search
+                const messages = [{
+                        role: 'user',
+                        content: args.query
+                    }];
+                // Select Perplexity model based on type
+                let model = PerplexityModel.SONAR_PRO;
+                if (args.type === 'research') {
+                    model = PerplexityModel.SONAR_DEEP_RESEARCH;
+                }
+                // Map type to search domain if needed
+                let searchDomain;
+                if (args.type === 'code') {
+                    searchDomain = 'github.com stackoverflow.com';
+                }
+                result = await callPerplexity(messages, model, searchDomain, args.recency);
+            }
+            else {
+                return `[${selectedProvider} search not available. Please check API keys]`;
+            }
+            // Save if requested
+            if (args.saveAs) {
+                try {
+                    const filePath = path.resolve(args.saveAs);
+                    await fs.writeFile(filePath, result, 'utf8');
+                    log?.info(`Saved search results to: ${filePath}`);
+                    return `${result}\n\n[Saved to: ${filePath}]`;
+                }
+                catch (error) {
+                    log?.error(`Failed to save: ${error}`);
+                    return `${result}\n\n[Failed to save: ${error instanceof Error ? error.message : String(error)}]`;
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log?.error(`Search error: ${errorMessage}`);
+            return `[Search Error: ${errorMessage}]`;
+        }
+    }
+};

package/dist/src/tools/consolidated/workflow-tool.js

@@ -0,0 +1,238 @@
+/**
+ * Workflow Tool
+ * Execute YAML workflows and custom orchestrations
+ */
+import { z } from "zod";
+import * as yaml from 'yaml';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { AIRouter } from './ai-router.js';
+import { searchTool } from './search-tool.js';
+import { brainstormTool } from './brainstorm-tool.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Workflow Execution Tool
+ * Replaces: nextThought, workflow tools, and session management
+ * Token cost: ~150 tokens
+ */
+export const workflowTool = {
+    name: "workflow",
+    description: "Execute workflows", // Ultra-short description
+    parameters: z.object({
+        task: z.string(),
+        template: z.string()
+            .optional(),
+        steps: z.array(z.string())
+            .optional(),
+        inputs: z.record(z.string())
+            .optional(),
+        saveAs: z.string()
+            .optional(),
+        format: z.enum(["md", "json", "yaml"])
+            .default("md")
+    }),
+    execute: async (args, { log }) => {
+        log?.info(`Workflow: task="${args.task}", template=${args.template || 'inline'}`);
+        try {
+            let workflow;
+            if (args.template) {
+                // Load workflow from template
+                workflow = await loadWorkflowTemplate(args.template);
+            }
+            else if (args.steps) {
+                // Create inline workflow
+                workflow = createInlineWorkflow(args.task, args.steps);
+            }
+            else {
+                // Default simple workflow
+                workflow = createDefaultWorkflow(args.task);
+            }
+            // Execute workflow
+            const result = await executeWorkflow(workflow, args.inputs || {}, log);
+            // Format output
+            const formatted = formatWorkflowOutput(result, args.format || 'md', workflow);
+            // Save if requested
+            if (args.saveAs || workflow.output?.saveAs) {
+                const savePath = args.saveAs || workflow.output?.saveAs;
+                if (savePath) {
+                    const filePath = path.resolve(savePath);
+                    await fs.writeFile(filePath, formatted, 'utf8');
+                    log?.info(`Saved workflow output to: ${filePath}`);
+                    return `${formatted}\n\n[Saved to: ${filePath}]`;
+                }
+            }
+            return formatted;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            log?.error(`Workflow error: ${errorMessage}`);
+            return `[Workflow Error: ${errorMessage}]`;
+        }
+    }
+};
+async function loadWorkflowTemplate(templatePath) {
+    try {
+        // Check if it's a built-in template
+        const builtInPath = path.join(__dirname, '../../../workflows/templates', `${templatePath}.yaml`);
+        const customPath = path.resolve(templatePath);
+        let workflowPath = customPath;
+        try {
+            await fs.access(builtInPath);
+            workflowPath = builtInPath;
+        }
+        catch {
+            // Use custom path
+        }
+        const content = await fs.readFile(workflowPath, 'utf8');
+        return yaml.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to load workflow template: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function createInlineWorkflow(task, steps) {
+    return {
+        name: 'inline-workflow',
+        description: task,
+        steps: steps.map((step, index) => {
+            const [action, ...rest] = step.split(':');
+            return {
+                id: `step_${index + 1}`,
+                tool: action.trim(),
+                prompt: rest.join(':').trim()
+            };
+        })
+    };
+}
+function createDefaultWorkflow(task) {
+    return {
+        name: 'default-workflow',
+        description: task,
+        steps: [
+            {
+                id: 'analyze',
+                tool: 'ai',
+                action: 'analyze',
+                prompt: task
+            },
+            {
+                id: 'execute',
+                tool: 'ai',
+                action: 'generate',
+                prompt: `Execute: ${task}\nBased on analysis: {{analyze.output}}`
+            }
+        ]
+    };
+}
+async function executeWorkflow(workflow, inputs, log) {
+    const results = { ...inputs };
+    const router = new AIRouter();
+    for (const step of workflow.steps) {
+        log?.info(`Executing step: ${step.id}`);
+        // Check condition
+        if (step.condition && !evaluateCondition(step.condition, results)) {
+            log?.info(`Skipping step ${step.id} due to condition`);
+            continue;
+        }
+        // Resolve variables in step
+        const resolvedStep = resolveVariables(step, results);
+        // Handle external MCP
+        if (step.external_mcp) {
+            results[step.id] = {
+                output: `[External MCP: ${step.external_mcp} - ${step.action}]`,
+                external: true
+            };
+            continue;
+        }
+        // Execute based on tool
+        let stepResult;
+        switch (step.tool) {
+            case 'ai':
+            case 'analyze':
+            case 'generate':
+            case 'reason':
+                stepResult = await router.route({
+                    prompt: resolvedStep.prompt || resolvedStep.input || '',
+                    mode: resolvedStep.action
+                });
+                break;
+            case 'search':
+                stepResult = await searchTool.execute({
+                    query: resolvedStep.query || resolvedStep.prompt || '',
+                    provider: resolvedStep.provider,
+                    type: resolvedStep.type
+                }, { log });
+                break;
+            case 'brainstorm':
+                stepResult = await brainstormTool.execute({
+                    topic: resolvedStep.prompt || resolvedStep.topic || '',
+                    approach: resolvedStep.approach
+                }, { log });
+                break;
+            case 'think':
+                stepResult = `[Thinking: ${resolvedStep.thought || resolvedStep.prompt}]`;
+                break;
+            case 'write_file':
+            case 'save':
+                const savePath = path.resolve(resolvedStep.path || `output_${step.id}.md`);
+                const content = resolvedStep.content || resolvedStep.prompt || '';
+                await fs.writeFile(savePath, content, 'utf8');
+                stepResult = `Saved to: ${savePath}`;
+                break;
+            default:
+                stepResult = `[Tool ${step.tool} not implemented in consolidated version]`;
+        }
+        results[step.id] = {
+            output: stepResult,
+            timestamp: new Date().toISOString()
+        };
+    }
+    return results;
+}
+function resolveVariables(obj, context) {
+    if (typeof obj === 'string') {
+        return obj.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
+            const keys = path.trim().split('.');
+            let value = context;
+            for (const key of keys) {
+                value = value?.[key];
+            }
+            return value?.output || value || match;
+        });
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        const resolved = {};
+        for (const [key, value] of Object.entries(obj)) {
+            resolved[key] = resolveVariables(value, context);
+        }
+        return resolved;
+    }
+    return obj;
+}
+function evaluateCondition(condition, context) {
+    // Simple condition evaluation
+    const resolved = resolveVariables(condition, context);
+    return resolved !== 'false' && resolved !== '' && resolved !== null;
+}
+function formatWorkflowOutput(results, format, workflow) {
+    if (format === 'json') {
+        return JSON.stringify(results, null, 2);
+    }
+    if (format === 'yaml') {
+        return yaml.stringify(results);
+    }
+    // Markdown format
+    let output = `# Workflow: ${workflow.name}\n\n`;
+    output += `*${workflow.description}*\n\n`;
+    for (const step of workflow.steps) {
+        const result = results[step.id];
+        if (result) {
+            output += `## Step: ${step.id}\n\n`;
+            output += result.output || JSON.stringify(result);
+            output += '\n\n';
+        }
+    }
+    return output;
+}