tachibot-mcp 2.0.2

package/dist/src/workflows/engine/WorkflowFileManager.js

@@ -0,0 +1,244 @@
+/**
+ * Workflow File Manager
+ * Handles file references, output saving, and manifest management
+ */
+import { promises as fsPromises } from 'fs';
+import * as path from 'path';
+export class WorkflowFileManager {
+    /**
+     * Extracts a summary from content (first 200 chars)
+     */
+    extractSummary(result) {
+        // Handle null/undefined explicitly
+        if (result === null)
+            return '[null]';
+        if (result === undefined)
+            return '[undefined]';
+        // Handle primitives (including falsy: 0, false, "")
+        if (typeof result === 'string') {
+            return this.truncateString(result, 200);
+        }
+        if (typeof result === 'number' || typeof result === 'boolean') {
+            return String(result);
+        }
+        // Handle objects with summary property
+        if (result && typeof result === 'object' && 'summary' in result) {
+            const summary = result.summary;
+            if (typeof summary === 'string') {
+                return this.truncateString(summary, 200);
+            }
+            // If summary is not a string, JSON.stringify it
+            try {
+                const summaryStr = JSON.stringify(summary, this.getCircularReplacer());
+                return this.truncateString(summaryStr, 200);
+            }
+            catch (error) {
+                return '[Summary unavailable]';
+            }
+        }
+        // Default: JSON.stringify with circular ref handling
+        try {
+            const resultStr = JSON.stringify(result, this.getCircularReplacer());
+            return this.truncateString(resultStr, 200);
+        }
+        catch (error) {
+            return '[Summary unavailable]';
+        }
+    }
+    /**
+     * Creates a file reference for step output
+     */
+    async createFileReference(options) {
+        const { stepName, content, workflowId, workflowName, saveToFile: initialSaveToFile, outputDir, stepNumber, modelName } = options;
+        const id = `${workflowId}-${stepName}-${Date.now()}`;
+        const summary = this.extractSummary(content);
+        const sizeBytes = Buffer.byteLength(content, 'utf-8');
+        let filePath = null;
+        let _inMemoryContent = undefined;
+        let saveToFile = initialSaveToFile;
+        // Auto-promote large in-memory results to file (>1MB)
+        if (!saveToFile && sizeBytes > 1000000) {
+            console.error(`⚠️  Step ${stepName} output is ${sizeBytes} bytes - forcing file save`);
+            saveToFile = true;
+        }
+        if (saveToFile && outputDir) {
+            // Save to file with step number and datetime
+            const safeStepName = stepName.replace(/[^a-zA-Z0-9_-]/g, '_');
+            // Generate datetime string: YYYY-MM-DD-HH-MM-SS-DayName
+            const now = new Date();
+            const year = now.getFullYear();
+            const month = String(now.getMonth() + 1).padStart(2, '0');
+            const day = String(now.getDate()).padStart(2, '0');
+            const hours = String(now.getHours()).padStart(2, '0');
+            const minutes = String(now.getMinutes()).padStart(2, '0');
+            const seconds = String(now.getSeconds()).padStart(2, '0');
+            const dayNames = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];
+            const dayName = dayNames[now.getDay()];
+            const datetime = `${year}-${month}-${day}-${hours}-${minutes}-${seconds}-${dayName}`;
+            // Sanitize model name for filename (remove special chars, keep alphanumeric and hyphens)
+            const safeModelName = modelName ? modelName.replace(/[^a-zA-Z0-9-]/g, '-') : undefined;
+            // Build filename: {stepNumber}-{stepName}-{modelName}-{datetime}.md
+            const filenamePrefix = stepNumber ? `${stepNumber}-` : '';
+            const modelSuffix = safeModelName ? `-${safeModelName}` : '';
+            const filename = `${filenamePrefix}${safeStepName}${modelSuffix}-${datetime}.md`;
+            filePath = path.join(outputDir, filename);
+            try {
+                // Format as markdown with metadata
+                const metadataLines = [
+                    `# ${stepName}`,
+                    '',
+                    `**Workflow:** ${workflowName}`,
+                    `**Workflow ID:** ${workflowId}`,
+                    `**Timestamp:** ${new Date().toISOString()}`,
+                    `**Size:** ${sizeBytes} bytes`,
+                    ...(modelName ? [`**Model:** ${modelName}`] : []),
+                    '',
+                    '## Output',
+                    '',
+                    content,
+                    ''
+                ];
+                await fsPromises.writeFile(filePath, metadataLines.join('\n'));
+                console.error(`💾 Saved step output to: ${filePath}`);
+            }
+            catch (error) {
+                console.error(`⚠️  File save failed for ${stepName}, falling back to in-memory:`, error);
+                filePath = null;
+                _inMemoryContent = content;
+            }
+        }
+        else {
+            // Keep in memory
+            _inMemoryContent = content;
+        }
+        // Create lazy loader with caching
+        let _cachedContent = null;
+        const getContent = async () => {
+            // Return cached content if available
+            if (_cachedContent)
+                return _cachedContent;
+            if (filePath) {
+                try {
+                    const markdown = await fsPromises.readFile(filePath, 'utf-8');
+                    // Extract content from markdown (skip metadata)
+                    const outputMatch = markdown.match(/## Output\s*\n\n([\s\S]*)/);
+                    _cachedContent = outputMatch ? outputMatch[1].trim() : markdown;
+                    return _cachedContent;
+                }
+                catch (error) {
+                    throw new Error(`Failed to load content from ${filePath}: ${error}`);
+                }
+            }
+            if (_inMemoryContent !== undefined) {
+                _cachedContent = _inMemoryContent;
+                return _cachedContent;
+            }
+            throw new Error(`No content available for step ${stepName}`);
+        };
+        return {
+            id,
+            stepName,
+            summary,
+            filePath,
+            sizeBytes,
+            getContent,
+            _inMemoryContent
+        };
+    }
+    /**
+     * Initializes output directory for workflow execution
+     */
+    async initializeOutputDirectory(workflowName, workflowId, query) {
+        const outputDir = path.join(process.cwd(), 'workflow-output', workflowName, workflowId);
+        try {
+            await fsPromises.mkdir(outputDir, { recursive: true });
+            // Create initial manifest
+            const manifest = {
+                workflowId,
+                workflowName,
+                startTime: new Date().toISOString(),
+                endTime: null,
+                status: 'running',
+                query,
+                steps: []
+            };
+            await fsPromises.writeFile(path.join(outputDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+            console.error(`📁 Workflow output directory: ${outputDir}`);
+            return outputDir;
+        }
+        catch (error) {
+            console.error('⚠️  Failed to initialize workflow directory:', error);
+            throw error;
+        }
+    }
+    /**
+     * Updates workflow manifest with step status
+     */
+    async updateManifest(outputDir, stepId, status, outputFile, error) {
+        const manifestPath = path.join(outputDir, 'manifest.json');
+        try {
+            const data = await fsPromises.readFile(manifestPath, 'utf-8');
+            const manifest = JSON.parse(data);
+            // Update or add step
+            const existingIdx = manifest.steps.findIndex(s => s.id === stepId);
+            const stepData = {
+                id: stepId,
+                status,
+                outputFile,
+                error,
+                timestamp: new Date().toISOString()
+            };
+            if (existingIdx >= 0) {
+                manifest.steps[existingIdx] = stepData;
+            }
+            else {
+                manifest.steps.push(stepData);
+            }
+            // Update workflow status
+            const allCompleted = manifest.steps.every(s => s.status === 'completed');
+            const anyFailed = manifest.steps.some(s => s.status === 'failed');
+            if (anyFailed) {
+                manifest.status = 'failed';
+                manifest.endTime = new Date().toISOString();
+            }
+            else if (allCompleted) {
+                manifest.status = 'completed';
+                manifest.endTime = new Date().toISOString();
+            }
+            await fsPromises.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to update manifest:', error);
+            // Don't throw - manifest updates are not critical
+        }
+    }
+    /**
+     * Unicode-safe truncation helper
+     */
+    truncateString(str, maxLength) {
+        if (str.length <= maxLength) {
+            return str;
+        }
+        // Use Array.from() for Unicode safety (handles emoji, multi-byte chars)
+        const chars = Array.from(str);
+        if (chars.length <= maxLength) {
+            return str;
+        }
+        return chars.slice(0, maxLength).join('') + '...';
+    }
+    /**
+     * Circular reference replacer for JSON.stringify
+     */
+    getCircularReplacer() {
+        const seen = new WeakSet();
+        return (key, value) => {
+            if (typeof value === 'object' && value !== null) {
+                if (seen.has(value)) {
+                    return '[Circular]';
+                }
+                seen.add(value);
+            }
+            return value;
+        };
+    }
+}

package/dist/src/workflows/engine/WorkflowHelpers.js

@@ -0,0 +1,114 @@
+/**
+ * Workflow Helper Utilities
+ * Small helper functions for workflow processing
+ */
+export class WorkflowHelpers {
+    /**
+     * Group workflow steps by dependencies for parallel execution
+     * Steps with no dependencies run first, then steps depending on them, etc.
+     */
+    static groupStepsByDependencies(steps) {
+        const groups = [];
+        const processed = new Set();
+        while (processed.size < steps.length) {
+            const group = [];
+            for (const step of steps) {
+                if (processed.has(step.name))
+                    continue;
+                // Check if all dependencies are satisfied
+                const ready = !step.dependsOn ||
+                    step.dependsOn.every(dep => processed.has(dep));
+                if (ready) {
+                    group.push(step);
+                }
+            }
+            if (group.length === 0) {
+                throw new Error('Circular dependency detected in workflow steps');
+            }
+            groups.push(group);
+            group.forEach(step => processed.add(step.name));
+        }
+        return groups;
+    }
+    /**
+     * Calculate step numbers for display (handles parallel execution)
+     * Example: step1=1, step2=2, step3=3a, step4=3b (parallel), step5=4
+     *
+     * Rules:
+     * - Steps are SEQUENTIAL by default (1, 2, 3...)
+     * - Steps marked with `parallel: true` share the same number (3a, 3b)
+     * - The `parallel` flag means "run in parallel with NEXT step"
+     */
+    static calculateStepNumbers(workflow) {
+        const stepNumbers = new Map();
+        let sequentialNumber = 1;
+        let i = 0;
+        while (i < workflow.steps.length) {
+            const step = workflow.steps[i];
+            // Check if this step and subsequent steps form a parallel group
+            const parallelGroup = [step];
+            let j = i + 1;
+            // If current step has parallel flag, collect all subsequent parallel steps
+            if (step.parallel === true) {
+                while (j < workflow.steps.length && workflow.steps[j - 1].parallel === true) {
+                    parallelGroup.push(workflow.steps[j]);
+                    j++;
+                }
+            }
+            // Assign numbers
+            console.error(`[WorkflowHelpers] Step ${step.name}: parallelGroup.length = ${parallelGroup.length}`);
+            if (parallelGroup.length === 1) {
+                // Single sequential step
+                stepNumbers.set(step.name, String(sequentialNumber));
+                console.error(`[WorkflowHelpers] Assigned sequential: ${step.name} -> ${sequentialNumber}`);
+            }
+            else {
+                // Parallel group - use letters (3a, 3b, 3c)
+                console.error(`[WorkflowHelpers] Parallel group with ${parallelGroup.length} steps`);
+                parallelGroup.forEach((parallelStep, index) => {
+                    const letter = String.fromCharCode(97 + index); // 97 = 'a'
+                    stepNumbers.set(parallelStep.name, `${sequentialNumber}${letter}`);
+                    console.error(`[WorkflowHelpers] Assigned parallel: ${parallelStep.name} -> ${sequentialNumber}${letter}`);
+                });
+            }
+            sequentialNumber++;
+            i = j;
+        }
+        return stepNumbers;
+    }
+    /**
+     * Check if two dependency sets are identical
+     */
+    static haveSameDependencies(deps1, deps2) {
+        if (deps1.size !== deps2.size)
+            return false;
+        for (const dep of deps1) {
+            if (!deps2.has(dep))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Estimate token count for any data type
+     * Uses character-based approximation: tokens ≈ characters / 4
+     */
+    static estimateTokens(data) {
+        const text = typeof data === 'string' ? data : JSON.stringify(data);
+        return Math.ceil(text.length / 4);
+    }
+    /**
+     * Evaluate a condition string (basic implementation)
+     * Returns true/false based on condition evaluation
+     */
+    static evaluateCondition(condition, context) {
+        // Simple equality check: "variable == value"
+        const match = condition.match(/^(\w+)\s*==\s*(.+)$/);
+        if (match) {
+            const [, variable, expectedValue] = match;
+            const actualValue = context[variable];
+            return String(actualValue).trim() === expectedValue.trim().replace(/['"]/g, '');
+        }
+        // Default: if variable exists and is truthy
+        return !!context[condition];
+    }
+}

package/dist/src/workflows/engine/WorkflowOutputFormatter.js

@@ -0,0 +1,83 @@
+/**
+ * Workflow Output Formatter
+ * Formats workflow execution results in multiple formats (summary, detailed, JSON)
+ */
+export class WorkflowOutputFormatter {
+    /**
+     * Formats workflow execution results
+     */
+    format(execution, format, truncateSteps, maxStepTokens) {
+        // Check if auto-synthesis ran - if so, return ONLY the synthesis
+        const synthesisStep = execution.outputs.find(step => step.step === 'auto-synthesis');
+        if (synthesisStep) {
+            // Auto-synthesis ran - return only the synthesis output to prevent MCP 25k limit
+            return synthesisStep.output;
+        }
+        switch (format) {
+            case "json":
+                return {
+                    workflowName: execution.workflowName,
+                    workflowId: execution.workflowId,
+                    outputDir: execution.outputDir,
+                    status: execution.status,
+                    steps: execution.outputs.map(out => ({
+                        step: out.step,
+                        summary: out.output,
+                        filePath: out.filePath
+                    }))
+                };
+            case "detailed":
+                return this.formatDetailed(execution);
+            case "summary":
+            default:
+                return this.formatSummary(execution);
+        }
+    }
+    /**
+     * Formats detailed output with all step information
+     */
+    formatDetailed(execution) {
+        const duration = execution.endTime && execution.startTime
+            ? (execution.endTime.getTime() - execution.startTime.getTime()) / 1000
+            : 0;
+        let output = `# Workflow: ${execution.workflowName}\n\n`;
+        output += `**Duration:** ${duration.toFixed(1)}s\n`;
+        output += `**Steps Completed:** ${execution.outputs.length}\n`;
+        if (execution.outputDir) {
+            output += `**Output Directory:** ${execution.outputDir}\n`;
+        }
+        output += `\n---\n\n`;
+        // Show summaries for each step
+        for (let i = 0; i < execution.outputs.length; i++) {
+            const step = execution.outputs[i];
+            output += `## Step ${i + 1}: ${step.step}\n\n`;
+            if (step.input && step.input !== '[cached]') {
+                output += `**Input:**\n${step.input}...\n\n`;
+            }
+            output += `${step.output}\n\n`;
+            if (step.filePath) {
+                output += `📄 *Full output saved to: ${step.filePath}*\n\n`;
+            }
+            output += `---\n\n`;
+        }
+        output += `\n**Workflow Complete** ✓\n\n`;
+        output += `**Next Steps:**\nUse Read tool to analyze full outputs from saved files.\n`;
+        return output;
+    }
+    /**
+     * Formats summary output with last step and file paths
+     */
+    formatSummary(execution) {
+        const lastOutput = execution.outputs[execution.outputs.length - 1];
+        const savedFiles = execution.outputs
+            .filter(out => out.filePath)
+            .map(out => `  - ${out.step}: ${out.filePath}`)
+            .join('\n');
+        let result = lastOutput?.output || "Workflow completed";
+        if (savedFiles) {
+            result += `\n\n**Files saved:**\n${savedFiles}\n\n`;
+            result += `Use Read tool to access full content for detailed analysis.`;
+        }
+        return result;
+    }
+}

package/dist/src/workflows/engine/events/WorkflowEventBus.js

@@ -0,0 +1,132 @@
+/**
+ * Workflow Event Bus
+ * Central pub/sub event bus for workflow coordination
+ * Extends EventEmitter pattern from MessageQueue
+ */
+import { EventEmitter } from 'events';
+/**
+ * Standard workflow event topics
+ */
+export const WorkflowEvents = {
+    // Workflow lifecycle
+    WORKFLOW_STARTED: 'workflow.started',
+    WORKFLOW_VALIDATING: 'workflow.validating',
+    WORKFLOW_COMPLETED: 'workflow.completed',
+    WORKFLOW_FAILED: 'workflow.failed',
+    WORKFLOW_PAUSED: 'workflow.paused',
+    WORKFLOW_RESUMED: 'workflow.resumed',
+    // Step lifecycle
+    STEP_READY: 'workflow.step.ready',
+    STEP_STARTED: 'workflow.step.started',
+    STEP_COMPLETED: 'workflow.step.completed',
+    STEP_FAILED: 'workflow.step.failed',
+    STEP_SKIPPED: 'workflow.step.skipped',
+    STEP_RETRYING: 'workflow.step.retrying',
+    // Tool invocation
+    TOOL_BEFORE_INVOKE: 'workflow.tool.before_invoke',
+    TOOL_INVOKED: 'workflow.tool.invoked',
+    TOOL_SUCCESS: 'workflow.tool.success',
+    TOOL_FAILURE: 'workflow.tool.failure',
+    // Variable & file operations
+    VARIABLE_RESOLVED: 'workflow.variable.resolved',
+    FILE_CREATED: 'workflow.file.created',
+    FILE_REFERENCE_CREATED: 'workflow.file_reference.created',
+    // Synthesis
+    SYNTHESIS_STARTED: 'workflow.synthesis.started',
+    SYNTHESIS_COMPLETED: 'workflow.synthesis.completed',
+    // Session management
+    SESSION_CHECKPOINT: 'workflow.session.checkpoint',
+    SESSION_RESTORED: 'workflow.session.restored',
+    // Error handling
+    ERROR_OCCURRED: 'workflow.error.occurred',
+    ERROR_RECOVERED: 'workflow.error.recovered'
+};
+export class WorkflowEventBus extends EventEmitter {
+    constructor() {
+        super();
+        // Increase max listeners for complex workflows
+        this.setMaxListeners(100);
+    }
+    /**
+     * Singleton instance (optional - can also use new WorkflowEventBus())
+     */
+    static getInstance() {
+        if (!WorkflowEventBus.instance) {
+            WorkflowEventBus.instance = new WorkflowEventBus();
+        }
+        return WorkflowEventBus.instance;
+    }
+    subscribe(topic, handler) {
+        this.on(topic, handler);
+        // Return unsubscribe function
+        return () => {
+            this.off(topic, handler);
+        };
+    }
+    async publish(topic, data) {
+        // Log event for debugging (can be disabled in production)
+        if (process.env.DEBUG_WORKFLOW_EVENTS === 'true') {
+            console.error(`[EventBus] ${topic}:`, JSON.stringify(data, null, 2));
+        }
+        // Emit to all synchronous listeners
+        this.emit(topic, data);
+        // Get all listeners for this topic
+        const listeners = this.listeners(topic);
+        // Execute async handlers
+        const asyncHandlers = listeners.filter((listener) => listener.constructor.name === 'AsyncFunction');
+        if (asyncHandlers.length > 0) {
+            await Promise.all(asyncHandlers.map((handler) => Promise.resolve(handler(data))));
+        }
+    }
+    clear(topic) {
+        this.removeAllListeners(topic);
+    }
+    clearAll() {
+        this.removeAllListeners();
+    }
+    listenerCount(topic) {
+        return super.listenerCount(topic);
+    }
+    /**
+     * Subscribe to multiple topics with same handler
+     */
+    subscribeMultiple(topics, handler) {
+        const unsubscribers = topics.map((topic) => this.subscribe(topic, handler));
+        return () => {
+            unsubscribers.forEach((unsub) => unsub());
+        };
+    }
+    /**
+     * Wait for a specific event to occur (Promise-based)
+     */
+    async waitFor(topic, timeout = 30000) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.off(topic, handler);
+                reject(new Error(`Timeout waiting for event: ${topic}`));
+            }, timeout);
+            const handler = (data) => {
+                clearTimeout(timer);
+                resolve(data);
+            };
+            this.once(topic, handler);
+        });
+    }
+    /**
+     * Publish with error handling
+     */
+    async publishSafe(topic, data) {
+        try {
+            await this.publish(topic, data);
+        }
+        catch (error) {
+            console.error(`[EventBus] Error publishing to ${topic}:`, error);
+            // Emit error event for monitoring
+            this.emit(WorkflowEvents.ERROR_OCCURRED, {
+                topic,
+                error,
+                data
+            });
+        }
+    }
+}

package/dist/src/workflows/engine/events/interfaces/IEventBus.js

@@ -0,0 +1,5 @@
+/**
+ * Event Bus Interface
+ * Defines contract for pub/sub event system
+ */
+export {};