@flowfuse/nr-assistant 0.3.1-8f3f1da-202507071743.0 → 0.3.1-92d1581-202507160925.0

package/lib/completions/Labeller.js

@@ -0,0 +1,56 @@
+class CompletionsLabeller {
+    constructor ({ inputFeatureLabels, classifierLabels, nodeLabels }) {
+        this.inputFeatureLabels = inputFeatureLabels
+        this.classifierLabels = classifierLabels
+        this.nodeLabels = nodeLabels
+    }
+
+    ohe (node) {
+        return this.inputFeatureLabels.map(cat => (cat === node ? 1 : 0))
+    }
+
+    countNodes (sequence) {
+        return this.nodeLabels.map(cat => sequence.filter(n => n === cat).length)
+    }
+
+    /**
+     * Encode a sequence of nodes into a feature vector.
+     * @param {string[]} userInput - Array of node type names.
+     * @returns {number[]} Encoded feature vector.
+     */
+    encode_sequence (userInput) {
+        const inputNode = userInput[0]
+        const recentNode = userInput[userInput.length - 1]
+        const sequenceLength = userInput.length
+
+        const inputOhe = this.ohe(inputNode)
+        const recentOhe = this.ohe(recentNode)
+        const counts = this.countNodes(userInput)
+
+        // Concatenate all features (order must match training)
+        // [sequence_length, ...input_ohe, ...recent_ohe, ...counts]
+        return [
+            sequenceLength,
+            ...inputOhe,
+            ...recentOhe,
+            ...counts
+        ]
+    }
+
+    /**
+     * Decode model predictions into human-readable labels.
+     * @param {Float32Array} predictions - Array of model predictions (probabilities).
+     * @param {number} [topN=5] - Number of top predictions to return.
+     * @returns {{ className: string, confidence: number, classIndex: number }[]}
+     */
+    decode_predictions (predictions, topN = 5) {
+        return [...predictions]
+            .map((confidence, classIndex) => {
+                return { confidence, classIndex, className: this.classifierLabels[classIndex] }
+            }).sort((a, b) => b.confidence - a.confidence)
+            .slice(0, topN) // Get top N predictions
+    }
+}
+
+module.exports.CompletionsLabeller = CompletionsLabeller
+module.exports.default = CompletionsLabeller

package/lib/flowGraph.js

@@ -0,0 +1,65 @@
+function buildReverseGraph (flow) {
+    const reverseGraph = new Map()
+    for (const node of flow) {
+        const outputs = (node && node.wires && node.wires.flat()) || []
+        for (const output of outputs) {
+            if (!reverseGraph.has(output)) {
+                reverseGraph.set(output, [])
+            }
+            reverseGraph.get(output).push(node.id) // output is downstream, node.id is upstream
+        }
+    }
+    return reverseGraph
+}
+
+/**
+ * Find the longest upstream path in a flow graph.
+ *
+ * Interesting parts:
+ * - Uses DFS (depth-first search) to find the longest upstream path
+ * - Handles circular references by using a Set to track visited nodes
+ * @param {Array} graph - The reverse graph where keys are node IDs and values are arrays of upstream node IDs.
+ * @param {string} startId - The ID of the node from which to start the search.
+ * @returns {Array} - An array of node IDs representing the longest upstream path.
+ * @throws {Error} - Throws an error if a circular reference is detected.
+ */
+function findLongestUpstreamPath (graph, startId) {
+    const visited = new Set()
+    function dfs (current, path) {
+        if (visited.has(current)) {
+            throw new Error(`Circular reference detected at node ${current}`)
+        }
+        visited.add(current)
+        let maxSubPath = []
+        for (const parent of graph.get(current) || []) {
+            const subPath = dfs(parent, path)
+            if (subPath.length > maxSubPath.length) {
+                maxSubPath = subPath
+            }
+        }
+        visited.delete(current)
+
+        return [...maxSubPath, current]
+    }
+    return dfs(startId, [])
+}
+
+/**
+ * Get the longest upstream path in a flow graph.
+ * @param {Array<{id: string, type: string, wires: Array<Array<string>>, [key: string]: any}>} flow - The flow graph.
+ * @param {string} finalNodeId - The ID of the final node.
+ * @returns {Array} - An array of nodes representing the longest upstream path.
+ */
+function getLongestUpstreamPath (flow, finalNodeId) {
+    const reverseGraph = buildReverseGraph(flow)
+    const idToNodeLookup = Object.fromEntries(flow.map(node => [node.id, node]))
+    const pathIds = findLongestUpstreamPath(reverseGraph, finalNodeId)
+    const result = pathIds.map(id => idToNodeLookup[id])
+    return result.filter(node => node !== undefined && node.id !== finalNodeId)
+}
+
+module.exports = {
+    getLongestUpstreamPath,
+    buildReverseGraph,
+    findLongestUpstreamPath
+}

package/lib/settings.js

@@ -0,0 +1,18 @@
+module.exports = {
+    getSettings: (RED) => {
+        const assistantSettings = (RED.settings.flowforge && RED.settings.flowforge.assistant) || {}
+        if (assistantSettings.enabled !== true) {
+            assistantSettings.enabled = false
+            assistantSettings.completions = null // if the assistant is not enabled, completions should not be enabled
+        }
+        assistantSettings.mcp = assistantSettings.mcp || {
+            enabled: true // default to enabled
+        }
+        assistantSettings.completions = assistantSettings.completions || {
+            enabled: true, // default to enabled
+            modelUrl: null,
+            vocabularyUrl: null
+        }
+        return assistantSettings
+    }
+}

package/lib/utils.js

@@ -0,0 +1,21 @@
+const tryJsonParse = (str, defaultValue = undefined) => {
+    try {
+        return JSON.parse(str)
+    } catch (e) {
+        return defaultValue
+    }
+}
+
+const hasProperty = (obj, prop) => {
+    return isObject(obj) && Object.prototype.hasOwnProperty.call(obj, prop)
+}
+
+const isObject = (obj) => {
+    return obj !== null && typeof obj === 'object' && !Array.isArray(obj)
+}
+
+module.exports = {
+    tryJsonParse,
+    hasProperty,
+    isObject
+}

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "@flowfuse/nr-assistant",
-    "version": "0.3.1-8f3f1da-202507071743.0",
+    "version": "0.3.1-92d1581-202507160925.0",
     "description": "FlowFuse Node-RED assistant plugin",
     "main": "index.js",
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 0",
+        "test": "mocha --exit \"test/**/*.test.js\"",
         "lint": "eslint -c .eslintrc --ext js,html \"*.js\" \"*.html\"",
         "lint:fix": "eslint -c .eslintrc --ext js,html \"*.js\"  \"*.html\" --fix"
     },
@@ -29,20 +29,25 @@
     "node-red": {
         "version": ">=2.2.0",
         "plugins": {
-            "flowfuse-nr-assistant": "index.js"
+            "flowfuse-nr-assistant": "index.js",
+            "ff-assistant-completions": "completions.html"
         }
     },
     "engines": {
         "node": ">=16.x"
     },
     "dependencies": {
-        "@modelcontextprotocol/sdk": "^1.12.1",
-        "got": "^11.8.6"
+        "@modelcontextprotocol/sdk": "^1.13.1",
+        "got": "^11.8.6",
+        "onnxruntime-web": "^1.22.0"
     },
     "devDependencies": {
         "eslint": "^8.48.0",
         "eslint-config-standard": "^17.1.0",
         "eslint-plugin-html": "7.1.0",
-        "eslint-plugin-no-only-tests": "^3.1.0"
+        "eslint-plugin-no-only-tests": "^3.1.0",
+        "mocha": "^11.6.0",
+        "should": "^13.2.3",
+        "sinon": "^18.0.0"
     }
 }

package/resources/sharedUtils.js

@@ -0,0 +1,70 @@
+/**
+* FFA Assistant Utils
+* Shared utility functions for the FlowFuse Assistant
+* To import this in js backend code, use:
+* const { cleanFlow } = require('flowfuse-nr-assistant/resources/sharedUtils.js')
+* To import this in frontend code, use:
+* <script src="/resources/@flowfuse/nr-assistant/sharedUtils.js"></script>
+* To use this in the browser, you can access it via:
+* FFAssistantUtils.cleanFlow(nodeArray)
+*/
+
+'use strict';
+
+(function (root, factory) {
+    if (typeof module === 'object' && module.exports) {
+        // Node.js / CommonJS
+        module.exports = factory()
+    } else {
+        // Browser
+        root.FFAssistantUtils = root.FFAssistantUtils || {}
+        Object.assign(root.FFAssistantUtils, factory())
+    }
+}(typeof self !== 'undefined' ? self : this, function () {
+    'use strict'
+    /**
+     * Cleans a single or an array nodes by removing internal properties and circular references.
+     * @param {Array<Object> | Object} flow - The node or array of nodes to clean
+     * @returns {{nodes: Array, totalNodeCount: number}} - The cleaned nodes and the total node count
+     */
+    function cleanFlow (flow) {
+        if (!flow) return { flow: [], nodeCount: 0 }
+        const nodeArray = Array.isArray(flow) ? flow : [flow]
+        const nodes = [...nodeArray] // make a shallow copy of the array
+        let totalNodeCount = 0
+        const MAX_DEPTH = 10 // maximum depth to recurse into groups
+        const visited = new Set() // to avoid circular references
+        // the input is an array of node. each node is an object.
+        // if the .type is 'group' and it has a .nodes array, we need to clean those nodes as well (and any nested groups).
+        const recursiveClean = (node, depth = 0) => {
+            if (!node || typeof node !== 'object' || !node.id) {
+                return null // if the node is not an object or doesn't have an id, return null
+            }
+            if (visited.has(node.id) || depth > MAX_DEPTH) {
+                return null
+            }
+            totalNodeCount += 1
+            visited.add(node.id)
+            const cleaned = { ...node }
+            delete cleaned._ // remove the internal _ property
+            delete cleaned._def // remove the definition
+            delete cleaned._config // remove the config
+            delete cleaned.validationErrors // remove validation errors
+            if (node.type === 'group') {
+                delete cleaned._childGroups // this can cause circular references
+                delete cleaned._parentGroup // this can cause circular references
+                cleaned.nodes = []
+                if (Array.isArray(node.nodes) && node.nodes.length > 0) {
+                    cleaned.nodes = node.nodes.map(childNode => recursiveClean(childNode, depth + 1))
+                        .filter(childNode => childNode !== null) // filter out any null nodes
+                }
+            }
+            return cleaned
+        }
+        return {
+            flow: nodes.map(node => recursiveClean(node)).filter(node => node !== null), // filter out any null nodes
+            nodeCount: totalNodeCount
+        }
+    }
+    return { cleanFlow }
+}))