speechflow 0.9.0 → 0.9.2

package/dst/speechflow-node-file.js

@@ -8,40 +8,98 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
 const node_fs_1 = __importDefault(require("node:fs"));
+const node_stream_1 = __importDefault(require("node:stream"));
+/*  internal dependencies  */
 const speechflow_node_1 = __importDefault(require("./speechflow-node"));
-class SpeechFlowNodeDevice extends speechflow_node_1.default {
+/*  SpeechFlow node for file access  */
+class SpeechFlowNodeFile extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "file";
+    /*  construct node  */
     constructor(id, opts, args) {
         super(id, opts, args);
+        /*  declare node configuration parameters  */
         this.configure({
             path: { type: "string", pos: 0 },
             mode: { type: "string", pos: 1, val: "r", match: /^(?:r|w|rw)$/ },
             type: { type: "string", pos: 2, val: "audio", match: /^(?:audio|text)$/ }
         });
+        /*  declare node input/output format  */
+        if (this.params.mode === "rw") {
+            this.input = this.params.type;
+            this.output = this.params.type;
+        }
+        else if (this.params.mode === "r") {
+            this.input = "none";
+            this.output = this.params.type;
+        }
+        else if (this.params.mode === "w") {
+            this.input = this.params.type;
+            this.output = "none";
+        }
     }
+    /*  open node  */
     async open() {
-        if (this.params.mode === "r") {
-            this.output = this.params.type;
-            if (this.params.path === "-")
+        const encoding = this.params.type === "text" ? this.config.textEncoding : "binary";
+        if (this.params.mode === "rw") {
+            if (this.params.path === "-") {
+                /*  standard I/O  */
+                process.stdin.setEncoding(encoding);
+                process.stdout.setEncoding(encoding);
+                this.stream = node_stream_1.default.Duplex.from({
+                    readable: process.stdin,
+                    writable: process.stdout
+                });
+            }
+            else {
+                /*  file I/O  */
+                this.stream = node_stream_1.default.Duplex.from({
+                    readable: node_fs_1.default.createReadStream(this.params.path, { encoding }),
+                    writable: node_fs_1.default.createWriteStream(this.params.path, { encoding })
+                });
+            }
+        }
+        else if (this.params.mode === "r") {
+            if (this.params.path === "-") {
+                /*  standard I/O  */
+                process.stdin.setEncoding(encoding);
                 this.stream = process.stdin;
-            else
-                this.stream = node_fs_1.default.createReadStream(this.params.path, { encoding: this.params.type === "text" ? this.config.textEncoding : "binary" });
+            }
+            else {
+                /*  file I/O  */
+                this.stream = node_fs_1.default.createReadStream(this.params.path, { encoding });
+            }
         }
         else if (this.params.mode === "w") {
-            this.input = this.params.type;
-            if (this.params.path === "-")
+            if (this.params.path === "-") {
+                /*  standard I/O  */
+                process.stdout.setEncoding(encoding);
                 this.stream = process.stdout;
-            else
-                this.stream = node_fs_1.default.createWriteStream(this.params.path, { encoding: this.params.type === "text" ? this.config.textEncoding : "binary" });
+            }
+            else {
+                /*  file I/O  */
+                this.stream = node_fs_1.default.createWriteStream(this.params.path, { encoding });
+            }
         }
         else
             throw new Error(`invalid file mode "${this.params.mode}"`);
     }
+    /*  close node  */
     async close() {
-        if (this.stream !== null && this.params.path !== "-") {
-            this.stream.destroy();
+        /*  shutdown stream  */
+        if (this.stream !== null) {
+            await new Promise((resolve) => {
+                if (this.stream instanceof node_stream_1.default.Writable || this.stream instanceof node_stream_1.default.Duplex)
+                    this.stream.end(() => { resolve(); });
+                else
+                    resolve();
+            });
+            if (this.params.path !== "-")
+                this.stream.destroy();
             this.stream = null;
         }
     }
 }
-exports.default = SpeechFlowNodeDevice;
+exports.default = SpeechFlowNodeFile;

package/dst/speechflow-node-gemma.d.ts

@@ -0,0 +1,11 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeGemma extends SpeechFlowNode {
+    static name: string;
+    private ollama;
+    private setup;
+    constructor(id: string, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    open(): Promise<void>;
+    close(): Promise<void>;
+}

package/dst/speechflow-node-gemma.js

@@ -0,0 +1,152 @@
+"use strict";
+/*
+**  SpeechFlow - Speech Processing Flow Graph
+**  Copyright (c) 2024-2025 Dr. Ralf S. Engelschall <rse@engelschall.com>
+**  Licensed under GPL 3.0 <https://spdx.org/licenses/GPL-3.0-only>
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
+const node_stream_1 = __importDefault(require("node:stream"));
+const node_events_1 = require("node:events");
+/*  external dependencies  */
+const ollama_1 = require("ollama");
+/*  internal dependencies  */
+const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for Gemma/Ollama text-to-text translation  */
+class SpeechFlowNodeGemma extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "gemma";
+    /*  internal state  */
+    ollama = null;
+    /*  internal LLM setup  */
+    setup = {
+        /*  English (EN) to German (DE) translation  */
+        "en-de": {
+            systemPrompt: "You are a translator.\n" +
+                "Output only the requested text.\n" +
+                "Do not use markdown.\n" +
+                "Do not chat.\n" +
+                "Do not show any explanations.\n" +
+                "Do not show any introduction.\n" +
+                "Do not show any preamble.\n" +
+                "Do not show any prolog.\n" +
+                "Do not show any epilog.\n" +
+                "Get to the point.\n" +
+                "Directly translate text from Enlish (EN) to German (DE) language.\n",
+            chat: [
+                { role: "user", content: "I love my wife." },
+                { role: "system", content: "Ich liebe meine Frau." },
+                { role: "user", content: "The weather is wonderful." },
+                { role: "system", content: "Das Wetter ist wunderschön." },
+                { role: "user", content: "The live is awesome." },
+                { role: "system", content: "Das Leben ist einfach großartig." }
+            ]
+        },
+        /*  German (DE) to English (EN) translation  */
+        "de-en": {
+            systemPrompt: "You are a translator.\n" +
+                "Output only the requested text.\n" +
+                "Do not use markdown.\n" +
+                "Do not chat.\n" +
+                "Do not show any explanations. \n" +
+                "Do not show any introduction.\n" +
+                "Do not show any preamble. \n" +
+                "Do not show any prolog. \n" +
+                "Do not show any epilog. \n" +
+                "Get to the point.\n" +
+                "Directly translate text from German (DE) to English (EN) language.\n",
+            chat: [
+                { role: "user", content: "Ich liebe meine Frau." },
+                { role: "system", content: "I love my wife." },
+                { role: "user", content: "Das Wetter ist wunderschön." },
+                { role: "system", content: "The weather is wonderful." },
+                { role: "user", content: "Das Leben ist einfach großartig." },
+                { role: "system", content: "The live is awesome." }
+            ]
+        }
+    };
+    /*  construct node  */
+    constructor(id, opts, args) {
+        super(id, opts, args);
+        /*  declare node configuration parameters  */
+        this.configure({
+            api: { type: "string", val: "http://127.0.0.1:11434", match: /^https?:\/\/.+?:\d+$/ },
+            src: { type: "string", pos: 0, val: "de", match: /^(?:de|en)$/ },
+            dst: { type: "string", pos: 1, val: "en", match: /^(?:de|en)$/ }
+        });
+        /*  sanity check situation  */
+        if (this.params.src === this.params.dst)
+            throw new Error("source and destination languages cannot be the same");
+        /*  declare node input/output format  */
+        this.input = "text";
+        this.output = "text";
+    }
+    /*  open node  */
+    async open() {
+        /*  instantiate Ollama API  */
+        this.ollama = new ollama_1.Ollama({ host: this.params.api });
+        /*  provide text-to-text translation  */
+        const translate = async (text) => {
+            const key = `${this.params.src}-${this.params.dst}`;
+            const cfg = this.setup[key];
+            const response = await this.ollama.chat({
+                model: "gemma3:4b-it-q4_K_M",
+                messages: [
+                    { role: "system", content: cfg.systemPrompt },
+                    ...cfg.chat,
+                    { role: "user", content: text }
+                ],
+                keep_alive: "10m",
+                options: {
+                    repeat_penalty: 1.1,
+                    temperature: 0.7,
+                    seed: 1,
+                    top_k: 10,
+                    top_p: 0.5
+                }
+            });
+            return response.message.content;
+        };
+        /*  establish a duplex stream and connect it to Ollama  */
+        const queue = new node_events_1.EventEmitter();
+        this.stream = new node_stream_1.default.Duplex({
+            write(chunk, encoding, callback) {
+                const data = chunk.toString();
+                if (data === "") {
+                    queue.emit("result", "");
+                    callback();
+                }
+                else {
+                    translate(data).then((result) => {
+                        queue.emit("result", result);
+                        callback();
+                    }).catch((err) => {
+                        callback(err);
+                    });
+                }
+            },
+            read(size) {
+                queue.once("result", (result) => {
+                    this.push(result);
+                });
+            }
+        });
+    }
+    /*  close node  */
+    async close() {
+        /*  close stream  */
+        if (this.stream !== null) {
+            this.stream.destroy();
+            this.stream = null;
+        }
+        /*  shutdown Ollama  */
+        if (this.ollama !== null) {
+            this.ollama.abort();
+            this.ollama = null;
+        }
+    }
+}
+exports.default = SpeechFlowNodeGemma;

package/dst/speechflow-node-websocket.d.ts

@@ -0,0 +1,11 @@
+import SpeechFlowNode from "./speechflow-node";
+export default class SpeechFlowNodeWebsocket extends SpeechFlowNode {
+    static name: string;
+    private server;
+    private client;
+    constructor(id: string, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    open(): Promise<void>;
+    close(): Promise<void>;
+}

package/dst/speechflow-node-websocket.js

@@ -8,25 +8,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
 const node_stream_1 = __importDefault(require("node:stream"));
+/*  external dependencies  */
 const ws_1 = __importDefault(require("ws"));
 const reconnecting_websocket_1 = __importDefault(require("@opensumi/reconnecting-websocket"));
+/*  internal dependencies  */
 const speechflow_node_1 = __importDefault(require("./speechflow-node"));
+/*  SpeechFlow node for Websocket networking  */
 class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
+    /*  declare official node name  */
+    static name = "websocket";
+    /*  internal state  */
     server = null;
     client = null;
+    /*  construct node  */
     constructor(id, opts, args) {
         super(id, opts, args);
+        /*  declare node configuration parameters  */
         this.configure({
             listen: { type: "string", val: "", match: /^(?:|ws:\/\/(.+?):(\d+))$/ },
             connect: { type: "string", val: "", match: /^(?:|ws:\/\/(.+?):(\d+)(?:\/.*)?)$/ },
             type: { type: "string", val: "text", match: /^(?:audio|text)$/ }
         });
+        /*  sanity check usage  */
+        if (this.params.listen !== "" && this.params.connect !== "")
+            throw new Error("Websocket node cannot listen and connect at the same time");
+        else if (this.params.listen === "" && this.params.connect === "")
+            throw new Error("Websocket node requires either listen or connect mode");
+        /*  declare node input/output format  */
+        if (this.params.listen !== "") {
+            this.input = "none";
+            this.output = this.params.type;
+        }
+        else if (this.params.connect !== "") {
+            this.input = this.params.type;
+            this.output = "none";
+        }
     }
+    /*  open node  */
     async open() {
-        this.input = this.params.type;
-        this.output = this.params.type;
         if (this.params.listen !== "") {
+            /*  listen locally on a Websocket port  */
             const url = new URL(this.params.listen);
             let websocket = null;
             const server = new ws_1.default.WebSocketServer({
@@ -49,6 +72,7 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
                 this.log("error", `error on URL ${this.params.listen}: ${error.message}`);
                 websocket = null;
             });
+            const textEncoding = this.config.textEncoding;
             this.stream = new node_stream_1.default.Duplex({
                 write(chunk, encoding, callback) {
                     const data = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
@@ -66,7 +90,7 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
                 read(size) {
                     if (websocket !== null) {
                         websocket.once("message", (data, isBinary) => {
-                            this.push(data, isBinary ? "binary" : "utf8");
+                            this.push(data, isBinary ? "binary" : textEncoding);
                         });
                     }
                     else
@@ -75,6 +99,7 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
             });
         }
         else if (this.params.connect !== "") {
+            /*  connect remotely to a Websocket port  */
             this.client = new reconnecting_websocket_1.default(this.params.connect, [], {
                 WebSocket: ws_1.default,
                 WebSocketOptions: {},
@@ -95,6 +120,7 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
             });
             const client = this.client;
             client.binaryType = "arraybuffer";
+            const textEncoding = this.config.textEncoding;
             this.stream = new node_stream_1.default.Duplex({
                 write(chunk, encoding, callback) {
                     const data = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
@@ -111,7 +137,7 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
                             if (ev.data instanceof ArrayBuffer)
                                 this.push(ev.data, "binary");
                             else
-                                this.push(ev.data, "utf8");
+                                this.push(ev.data, textEncoding);
                         }, { once: true });
                     }
                     else
@@ -119,10 +145,10 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
                 }
             });
         }
-        else
-            throw new Error("neither listen nor connect mode requested");
     }
+    /*  close node  */
     async close() {
+        /*  close Websocket server  */
         if (this.server !== null) {
             await new Promise((resolve, reject) => {
                 this.server.close((error) => {
@@ -134,10 +160,12 @@ class SpeechFlowNodeWebsocket extends speechflow_node_1.default {
             });
             this.server = null;
         }
+        /*  close Websocket client  */
         if (this.client !== null) {
             this.client.close();
             this.client = null;
         }
+        /*  close stream  */
         if (this.stream !== null) {
             this.stream.destroy();
             this.stream = null;

package/dst/speechflow-node.d.ts

@@ -0,0 +1,38 @@
+import Events from "node:events";
+import Stream from "node:stream";
+export default class SpeechFlowNode extends Events.EventEmitter {
+    id: string;
+    private opts;
+    private args;
+    config: {
+        readonly audioChannels: 1;
+        readonly audioBitDepth: 16;
+        readonly audioLittleEndian: true;
+        readonly audioSampleRate: 48000;
+        readonly textEncoding: "utf8";
+    };
+    input: string;
+    output: string;
+    params: {
+        [id: string]: any;
+    };
+    stream: Stream.Writable | Stream.Readable | Stream.Duplex | null;
+    connectionsIn: Set<SpeechFlowNode>;
+    connectionsOut: Set<SpeechFlowNode>;
+    constructor(id: string, opts: {
+        [id: string]: any;
+    }, args: any[]);
+    configure(spec: {
+        [id: string]: {
+            type: string;
+            pos?: number;
+            val?: any;
+            match?: RegExp;
+        };
+    }): void;
+    connect(other: SpeechFlowNode): void;
+    disconnect(other: SpeechFlowNode): void;
+    log(level: string, msg: string, data?: any): void;
+    open(): Promise<void>;
+    close(): Promise<void>;
+}

package/dst/speechflow-node.js

@@ -8,11 +8,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/*  standard dependencies  */
 const node_events_1 = __importDefault(require("node:events"));
+/*  the base class for all SpeechFlow nodes  */
 class SpeechFlowNode extends node_events_1.default.EventEmitter {
     id;
     opts;
     args;
+    /*  general constant configuration (for reference)  */
     config = {
         audioChannels: 1, /* audio mono channel       */
         audioBitDepth: 16, /* audio PCM 16-bit integer */
@@ -20,58 +23,73 @@ class SpeechFlowNode extends node_events_1.default.EventEmitter {
         audioSampleRate: 48000, /* audio 48kHz sample rate  */
         textEncoding: "utf8" /* UTF-8 text encoding      */
     };
+    /*  announced information  */
     input = "none";
     output = "none";
     params = {};
     stream = null;
     connectionsIn = new Set();
     connectionsOut = new Set();
+    /*  the default constructor  */
     constructor(id, opts, args) {
         super();
         this.id = id;
         this.opts = opts;
         this.args = args;
     }
+    /*  INTERNAL: utility function: create "params" attribute from constructor of sub-classes  */
     configure(spec) {
         for (const name of Object.keys(spec)) {
             if (this.opts[name] !== undefined) {
+                /*  named parameter  */
                 if (typeof this.opts[name] !== spec[name].type)
-                    throw new Error(`invalid type of option "${name}"`);
-                if ("match" in spec[name] && this.opts[name].match(spec[name].match) === null)
-                    throw new Error(`invalid value of option "${name}" (has to match ${spec[name].match})`);
+                    throw new Error(`invalid type of named parameter "${name}" ` +
+                        `(has to be ${spec[name].type})`);
+                if ("match" in spec[name]
+                    && this.opts[name].match(spec[name].match) === null)
+                    throw new Error(`invalid value of named parameter "${name}" ` +
+                        `(has to match ${spec[name].match})`);
                 this.params[name] = this.opts[name];
             }
             else if (this.opts[name] === undefined
                 && "pos" in spec[name]
+                && typeof spec[name].pos === "number"
                 && spec[name].pos < this.args.length) {
+                /*  positional argument  */
                 if (typeof this.args[spec[name].pos] !== spec[name].type)
-                    throw new Error(`invalid type of argument "${name}"`);
-                if ("match" in spec[name] && this.args[spec[name].pos].match(spec[name].match) === null)
-                    throw new Error(`invalid value of option "${name}" (has to match ${spec[name].match})`);
+                    throw new Error(`invalid type of positional parameter "${name}" ` +
+                        `(has to be ${spec[name].type})`);
+                if ("match" in spec[name]
+                    && this.args[spec[name].pos].match(spec[name].match) === null)
+                    throw new Error(`invalid value of positional parameter "${name}" ` +
+                        `(has to match ${spec[name].match})`);
                 this.params[name] = this.args[spec[name].pos];
             }
             else if ("val" in spec[name] && spec[name].val !== undefined)
+                /*  default argument  */
                 this.params[name] = spec[name].val;
             else
                 throw new Error(`required parameter "${name}" not given`);
         }
     }
+    /*  connect node to another one  */
     connect(other) {
         this.connectionsOut.add(other);
         other.connectionsIn.add(this);
     }
+    /*  disconnect node from another one  */
     disconnect(other) {
         if (!this.connectionsOut.has(other))
             throw new Error("invalid node: not connected to this node");
         this.connectionsOut.delete(other);
         other.connectionsIn.delete(this);
     }
+    /*  internal log function  */
     log(level, msg, data) {
         this.emit("log", level, msg, data);
     }
-    async open() {
-    }
-    async close() {
-    }
+    /*  default implementation for open/close operations  */
+    async open() { }
+    async close() { }
 }
 exports.default = SpeechFlowNode;

package/dst/speechflow.d.ts

@@ -0,0 +1 @@
+export {};