tachibot-mcp 2.0.2

package/dist/src/workflows/engine/handlers/ToolInvocationHandler.js

@@ -0,0 +1,46 @@
+/**
+ * Tool Invocation Handler
+ * Handles actual tool execution via tool-mapper
+ * Subscribes to workflow.tool.invoke events
+ */
+import { WorkflowEvents } from '../events/WorkflowEventBus.js';
+export class ToolInvocationHandler {
+    constructor(eventBus) {
+        this.eventBus = eventBus;
+        // Subscribe to tool invoke events
+        this.eventBus.subscribe(WorkflowEvents.TOOL_INVOKED, this.handleToolInvoke.bind(this));
+    }
+    async handleToolInvoke(event) {
+        const { stepName, tool, input, options } = event;
+        const startTime = Date.now();
+        try {
+            // Dynamic import to avoid circular dependencies
+            const { executeWorkflowTool } = await import('../../tool-mapper.js');
+            console.error(`[ToolInvocation] Executing ${tool} for step ${stepName}`);
+            // Execute the tool
+            const toolResult = await executeWorkflowTool(tool, input, options);
+            const duration = Date.now() - startTime;
+            // Publish success event
+            await this.eventBus.publish(WorkflowEvents.TOOL_SUCCESS, {
+                stepName,
+                success: true,
+                result: toolResult.result,
+                modelUsed: toolResult.modelUsed,
+                duration,
+                tokensUsed: 0, // TODO: Extract from toolResult if available
+                cost: 0 // TODO: Calculate based on model and tokens
+            });
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            console.error(`[ToolInvocation] Error executing ${tool} for step ${stepName}:`, error);
+            // Publish failure event
+            await this.eventBus.publish(WorkflowEvents.TOOL_FAILURE, {
+                stepName,
+                success: false,
+                error: error,
+                duration
+            });
+        }
+    }
+}

package/dist/src/workflows/engine/interfaces/IAutoSynthesizer.js

@@ -0,0 +1,5 @@
+/**
+ * Interface for automatic workflow synthesis
+ * Summarizes large multi-step workflow outputs to bypass MCP 25k token limit
+ */
+export {};

package/dist/src/workflows/engine/interfaces/IStepParameterResolver.js

@@ -0,0 +1,5 @@
+/**
+ * Interface for resolving step parameters (model, temperature, maxTokens)
+ * Handles interpolation of ${variable} syntax in step configuration
+ */
+export {};

package/dist/src/workflows/engine/interfaces/IVariableInterpolator.js

@@ -0,0 +1,5 @@
+/**
+ * Interface for variable interpolation in workflow templates
+ * Handles ${variable} and ${step.output} syntax in strings
+ */
+export {};

package/dist/src/workflows/engine/interfaces/IWorkflowDiscovery.js

@@ -0,0 +1,4 @@
+/**
+ * Interface for workflow discovery and loading
+ */
+export {};

package/dist/src/workflows/engine/interfaces/IWorkflowFileManager.js

@@ -0,0 +1,5 @@
+/**
+ * Interface for workflow file management
+ * Handles file references, output saving, and manifest updates
+ */
+export {};

package/dist/src/workflows/engine/interfaces/IWorkflowOutputFormatter.js

@@ -0,0 +1,5 @@
+/**
+ * Interface for formatting workflow execution results
+ * Supports multiple output formats (summary, detailed, JSON)
+ */
+export {};

package/dist/src/workflows/engine/state/WorkflowStateMachine.js

@@ -0,0 +1,194 @@
+/**
+ * Workflow State Machine
+ * Manages workflow state transitions with event emission
+ * Follows CircuitBreaker pattern (extends EventEmitter)
+ */
+import { EventEmitter } from 'events';
+import { WorkflowState } from './interfaces/IStateMachine.js';
+export class WorkflowStateMachine extends EventEmitter {
+    constructor() {
+        super();
+        this.currentState = WorkflowState.INITIALIZED;
+        this.stateHistory = [];
+        // Valid state transitions (adjacency list)
+        this.validTransitions = new Map([
+            [WorkflowState.INITIALIZED, [
+                    WorkflowState.VALIDATING,
+                    WorkflowState.FAILED
+                ]],
+            [WorkflowState.VALIDATING, [
+                    WorkflowState.RUNNING,
+                    WorkflowState.FAILED
+                ]],
+            [WorkflowState.RUNNING, [
+                    WorkflowState.STEP_EXECUTING,
+                    WorkflowState.SYNTHESIZING,
+                    WorkflowState.COMPLETED,
+                    WorkflowState.FAILED,
+                    WorkflowState.PAUSED
+                ]],
+            [WorkflowState.STEP_EXECUTING, [
+                    WorkflowState.WAITING,
+                    WorkflowState.RUNNING,
+                    WorkflowState.RETRYING,
+                    WorkflowState.FAILED
+                ]],
+            [WorkflowState.WAITING, [
+                    WorkflowState.STEP_EXECUTING,
+                    WorkflowState.RUNNING,
+                    WorkflowState.FAILED
+                ]],
+            [WorkflowState.RETRYING, [
+                    WorkflowState.STEP_EXECUTING,
+                    WorkflowState.FAILED
+                ]],
+            [WorkflowState.SYNTHESIZING, [
+                    WorkflowState.STEP_EXECUTING,
+                    WorkflowState.COMPLETED,
+                    WorkflowState.FAILED
+                ]],
+            [WorkflowState.PAUSED, [
+                    WorkflowState.RUNNING,
+                    WorkflowState.FAILED
+                ]],
+            [WorkflowState.COMPLETED, []],
+            [WorkflowState.FAILED, []]
+        ]);
+        this.recordState(WorkflowState.INITIALIZED, {
+            workflowId: '',
+            workflowName: ''
+        });
+    }
+    getCurrentState() {
+        return this.currentState;
+    }
+    canTransition(to) {
+        const allowedStates = this.validTransitions.get(this.currentState) || [];
+        return allowedStates.includes(to);
+    }
+    transition(to, context) {
+        const from = this.currentState;
+        // Validate transition
+        if (!this.canTransition(to)) {
+            throw new Error(`Invalid state transition: ${from} -> ${to}. ` +
+                `Allowed transitions from ${from}: ${this.validTransitions.get(from)?.join(', ') || 'none'}`);
+        }
+        // Update state
+        this.currentState = to;
+        this.recordState(to, context);
+        // Emit state change event
+        this.emit('state:changed', {
+            from,
+            to,
+            context,
+            timestamp: new Date()
+        });
+        // Emit specific workflow lifecycle events
+        this.emitLifecycleEvents(to, context);
+    }
+    emitLifecycleEvents(state, context) {
+        switch (state) {
+            case WorkflowState.VALIDATING:
+                this.emit('workflow:validating', context);
+                break;
+            case WorkflowState.RUNNING:
+                this.emit('workflow:started', context);
+                break;
+            case WorkflowState.STEP_EXECUTING:
+                this.emit('step:started', {
+                    stepName: context.currentStep,
+                    stepIndex: context.stepIndex,
+                    totalSteps: context.totalSteps,
+                    workflowId: context.workflowId
+                });
+                break;
+            case WorkflowState.WAITING:
+                this.emit('step:waiting', {
+                    stepName: context.currentStep,
+                    reason: context.metadata?.waitReason || 'dependency'
+                });
+                break;
+            case WorkflowState.RETRYING:
+                this.emit('step:retrying', {
+                    stepName: context.currentStep,
+                    attempt: context.metadata?.retryAttempt || 1,
+                    maxAttempts: context.metadata?.maxRetries || 3,
+                    error: context.error
+                });
+                break;
+            case WorkflowState.SYNTHESIZING:
+                this.emit('workflow:synthesizing', {
+                    workflowId: context.workflowId,
+                    reason: context.metadata?.synthesisReason || 'auto'
+                });
+                break;
+            case WorkflowState.COMPLETED:
+                this.emit('workflow:completed', {
+                    workflowId: context.workflowId,
+                    workflowName: context.workflowName,
+                    totalSteps: context.totalSteps,
+                    duration: this.calculateDuration()
+                });
+                break;
+            case WorkflowState.FAILED:
+                this.emit('workflow:failed', {
+                    workflowId: context.workflowId,
+                    workflowName: context.workflowName,
+                    error: context.error,
+                    failedAt: context.currentStep,
+                    duration: this.calculateDuration()
+                });
+                break;
+            case WorkflowState.PAUSED:
+                this.emit('workflow:paused', {
+                    workflowId: context.workflowId,
+                    pausedAt: context.currentStep
+                });
+                break;
+        }
+    }
+    getStateHistory() {
+        return [...this.stateHistory];
+    }
+    reset() {
+        this.currentState = WorkflowState.INITIALIZED;
+        this.stateHistory = [];
+        this.recordState(WorkflowState.INITIALIZED, {
+            workflowId: '',
+            workflowName: ''
+        });
+        this.emit('state:reset');
+    }
+    recordState(state, context) {
+        this.stateHistory.push({
+            state,
+            timestamp: new Date(),
+            context
+        });
+    }
+    calculateDuration() {
+        if (this.stateHistory.length < 2)
+            return 0;
+        const start = this.stateHistory[0].timestamp.getTime();
+        const end = this.stateHistory[this.stateHistory.length - 1].timestamp.getTime();
+        return end - start;
+    }
+    /**
+     * Get human-readable state description
+     */
+    getStateDescription() {
+        const descriptions = {
+            [WorkflowState.INITIALIZED]: 'Ready to start',
+            [WorkflowState.VALIDATING]: 'Validating workflow configuration',
+            [WorkflowState.RUNNING]: 'Running workflow',
+            [WorkflowState.STEP_EXECUTING]: 'Executing step',
+            [WorkflowState.WAITING]: 'Waiting for dependencies',
+            [WorkflowState.RETRYING]: 'Retrying failed step',
+            [WorkflowState.SYNTHESIZING]: 'Synthesizing results',
+            [WorkflowState.COMPLETED]: 'Completed successfully',
+            [WorkflowState.FAILED]: 'Failed with errors',
+            [WorkflowState.PAUSED]: 'Paused'
+        };
+        return descriptions[this.currentState];
+    }
+}

package/dist/src/workflows/engine/state/interfaces/IStateMachine.js

@@ -0,0 +1,17 @@
+/**
+ * State Machine Interface
+ * Defines contract for workflow state management
+ */
+export var WorkflowState;
+(function (WorkflowState) {
+    WorkflowState["INITIALIZED"] = "INITIALIZED";
+    WorkflowState["VALIDATING"] = "VALIDATING";
+    WorkflowState["RUNNING"] = "RUNNING";
+    WorkflowState["STEP_EXECUTING"] = "STEP_EXECUTING";
+    WorkflowState["WAITING"] = "WAITING";
+    WorkflowState["RETRYING"] = "RETRYING";
+    WorkflowState["SYNTHESIZING"] = "SYNTHESIZING";
+    WorkflowState["COMPLETED"] = "COMPLETED";
+    WorkflowState["FAILED"] = "FAILED";
+    WorkflowState["PAUSED"] = "PAUSED";
+})(WorkflowState || (WorkflowState = {}));

package/dist/src/workflows/fallback-strategies.js

@@ -0,0 +1,373 @@
+import { EventEmitter } from 'events';
+/**
+ * Collection of predefined fallback strategies
+ */
+export class FallbackStrategies {
+    constructor() {
+        this.strategies = [];
+        this.initializeStrategies();
+    }
+    initializeStrategies() {
+        // 1. Use cached results fallback
+        this.strategies.push({
+            name: 'cached-results',
+            description: 'Return previously cached successful results',
+            priority: 1,
+            canHandle: (context) => {
+                return context.previousResults !== undefined &&
+                    context.previousResults.length > 0;
+            },
+            execute: async (context) => {
+                return {
+                    result: context.previousResults[context.previousResults.length - 1],
+                    fallbackUsed: 'cached-results',
+                    warning: 'Using cached results due to service failure'
+                };
+            }
+        });
+        // 2. Use simpler alternative tool
+        this.strategies.push({
+            name: 'simpler-tool',
+            description: 'Use a simpler, more reliable tool',
+            priority: 2,
+            canHandle: (context) => {
+                const complexTools = ['focus', 'architect', 'verifier'];
+                return complexTools.includes(context.stepId);
+            },
+            execute: async (context) => {
+                const simplifiedTools = {
+                    'focus': 'think',
+                    'architect': 'code_reviewer',
+                    'verifier': 'auditor',
+                    'perplexity_research': 'perplexity_ask',
+                    'focus_deep_research': 'scout'
+                };
+                return {
+                    alternativeTool: simplifiedTools[context.stepId] || 'think',
+                    fallbackUsed: 'simpler-tool',
+                    warning: `Using simpler alternative due to ${context.stepId} failure`
+                };
+            }
+        });
+        // 3. Use cheaper model fallback
+        this.strategies.push({
+            name: 'cheaper-model',
+            description: 'Fallback to GPT-5 Nano for cost efficiency',
+            priority: 3,
+            canHandle: (context) => {
+                const expensiveModels = ['gpt5'];
+                return expensiveModels.some(model => context.stepId.includes(model));
+            },
+            execute: async (context) => {
+                return {
+                    alternativeTool: 'gpt-5-nano',
+                    fallbackUsed: 'cheaper-model',
+                    warning: 'Falling back to GPT-5 Nano for cost efficiency'
+                };
+            }
+        });
+        // 4. Retry with reduced scope
+        this.strategies.push({
+            name: 'reduced-scope',
+            description: 'Retry with reduced complexity or scope',
+            priority: 4,
+            canHandle: (context) => {
+                return context.attemptNumber < 3 &&
+                    context.originalQuery !== undefined;
+            },
+            execute: async (context) => {
+                // Simplify the query by taking first sentence or reducing length
+                const simplifiedQuery = context.originalQuery
+                    .split('.')[0]
+                    .substring(0, 200);
+                return {
+                    simplifiedQuery,
+                    fallbackUsed: 'reduced-scope',
+                    warning: 'Retrying with reduced query scope'
+                };
+            }
+        });
+        // 5. Basic error response
+        this.strategies.push({
+            name: 'basic-response',
+            description: 'Return basic error information',
+            priority: 99,
+            canHandle: () => true, // Always can handle as last resort
+            execute: async (context) => {
+                return {
+                    error: true,
+                    fallbackUsed: 'basic-response',
+                    message: `Service ${context.stepId} is temporarily unavailable`,
+                    reason: context.failureReason,
+                    suggestion: 'Please try again later or use a different approach'
+                };
+            }
+        });
+    }
+    /**
+     * Get the best fallback strategy for the given context
+     */
+    getBestStrategy(context) {
+        // Sort by priority and find first that can handle
+        const availableStrategies = this.strategies
+            .filter(s => s.canHandle(context))
+            .sort((a, b) => a.priority - b.priority);
+        return availableStrategies[0] || null;
+    }
+    /**
+     * Execute fallback with the best available strategy
+     */
+    async executeFallback(context) {
+        const strategy = this.getBestStrategy(context);
+        if (!strategy) {
+            throw new Error(`No fallback strategy available for ${context.stepId}`);
+        }
+        console.error(`[Fallback] Using strategy: ${strategy.name} for ${context.stepId}`);
+        return strategy.execute(context);
+    }
+    /**
+     * Add custom fallback strategy
+     */
+    addStrategy(strategy) {
+        this.strategies.push(strategy);
+        // Re-sort by priority
+        this.strategies.sort((a, b) => a.priority - b.priority);
+    }
+    /**
+     * Remove a strategy by name
+     */
+    removeStrategy(name) {
+        this.strategies = this.strategies.filter(s => s.name !== name);
+    }
+    /**
+     * Get all registered strategies
+     */
+    getAllStrategies() {
+        return [...this.strategies];
+    }
+}
+/**
+ * Health monitoring for circuit breakers
+ */
+export class HealthMonitor extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.healthChecks = new Map();
+        this.healthStatus = new Map();
+        this.alertThresholds = {
+            consecutiveFailures: 3,
+            failureRate: 0.5,
+            responseTime: 10000 // 10 seconds
+        };
+    }
+    /**
+     * Start monitoring a service
+     */
+    startMonitoring(serviceId, checkFn, intervalMs = 30000) {
+        // Clear existing check if any
+        this.stopMonitoring(serviceId);
+        // Initial check
+        this.performHealthCheck(serviceId, checkFn);
+        // Set up interval
+        const interval = setInterval(() => {
+            this.performHealthCheck(serviceId, checkFn);
+        }, intervalMs);
+        this.healthChecks.set(serviceId, interval);
+    }
+    /**
+     * Stop monitoring a service
+     */
+    stopMonitoring(serviceId) {
+        const interval = this.healthChecks.get(serviceId);
+        if (interval) {
+            clearInterval(interval);
+            this.healthChecks.delete(serviceId);
+        }
+    }
+    /**
+     * Perform a health check
+     */
+    async performHealthCheck(serviceId, checkFn) {
+        const startTime = Date.now();
+        try {
+            const isHealthy = await checkFn();
+            const responseTime = Date.now() - startTime;
+            const wasHealthy = this.healthStatus.get(serviceId);
+            this.healthStatus.set(serviceId, isHealthy);
+            // Emit events based on health changes
+            if (wasHealthy === false && isHealthy) {
+                this.emit('service-recovered', { serviceId, responseTime });
+            }
+            else if (wasHealthy === true && !isHealthy) {
+                this.emit('service-degraded', { serviceId, responseTime });
+            }
+            // Check response time threshold
+            if (responseTime > this.alertThresholds.responseTime) {
+                this.emit('slow-response', { serviceId, responseTime });
+            }
+        }
+        catch (error) {
+            this.healthStatus.set(serviceId, false);
+            this.emit('health-check-failed', {
+                serviceId,
+                error: error.message
+            });
+        }
+    }
+    /**
+     * Get current health status
+     */
+    getHealthStatus() {
+        return new Map(this.healthStatus);
+    }
+    /**
+     * Check if a service is healthy
+     */
+    isHealthy(serviceId) {
+        return this.healthStatus.get(serviceId) || false;
+    }
+    /**
+     * Get overall system health score (0-1)
+     */
+    getSystemHealthScore() {
+        if (this.healthStatus.size === 0)
+            return 1;
+        let healthyCount = 0;
+        for (const isHealthy of this.healthStatus.values()) {
+            if (isHealthy)
+                healthyCount++;
+        }
+        return healthyCount / this.healthStatus.size;
+    }
+    /**
+     * Clean up all monitoring
+     */
+    cleanup() {
+        for (const serviceId of this.healthChecks.keys()) {
+            this.stopMonitoring(serviceId);
+        }
+        this.healthStatus.clear();
+    }
+}
+/**
+ * Proactive alert system for circuit breakers
+ */
+export class AlertManager extends EventEmitter {
+    constructor() {
+        super();
+        this.alerts = new Map();
+        this.alertRules = new Map();
+        this.initializeDefaultRules();
+    }
+    initializeDefaultRules() {
+        // Critical failure rate
+        this.alertRules.set('critical-failure-rate', (stats) => {
+            return stats.failureRate > 0.8;
+        });
+        // Multiple services down
+        this.alertRules.set('multiple-services-down', (health) => {
+            return health.openBreakers > 3;
+        });
+        // Cascade failure risk
+        this.alertRules.set('cascade-risk', (stats) => {
+            return stats.halfOpenBreakers > 2 && stats.openBreakers > 1;
+        });
+        // Low system health
+        this.alertRules.set('low-system-health', (health) => {
+            return health.healthScore < 0.5;
+        });
+    }
+    /**
+     * Check alerts based on current state
+     */
+    checkAlerts(data) {
+        for (const [ruleName, ruleFn] of this.alertRules.entries()) {
+            if (ruleFn(data)) {
+                this.triggerAlert(ruleName, data);
+            }
+        }
+    }
+    /**
+     * Trigger an alert
+     */
+    triggerAlert(alertType, data) {
+        const alert = {
+            type: alertType,
+            timestamp: Date.now(),
+            data,
+            severity: this.getAlertSeverity(alertType)
+        };
+        // Store alert
+        if (!this.alerts.has(alertType)) {
+            this.alerts.set(alertType, []);
+        }
+        this.alerts.get(alertType).push(alert);
+        // Emit alert event
+        this.emit('alert', alert);
+        // Log critical alerts
+        if (alert.severity === 'critical') {
+            console.error(`[CRITICAL ALERT] ${alertType}:`, data);
+        }
+    }
+    /**
+     * Get alert severity
+     */
+    getAlertSeverity(alertType) {
+        const criticalAlerts = ['multiple-services-down', 'cascade-risk'];
+        const warningAlerts = ['critical-failure-rate', 'low-system-health'];
+        if (criticalAlerts.includes(alertType))
+            return 'critical';
+        if (warningAlerts.includes(alertType))
+            return 'warning';
+        return 'info';
+    }
+    /**
+     * Get recent alerts
+     */
+    getRecentAlerts(minutes = 5) {
+        const cutoff = Date.now() - (minutes * 60 * 1000);
+        const recent = [];
+        for (const alerts of this.alerts.values()) {
+            recent.push(...alerts.filter(a => a.timestamp > cutoff));
+        }
+        return recent.sort((a, b) => b.timestamp - a.timestamp);
+    }
+    /**
+     * Clear old alerts
+     */
+    clearOldAlerts(hours = 24) {
+        const cutoff = Date.now() - (hours * 60 * 60 * 1000);
+        for (const [type, alerts] of this.alerts.entries()) {
+            const filtered = alerts.filter(a => a.timestamp > cutoff);
+            if (filtered.length > 0) {
+                this.alerts.set(type, filtered);
+            }
+            else {
+                this.alerts.delete(type);
+            }
+        }
+    }
+    /**
+     * Add custom alert rule
+     */
+    addRule(name, ruleFn) {
+        this.alertRules.set(name, ruleFn);
+    }
+    /**
+     * Remove alert rule
+     */
+    removeRule(name) {
+        this.alertRules.delete(name);
+    }
+}
+// Export a singleton instance for global use
+export const fallbackStrategies = new FallbackStrategies();
+export const healthMonitor = new HealthMonitor();
+export const alertManager = new AlertManager();
+// Set up connections between components
+healthMonitor.on('service-degraded', (data) => {
+    alertManager.checkAlerts({ serviceDown: data.serviceId });
+});
+healthMonitor.on('slow-response', (data) => {
+    alertManager.checkAlerts({ slowService: data.serviceId, responseTime: data.responseTime });
+});