@positronic/core 0.0.1 → 0.0.2

package/dist/src/dsl/constants.js

@@ -1,13 +1,13 @@
-export const WORKFLOW_EVENTS = {
-    START: 'workflow:start',
-    RESTART: 'workflow:restart',
+export var BRAIN_EVENTS = {
+    START: 'brain:start',
+    RESTART: 'brain:restart',
     STEP_START: 'step:start',
     STEP_COMPLETE: 'step:complete',
     STEP_STATUS: 'step:status',
-    ERROR: 'workflow:error',
-    COMPLETE: 'workflow:complete'
+    ERROR: 'brain:error',
+    COMPLETE: 'brain:complete'
 };
-export const STATUS = {
+export var STATUS = {
     PENDING: 'pending',
     RUNNING: 'running',
     COMPLETE: 'complete',

package/dist/src/dsl/json-patch.js

@@ -1,30 +1,58 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
 import pkg from 'fast-json-patch';
-const { compare, applyPatch } = pkg;
+var compare = pkg.compare, applyPatch = pkg.applyPatch;
 /**
  * Creates a JSON Patch that describes the changes needed to transform prevState into nextState.
  */ export function createPatch(prevState, nextState) {
     // Filter out non-standard operations and ensure type safety
-    return compare(prevState, nextState).filter((op)=>[
+    return compare(prevState, nextState).filter(function(op) {
+        return [
             'add',
             'remove',
             'replace',
             'move',
             'copy',
             'test'
-        ].includes(op.op));
+        ].includes(op.op);
+    });
 }
 /**
  * Applies one or more JSON Patches to a state object and returns the resulting state.
  * If multiple patches are provided, they are applied in sequence.
  */ export function applyPatches(state, patches) {
-    const patchArray = Array.isArray(patches[0]) ? patches : [
+    var patchArray = Array.isArray(patches[0]) ? patches : [
         patches
     ];
     // Apply patches in sequence, creating a new state object each time
-    return patchArray.reduce((currentState, patch)=>{
-        const { newDocument } = applyPatch(currentState, patch, true, false);
+    return patchArray.reduce(function(currentState, patch) {
+        var newDocument = applyPatch(currentState, patch, true, false).newDocument;
         return newDocument;
-    }, {
-        ...state
-    });
+    }, _object_spread({}, state));
 }

package/dist/src/index.js

@@ -1,10 +1,11 @@
-export { Workflow } from "./dsl/workflow.js";
-export { workflow } from "./dsl/workflow.js";
-export { WorkflowRunner } from "./dsl/workflow-runner.js";
-export { createExtension } from "./dsl/extensions.js";
-export { STATUS } from "./dsl/constants.js";
-export { WORKFLOW_EVENTS } from "./dsl/constants.js";
-export { Adapter } from "./adapters/types.js";
-export { createPatch } from "./dsl/json-patch.js";
-export { applyPatches } from "./dsl/json-patch.js";
-export { LocalFileStore } from "./file-stores/local-file-store.js";
+export { Brain, brain } from './dsl/brain.js';
+export { BrainRunner } from './dsl/brain-runner.js';
+export { STATUS, BRAIN_EVENTS } from './dsl/constants.js';
+export { createPatch, applyPatches } from './dsl/json-patch.js';
+// Only needed for development to ensure that zod version numbers are the same, it's a peer
+// dependency so when not using file://..path/to/package links the version numbers
+// will match just fine if the user has the same version of zod installed.
+// NOTE: Not 100% sure this is still needed - worth re-evaluating if we can remove this.
+export { z } from 'zod';
+export { createResources } from './resources/resources.js';
+export { RESOURCE_TYPES } from './resources/resources.js';

package/dist/src/resources/resources.js

@@ -0,0 +1,371 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+// Runtime array of valid resource types
+export var RESOURCE_TYPES = [
+    'text',
+    'binary'
+];
+function isResourceEntry(entry) {
+    return typeof entry.type === 'string';
+}
+export function createResources(loader, initialManifest) {
+    // Helper function to find a resource entry by path in the manifest
+    function findResourceByPath(manifest, path) {
+        var _loop = function(i) {
+            var part = parts[i];
+            if (isResourceEntry(current)) {
+                // We hit a resource entry before consuming all parts
+                return {
+                    v: null
+                };
+            }
+            var currentManifest = current;
+            var next = currentManifest[part];
+            if (!next) {
+                // If exact match not found and this is the last part, try without extension
+                if (i === parts.length - 1) {
+                    var partWithoutExt = part.replace(/\.[^/.]+$/, '');
+                    var currentManifest1 = current; // We know it's a Manifest since we checked isResourceEntry above
+                    var matches = Object.keys(currentManifest1).filter(function(key) {
+                        var keyWithoutExt = key.replace(/\.[^/.]+$/, '');
+                        return keyWithoutExt === partWithoutExt && isResourceEntry(currentManifest1[key]);
+                    });
+                    if (matches.length === 1) {
+                        return {
+                            v: currentManifest1[matches[0]]
+                        };
+                    } else if (matches.length > 1) {
+                        throw new Error("Ambiguous resource path '".concat(path, "': found ").concat(matches.join(', '), ". ") + "Please specify the full filename with extension.");
+                    }
+                }
+                return {
+                    v: null
+                };
+            }
+            if (i === parts.length - 1 && isResourceEntry(next)) {
+                // Found the resource
+                return {
+                    v: next
+                };
+            }
+            current = next;
+        };
+        var parts = path.split('/');
+        var current = manifest;
+        for(var i = 0; i < parts.length; i++){
+            var _ret = _loop(i);
+            if (_type_of(_ret) === "object") return _ret.v;
+        }
+        return null;
+    }
+    function createProxiedResources(manifestNode) {
+        // Create methods that will be shared across all instances
+        var loadText = function(path) {
+            return _async_to_generator(function() {
+                var entry;
+                return _ts_generator(this, function(_state) {
+                    entry = findResourceByPath(manifestNode, path);
+                    if (!entry) {
+                        throw new Error("Resource not found: ".concat(path));
+                    }
+                    if (entry.type !== 'text') {
+                        throw new Error('Resource "'.concat(path, '" is of type "').concat(entry.type, '", but was accessed with loadText().'));
+                    }
+                    return [
+                        2,
+                        loader.load(entry.key, 'text')
+                    ];
+                });
+            })();
+        };
+        var loadBinary = function(path) {
+            return _async_to_generator(function() {
+                var entry;
+                return _ts_generator(this, function(_state) {
+                    entry = findResourceByPath(manifestNode, path);
+                    if (!entry) {
+                        throw new Error("Resource not found: ".concat(path));
+                    }
+                    if (entry.type !== 'binary') {
+                        throw new Error('Resource "'.concat(path, '" is of type "').concat(entry.type, '", but was accessed with loadBinary().'));
+                    }
+                    return [
+                        2,
+                        loader.load(entry.key, 'binary')
+                    ];
+                });
+            })();
+        };
+        var resultProxy = new Proxy({}, {
+            get: function(target, prop, receiver) {
+                if (prop === 'loadText') {
+                    return loadText;
+                }
+                if (prop === 'loadBinary') {
+                    return loadBinary;
+                }
+                // Handle dynamic resource properties
+                if (typeof prop !== 'string') {
+                    return Reflect.get(target, prop, receiver);
+                }
+                // Check if the property exists directly (with extension)
+                if (prop in manifestNode) {
+                    var manifestEntry = manifestNode[prop];
+                    if (isResourceEntry(manifestEntry)) {
+                        var key = manifestEntry.key, type = manifestEntry.type;
+                        var apiObject = {
+                            load: function() {
+                                return manifestEntry.type === 'text' ? loader.load(key, 'text') : loader.load(key, 'binary');
+                            },
+                            loadText: function() {
+                                if (type !== 'text') {
+                                    throw new Error('Resource "'.concat(prop, '" is of type "').concat(type, '", but was accessed with loadText().'));
+                                }
+                                return loader.load(key, 'text');
+                            },
+                            loadBinary: function() {
+                                if (type !== 'binary') {
+                                    throw new Error('Resource "'.concat(prop, '" is of type "').concat(type, '", but was accessed with loadBinary().'));
+                                }
+                                return loader.load(key, 'binary');
+                            }
+                        };
+                        return apiObject;
+                    } else {
+                        // manifestEntry is a nested Manifest
+                        var nestedResources = createProxiedResources(manifestEntry);
+                        return nestedResources;
+                    }
+                }
+                // If not found directly, check for files without extension
+                // Find all keys that match when extension is removed
+                var matches = Object.keys(manifestNode).filter(function(key) {
+                    var keyWithoutExt = key.replace(/\.[^/.]+$/, '');
+                    return keyWithoutExt === prop && isResourceEntry(manifestNode[key]);
+                });
+                if (matches.length === 0) {
+                    // No matches - might be a nested directory
+                    if (prop in manifestNode && !isResourceEntry(manifestNode[prop])) {
+                        return createProxiedResources(manifestNode[prop]);
+                    }
+                    return undefined;
+                }
+                if (matches.length === 1) {
+                    // Single match - return it
+                    var manifestEntry1 = manifestNode[matches[0]];
+                    var key1 = manifestEntry1.key, type1 = manifestEntry1.type;
+                    var apiObject1 = {
+                        load: function() {
+                            return type1 === 'text' ? loader.load(key1, 'text') : loader.load(key1, 'binary');
+                        },
+                        loadText: function() {
+                            if (type1 !== 'text') {
+                                throw new Error('Resource "'.concat(matches[0], '" is of type "').concat(type1, '", but was accessed with loadText().'));
+                            }
+                            return loader.load(key1, 'text');
+                        },
+                        loadBinary: function() {
+                            if (type1 !== 'binary') {
+                                throw new Error('Resource "'.concat(matches[0], '" is of type "').concat(type1, '", but was accessed with loadBinary().'));
+                            }
+                            return loader.load(key1, 'binary');
+                        }
+                    };
+                    return apiObject1;
+                }
+                // Multiple matches - throw helpful error
+                throw new Error("Ambiguous resource name '".concat(prop, "': found ").concat(matches.join(', '), ". ") + "Please use resources.loadText('".concat(matches[0], "') or resources.loadBinary('").concat(matches[1], "') instead."));
+            },
+            has: function(target, prop) {
+                // Check for special methods
+                if (prop === 'loadText' || prop === 'loadBinary') {
+                    return true;
+                }
+                // Then check manifest
+                if (typeof prop === 'string') {
+                    return prop in manifestNode;
+                }
+                return Reflect.has(target, prop);
+            },
+            ownKeys: function(target) {
+                // Combine special methods with manifest keys
+                return [
+                    'loadText',
+                    'loadBinary'
+                ].concat(_to_consumable_array(Object.keys(manifestNode)));
+            },
+            getOwnPropertyDescriptor: function(target, prop) {
+                if (prop === 'loadText' || prop === 'loadBinary') {
+                    return {
+                        value: prop === 'loadText' ? loadText : loadBinary,
+                        writable: false,
+                        enumerable: true,
+                        configurable: true
+                    };
+                }
+                if (typeof prop === 'string' && prop in manifestNode) {
+                    var value = resultProxy[prop];
+                    if (value === undefined) {
+                        return undefined;
+                    }
+                    return {
+                        value: value,
+                        writable: false,
+                        enumerable: true,
+                        configurable: true
+                    };
+                }
+                return Reflect.getOwnPropertyDescriptor(target, prop);
+            }
+        });
+        return resultProxy;
+    }
+    return createProxiedResources(initialManifest);
+}