tachibot-mcp 2.0.2 → 2.0.4

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

@@ -1,200 +0,0 @@
-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}
-  `
-};