@promptbook/core 0.23.2 → 0.24.0-0

package/umd/index.umd.js

@@ -349,6 +349,14 @@
      */
     var ExecutionTypes = ['PROMPT_TEMPLATE', 'SIMPLE_TEMPLATE', 'SCRIPT', 'PROMPT_DIALOG'];
 
+    /**
+     * Units of text measurement
+     */
+    var EXPECTATION_UNITS = ['CHARACTERS', 'WORDS', 'SENTENCES', 'PARAGRAPHS', 'LINES', 'PAGES'];
+    /**
+     * TODO: use one helper type> (string_prompt | string_javascript | string_markdown) & string_template
+     */
+
     /**
      * Removes Markdown formatting tags from a string.
      *
@@ -365,10 +373,73 @@
         return str;
     }
 
+    /**
+     * Function parseNumber will parse number from string
+     *
+     * Unlike Number.parseInt, Number.parseFloat it will never ever result in NaN
+     * Note: it also works only with decimal numbers
+     */
+    function parseNumber(value) {
+        var originalValue = value;
+        if (typeof value === 'number') {
+            value = value.toString(); // <- TODO: Maybe more efficient way to do this
+        }
+        if (typeof value !== 'string') {
+            return 0;
+        }
+        value = value.trim();
+        if (value.startsWith('+')) {
+            return parseNumber(value.substring(1));
+        }
+        if (value.startsWith('-')) {
+            var number = parseNumber(value.substring(1));
+            if (number === 0) {
+                return 0; // <- Note: To prevent -0
+            }
+            return -number;
+        }
+        value = value.replace(/,/g, '.');
+        value = value.toUpperCase();
+        if (value === '') {
+            return 0;
+        }
+        if (value === '♾' || value.startsWith('INF')) {
+            return Infinity;
+        }
+        if (value.includes('/')) {
+            var _a = __read(value.split('/'), 2), numerator_ = _a[0], denominator_ = _a[1];
+            var numerator = parseNumber(numerator_);
+            var denominator = parseNumber(denominator_);
+            if (denominator === 0) {
+                throw new Error("Unable to parse number from \"".concat(originalValue, "\" because denominator is zero"));
+            }
+            return numerator / denominator;
+        }
+        if (/^(NAN|NULL|NONE|UNDEFINED|ZERO|NO.*)$/.test(value)) {
+            return 0;
+        }
+        if (value.includes('E')) {
+            var _b = __read(value.split('E'), 2), significand = _b[0], exponent = _b[1];
+            return parseNumber(significand) * Math.pow(10, parseNumber(exponent));
+        }
+        if (!/^[0-9.]+$/.test(value) || value.split('.').length > 2) {
+            throw new Error("Unable to parse number from \"".concat(originalValue, "\""));
+        }
+        var num = parseFloat(value);
+        if (isNaN(num)) {
+            throw new Error("Unexpected NaN when parsing number from \"".concat(originalValue, "\""));
+        }
+        return num;
+    }
+    /**
+     * TODO: Maybe use sth. like safe-eval in fraction/calculation case @see https://www.npmjs.com/package/safe-eval
+     */
+
     /**
      * Parses one line of ul/ol to command
      */
     function parseCommand(listItem) {
+        var e_1, _a;
         if (listItem.includes('\n') || listItem.includes('\r')) {
             throw new Error('Command can not contain new line characters:');
         }
@@ -475,7 +546,7 @@
                 throw new Error(spaceTrim__default["default"]("\n                        Invalid parameter in command:\n\n                        - ".concat(listItem, "\n                    ")));
             }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            var _a = parametersMatch.groups, parameterName = _a.parameterName, parameterDescription = _a.parameterDescription;
+            var _b = parametersMatch.groups, parameterName = _b.parameterName, parameterDescription = _b.parameterDescription;
             if (parameterDescription && parameterDescription.match(/\{(?<parameterName>[a-z0-9_]+)\}/im)) {
                 throw new Error(spaceTrim__default["default"]("\n                        Parameter {".concat(parameterName, "} can not contain another parameter in description:\n\n                        - ").concat(listItem, "\n                    ")));
             }
@@ -497,6 +568,74 @@
                 functionName: functionName,
             };
         }
+        else if (type.startsWith('EXPECT')) {
+            try {
+                listItemParts.shift();
+                var sign = void 0;
+                var signRaw = listItemParts.shift();
+                if (/^exact/i.test(signRaw)) {
+                    sign = 'EXACTLY';
+                }
+                else if (/^min/i.test(signRaw)) {
+                    sign = 'MINIMUM';
+                }
+                else if (/^max/i.test(signRaw)) {
+                    sign = 'MAXIMUM';
+                }
+                else {
+                    throw new Error("Invalid sign \"".concat(signRaw, "\""));
+                }
+                var amountRaw = listItemParts.shift();
+                var amount = parseNumber(amountRaw);
+                if (amount < 0) {
+                    throw new Error('Amount must be positive number or zero');
+                }
+                if (amount !== Math.floor(amount)) {
+                    throw new Error('Amount must be whole number');
+                }
+                var unitRaw = listItemParts.shift();
+                var unit = undefined;
+                try {
+                    for (var EXPECTATION_UNITS_1 = __values(EXPECTATION_UNITS), EXPECTATION_UNITS_1_1 = EXPECTATION_UNITS_1.next(); !EXPECTATION_UNITS_1_1.done; EXPECTATION_UNITS_1_1 = EXPECTATION_UNITS_1.next()) {
+                        var existingUnit = EXPECTATION_UNITS_1_1.value;
+                        var existingUnitText = existingUnit;
+                        existingUnitText = existingUnitText.substring(0, existingUnitText.length - 1);
+                        if (existingUnitText === 'CHARACTER') {
+                            existingUnitText = 'CHAR';
+                        }
+                        if (new RegExp("^".concat(existingUnitText.toLowerCase())).test(unitRaw.toLowerCase()) ||
+                            new RegExp("^".concat(unitRaw.toLowerCase())).test(existingUnitText.toLowerCase())) {
+                            if (unit !== undefined) {
+                                throw new Error("Ambiguous unit \"".concat(unitRaw, "\""));
+                            }
+                            unit = existingUnit;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (EXPECTATION_UNITS_1_1 && !EXPECTATION_UNITS_1_1.done && (_a = EXPECTATION_UNITS_1.return)) _a.call(EXPECTATION_UNITS_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                if (unit === undefined) {
+                    throw new Error("Invalid unit \"".concat(unitRaw, "\""));
+                }
+                return {
+                    type: 'EXPECT',
+                    sign: sign,
+                    unit: unit,
+                    amount: amount,
+                };
+            }
+            catch (error) {
+                if (!(error instanceof Error)) {
+                    throw error;
+                }
+                throw new Error(spaceTrim__default["default"]("\n                  Invalid EXPECT command; ".concat(error.message, ":\n\n                  - ").concat(listItem, "\n              ")));
+            }
+        }
         else {
             throw new Error(spaceTrim__default["default"]("\n                    Unknown command:\n\n                    - ".concat(listItem, "\n\n                    Supported commands are:\n                    - Execute\n                    - Model\n                    - Parameter\n                    - Input parameter\n                    - Output parameter\n                    - PTBK Version\n                ")));
         }
@@ -605,6 +744,7 @@
             var postprocessingCommands = [];
             var listItems_3 = extractAllListItemsFromMarkdown(section.content);
             var executionType = 'PROMPT_TEMPLATE';
+            var expectations = {};
             var isExecutionTypeChanged = false;
             try {
                 for (var listItems_2 = (e_3 = void 0, __values(listItems_3)), listItems_2_1 = listItems_2.next(); !listItems_2_1.done; listItems_2_1 = listItems_2.next()) {
@@ -628,6 +768,23 @@
                         case 'POSTPROCESS':
                             postprocessingCommands.push(command);
                             break;
+                        case 'EXPECT':
+                            // eslint-disable-next-line no-case-declarations
+                            var unit = command.unit.toLowerCase();
+                            expectations[unit] = expectations[unit] || {};
+                            if (command.sign === 'MINIMUM' || command.sign === 'EXACTLY') {
+                                if (expectations[unit].min !== undefined) {
+                                    throw new Error("Already defined minumum ".concat(expectations[unit].min, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
+                                }
+                                expectations[unit].min = command.amount;
+                            } /* not else */
+                            if (command.sign === 'MAXIMUM' || command.sign === 'EXACTLY') {
+                                if (expectations[unit].max !== undefined) {
+                                    throw new Error("Already defined maximum ".concat(expectations[unit].max, " ").concat(command.unit.toLowerCase(), ", now trying to redefine it to ").concat(command.amount));
+                                }
+                                expectations[unit].max = command.amount;
+                            }
+                            break;
                         default:
                             throw new Error("Command ".concat(command.type, " is not allowed in the block of the prompt template ONLY at the head of the prompt template pipeline"));
                     }
@@ -691,6 +848,7 @@
                 title: section.title,
                 description: description_1,
                 executionType: executionType,
+                expectations: expectations,
                 modelRequirements: templateModelRequirements,
                 contentLanguage: executionType === 'SCRIPT' ? language : undefined,
                 content: content,
@@ -927,6 +1085,74 @@
      * TODO: [🧠] Each PromptTemplatePipeline should have its unique hash to be able to compare them and execute on server ONLY the desired ones
      */
 
+    /**
+     * Counts number of characters in the text
+     */
+    function countCharacters(text) {
+        // Remove null characters
+        text = text.replace(/\0/g, '');
+        // Replace emojis (and also ZWJ sequence) with hyphens
+        text = text.replace(/(\p{Emoji})\p{Modifier_Symbol}/gu, '$1');
+        text = text.replace(/(\p{Emoji})[\u{FE00}-\u{FE0F}]/gu, '$1');
+        text = text.replace(/\p{Emoji}(\u{200D}\p{Emoji})*/gu, '-');
+        return text.length;
+    }
+
+    /**
+     * Counts number of lines in the text
+     */
+    function countLines(text) {
+        if (text === '') {
+            return 0;
+        }
+        return text.split('\n').length;
+    }
+
+    /**
+     * Counts number of pages in the text
+     */
+    function countPages(text) {
+        var sentencesPerPage = 5; // Assuming each page has 5 sentences
+        var sentences = text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; });
+        var pageCount = Math.ceil(sentences.length / sentencesPerPage);
+        return pageCount;
+    }
+
+    /**
+     * Counts number of paragraphs in the text
+     */
+    function countParagraphs(text) {
+        return text.split(/\n\s*\n/).filter(function (paragraph) { return paragraph.trim() !== ''; }).length;
+    }
+
+    /**
+     * Counts number of sentences in the text
+     */
+    function countSentences(text) {
+        return text.split(/[.!?]+/).filter(function (sentence) { return sentence.trim() !== ''; }).length;
+    }
+
+    /**
+     * Counts number of words in the text
+     */
+    function countWords(text) {
+        text = text.replace(/[\p{Emoji}]/gu, 'a');
+        text = n12.removeDiacritics(text);
+        return text.split(/[^a-zа-я0-9]+/i).filter(function (word) { return word.length > 0; }).length;
+    }
+
+    /**
+     * Index of all counter functions
+     */
+    var CountUtils = {
+        CHARACTERS: countCharacters,
+        WORDS: countWords,
+        SENTENCES: countSentences,
+        PARAGRAPHS: countParagraphs,
+        LINES: countLines,
+        PAGES: countPages,
+    };
+
     /**
      * All possible emoji chars like "🍆", "🍡", "🍤"...
      * Note: this will be needed to update annually - now updated at 2022-01-19
@@ -1052,17 +1278,18 @@
         var _this = this;
         var ptp = options.ptp, tools = options.tools;
         var ptpExecutor = function (inputParameters, onProgress) { return __awaiter(_this, void 0, void 0, function () {
-            var parametersToPass, currentTemplate, _loop_1;
+            var parametersToPass, currentTemplate, executionReport, _loop_1;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         parametersToPass = inputParameters;
                         currentTemplate = ptp.entryPromptTemplate;
+                        executionReport = [];
                         _loop_1 = function () {
-                            var resultingParameter, name_1, title, prompt_1, chatThread, completionResult, promptResult, scriptExecutionErrors, isScriptExecutionSuccessful, _b, _c, _d, _e, scriptTools, error_1, e_1_1;
-                            var e_1, _f, _g;
-                            return __generator(this, function (_h) {
-                                switch (_h.label) {
+                            var resultingParameter, name_1, title, prompt_1, chatThread, completionResult, result, resultString, scriptExecutionErrors, isScriptExecutionSuccessful, _b, _c, _d, _e, _f, unit, _g, max, min, amount, _h, _j, scriptTools, error_1, e_1_1;
+                            var e_2, _k, e_1, _l, _m;
+                            return __generator(this, function (_o) {
+                                switch (_o.label) {
                                     case 0:
                                         resultingParameter = ptp.getResultingParameter(currentTemplate.name);
                                         name_1 = "ptp-executor-frame-".concat(currentTemplate.name);
@@ -1078,13 +1305,14 @@
                                                 parameterValue: null,
                                             })];
                                     case 1:
-                                        _h.sent();
-                                        _h.label = 2;
+                                        _o.sent();
+                                        _o.label = 2;
                                     case 2:
                                         prompt_1 = void 0;
                                         chatThread = void 0;
                                         completionResult = void 0;
-                                        promptResult = null;
+                                        result = void 0;
+                                        resultString = null;
                                         isScriptExecutionSuccessful = void 0;
                                         _b = currentTemplate.executionType;
                                         switch (_b) {
@@ -1095,7 +1323,7 @@
                                         }
                                         return [3 /*break*/, 24];
                                     case 3:
-                                        promptResult = replaceParameters(currentTemplate.content, parametersToPass);
+                                        resultString = replaceParameters(currentTemplate.content, parametersToPass);
                                         return [3 /*break*/, 25];
                                     case 4:
                                         prompt_1 = {
@@ -1114,19 +1342,48 @@
                                         return [3 /*break*/, 9];
                                     case 5: return [4 /*yield*/, tools.natural.gptChat(prompt_1)];
                                     case 6:
-                                        chatThread = _h.sent();
-                                        // TODO: Use all information from chatThread like "model"
+                                        chatThread = _o.sent();
                                         // TODO: [🍬] Destroy chatThread
-                                        promptResult = chatThread.content;
+                                        result = chatThread;
+                                        resultString = chatThread.content;
                                         return [3 /*break*/, 10];
                                     case 7: return [4 /*yield*/, tools.natural.gptComplete(prompt_1)];
                                     case 8:
-                                        completionResult = _h.sent();
-                                        // TODO: Use all information from chatThread like "model"
-                                        promptResult = completionResult.content;
+                                        completionResult = _o.sent();
+                                        result = completionResult;
+                                        resultString = completionResult.content;
                                         return [3 /*break*/, 10];
                                     case 9: throw new Error("Unknown model variant \"".concat(currentTemplate.modelRequirements.modelVariant, "\""));
-                                    case 10: return [3 /*break*/, 25];
+                                    case 10:
+                                        try {
+                                            for (_d = (e_2 = void 0, __values(Object.entries(currentTemplate.expectations))), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                                _f = __read(_e.value, 2), unit = _f[0], _g = _f[1], max = _g.max, min = _g.min;
+                                                amount = CountUtils[unit](resultString);
+                                                // TODO: !!!!! Do not crash BUT retry some amount of times
+                                                if (min && amount < min) {
+                                                    throw new Error("Expected at least ".concat(min, " ").concat(unit, " but got ").concat(amount));
+                                                } /* not else */
+                                                if (max && amount > max) {
+                                                    throw new Error("Expected at most ".concat(max, " ").concat(unit, " but got ").concat(amount));
+                                                }
+                                            }
+                                        }
+                                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                        finally {
+                                            try {
+                                                if (_e && !_e.done && (_k = _d.return)) _k.call(_d);
+                                            }
+                                            finally { if (e_2) throw e_2.error; }
+                                        }
+                                        executionReport.push({
+                                            prompt: {
+                                                content: prompt_1.content,
+                                                modelRequirements: prompt_1.modelRequirements,
+                                                // <- Note: Do want to pass ONLY wanted information to the report
+                                            },
+                                            result: result,
+                                        });
+                                        return [3 /*break*/, 25];
                                     case 11:
                                         if (tools.script.length === 0) {
                                             throw new Error('No script execution tools are available');
@@ -1136,44 +1393,44 @@
                                         }
                                         scriptExecutionErrors = [];
                                         isScriptExecutionSuccessful = false;
-                                        _h.label = 12;
+                                        _o.label = 12;
                                     case 12:
-                                        _h.trys.push([12, 19, 20, 21]);
-                                        _d = (e_1 = void 0, __values(tools.script)), _e = _d.next();
-                                        _h.label = 13;
+                                        _o.trys.push([12, 19, 20, 21]);
+                                        _h = (e_1 = void 0, __values(tools.script)), _j = _h.next();
+                                        _o.label = 13;
                                     case 13:
-                                        if (!!_e.done) return [3 /*break*/, 18];
-                                        scriptTools = _e.value;
-                                        _h.label = 14;
+                                        if (!!_j.done) return [3 /*break*/, 18];
+                                        scriptTools = _j.value;
+                                        _o.label = 14;
                                     case 14:
-                                        _h.trys.push([14, 16, , 17]);
+                                        _o.trys.push([14, 16, , 17]);
                                         return [4 /*yield*/, scriptTools.execute({
                                                 scriptLanguage: currentTemplate.contentLanguage,
                                                 script: currentTemplate.content,
                                                 parameters: parametersToPass,
                                             })];
                                     case 15:
-                                        promptResult = _h.sent();
+                                        resultString = _o.sent();
                                         isScriptExecutionSuccessful = true;
                                         return [3 /*break*/, 18];
                                     case 16:
-                                        error_1 = _h.sent();
+                                        error_1 = _o.sent();
                                         if (!(error_1 instanceof Error)) {
                                             throw error_1;
                                         }
                                         scriptExecutionErrors.push(error_1);
                                         return [3 /*break*/, 17];
                                     case 17:
-                                        _e = _d.next();
+                                        _j = _h.next();
                                         return [3 /*break*/, 13];
                                     case 18: return [3 /*break*/, 21];
                                     case 19:
-                                        e_1_1 = _h.sent();
+                                        e_1_1 = _o.sent();
                                         e_1 = { error: e_1_1 };
                                         return [3 /*break*/, 21];
                                     case 20:
                                         try {
-                                            if (_e && !_e.done && (_f = _d.return)) _f.call(_d);
+                                            if (_j && !_j.done && (_l = _h.return)) _l.call(_h);
                                         }
                                         finally { if (e_1) throw e_1.error; }
                                         return [7 /*endfinally*/];
@@ -1194,13 +1451,13 @@
                                             placeholder: undefined,
                                         })];
                                     case 23:
-                                        promptResult = _h.sent();
+                                        resultString = _o.sent();
                                         return [3 /*break*/, 25];
                                     case 24: 
                                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                     throw new Error("Unknown execution type \"".concat(currentTemplate.executionType, "\""));
                                     case 25:
-                                        if (promptResult === null) {
+                                        if (resultString === null) {
                                             //              <- TODO: [🥨] Make some NeverShouldHappenError
                                             throw new Error('Something went wrong and prompt result is null');
                                         }
@@ -1212,10 +1469,10 @@
                                                 isDone: true,
                                                 executionType: currentTemplate.executionType,
                                                 parameterName: resultingParameter.name,
-                                                parameterValue: promptResult,
+                                                parameterValue: resultString,
                                             });
                                         }
-                                        parametersToPass = __assign(__assign({}, parametersToPass), (_g = {}, _g[resultingParameter.name] = promptResult /* <- Note: Not need to detect parameter collision here because PromptTemplatePipeline checks logic consistency during construction */, _g));
+                                        parametersToPass = __assign(__assign({}, parametersToPass), (_m = {}, _m[resultingParameter.name] = resultString /* <- Note: Not need to detect parameter collision here because PromptTemplatePipeline checks logic consistency during construction */, _m));
                                         currentTemplate = ptp.getFollowingPromptTemplate(currentTemplate.name);
                                         return [2 /*return*/];
                                 }