@promptbook/core 0.23.1 → 0.24.0-0

package/esm/index.es.js

@@ -1,4 +1,4 @@
-import { capitalize, normalizeTo_SCREAMING_CASE, normalizeTo_PascalCase, normalizeTo_camelCase } from 'n12';
+import { capitalize, normalizeTo_SCREAMING_CASE, normalizeTo_PascalCase, normalizeTo_camelCase, removeDiacritics } from 'n12';
 import spaceTrim from 'spacetrim';
 
 /*! *****************************************************************************
@@ -342,6 +342,14 @@ function removeContentComments(content) {
  */
 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.
  *
@@ -358,10 +366,73 @@ function removeMarkdownFormatting(str) {
     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:');
     }
@@ -468,7 +539,7 @@ function parseCommand(listItem) {
             throw new Error(spaceTrim("\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("\n                        Parameter {".concat(parameterName, "} can not contain another parameter in description:\n\n                        - ").concat(listItem, "\n                    ")));
         }
@@ -490,6 +561,74 @@ function parseCommand(listItem) {
             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("\n                  Invalid EXPECT command; ".concat(error.message, ":\n\n                  - ").concat(listItem, "\n              ")));
+        }
+    }
     else {
         throw new Error(spaceTrim("\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                ")));
     }
@@ -598,6 +737,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
         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()) {
@@ -621,6 +761,23 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
                     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"));
                 }
@@ -684,6 +841,7 @@ function promptTemplatePipelineStringToJson(promptTemplatePipelineString) {
             title: section.title,
             description: description_1,
             executionType: executionType,
+            expectations: expectations,
             modelRequirements: templateModelRequirements,
             contentLanguage: executionType === 'SCRIPT' ? language : undefined,
             content: content,
@@ -920,6 +1078,74 @@ var PromptTemplatePipeline = /** @class */ (function () {
  * 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 = 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
@@ -1045,17 +1271,18 @@ function createPtpExecutor(options) {
     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);
@@ -1071,13 +1298,14 @@ function createPtpExecutor(options) {
                                             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) {
@@ -1088,7 +1316,7 @@ function createPtpExecutor(options) {
                                     }
                                     return [3 /*break*/, 24];
                                 case 3:
-                                    promptResult = replaceParameters(currentTemplate.content, parametersToPass);
+                                    resultString = replaceParameters(currentTemplate.content, parametersToPass);
                                     return [3 /*break*/, 25];
                                 case 4:
                                     prompt_1 = {
@@ -1107,19 +1335,48 @@ function createPtpExecutor(options) {
                                     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');
@@ -1129,44 +1386,44 @@ function createPtpExecutor(options) {
                                     }
                                     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*/];
@@ -1187,13 +1444,13 @@ function createPtpExecutor(options) {
                                         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');
                                     }
@@ -1205,10 +1462,10 @@ function createPtpExecutor(options) {
                                             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*/];
                             }