tachibot-mcp 2.0.2

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

@@ -0,0 +1,283 @@
+import * as yaml from 'js-yaml';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+export class WorkflowParser {
+    constructor() {
+        this.defaultWorkflows = null;
+    }
+    async parse(input) {
+        try {
+            const parsed = yaml.load(input);
+            if (parsed.workflows) {
+                const config = parsed;
+                const firstWorkflow = Object.values(config.workflows)[0];
+                return this.validateWorkflowInternal(firstWorkflow);
+            }
+            return this.validateWorkflowInternal(parsed);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse workflow: ${error}`);
+        }
+    }
+    async loadConfig(configPath) {
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+            return yaml.load(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to load workflow config: ${error}`);
+        }
+    }
+    async loadDefaultWorkflows() {
+        if (this.defaultWorkflows) {
+            return this.defaultWorkflows;
+        }
+        const defaultPath = path.join(__dirname, '../../config/default-workflows.yaml');
+        this.defaultWorkflows = await this.loadConfig(defaultPath);
+        return this.defaultWorkflows;
+    }
+    async loadCustomWorkflows(projectPath) {
+        // Load workflows from multiple sources and merge them
+        const mergedConfig = {
+            version: '1.0',
+            defaults: {},
+            workflows: {}
+        };
+        // Define directories to scan for workflow files
+        const dirs = [];
+        // Project-specific
+        if (projectPath) {
+            dirs.push(path.join(projectPath, '.focus'));
+            dirs.push(path.join(projectPath, '.focus', 'workflows'));
+        }
+        // Current directory
+        dirs.push(path.join(process.cwd(), '.focus'));
+        dirs.push(path.join(process.cwd(), '.focus', 'workflows'));
+        // User home
+        dirs.push(path.join(os.homedir(), '.focus'));
+        dirs.push(path.join(os.homedir(), '.focus', 'workflows'));
+        // Built-in config directory
+        dirs.push(path.join(__dirname, '../../config'));
+        let hasLoadedAny = false;
+        for (const dir of dirs) {
+            try {
+                const files = await this.findWorkflowFiles(dir);
+                for (const file of files) {
+                    try {
+                        const config = await this.loadConfig(file);
+                        console.error(`Loaded workflows from: ${file}`);
+                        // Merge defaults
+                        if (config.defaults) {
+                            mergedConfig.defaults = {
+                                ...mergedConfig.defaults,
+                                ...config.defaults
+                            };
+                        }
+                        // Merge workflows (later files override earlier ones)
+                        if (config.workflows) {
+                            mergedConfig.workflows = {
+                                ...mergedConfig.workflows,
+                                ...config.workflows
+                            };
+                        }
+                        hasLoadedAny = true;
+                    }
+                    catch (error) {
+                        console.warn(`Failed to load workflow file ${file}:`, error);
+                    }
+                }
+            }
+            catch {
+                // Directory doesn't exist, skip
+            }
+        }
+        return hasLoadedAny ? mergedConfig : null;
+    }
+    async findWorkflowFiles(dir) {
+        const workflowFiles = [];
+        try {
+            const entries = await fs.readdir(dir);
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry);
+                const stat = await fs.stat(fullPath);
+                if (stat.isFile()) {
+                    // Check if it's a YAML workflow file
+                    if (entry.endsWith('.yaml') || entry.endsWith('.yml')) {
+                        // Include files with 'workflow' in name or specific known files
+                        if (entry.includes('workflow') ||
+                            entry === 'config.yaml' ||
+                            entry === 'config.yml' ||
+                            entry.startsWith('custom-') ||
+                            entry.startsWith('project-')) {
+                            workflowFiles.push(fullPath);
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist or not readable
+        }
+        return workflowFiles;
+    }
+    async mergeWorkflows(projectPath) {
+        const defaultWorkflows = await this.loadDefaultWorkflows();
+        const customWorkflows = await this.loadCustomWorkflows(projectPath);
+        if (!customWorkflows) {
+            return defaultWorkflows;
+        }
+        // Merge custom workflows with defaults
+        // Custom workflows override defaults with the same name
+        return {
+            version: customWorkflows.version || defaultWorkflows.version,
+            defaults: {
+                ...defaultWorkflows.defaults,
+                ...customWorkflows.defaults
+            },
+            workflows: {
+                ...defaultWorkflows.workflows,
+                ...customWorkflows.workflows // Custom overrides default
+            }
+        };
+    }
+    async validateWorkflow(workflow) {
+        const errors = [];
+        try {
+            this.validateWorkflowInternal(workflow);
+            return { valid: true, errors: [] };
+        }
+        catch (error) {
+            errors.push(error.message);
+            return { valid: false, errors };
+        }
+    }
+    async getWorkflowSources(projectPath) {
+        const sources = [];
+        // Get all directories
+        const dirs = [];
+        if (projectPath) {
+            dirs.push(path.join(projectPath, '.focus'));
+            dirs.push(path.join(projectPath, '.focus', 'workflows'));
+        }
+        dirs.push(path.join(process.cwd(), '.focus'));
+        dirs.push(path.join(process.cwd(), '.focus', 'workflows'));
+        dirs.push(path.join(os.homedir(), '.focus'));
+        dirs.push(path.join(os.homedir(), '.focus', 'workflows'));
+        dirs.push(path.join(__dirname, '../../config'));
+        for (const dir of dirs) {
+            try {
+                const files = await this.findWorkflowFiles(dir);
+                for (const file of files) {
+                    try {
+                        const config = await this.loadConfig(file);
+                        if (config.workflows) {
+                            sources.push({
+                                file: path.relative(process.cwd(), file),
+                                workflows: Object.keys(config.workflows)
+                            });
+                        }
+                    }
+                    catch {
+                        // Skip invalid files
+                    }
+                }
+            }
+            catch {
+                // Skip non-existent directories
+            }
+        }
+        return sources;
+    }
+    async getWorkflow(name, projectPath) {
+        const merged = await this.mergeWorkflows(projectPath);
+        return merged.workflows[name] || null;
+    }
+    async listAvailableWorkflows(projectPath) {
+        const merged = await this.mergeWorkflows(projectPath);
+        return Object.keys(merged.workflows);
+    }
+    validateWorkflowInternal(workflow) {
+        if (!workflow.name) {
+            throw new Error('Workflow must have a name');
+        }
+        if (!workflow.steps || workflow.steps.length === 0) {
+            throw new Error('Workflow must have at least one step');
+        }
+        for (const step of workflow.steps) {
+            this.validateStep(step);
+        }
+        this.validateDependencies(workflow.steps);
+        return workflow;
+    }
+    validateStep(step) {
+        if (!step.id) {
+            throw new Error('Step must have an id');
+        }
+        if (!step.mode) {
+            throw new Error(`Step ${step.id} must have a mode`);
+        }
+        const validModes = [
+            'verifier', 'challenger', 'auditor',
+            'scout', 'commit_guardian', 'architect', 'synthesis'
+        ];
+        if (!validModes.includes(step.mode)) {
+            throw new Error(`Invalid mode ${step.mode} in step ${step.id}`);
+        }
+        if (step.maxTokens && step.maxTokens < 100) {
+            throw new Error(`Max tokens too low in step ${step.id}`);
+        }
+        if (step.temperature !== undefined && (step.temperature < 0 || step.temperature > 2)) {
+            throw new Error(`Invalid temperature in step ${step.id}`);
+        }
+    }
+    validateDependencies(steps) {
+        const stepIds = new Set(steps.map(s => s.id));
+        for (const step of steps) {
+            if (step.dependsOn) {
+                for (const dep of step.dependsOn) {
+                    if (!stepIds.has(dep)) {
+                        throw new Error(`Step ${step.id} depends on non-existent step ${dep}`);
+                    }
+                }
+            }
+            if (step.contextFrom) {
+                const stepId = step.contextFrom.split('.')[0];
+                if (!stepIds.has(stepId)) {
+                    throw new Error(`Step ${step.id} references non-existent step ${stepId}`);
+                }
+            }
+        }
+    }
+    expandShorthand(shorthand) {
+        if (typeof shorthand === 'string') {
+            return {
+                id: shorthand,
+                mode: shorthand
+            };
+        }
+        if (typeof shorthand === 'object' && !shorthand.id) {
+            const mode = Object.keys(shorthand)[0];
+            return {
+                id: mode,
+                mode,
+                ...shorthand[mode]
+            };
+        }
+        return shorthand;
+    }
+    mergeWithDefaults(workflow, defaults) {
+        return {
+            ...workflow,
+            defaults: {
+                ...defaults,
+                ...workflow.defaults
+            },
+            steps: workflow.steps.map((step) => ({
+                maxTokens: defaults.maxTokens,
+                temperature: defaults.temperature,
+                ...step
+            }))
+        };
+    }
+}

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

@@ -0,0 +1,95 @@
+/**
+ * Workflow Type Definitions
+ * Extracted from custom-workflows.ts to break circular dependencies
+ */
+import { z } from "zod";
+// ═══════════════════════════════════════════════════════════════════════════
+// Workflow Step Schema
+// ═══════════════════════════════════════════════════════════════════════════
+export const WorkflowStepSchema = z.object({
+    name: z.string(),
+    tool: z.string(), // Tool name or model name
+    input: z
+        .union([
+        z.string(),
+        z.record(z.any()), // Allow any object with any fields
+    ])
+        .optional(),
+    model: z.string().optional(), // Override model selection (supports ${variable})
+    maxTokens: z.union([z.number(), z.string()]).optional(), // Accepts number OR "${variable}"
+    temperature: z.union([z.number(), z.string()]).optional(), // Accepts number OR "${variable}"
+    condition: z
+        .object({
+        if: z.string().optional(), // Condition expression
+        skip: z.boolean().optional(),
+        failOnError: z.boolean().optional(),
+    })
+        .optional(),
+    parallel: z.boolean().optional(), // Run in parallel with next step
+    dependsOn: z.array(z.string()).optional(), // Step dependencies for parallel execution
+    retry: z
+        .object({
+        attempts: z.number().default(3),
+        backoff: z.number().default(1000),
+    })
+        .optional(),
+    output: z
+        .object({
+        save: z.boolean().optional(),
+        format: z.enum(["text", "json", "markdown"]).optional(),
+        variable: z.string().optional(), // Save to variable for later use
+    })
+        .optional(),
+    saveToFile: z.boolean().optional(), // Save step output to file
+    loadFiles: z.array(z.string()).optional(), // Load previous step files
+    promptTechnique: z.string().optional(), // Prompt engineering technique to apply
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// Complete Workflow Schema
+// ═══════════════════════════════════════════════════════════════════════════
+export const WorkflowSchema = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    version: z.string().default("1.0"),
+    // Global settings
+    settings: z
+        .object({
+        maxCost: z.number().optional(), // Max cost in dollars
+        maxTime: z.number().optional(), // Max time in seconds
+        defaultModel: z.string().optional(),
+        optimization: z
+            .object({
+            enabled: z.boolean().default(true),
+            cacheResults: z.boolean().default(true),
+            compressPrompts: z.boolean().default(true),
+            smartRouting: z.boolean().default(true),
+        })
+            .optional(),
+        autoSynthesis: z
+            .object({
+            enabled: z.boolean().default(false),
+            tokenThreshold: z.number().optional(),
+            synthesisTool: z.string().optional(),
+            synthesisMaxTokens: z.number().optional(),
+            checkpointInterval: z.number().optional(),
+            maxRetries: z.number().optional(),
+            logLevel: z.enum(['silent', 'error', 'info']).optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    // Variables that can be used in steps
+    variables: z.record(z.any()).optional(),
+    // The workflow steps
+    steps: z.array(WorkflowStepSchema),
+    // Post-processing
+    output: z
+        .object({
+        format: z.enum(["summary", "detailed", "json"]).default("summary"),
+        saveToFile: z.string().optional(),
+        notifications: z.array(z.string()).optional(),
+        truncateSteps: z.boolean().optional(),
+        maxStepTokens: z.number().optional(),
+    })
+        .optional(),
+});