tachibot-mcp 2.0.2

package/dist/src/validators/tool-types.js

@@ -0,0 +1,97 @@
+/**
+ * Tool type system using TypeScript's infer and conditional types
+ * NO 'any' - uses 'unknown' where type is truly unknown
+ */
+// ============================================================================
+// TOOL REGISTRY - Single source of truth for all tools
+// ============================================================================
+/**
+ * Known tool names - this is the ONLY place we list tools
+ * Validators check against this list
+ */
+export const KNOWN_TOOLS = [
+    // Core
+    'think',
+    'focus',
+    // Perplexity
+    'perplexity_ask',
+    'perplexity_reason',
+    'perplexity_research',
+    'perplexity_code_search',
+    // Grok
+    'grok_reason',
+    'grok_code',
+    'grok_debug',
+    'grok_brainstorm',
+    'grok_search',
+    'grok_heavy',
+    // OpenAI
+    'openai_brainstorm',
+    'openai_analyze',
+    'openai_reason',
+    'openai_compare',
+    'gpt5',
+    'gpt5_mini',
+    'gpt5_nano',
+    // Gemini
+    'gemini_query',
+    'gemini_brainstorm',
+    'gemini_analyze_code',
+    'gemini_analyze_text',
+    // Qwen
+    'qwen_coder',
+    'qwq_reason',
+    // Advanced modes
+    'verifier',
+    'challenger',
+    'scout',
+    'auditor',
+    'architect',
+    'commit_guardian',
+    // Meta tools
+    'code_reviewer',
+    'test_architect',
+    'documentation_writer',
+    // Workflow
+    'workflow',
+    'pingpong',
+];
+/**
+ * Type guard to check if string is a valid tool name
+ */
+export function isValidToolName(name) {
+    return KNOWN_TOOLS.includes(name);
+}
+/**
+ * Type guard to narrow Step to TypedStep<T>
+ */
+export function isTypedStep(step, toolName) {
+    return step.tool === toolName;
+}
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Get all step names from workflow (for interpolation validation)
+ */
+export function getStepNames(workflow) {
+    return new Set(workflow.steps.map(s => s.name));
+}
+/**
+ * Check if a reference is a step name or variable
+ */
+export function isStepReference(reference, stepNames) {
+    // Remove .output suffix if present
+    const baseName = reference.includes('.')
+        ? reference.split('.')[0]
+        : reference;
+    return stepNames.has(baseName);
+}
+/**
+ * Extract all interpolation references from a string
+ */
+export function extractInterpolations(text) {
+    const regex = /\$\{([^}]+)\}/g;
+    const matches = text.matchAll(regex);
+    return Array.from(matches, m => m[1]);
+}

package/dist/src/validators/types.js

@@ -0,0 +1,8 @@
+/**
+ * Workflow validator type definitions
+ *
+ * NOTE: This file now re-exports from tool-types.ts which uses proper
+ * TypeScript inference and conditional types without 'any'
+ */
+// Re-export all types from tool-types for backward compatibility
+export * from './tool-types.js';

package/dist/src/validators/workflow-validator.js

@@ -0,0 +1,134 @@
+/**
+ * Main workflow validator - orchestrates all validation checks
+ */
+import { SyntaxValidator } from './syntax-validator.js';
+import { InterpolationValidator } from './interpolation-validator.js';
+import { ToolRegistryValidator } from './tool-registry-validator.js';
+import { DependencyGraphValidator } from './dependency-graph-validator.js';
+import { OutputUsageValidator } from './output-usage-validator.js';
+import { getEnabledTools } from '../utils/tool-config.js';
+export class WorkflowValidator {
+    constructor() {
+        this.syntaxValidator = new SyntaxValidator();
+        this.interpolationValidator = new InterpolationValidator();
+        this.toolValidator = new ToolRegistryValidator();
+        this.dependencyValidator = new DependencyGraphValidator();
+        this.outputUsageValidator = new OutputUsageValidator();
+    }
+    /**
+     * Validate a workflow from YAML/JSON content
+     */
+    async validate(workflowContent, isJson = false, enabledToolsOverride) {
+        const allErrors = [];
+        // Step 1: Syntax validation
+        const syntaxResult = this.syntaxValidator.validate(workflowContent, isJson);
+        allErrors.push(...syntaxResult.errors);
+        // If syntax validation failed, can't proceed
+        if (!syntaxResult.valid || !syntaxResult.workflow) {
+            return {
+                valid: false,
+                errors: allErrors.filter(e => e.severity === 'error'),
+                warnings: allErrors.filter(e => e.severity === 'warning')
+            };
+        }
+        // Step 2: Build validation context
+        // If override provided, it contains ALL known tools
+        // Otherwise, get from config (which may be empty if config not loaded)
+        const allKnownTools = enabledToolsOverride || new Set(getEnabledTools());
+        const enabledTools = new Set(getEnabledTools());
+        const context = {
+            workflow: syntaxResult.workflow,
+            allKnownTools,
+            enabledTools: enabledTools.size > 0 ? enabledTools : allKnownTools, // Fallback to all if none enabled
+            sourceMap: new Map() // TODO: Implement source mapping for line numbers
+        };
+        // Step 3: Run all validators in parallel
+        const [interpolationErrors, toolErrors, dependencyErrors, outputUsageErrors] = await Promise.all([
+            Promise.resolve(this.interpolationValidator.validate(context)),
+            Promise.resolve(this.toolValidator.validate(context)),
+            Promise.resolve(this.dependencyValidator.validate(context)),
+            Promise.resolve(this.outputUsageValidator.validate(context))
+        ]);
+        allErrors.push(...interpolationErrors);
+        allErrors.push(...toolErrors);
+        allErrors.push(...dependencyErrors);
+        allErrors.push(...outputUsageErrors);
+        // Separate errors and warnings
+        const errors = allErrors.filter(e => e.severity === 'error');
+        const warnings = allErrors.filter(e => e.severity === 'warning');
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    /**
+     * Validate a workflow from a file path
+     */
+    async validateFile(filePath, enabledToolsOverride) {
+        const fs = await import('fs');
+        const path = await import('path');
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const isJson = path.extname(filePath).toLowerCase() === '.json';
+            return this.validate(content, isJson, enabledToolsOverride);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                errors: [{
+                        type: 'syntax',
+                        severity: 'error',
+                        message: `Failed to read file: ${error.message}`,
+                        path: '$'
+                    }],
+                warnings: []
+            };
+        }
+    }
+    /**
+     * Format validation results as human-readable text
+     */
+    formatResults(result) {
+        const lines = [];
+        if (result.valid) {
+            lines.push('✅ Workflow validation passed!');
+            if (result.warnings.length > 0) {
+                lines.push(`\n⚠️  ${result.warnings.length} warning(s):\n`);
+                result.warnings.forEach((warning, i) => {
+                    lines.push(this.formatError(warning, i + 1));
+                });
+            }
+        }
+        else {
+            lines.push(`❌ Workflow validation failed with ${result.errors.length} error(s)!\n`);
+            result.errors.forEach((error, i) => {
+                lines.push(this.formatError(error, i + 1));
+            });
+            if (result.warnings.length > 0) {
+                lines.push(`\n⚠️  ${result.warnings.length} warning(s):\n`);
+                result.warnings.forEach((warning, i) => {
+                    lines.push(this.formatError(warning, i + 1));
+                });
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format a single error/warning
+     */
+    formatError(error, index) {
+        const icon = error.severity === 'error' ? '❌' : '⚠️';
+        const location = error.line ? ` (line ${error.line}${error.column ? `:${error.column}` : ''})` : '';
+        const suggestion = error.suggestion ? `\n   💡 ${error.suggestion}` : '';
+        return `${icon} ${index}. [${error.type.toUpperCase()}]${location}\n   ${error.message}\n   Path: ${error.path}${suggestion}\n`;
+    }
+    /**
+     * Format validation results as JSON
+     */
+    formatResultsJSON(result) {
+        return JSON.stringify(result, null, 2);
+    }
+}
+// Export singleton instance
+export const workflowValidator = new WorkflowValidator();

package/dist/src/visualizer-lite.js

@@ -0,0 +1,42 @@
+import { ToolStatus } from './types.js';
+import { PromptEngineerLite } from './prompt-engineer-lite.js';
+export class WorkflowVisualizerLite {
+    constructor() {
+        this.pe = new PromptEngineerLite();
+        this.faces = {
+            idle: ['  ● ●  ', '   ◡   '],
+            work: ['  ◉ ◉  ', '   ~   '],
+            done: ['  ★ ★  ', ' \\___//'],
+            err: ['  x x  ', '   ⌒   ']
+        };
+    }
+    getCompactDisplay(workflow, states) {
+        const tools = workflow.steps.map(s => s.tool.substring(0, 3));
+        const statuses = workflow.steps.map(s => {
+            const st = states.get(s.tool) || ToolStatus.IDLE;
+            return st === ToolStatus.COMPLETE ? '✓' :
+                st === ToolStatus.PROCESSING ? '◉' :
+                    st === ToolStatus.ERROR ? '!' : '○';
+        });
+        const progress = Math.round((statuses.filter(s => s === '✓').length / tools.length) * 100);
+        const current = workflow.steps.find(s => states.get(s.tool) === ToolStatus.PROCESSING);
+        return `${workflow.name} [${statuses.join('→')}] ${progress}%${current ? ` | ${this.pe.getTechniqueDescription(current.promptTechnique)}` : ''}`;
+    }
+    async renderWorkflow(workflow, states) {
+        if (states.size === 0) {
+            workflow.steps.forEach(s => states.set(s.tool, ToolStatus.IDLE));
+        }
+        const display = this.getCompactDisplay(workflow, states);
+        console.error(`\n${display}\n`);
+        return display;
+    }
+    async updateProgress(tool, status) {
+        const emoji = { idle: '⏸️', processing: '⚙️', complete: '✅', error: '❌' };
+        console.error(`${emoji[status]} ${tool}: ${status}`);
+    }
+    async showCompletion(workflow, results) {
+        const dur = ((results[results.length - 1]?.duration || 0) / 1000).toFixed(1);
+        const face = this.faces.done;
+        console.error(`\n✨ ${workflow.name} Complete in ${dur}s\n @@@@@@@\n @ ${face[0]} @\n @ ${face[1]} @\n @@@@@@@`);
+    }
+}

package/dist/src/visualizer.js

@@ -0,0 +1,179 @@
+import { ToolStatus } from './types.js';
+import { getStatusIndicator } from './workflows.js';
+import { PromptEngineer } from './prompt-engineer.js';
+export class WorkflowVisualizer {
+    constructor() {
+        this.currentDisplay = '';
+        this.animationFrames = new Map();
+        this.promptEngineer = new PromptEngineer();
+        this.initializeAnimations();
+    }
+    initializeAnimations() {
+        // Processing animations for each tool
+        this.animationFrames.set('processing', [
+            '.', '..', '...', '..', '.'
+        ]);
+        this.animationFrames.set('thinking', [
+            '~', '≈', '~', '∞', '~'
+        ]);
+    }
+    async renderWorkflow(workflow, toolStates) {
+        // Initialize states if empty
+        if (toolStates.size === 0) {
+            workflow.steps.forEach(step => {
+                toolStates.set(step.tool, ToolStatus.IDLE);
+            });
+        }
+        // Build the display from the template
+        let display = workflow.visualTemplate;
+        // Replace placeholders with actual states
+        workflow.steps.forEach(step => {
+            const status = toolStates.get(step.tool) || ToolStatus.IDLE;
+            const indicator = getStatusIndicator(status);
+            // Replace status indicators in template
+            switch (step.tool) {
+                case 'gemini_brainstorm':
+                    display = display.replace('{g}', indicator);
+                    break;
+                case 'openai_brainstorm':
+                case 'openai_reason':
+                    display = display.replace('{o}', indicator);
+                    break;
+                case 'think':
+                    display = display.replace('{t}', indicator);
+                    break;
+                case 'perplexity_research':
+                    display = display.replace('{p}', indicator);
+                    break;
+                case 'reason':
+                    display = display.replace('{r}', indicator);
+                    break;
+            }
+        });
+        // Calculate overall progress
+        const completed = Array.from(toolStates.values()).filter(s => s === ToolStatus.COMPLETE).length;
+        const total = workflow.steps.length;
+        const progress = Math.round((completed / total) * 100);
+        // Create progress bar
+        const progressBar = this.createProgressBar(progress);
+        display = display.replace('{progress}', progressBar);
+        // Add current technique and activity
+        const currentTool = this.getCurrentTool(workflow, toolStates);
+        if (currentTool) {
+            const technique = this.promptEngineer.getTechniqueDescription(currentTool.promptTechnique);
+            display = display.replace('{technique}', technique);
+            display = display.replace('{current}', `Processing with ${currentTool.tool}...`);
+        }
+        else {
+            display = display.replace('{technique}', 'Initializing workflow...');
+            display = display.replace('{current}', 'Starting orchestration...');
+        }
+        this.currentDisplay = display;
+        console.error('\n' + display + '\n');
+        return display;
+    }
+    async updateProgress(toolName, status) {
+        // This would normally update just the relevant part of the display
+        // For now, we'll log the update
+        const statusEmoji = {
+            [ToolStatus.IDLE]: '⏸️',
+            [ToolStatus.PROCESSING]: '⚙️',
+            [ToolStatus.COMPLETE]: '✅',
+            [ToolStatus.ERROR]: '❌'
+        };
+        console.error(`\n${statusEmoji[status]} ${toolName}: ${status}\n`);
+        // If processing, show animation
+        if (status === ToolStatus.PROCESSING) {
+            await this.animateProcessing(toolName);
+        }
+    }
+    async animateProcessing(toolName) {
+        // Show a simple animation for processing
+        const frames = this.animationFrames.get('processing') || ['.'];
+        console.error(`🔄 ${toolName} is thinking${frames[0]}`);
+    }
+    async showCompletion(workflow, results) {
+        const duration = results[results.length - 1]?.duration || 0;
+        const toolsUsed = results.map(r => r.tool).join(' → ');
+        const completion = `
+╔═══════════════════════════════════════════════════╗
+║          🎉 Workflow Complete! 🎉                 ║
+╠═══════════════════════════════════════════════════╣
+║ Workflow: ${workflow.name.padEnd(39)}║
+║ Duration: ${(duration / 1000).toFixed(2)}s${' '.repeat(40 - (duration / 1000).toFixed(2).length - 1)}║
+║ Tools: ${toolsUsed.substring(0, 42).padEnd(42)}║
+╚═══════════════════════════════════════════════════╝
+
+     @@@@@@@@@
+     @  ● ●  @
+     @   ◡   @  Mission accomplished!
+     @@@@@@@@@
+`;
+        console.error(completion);
+    }
+    createProgressBar(percentage) {
+        const width = 20;
+        const filled = Math.round((percentage / 100) * width);
+        const empty = width - filled;
+        return `[${'='.repeat(filled)}${' '.repeat(empty)}] ${percentage}%`;
+    }
+    getCurrentTool(workflow, toolStates) {
+        // Find the currently processing tool
+        for (const step of workflow.steps) {
+            const status = toolStates.get(step.tool);
+            if (status === ToolStatus.PROCESSING) {
+                return step;
+            }
+        }
+        // If none processing, find the first incomplete
+        for (const step of workflow.steps) {
+            const status = toolStates.get(step.tool);
+            if (status !== ToolStatus.COMPLETE && status !== ToolStatus.ERROR) {
+                return step;
+            }
+        }
+        return null;
+    }
+    // Special animations for different phases
+    async showCreativeExplosion() {
+        const explosion = `
+         ✨ ★ ✨
+       ★  💡  ★
+     ✨  🎨  ✨
+       ★    ★
+         ✨
+    Creative breakthrough!
+`;
+        console.error(explosion);
+    }
+    async showResearchDiscovery() {
+        const discovery = `
+    📚 → 🔍 → 💎
+    
+    Found valuable insights!
+`;
+        console.error(discovery);
+    }
+    async showProblemSolved() {
+        const solved = `
+    🧩 + 🧩 + 🧩 = ✅
+    
+    Problem decomposed and solved!
+`;
+        console.error(solved);
+    }
+    async showSynthesisComplete() {
+        const synthesis = `
+    🎯 All perspectives integrated!
+    
+    ╱│╲
+    ─●─  Unified insight achieved
+    ╲│╱
+`;
+        console.error(synthesis);
+    }
+    // Get current display for external use
+    getCurrentDisplay() {
+        return this.currentDisplay;
+    }
+}

package/dist/src/workflows/circuit-breaker.js

@@ -0,0 +1,199 @@
+import { EventEmitter } from 'events';
+export var CircuitState;
+(function (CircuitState) {
+    CircuitState["CLOSED"] = "CLOSED";
+    CircuitState["OPEN"] = "OPEN";
+    CircuitState["HALF_OPEN"] = "HALF_OPEN"; // Testing if service recovered
+})(CircuitState || (CircuitState = {}));
+export class CircuitBreaker extends EventEmitter {
+    constructor(stepId, options) {
+        super();
+        this.stepId = stepId;
+        this.options = options;
+        this.state = CircuitState.CLOSED;
+        this.failures = 0;
+        this.successes = 0;
+        this.lastFailureTime = 0;
+        this.lastSuccessTime = 0;
+        this.totalRequests = 0;
+        this.totalFailures = 0;
+        this.startTime = Date.now();
+        this.nextAttempt = 0;
+        this.setMaxListeners(20); // Allow multiple listeners
+    }
+    async execute(operation) {
+        this.totalRequests++;
+        if (this.state === CircuitState.OPEN) {
+            if (this.shouldAttemptReset()) {
+                this.state = CircuitState.HALF_OPEN;
+                this.successes = 0;
+                this.emit('half-open', { stepId: this.stepId });
+            }
+            else {
+                this.emit('fallback', { stepId: this.stepId, reason: 'circuit-open' });
+                return this.executeFallback();
+            }
+        }
+        try {
+            const result = await operation();
+            this.onSuccess();
+            return result;
+        }
+        catch (error) {
+            this.onFailure(error);
+            throw error;
+        }
+    }
+    onSuccess() {
+        this.failures = 0;
+        this.successes++;
+        this.lastSuccessTime = Date.now();
+        if (this.state === CircuitState.HALF_OPEN) {
+            if (this.successes >= this.options.successThreshold) {
+                this.state = CircuitState.CLOSED;
+                this.emit('closed', { stepId: this.stepId });
+            }
+        }
+        this.emit('success', { stepId: this.stepId, state: this.state });
+    }
+    onFailure(error) {
+        this.failures++;
+        this.totalFailures++;
+        this.lastFailureTime = Date.now();
+        if (this.state === CircuitState.HALF_OPEN) {
+            this.state = CircuitState.OPEN;
+            this.nextAttempt = Date.now() + this.options.recoveryTimeout;
+            this.emit('opened', { stepId: this.stepId, reason: 'half-open-failure' });
+        }
+        else if (this.state === CircuitState.CLOSED) {
+            if (this.failures >= this.options.failureThreshold) {
+                this.state = CircuitState.OPEN;
+                this.nextAttempt = Date.now() + this.options.recoveryTimeout;
+                this.emit('opened', { stepId: this.stepId, reason: 'failure-threshold' });
+            }
+        }
+        this.emit('failure', { stepId: this.stepId, error: error.message, state: this.state });
+    }
+    shouldAttemptReset() {
+        return Date.now() >= this.nextAttempt;
+    }
+    async executeFallback() {
+        if (this.options.fallback) {
+            try {
+                const result = await this.options.fallback();
+                this.emit('fallback-success', { stepId: this.stepId });
+                return result;
+            }
+            catch (error) {
+                this.emit('fallback-failure', { stepId: this.stepId, error: error.message });
+                throw new Error(`Circuit breaker open for ${this.stepId} and fallback failed: ${error.message}`);
+            }
+        }
+        throw new Error(`Circuit breaker open for ${this.stepId} and no fallback configured`);
+    }
+    getStats() {
+        return {
+            state: this.state,
+            failures: this.failures,
+            successes: this.successes,
+            lastFailure: this.lastFailureTime,
+            lastSuccess: this.lastSuccessTime,
+            totalRequests: this.totalRequests,
+            totalFailures: this.totalFailures,
+            uptime: Date.now() - this.startTime
+        };
+    }
+    // Manual control methods
+    forceOpen() {
+        this.state = CircuitState.OPEN;
+        this.nextAttempt = Date.now() + this.options.recoveryTimeout;
+        this.emit('force-opened', { stepId: this.stepId });
+    }
+    forceClose() {
+        this.state = CircuitState.CLOSED;
+        this.failures = 0;
+        this.successes = 0;
+        this.emit('force-closed', { stepId: this.stepId });
+    }
+    forceHalfOpen() {
+        this.state = CircuitState.HALF_OPEN;
+        this.successes = 0;
+        this.emit('force-half-open', { stepId: this.stepId });
+    }
+}
+export class CircuitBreakerManager extends EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.breakers = new Map();
+        this.defaultOptions = {
+            failureThreshold: 5,
+            recoveryTimeout: 30000, // 30 seconds
+            successThreshold: 2,
+            monitoringWindow: 60000, // 1 minute
+        };
+    }
+    getOrCreateCircuitBreaker(stepId, options) {
+        if (!this.breakers.has(stepId)) {
+            const finalOptions = { ...this.defaultOptions, ...options };
+            const breaker = new CircuitBreaker(stepId, finalOptions);
+            // Proxy all events to the manager
+            breaker.on('opened', (data) => this.emit('breaker-opened', data));
+            breaker.on('closed', (data) => this.emit('breaker-closed', data));
+            breaker.on('half-open', (data) => this.emit('breaker-half-open', data));
+            breaker.on('failure', (data) => this.emit('breaker-failure', data));
+            breaker.on('success', (data) => this.emit('breaker-success', data));
+            breaker.on('fallback', (data) => this.emit('breaker-fallback', data));
+            this.breakers.set(stepId, breaker);
+        }
+        return this.breakers.get(stepId);
+    }
+    getAllStats() {
+        const stats = {};
+        for (const [stepId, breaker] of this.breakers.entries()) {
+            stats[stepId] = breaker.getStats();
+        }
+        return stats;
+    }
+    getHealthReport() {
+        const stats = this.getAllStats();
+        const total = Object.keys(stats).length;
+        let open = 0;
+        let halfOpen = 0;
+        let closed = 0;
+        for (const stat of Object.values(stats)) {
+            switch (stat.state) {
+                case CircuitState.OPEN:
+                    open++;
+                    break;
+                case CircuitState.HALF_OPEN:
+                    halfOpen++;
+                    break;
+                case CircuitState.CLOSED:
+                    closed++;
+                    break;
+            }
+        }
+        const healthScore = total === 0 ? 1.0 : closed / total;
+        return {
+            totalBreakers: total,
+            openBreakers: open,
+            halfOpenBreakers: halfOpen,
+            closedBreakers: closed,
+            healthScore
+        };
+    }
+    // Cleanup unused breakers
+    cleanup() {
+        const now = Date.now();
+        const maxIdle = 300000; // 5 minutes
+        for (const [stepId, breaker] of this.breakers.entries()) {
+            const stats = breaker.getStats();
+            const lastActivity = Math.max(stats.lastSuccess, stats.lastFailure);
+            if (lastActivity > 0 && (now - lastActivity) > maxIdle) {
+                breaker.removeAllListeners();
+                this.breakers.delete(stepId);
+                this.emit('breaker-cleanup', { stepId });
+            }
+        }
+    }
+}