@promptbook/node 0.86.22 → 0.86.31

package/esm/typings/src/_packages/execute-javascript.index.d.ts

@@ -2,7 +2,9 @@ import { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION } from '../version';
 import { JavascriptEvalExecutionTools } from '../scripting/javascript/JavascriptEvalExecutionTools';
 import { JavascriptExecutionTools } from '../scripting/javascript/JavascriptExecutionTools';
 import { POSTPROCESSING_FUNCTIONS } from '../scripting/javascript/postprocessing-functions';
+import { extractVariablesFromJavascript } from '../scripting/javascript/utils/extractVariablesFromJavascript';
 export { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION };
 export { JavascriptEvalExecutionTools };
 export { JavascriptExecutionTools };
 export { POSTPROCESSING_FUNCTIONS };
+export { extractVariablesFromJavascript };

package/esm/typings/src/_packages/utils.index.d.ts

@@ -2,7 +2,6 @@ import { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION } from '../version';
 import { VALUE_STRINGS } from '../config';
 import { SMALL_NUMBER } from '../config';
 import { renderPromptbookMermaid } from '../conversion/prettify/renderPipelineMermaidOptions';
-import { extractVariablesFromScript } from '../conversion/utils/extractVariablesFromScript';
 import { deserializeError } from '../errors/utils/deserializeError';
 import { serializeError } from '../errors/utils/serializeError';
 import { forEachAsync } from '../execution/utils/forEachAsync';
@@ -84,7 +83,6 @@ export { BOOK_LANGUAGE_VERSION, PROMPTBOOK_ENGINE_VERSION };
 export { VALUE_STRINGS };
 export { SMALL_NUMBER };
 export { renderPromptbookMermaid };
-export { extractVariablesFromScript };
 export { deserializeError };
 export { serializeError };
 export { forEachAsync };

package/esm/typings/src/scripting/javascript/utils/extractVariablesFromJavascript.d.ts

@@ -0,0 +1,14 @@
+import type { string_javascript } from '../../../types/typeAliases';
+import type { string_javascript_name } from '../../../types/typeAliases';
+/**
+ * Parses the given script and returns the list of all used variables that are not defined in the script
+ *
+ * @param script from which to extract the variables
+ * @returns the list of variable names
+ * @throws {ParseError} if the script is invalid
+ * @public exported from `@promptbook/execute-javascript`
+ */
+export declare function extractVariablesFromJavascript(script: string_javascript): Set<string_javascript_name>;
+/**
+ * TODO: [🔣] Support for multiple languages - python, java,...
+ */

package/esm/typings/src/scripting/javascript/utils/extractVariablesFromScript.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/node",
-    "version": "0.86.22",
+    "version": "0.86.31",
     "description": "It's time for a paradigm shift. The future of software in plain English, French or Latin",
     "private": false,
     "sideEffects": false,
@@ -47,7 +47,7 @@
     "module": "./esm/index.es.js",
     "typings": "./esm/typings/src/_packages/node.index.d.ts",
     "peerDependencies": {
-        "@promptbook/core": "0.86.22"
+        "@promptbook/core": "0.86.31"
     },
     "dependencies": {
         "colors": "1.4.0",

package/umd/index.umd.js

@@ -46,7 +46,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.86.22';
+    const PROMPTBOOK_ENGINE_VERSION = '0.86.31';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -2133,119 +2133,60 @@
     }
 
     /**
-     * Extract all used variable names from ginen JavaScript/TypeScript script
+     * Parses the given script and returns the list of all used variables that are not defined in the script
      *
-     * @param script JavaScript/TypeScript script
-     * @returns Set of variable names
+     * @param script from which to extract the variables
+     * @returns the list of variable names
      * @throws {ParseError} if the script is invalid
-     * @public exported from `@promptbook/utils` <- Note: [👖] This is usable elsewhere than in Promptbook, so keeping in utils
+     * @public exported from `@promptbook/execute-javascript`
      */
-    function extractVariablesFromScript(script) {
-        if (script.trim() === '') {
-            return new Set();
-        }
+    function extractVariablesFromJavascript(script) {
         const variables = new Set();
-        // JS keywords and builtins to exclude
-        const exclude = new Set([
-            // Keywords
-            'break',
-            'case',
-            'catch',
-            'class',
-            'const',
-            'continue',
-            'debugger',
-            'default',
-            'delete',
-            'do',
-            'else',
-            'export',
-            'extends',
-            'false',
-            'finally',
-            'for',
-            'function',
-            'if',
-            'import',
-            'in',
-            'instanceof',
-            'let',
-            'new',
-            'null',
-            'return',
-            'super',
-            'switch',
-            'this',
-            'throw',
-            'true',
-            'try',
-            'typeof',
-            'var',
-            'void',
-            'while',
-            'with',
-            'yield',
-            // Common globals
-            'console',
-            'JSON',
-            'Error',
-            // Typescript types
-            'string',
-            'number',
-            'boolean',
-            'object',
-            'symbol',
-            // Common methods on built-in objects
-            'test',
-            'match',
-            'exec',
-            'replace',
-            'search',
-            'split',
-        ]);
+        const originalScript = script;
+        script = `(()=>{${script}})()`;
         try {
-            // Note: Extract variables from template literals like ${variable}
-            const templateRegex = /\$\{([a-zA-Z_$][a-zA-Z0-9_$]*)\}/g;
-            let match;
-            while ((match = templateRegex.exec(script)) !== null) {
-                const varName = match[1];
-                if (!exclude.has(varName)) {
-                    variables.add(varName);
+            for (let i = 0; i < LOOP_LIMIT; i++)
+                try {
+                    eval(script); // <- TODO: Use `JavascriptExecutionTools.execute` here
                 }
-            }
-            // Note: Process the script to handle normal variable usage
-            const processedScript = script
-                .replace(/'(?:\\.|[^'\\])*'/g, "''") // <- Note: Remove string literals
-                .replace(/"(?:\\.|[^"\\])*"/g, '""')
-                .replace(/`(?:\\.|[^`\\])*`/g, '``')
-                .replace(/\/(?:\\.|[^/\\])*\/[gimsuy]*/g, '{}'); // <- Note: Remove regex literals
-            // Note: Find identifiers in function arguments
-            const funcArgRegex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
-            const funcNames = new Set();
-            while ((match = funcArgRegex.exec(processedScript)) !== null) {
-                funcNames.add(match[1]);
-            }
-            // Find variable declarations to exclude them
-            const declaredVars = new Set();
-            const declRegex = /\b(const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
-            while ((match = declRegex.exec(processedScript)) !== null) {
-                declaredVars.add(match[2]);
-            }
-            // Note: Find identifiers in the script
-            const identifierRegex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
-            while ((match = identifierRegex.exec(processedScript)) !== null) {
-                const name = match[1];
-                // Add if not excluded, not a function name, and not a declared variable
-                if (!exclude.has(name) && !funcNames.has(name) && !declaredVars.has(name)) {
-                    variables.add(name);
+                catch (error) {
+                    if (!(error instanceof ReferenceError)) {
+                        throw error;
+                    }
+                    /*
+                    Note: Parsing the error
+                          🌟 Most devices:
+                          [PipelineUrlError: thing is not defined]
+
+                          🍏 iPhone`s Safari:
+                          [PipelineUrlError: Can't find variable: thing]
+                    */
+                    let variableName = undefined;
+                    if (error.message.startsWith(`Can't`)) {
+                        // 🍏 Case
+                        variableName = error.message.split(' ').pop();
+                    }
+                    else {
+                        // 🌟 Case
+                        variableName = error.message.split(' ').shift();
+                    }
+                    if (variableName === undefined) {
+                        throw error;
+                    }
+                    if (script.includes(variableName + '(')) {
+                        script = `const ${variableName} = ()=>'';` + script;
+                    }
+                    else {
+                        variables.add(variableName);
+                        script = `const ${variableName} = '';` + script;
+                    }
                 }
-            }
         }
         catch (error) {
             if (!(error instanceof Error)) {
                 throw error;
             }
-            throw new ParseError(spaceTrim__default["default"]((block) => `
+            throw new ParseError(spaceTrim.spaceTrim((block) => `
                     Can not extract variables from the script
                     ${block(error.stack || error.message)}
 
@@ -2258,7 +2199,7 @@
                     The script:
 
                     \`\`\`javascript
-                    ${block(script)}
+                    ${block(originalScript)}
                     \`\`\`
                 `));
         }
@@ -2279,19 +2220,24 @@
     function extractParameterNamesFromTask(task) {
         const { title, description, taskType, content, preparedContent, jokerParameterNames, foreach } = task;
         const parameterNames = new Set();
+        let contentParameters;
+        if (taskType !== 'SCRIPT_TASK') {
+            contentParameters = extractParameterNames(content);
+        }
+        else {
+            // TODO: What if script is not javascript?
+            // const { contentLanguage } = task;
+            // if (contentLanguage !== 'javascript') {
+            contentParameters = extractVariablesFromJavascript(content);
+        }
         for (const parameterName of [
             ...extractParameterNames(title),
             ...extractParameterNames(description || ''),
-            ...extractParameterNames(content),
+            ...contentParameters,
             ...extractParameterNames(preparedContent || ''),
         ]) {
             parameterNames.add(parameterName);
         }
-        if (taskType === 'SCRIPT_TASK') {
-            for (const parameterName of extractVariablesFromScript(content)) {
-                parameterNames.add(parameterName);
-            }
-        }
         for (const jokerName of jokerParameterNames || []) {
             parameterNames.add(jokerName);
         }
@@ -10081,6 +10027,7 @@
             // Note: Custom functions are exposed to the current scope as variables
             `const ${functionName} = customFunctions.${functionName};`)
                 .join('\n');
+            script = templateParameters(script, parameters);
             const statementToEvaluate = spaceTrim__default["default"]((block) => `
 
                 // Build-in functions: