tachibot-mcp 2.0.2

package/workflows/core/iterative-problem-solver.yaml

@@ -0,0 +1,283 @@
+# Iterative Problem Solver - Using Real TachiBot MCP Tools
+# Pattern: Research → Decompose → Solve → Challenge → Iterate
+# Enhanced with 13 prompt engineering techniques for optimal results
+
+name: "Iterative Problem Solver"
+version: "3.0"
+description: "Step-by-step problem solving with research, reasoning, and validation using prompt engineering techniques"
+tags: ["problem-solving", "iterative", "practical", "prompt-engineering"]
+
+config:
+  max_iterations: 5
+  success_threshold: 0.8
+
+steps:
+  # Step 1: Initial Research and Context Gathering
+  # Uses comprehensive_investigation technique for thorough 5W1H analysis
+  - name: research-context
+    tool: scout
+    variant: research_scout
+    promptTechnique: comprehensive_investigation
+    input:
+      query: "${input}"
+    saveToFile: true
+    maxTokens: 10000
+    output:
+      variable: research_context
+
+  # Step 2: Problem Decomposition
+  # Uses problem_decomposition technique to break down complexity
+  - name: decompose-problem
+    tool: think
+    promptTechnique: problem_decomposition
+    input:
+      thought: "${input}"
+    saveToFile: true
+    output:
+      variable: problem_breakdown
+
+  # Step 3: Systematic Analysis
+  # Uses systematic_analysis with research context
+  - name: analyze-problem
+    tool: grok_reason
+    promptTechnique: systematic_analysis
+    input:
+      problem: "${input}"
+      approach: "systematic"
+      context: "Research findings: ${research_context}\n\nProblem structure: ${problem_breakdown}"
+    saveToFile: true
+    maxTokens: 12000
+    output:
+      variable: problem_analysis
+
+  # Step 4: Generate Initial Solutions
+  # Uses innovative_solutions technique for creative approaches
+  - name: brainstorm-solutions
+    tool: openai_brainstorm
+    promptTechnique: innovative_solutions
+    input:
+      problem: "${input}"
+      style: "innovative"
+      quantity: 5
+      reasoning_effort: "medium"
+      context: "Analysis: ${problem_analysis}\n\nResearch: ${research_context}"
+    saveToFile: true
+    maxTokens: 10000
+    output:
+      variable: solution_ideas
+
+  # Step 5: First Principles Analysis
+  # Uses first_principles technique to rebuild from fundamentals
+  - name: first-principles-reasoning
+    tool: grok_reason
+    promptTechnique: first_principles
+    input:
+      problem: "${input}"
+      approach: "first-principles"
+      context: "Solutions proposed: ${solution_ideas}\n\nAnalysis: ${problem_analysis}"
+    saveToFile: true
+    maxTokens: 12000
+    output:
+      variable: first_principles_analysis
+
+  # Step 6: Deep Multi-Model Reasoning
+  - name: reason-solution
+    tool: focus
+    mode: deep-reasoning
+    input:
+      query: "Synthesize the best solution for: ${input}"
+      rounds: 3
+      models: ["grok-3", "gpt-5", "gemini-2.5"]
+      context: |
+        Research: ${research_context}
+        Problem breakdown: ${problem_breakdown}
+        Analysis: ${problem_analysis}
+        Solution ideas: ${solution_ideas}
+        First principles: ${first_principles_analysis}
+    saveToFile: true
+    maxTokens: 15000
+    output:
+      variable: reasoned_solution
+
+  # Step 7: Evidence Gathering for Validation
+  # Uses evidence_gathering technique to find supporting/contradicting data
+  - name: gather-evidence
+    tool: perplexity_ask
+    promptTechnique: evidence_gathering
+    input:
+      query: "${input} validation best practices case studies"
+    saveToFile: true
+    maxTokens: 8000
+    output:
+      variable: validation_evidence
+
+  # Step 8: Challenge and Validate
+  - name: challenge-solution
+    tool: challenger
+    input:
+      context: |
+        Original problem: ${input}
+        Proposed solution: ${reasoned_solution}
+        Evidence: ${validation_evidence}
+      thoroughness: deep
+      enableFactChecking: true
+    saveToFile: true
+    maxTokens: 12000
+    output:
+      variable: challenges
+
+  # Step 9: Feasibility Analysis
+  # Uses feasibility_analysis technique to evaluate practicality
+  - name: assess-feasibility
+    tool: gemini_analyze_text
+    promptTechnique: feasibility_analysis
+    input:
+      text: "${reasoned_solution}"
+      type: "analysis"
+      context: "Challenges: ${challenges}\n\nEvidence: ${validation_evidence}"
+    saveToFile: true
+    maxTokens: 10000
+    output:
+      variable: feasibility
+
+  # Step 10: Verify with Multi-Model Consensus
+  - name: verify-solution
+    tool: verifier
+    variant: deep_verify
+    input:
+      query: |
+        Solution: ${reasoned_solution}
+        Challenges raised: ${challenges}
+        Feasibility: ${feasibility}
+
+        Is this a valid and complete solution?
+    saveToFile: true
+    maxTokens: 10000
+    output:
+      variable: verification
+
+  # Step 11: Pattern Recognition
+  # Uses pattern_recognition to identify insights across all analyses
+  - name: identify-patterns
+    tool: think
+    promptTechnique: pattern_recognition
+    input:
+      thought: "What patterns emerge from our analysis of '${input}'? Context: ${problem_analysis}, ${solution_ideas}, ${challenges}, ${feasibility}"
+    saveToFile: true
+    output:
+      variable: patterns
+
+  # Step 12: Refine if Needed
+  # Uses alternative_perspectives for creative refinement
+  - name: refine-solution
+    tool: kimi_thinking
+    promptTechnique: alternative_perspectives
+    when: "${verification.confidence} < 0.8"
+    input:
+      problem: "Refine solution for: ${input}"
+      approach: "creative"
+      maxSteps: 10
+      context: |
+        Original: ${reasoned_solution}
+        Issues: ${challenges}
+        Patterns: ${patterns}
+    saveToFile: true
+    maxTokens: 12000
+    output:
+      variable: refined_solution
+
+  # Step 13: Quick Reflection Before Synthesis
+  # Uses quick_reflection to consolidate insights
+  - name: pre-synthesis-reflection
+    tool: think
+    promptTechnique: quick_reflection
+    input:
+      thought: "Reflect on our complete analysis of '${input}': What are the key insights, surprises, and next steps?"
+    saveToFile: true
+    output:
+      variable: reflection
+
+  # Step 14: Ultimate Integration and Synthesis
+  # Uses integration_reflection to combine all perspectives
+  - name: ultimate-synthesis
+    tool: openai_brainstorm
+    promptTechnique: integration_reflection
+    input:
+      problem: "Create comprehensive solution for: ${input}"
+      style: "systematic"
+      reasoning_effort: "high"
+      model: "gpt-5"
+      context: |
+        COMPLETE WORKFLOW CONTEXT:
+
+        Research: ${research_context}
+        Problem Breakdown: ${problem_breakdown}
+        Systematic Analysis: ${problem_analysis}
+        Solution Ideas: ${solution_ideas}
+        First Principles: ${first_principles_analysis}
+        Reasoned Solution: ${reasoned_solution}
+        Evidence: ${validation_evidence}
+        Challenges: ${challenges}
+        Feasibility: ${feasibility}
+        Patterns: ${patterns}
+        Verification: ${verification}
+        Refined Solution: ${refined_solution}
+        Reflection: ${reflection}
+    saveToFile: true
+    maxTokens: 20000
+    output:
+      variable: integrated_solution
+
+  # Step 15: Executive Summary (using Gemini 2.5 Flash for large context)
+  - name: executive-summary
+    tool: gemini_analyze_text
+    input:
+      text: "${integrated_solution}"
+      type: "summary"
+    saveToFile: true
+    maxTokens: 8000
+    output:
+      variable: final_solution
+
+output:
+  format: detailed
+  truncateSteps: false
+  summary: |
+    ╔═══════════════════════════════════════════════════════════════════════════╗
+    ║  ITERATIVE PROBLEM SOLVER v3.0 - Enhanced with Prompt Engineering        ║
+    ║  Problem: ${input}                                                        ║
+    ╚═══════════════════════════════════════════════════════════════════════════╝
+
+    📊 ANALYSIS PHASES COMPLETED:
+    ✅ Phase 1: Research & Context (comprehensive_investigation)
+    ✅ Phase 2: Problem Decomposition (problem_decomposition)
+    ✅ Phase 3: Systematic Analysis (systematic_analysis)
+    ✅ Phase 4: Solution Ideation (innovative_solutions)
+    ✅ Phase 5: First Principles Reasoning (first_principles)
+    ✅ Phase 6: Multi-Model Deep Reasoning (focus)
+    ✅ Phase 7: Evidence Validation (evidence_gathering)
+    ✅ Phase 8: Critical Challenge (challenger)
+    ✅ Phase 9: Feasibility Assessment (feasibility_analysis)
+    ✅ Phase 10: Multi-Model Verification (verifier)
+    ✅ Phase 11: Pattern Recognition (pattern_recognition)
+    ✅ Phase 12: Refinement (alternative_perspectives)
+    ✅ Phase 13: Reflection (quick_reflection)
+    ✅ Phase 14: Ultimate Synthesis (integration_reflection)
+
+    🎯 EXECUTIVE SUMMARY:
+    ${final_solution}
+
+    📁 All outputs saved to: workflow-output/iterative-problem-solver/
+
+    💡 This workflow uses 10 of 13 prompt engineering techniques for optimal results
+
+# Usage examples
+examples:
+  - description: "Debug a complex performance issue"
+    input: "My React app is slow when rendering large lists with complex state updates"
+
+  - description: "Design a system architecture"
+    input: "Design a scalable microservice architecture for an e-commerce platform"
+
+  - description: "Solve algorithmic problem"
+    input: "Optimize database query performance for time-series data"

package/workflows/creative-brainstorm-yaml.yaml

@@ -0,0 +1,215 @@
+name: creative-brainstorm-yaml
+description: Multi-model creative brainstorming with mid-flow and final verification
+version: "2.0"
+
+settings:
+  optimization:
+    enabled: true
+    cacheResults: true
+    promptEnhancement: true  # Use prompt-engineer.ts
+  maxCost: 1.00
+
+variables:
+  analysis_depth: "comprehensive"
+
+steps:
+  # Step 1: Claude Thinking - Problem Framing
+  - name: claude-thinking
+    tool: openai_gpt5_reason  # Using GPT-5 Mini for structured thinking
+    input:
+      query: |
+        Analyze and structure the brainstorming request: ${query}
+
+        Provide:
+        1. Domain and framing
+        2. Key stakeholders
+        3. Core constraints and goals
+        4. Success criteria
+        5. Potential approaches to explore
+      mode: "analytical"
+    saveToFile: true
+    maxTokens: 4000
+    output:
+      variable: initial_analysis
+    promptTechnique: "systematic_analysis"
+
+  # Step 2: Initial Ideas Generation
+  - name: initial-ideas
+    tool: openai_brainstorm
+    input:
+      problem: "${initial_analysis}"
+      style: "systematic"
+      quantity: 5
+      constraints: |
+        Based on the framing:
+        ${initial_analysis}
+
+        Generate initial ideas for: ${query}
+    saveToFile: true
+    maxTokens: 8000
+    output:
+      variable: initial_ideas
+    promptTechnique: "innovative_solutions"
+
+  # Step 3: Expand Ideas with Deep Thinking
+  - name: expand-ideas
+    tool: kimi_thinking
+    input:
+      problem: |
+        Expand and build upon these ideas:
+        ${initial_ideas}
+
+        Original query: ${query}
+      approach: "step-by-step"
+      maxSteps: 10
+      context: "${initial_analysis}"
+    saveToFile: true
+    maxTokens: 12000
+    output:
+      variable: expanded_ideas
+    promptTechnique: "what_if_speculation"
+
+  # Step 4: Mid-Flow Verification
+  - name: mid-verification
+    tool: verifier
+    input:
+      query: |
+        Verify the feasibility and soundness of these ideas:
+
+        Original Analysis: ${initial_analysis}
+
+        Initial Ideas: ${initial_ideas}
+
+        Expanded Ideas: ${expanded_ideas}
+
+        Assess:
+        1. Feasibility (can this actually be done?)
+        2. Soundness (does the reasoning hold up?)
+        3. Completeness (are we missing critical aspects?)
+        4. Potential flaws or risks
+    saveToFile: true
+    maxTokens: 10000
+    output:
+      variable: mid_verification
+
+  # Step 5: Research Validation
+  - name: research-validation
+    tool: perplexity_research
+    input:
+      topic: |
+        Find the "RESEARCH VALIDATION TOPICS" section in the text below and research ONLY those specific topics in depth.
+
+        ${expanded_ideas}
+
+        If no explicit "RESEARCH VALIDATION TOPICS" section exists, research:
+        - Latest industry data and statistics
+        - Case studies and real-world implementations
+        - Expert opinions and academic research
+        - Recent developments and trends
+
+        For query: ${query}
+      depth: "deep"
+      questions:
+        - "What are the latest industry statistics and trends?"
+        - "What real-world implementations or case studies exist?"
+        - "What do experts and researchers say?"
+    saveToFile: true
+    maxTokens: 15000
+    output:
+      variable: research_findings
+    promptTechnique: "comprehensive_investigation"
+
+  # Step 6: Contrarian View / Devil's Advocate
+  - name: contrarian-view
+    tool: grok_reason
+    input:
+      problem: |
+        Challenge these ideas using first-principles thinking:
+        ${expanded_ideas}
+
+        Verification feedback:
+        ${mid_verification}
+      approach: "first-principles"
+      useHeavy: false
+      context: |
+        Research findings: ${research_findings}
+
+        Be a constructive skeptic. Find:
+        1. Hidden assumptions
+        2. Potential failure modes
+        3. Alternative approaches not considered
+        4. Edge cases and risks
+    saveToFile: true
+    maxTokens: 8000
+    output:
+      variable: contrarian_analysis
+    promptTechnique: "critical_analysis"
+
+  # Step 7: Final Synthesis
+  - name: final-synthesis
+    tool: gemini_brainstorm
+    input:
+      prompt: |
+        Initial Analysis: ${initial_analysis}
+
+        Initial Ideas: ${initial_ideas}
+
+        Expanded Ideas: ${expanded_ideas}
+
+        Verification: ${mid_verification}
+
+        Research: ${research_findings}
+
+        Critical Analysis: ${contrarian_analysis}
+
+        Synthesize all insights into a comprehensive, actionable recommendation for:
+        ${query}
+
+        Include:
+        1. Executive Summary
+        2. Recommended Approach (with reasoning)
+        3. Implementation Roadmap
+        4. Risks and Mitigation
+        5. Success Metrics
+      claudeThoughts: |
+        You are synthesizing 6 rounds of multi-model analysis.
+        Focus on actionable insights, not just summaries.
+      maxRounds: 2
+    saveToFile: true
+    maxTokens: 12000
+    output:
+      variable: final_synthesis
+
+  # Step 8: Final Verification
+  - name: final-verification
+    tool: grok_reason
+    input:
+      problem: |
+        Perform final validation of the synthesized recommendations:
+
+        ${final_synthesis}
+
+        Original query: ${query}
+      approach: "analytical"
+      context: |
+        Verify:
+        1. Internal consistency
+        2. Alignment with original query
+        3. Practical feasibility
+        4. Completeness
+
+        Provide confidence score (0-100%) and final verdict.
+    saveToFile: true
+    maxTokens: 6000
+    output:
+      variable: final_verification
+
+output:
+  format: detailed
+  return: |
+    ${final_synthesis}
+
+    ---
+
+    VALIDATION:
+    ${final_verification}

package/workflows/pingpong.yaml

@@ -0,0 +1,141 @@
+name: pingpong
+description: Multi-model debate with analysis, challenge, and consensus
+version: "2.0"
+
+# Usage: workflow --name pingpong --query "your question/idea/architecture"
+# All outputs saved to: workflow-output/pingpong/{timestamp}/
+
+steps:
+  # ═══════════════════════════════════════════════════════════════════════════
+  # ANALYSIS: Initial perspectives from all models
+  # ═══════════════════════════════════════════════════════════════════════════
+
+  - name: analyze-grok
+    tool: grok_reason
+    input:
+      problem: "${query}"
+      approach: "first-principles"
+    saveToFile: true
+    maxTokens: 3500
+
+  - name: analyze-gemini
+    tool: gemini_brainstorm
+    input:
+      prompt: "${query}"
+      maxRounds: 1
+    dependsOn: [analyze-grok]
+    saveToFile: true
+    maxTokens: 3500
+
+  - name: analyze-qwen
+    tool: qwen_coder
+    input:
+      task: "explain"
+      requirements: "${query}"
+      language: "typescript"
+    dependsOn: [analyze-gemini]
+    saveToFile: true
+    maxTokens: 3500
+
+  - name: analyze-perplexity
+    tool: perplexity_reason
+    input:
+      problem: "${query}"
+      approach: "analytical"
+    dependsOn: [analyze-qwen]
+    saveToFile: true
+    maxTokens: 3500
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # CHALLENGE: Models critique and refine each other's analyses
+  # ═══════════════════════════════════════════════════════════════════════════
+
+  - name: challenge-grok
+    tool: grok_reason
+    input:
+      problem: |
+        Challenge the previous analyses. Find flaws, edge cases, and hidden assumptions.
+
+        Original question: ${query}
+
+        Perplexity's analysis: ${analyze-perplexity.output}
+      approach: "systematic"
+      useHeavy: true
+    loadFiles: [analyze-grok, analyze-gemini, analyze-qwen, analyze-perplexity]
+    dependsOn: [analyze-perplexity]
+    saveToFile: true
+    maxTokens: 3500
+
+  - name: challenge-gemini
+    tool: gemini_analyze_text
+    input:
+      text: |
+        Original question: ${query}
+
+        Task: Synthesize all analyses, then propose alternative approaches.
+
+        Grok's challenges: ${challenge-grok.output}
+      type: "general"
+    loadFiles: [challenge-grok]
+    dependsOn: [challenge-grok]
+    saveToFile: true
+    maxTokens: 3500
+
+  - name: challenge-qwen
+    tool: qwen_coder
+    input:
+      task: "explain"
+      requirements: |
+        Original question: ${query}
+
+        Context: Review Gemini's synthesis below and identify technical risks, implementation challenges, and missing considerations.
+
+        Gemini's synthesis:
+        ${challenge-gemini.output}
+      language: "typescript"
+    loadFiles: [challenge-gemini]
+    dependsOn: [challenge-gemini]
+    saveToFile: true
+    maxTokens: 3500
+
+  - name: challenge-perplexity
+    tool: perplexity_ask
+    input:
+      query: |
+        Context: We are analyzing architectural patterns (SOLID principles vs CQRS vs other patterns) for this question: "${query}"
+
+        Task: Research and find evidence from authoritative sources that supports or refutes the technical analysis below:
+
+        ${challenge-qwen.output}
+
+        Focus your research on: architectural patterns, SOLID principles, CQRS, software design trade-offs, and real-world case studies.
+      searchDomain: "general"
+      searchRecency: "month"
+    loadFiles: [challenge-qwen]
+    dependsOn: [challenge-qwen]
+    saveToFile: true
+    maxTokens: 3500
+
+  # ═══════════════════════════════════════════════════════════════════════════
+  # CONSENSUS: Final multi-model comparison
+  # ═══════════════════════════════════════════════════════════════════════════
+
+  - name: consensus
+    tool: openai_compare
+    input:
+      topic: "Final consensus on: ${query}"
+      options:
+        - "Grok's analysis: ${challenge-grok.output}"
+        - "Gemini's synthesis: ${challenge-gemini.output}"
+        - "Qwen's technical review: ${challenge-qwen.output}"
+        - "Perplexity's validation: ${challenge-perplexity.output}"
+      criteria: "Coherence, technical soundness, real-world feasibility, and consensus strength"
+      includeRecommendation: true
+    loadFiles: [challenge-grok, challenge-gemini, challenge-qwen, challenge-perplexity]
+    dependsOn: [challenge-perplexity]
+    saveToFile: true
+    maxTokens: 4000
+
+output:
+  format: detailed
+  truncateSteps: false