@alpic80/rivet-core 1.19.1-aidon.2 → 1.24.0-aidon.1

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

@@ -0,0 +1,210 @@
+import {} from '../NodeBase.js';
+import {} from '../DataValue.js';
+import { NodeImpl } from '../NodeImpl.js';
+import { nodeDefinition } from '../NodeDefinition.js';
+import { nanoid } from 'nanoid/non-secure';
+import { getInputOrData } from '../../utils/index.js';
+import {} from '../ProcessContext.js';
+import { dedent } from 'ts-dedent';
+import { uint8ArrayToBase64 } from '../../utils/base64.js';
+export class ReadAllFilesNodeImpl extends NodeImpl {
+    static create() {
+        return {
+            id: nanoid(),
+            type: 'readAllFiles',
+            title: 'Read All Files',
+            visualData: { x: 0, y: 0, width: 250 },
+            data: {
+                path: '',
+                usePathInput: false,
+                recursive: false,
+                useRecursiveInput: false,
+                filterGlobs: [],
+                useFilterGlobsInput: false,
+                ignores: [],
+                useIgnoresInput: false,
+                asBinary: false,
+                errorOnMissingFile: false,
+            },
+        };
+    }
+    getInputDefinitions() {
+        const inputDefinitions = [];
+        if (this.chartNode.data.usePathInput) {
+            inputDefinitions.push({
+                id: 'path',
+                title: 'Path',
+                dataType: 'string',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useRecursiveInput) {
+            inputDefinitions.push({
+                id: 'recursive',
+                title: 'Recursive',
+                dataType: 'boolean',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useFilterGlobsInput) {
+            inputDefinitions.push({
+                id: 'filterGlobs',
+                title: 'Filter Globs',
+                dataType: 'string[]',
+                required: true,
+                coerced: false,
+            });
+        }
+        if (this.chartNode.data.useIgnoresInput) {
+            inputDefinitions.push({
+                id: 'ignores',
+                title: 'Ignores',
+                dataType: 'string[]',
+                required: true,
+                coerced: false,
+            });
+        }
+        return inputDefinitions;
+    }
+    getOutputDefinitions() {
+        return [
+            {
+                id: 'files',
+                title: 'Files',
+                dataType: 'object[]',
+            },
+            {
+                id: 'rootPath',
+                title: 'Root Path',
+                dataType: 'string',
+            },
+        ];
+    }
+    getEditors() {
+        return [
+            {
+                type: 'directoryBrowser',
+                label: 'Path',
+                dataKey: 'path',
+                useInputToggleDataKey: 'usePathInput',
+            },
+            {
+                type: 'toggle',
+                label: 'Recursive',
+                dataKey: 'recursive',
+                useInputToggleDataKey: 'useRecursiveInput',
+            },
+            {
+                type: 'stringList',
+                label: 'Filter Globs',
+                dataKey: 'filterGlobs',
+                useInputToggleDataKey: 'useFilterGlobsInput',
+            },
+            {
+                type: 'stringList',
+                label: 'Ignores',
+                dataKey: 'ignores',
+                useInputToggleDataKey: 'useIgnoresInput',
+            },
+            {
+                type: 'toggle',
+                label: 'Read as Binary',
+                dataKey: 'asBinary',
+            },
+            {
+                type: 'toggle',
+                label: 'Error on Missing File',
+                dataKey: 'errorOnMissingFile',
+            },
+        ];
+    }
+    getBody() {
+        return dedent `
+      ${this.data.asBinary ? 'Read as Binary' : 'Read as Text'}
+      Path: ${this.data.usePathInput ? '(Input)' : this.data.path}
+      Recursive: ${this.data.useRecursiveInput ? '(Input)' : this.data.recursive}
+      Filters: ${this.data.useFilterGlobsInput
+            ? '(Input)'
+            : this.data.filterGlobs.length > 0
+                ? this.data.filterGlobs.join(', ')
+                : 'None'}
+    `;
+    }
+    static getUIData() {
+        return {
+            infoBoxBody: dedent `
+        Reads all files in the specified directory and outputs an array of objects containing each file's path and contents.
+        Each object has a 'path' (string) and 'content' (string or binary) property.
+      `,
+            infoBoxTitle: 'Read All Files Node',
+            contextMenuTitle: 'Read All Files',
+            group: ['Input/Output'],
+        };
+    }
+    async process(inputs, context) {
+        const { nativeApi } = context;
+        if (nativeApi == null) {
+            throw new Error('This node requires a native API to run.');
+        }
+        const path = getInputOrData(this.chartNode.data, inputs, 'path');
+        const recursive = getInputOrData(this.data, inputs, 'recursive', 'boolean');
+        const filterGlobs = getInputOrData(this.data, inputs, 'filterGlobs', 'string[]');
+        const ignores = getInputOrData(this.data, inputs, 'ignores', 'string[]');
+        try {
+            // First read the directory
+            const filePaths = await nativeApi.readdir(path, undefined, {
+                recursive,
+                includeDirectories: false, // We only want files since we're reading contents
+                filterGlobs,
+                relative: true, // Always use relative paths in output
+                ignores,
+            });
+            // Then read each file
+            const filePromises = filePaths.map(async (filePath) => {
+                try {
+                    if (this.data.asBinary) {
+                        const content = await nativeApi.readBinaryFile(`${path}/${filePath}`);
+                        const buffer = await content.arrayBuffer();
+                        return {
+                            path: filePath,
+                            content: (await uint8ArrayToBase64(new Uint8Array(buffer))) ?? '',
+                        };
+                    }
+                    else {
+                        const content = await nativeApi.readTextFile(`${path}/${filePath}`, undefined);
+                        return {
+                            path: filePath,
+                            content,
+                        };
+                    }
+                }
+                catch (err) {
+                    if (this.chartNode.data.errorOnMissingFile) {
+                        throw err;
+                    }
+                    return {
+                        path: filePath,
+                        content: this.data.asBinary ? new Uint8Array() : '',
+                    };
+                }
+            });
+            const files = await Promise.all(filePromises);
+            return {
+                ['files']: { type: 'object[]', value: files },
+                ['rootPath']: { type: 'string', value: path },
+            };
+        }
+        catch (err) {
+            if (this.chartNode.data.errorOnMissingFile) {
+                throw err;
+            }
+            return {
+                ['files']: { type: 'object[]', value: [] },
+                ['rootPath']: { type: 'string', value: path },
+            };
+        }
+    }
+}
+export const readAllFilesNode = nodeDefinition(ReadAllFilesNodeImpl, 'Read All Files');

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/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');