@alpic80/rivet-core 1.19.1-aidon.3 → 1.24.0-aidon.3

package/dist/esm/model/nodes/ReadDirectoryNode.js

@@ -6,7 +6,8 @@ import {} from '../GraphProcessor.js';
 import {} from '../../index.js';
 import {} from '../ProcessContext.js';
 import { dedent } from 'ts-dedent';
-import { expectType } from '../../utils/expectType.js';
+import { createTreeFromPaths } from '../../utils/paths.js';
+import { getInputOrData } from '../../utils/inputs.js';
 export class ReadDirectoryNodeImpl extends NodeImpl {
     static create() {
         return {
@@ -91,6 +92,11 @@ export class ReadDirectoryNodeImpl extends NodeImpl {
                 title: 'Paths',
                 dataType: 'string[]',
             },
+            {
+                id: 'tree',
+                title: 'Tree',
+                dataType: 'object',
+            },
         ];
     }
     getBody() {
@@ -109,36 +115,27 @@ export class ReadDirectoryNodeImpl extends NodeImpl {
     static getUIData() {
         return {
             infoBoxBody: dedent `
-        Reads the contents of the specified directory and outputs an array of filenames.
+        Reads the contents of the specified directory and outputs:
+        1. An array of filenames
+        2. The root path of the search
+        3. A tree structure representing the directory hierarchy
       `,
             infoBoxTitle: 'Read Directory Node',
             contextMenuTitle: 'Read Directory',
             group: ['Input/Output'],
         };
     }
-    async process(inputData, context) {
+    async process(inputs, context) {
         const { nativeApi } = context;
         if (nativeApi == null) {
             throw new Error('This node requires a native API to run.');
         }
-        const path = this.chartNode.data.usePathInput
-            ? expectType(inputData['path'], 'string')
-            : this.chartNode.data.path;
-        const recursive = this.chartNode.data.useRecursiveInput
-            ? expectType(inputData['recursive'], 'boolean')
-            : this.chartNode.data.recursive;
-        const includeDirectories = this.chartNode.data.useIncludeDirectoriesInput
-            ? expectType(inputData['includeDirectories'], 'boolean')
-            : this.chartNode.data.includeDirectories;
-        const filterGlobs = this.chartNode.data.useFilterGlobsInput
-            ? expectType(inputData['filterGlobs'], 'string[]')
-            : this.chartNode.data.filterGlobs;
-        const relative = this.chartNode.data.useRelativeInput
-            ? expectType(inputData['relative'], 'boolean')
-            : this.chartNode.data.relative;
-        const ignores = this.chartNode.data.useIgnoresInput
-            ? expectType(inputData['ignores'], 'string[]')
-            : this.chartNode.data.ignores;
+        const path = getInputOrData(this.data, inputs, 'path');
+        const recursive = getInputOrData(this.data, inputs, 'recursive', 'boolean');
+        const includeDirectories = getInputOrData(this.data, inputs, 'includeDirectories', 'boolean');
+        const filterGlobs = getInputOrData(this.data, inputs, 'filterGlobs', 'string[]');
+        const relative = getInputOrData(this.data, inputs, 'relative', 'boolean');
+        const ignores = getInputOrData(this.data, inputs, 'ignores', 'string[]');
         try {
             const files = await nativeApi.readdir(path, undefined, {
                 recursive,
@@ -147,18 +144,27 @@ export class ReadDirectoryNodeImpl extends NodeImpl {
                 relative,
                 ignores,
             });
-            const outputs = {
+            const tree = createTreeFromPaths(files, path);
+            return {
                 ['paths']: { type: 'string[]', value: files },
                 ['rootPath']: { type: 'string', value: path },
+                ['tree']: { type: 'object', value: tree },
             };
-            return outputs;
         }
         catch (err) {
-            const outputs = {
+            return {
                 ['paths']: { type: 'string[]', value: ['(no such path)'] },
                 ['rootPath']: { type: 'string', value: path },
+                ['tree']: {
+                    type: 'object',
+                    value: {
+                        path,
+                        name: path.split('/').pop() || path,
+                        isDirectory: true,
+                        children: [],
+                    },
+                },
             };
-            return outputs;
         }
     }
 }

package/dist/esm/model/nodes/ReferencedGraphAliasNode.js

@@ -0,0 +1,199 @@
+import {} from '../NodeBase.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.js';
+import {} from '../NodeGraph.js';
+import { nanoid } from 'nanoid/non-secure';
+import {} from '../Project.js';
+import {} from './GraphInputNode.js';
+import {} from './GraphOutputNode.js';
+import {} from '../DataValue.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import { getError } from '../../utils/errors.js';
+export class ReferencedGraphAliasNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'referencedGraphAlias',
+            title: '', // Always set initially by the editor
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+            data: {
+                projectId: undefined, // Always set initially by the editor
+                graphId: undefined, // Always set initially by the editor
+                useErrorOutput: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions(_connections, _nodes, _project, referencedProjects) {
+        const referencedProject = referencedProjects[this.data.projectId];
+        if (!referencedProject) {
+            return [];
+        }
+        const graph = referencedProject.graphs[this.data.graphId];
+        if (!graph) {
+            return [];
+        }
+        const inputNodes = graph.nodes.filter((node) => node.type === 'graphInput');
+        const inputIds = [...new Set(inputNodes.map((node) => node.data.id))].sort();
+        return inputIds.map((id) => ({
+            id: id,
+            title: id,
+            dataType: inputNodes.find((node) => node.data.id === id).data.dataType,
+        }));
+    }
+    getGraphOutputs(referencedProject) {
+        const graph = referencedProject.graphs[this.data.graphId];
+        if (!graph) {
+            return [];
+        }
+        const outputNodes = graph.nodes.filter((node) => node.type === 'graphOutput');
+        const outputIds = [...new Set(outputNodes.map((node) => node.data.id))].sort();
+        const outputs = outputIds.map((id) => ({
+            id: id,
+            title: id,
+            dataType: outputNodes.find((node) => node.data.id === id).data.dataType,
+        }));
+        return outputs;
+    }
+    getOutputDefinitions(_connections, _nodes, _project, referencedProjects) {
+        const outputs = [];
+        const referencedProject = referencedProjects[this.data.projectId];
+        if (!referencedProject) {
+            return outputs;
+        }
+        outputs.push(...this.getGraphOutputs(referencedProject));
+        if (this.data.useErrorOutput) {
+            outputs.push({
+                id: 'error',
+                title: 'Error',
+                dataType: 'string',
+            });
+        }
+        return outputs;
+    }
+    getEditors(context) {
+        const definitions = [
+            {
+                type: 'toggle',
+                label: 'Use Error Output',
+                dataKey: 'useErrorOutput',
+            },
+            {
+                type: 'toggle',
+                label: 'Output Cost & Duration',
+                dataKey: 'outputCostDuration',
+            },
+        ];
+        const referencedProject = context.referencedProjects[this.data.projectId];
+        if (referencedProject) {
+            const graph = referencedProject.graphs[this.data.graphId];
+            if (graph) {
+                const inputNodes = graph.nodes.filter((node) => node.type === 'graphInput');
+                const inputIds = [...new Set(inputNodes.map((node) => node.data.id))].sort();
+                for (const inputId of inputIds) {
+                    const inputNode = inputNodes.find((node) => node.data.id === inputId);
+                    definitions.push({
+                        type: 'dynamic',
+                        dataKey: 'inputData',
+                        dynamicDataKey: inputNode.data.id,
+                        dataType: inputNode.data.dataType,
+                        label: inputNode.data.id,
+                        editor: inputNode.data.editor ?? 'auto',
+                    });
+                }
+            }
+        }
+        return definitions;
+    }
+    getBody(context) {
+        return context.referencedProjects[this.data.projectId]?.graphs[this.data.graphId]?.metadata?.description ?? '';
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        References a graph from another project. Inputs and outputs are defined by Graph Input and Graph Output nodes within the referenced graph.
+      `,
+            infoBoxTitle: 'Referenced Graph Alias Node',
+            contextMenuTitle: 'Referenced Graph Alias',
+            group: ['Advanced'],
+        };
+    }
+    async process(inputs, context) {
+        const referencedProject = context.referencedProjects[this.data.projectId];
+        if (!referencedProject) {
+            throw new Error(`ReferencedGraphAliasNode requires a project with id ${this.data.projectId} to be available in the context.referencedProjects.`);
+        }
+        const graph = referencedProject.graphs[this.data.graphId];
+        if (!graph) {
+            throw new Error(`ReferencedGraphAliasNode requires a graph with id ${this.data.graphId} to be present in the referenced project.`);
+        }
+        const inputNodes = graph.nodes.filter((node) => node.type === 'graphInput');
+        const inputIds = [...new Set(inputNodes.map((node) => node.data.id))].sort();
+        const inputData = inputIds.reduce((obj, id) => {
+            if (inputs[id] != null) {
+                return {
+                    ...obj,
+                    [id]: inputs[id],
+                };
+            }
+            if (this.data.inputData?.[id] != null) {
+                return {
+                    ...obj,
+                    [id]: this.data.inputData[id],
+                };
+            }
+            return obj;
+        }, {});
+        // Create a subprocessor using the referenced project's graph
+        const subGraphProcessor = context.createSubProcessor(this.data.graphId, {
+            signal: context.signal,
+            project: referencedProject,
+        });
+        try {
+            const startTime = Date.now();
+            const outputs = await subGraphProcessor.processGraph(context, inputData, context.contextValues);
+            const duration = Date.now() - startTime;
+            if (this.data.useErrorOutput) {
+                outputs['error'] = {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                };
+            }
+            if (outputs['duration'] == null) {
+                outputs['duration'] = {
+                    type: 'number',
+                    value: duration,
+                };
+            }
+            if (!this.data.outputCostDuration) {
+                delete outputs['cost'];
+                delete outputs['duration'];
+            }
+            return outputs;
+        }
+        catch (err) {
+            if (!this.data.useErrorOutput) {
+                throw err;
+            }
+            const outputs = this.getGraphOutputs(referencedProject).reduce((obj, output) => ({
+                ...obj,
+                [output.id]: {
+                    type: 'control-flow-excluded',
+                    value: undefined,
+                },
+            }), {});
+            outputs['error'] = {
+                type: 'string',
+                value: getError(err).message,
+            };
+            return outputs;
+        }
+    }
+}
+export const referencedGraphAliasNode = nodeDefinition(ReferencedGraphAliasNodeImpl, 'Referenced Graph Alias');

package/dist/esm/model/nodes/ReplaceDatasetNode.js

@@ -3,7 +3,7 @@ import { nanoid } from 'nanoid/non-secure';
 import { dedent } from 'ts-dedent';
 import { nodeDefinition } from '../NodeDefinition.js';
 import { getInputOrData, coerceType, newId, inferType } from '../../utils/index.js';
-import { arrayizeDataValue, unwrapDataValue } from '../DataValue.js';
+import { unwrapDataValue } from '../DataValue.js';
 export class ReplaceDatasetNodeImpl extends NodeImpl {
     static create() {
         return {

package/dist/esm/model/nodes/SliceNode.js

@@ -3,7 +3,6 @@ import { nanoid } from 'nanoid/non-secure';
 import { NodeImpl } from '../NodeImpl.js';
 import { nodeDefinition } from '../NodeDefinition.js';
 import {} from '../GraphProcessor.js';
-import { entries } from '../../utils/typeSafety.js';
 import { dedent } from 'ts-dedent';
 import {} from '../EditorDefinition.js';
 import {} from '../../index.js';

package/dist/esm/model/nodes/SplitNode.js

@@ -85,7 +85,7 @@ export class SplitNodeImpl extends NodeImpl {
         }
         return normalized;
     }
-    async process(inputs, context) {
+    async process(inputs) {
         const delimiter = getInputOrData(this.data, inputs, 'delimiter');
         const normalizedDelimiter = this.data.regex ? new RegExp(delimiter) : handleEscapeCharacters(delimiter);
         const stringToSplit = coerceType(inputs['string'], 'string');

package/dist/esm/model/nodes/SubGraphNode.js

@@ -12,7 +12,6 @@ import {} from '../ProcessContext.js';
 import {} from '../../index.js';
 import { dedent } from 'ts-dedent';
 import { getError } from '../../utils/errors.js';
-import { match } from 'ts-pattern';
 export class SubGraphNodeImpl extends NodeImpl {
     static create() {
         const chartNode = {

package/dist/esm/model/nodes/TextNode.js

@@ -6,7 +6,7 @@ import {} from '../DataValue.js';
 import {} from '../../index.js';
 import { dedent } from 'ts-dedent';
 import { coerceTypeOptional } from '../../utils/coerceType.js';
-import { interpolate } from '../../utils/interpolation.js';
+import { extractInterpolationVariables, interpolate } from '../../utils/interpolation.js';
 export class TextNodeImpl extends NodeImpl {
     static create() {
         const chartNode = {
@@ -26,13 +26,13 @@ export class TextNodeImpl extends NodeImpl {
     }
     getInputDefinitions() {
         // Extract inputs from text, everything like {{input}}
-        const inputNames = [...new Set(this.chartNode.data.text.match(/\{\{([^}]+)\}\}/g))];
+        const inputNames = extractInterpolationVariables(this.data.text);
         return (inputNames?.map((inputName) => {
             return {
                 type: 'string',
                 // id and title should not have the {{ and }}
-                id: inputName.slice(2, -2),
-                title: inputName.slice(2, -2),
+                id: inputName,
+                title: inputName,
                 dataType: 'string',
                 required: false,
             };
@@ -49,6 +49,11 @@ export class TextNodeImpl extends NodeImpl {
     }
     getEditors() {
         return [
+            {
+                type: 'custom',
+                label: 'AI Assist',
+                customEditorId: 'TextNodeAiAssist',
+            },
             {
                 type: 'code',
                 label: 'Text',

package/dist/esm/model/nodes/ToMarkdownTableNode.js

@@ -0,0 +1,119 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../GraphProcessor.js';
+import {} from '../../index.js';
+import { dedent } from 'ts-dedent';
+import { coerceType } from '../../utils/coerceType.js';
+export class ToMarkdownTableNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'toMarkdownTable',
+            title: 'To Markdown Table',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 200,
+            },
+            data: {
+                includeHeaders: true,
+                alignPipes: false,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'data',
+                title: 'Data Array',
+                dataType: 'any',
+                required: true,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'markdown',
+                title: 'Markdown Table',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'toggle',
+                label: 'Include Headers',
+                dataKey: 'includeHeaders',
+            },
+            {
+                type: 'toggle',
+                label: 'Align Pipes',
+                dataKey: 'alignPipes',
+            },
+        ];
+    }
+    getBody() {
+        const parts = [];
+        if (this.data.includeHeaders)
+            parts.push('With Header Row');
+        if (this.data.alignPipes)
+            parts.push('Pipes Aligned');
+        return parts.length > 0 ? parts.join(', ') : undefined;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Converts an array of objects into a markdown table format.
+        Input should be an array of objects with consistent keys.
+      `,
+            infoBoxTitle: 'To Markdown Table Node',
+            contextMenuTitle: 'To Markdown Table',
+            group: ['Text'],
+        };
+    }
+    async process(inputs) {
+        const data = coerceType(inputs['data'], 'object[]');
+        const keys = data.length === 0 ? [] : Object.keys(data[0]);
+        // Dynamic import because these are ESM-only, and top level imports are converted to CommonJS for rivet-node.
+        // Dynamic import is able to load ESM-only modules.
+        const { toMarkdown } = await import('mdast-util-to-markdown');
+        const { gfmTableToMarkdown } = await import('mdast-util-gfm-table');
+        const markdownTable = toMarkdown({
+            type: 'table',
+            children: [
+                ...(this.data.includeHeaders
+                    ? [
+                        {
+                            type: 'tableRow',
+                            children: keys.map((key) => ({
+                                type: 'tableCell',
+                                children: [{ type: 'text', value: key }],
+                            })),
+                        },
+                    ]
+                    : []),
+                ...data.map((row) => ({
+                    type: 'tableRow',
+                    children: keys.map((key) => ({
+                        type: 'tableCell',
+                        children: [{ type: 'text', value: `${row[key]}` }],
+                    })),
+                })),
+            ],
+        }, {
+            extensions: [gfmTableToMarkdown({ tablePipeAlign: this.data.alignPipes })],
+        });
+        return {
+            ['markdown']: {
+                type: 'string',
+                value: markdownTable,
+            },
+        };
+    }
+}
+export const toMarkdownTableNode = nodeDefinition(ToMarkdownTableNodeImpl, 'To Markdown Table');

package/dist/esm/model/nodes/ToTreeNode.js

@@ -0,0 +1,133 @@
+import {} from '../NodeBase.js';
+import { nanoid } from 'nanoid/non-secure';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import {} from '../DataValue.js';
+import {} from '../EditorDefinition.js';
+import { dedent } from 'ts-dedent';
+import { coerceTypeOptional } from '../../utils/coerceType.js';
+import { extractInterpolationVariables, interpolate } from '../../utils/interpolation.js';
+import { get, sortBy } from 'lodash-es';
+export class ToTreeNodeImpl extends NodeImpl {
+    static create() {
+        const chartNode = {
+            type: 'toTree',
+            title: 'To Tree',
+            id: nanoid(),
+            visualData: {
+                x: 0,
+                y: 0,
+                width: 300,
+            },
+            data: {
+                format: '{{path}}',
+                childrenProperty: 'children',
+                useSortAlphabetically: true,
+            },
+        };
+        return chartNode;
+    }
+    getInputDefinitions() {
+        return [
+            {
+                id: 'objects',
+                title: 'Objects',
+                dataType: ['object[]', 'object'],
+                required: true,
+            },
+        ];
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'tree',
+                title: 'Tree',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'string',
+                label: 'Children Property',
+                dataKey: 'childrenProperty',
+            },
+            {
+                type: 'code',
+                label: 'Format',
+                dataKey: 'format',
+                language: 'prompt-interpolation-markdown',
+                theme: 'prompt-interpolation',
+            },
+            {
+                type: 'toggle',
+                label: 'Sort Alphabetically',
+                dataKey: 'useSortAlphabetically',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      Format: ${this.data.format}
+      Children: ${this.data.childrenProperty}
+      Sort: ${this.data.useSortAlphabetically ? 'Yes' : 'No'}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Converts an array of objects into a tree structure and renders it as text.
+
+        The format field supports interpolation using {{property}} syntax to determine
+        how each node is displayed.
+
+        Use the children property to specify which field contains child nodes.
+      `,
+            infoBoxTitle: 'To Tree Node',
+            contextMenuTitle: 'To Tree',
+            group: ['Text'],
+        };
+    }
+    buildTree(objects, parentPath = '', level = 0, isLast = true) {
+        if (!Array.isArray(objects) || objects.length === 0)
+            return '';
+        let result = '';
+        const sortedObjects = this.data.useSortAlphabetically
+            ? sortBy(objects, (obj) => String(get(obj, 'path', '')))
+            : objects;
+        sortedObjects.forEach((obj, index) => {
+            const isLastItem = index === sortedObjects.length - 1;
+            const prefix = level === 0 ? '' : isLast ? '└── ' : '├── ';
+            const indent = level === 0 ? '' : '    '.repeat(level - 1) + (isLast ? '    ' : '│   ');
+            // Get all potential interpolation variables from the format string
+            const matches = extractInterpolationVariables(this.data.format);
+            const interpolationVars = matches.reduce((acc, match) => {
+                const key = match;
+                acc[key] = String(get(obj, key, ''));
+                return acc;
+            }, {});
+            const formattedNode = interpolate(this.data.format, interpolationVars);
+            // Add this node to the result
+            result += indent + prefix + formattedNode + '\n';
+            // Process children if they exist
+            const children = get(obj, this.data.childrenProperty);
+            if (Array.isArray(children) && children.length > 0) {
+                const newPath = parentPath ? `${parentPath}/${formattedNode}` : formattedNode;
+                result += this.buildTree(children, newPath, level + 1, isLastItem);
+            }
+        });
+        return result;
+    }
+    async process(inputs) {
+        const objects = coerceTypeOptional(inputs['objects'], 'object[]') ?? [];
+        const treeOutput = this.buildTree(objects);
+        return {
+            ['tree']: {
+                type: 'string',
+                value: treeOutput,
+            },
+        };
+    }
+}
+export const toTreeNode = nodeDefinition(ToTreeNodeImpl, 'To Tree');