tachibot-mcp 2.0.2

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

@@ -0,0 +1,46 @@
+/**
+ * ModeRegistry - Registry pattern for Focus modes
+ * Follows Open/Closed Principle - add new modes without modifying this class
+ */
+export class ModeRegistry {
+    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/modes/focus-deep.mode.js

@@ -0,0 +1,27 @@
+/**
+ * FocusDeep Mode - Ultimate reasoning combining Sequential Thinking + Multi-Model
+ * Extracted from server.ts (Phase 2: SOLID refactoring)
+ * Wraps existing focus-deep.ts functionality
+ */
+import { createFocusDeepPlan, generateFocusDeepVisualization } from '../../../../focus-deep.js';
+export class FocusDeepMode {
+    constructor() {
+        this.modeName = 'focus-deep';
+        this.description = 'Ultimate reasoning combining Sequential Thinking + Multi-Model orchestration';
+    }
+    async execute(params) {
+        const query = params.query;
+        const domain = params.domain;
+        const plan = createFocusDeepPlan(query, domain);
+        const viz = generateFocusDeepVisualization(plan);
+        return {
+            output: viz,
+            metadata: {
+                mode: this.modeName,
+                sessionId: plan.sessionId,
+                models: plan.availableModels,
+                estimatedThoughts: plan.estimatedThoughts
+            }
+        };
+    }
+}

package/dist/src/application/services/focus/modes/status.mode.js

@@ -0,0 +1,50 @@
+/**
+ * Status Mode - Display system status
+ * Extracted from server.ts lines 379-400 (Phase 2: SOLID refactoring)
+ */
+import { canRunFocusDeep } from '../../../../focus-deep.js';
+import { isPerplexityAvailable } from '../../../../tools/perplexity-tools.js';
+import { isGrokAvailable } from '../../../../tools/grok-tools.js';
+import { getProviderInfo } from '../../../../tools/unified-ai-provider.js';
+import { loadConfig } from '../../../../config.js';
+export class StatusMode {
+    constructor() {
+        this.modeName = 'status';
+        this.description = 'Display system status and available features';
+    }
+    async execute(params) {
+        const config = loadConfig();
+        const providerInfo = getProviderInfo();
+        const availableProviders = Object.entries(providerInfo)
+            .filter(([_, info]) => info.available)
+            .map(([name]) => name);
+        const statusInfo = canRunFocusDeep();
+        let status = `# 🔧 Focus MCP Server Status\n\n`;
+        status += `**Mode**: ${config.isClaudeCode ? 'Claude Code' : 'Standalone'}\n`;
+        if (config.isClaudeCode) {
+            status += `**Claude Model**: ${config.claudeModel || 'Not detected'}\n`;
+        }
+        status += `\n**Available Features**:\n`;
+        status += `- Think tool: ✅ Always available\n`;
+        status += `- Sequential thinking: ✅ Always available\n`;
+        status += `- Unified AI providers: ${availableProviders.join(', ') || 'None configured'}\n`;
+        status += `- Perplexity tools: ${isPerplexityAvailable() ? '✅ Available' : '❌ Need PERPLEXITY_API_KEY'}\n`;
+        status += `- Grok tools: ${isGrokAvailable() ? '✅ Available' : '❌ Need GROK_API_KEY'}\n`;
+        // Check LM Studio async
+        const lmstudioAvailable = availableProviders.includes('lmstudio');
+        const lmstudioModel = lmstudioAvailable ? 'local-model' : 'Not connected';
+        status += `- LM Studio tools: ${lmstudioAvailable ? `✅ Available (${lmstudioModel})` : '❌ Start LM Studio'}\n`;
+        status += `\n**Focus-Deep Status**:\n`;
+        status += `- Quality: ${statusInfo.quality}\n`;
+        status += `- Available models: ${statusInfo.models.join(', ')}\n`;
+        return {
+            output: status,
+            metadata: {
+                mode: this.modeName,
+                timestamp: Date.now(),
+                providers: availableProviders,
+                quality: statusInfo.quality
+            }
+        };
+    }
+}

package/dist/src/application/services/focus/modes/tachibot-status.mode.js

@@ -0,0 +1,50 @@
+/**
+ * Status Mode - Display system status
+ * Extracted from server.ts lines 379-400 (Phase 2: SOLID refactoring)
+ */
+import { canRunFocusDeep } from '../../../../focus-deep.js';
+import { isPerplexityAvailable } from '../../../../tools/perplexity-tools.js';
+import { isGrokAvailable } from '../../../../tools/grok-tools.js';
+import { getProviderInfo } from '../../../../tools/unified-ai-provider.js';
+import { loadConfig } from '../../../../config.js';
+export class TachibotStatusMode {
+    constructor() {
+        this.modeName = 'tachibot-status';
+        this.description = 'Display TachiBot system status and available features';
+    }
+    async execute(params) {
+        const config = loadConfig();
+        const providerInfo = getProviderInfo();
+        const availableProviders = Object.entries(providerInfo)
+            .filter(([_, info]) => info.available)
+            .map(([name]) => name);
+        const statusInfo = canRunFocusDeep();
+        let status = `# 🔧 Focus MCP Server Status\n\n`;
+        status += `**Mode**: ${config.isClaudeCode ? 'Claude Code' : 'Standalone'}\n`;
+        if (config.isClaudeCode) {
+            status += `**Claude Model**: ${config.claudeModel || 'Not detected'}\n`;
+        }
+        status += `\n**Available Features**:\n`;
+        status += `- Think tool: ✅ Always available\n`;
+        status += `- Sequential thinking: ✅ Always available\n`;
+        status += `- Unified AI providers: ${availableProviders.join(', ') || 'None configured'}\n`;
+        status += `- Perplexity tools: ${isPerplexityAvailable() ? '✅ Available' : '❌ Need PERPLEXITY_API_KEY'}\n`;
+        status += `- Grok tools: ${isGrokAvailable() ? '✅ Available' : '❌ Need GROK_API_KEY'}\n`;
+        // Check LM Studio async
+        const lmstudioAvailable = availableProviders.includes('lmstudio');
+        const lmstudioModel = lmstudioAvailable ? 'local-model' : 'Not connected';
+        status += `- LM Studio tools: ${lmstudioAvailable ? `✅ Available (${lmstudioModel})` : '❌ Start LM Studio'}\n`;
+        status += `\n**Focus-Deep Status**:\n`;
+        status += `- Quality: ${statusInfo.quality}\n`;
+        status += `- Available models: ${statusInfo.models.join(', ')}\n`;
+        return {
+            output: status,
+            metadata: {
+                mode: this.modeName,
+                timestamp: Date.now(),
+                providers: availableProviders,
+                quality: statusInfo.quality
+            }
+        };
+    }
+}

package/dist/src/collaborative-orchestrator.js

@@ -0,0 +1,391 @@
+import { TechnicalDomain, REASONING_TEMPLATES } from "./reasoning-chain.js";
+import { sessionLogger } from "./session/session-logger.js";
+import { sessionManager } from "./session/session-manager.js";
+import { ToolRouter } from "./tools/tool-router.js";
+import { getMemoryManager } from "./memory/index.js";
+import { VisualizationService } from "./orchestrators/collaborative/services/visualization/VisualizationService.js";
+import { ToolExecutionService } from "./orchestrators/collaborative/services/tool-execution/ToolExecutionService.js";
+export class CollaborativeOrchestrator {
+    constructor() {
+        this.sessions = new Map();
+        this.modelTurnTaking = true;
+        this.enableVisualization = true;
+        this.modelPreferences = {}; // Global model preferences
+        this.sessionConfig = {
+            verbose: false,
+            saveSession: false,
+            outputFormat: "markdown",
+            includeTimestamps: true,
+            includeModelMetadata: true
+        };
+        this.mcpServer = null;
+        this.memoryManager = null;
+        this.enableMemory = false;
+        this.toolRouter = new ToolRouter({
+            verboseLogging: false,
+            qualityPriority: true,
+            fallbackEnabled: true
+        });
+        // Phase 2: Initialize visualization service
+        this.visualizationService = new VisualizationService({
+            modelTurnTaking: this.modelTurnTaking,
+            enableVisualization: this.enableVisualization
+        });
+        // Phase 4: Initialize tool execution service
+        this.toolExecutionService = new ToolExecutionService({
+            toolRouter: this.toolRouter,
+            memoryManager: this.memoryManager || undefined, // Convert null to undefined
+            enableMemory: this.enableMemory,
+            verbose: this.sessionConfig.verbose || false
+        });
+        // Initialize memory manager if configured
+        this.initializeMemory().catch(console.error);
+    }
+    /**
+     * Initialize memory manager
+     */
+    async initializeMemory() {
+        try {
+            // Check if memory is enabled via environment variable
+            if (process.env.ENABLE_MEMORY === 'true' || process.env.MEMORY_PROVIDER) {
+                this.memoryManager = await getMemoryManager();
+                this.enableMemory = true;
+                console.error('🧠 Memory system initialized');
+            }
+        }
+        catch (error) {
+            console.error('Failed to initialize memory:', error);
+            this.enableMemory = false;
+        }
+    }
+    /**
+     * Set MCP server reference for tool execution
+     */
+    setMCPServer(server) {
+        this.mcpServer = server;
+    }
+    /**
+     * Configure session logging
+     */
+    configureSessionLogging(config) {
+        this.sessionConfig = { ...this.sessionConfig, ...config };
+    }
+    /**
+     * Start a Deep Reasoning session - multi-model collaborative thinking
+     */
+    async startDeepReasoning(problem, domain = TechnicalDomain.ARCHITECTURE, modelOverrides, sessionOptions) {
+        const template = REASONING_TEMPLATES.deep_reasoning;
+        const sessionId = this.generateSessionId();
+        // Merge session options
+        const config = { ...this.sessionConfig, ...sessionOptions };
+        // Start session logging if enabled
+        if (config.verbose || config.saveSession) {
+            // Update sessionLogger config to match the request config
+            sessionLogger.updateConfig({
+                saveSession: config.saveSession ?? true,
+                verbose: config.verbose ?? false
+            });
+            await sessionManager.startSession("deep-reasoning", problem, config);
+        }
+        // Apply model overrides to the chain
+        const steps = template.chain.map(step => {
+            const model = modelOverrides?.[step.model] || this.modelPreferences[step.model] || step.model;
+            return {
+                ...step,
+                model,
+                prompt: step.prompt.replace("{problem}", problem)
+            };
+        });
+        const session = {
+            id: sessionId,
+            domain,
+            objective: problem,
+            chain: {
+                domain,
+                objective: problem,
+                steps,
+                maxRounds: 5
+            },
+            responses: [],
+            currentStep: 0,
+            status: "active",
+            startTime: new Date(),
+            modelOverrides
+        };
+        this.sessions.set(sessionId, session);
+        return this.generateOrchestrationPlan(session);
+    }
+    /**
+     * Start a custom reasoning chain
+     */
+    async startCustomChain(chainConfig) {
+        const sessionId = this.generateSessionId();
+        const session = {
+            id: sessionId,
+            domain: chainConfig.domain,
+            objective: chainConfig.objective,
+            chain: chainConfig,
+            responses: [],
+            currentStep: 0,
+            status: "active",
+            startTime: new Date()
+        };
+        this.sessions.set(sessionId, session);
+        return this.generateOrchestrationPlan(session);
+    }
+    /**
+     * Start a ping-pong brainstorm session
+     */
+    async startPingPongBrainstorm(problem, domain = TechnicalDomain.ARCHITECTURE, sessionOptions) {
+        return this.startTemplateSession("pingpong_brainstorm", problem, domain);
+    }
+    /**
+     * Start a dynamic debate session
+     */
+    async startDynamicDebate(debateTopic, domain = TechnicalDomain.ARCHITECTURE, sessionOptions) {
+        return this.startTemplateSession("dynamic_debate", debateTopic, domain);
+    }
+    /**
+     * Start a template-based reasoning session
+     */
+    async startTemplateSession(templateName, problem, domain) {
+        const template = REASONING_TEMPLATES[templateName];
+        if (!template) {
+            throw new Error(`Template ${templateName} not found`);
+        }
+        const sessionId = this.generateSessionId();
+        const actualDomain = domain || TechnicalDomain.ARCHITECTURE;
+        const session = {
+            id: sessionId,
+            domain: actualDomain,
+            objective: problem,
+            chain: {
+                domain: actualDomain,
+                objective: problem,
+                steps: template.chain.map(step => ({
+                    ...step,
+                    prompt: step.prompt
+                        .replace("{problem}", problem)
+                        .replace("{system}", problem)
+                        .replace("{algorithm_problem}", problem)
+                        .replace("{code}", problem)
+                        .replace("{feature}", problem)
+                        .replace("{bug_description}", problem)
+                })),
+                maxRounds: 5
+            },
+            responses: [],
+            currentStep: 0,
+            status: "active",
+            startTime: new Date(),
+            metadata: {
+                templateName,
+                templateDescription: template.description
+            }
+        };
+        this.sessions.set(sessionId, session);
+        return this.generateOrchestrationPlan(session);
+    }
+    /**
+     * Generate visual orchestration plan for a session
+     * Phase 2: Delegates to VisualizationService
+     */
+    generateOrchestrationPlan(session) {
+        return this.visualizationService.generateOrchestrationPlan(session);
+    }
+    /**
+     * Generate TachiBot visualization for the session
+     * Phase 2: Delegates to VisualizationService
+     */
+    generateTachiBotVisualization(session) {
+        return this.visualizationService.generateTachiBotVisualization(session);
+    }
+    /**
+     * Get icon for reasoning mode
+     * Phase 2: Delegates to VisualizationService
+     */
+    getModeIcon(mode) {
+        return this.visualizationService.getModeIcon(mode);
+    }
+    /**
+     * Generate example workflows for different technical domains
+     * Phase 2: Delegates to VisualizationService
+     */
+    getExampleWorkflows() {
+        return this.visualizationService.getExampleWorkflows();
+    }
+    /**
+     * Get available templates
+     * Phase 2: Delegates to VisualizationService
+     */
+    getAvailableTemplates() {
+        return this.visualizationService.getAvailableTemplates();
+    }
+    /**
+     * Set global model preferences
+     */
+    setModelPreferences(preferences) {
+        this.modelPreferences = { ...this.modelPreferences, ...preferences };
+    }
+    /**
+     * Use Grok 4 Heavy for all Grok operations
+     */
+    useGrok4Heavy() {
+        // Use GROK_4_0709 as the "heavy" model (reasoning model)
+        this.modelPreferences['grok'] = 'grok-4-0709';
+        this.modelPreferences['grok-4'] = 'grok-4-0709';
+    }
+    /**
+     * Generate session ID
+     */
+    generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Get session status
+     */
+    getSessionStatus(sessionId) {
+        return this.sessions.get(sessionId) || null;
+    }
+    /**
+     * List active sessions
+     */
+    listActiveSessions() {
+        const activeSessions = Array.from(this.sessions.values())
+            .filter(s => s.status === "active");
+        if (activeSessions.length === 0) {
+            return "No active reasoning sessions.";
+        }
+        let output = `# Active Reasoning Sessions\n\n`;
+        activeSessions.forEach(session => {
+            output += `- **${session.id}**: ${session.objective} (Step ${session.currentStep}/${session.chain.steps.length})\n`;
+        });
+        return output;
+    }
+    /**
+     * Execute reasoning chain with session logging
+     */
+    async executeWithLogging(session, verbose = false, saveSession = false) {
+        const config = { ...this.sessionConfig, verbose, saveSession };
+        // Start session logging
+        if (config.verbose || config.saveSession) {
+            // Update sessionLogger config to match the request config
+            sessionLogger.updateConfig({
+                saveSession: config.saveSession ?? true,
+                verbose: config.verbose ?? false
+            });
+            await sessionManager.startSession(session.chain.steps[0]?.mode || "reasoning", session.objective, config);
+        }
+        const modelContributions = new Map();
+        const insights = [];
+        const actionItems = [];
+        // Execute each step in the chain
+        for (let i = 0; i < session.chain.steps.length; i++) {
+            const step = session.chain.steps[i];
+            session.currentStep = i;
+            // Log step if verbose
+            if (config.verbose) {
+                console.error(`\n📍 Step ${i + 1}/${session.chain.steps.length}: ${step.mode}`);
+                console.error(`Model: ${step.model}`);
+            }
+            // Execute real tool instead of simulation
+            const response = await this.executeRealTool(step.model, step.prompt, step.mode);
+            // Log to session
+            if (config.verbose || config.saveSession) {
+                await sessionLogger.logStep(step.model, this.getProviderForModel(step.model), step.mode, step.prompt, response, { stepNumber: i + 1 });
+            }
+            // Store response
+            session.responses.push({
+                model: step.model,
+                content: response,
+                reasoning: `Mode: ${step.mode}`
+            });
+            // Track contributions
+            const contributions = modelContributions.get(step.model) || [];
+            contributions.push(response);
+            modelContributions.set(step.model, contributions);
+        }
+        // Generate synthesis
+        const finalSynthesis = this.generateSynthesis(session.responses);
+        // Log synthesis
+        if (config.verbose || config.saveSession) {
+            await sessionLogger.addSynthesis(finalSynthesis);
+            await sessionManager.endSession(config.saveSession);
+        }
+        session.status = "completed";
+        return {
+            session,
+            finalSynthesis,
+            modelContributions,
+            consensusScore: this.calculateConsensus(session.responses),
+            insights,
+            actionItems
+        };
+    }
+    /**
+     * Execute real tool based on model and reasoning mode
+     * Phase 4: Delegates to ToolExecutionService (extracted 842 lines!)
+     */
+    async executeRealTool(model, prompt, mode, context) {
+        // Update service with current settings
+        this.toolExecutionService.setVerbose(this.sessionConfig.verbose || false);
+        // Delegate to tool execution service
+        return await this.toolExecutionService.executeRealTool(model, prompt, mode, context);
+    }
+    /**
+     * Set memory context for the session
+     */
+    setMemoryContext(context) {
+        if (this.memoryManager) {
+            this.memoryManager.setContext(context);
+        }
+    }
+    /**
+     * Get memory metrics
+     */
+    async getMemoryMetrics() {
+        if (!this.memoryManager)
+            return null;
+        return await this.memoryManager.getMetrics();
+    }
+    /**
+     * Get provider name for a model
+     */
+    getProviderForModel(model) {
+        if (model.startsWith('gpt'))
+            return 'openai';
+        if (model.startsWith('claude'))
+            return 'anthropic';
+        if (model.startsWith('gemini'))
+            return 'google';
+        if (model.startsWith('grok'))
+            return 'xai';
+        if (model.startsWith('kimi'))
+            return 'moonshot';
+        if (model.includes('perplexity'))
+            return 'perplexity';
+        return 'unknown';
+    }
+    /**
+     * Generate synthesis from model responses
+     */
+    generateSynthesis(responses) {
+        if (responses.length === 0)
+            return '';
+        // Simple synthesis - combine all responses
+        const combined = responses.map((r, i) => `### ${i + 1}. ${r.model}\n\n${r.content}`).join('\n\n---\n\n');
+        return `# Synthesis of ${responses.length} Model Responses\n\n${combined}`;
+    }
+    /**
+     * Calculate consensus score from responses
+     */
+    calculateConsensus(responses) {
+        if (responses.length < 2)
+            return 1.0;
+        // Simple consensus score based on response similarity
+        // For now, return a fixed score - can be enhanced later
+        return 0.85;
+    }
+}
+// Export singleton instance
+export const collaborativeOrchestrator = new CollaborativeOrchestrator();