tachibot-mcp 2.0.2

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

@@ -0,0 +1,123 @@
+/**
+ * Variable Interpolation Utility
+ * Handles ${variable} and ${step.output} syntax in workflow templates
+ */
+export class VariableInterpolator {
+    /**
+     * 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');
+    }
+    /**
+     * Interpolates variables and step outputs in template strings
+     */
+    async interpolate(template, context) {
+        const mergedContext = {
+            ...context.variables,
+            ...Object.fromEntries(context.fileReferences)
+        };
+        // Collect all variable references
+        const matches = [...template.matchAll(/\${([^}]+)}/g)];
+        // Resolve each variable (possibly async)
+        const replacements = await Promise.all(matches.map(async (match) => {
+            const fullMatch = match[0];
+            const key = match[1];
+            let value;
+            // Check for property access (e.g., step.content, step.summary)
+            const parts = key.split('.');
+            const baseKey = parts[0];
+            const property = parts[1];
+            // Get base value
+            value = mergedContext[baseKey];
+            // Support ${step-name.output} syntax
+            if (value === undefined && baseKey.endsWith('.output')) {
+                const stepName = baseKey.slice(0, -7);
+                if (mergedContext[stepName] !== undefined) {
+                    value = mergedContext[stepName];
+                    console.error(`🔄 Resolved ${baseKey} → ${stepName}`);
+                }
+            }
+            // Handle undefined
+            if (value === undefined) {
+                const available = Object.keys(mergedContext).join(', ');
+                throw new Error(`Variable '${key}' not found!\n` +
+                    `Available: [${available}]\n` +
+                    `Check previous step's output.variable setting.`);
+            }
+            // Handle FileReference objects
+            if (this.isFileReference(value)) {
+                if (!property || property === 'summary') {
+                    // Default: return summary
+                    console.error(`✓ Interpolated '${key}': using summary (${value.summary.length} chars)`);
+                    return { match: fullMatch, replacement: value.summary };
+                }
+                else if (property === 'content') {
+                    // Explicit: load full content
+                    const content = await value.getContent();
+                    console.error(`✓ Interpolated '${key}': loaded content (${content.length} chars)`);
+                    return { match: fullMatch, replacement: content };
+                }
+                else if (property === 'filePath') {
+                    // Return file path
+                    const path = value.filePath || 'in-memory';
+                    console.error(`✓ Interpolated '${key}': filePath = ${path}`);
+                    return { match: fullMatch, replacement: path };
+                }
+                else if (property === 'savedTo') {
+                    // Return filename
+                    const filename = value.filePath ? value.filePath.split('/').pop() || 'in-memory' : 'in-memory';
+                    console.error(`✓ Interpolated '${key}': savedTo = ${filename}`);
+                    return { match: fullMatch, replacement: filename };
+                }
+                else if (property === 'output') {
+                    // Handle ${step.output} by returning summary
+                    console.error(`✓ Interpolated '${key}': using summary (${value.summary.length} chars)`);
+                    return { match: fullMatch, replacement: value.summary };
+                }
+                else {
+                    throw new Error(`Unknown FileReference property: ${property}`);
+                }
+            }
+            // Handle primitive values
+            console.error(`✓ Interpolated '${key}': type=${typeof value}, length=${String(value).length}`);
+            return { match: fullMatch, replacement: String(value) };
+        }));
+        // Apply all replacements
+        let result = template;
+        for (const { match, replacement } of replacements) {
+            result = result.replace(match, replacement);
+        }
+        return result;
+    }
+    /**
+     * Interpolates variables in an object (recursive)
+     */
+    async interpolateObject(obj, context) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'string') {
+                result[key] = await this.interpolate(value, context);
+            }
+            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                result[key] = await this.interpolateObject(value, context);
+            }
+            else if (Array.isArray(value)) {
+                result[key] = await Promise.all(value.map(item => typeof item === 'string'
+                    ? this.interpolate(item, context)
+                    : typeof item === 'object' && item !== null
+                        ? this.interpolateObject(item, context)
+                        : item));
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,125 @@
+/**
+ * Workflow Discovery
+ * Handles loading workflows from filesystem (built-in, user, project locations)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as yaml from 'yaml';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+export class WorkflowDiscovery {
+    constructor(options) {
+        this.workflows = new Map();
+        this.validationErrors = [];
+        this.options = options;
+    }
+    /**
+     * Load workflows from all discovery locations
+     * Priority: Built-in → User → Project (later overrides earlier)
+     */
+    discoverWorkflows() {
+        const configDirs = [
+            // Priority 1: Built-in workflows (shipped with package)
+            {
+                path: path.join(this.options.packageRoot, 'workflows'),
+                label: 'Built-in',
+            },
+            // Priority 2: User personal (survives updates)
+            {
+                path: path.join(os.homedir(), '.config', 'tachibot', 'workflows'),
+                label: 'User',
+            },
+            // Priority 3: Project-specific (git-committed, team-shared)
+            {
+                path: path.join(process.cwd(), '.tachibot', 'workflows'),
+                label: 'Project',
+            },
+        ];
+        for (const { path: dir, label } of configDirs) {
+            if (!fs.existsSync(dir)) {
+                console.error(`📂 [${label}] Skipping: ${dir} (not found)`);
+                continue;
+            }
+            console.error(`📂 [${label}] Loading workflows from: ${dir}`);
+            this.loadWorkflowsFromDirectory(dir, label, 0);
+        }
+        console.error(`✅ Total workflows loaded: ${this.workflows.size}`);
+        return {
+            workflows: this.workflows,
+            errors: this.validationErrors
+        };
+    }
+    /**
+     * Recursively load workflows from directory (max 4 levels deep)
+     */
+    loadWorkflowsFromDirectory(dir, source, depth, maxDepth = 4) {
+        if (depth >= maxDepth) {
+            console.error(`⚠️  [${source}] Max depth (${maxDepth}) reached in: ${dir}`);
+            return;
+        }
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Recurse into subdirectories
+                this.loadWorkflowsFromDirectory(fullPath, source, depth + 1, maxDepth);
+            }
+            else if (entry.isFile() && entry.name.match(/\.(yaml|yml|json)$/)) {
+                try {
+                    const content = fs.readFileSync(fullPath, 'utf-8');
+                    const data = entry.name.endsWith('.json')
+                        ? JSON.parse(content)
+                        : yaml.parse(content);
+                    const variables = data.variables || {};
+                    const preprocessed = this.options.preprocessVariables(data, variables);
+                    const workflow = this.options.workflowSchema.parse(preprocessed);
+                    // Later sources override earlier ones (Project > User > Built-in)
+                    if (this.workflows.has(workflow.name)) {
+                        console.error(`🔄 [${source}] Overriding: ${workflow.name}`);
+                    }
+                    this.workflows.set(workflow.name, workflow);
+                    console.error(`✅ [${source}] Loaded: ${workflow.name} from ${entry.name}`);
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    this.validationErrors.push({
+                        file: entry.name,
+                        source,
+                        error: errorMsg,
+                    });
+                    console.error(`❌ [${source}] Failed to load ${entry.name}:`, error);
+                }
+            }
+        }
+    }
+    /**
+     * Load workflow from arbitrary file path
+     */
+    loadWorkflowFile(filePath) {
+        // Resolve relative paths
+        const resolvedPath = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(process.cwd(), filePath);
+        if (!fs.existsSync(resolvedPath)) {
+            throw new Error(`Workflow file not found: ${resolvedPath}`);
+        }
+        const content = fs.readFileSync(resolvedPath, 'utf-8');
+        const data = resolvedPath.endsWith('.json')
+            ? JSON.parse(content)
+            : yaml.parse(content);
+        const variables = data.variables || {};
+        const preprocessed = this.options.preprocessVariables(data, variables);
+        const workflow = this.options.workflowSchema.parse(preprocessed);
+        return workflow;
+    }
+    /**
+     * Get package root from import.meta.url
+     */
+    static getPackageRoot() {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // Up to tachibot-mcp/ (dist/src/workflows/engine -> dist/src/workflows -> dist/src -> dist -> root)
+        return path.join(__dirname, '..', '..', '..', '..');
+    }
+}