tachibot-mcp 2.0.2

package/dist/src/workflows/orchestrator-examples.js

@@ -0,0 +1,174 @@
+import { ToolOrchestrator } from './tool-orchestrator.js';
+// Example usage of the intelligent tool orchestrator
+export async function demonstrateToolOrchestrator() {
+    const orchestrator = new ToolOrchestrator();
+    console.error('🎯 Tool Orchestrator Demo\n');
+    // Example 1: Simple question
+    const example1 = "What is TypeScript?";
+    console.error(`📝 Query: "${example1}"`);
+    const rec1 = orchestrator.recommendTools(example1);
+    console.error('🤖 Recommended workflow:');
+    rec1.workflow.forEach((step, i) => {
+        console.error(`  ${i + 1}. ${step.toolId}: ${step.reason}`);
+    });
+    console.error(`📊 Analysis: ${rec1.analysis.category}, ${rec1.analysis.complexity}, ${rec1.analysis.timeConstraint}\n`);
+    // Example 2: Complex technical analysis
+    const example2 = "Analyze my React application architecture for performance bottlenecks and security vulnerabilities";
+    console.error(`📝 Query: "${example2}"`);
+    const rec2 = orchestrator.recommendTools(example2);
+    console.error('🤖 Recommended workflow:');
+    rec2.workflow.forEach((step, i) => {
+        console.error(`  ${i + 1}. ${step.toolId}: ${step.reason}`);
+    });
+    console.error(`📊 Analysis: ${rec2.analysis.category}, ${rec2.analysis.complexity}, ${rec2.analysis.timeConstraint}\n`);
+    // Example 3: Research project
+    const example3 = "I need comprehensive research on current AI safety practices for deployment in production systems";
+    console.error(`📝 Query: "${example3}"`);
+    const rec3 = orchestrator.recommendTools(example3);
+    console.error('🤖 Recommended workflow:');
+    rec3.workflow.forEach((step, i) => {
+        console.error(`  ${i + 1}. ${step.toolId}: ${step.reason}`);
+    });
+    console.error(`📊 Analysis: ${rec3.analysis.category}, ${rec3.analysis.complexity}, ${rec3.analysis.timeConstraint}\n`);
+    // Example 4: Urgent simple task
+    const example4 = "Quickly validate this code snippet for security issues";
+    console.error(`📝 Query: "${example4}"`);
+    const rec4 = orchestrator.recommendTools(example4);
+    console.error('🤖 Recommended workflow:');
+    rec4.workflow.forEach((step, i) => {
+        console.error(`  ${i + 1}. ${step.toolId}: ${step.reason}`);
+    });
+    console.error(`📊 Analysis: ${rec4.analysis.category}, ${rec4.analysis.complexity}, ${rec4.analysis.timeConstraint}\n`);
+    // Show orchestrator capabilities
+    console.error('🔧 Orchestrator Status:');
+    const status = orchestrator.getStatus();
+    console.error(`  Available tools: ${status.totalTools}`);
+    console.error(`  Categories: ${status.categories.join(', ')}`);
+    console.error(`  Tools: ${status.availableTools.join(', ')}`);
+}
+// Smart workflow examples for different scenarios
+export const ORCHESTRATION_SCENARIOS = {
+    // Quick fact-checking
+    factCheck: {
+        query: "What is the latest version of Node.js?",
+        expectedFlow: ['perplexity_ask'],
+        reason: "Simple factual question needs quick, current answer"
+    },
+    // Initial exploration
+    exploration: {
+        query: "I want to understand microservices architecture",
+        expectedFlow: ['scout', 'think'],
+        reason: "Exploration task needs context gathering, then reflection"
+    },
+    // Complex technical analysis
+    technicalAnalysis: {
+        query: "Analyze this codebase for architectural improvements and security issues",
+        expectedFlow: ['scout', 'architect', 'focus', 'challenger', 'verifier'],
+        reason: "Complex technical task needs comprehensive analysis and validation"
+    },
+    // Research project
+    researchProject: {
+        query: "Comprehensive research on quantum computing applications in cryptography",
+        expectedFlow: ['perplexity_research', 'focus', 'challenger'],
+        reason: "Research task needs deep investigation, reasoning, and validation"
+    },
+    // Code review
+    codeReview: {
+        query: "Review this React component for bugs and improvements",
+        expectedFlow: ['code_reviewer', 'challenger', 'test_architect'],
+        reason: "Code review needs specialized analysis, challenges, and test recommendations"
+    },
+    // Urgent debugging
+    urgentDebugging: {
+        query: "Quickly debug this production error in our API",
+        expectedFlow: ['scout', 'nextThought', 'challenger'],
+        reason: "Urgent task needs fast context, structured thinking, validation"
+    },
+    // System design
+    systemDesign: {
+        query: "Design a scalable e-commerce platform architecture",
+        expectedFlow: ['scout', 'architect', 'focus', 'challenger', 'verifier'],
+        reason: "Design task needs research, architecture, reasoning, validation"
+    },
+    // Data-driven decision
+    dataDecision: {
+        query: "Should we migrate from MongoDB to PostgreSQL based on current performance data?",
+        expectedFlow: ['perplexity_reason', 'architect', 'challenger'],
+        reason: "Decision needs current data, technical analysis, critical evaluation"
+    }
+};
+// Test the orchestrator's decision making
+export function testOrchestrationLogic() {
+    const orchestrator = new ToolOrchestrator();
+    console.error('🧪 Testing Orchestration Logic\n');
+    Object.entries(ORCHESTRATION_SCENARIOS).forEach(([scenario, config]) => {
+        console.error(`📋 Scenario: ${scenario}`);
+        console.error(`   Query: "${config.query}"`);
+        const recommendations = orchestrator.recommendTools(config.query);
+        const actualFlow = recommendations.workflow.map(step => step.toolId);
+        console.error(`   Expected: [${config.expectedFlow.join(', ')}]`);
+        console.error(`   Actual:   [${actualFlow.join(', ')}]`);
+        console.error(`   Reason: ${config.reason}`);
+        // Check if key tools are included
+        const hasKeyTools = config.expectedFlow.some(tool => actualFlow.includes(tool));
+        console.error(`   ✅ Has key tools: ${hasKeyTools}`);
+        console.error('');
+    });
+}
+// Example integration with YAML workflows
+export function generateDynamicWorkflow(query, context) {
+    const orchestrator = new ToolOrchestrator();
+    const recommendations = orchestrator.recommendTools(query, context);
+    // Generate YAML workflow dynamically
+    const workflow = {
+        name: "Dynamic AI Orchestrated Workflow",
+        version: "1.0",
+        description: `Automatically orchestrated workflow for: ${query}`,
+        tags: ["dynamic", "ai-orchestrated", recommendations.analysis.category],
+        ai_enhancements: {
+            circuit_breakers: true,
+            intelligent_orchestration: true,
+            adaptive_routing: true
+        },
+        steps: recommendations.workflow.map((step, index) => ({
+            id: `step_${index + 1}`,
+            type: step.toolId.includes('perplexity') ? 'tachibot-mcp-tool' :
+                step.toolId.includes('focus') ? 'tachibot-mcp-tool' :
+                    'tachibot-mcp-tool',
+            tool: step.toolId,
+            config: {
+                reason: step.reason,
+                auto_selected: true
+            },
+            circuit_breaker: {
+                failure_threshold: 3,
+                recovery_timeout: '10s'
+            }
+        })),
+        metadata: {
+            generated_by: "ToolOrchestrator",
+            analysis: recommendations.analysis,
+            timestamp: new Date().toISOString()
+        }
+    };
+    return workflow;
+}
+// CLI-like interface for testing
+export function orchestratorCLI(query) {
+    const orchestrator = new ToolOrchestrator();
+    const recommendations = orchestrator.recommendTools(query);
+    let output = `🎯 Orchestration for: "${query}"\n\n`;
+    output += `📊 Analysis:\n`;
+    output += `   Category: ${recommendations.analysis.category}\n`;
+    output += `   Complexity: ${recommendations.analysis.complexity}\n`;
+    output += `   Domain: ${recommendations.analysis.domain}\n`;
+    output += `   Time Constraint: ${recommendations.analysis.timeConstraint}\n`;
+    output += `   Quality Requirement: ${recommendations.analysis.qualityRequirement}\n\n`;
+    output += `🤖 Recommended Workflow:\n`;
+    recommendations.workflow.forEach((step, index) => {
+        output += `   ${index + 1}. ${step.toolId}\n`;
+        output += `      └─ ${step.reason}\n`;
+    });
+    output += `\n💡 Primary Tools: ${recommendations.primary.map(p => p.toolId).join(', ')}\n`;
+    return output;
+}

package/dist/src/workflows/orchestrator-integration.js

@@ -0,0 +1,200 @@
+import { ToolOrchestrator } from './tool-orchestrator.js';
+export class OrchestratorIntegration {
+    constructor() {
+        this.orchestrator = new ToolOrchestrator();
+    }
+    async executeOrchestratorStep(step, context) {
+        const query = context.metadata.get('input_query') || context.query;
+        const contextStr = context.metadata.get('input_context') || '';
+        // Get recommendations from orchestrator
+        const recommendations = this.orchestrator.recommendTools(query, contextStr);
+        // Transform to workflow-compatible format
+        const result = {
+            analysis: {
+                category: recommendations.analysis.category,
+                complexity: recommendations.analysis.complexity,
+                domain: recommendations.analysis.domain,
+                timeConstraint: recommendations.analysis.timeConstraint,
+                qualityRequirement: recommendations.analysis.qualityRequirement,
+                keywords: recommendations.analysis.keywords
+            },
+            recommended_tools: {
+                primary: recommendations.primary.map(p => p.toolId),
+                primary_agent: this.selectPrimaryAgent(recommendations.analysis)
+            },
+            workflow_plan: {
+                tools: recommendations.workflow,
+                agent_reason: this.getAgentReason(recommendations.analysis),
+                research_reason: recommendations.workflow.find(w => w.toolId.includes('scout') || w.toolId.includes('perplexity'))?.reason || 'Context gathering',
+                reasoning_reason: recommendations.workflow.find(w => w.toolId.includes('focus') || w.toolId.includes('think'))?.reason || 'Problem solving',
+                validation_reasons: recommendations.workflow.filter(w => w.toolId.includes('challenger') || w.toolId.includes('verifier')).map(w => w.reason)
+            },
+            research_tool: this.extractResearchTool(recommendations.workflow),
+            research_variant: this.getResearchVariant(recommendations.workflow),
+            reasoning_tool: this.extractReasoningTool(recommendations.workflow),
+            reasoning_mode: this.getReasoningMode(recommendations.analysis),
+            reasoning_rounds: this.getReasoningRounds(recommendations.analysis),
+            recommended_models: this.getRecommendedModels(recommendations.analysis),
+            validation_tools: this.extractValidationTools(recommendations.workflow)
+        };
+        // Store orchestrator result in context for other steps to use
+        context.metadata.set('orchestrator_result', result);
+        context.metadata.set('tool_analysis', recommendations.analysis);
+        return result;
+    }
+    selectPrimaryAgent(analysis) {
+        if (analysis.domain === 'technical' && analysis.keywords.includes('code')) {
+            return 'code-quality-reviewer';
+        }
+        if (analysis.keywords.includes('architecture') || analysis.keywords.includes('system')) {
+            return 'atlassian-forge-architect';
+        }
+        if (analysis.keywords.includes('ui') || analysis.keywords.includes('design')) {
+            return 'responsive-ui-designer';
+        }
+        return 'code-quality-reviewer'; // Default
+    }
+    getAgentReason(analysis) {
+        return `Selected based on ${analysis.domain} domain and ${analysis.complexity} complexity`;
+    }
+    extractResearchTool(workflow) {
+        const researchStep = workflow.find(step => ['scout', 'perplexity_ask', 'perplexity_research', 'focus_deep_research'].includes(step.toolId));
+        return researchStep?.toolId || 'scout';
+    }
+    getResearchVariant(workflow) {
+        const researchTool = this.extractResearchTool(workflow);
+        if (researchTool === 'scout')
+            return 'research_scout';
+        return undefined; // Other tools don't need variants
+    }
+    extractReasoningTool(workflow) {
+        const reasoningStep = workflow.find(step => ['focus', 'think', 'nextThought', 'perplexity_reason'].includes(step.toolId));
+        return reasoningStep?.toolId || 'focus';
+    }
+    getReasoningMode(analysis) {
+        const tool = this.extractReasoningTool([]);
+        if (tool === 'focus') {
+            if (analysis.complexity === 'complex')
+                return 'deep-reasoning';
+            if (analysis.domain === 'technical')
+                return 'code-brainstorm';
+            return 'simple';
+        }
+        return 'simple'; // Default to simple mode
+    }
+    getReasoningRounds(analysis) {
+        if (analysis.complexity === 'complex')
+            return 3;
+        if (analysis.complexity === 'medium')
+            return 2;
+        return 1;
+    }
+    getRecommendedModels(analysis) {
+        if (analysis.complexity === 'complex') {
+            return ['grok', 'gemini', 'openai'];
+        }
+        if (analysis.domain === 'technical') {
+            return ['grok', 'qwen'];
+        }
+        return ['gemini', 'openai'];
+    }
+    extractValidationTools(workflow) {
+        return workflow
+            .filter(step => ['challenger', 'verifier', 'auditor'].includes(step.toolId))
+            .map(step => step.toolId);
+    }
+    // Method to be called from workflow engine
+    static async executeStep(step, context) {
+        const integration = new OrchestratorIntegration();
+        return integration.executeOrchestratorStep(step, context);
+    }
+}
+// Export for workflow engine registration
+export const orchestratorStepHandler = {
+    type: 'tool-orchestrator',
+    execute: OrchestratorIntegration.executeStep
+};
+// Usage examples
+export const ORCHESTRATOR_USAGE_EXAMPLES = {
+    // How to call the orchestrated workflow from CLI
+    cli_usage: `
+    # Use the AI-orchestrated problem solver
+    focus workflow run agent-scout-solve-iterate "Fix performance issues in my React app"
+    
+    # The orchestrator will automatically:
+    # 1. Analyze: technical domain, medium complexity, performance focus
+    # 2. Select: scout (quick research), focus (code-brainstorm), challenger
+    # 3. Execute: Optimized workflow based on analysis
+  `,
+    // How to use in code
+    programmatic_usage: `
+    import { ToolOrchestrator } from './tool-orchestrator.js';
+    
+    const orchestrator = new ToolOrchestrator();
+    const recommendations = orchestrator.recommendTools(
+      "Debug memory leaks in Node.js application",
+      "Production environment, urgent fix needed"
+    );
+    
+    // Results:
+    // - analysis: { category: 'analysis', complexity: 'medium', timeConstraint: 'urgent' }
+    // - workflow: [{ toolId: 'scout', reason: '...' }, { toolId: 'nextThought', reason: '...' }]
+    // - primary: [{ toolId: 'architect', reason: '...' }]
+  `,
+    // How to test orchestrator decisions
+    testing_usage: `
+    import { testOrchestrationLogic, orchestratorCLI } from './orchestrator-examples.js';
+    
+    // Test all scenarios
+    testOrchestrationLogic();
+    
+    // Quick CLI test
+    console.error(orchestratorCLI("Research AI safety best practices"));
+    
+    // Output shows:
+    # 📊 Analysis: research, complex, general, normal, high
+    # 🤖 Recommended Workflow:
+    #    1. perplexity_research
+    #       └─ Comprehensive research with evidence gathering
+    #    2. focus
+    #       └─ Deep multi-AI collaborative reasoning
+  `
+};
+// Smart workflow templates that use orchestration
+export const ORCHESTRATED_WORKFLOW_TEMPLATES = {
+    smart_code_review: `
+name: "Smart Code Review (Orchestrated)"
+steps:
+  - id: orchestrator
+    type: tool-orchestrator
+  - id: dynamic_analysis
+    type: tachibot-mcp-tool
+    tool: \${orchestrator.reasoning_tool}
+    config:
+      selected_by_ai: true
+  `,
+    adaptive_research: `
+name: "Adaptive Research (Orchestrated)"
+steps:
+  - id: orchestrator
+    type: tool-orchestrator
+  - id: intelligent_research
+    type: tachibot-mcp-tool
+    tool: \${orchestrator.research_tool}
+    variant: \${orchestrator.research_variant}
+  `,
+    context_aware_problem_solving: `
+name: "Context-Aware Problem Solving"
+steps:
+  - id: orchestrator
+    type: tool-orchestrator
+    config:
+      analyze_task: true
+      adaptive_selection: true
+  - id: contextual_solution
+    type: tachibot-mcp-tool
+    tool: \${orchestrator.reasoning_tool}
+    models: \${orchestrator.recommended_models}
+    rounds: \${orchestrator.reasoning_rounds}
+  `
+};