tachibot-mcp 2.0.2

package/dist/src/workflows/workflow-engine.js

@@ -0,0 +1,573 @@
+import { randomUUID } from 'crypto';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import { ModelRouter } from './model-router.js';
+import { WorkflowParser } from './workflow-parser.js';
+import { TokenTracker } from '../optimization/token-tracker.js';
+import { ResultCache } from '../optimization/result-cache.js';
+import { BatchExecutor } from '../optimization/batch-executor.js';
+import { performanceMonitor } from '../monitoring/performance-monitor.js';
+import { costMonitor } from '../optimization/cost-monitor.js';
+export class WorkflowEngine {
+    constructor() {
+        this.modelRouter = new ModelRouter();
+        this.parser = new WorkflowParser();
+        this.tokenTracker = new TokenTracker();
+        this.cache = new ResultCache();
+        this.batchExecutor = new BatchExecutor();
+    }
+    async parseWorkflow(yaml) {
+        return this.parser.parse(yaml);
+    }
+    async executeWorkflow(workflow, query) {
+        // Generate unique workflow ID: YYYYMMDD-HHMMSS-xxxx
+        const now = new Date();
+        const timestamp = now.toISOString().replace(/[-:]/g, '').split('.')[0].replace('T', '-');
+        const shortId = randomUUID().split('-')[0];
+        const workflowId = `${timestamp}-${shortId}`;
+        // Setup output directory
+        const outputDir = join(process.cwd(), 'workflow-output', workflow.name, workflowId);
+        const context = {
+            workflowId,
+            workflowName: workflow.name,
+            query,
+            results: new Map(),
+            tokens: new Map(),
+            metadata: new Map(),
+            startTime: Date.now(),
+            outputDir
+        };
+        // Create output directory and manifest
+        await this.initializeWorkflowDirectory(context, workflow);
+        const stepGroups = this.groupStepsByDependencies(workflow.steps);
+        for (const group of stepGroups) {
+            if (group.length === 1 && !group[0].parallel) {
+                await this.executeStep(group[0], context, workflow);
+            }
+            else {
+                await this.executeParallelSteps(group, context, workflow);
+            }
+            if (workflow.defaults?.earlyTermination && this.shouldTerminateEarly(context)) {
+                break;
+            }
+        }
+        return this.synthesizeResults(context, workflow);
+    }
+    async executeStep(step, context, workflow) {
+        if (step.condition && !this.evaluateCondition(step.condition, context)) {
+            return;
+        }
+        const cacheKey = this.getCacheKey(step, context);
+        const cached = await this.cache.get(cacheKey);
+        if (cached) {
+            context.results.set(step.id, cached.result);
+            context.tokens.set(step.id, cached.tokens);
+            return;
+        }
+        const models = this.selectModels(step, context);
+        const maxTokens = step.maxTokens || workflow.defaults?.maxTokens || 2000;
+        const stepContext = await this.buildStepContext(step, context);
+        const requestMeta = models.map(model => ({
+            model,
+            requestId: `${step.id}-${model}-${randomUUID()}`
+        }));
+        requestMeta.forEach(({ requestId, model }) => {
+            performanceMonitor.startRequest(requestId, model);
+        });
+        let result;
+        try {
+            result = await this.executeModeWithModels(step.mode, models, stepContext, maxTokens, step);
+        }
+        catch (error) {
+            requestMeta.forEach(({ requestId, model }) => {
+                performanceMonitor.completeRequest(requestId, false, undefined, error instanceof Error ? error.message : String(error), { stepId: step.id, mode: step.mode, model });
+            });
+            throw error;
+        }
+        context.results.set(step.id, result);
+        const metrics = this.tokenTracker.track(step.id, result, models[0]);
+        context.tokens.set(step.id, metrics.total);
+        // NEW: Save to file if requested
+        if (step.saveToFile && context.outputDir) {
+            try {
+                const filename = await this.saveStepOutput(context, step.id, result, metrics);
+                // Replace in-memory result with file reference + summary
+                context.results.set(step.id, {
+                    savedTo: filename,
+                    filePath: join(context.outputDir, filename),
+                    summary: this.extractSummary(result),
+                    tokens: metrics.total
+                });
+                await this.updateManifest(context, step.id, 'completed', metrics, filename);
+            }
+            catch (error) {
+                console.error(`Failed to save step output for ${step.id}:`, error);
+                await this.updateManifest(context, step.id, 'failed', metrics, undefined, error instanceof Error ? error.message : String(error));
+                // Don't throw - keep the in-memory result
+            }
+        }
+        if (models[0]) {
+            const costResult = await costMonitor.trackUsage(models[0], metrics.input, metrics.output, step.id);
+            if (costResult.alert) {
+                console.warn(`⚠️ Cost Alert (${models[0]}): ${costResult.alert.message}`);
+            }
+            if (!costResult.allowed) {
+                requestMeta.forEach(({ requestId, model }) => {
+                    performanceMonitor.completeRequest(requestId, false, { input: metrics.input, output: metrics.output }, costResult.alert?.message || 'Budget exceeded', { stepId: step.id, mode: step.mode, model });
+                });
+                throw new Error(`Cost limit exceeded for ${models[0]} on step ${step.id}: ${costResult.alert?.message || 'budget exceeded'}`);
+            }
+        }
+        const primaryRequest = requestMeta[0];
+        if (primaryRequest) {
+            performanceMonitor.completeRequest(primaryRequest.requestId, true, { input: metrics.input, output: metrics.output }, undefined, { stepId: step.id, mode: step.mode, model: primaryRequest.model });
+            // Mark secondary models as completed for visibility (token usage tracked via primary)
+            requestMeta.slice(1).forEach(({ requestId, model }) => {
+                performanceMonitor.completeRequest(requestId, true, undefined, undefined, { stepId: step.id, mode: step.mode, model });
+            });
+        }
+        await this.cache.set(cacheKey, {
+            result,
+            tokens: metrics.total,
+            timestamp: Date.now()
+        });
+    }
+    async executeParallelSteps(steps, context, workflow) {
+        console.error(`[Workflow] Starting ${steps.length} parallel steps: ${steps.map(s => s.id).join(', ')}`);
+        // Track execution progress
+        const tracker = {
+            started: new Set(),
+            completed: new Set(),
+            failed: new Set()
+        };
+        // Execute all steps with individual error handling
+        const executions = steps.map(async (step, index) => {
+            tracker.started.add(step.id);
+            console.error(`[Workflow] Step ${index + 1}/${steps.length} started: ${step.id}`);
+            try {
+                const result = await this.executeStep(step, context, workflow);
+                tracker.completed.add(step.id);
+                console.error(`[Workflow] Step ${index + 1}/${steps.length} ✓ completed: ${step.id}`);
+                return result;
+            }
+            catch (error) {
+                tracker.failed.add(step.id);
+                console.error(`[Workflow] Step ${index + 1}/${steps.length} ✗ failed: ${step.id}`, error);
+                // Store error in context for later inspection
+                context.metadata.set(`error:${step.id}`, error instanceof Error ? error.message : String(error));
+                // Update manifest for failed step
+                await this.updateManifest(context, step.id, 'failed', undefined, undefined, error instanceof Error ? error.message : String(error));
+                throw error; // Re-throw so Promise.allSettled captures it
+            }
+        });
+        // Use Promise.allSettled to ensure ALL steps execute regardless of failures
+        const results = await Promise.allSettled(executions);
+        // Log execution summary
+        const succeeded = results.filter(r => r.status === 'fulfilled').length;
+        const failed = results.filter(r => r.status === 'rejected').length;
+        console.error(`[Workflow] Parallel execution complete: ${succeeded} succeeded, ${failed} failed`);
+        // Debug summary
+        console.error('[Workflow] Execution summary:', {
+            started: tracker.started.size,
+            completed: tracker.completed.size,
+            failed: tracker.failed.size,
+            notStarted: steps.filter(s => !tracker.started.has(s.id)).map(s => s.id),
+            notCompleted: steps.filter(s => !tracker.completed.has(s.id)).map(s => s.id)
+        });
+        // Only throw if ALL steps failed (partial success is acceptable for file-based workflows)
+        if (failed === steps.length) {
+            throw new Error(`All ${steps.length} parallel steps failed`);
+        }
+    }
+    selectModels(step, context) {
+        if (step.model) {
+            return Array.isArray(step.model) ? step.model : [step.model];
+        }
+        const task = {
+            type: step.mode,
+            complexity: this.estimateComplexity(context),
+            needsCurrentInfo: step.mode === 'scout' || step.mode === 'research'
+        };
+        const constraints = {
+            budget: context.metadata.get('maxCostPerQuery'),
+            speed: context.metadata.get('preferSpeed')
+        };
+        return [this.modelRouter.selectModel(task, constraints)];
+    }
+    async buildStepContext(step, context) {
+        let stepContext = { query: context.query };
+        // NEW: Load files if requested
+        if (step.loadFiles && step.loadFiles.length > 0) {
+            const loadedFiles = await this.loadStepFiles(context, step.loadFiles);
+            stepContext.loadedFiles = loadedFiles;
+        }
+        if (step.contextFrom) {
+            const parts = step.contextFrom.split('.');
+            const stepId = parts[0];
+            const property = parts[1];
+            const result = context.results.get(stepId);
+            if (result) {
+                stepContext = {
+                    ...stepContext,
+                    ...(property ? { [property]: result[property] } : { context: result })
+                };
+            }
+        }
+        return stepContext;
+    }
+    async executeModeWithModels(mode, models, context, maxTokens, step) {
+        if (models.length === 1) {
+            return this.executeMode(mode, models[0], context, maxTokens, step);
+        }
+        const executions = models.map(model => this.executeMode(mode, model, context, maxTokens, step));
+        const results = await Promise.all(executions);
+        return this.combineModelResults(results, step);
+    }
+    async executeMode(mode, model, context, maxTokens, step) {
+        const modeHandlers = {
+            'verifier': async (m, c, t, s) => {
+                const { Verifier } = await import('../modes/verifier.js');
+                const verifier = new Verifier();
+                return verifier.verify(c.query, {
+                    model: m,
+                    maxTokens: t,
+                    variant: s.variant
+                });
+            },
+            'challenger': async (m, c, t, s) => {
+                const { Challenger } = await import('../modes/challenger.js');
+                const challenger = new Challenger();
+                return challenger.challenge(c, {
+                    model: m,
+                    maxTokens: t
+                });
+            },
+            'scout': async (m, c, t, s) => {
+                const { Scout } = await import('../modes/scout.js');
+                const scout = new Scout();
+                return scout.scout(c.query, {
+                    variant: s.variant || 'research_scout',
+                    maxTokens: t
+                });
+            },
+            'auditor': async (m, c, t, s) => {
+                const { Auditor } = await import('../modes/auditor.js');
+                const auditor = new Auditor();
+                return auditor.audit(c, {
+                    model: m,
+                    maxTokens: t
+                });
+            },
+            'commit_guardian': async (m, c, t, s) => {
+                const { CommitGuardian } = await import('../modes/commit-guardian.js');
+                const guardian = new CommitGuardian();
+                return guardian.validate(c, {
+                    model: m,
+                    maxTokens: t
+                });
+            },
+            'architect': async (m, c, t, s) => {
+                const { Architect } = await import('../modes/architect.js');
+                const architect = new Architect();
+                return architect.analyze(c.query || c, {
+                    maxTokens: t,
+                    depth: s.variant
+                });
+            },
+            'synthesis': async (m, c, t, s) => {
+                return this.synthesize(c, t);
+            }
+        };
+        const handler = modeHandlers[mode];
+        if (!handler) {
+            throw new Error(`Unknown mode: ${mode}`);
+        }
+        return handler(model, context, maxTokens, step);
+    }
+    combineModelResults(results, step) {
+        if (step.mode === 'verifier') {
+            return this.calculateConsensus(results);
+        }
+        return {
+            results,
+            combined: true,
+            count: results.length
+        };
+    }
+    calculateConsensus(responses) {
+        const grouped = new Map();
+        for (const response of responses) {
+            const key = JSON.stringify(response.conclusion || response);
+            if (!grouped.has(key)) {
+                grouped.set(key, []);
+            }
+            grouped.get(key).push(response);
+        }
+        const sorted = Array.from(grouped.entries())
+            .sort((a, b) => b[1].length - a[1].length);
+        const majority = sorted[0];
+        const consensus = majority[1].length / responses.length;
+        const outliers = sorted.slice(1).flatMap(([_, responses]) => responses);
+        return {
+            consensus,
+            majority: majority[0],
+            outliers,
+            shouldTerminate: consensus >= 0.8
+        };
+    }
+    shouldTerminateEarly(context) {
+        const lastResult = Array.from(context.results.values()).pop();
+        if (lastResult && lastResult.consensus && lastResult.consensus >= 0.9) {
+            return true;
+        }
+        return false;
+    }
+    groupStepsByDependencies(steps) {
+        const groups = [];
+        const processed = new Set();
+        while (processed.size < steps.length) {
+            const group = [];
+            for (const step of steps) {
+                if (processed.has(step.id))
+                    continue;
+                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');
+            }
+            groups.push(group);
+            group.forEach(step => processed.add(step.id));
+        }
+        return groups;
+    }
+    getCacheKey(step, context) {
+        return `${step.mode}:${step.id}:${context.query}:${JSON.stringify(step)}`;
+    }
+    estimateComplexity(context) {
+        const queryLength = context.query.length;
+        const resultsCount = context.results.size;
+        if (queryLength > 500 || resultsCount > 5)
+            return 0.8;
+        if (queryLength > 200 || resultsCount > 2)
+            return 0.5;
+        return 0.2;
+    }
+    evaluateCondition(condition, context) {
+        try {
+            const func = new Function('context', `return ${condition}`);
+            return func(context);
+        }
+        catch {
+            return true;
+        }
+    }
+    async synthesize(context, maxTokens) {
+        const inputs = Object.values(context).filter(v => v != null);
+        return {
+            synthesis: `Combined insights from ${inputs.length} sources`,
+            inputs,
+            timestamp: Date.now()
+        };
+    }
+    // ============================================================================
+    // File-based workflow output methods
+    // ============================================================================
+    async initializeWorkflowDirectory(context, workflow) {
+        if (!context.outputDir)
+            return;
+        try {
+            await fs.mkdir(context.outputDir, { recursive: true });
+            const manifest = {
+                workflowId: context.workflowId,
+                workflowName: context.workflowName,
+                startTime: new Date(context.startTime).toISOString(),
+                endTime: null,
+                status: 'running',
+                query: context.query,
+                steps: []
+            };
+            await fs.writeFile(join(context.outputDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to initialize workflow directory:', error);
+            // Clear outputDir to prevent further file operations
+            context.outputDir = undefined;
+            throw new Error(`Failed to initialize workflow directory: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async updateManifest(context, stepId, status, metrics, outputFile, error) {
+        if (!context.outputDir)
+            return;
+        try {
+            const manifestPath = join(context.outputDir, 'manifest.json');
+            const manifestData = await fs.readFile(manifestPath, 'utf-8');
+            const manifest = JSON.parse(manifestData);
+            const existingStepIndex = manifest.steps.findIndex((s) => s.id === stepId);
+            const stepData = {
+                id: stepId,
+                status,
+                outputFile,
+                tokens: metrics?.total,
+                cost: metrics?.cost,
+                error,
+                timestamp: new Date().toISOString()
+            };
+            if (existingStepIndex >= 0) {
+                manifest.steps[existingStepIndex] = 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.steps.length > 0) {
+                manifest.status = 'completed';
+                manifest.endTime = new Date().toISOString();
+            }
+            await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+        }
+        catch (error) {
+            console.error(`Failed to update manifest for step ${stepId}:`, error);
+            // Don't throw - manifest updates are not critical
+        }
+    }
+    async saveStepOutput(context, stepId, result, metrics) {
+        if (!context.outputDir) {
+            throw new Error('Output directory not initialized');
+        }
+        const filename = `${stepId}.md`;
+        const filepath = join(context.outputDir, filename);
+        const markdown = this.formatAsMarkdown(stepId, result, metrics, context);
+        await fs.writeFile(filepath, markdown);
+        return filename;
+    }
+    formatAsMarkdown(stepId, result, metrics, context) {
+        const lines = [];
+        lines.push(`# ${stepId}`);
+        lines.push('');
+        lines.push(`**Workflow:** ${context.workflowName}`);
+        lines.push(`**Workflow ID:** ${context.workflowId}`);
+        lines.push(`**Timestamp:** ${new Date().toISOString()}`);
+        lines.push('');
+        lines.push(`## Metrics`);
+        lines.push('');
+        lines.push(`- **Model:** ${metrics.model}`);
+        lines.push(`- **Input Tokens:** ${metrics.input.toLocaleString()}`);
+        lines.push(`- **Output Tokens:** ${metrics.output.toLocaleString()}`);
+        lines.push(`- **Total Tokens:** ${metrics.total.toLocaleString()}`);
+        lines.push(`- **Estimated Cost:** $${metrics.cost.toFixed(4)}`);
+        lines.push('');
+        lines.push(`## Result`);
+        lines.push('');
+        if (typeof result === 'string') {
+            lines.push(result);
+        }
+        else if (result && typeof result === 'object') {
+            // Handle structured results
+            if (result.summary) {
+                lines.push(`### Summary`);
+                lines.push('');
+                lines.push(result.summary);
+                lines.push('');
+            }
+            if (result.findings || result.issues) {
+                lines.push(`### Findings`);
+                lines.push('');
+                const findings = result.findings || result.issues;
+                if (Array.isArray(findings)) {
+                    findings.forEach((finding, i) => {
+                        lines.push(`${i + 1}. ${JSON.stringify(finding, null, 2)}`);
+                    });
+                }
+                else {
+                    lines.push(JSON.stringify(findings, null, 2));
+                }
+                lines.push('');
+            }
+            if (result.recommendations) {
+                lines.push(`### Recommendations`);
+                lines.push('');
+                if (Array.isArray(result.recommendations)) {
+                    result.recommendations.forEach((rec, i) => {
+                        lines.push(`${i + 1}. ${rec}`);
+                    });
+                }
+                else {
+                    lines.push(result.recommendations);
+                }
+                lines.push('');
+            }
+            // Add full raw result
+            lines.push(`### Raw Result`);
+            lines.push('');
+            lines.push('```json');
+            lines.push(JSON.stringify(result, null, 2));
+            lines.push('```');
+        }
+        else {
+            lines.push(String(result));
+        }
+        return lines.join('\n');
+    }
+    async loadStepFiles(context, stepIds) {
+        if (!context.outputDir) {
+            return {};
+        }
+        const loaded = {};
+        for (const stepId of stepIds) {
+            const filepath = join(context.outputDir, `${stepId}.md`);
+            try {
+                const content = await fs.readFile(filepath, 'utf-8');
+                loaded[stepId] = content;
+            }
+            catch (error) {
+                console.warn(`Could not load file for step ${stepId}: ${error}`);
+            }
+        }
+        return loaded;
+    }
+    extractSummary(result) {
+        if (typeof result === 'string') {
+            return result.slice(0, 200) + (result.length > 200 ? '...' : '');
+        }
+        if (result?.summary) {
+            return typeof result.summary === 'string'
+                ? result.summary
+                : JSON.stringify(result.summary).slice(0, 200) + '...';
+        }
+        const resultStr = JSON.stringify(result);
+        return resultStr.slice(0, 200) + (resultStr.length > 200 ? '...' : '');
+    }
+    // ============================================================================
+    async synthesizeResults(context, workflow) {
+        const duration = Date.now() - context.startTime;
+        const totalTokens = Array.from(context.tokens.values()).reduce((a, b) => a + b, 0);
+        const response = {
+            workflow: workflow.name,
+            workflowId: context.workflowId,
+            query: context.query,
+            results: Object.fromEntries(context.results),
+            metrics: {
+                duration,
+                totalTokens,
+                estimatedCost: workflow.estimatedCost,
+                steps: context.results.size
+            }
+        };
+        // Include output directory info if files were saved
+        if (context.outputDir) {
+            response.outputDirectory = context.outputDir;
+            response.message = `Results saved to: ${context.outputDir}`;
+        }
+        return response;
+    }
+}