@zerowidth/workbench-sdk 2.0.0-alpha.0

package/nodes/yaml-to-json/yaml-to-json.config.json

@@ -0,0 +1,36 @@
+{
+  "display_name": "YAML to JSON",
+  "tagline": "Convert YAML to JSON",
+  "description": "Parses a YAML string into a JSON object.",
+  "icon": "file-code",
+  "category": "data",
+  "inputs": [
+    {
+      "name": "yaml",
+      "display_name": "YAML",
+      "type": "string",
+      "description": "The YAML string to parse",
+      "required": true
+    }
+  ],
+  "outputs": [
+    {
+      "name": "json",
+      "display_name": "JSON",
+      "type": "any",
+      "description": "The parsed JSON object"
+    },
+    {
+      "name": "success",
+      "display_name": "Success",
+      "type": "boolean",
+      "description": "Whether parsing succeeded"
+    },
+    {
+      "name": "error",
+      "display_name": "Error",
+      "type": "string",
+      "description": "Error message if parsing failed"
+    }
+  ]
+}

package/nodes/yaml-to-json/yaml-to-json.process.js

@@ -0,0 +1,178 @@
+export default async ({ inputs, settings, config }) => {
+  const yaml = inputs.yaml;
+
+  if (typeof yaml !== "string") {
+    return { json: null, success: false, error: "Input must be a string" };
+  }
+
+  if (yaml.trim() === "") {
+    return { json: null, success: true, error: null };
+  }
+
+  try {
+    const result = parseYaml(yaml);
+    return { json: result, success: true, error: null };
+  } catch (e) {
+    return { json: null, success: false, error: e.message };
+  }
+};
+
+function parseYaml(yaml) {
+  const lines = yaml.split("\n");
+  let index = 0;
+
+  function getIndent(line) {
+    const match = line.match(/^(\s*)/);
+    return match ? match[1].length : 0;
+  }
+
+  function parseValue(value) {
+    value = value.trim();
+
+    if (value === "" || value === "null" || value === "~") return null;
+    if (value === "true") return true;
+    if (value === "false") return false;
+
+    // Quoted string
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      return value.slice(1, -1).replace(/\\n/g, "\n").replace(/\\"/g, '"');
+    }
+
+    // Number
+    if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+    if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+
+    // Empty object/array
+    if (value === "{}") return {};
+    if (value === "[]") return [];
+
+    return value;
+  }
+
+  function parseBlock(minIndent) {
+    const result = {};
+    let isArray = null;
+    const arrayResult = [];
+
+    while (index < lines.length) {
+      const line = lines[index];
+
+      // Skip empty lines and comments
+      if (line.trim() === "" || line.trim().startsWith("#")) {
+        index++;
+        continue;
+      }
+
+      const indent = getIndent(line);
+
+      // If we've dedented, we're done with this block
+      if (indent < minIndent) {
+        break;
+      }
+
+      const trimmed = line.trim();
+
+      // Array item
+      if (trimmed.startsWith("- ")) {
+        if (isArray === false) throw new Error("Mixed array and object syntax");
+        isArray = true;
+
+        const content = trimmed.slice(2);
+
+        // Check if it's a key-value on same line as dash
+        if (content.includes(": ")) {
+          const colonPos = content.indexOf(": ");
+          const key = content.slice(0, colonPos);
+          const value = content.slice(colonPos + 2);
+
+          index++;
+          const childIndent = indent + 2;
+
+          // Check if there are more keys at the child indent level
+          const obj = { [key]: parseValue(value) };
+
+          while (index < lines.length) {
+            const nextLine = lines[index];
+            if (nextLine.trim() === "" || nextLine.trim().startsWith("#")) {
+              index++;
+              continue;
+            }
+            const nextIndent = getIndent(nextLine);
+            if (nextIndent < childIndent || nextLine.trim().startsWith("- ")) {
+              break;
+            }
+            if (nextIndent === childIndent) {
+              const nextTrimmed = nextLine.trim();
+              if (nextTrimmed.includes(": ")) {
+                const nextColonPos = nextTrimmed.indexOf(": ");
+                const nextKey = nextTrimmed.slice(0, nextColonPos);
+                const nextValue = nextTrimmed.slice(nextColonPos + 2);
+                obj[nextKey] = parseValue(nextValue);
+                index++;
+              } else {
+                break;
+              }
+            } else {
+              break;
+            }
+          }
+
+          arrayResult.push(obj);
+        } else {
+          index++;
+          arrayResult.push(parseValue(content));
+        }
+        continue;
+      }
+
+      // Key-value pair
+      if (trimmed.includes(": ")) {
+        if (isArray === true) throw new Error("Mixed array and object syntax");
+        isArray = false;
+
+        const colonPos = trimmed.indexOf(": ");
+        const key = trimmed.slice(0, colonPos);
+        const value = trimmed.slice(colonPos + 2);
+
+        index++;
+
+        if (value === "" || value === "|" || value === ">") {
+          // Nested block
+          const nextIndent = index < lines.length ? getIndent(lines[index]) : indent;
+          if (nextIndent > indent && index < lines.length && !lines[index].trim().startsWith("#")) {
+            result[key] = parseBlock(nextIndent);
+          } else {
+            result[key] = null;
+          }
+        } else {
+          result[key] = parseValue(value);
+        }
+        continue;
+      }
+
+      // Key without value (nested object follows)
+      if (trimmed.endsWith(":")) {
+        if (isArray === true) throw new Error("Mixed array and object syntax");
+        isArray = false;
+
+        const key = trimmed.slice(0, -1);
+        index++;
+
+        const nextIndent = index < lines.length ? getIndent(lines[index]) : indent;
+        if (nextIndent > indent) {
+          result[key] = parseBlock(nextIndent);
+        } else {
+          result[key] = null;
+        }
+        continue;
+      }
+
+      index++;
+    }
+
+    return isArray ? arrayResult : result;
+  }
+
+  return parseBlock(0);
+}

package/nodes/yaml-to-json/yaml-to-json.tests.json

@@ -0,0 +1,112 @@
+[
+  {
+    "description": "Parse simple object",
+    "inputs": {
+      "yaml": "name: Alice\nage: 30"
+    },
+    "expected": {
+      "json": {"name": "Alice", "age": 30},
+      "success": true,
+      "error": null
+    }
+  },
+  {
+    "description": "Parse nested object",
+    "inputs": {
+      "yaml": "user:\n  name: Bob\n  active: true"
+    },
+    "expected": {
+      "json": {"user": {"name": "Bob", "active": true}},
+      "success": true,
+      "error": null
+    }
+  },
+  {
+    "description": "Parse array of primitives",
+    "inputs": {
+      "yaml": "tags:\n  - a\n  - b\n  - c"
+    },
+    "expected": {
+      "json": {"tags": ["a", "b", "c"]},
+      "success": true,
+      "error": null
+    }
+  },
+  {
+    "description": "Parse array of objects",
+    "inputs": {
+      "yaml": "users:\n  - name: Alice\n  - name: Bob"
+    },
+    "expected": {
+      "json": {"users": [{"name": "Alice"}, {"name": "Bob"}]},
+      "success": true,
+      "error": null
+    }
+  },
+  {
+    "description": "Parse boolean values",
+    "inputs": {
+      "yaml": "enabled: true\ndebug: false"
+    },
+    "expected": {
+      "json": {"enabled": true, "debug": false},
+      "success": true,
+      "error": null
+    }
+  },
+  {
+    "description": "Parse null value",
+    "inputs": {
+      "yaml": "value: null"
+    },
+    "expected": {
+      "json": {"value": null},
+      "success": true,
+      "error": null
+    }
+  },
+  {
+    "description": "Parse numeric values",
+    "inputs": {
+      "yaml": "count: 42\nprice: 19.99"
+    },
+    "expected": {
+      "json": {"count": 42, "price": 19.99},
+      "success": true,
+      "error": null
+    }
+  },
+  {
+    "description": "Parse quoted string",
+    "inputs": {
+      "yaml": "url: \"http://example.com\""
+    },
+    "expected": {
+      "json": {"url": "http://example.com"},
+      "success": true,
+      "error": null
+    }
+  },
+  {
+    "description": "Parse empty object",
+    "inputs": {
+      "yaml": "{}"
+    },
+    "expected": {
+      "json": {},
+      "success": true,
+      "error": null
+    }
+  },
+  {
+    "description": "Handle empty string",
+    "inputs": {
+      "yaml": ""
+    },
+    "expected": {
+      "json": null,
+      "success": true,
+      "error": null
+    }
+  }
+]

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@zerowidth/workbench-sdk",
+  "version": "2.0.0-alpha.0",
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "ajv": "^8.17.1",
+    "axios": "^1.9.0",
+    "js-tiktoken": "^1.0.21",
+    "openai": "^4.92.1",
+    "sqlite-vec": "^0.1.7-alpha.2",
+    "sqlite3": "^5.1.7",
+    "tiktoken": "^1.0.22",
+    "uuid": "^11.1.0"
+  },
+  "repository": "https://github.com/zerowidth-ai/workbench-sdk",
+  "description": "Workbench SDK — execute Workbench-authored flows in production. Successor to the zv1 package; see https://zerowidth.ai for the design surface.",
+  "main": "./src/index.js",
+  "files": ["src/", "nodes/", "types/", "LICENSE", "README.md"],
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "devDependencies": {
+    "dotenv": "^17.2.2"
+  },
+  "scripts": {
+    "test-nodes": "node tests/test.all-nodes.js",
+    "test-flows": "node tests/test.flows.js",
+    "test-flow": "node tests/test.flows.js"
+  },
+  "author": "Peter Binggeser @ ZeroWidth, LLC",
+  "license": "Apache-2.0",
+  "type": "module"
+}

package/src/classes/ErrorManager.js

@@ -0,0 +1,234 @@
+/**
+ * ErrorManager - Centralized error handling utility for the FlowEngine
+ * 
+ * This utility handles:
+ * - Creating consistent error structures
+ * - Invoking onError callbacks
+ * - Enriching errors with execution context
+ * - Managing error types and severity levels
+ */
+
+export default class ErrorManager {
+  constructor(options = {}) {
+    this.onError = options.onError || null;
+    this.executionId = options.executionId;
+    this.executionContext = options.executionContext || {};
+  }
+
+  /**
+   * Main method to throw errors with full context
+   * @param {string} errorType - Type of error ('node', 'flow', 'system', etc.)
+   * @param {Object} errorDetails - Specific details about the error
+   * @param {Error} originalError - Original error object if one exists
+   */
+  throwError(errorType, errorDetails, originalError = null) {
+    const errorEvent = this.createErrorEvent(errorType, errorDetails, originalError);
+    
+    // Invoke callback if provided
+    if (this.onError) {
+      try {
+        this.onError(errorEvent);
+      } catch (callbackError) {
+        // Don't let callback errors interfere with main error
+        console.warn('Error in onError callback:', callbackError);
+      }
+    }
+    
+    // Create and throw the enriched error
+    const enrichedError = this.createEnrichedError(errorEvent);
+    throw enrichedError;
+  }
+
+  /**
+   * Create the error event structure for callbacks
+   * @param {string} errorType - Type of error
+   * @param {Object} errorDetails - Error details
+   * @param {Error} originalError - Original error
+   * @returns {Object} Formatted error event
+   */
+  createErrorEvent(errorType, errorDetails, originalError) {
+    const baseEvent = {
+      event: 'error',
+      type: errorType,
+      error: originalError || new Error(errorDetails.message || 'Unknown error'),
+      errorDetails: {
+        ...errorDetails,
+        timestamp: Date.now(),
+        executionId: this.executionId
+      },
+      executionId: this.executionId
+    };
+
+    baseEvent.context = {
+      ...this.executionContext,
+      // Will include timeline, nodeEvents, etc. when available
+    };
+
+    return baseEvent;
+  }
+
+  /**
+   * Create the actual Error object to throw
+   * @param {Object} errorEvent - The error event structure
+   * @returns {Error} Enriched error object
+   */
+  createEnrichedError(errorEvent) {
+    const { error, errorDetails, type } = errorEvent;
+    
+    // If we have an original error, enhance it
+    if (error instanceof Error) {
+      // Add custom properties
+      error.errorType = type;
+      error.errorDetails = errorDetails;
+      error.executionId = this.executionId;
+      
+      // Enhance the message if needed
+      if (errorDetails.message && error.message !== errorDetails.message) {
+        error.originalMessage = error.message;
+        error.message = errorDetails.message;
+      }
+
+      error.context = this.executionContext;
+      
+      return error;
+    }
+    
+    // Create new error if none provided
+    const newError = new Error(errorDetails.message || 'Flow execution error');
+    newError.errorType = type;
+    newError.errorDetails = errorDetails;
+    newError.executionId = this.executionId;
+    newError.context = this.executionContext;
+    
+    return newError;
+  }
+
+  /**
+   * Update execution context (called during flow execution)
+   * @param {Object} context - New execution context
+   */
+  updateExecutionContext(context) {
+    this.executionContext = {
+      ...this.executionContext,
+      ...context
+    };
+  }
+
+  // Convenience methods for common error types
+  /**
+   * Throw a node-specific error
+   * @param {string} nodeId - ID of the node that failed
+   * @param {string} nodeType - Type of the node
+   * @param {string} message - Error message
+   * @param {Error} originalError - Original error if one exists
+   */
+  throwNodeError(nodeId, nodeType, message, originalError = null) {
+    return this.throwError('node', {
+      nodeId,
+      nodeType,
+      message,
+      severity: 'recoverable' // Most node errors are recoverable
+    }, originalError);
+  }
+
+  /**
+   * Throw a flow-level error
+   * @param {string} message - Error message
+   * @param {Error} originalError - Original error if one exists
+   */
+  throwFlowError(message, originalError = null) {
+    return this.throwError('flow', {
+      message,
+      severity: 'fatal' // Flow errors are usually fatal
+    }, originalError);
+  }
+
+  /**
+   * Throw a system-level error
+   * @param {string} message - Error message
+   * @param {Error} originalError - Original error if one exists
+   */
+  throwSystemError(message, originalError = null) {
+    return this.throwError('system', {
+      message,
+      severity: 'fatal'
+    }, originalError);
+  }
+
+  /**
+   * Throw a validation error
+   * @param {string} field - Field that failed validation
+   * @param {string} message - Validation error message
+   * @param {Error} originalError - Original error if one exists
+   */
+  throwValidationError(field, message, originalError = null) {
+    return this.throwError('validation', {
+      field,
+      message,
+      severity: 'fatal'
+    }, originalError);
+  }
+
+  /**
+   * Throw a timeout error
+   * @param {string} message - Timeout error message
+   */
+  throwTimeoutError(message = 'Flow execution timed out') {
+    return this.throwError('timeout', {
+      message,
+      severity: 'fatal',
+      timeout: this.executionContext.timeout
+    });
+  }
+
+  /**
+   * Throw a resource exhaustion error
+   * @param {string} resourceType - Type of resource that was exhausted
+   * @param {string} message - Error message
+   */
+  throwResourceError(resourceType, message) {
+    return this.throwError('resource', {
+      resourceType,
+      message,
+      severity: 'fatal'
+    });
+  }
+
+  /**
+   * Create an error event without throwing (useful for logging/monitoring)
+   * @param {string} errorType - Type of error
+   * @param {Object} errorDetails - Error details
+   * @param {Error} originalError - Original error if one exists
+   * @returns {Object} Error event object
+   */
+  createErrorEventOnly(errorType, errorDetails, originalError = null) {
+    const errorEvent = this.createErrorEvent(errorType, errorDetails, originalError);
+    
+    // Invoke callback if provided
+    if (this.onError) {
+      try {
+        this.onError(errorEvent);
+      } catch (callbackError) {
+        console.warn('Error in onError callback:', callbackError);
+      }
+    }
+    
+    return errorEvent;
+  }
+
+  /**
+   * Check if an error is recoverable based on its type
+   * @param {string} errorType - Type of error
+   * @returns {boolean} True if error is recoverable
+   */
+  isRecoverableError(errorType) {
+    const recoverableTypes = ['node', 'validation'];
+    const fatalTypes = ['flow', 'system', 'timeout', 'resource'];
+    
+    if (recoverableTypes.includes(errorType)) return true;
+    if (fatalTypes.includes(errorType)) return false;
+    
+    // Default to recoverable for unknown types
+    return true;
+  }
+}