tachibot-mcp 2.0.2

package/README.md

@@ -0,0 +1,201 @@
+# TachiBot MCP - Universal AI Orchestrator
+
+[![Version](https://img.shields.io/badge/version-2.0.0-blue.svg)](https://github.com/byPawel/tachibot-mcp)
+[![License](https://img.shields.io/badge/license-Apache%202.0-green.svg)](LICENSE)
+[![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org)
+[![MCP](https://img.shields.io/badge/MCP-Compatible-purple.svg)](https://modelcontextprotocol.io)
+
+Multi-model AI orchestration platform with 31 tools (32 with competitive mode), advanced workflows, and intelligent prompt engineering. Works with Claude Code, Claude Desktop, Cursor, and any MCP-compatible client.
+
+---
+
+## 📚 Documentation
+
+**🌐 Full Documentation:** [tachibot.com/docs](https://tachibot.com/docs)
+
+### Quick Links
+
+- **[Installation Guide](docs/INSTALLATION_BOTH.md)** - Get started in 5 minutes
+- **[Configuration](docs/CONFIGURATION.md)** - Profiles, API keys, settings
+- **[Tools Reference](docs/TOOLS_REFERENCE.md)** - All 31 tools explained
+- **[Workflows](docs/WORKFLOWS.md)** - Multi-step AI orchestration
+- **[API Keys Guide](docs/API_KEYS.md)** - Where to get API keys
+
+---
+
+## ✨ Key Features
+
+### 🤖 Multi-Model Intelligence
+- **31 AI Tools:** Perplexity, Grok, GPT-5, Gemini, Qwen, Kimi (32 with competitive mode)
+- **Multi-Model Reasoning:** Challenger, Verifier, Scout modes
+- **Smart Routing:** Automatic model selection for optimal results
+
+### 🔄 Advanced Workflows
+- **YAML-Based Workflows:** Define complex multi-step AI processes
+- **Prompt Engineering:** 14 research-backed techniques built-in
+- **Auto-Synthesis:** Prevents token overflow on large workflows
+- **Parallel Execution:** Run multiple models simultaneously
+
+### 🎯 Tool Profiles
+- **Minimal** (8 tools) - Budget-friendly, token-constrained
+- **Research Power** (15 tools) - Default, best balance
+- **Code Focus** (13 tools) - Software development
+- **Balanced** (17 tools) - General-purpose
+- **Full** (31 tools, 32 with competitive) - Maximum capability
+
+### 🔧 Developer Experience
+- **Claude Code Native** - First-class support
+- **Claude Desktop** - Full integration
+- **Cursor** - Works seamlessly
+- **TypeScript** - Fully typed
+- **Extensible** - Add custom tools & workflows
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+# Via NPM (recommended)
+npm install -g tachibot-mcp
+
+# Verify installation
+tachibot --version
+```
+
+### Setup
+
+1. **Add API Keys** (at least one):
+   ```bash
+   cp .env.example .env
+   # Edit .env and add your API keys
+   ```
+
+2. **Configure Profile** (optional):
+   ```bash
+   # Edit .env
+   TACHIBOT_PROFILE=research_power  # or minimal, code_focus, balanced, full
+   ```
+
+3. **Add to Claude Code/Desktop**:
+   ```json
+   {
+     "mcpServers": {
+       "tachibot": {
+         "command": "tachibot",
+         "env": {
+           "PERPLEXITY_API_KEY": "your-key",
+           "GROK_API_KEY": "your-key",
+           "OPENAI_API_KEY": "your-key",
+           "GEMINI_API_KEY": "your-key",
+           "OPENROUTER_API_KEY": "your-key"
+         }
+       }
+     }
+   }
+   ```
+
+4. **Restart Claude** and you're ready! 🎉
+
+See [Installation Guide](docs/INSTALLATION_BOTH.md) for detailed instructions.
+
+---
+
+## 📦 What's Included
+
+### Core Tools
+- 🔍 **Research:** `perplexity_ask`, `perplexity_research`, `grok_search`, `scout`
+- 🧠 **Reasoning:** `grok_reason`, `kimi_thinking`, `openai_brainstorm`, `focus`
+- 💡 **Analysis:** `gemini_brainstorm`, `gemini_analyze_text`, `qwen_coder`
+- ✅ **Validation:** `verifier`, `challenger`
+- 💭 **Meta:** `think`, `nextThought`
+
+### Advanced Modes
+- **Focus** - Deep collaborative reasoning (4+ models)
+- **Scout** - Multi-source information gathering
+- **Challenger** - Critical analysis with fact-checking
+- **Verifier** - Multi-model consensus verification
+
+### Workflows
+- **Ultra Creative Brainstorm** - 15 steps, 10 techniques
+- **Iterative Problem Solver** - Research → Analyze → Solve
+- **Code Architecture Review** - Systematic code analysis
+- **Accessibility Audit** - WCAG compliance checking
+- **Custom Workflows** - Build your own in YAML
+
+---
+
+## 🌟 Example Usage
+
+### Quick Research
+```typescript
+// In Claude Code
+perplexity_ask({
+  query: "What are the latest developments in transformer architecture?"
+})
+```
+
+### Multi-Model Reasoning
+```typescript
+focus({
+  query: "Design a scalable microservice architecture",
+  mode: "deep-reasoning",
+  models: ["grok-3", "gpt-5", "gemini-2.5"],
+  rounds: 5
+})
+```
+
+### Run Workflow
+```bash
+workflow --name ultra-creative-brainstorm --query "AI-powered code review system"
+```
+
+---
+
+## 🎓 Learn More
+
+### Documentation
+- 📖 [Full Documentation](https://tachibot.com/docs)
+- 🔧 [Configuration Guide](docs/CONFIGURATION.md)
+- 🛠️ [Tool Parameters](docs/TOOL_PARAMETERS.md)
+- 🎯 [Tool Profiles](docs/TOOL_PROFILES.md)
+- 🔐 [API Keys Guide](docs/API_KEYS.md)
+- ⚡ [Focus Modes](docs/FOCUS_MODES.md)
+- 📝 [Workflows Guide](docs/WORKFLOWS.md)
+
+### Setup Guides
+- [Claude Code Setup](docs/CLAUDE_CODE_SETUP.md)
+- [Claude Desktop Setup](docs/CLAUDE_DESKTOP_MANUAL.md)
+- [Both Platforms](docs/INSTALLATION_BOTH.md)
+
+---
+
+## 🤝 Contributing
+
+We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+- 🐛 [Report Issues](https://github.com/byPawel/tachibot-mcp/issues)
+- 💡 [Request Features](https://github.com/byPawel/tachibot-mcp/issues/new?template=feature_request.md)
+- 📖 [Improve Docs](https://github.com/byPawel/tachibot-mcp/pulls)
+
+---
+
+## 📄 License
+
+Apache License 2.0 - see [LICENSE](LICENSE) for details.
+
+---
+
+## 🔗 Links
+
+- **Website:** [tachibot.com](https://tachibot.com)
+- **Documentation:** [tachibot.com/docs](https://tachibot.com/docs)
+- **GitHub:** [github.com/byPawel/tachibot-mcp](https://github.com/byPawel/tachibot-mcp)
+- **Issues:** [Report a Bug](https://github.com/byPawel/tachibot-mcp/issues)
+
+---
+
+**Made with ❤️ by the TachiBot Team**
+
+*Transform your AI workflow with intelligent multi-model orchestration.*

package/SECURITY.md

@@ -0,0 +1,95 @@
+# Security Policy
+
+## Supported Versions
+
+Currently supported versions for security updates:
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 2.0.x   | :white_check_mark: |
+| < 2.0   | :x:                |
+
+## Reporting a Vulnerability
+
+We take security vulnerabilities seriously. If you discover a security vulnerability within TachiBot MCP, please follow these steps:
+
+### How to Report
+
+1. **DO NOT** create a public GitHub issue for security vulnerabilities
+2. Instead, please report vulnerabilities via:
+   - Email: `tachibotmcp [at] gmail [dot] com`
+   - GitHub Security Advisory: [Report a vulnerability](https://github.com/pavveu/tachibot-mcp/security/advisories/new)
+
+### What to Include
+
+Please provide:
+- Description of the vulnerability
+- Steps to reproduce
+- Potential impact
+- Suggested fix (if any)
+
+### Response Timeline
+
+- Acknowledgment: Within 48 hours
+- Initial assessment: Within 1 week
+- Fix timeline: Depends on severity
+
+## Security Best Practices
+
+When using TachiBot MCP:
+
+### API Key Management
+- **Never** commit API keys to version control
+- Always use `.env` files for sensitive data
+- Keep `.env` in `.gitignore`
+- Rotate API keys regularly
+- Use minimal required permissions for API keys
+
+### Environment Variables
+- All sensitive data should be in environment variables
+- Never hardcode credentials in source code
+- Review `.env.example` for required variables
+
+### Dependencies
+- Keep dependencies updated
+- Run `npm audit` regularly
+- Fix vulnerabilities with `npm audit fix`
+
+### MCP Server Security
+- Only install MCP servers from trusted sources
+- Review server permissions before installation
+- Understand what data servers can access
+
+## Known Security Considerations
+
+### API Key Exposure
+- TachiBot MCP requires multiple API keys
+- Each key should have minimal required permissions
+- Monitor API usage for unusual activity
+
+### Tool Execution
+- Tools can make external API calls
+- Review tool actions before execution
+- Understand cost implications of tool usage
+
+### Data Privacy
+- TachiBot may send data to external AI providers
+- Review privacy policies of used services
+- Don't process sensitive/personal data
+
+## Security Updates
+
+Security updates will be released as:
+- Patch versions for minor fixes
+- Minor versions for significant security improvements
+- Announced in GitHub releases
+
+## Contact
+
+For security-related inquiries:
+- Email: `tachibotmcp [at] gmail [dot] com`
+- GitHub Security Advisory: [Report a vulnerability](https://github.com/pavveu/tachibot-mcp/security/advisories/new)
+
+## Acknowledgments
+
+We appreciate responsible disclosure of security vulnerabilities and will acknowledge security researchers who help improve TachiBot MCP's security.

package/dist/personality/komaai-expressions.js

@@ -0,0 +1,12 @@
+export function getKomaAIForStep(step) {
+    return {
+        message: "TachiBot thinking...",
+        ascii: "@@@@@@@@@\n@  ● ●  @\n@   ◡   @\n@@@@@@@@@"
+    };
+}
+export function getRandomKomaAI() {
+    return getKomaAIForStep(0);
+}
+export function getKomaAIState() {
+    return "active";
+}

package/dist/profiles/balanced.json

@@ -0,0 +1,33 @@
+{
+  "description": "Balanced set for general use (~10-11k tokens, 17 tools)",
+  "tools": {
+    "think": true,
+    "focus": true,
+    "nextThought": true,
+    "perplexity_ask": true,
+    "perplexity_reason": true,
+    "grok_reason": true,
+    "grok_code": true,
+    "openai_brainstorm": true,
+    "gemini_brainstorm": true,
+    "gemini_analyze_code": true,
+    "qwen_coder": true,
+    "verifier": true,
+    "scout": true,
+    "challenger": true,
+    "workflow": true,
+    "list_workflows": true,
+    "pingpong": true,
+    "perplexity_research": false,
+    "grok_debug": false,
+    "grok_architect": false,
+    "grok_brainstorm": false,
+    "grok_search": false,
+    "openai_compare": false,
+    "gemini_analyze_text": false,
+    "kimi_thinking": false,
+    "create_workflow": false,
+    "visualize_workflow": false,
+    "qwen_competitive": false
+  }
+}

package/dist/profiles/code_focus.json

@@ -0,0 +1,33 @@
+{
+  "description": "Code-heavy work with debugging and analysis (~8-9k tokens, 13 tools)",
+  "tools": {
+    "think": true,
+    "focus": true,
+    "nextThought": true,
+    "perplexity_ask": true,
+    "grok_reason": true,
+    "grok_code": true,
+    "grok_debug": true,
+    "gemini_analyze_code": true,
+    "gemini_brainstorm": true,
+    "qwen_coder": true,
+    "verifier": true,
+    "workflow": true,
+    "list_workflows": true,
+    "perplexity_reason": false,
+    "perplexity_research": false,
+    "grok_architect": false,
+    "grok_brainstorm": false,
+    "grok_search": false,
+    "openai_compare": false,
+    "openai_brainstorm": false,
+    "gemini_analyze_text": false,
+    "kimi_thinking": false,
+    "scout": false,
+    "challenger": false,
+    "create_workflow": false,
+    "visualize_workflow": false,
+    "pingpong": false,
+    "qwen_competitive": false
+  }
+}

package/dist/profiles/full.json

@@ -0,0 +1,33 @@
+{
+  "description": "All tools enabled for maximum capability (~18-19k tokens, 26 tools)",
+  "tools": {
+    "think": true,
+    "focus": true,
+    "nextThought": true,
+    "perplexity_ask": true,
+    "perplexity_reason": true,
+    "perplexity_research": true,
+    "grok_reason": true,
+    "grok_code": true,
+    "grok_debug": true,
+    "grok_architect": true,
+    "grok_brainstorm": true,
+    "grok_search": true,
+    "openai_compare": true,
+    "openai_brainstorm": true,
+    "gemini_brainstorm": true,
+    "gemini_analyze_code": true,
+    "gemini_analyze_text": true,
+    "qwen_coder": true,
+    "kimi_thinking": true,
+    "verifier": true,
+    "scout": true,
+    "challenger": true,
+    "workflow": true,
+    "list_workflows": true,
+    "create_workflow": true,
+    "visualize_workflow": true,
+    "pingpong": true,
+    "qwen_competitive": false
+  }
+}

package/dist/profiles/minimal.json

@@ -0,0 +1,33 @@
+{
+  "description": "Minimal tool set for basic tasks (~4-5k tokens, 8 tools)",
+  "tools": {
+    "think": true,
+    "focus": true,
+    "nextThought": true,
+    "perplexity_ask": true,
+    "grok_reason": true,
+    "gemini_brainstorm": true,
+    "qwen_coder": true,
+    "workflow": true,
+    "perplexity_reason": false,
+    "perplexity_research": false,
+    "grok_code": false,
+    "grok_debug": false,
+    "grok_architect": false,
+    "grok_brainstorm": false,
+    "grok_search": false,
+    "openai_compare": false,
+    "openai_brainstorm": false,
+    "gemini_analyze_code": false,
+    "gemini_analyze_text": false,
+    "kimi_thinking": false,
+    "verifier": false,
+    "scout": false,
+    "challenger": false,
+    "list_workflows": false,
+    "create_workflow": false,
+    "visualize_workflow": false,
+    "pingpong": false,
+    "qwen_competitive": false
+  }
+}

package/dist/profiles/research_power.json

@@ -0,0 +1,33 @@
+{
+  "description": "Research-focused with Grok search + all Perplexity + brainstorming (~9-10k tokens, 15 tools)",
+  "tools": {
+    "think": true,
+    "focus": true,
+    "nextThought": true,
+    "perplexity_ask": true,
+    "perplexity_reason": true,
+    "perplexity_research": true,
+    "grok_search": true,
+    "grok_reason": true,
+    "openai_brainstorm": true,
+    "gemini_brainstorm": true,
+    "scout": true,
+    "verifier": true,
+    "challenger": true,
+    "qwen_coder": true,
+    "kimi_thinking": true,
+    "workflow": true,
+    "list_workflows": true,
+    "grok_code": false,
+    "grok_debug": false,
+    "grok_architect": false,
+    "grok_brainstorm": false,
+    "openai_compare": false,
+    "gemini_analyze_code": false,
+    "gemini_analyze_text": false,
+    "create_workflow": false,
+    "visualize_workflow": false,
+    "pingpong": false,
+    "qwen_competitive": false
+  }
+}

package/dist/scripts/build-profiles.js

@@ -0,0 +1,46 @@
+/**
+ * Build Profiles Script
+ * Converts TypeScript profile definitions to JSON files
+ * Run during npm run build
+ */
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Get __dirname equivalent in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Import profile definitions
+import { minimalProfile } from '../src/profiles/minimal.js';
+import { researchPowerProfile } from '../src/profiles/research_power.js';
+import { codeFocusProfile } from '../src/profiles/code_focus.js';
+import { balancedProfile } from '../src/profiles/balanced.js';
+import { fullProfile } from '../src/profiles/full.js';
+const profiles = {
+    minimal: minimalProfile,
+    research_power: researchPowerProfile,
+    code_focus: codeFocusProfile,
+    balanced: balancedProfile,
+    full: fullProfile,
+};
+// Output directory - write to root profiles/ (not dist/profiles/)
+const outputDir = join(__dirname, '../..', 'profiles');
+// Ensure output directory exists
+if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+}
+console.log('🔨 Building profile JSON files...\n');
+// Convert each profile to JSON
+for (const [name, profile] of Object.entries(profiles)) {
+    const outputPath = join(outputDir, `${name}.json`);
+    // Count enabled tools
+    const enabledCount = Object.values(profile.tools).filter(Boolean).length;
+    // Update description with actual count (replace any existing count)
+    const updatedProfile = {
+        ...profile,
+        description: profile.description.replace(/\d+ tools\)/, `${enabledCount} tools)`)
+    };
+    const jsonContent = JSON.stringify(updatedProfile, null, 2);
+    writeFileSync(outputPath, jsonContent, 'utf-8');
+    console.log(`✅ ${name}.json (${enabledCount} tools)`);
+}
+console.log(`\n✨ Built ${Object.keys(profiles).length} profile files in ${outputDir}`);

package/dist/src/application/services/focus/FocusModeRegistry.js

@@ -0,0 +1,46 @@
+/**
+ * FocusModeRegistry - Registry pattern for Focus modes
+ * Follows Open/Closed Principle - add new modes without modifying this class
+ */
+export class FocusModeRegistry {
+    constructor() {
+        this.modes = new Map();
+    }
+    /**
+     * Register a focus mode
+     * @param mode Mode implementation to register
+     */
+    register(mode) {
+        this.modes.set(mode.modeName, mode);
+    }
+    /**
+     * Get a focus mode by name
+     * @param name Mode name
+     * @returns Mode implementation or undefined
+     */
+    get(name) {
+        return this.modes.get(name);
+    }
+    /**
+     * Get all registered mode names
+     * @returns Array of mode names
+     */
+    getAllNames() {
+        return Array.from(this.modes.keys());
+    }
+    /**
+     * Check if a mode is registered
+     * @param name Mode name
+     * @returns true if mode exists
+     */
+    has(name) {
+        return this.modes.has(name);
+    }
+    /**
+     * Get count of registered modes
+     * @returns Number of modes
+     */
+    get size() {
+        return this.modes.size;
+    }
+}

package/dist/src/application/services/focus/FocusTool.service.js

@@ -0,0 +1,109 @@
+/**
+ * FocusTool Service - Orchestrator for Focus modes
+ * Uses Strategy Pattern + Registry + Delegate Map for mode management
+ * Phase 2 of SOLID refactoring (reduces 431-line switch statement)
+ *
+ * Architecture:
+ * 1. FocusModeRegistry - For complex extracted modes (FocusDeepMode, TachibotStatusMode)
+ * 2. Delegate Map - For simple orchestrator calls
+ * 3. Legacy fallback - For modes with complex conditional logic (handled by server.ts)
+ */
+import { TechnicalDomain } from '../../../reasoning-chain.js';
+export class FocusToolService {
+    constructor(modeRegistry, collaborativeOrchestrator) {
+        this.modeRegistry = modeRegistry;
+        this.collaborativeOrchestrator = collaborativeOrchestrator;
+        this.name = 'focus';
+        this.description = 'Multi-model reasoning with various modes';
+        this.delegateHandlers = this.createDelegateHandlers();
+    }
+    async execute(params) {
+        const modeName = params.mode || 'simple';
+        // 1. Try extracted modes first (Strategy Pattern)
+        const mode = this.modeRegistry.get(modeName);
+        if (mode) {
+            return mode.execute(params);
+        }
+        // 2. Try delegate handlers (simple orchestrator calls)
+        const handler = this.delegateHandlers.get(modeName);
+        if (handler) {
+            const output = await handler(params);
+            return {
+                output,
+                metadata: {
+                    mode: modeName,
+                    timestamp: Date.now()
+                }
+            };
+        }
+        // 3. Mode not found in service - fallback to legacy server.ts
+        // This allows gradual migration of complex conditional modes
+        throw new Error(`Mode "${modeName}" not handled by FocusToolService. ` +
+            `Available: [${[...this.modeRegistry.getAllNames(), ...this.delegateHandlers.keys()].join(', ')}]`);
+    }
+    validate(params) {
+        const mode = params.mode;
+        return typeof mode === 'string' && mode.length > 0;
+    }
+    /**
+     * Create delegate handlers for simple orchestrator modes
+     * These modes just call a single collaborativeOrchestrator method
+     */
+    createDelegateHandlers() {
+        const handlers = new Map();
+        // Helper to parse domain parameter
+        const parseDomain = (domainParam) => {
+            if (!domainParam || typeof domainParam !== 'string') {
+                return TechnicalDomain.ARCHITECTURE; // Default fallback
+            }
+            const domainKey = domainParam.toUpperCase();
+            return TechnicalDomain[domainKey] || TechnicalDomain.ARCHITECTURE;
+        };
+        // Deep reasoning & code brainstorming
+        handlers.set('deep-reasoning', async (params) => {
+            const query = params.query;
+            const domain = parseDomain(params.domain);
+            const plan = await this.collaborativeOrchestrator.startDeepReasoning(query, domain);
+            const title = "🧠 **DEEP COLLABORATIVE REASONING**";
+            return `${title}\n\n${plan}\n\n🔄 **How it works**: Models collaborate, critique, and build upon each other's ideas to find optimal solutions.`;
+        });
+        handlers.set('code-brainstorm', async (params) => {
+            const query = params.query;
+            const domain = parseDomain(params.domain);
+            const plan = await this.collaborativeOrchestrator.startDeepReasoning(query, domain);
+            const title = "💡 **CODE BRAINSTORMING SESSION**";
+            return `${title}\n\n${plan}\n\n🔄 **How it works**: Models collaborate, critique, and build upon each other's ideas to find optimal solutions.`;
+        });
+        // Dynamic debate
+        handlers.set('dynamic-debate', async (params) => {
+            const query = params.query;
+            const domain = parseDomain(params.domain);
+            const plan = await this.collaborativeOrchestrator.startDynamicDebate(query, domain);
+            return `⚔️ **DYNAMIC DEBATE SESSION**\n\n${plan}\n\n🥊 **How it works**: Models take opposing positions, argue their cases, provide rebuttals, and engage in intellectual combat to explore all angles of complex problems.`;
+        });
+        // Template-based modes
+        const templateModes = [
+            ['architecture-debate', 'architecture_debate'],
+            ['algorithm-optimize', 'algorithm_optimize'],
+            ['security-audit', 'security_audit'],
+            ['api-design', 'api_design'],
+            ['debug-detective', 'debug_detective'],
+            ['performance-council', 'performance_council']
+        ];
+        for (const [modeName, templateKey] of templateModes) {
+            handlers.set(modeName, async (params) => {
+                const query = params.query;
+                const domain = parseDomain(params.domain);
+                return await this.collaborativeOrchestrator.startTemplateSession(templateKey, query, domain);
+            });
+        }
+        // Simple utility modes
+        handlers.set('list-templates', async () => {
+            return this.collaborativeOrchestrator.getAvailableTemplates();
+        });
+        handlers.set('examples', async () => {
+            return this.collaborativeOrchestrator.getExampleWorkflows();
+        });
+        return handlers;
+    }
+}