tachibot-mcp 2.0.2

package/dist/src/workflows/custom-workflows.js

@@ -0,0 +1,451 @@
+/**
+ * Custom Workflow System - User-configurable workflows with YAML/JSON support
+ * Part of TachiBot's extensibility features
+ *
+ * This file now delegates to engine modules for better maintainability.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "yaml";
+import { costMonitor } from "../optimization/cost-monitor.js";
+// Import shared types (breaks circular dependency)
+import { WorkflowSchema, WorkflowStepSchema } from "./workflow-types.js";
+export { WorkflowSchema, WorkflowStepSchema };
+// Import engine modules
+import { VariableInterpolator } from "./engine/VariableInterpolator.js";
+import { StepParameterResolver } from "./engine/StepParameterResolver.js";
+import { WorkflowHelpers } from "./engine/WorkflowHelpers.js";
+import { WorkflowDiscovery } from "./engine/WorkflowDiscovery.js";
+import { WorkflowFileManager } from "./engine/WorkflowFileManager.js";
+import { WorkflowOutputFormatter } from "./engine/WorkflowOutputFormatter.js";
+import { AutoSynthesizer } from "./engine/AutoSynthesizer.js";
+import { executeWorkflowImpl } from "./engine/WorkflowExecutionEngine.js";
+import { WorkflowEventBus } from "./engine/events/WorkflowEventBus.js";
+import { PromptEnhancementHandler } from "./engine/handlers/PromptEnhancementHandler.js";
+import { ErrorRecoveryHandler } from "./engine/handlers/ErrorRecoveryHandler.js";
+import { StepExecutionHandler } from "./engine/handlers/StepExecutionHandler.js";
+import { ToolInvocationHandler } from "./engine/handlers/ToolInvocationHandler.js";
+import { WorkflowStateMachine } from "./engine/state/WorkflowStateMachine.js";
+export class CustomWorkflowEngine {
+    constructor() {
+        this.workflows = new Map();
+        this.executionHistory = [];
+        // Initialize engine modules
+        this.variableInterpolator = new VariableInterpolator();
+        this.parameterResolver = new StepParameterResolver();
+        this.fileManager = new WorkflowFileManager();
+        this.outputFormatter = new WorkflowOutputFormatter();
+        this.autoSynthesizer = new AutoSynthesizer();
+        this.eventBus = new WorkflowEventBus();
+        this.stateMachine = new WorkflowStateMachine();
+        // Initialize event handlers (Phase 3: Full event-driven architecture)
+        this.promptEnhancer = new PromptEnhancementHandler(this.eventBus);
+        this.errorRecovery = new ErrorRecoveryHandler(this.eventBus);
+        this.stepExecutor = new StepExecutionHandler(this.eventBus, this.stateMachine);
+        this.toolInvoker = new ToolInvocationHandler(this.eventBus);
+        console.error('[CustomWorkflowEngine] Phase 3 handlers initialized:');
+        console.error('  ✓ PromptEnhancementHandler - 13 prompt engineering techniques');
+        console.error('  ✓ ErrorRecoveryHandler - Circuit breaker pattern');
+        console.error('  ✓ StepExecutionHandler - Step lifecycle tracking');
+        console.error('  ✓ ToolInvocationHandler - Tool execution coordination');
+        console.error('  ℹ Progress tracking: manifest.json in workflow-output/');
+        // Load workflows
+        this.loadBuiltInWorkflows();
+        this.loadUserWorkflows();
+    }
+    /**
+     * Load built-in workflow templates
+     */
+    loadBuiltInWorkflows() {
+        const builtInWorkflows = [
+            {
+                name: "code-review",
+                description: "Comprehensive code review with multiple perspectives",
+                version: "1.0",
+                settings: {
+                    maxCost: 0.5,
+                    optimization: {
+                        enabled: true,
+                        cacheResults: true,
+                        compressPrompts: true,
+                        smartRouting: true,
+                    },
+                },
+                steps: [
+                    {
+                        name: "Initial Analysis",
+                        tool: "gemini_analyze_code",
+                        input: { prompt: "Analyze this code for issues and improvements" },
+                        output: { variable: "initial_analysis" },
+                    },
+                    {
+                        name: "Security Check",
+                        tool: "verifier",
+                        input: {
+                            prompt: "Check for security vulnerabilities",
+                            previousStep: "initial_analysis",
+                        },
+                        parallel: true,
+                    },
+                    {
+                        name: "Performance Review",
+                        tool: "gemini_analyze_code", // Use Gemini for performance analysis
+                        input: {
+                            prompt: "Analyze performance of: ${input}"
+                        },
+                        parallel: true,
+                    },
+                    {
+                        name: "Best Practices",
+                        tool: "code_reviewer",
+                        input: { prompt: "Evaluate against best practices" },
+                    },
+                    {
+                        name: "Synthesis",
+                        tool: "gpt5_analyze",
+                        input: {
+                            prompt: "Synthesize all findings into actionable recommendations",
+                            context: "Combine all previous analyses",
+                        },
+                    },
+                ],
+            },
+            {
+                name: "brainstorm",
+                description: "Multi-model brainstorming session",
+                version: "1.0",
+                settings: {
+                    maxCost: 1.0,
+                    defaultModel: "gpt-5-mini",
+                },
+                steps: [
+                    {
+                        name: "Gemini Ideas",
+                        tool: "gemini_brainstorm",
+                        maxTokens: 500,
+                    },
+                    {
+                        name: "GPT-5 Creative",
+                        tool: "gpt5_mini",
+                        input: { prompt: "Build on previous ideas with creative twists" },
+                    },
+                    {
+                        name: "Perplexity Research",
+                        tool: "perplexity_research",
+                        input: { prompt: "Find real-world examples and evidence" },
+                    },
+                    {
+                        name: "Final Synthesis",
+                        tool: "focus",
+                        input: { prompt: "Combine all ideas into top 5 recommendations" },
+                    },
+                ],
+            },
+            {
+                name: "debug-assistant",
+                description: "Multi-stage debugging helper",
+                version: "1.0",
+                steps: [
+                    {
+                        name: "Error Analysis",
+                        tool: "grok_debug",
+                        input: {
+                            prompt: "Analyze the error message and stack trace: ${input}"
+                        },
+                        output: { variable: "error_analysis" },
+                    },
+                    {
+                        name: "Code Context",
+                        tool: "grok_code",
+                        input: {
+                            prompt: "Analyze the code path leading to this error",
+                            previousStep: "error_analysis",
+                        },
+                    },
+                    {
+                        name: "Solution Search",
+                        tool: "perplexity_code_search",
+                        input: { prompt: "Find solutions for similar errors" },
+                        parallel: true,
+                    },
+                    {
+                        name: "Fix Suggestion",
+                        tool: "gpt5_mini",
+                        input: {
+                            prompt: "Suggest specific code fixes",
+                            context: "Based on all previous analysis",
+                        },
+                    },
+                ],
+            },
+        ];
+        for (const workflow of builtInWorkflows) {
+            this.workflows.set(workflow.name, workflow);
+        }
+    }
+    /**
+     * Load user-defined workflows from config directory
+     * Delegates to WorkflowDiscovery for multi-location workflow loading
+     */
+    loadUserWorkflows() {
+        const packageRoot = WorkflowDiscovery.getPackageRoot();
+        const discovery = new WorkflowDiscovery({
+            packageRoot,
+            workflowSchema: WorkflowSchema,
+            preprocessVariables: this.preprocessWorkflowVariables.bind(this),
+        });
+        const { workflows, errors } = discovery.discoverWorkflows();
+        // Merge discovered workflows
+        for (const [name, workflow] of workflows.entries()) {
+            this.workflows.set(name, workflow);
+        }
+        // Log validation errors if any
+        if (errors.length > 0) {
+            console.error(`⚠️  ${errors.length} workflow validation error(s):`);
+            for (const error of errors) {
+                console.error(`   [${error.source}] ${error.file}: ${error.error}`);
+            }
+        }
+    }
+    /**
+     * Pre-process workflow to interpolate initial variables (load-time)
+     * This resolves ${variable} references from the variables: section
+     */
+    preprocessWorkflowVariables(obj, variables) {
+        if (typeof obj === "string") {
+            // Check if this string contains ${variable} references
+            if (!obj.includes("${")) {
+                return obj; // No interpolation needed
+            }
+            // Interpolate ${variable} references
+            const interpolated = obj.replace(/\${([^}]+)}/g, (match, key) => {
+                const value = variables[key];
+                if (value === undefined) {
+                    return match; // Keep unresolved for runtime (e.g., ${step_output})
+                }
+                // Return the actual value, preserving its type
+                // If the entire string is just "${variable}", return the raw value (number stays number)
+                // Otherwise convert to string for concatenation
+                return value;
+            });
+            // If the ENTIRE string was just "${variable}", return the value with its original type
+            const singleVarMatch = obj.match(/^\${([^}]+)}$/);
+            if (singleVarMatch) {
+                const value = variables[singleVarMatch[1]];
+                return value !== undefined ? value : obj; // Preserve number type!
+            }
+            return interpolated;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.preprocessWorkflowVariables(item, variables));
+        }
+        if (obj && typeof obj === "object") {
+            const result = {};
+            for (const [key, value] of Object.entries(obj)) {
+                if (key === "variables") {
+                    // Don't interpolate variable definitions themselves
+                    result[key] = value;
+                }
+                else {
+                    result[key] = this.preprocessWorkflowVariables(value, variables);
+                }
+            }
+            return result;
+        }
+        return obj;
+    }
+    /**
+     * Execute a workflow by name
+     * Delegates to WorkflowExecutionEngine for the actual execution logic
+     */
+    async executeWorkflow(workflowName, input, options) {
+        const workflow = this.workflows.get(workflowName);
+        if (!workflow) {
+            throw new Error(`Workflow '${workflowName}' not found`);
+        }
+        // Check cost limit
+        const maxCost = workflow.settings?.maxCost || 10.0;
+        const costCheck = await costMonitor.checkRequest("workflow", 1000);
+        if (!costCheck.allowed) {
+            throw new Error(`Cost limit would be exceeded: ${costCheck.warning}`);
+        }
+        // Delegate to execution engine
+        return executeWorkflowImpl(this, workflowName, input, options);
+    }
+    /**
+     * Helper to evaluate conditions - delegates to WorkflowHelpers
+     */
+    evaluateCondition(condition, variables, outputs) {
+        const context = { ...variables, ...outputs };
+        return WorkflowHelpers.evaluateCondition(condition, context);
+    }
+    /**
+     * Helper to interpolate variables in strings - delegates to VariableInterpolator
+     */
+    async interpolateVariables(template, variables, stepOutputs) {
+        return this.variableInterpolator.interpolate(template, {
+            variables,
+            stepOutputs: new Map(Object.entries(stepOutputs)),
+            fileReferences: new Map(Object.entries(stepOutputs)),
+        });
+    }
+    /**
+     * Resolve step parameters at runtime - delegates to StepParameterResolver
+     */
+    resolveStepParameters(step, variables, stepOutputs) {
+        return this.parameterResolver.resolve(step, {
+            variables,
+            stepOutputs,
+        });
+    }
+    /**
+     * Call a tool - now integrated with actual MCP tools!
+     */
+    async callTool(toolName, input, options) {
+        // Import tool mapper dynamically to avoid circular dependencies
+        const { executeWorkflowTool } = await import("./tool-mapper.js");
+        console.error(`Calling ${toolName} with`, { input, options });
+        // Execute the actual tool - returns { result, modelUsed }
+        return await executeWorkflowTool(toolName, input, options);
+    }
+    /**
+     * Format workflow output - delegates to WorkflowOutputFormatter
+     */
+    formatOutput(execution, format, truncateSteps = true, maxStepTokens = 2500) {
+        return this.outputFormatter.format(execution, format, truncateSteps, maxStepTokens);
+    }
+    /**
+     * Create FileReference for step output - delegates to WorkflowFileManager
+     */
+    async createFileReference(stepName, content, workflowId, workflowName, saveToFile, outputDir, stepNumber, modelName) {
+        return this.fileManager.createFileReference({
+            stepName,
+            content,
+            workflowId,
+            workflowName,
+            saveToFile,
+            outputDir,
+            stepNumber,
+            modelName
+        });
+    }
+    /**
+     * Extract input summary for logging
+     */
+    extractInputSummary(input) {
+        if (typeof input === 'string') {
+            return input.length > 200 ? input.substring(0, 200) + '...' : input;
+        }
+        return JSON.stringify(input).substring(0, 200) + '...';
+    }
+    /**
+     * Calculate step numbers for display - delegates to WorkflowHelpers
+     */
+    calculateStepNumbers(workflow) {
+        return WorkflowHelpers.calculateStepNumbers(workflow);
+    }
+    /**
+     * Estimate total tokens - delegates to AutoSynthesizer
+     */
+    estimateTotalTokens(results) {
+        return this.autoSynthesizer.estimateTotalTokens(results);
+    }
+    /**
+     * Check if auto-synthesis should run - delegates to AutoSynthesizer
+     */
+    shouldAutoSynthesize(workflow, accumulatedResults, currentStepIndex) {
+        return this.autoSynthesizer.shouldSynthesize(workflow, accumulatedResults, currentStepIndex);
+    }
+    /**
+     * Create synthesis step - delegates to AutoSynthesizer
+     */
+    createSynthesisStep(workflow, variables, sessionDir) {
+        return this.autoSynthesizer.createSynthesisStep({
+            workflow,
+            variables,
+            sessionDir: sessionDir || null
+        });
+    }
+    /**
+     * Create checkpoint (stub for now)
+     */
+    async createCheckpoint(workflowName, outputDir, variables, stepIndex) {
+        // Implementation to be added if needed
+    }
+    /**
+     * Delete checkpoint (stub for now)
+     */
+    async deleteCheckpoint(outputDir) {
+        // Implementation to be added if needed
+    }
+    /**
+     * List available workflows
+     */
+    listWorkflows() {
+        return Array.from(this.workflows.values()).map((w) => ({
+            name: w.name,
+            description: w.description,
+            steps: w.steps.length,
+        }));
+    }
+    /**
+     * Get workflow definition
+     */
+    getWorkflow(name) {
+        return this.workflows.get(name);
+    }
+    /**
+     * Save a new workflow
+     */
+    async saveWorkflow(workflow, format = "yaml") {
+        const dir = path.join(process.cwd(), ".tachi", "workflows");
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const filename = `${workflow.name}.${format}`;
+        const filepath = path.join(dir, filename);
+        const content = format === "json"
+            ? JSON.stringify(workflow, null, 2)
+            : yaml.stringify(workflow);
+        fs.writeFileSync(filepath, content);
+        this.workflows.set(workflow.name, workflow);
+        console.log(`✅ Saved workflow: ${workflow.name} to ${filepath}`);
+    }
+    /**
+     * Load and execute workflow from file (stub - needs implementation)
+     */
+    async loadAndExecuteWorkflowFile(filePath, query, options) {
+        // Load workflow from file
+        const discovery = new WorkflowDiscovery({
+            packageRoot: WorkflowDiscovery.getPackageRoot(),
+            workflowSchema: WorkflowSchema,
+            preprocessVariables: this.preprocessWorkflowVariables.bind(this),
+        });
+        const workflow = discovery.loadWorkflowFile(filePath);
+        // Temporarily add to workflows map
+        this.workflows.set(workflow.name, workflow);
+        // Execute it
+        return this.executeWorkflow(workflow.name, query, options);
+    }
+    /**
+     * Get validation errors from workflow loading (stub)
+     */
+    getValidationErrors() {
+        // TODO: Implement validation error tracking
+        return [];
+    }
+    /**
+     * Start workflow step-by-step (stub - needs implementation)
+     */
+    async startWorkflowStepByStep(workflowName, query, options) {
+        throw new Error("Step-by-step execution not yet implemented in refactored engine");
+    }
+    /**
+     * Continue workflow from session (stub - needs implementation)
+     */
+    async continueWorkflow(sessionId) {
+        throw new Error("Continue workflow not yet implemented in refactored engine");
+    }
+}
+// Export singleton
+export const workflowEngine = new CustomWorkflowEngine();

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

@@ -0,0 +1,97 @@
+/**
+ * Auto-Synthesizer
+ * Automatically summarizes large workflow outputs to bypass MCP 25k token limit
+ */
+export class AutoSynthesizer {
+    /**
+     * Determines if auto-synthesis should run
+     */
+    shouldSynthesize(workflow, accumulatedResults, currentStepIndex) {
+        // Check if auto-synthesis is enabled
+        const autoSynthesis = workflow.settings?.autoSynthesis;
+        if (!autoSynthesis?.enabled) {
+            return false;
+        }
+        // Check if any step up to current has saveToFile: true
+        const hasSaveToFile = workflow.steps
+            .slice(0, currentStepIndex + 1)
+            .some((step) => step.saveToFile === true);
+        // Estimate total tokens accumulated
+        const totalTokens = this.estimateTotalTokens(accumulatedResults);
+        // Trigger if:
+        // 1. Any step saves to file (indicates large/important outputs), OR
+        // 2. Total tokens exceed threshold
+        const shouldTrigger = hasSaveToFile || totalTokens >= (autoSynthesis.tokenThreshold ?? 20000);
+        return shouldTrigger;
+    }
+    /**
+     * Creates a synthesis step that summarizes all previous outputs
+     */
+    createSynthesisStep(context) {
+        const { workflow, variables, sessionDir } = context;
+        const autoSynthesis = workflow.settings?.autoSynthesis;
+        const synthesisTool = autoSynthesis?.synthesisTool ?? 'gemini_analyze_text';
+        const maxTokens = autoSynthesis?.synthesisMaxTokens ?? 6000;
+        // Collect all step outputs (variable names)
+        const stepOutputs = workflow.steps
+            .filter((step) => step.output?.variable)
+            .map((step) => step.output?.variable)
+            .filter((varName) => varName !== undefined);
+        // Build text parameter with all outputs
+        const allOutputsText = stepOutputs
+            .map((varName) => `${variables[varName] ?? ''}`)
+            .join('\n\n');
+        // Build list of saved files if applicable
+        const savedFiles = sessionDir
+            ? workflow.steps
+                .filter((step) => step.saveToFile)
+                .map((step) => `- ${step.name}.md`)
+                .join('\n')
+            : '';
+        const fileNote = savedFiles
+            ? `\n\nNote: Full outputs saved to ${sessionDir}/\nFiles:\n${savedFiles}\n\nEnd with: "Use Read tool on saved files for full detailed analysis."`
+            : '';
+        // Create synthesis task instruction
+        const synthesisTask = `Synthesize all workflow outputs into executive summary:
+
+1. Key findings (brief, top 3-5 points)
+2. Main insights or patterns discovered
+3. Critical issues or challenges identified
+4. Recommended next steps with priorities
+5. Overall assessment${fileNote}
+
+Keep under 2000 words for Claude Code.`;
+        // Create the synthesis step
+        const synthesisStep = {
+            name: 'auto-synthesis',
+            tool: synthesisTool,
+            input: {
+                text: allOutputsText,
+                task: synthesisTask,
+            },
+            maxTokens,
+            output: {
+                variable: 'executive_summary',
+            },
+        };
+        return synthesisStep;
+    }
+    /**
+     * Estimates total tokens across accumulated results
+     */
+    estimateTotalTokens(results) {
+        let total = 0;
+        for (const result of results) {
+            total += this.estimateTokens(result);
+        }
+        return total;
+    }
+    /**
+     * Estimate token count for any data type
+     * Uses character-based approximation: tokens ≈ characters / 4
+     */
+    estimateTokens(data) {
+        const text = typeof data === 'string' ? data : JSON.stringify(data);
+        return Math.ceil(text.length / 4);
+    }
+}

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

@@ -0,0 +1,74 @@
+/**
+ * Step Parameter Resolver
+ * Resolves step parameters (model, temperature, maxTokens) with variable interpolation
+ */
+export class StepParameterResolver {
+    /**
+     * Type guard to check if value is a FileReference
+     */
+    isFileReference(value) {
+        return (value &&
+            typeof value === 'object' &&
+            'stepName' in value &&
+            'summary' in value &&
+            'getContent' in value &&
+            typeof value.getContent === 'function');
+    }
+    /**
+     * Resolves step parameters (model, temperature, maxTokens)
+     */
+    resolve(step, context) {
+        const mergedContext = { ...context.variables, ...context.stepOutputs };
+        // Helper to resolve a value (string or already-resolved)
+        const resolve = (value, type) => {
+            if (value === undefined)
+                return undefined;
+            // Already the correct type
+            if (type === "number" && typeof value === "number")
+                return value;
+            if (type === "string" &&
+                typeof value === "string" &&
+                !value.includes("${"))
+                return value;
+            // Interpolate ${variable} if it's a string
+            if (typeof value === "string") {
+                const interpolated = value.replace(/\${([^}]+)}/g, (match, key) => {
+                    const resolved = mergedContext[key];
+                    // Handle FileReference objects - return summary by default
+                    if (this.isFileReference(resolved)) {
+                        return resolved.summary;
+                    }
+                    // Preserve placeholder if undefined (better for debugging than empty string)
+                    return resolved !== undefined ? String(resolved) : match;
+                });
+                // Convert to number if needed
+                if (type === "number") {
+                    const num = parseFloat(interpolated);
+                    if (isNaN(num)) {
+                        console.warn(`⚠️ Could not convert "${interpolated}" to number, using undefined`);
+                        return undefined;
+                    }
+                    return num;
+                }
+                return interpolated;
+            }
+            return value;
+        };
+        const resolved = {
+            model: resolve(step.model, "string"),
+            temperature: resolve(step.temperature, "number"),
+            maxTokens: resolve(step.maxTokens, "number"),
+        };
+        // Log if interpolation happened
+        if (step.model && step.model !== resolved.model) {
+            console.error(`🔄 Resolved model: "${step.model}" → "${resolved.model}"`);
+        }
+        if (step.temperature && step.temperature !== resolved.temperature) {
+            console.error(`🔄 Resolved temperature: "${step.temperature}" → ${resolved.temperature}`);
+        }
+        if (step.maxTokens && step.maxTokens !== resolved.maxTokens) {
+            console.error(`🔄 Resolved maxTokens: "${step.maxTokens}" → ${resolved.maxTokens}`);
+        }
+        return resolved;
+    }
+}