@promptbook/templates
Version:
Promptbook: Create persistent AI agents that turn your company's scattered knowledge into action
1,692 lines (1,635 loc) • 3.29 MB
JavaScript
import { spaceTrim as spaceTrim$1 } from 'spacetrim';
// ⚠️ WARNING: This code has been generated so that any manual changes will be overwritten
/**
* The version of the Book language
*
* @generated
* @see https://github.com/webgptorg/book
*/
const BOOK_LANGUAGE_VERSION = '2.0.0';
/**
* The version of the Promptbook engine
*
* @generated
* @see https://github.com/webgptorg/promptbook
*/
const PROMPTBOOK_ENGINE_VERSION = '0.112.0-80';
/**
* TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
* Note: [💞] Ignore a discrepancy between file name and entity name
*/
/**
* Checks if value is valid email
*
* @public exported from `@promptbook/utils`
*/
function isValidEmail(email) {
if (typeof email !== 'string') {
return false;
}
if (email.split(/\r?\n/).length > 1) {
return false;
}
return /^.+@.+\..+$/.test(email);
}
/**
* Tests if given string is valid file path.
*
* Note: This does not check if the file exists only if the path is valid
*
* @public exported from `@promptbook/utils`
*/
function isValidFilePath(filename) {
if (typeof filename !== 'string') {
return false;
}
if (filename.split(/\r?\n/).length > 1) {
return false;
}
// Normalize slashes early so heuristics can detect path-like inputs
const filenameSlashes = filename.replace(/\\/g, '/');
// Reject strings that look like sentences (informational text)
// Heuristic: contains multiple spaces and ends with a period, or contains typical sentence punctuation
// But skip this heuristic if the string looks like a path (contains '/' or starts with a drive letter)
if (filename.trim().length > 60 && // long enough to be a sentence
/[.!?]/.test(filename) && // contains sentence punctuation
filename.split(' ').length > 8 && // has many words
!/\/|^[A-Z]:/i.test(filenameSlashes) // do NOT treat as sentence if looks like a path
) {
return false;
}
// Absolute Unix path: /hello.txt
if (/^(\/)/i.test(filenameSlashes)) {
// console.log(filename, 'Absolute Unix path: /hello.txt');
return true;
}
// Absolute Windows path: C:/ or C:\ (allow spaces and multiple dots in filename)
if (/^[A-Z]:\/.+$/i.test(filenameSlashes)) {
// console.log(filename, 'Absolute Windows path: /hello.txt');
return true;
}
// Relative path: ./hello.txt
if (/^(\.\.?\/)+/i.test(filenameSlashes)) {
// console.log(filename, 'Relative path: ./hello.txt');
return true;
}
// Allow paths like foo/hello
if (/^[^/]+\/[^/]+/i.test(filenameSlashes)) {
// console.log(filename, 'Allow paths like foo/hello');
return true;
}
// Allow paths like hello.book
if (/^[^/]+\.[^/]+$/i.test(filenameSlashes)) {
// console.log(filename, 'Allow paths like hello.book');
return true;
}
return false;
}
// TODO: [🍏] Implement for MacOs
/**
* Tests if given string is valid URL.
*
* Note: [🔂] This function is idempotent.
* Note: Dataurl are considered perfectly valid.
* Note: There are few similar functions:
* - `isValidUrl` *(this one)* which tests any URL
* - `isValidAgentUrl` which tests just agent URL
* - `isValidPipelineUrl` which tests just pipeline URL
*
* @public exported from `@promptbook/utils`
*/
function isValidUrl(url) {
if (typeof url !== 'string') {
return false;
}
try {
if (url.startsWith('blob:')) {
url = url.replace(/^blob:/, '');
}
const urlObject = new URL(url /* because fail is handled */);
if (!['http:', 'https:', 'data:'].includes(urlObject.protocol)) {
return false;
}
return true;
}
catch (error) {
return false;
}
}
/**
* This error indicates that the promptbook in a markdown format cannot be parsed into a valid promptbook object
*
* @public exported from `@promptbook/core`
*/
class ParseError extends Error {
constructor(message) {
super(message);
this.name = 'ParseError';
Object.setPrototypeOf(this, ParseError.prototype);
}
}
// TODO: Maybe split `ParseError` and `ApplyError`
/**
* Trims string from all 4 sides
*
* Note: This is a re-exported function from the `spacetrim` package which is
* Developed by same author @hejny as this package
*
* @see https://github.com/hejny/spacetrim#usage
*
* @public exported from `@promptbook/utils`
*/
const spaceTrim = spaceTrim$1;
/**
* Class implementing take chain.
*
* @de
*
* @private util of `@promptbook/color`
*/
class TakeChain {
constructor(value) {
this.value = value;
}
then(callback) {
const newValue = callback(this.value);
return take(newValue);
}
}
/**
* A function that takes an initial value and returns a proxy object with chainable methods.
*
* @param {*} initialValue - The initial value.
* @returns {Proxy<WithTake<TValue>>} - A proxy object with a `take` method.
* @deprecated [🤡] Use some better functional library instead of `TakeChain`
*
* @private util of `@promptbook/color`
*/
function take(initialValue) {
if (initialValue instanceof TakeChain) {
return initialValue;
}
return new Proxy(new TakeChain(initialValue), {
get(target, property, receiver) {
if (Reflect.has(target, property)) {
return Reflect.get(target, property, receiver);
}
else if (Reflect.has(initialValue, property)) {
return Reflect.get(initialValue, property, receiver);
}
else {
return undefined;
}
},
});
}
/**
* 🎨 List of all 140 color names which are supported by CSS
*
* @public exported from `@promptbook/color`
*/
const CSS_COLORS = {
promptbook: '#79EAFD',
transparent: 'rgba(0,0,0,0)',
aliceblue: '#f0f8ff',
antiquewhite: '#faebd7',
aqua: '#00ffff',
aquamarine: '#7fffd4',
azure: '#f0ffff',
beige: '#f5f5dc',
bisque: '#ffe4c4',
black: '#000000',
blanchedalmond: '#ffebcd',
blue: '#0000ff',
blueviolet: '#8a2be2',
brown: '#a52a2a',
burlywood: '#deb887',
cadetblue: '#5f9ea0',
chartreuse: '#7fff00',
chocolate: '#d2691e',
coral: '#ff7f50',
cornflowerblue: '#6495ed',
cornsilk: '#fff8dc',
crimson: '#dc143c',
cyan: '#00ffff',
darkblue: '#00008b',
darkcyan: '#008b8b',
darkgoldenrod: '#b8860b',
darkgray: '#a9a9a9',
darkgrey: '#a9a9a9',
darkgreen: '#006400',
darkkhaki: '#bdb76b',
darkmagenta: '#8b008b',
darkolivegreen: '#556b2f',
darkorange: '#ff8c00',
darkorchid: '#9932cc',
darkred: '#8b0000',
darksalmon: '#e9967a',
darkseagreen: '#8fbc8f',
darkslateblue: '#483d8b',
darkslategray: '#2f4f4f',
darkslategrey: '#2f4f4f',
darkturquoise: '#00ced1',
darkviolet: '#9400d3',
deeppink: '#ff1493',
deepskyblue: '#00bfff',
dimgray: '#696969',
dimgrey: '#696969',
dodgerblue: '#1e90ff',
firebrick: '#b22222',
floralwhite: '#fffaf0',
forestgreen: '#228b22',
fuchsia: '#ff00ff',
gainsboro: '#dcdcdc',
ghostwhite: '#f8f8ff',
gold: '#ffd700',
goldenrod: '#daa520',
gray: '#808080',
grey: '#808080',
green: '#008000',
greenyellow: '#adff2f',
honeydew: '#f0fff0',
hotpink: '#ff69b4',
indianred: '#cd5c5c',
indigo: '#4b0082',
ivory: '#fffff0',
khaki: '#f0e68c',
lavender: '#e6e6fa',
lavenderblush: '#fff0f5',
lawngreen: '#7cfc00',
lemonchiffon: '#fffacd',
lightblue: '#add8e6',
lightcoral: '#f08080',
lightcyan: '#e0ffff',
lightgoldenrodyellow: '#fafad2',
lightgray: '#d3d3d3',
lightgrey: '#d3d3d3',
lightgreen: '#90ee90',
lightpink: '#ffb6c1',
lightsalmon: '#ffa07a',
lightseagreen: '#20b2aa',
lightskyblue: '#87cefa',
lightslategray: '#778899',
lightslategrey: '#778899',
lightsteelblue: '#b0c4de',
lightyellow: '#ffffe0',
lime: '#00ff00',
limegreen: '#32cd32',
linen: '#faf0e6',
magenta: '#ff00ff',
maroon: '#800000',
mediumaquamarine: '#66cdaa',
mediumblue: '#0000cd',
mediumorchid: '#ba55d3',
mediumpurple: '#9370db',
mediumseagreen: '#3cb371',
mediumslateblue: '#7b68ee',
mediumspringgreen: '#00fa9a',
mediumturquoise: '#48d1cc',
mediumvioletred: '#c71585',
midnightblue: '#191970',
mintcream: '#f5fffa',
mistyrose: '#ffe4e1',
moccasin: '#ffe4b5',
navajowhite: '#ffdead',
navy: '#000080',
oldlace: '#fdf5e6',
olive: '#808000',
olivedrab: '#6b8e23',
orange: '#ffa500',
orangered: '#ff4500',
orchid: '#da70d6',
palegoldenrod: '#eee8aa',
palegreen: '#98fb98',
paleturquoise: '#afeeee',
palevioletred: '#db7093',
papayawhip: '#ffefd5',
peachpuff: '#ffdab9',
peru: '#cd853f',
pink: '#ffc0cb',
plum: '#dda0dd',
powderblue: '#b0e0e6',
purple: '#800080',
rebeccapurple: '#663399',
red: '#ff0000',
rosybrown: '#bc8f8f',
royalblue: '#4169e1',
saddlebrown: '#8b4513',
salmon: '#fa8072',
sandybrown: '#f4a460',
seagreen: '#2e8b57',
seashell: '#fff5ee',
sienna: '#a0522d',
silver: '#c0c0c0',
skyblue: '#87ceeb',
slateblue: '#6a5acd',
slategray: '#708090',
slategrey: '#708090',
snow: '#fffafa',
springgreen: '#00ff7f',
steelblue: '#4682b4',
tan: '#d2b48c',
teal: '#008080',
thistle: '#d8bfd8',
tomato: '#ff6347',
turquoise: '#40e0d0',
violet: '#ee82ee',
wheat: '#f5deb3',
white: '#ffffff',
whitesmoke: '#f5f5f5',
yellow: '#ffff00',
yellowgreen: '#9acd32',
};
// Note: [💞] Ignore a discrepancy between file name and entity name
/**
* Validates that a channel value is a valid number within the range of 0 to 255.
* Throws an error if the value is not valid.
*
* @param channelName - The name of the channel being validated.
* @param value - The value of the channel to validate.
* @throws Will throw an error if the value is not a valid channel number.
*
* @private util of `@promptbook/color`
*/
function checkChannelValue(channelName, value) {
if (typeof value !== 'number') {
throw new Error(`${channelName} channel value is not number but ${typeof value}`);
}
if (isNaN(value)) {
throw new Error(`${channelName} channel value is NaN`);
}
if (Math.round(value) !== value) {
throw new Error(`${channelName} channel is not whole number, it is ${value}`);
}
if (value < 0) {
throw new Error(`${channelName} channel is lower than 0, it is ${value}`);
}
if (value > 255) {
throw new Error(`${channelName} channel is greater than 255, it is ${value}`);
}
}
/**
* Shared immutable channel storage and serialization helpers for `Color`.
*
* @private base class of Color
*/
class ColorValue {
constructor(red, green, blue, alpha = 255) {
this.red = red;
this.green = green;
this.blue = blue;
this.alpha = alpha;
checkChannelValue('Red', red);
checkChannelValue('Green', green);
checkChannelValue('Blue', blue);
checkChannelValue('Alpha', alpha);
}
/**
* Shortcut for `red` property
* Number from 0 to 255
* @alias red
*/
get r() {
return this.red;
}
/**
* Shortcut for `green` property
* Number from 0 to 255
* @alias green
*/
get g() {
return this.green;
}
/**
* Shortcut for `blue` property
* Number from 0 to 255
* @alias blue
*/
get b() {
return this.blue;
}
/**
* Shortcut for `alpha` property
* Number from 0 (transparent) to 255 (opaque)
* @alias alpha
*/
get a() {
return this.alpha;
}
/**
* Shortcut for `alpha` property
* Number from 0 (transparent) to 255 (opaque)
* @alias alpha
*/
get opacity() {
return this.alpha;
}
/**
* Shortcut for 1-`alpha` property
*/
get transparency() {
return 255 - this.alpha;
}
clone() {
return take(this.createColor(this.red, this.green, this.blue, this.alpha));
}
toString() {
return this.toHex();
}
toHex() {
if (this.alpha === 255) {
return `#${this.red.toString(16).padStart(2, '0')}${this.green.toString(16).padStart(2, '0')}${this.blue
.toString(16)
.padStart(2, '0')}`;
}
else {
return `#${this.red.toString(16).padStart(2, '0')}${this.green.toString(16).padStart(2, '0')}${this.blue
.toString(16)
.padStart(2, '0')}${this.alpha.toString(16).padStart(2, '0')}`;
}
}
toRgb() {
if (this.alpha === 255) {
return `rgb(${this.red}, ${this.green}, ${this.blue})`;
}
else {
return `rgba(${this.red}, ${this.green}, ${this.blue}, ${Math.round((this.alpha / 255) * 100)}%)`;
}
}
toHsl() {
throw new Error(`Getting HSL is not implemented`);
}
}
/**
* Checks if the given value is a valid hex color string
*
* @param value - value to check
* @returns true if the value is a valid hex color string (e.g., `#009edd`, `#fff`, etc.)
*
* @private function of Color
*/
function isHexColorString(value) {
return (typeof value === 'string' && /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(value));
}
/**
* Constant for short hex lengths.
*/
const SHORT_HEX_LENGTHS = new Set([3, 4]);
/**
* Constant for long hex lengths.
*/
const LONG_HEX_LENGTHS = new Set([6, 8]);
/**
* Parses a hex string into RGBA channel values.
*
* @param hex - Hex value such as `#09d`, `009edd`, `#009eddff`.
* @returns RGBA channel values.
*
* @private function of Color
*/
function parseHexColor(hex) {
const sanitized = hex.startsWith('#') ? hex.substring(1) : hex;
const throwInvalidHex = () => {
throw new Error(`Can not parse color from hex string "${hex}"`);
};
if (SHORT_HEX_LENGTHS.has(sanitized.length)) {
return {
red: parseShortHexChannel(sanitized.charAt(0), throwInvalidHex),
green: parseShortHexChannel(sanitized.charAt(1), throwInvalidHex),
blue: parseShortHexChannel(sanitized.charAt(2), throwInvalidHex),
alpha: sanitized.length === 4 ? parseShortHexChannel(sanitized.charAt(3), throwInvalidHex) : 255,
};
}
if (LONG_HEX_LENGTHS.has(sanitized.length)) {
return {
red: parseLongHexChannel(sanitized, 0, throwInvalidHex),
green: parseLongHexChannel(sanitized, 2, throwInvalidHex),
blue: parseLongHexChannel(sanitized, 4, throwInvalidHex),
alpha: sanitized.length === 8 ? parseLongHexChannel(sanitized, 6, throwInvalidHex) : 255,
};
}
return throwInvalidHex();
}
/**
* Parses short hex channel.
*/
function parseShortHexChannel(char, onError) {
if (!char) {
return onError();
}
const parsed = parseInt(char, 16);
if (Number.isNaN(parsed)) {
return onError();
}
return parsed * 16;
}
/**
* Parses long hex channel.
*/
function parseLongHexChannel(hex, start, onError) {
const segment = hex.substr(start, 2);
if (segment.length < 2) {
return onError();
}
const parsed = parseInt(segment, 16);
if (Number.isNaN(parsed)) {
return onError();
}
return parsed;
}
/**
* Pattern matching hsl.
*/
const HSL_REGEX = /^hsl\(\s*([0-9.]+)\s*,\s*([0-9.]+)%\s*,\s*([0-9.]+)%\s*\)$/;
/**
* Parses an HSL string into RGBA channel values.
*
* @param hsl - HSL string such as `hsl(197.1, 100%, 43.3%)`.
* @returns RGBA channel values.
*
* @private function of Color
*/
function parseHslColor(hsl) {
const match = hsl.match(HSL_REGEX);
if (!match) {
throw new Error(`Invalid hsl string format: "${hsl}"`);
}
const hue = parseFloat(match[1]);
const saturation = parseFloat(match[2]) / 100;
const lightness = parseFloat(match[3]) / 100;
const { red, green, blue } = convertHslToRgb(hue, saturation, lightness);
return {
red,
green,
blue,
alpha: 255,
};
}
/**
* Handles convert hsl to Rgb.
*/
function convertHslToRgb(h, s, l) {
const c = (1 - Math.abs(2 * l - 1)) * s;
const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
const m = l - c / 2;
let r1 = 0;
let g1 = 0;
let b1 = 0;
if (h >= 0 && h < 60) {
r1 = c;
g1 = x;
}
else if (h >= 60 && h < 120) {
r1 = x;
g1 = c;
}
else if (h >= 120 && h < 180) {
g1 = c;
b1 = x;
}
else if (h >= 180 && h < 240) {
g1 = x;
b1 = c;
}
else if (h >= 240 && h < 300) {
r1 = x;
b1 = c;
}
else if (h >= 300 && h < 360) {
r1 = c;
b1 = x;
}
return {
red: Math.round((r1 + m) * 255),
green: Math.round((g1 + m) * 255),
blue: Math.round((b1 + m) * 255),
};
}
/**
* Pattern matching RGB.
*/
const RGB_REGEX = /^rgb\(\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*\)$/;
/**
* Pattern matching rgba.
*/
const RGBA_REGEX = /^rgba\(\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*\)$/;
/**
* Parses an RGB string into RGBA channel values.
*
* @param rgb - RGB string such as `rgb(0%, 62%, 86.7%)`.
* @returns RGBA channel values.
*
* @private function of Color
*/
function parseRgbColor(rgb) {
const match = rgb.match(RGB_REGEX);
if (!match) {
throw new Error(`Invalid rgb string format: "${rgb}"`);
}
return {
red: parseChannelValue(match[1]),
green: parseChannelValue(match[2]),
blue: parseChannelValue(match[3]),
alpha: 255,
};
}
/**
* Parses an RGBA string into RGBA channel values.
*
* @param rgba - RGBA string such as `rgba(0, 158, 221, 0.5)`.
* @returns RGBA channel values.
*
* @private function of Color
*/
function parseRgbaColor(rgba) {
const match = rgba.match(RGBA_REGEX);
if (!match) {
throw new Error(`Invalid rgba string format: "${rgba}"`);
}
return {
red: parseChannelValue(match[1]),
green: parseChannelValue(match[2]),
blue: parseChannelValue(match[3]),
alpha: parseAlphaValue(match[4]),
};
}
/**
* Parses channel value.
*/
function parseChannelValue(value) {
if (value.endsWith('%')) {
const percent = parseFloat(value);
return Math.round((percent / 100) * 255);
}
return Math.round(parseFloat(value));
}
/**
* Parses alpha value.
*/
function parseAlphaValue(value) {
if (value.endsWith('%')) {
const percent = parseFloat(value);
return Math.round((percent / 100) * 255);
}
const parsed = parseFloat(value);
if (parsed <= 1) {
return Math.round(parsed * 255);
}
return Math.round(parsed);
}
/**
* Pattern matching hsl regex.
*
* @private function of Color
*/
const HSL_REGEX_PATTERN = /^hsl\(\s*([0-9.]+)\s*,\s*([0-9.]+)%\s*,\s*([0-9.]+)%\s*\)$/;
/**
* Pattern matching RGB regex.
*
* @private function of Color
*/
const RGB_REGEX_PATTERN = /^rgb\(\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*\)$/;
/**
* Pattern matching rgba regex.
*
* @private function of Color
*/
const RGBA_REGEX_PATTERN = /^rgba\(\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*,\s*([0-9.%-]+)\s*\)$/;
/**
* Parses a supported color string into RGBA channels.
*
* @param color as a string for example `#009edd`, `rgb(0,158,221)`, `rgb(0%,62%,86.7%)`, `hsl(197.1,100%,43.3%)`, `red`, `darkgrey`,...
* @returns RGBA channel values.
*
* @private function of Color
*/
function parseColorString(color) {
const trimmed = color.trim();
const cssColor = CSS_COLORS[trimmed];
if (cssColor) {
return parseColorString(cssColor);
}
else if (isHexColorString(trimmed)) {
return parseHexColor(trimmed);
}
if (HSL_REGEX_PATTERN.test(trimmed)) {
return parseHslColor(trimmed);
}
else if (RGB_REGEX_PATTERN.test(trimmed)) {
return parseRgbColor(trimmed);
}
else if (RGBA_REGEX_PATTERN.test(trimmed)) {
return parseRgbaColor(trimmed);
}
else {
throw new Error(`Can not create a new Color instance from string "${trimmed}".`);
}
}
/**
* Color object represents an RGB color with alpha channel
*
* Note: There is no fromObject/toObject because the most logical way to serialize color is as a hex string (#009edd)
*
* @public exported from `@promptbook/color`
*/
class Color extends ColorValue {
/**
* Creates a new Color instance from miscellaneous formats
* - It can receive Color instance and just return the same instance
* - It can receive color in string format for example `#009edd`, `rgb(0,158,221)`, `rgb(0%,62%,86.7%)`, `hsl(197.1,100%,43.3%)`
*
* Note: This is not including fromImage because detecting color from an image is heavy task which requires async stuff and we cannot safely determine with overloading if return value will be a promise
*
* @param color
* @returns Color object
*/
static from(color, _isSingleValue = false) {
if (color === '') {
throw new Error(`Can not create color from empty string`);
}
else if (color instanceof Color) {
return take(color);
}
else if (Color.isColor(color)) {
return take(color);
}
else if (typeof color === 'string') {
try {
return Color.fromString(color);
}
catch (error) {
// <- Note: Can not use `assertsError(error)` here because it causes circular dependency
if (_isSingleValue) {
throw error;
}
const parts = color.split(/[\s+,;|]/);
if (parts.length > 0) {
return Color.from(parts[0].trim(), true);
}
else {
throw new Error(`Can not create color from given string "${color}"`);
}
}
}
else {
console.error({ color });
throw new Error(`Can not create color from given object`);
}
}
/**
* Creates a new Color instance from miscellaneous formats
* It just does not throw error when it fails, it returns PROMPTBOOK_COLOR instead
*
* @param color
* @returns Color object
*/
static fromSafe(color) {
try {
return Color.from(color);
}
catch (error) {
// <- Note: Can not use `assertsError(error)` here because it causes circular dependency
console.warn(spaceTrim((block) => `
Color.fromSafe error:
${block(error.message)}
Returning default PROMPTBOOK_COLOR.
`));
return Color.fromString('promptbook');
}
}
/**
* Creates a new Color instance from miscellaneous string formats
*
* @param color as a string for example `#009edd`, `rgb(0,158,221)`, `rgb(0%,62%,86.7%)`, `hsl(197.1,100%,43.3%)`, `red`, `darkgrey`,...
* @returns Color object
*/
static fromString(color) {
return Color.fromColorChannels(parseColorString(color));
}
/**
* Gets common color
*
* @param key as a css string like `midnightblue`
* @returns Color object
*/
static get(key) {
if (!CSS_COLORS[key]) {
throw new Error(`"${key}" is not a common css color.`);
}
return Color.fromString(CSS_COLORS[key]);
}
/**
* Creates a new Color instance from average color of given image
*
* @param image as a source for example `data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAAXNSR0IArs4c6QAAAA1JREFUGFdjYJh39z8ABJgCe/ZvAS4AAAAASUVORK5CYII=`
* @returns Color object
*/
static async fromImage(image) {
return Color.fromHex(`#009edd`);
}
/**
* Creates a new Color instance from color in hex format
*
* @param color in hex for example `#009edd`, `009edd`, `#555`,...
* @returns Color object
*/
static fromHex(hex) {
return Color.fromColorChannels(parseHexColor(hex));
}
/**
* Creates a new Color instance from color in hsl format
*
* @param color as a hsl for example `hsl(197.1,100%,43.3%)`
* @returns Color object
*/
static fromHsl(hsl) {
return Color.fromColorChannels(parseHslColor(hsl));
}
/**
* Creates a new Color instance from color in rgb format
*
* @param color as a rgb for example `rgb(0,158,221)`, `rgb(0%,62%,86.7%)`
* @returns Color object
*/
static fromRgbString(rgb) {
return Color.fromColorChannels(parseRgbColor(rgb));
}
/**
* Creates a new Color instance from color in rbga format
*
* @param color as a rgba for example `rgba(0,158,221,0.5)`, `rgb(0%,62%,86.7%,50%)`
* @returns Color object
*/
static fromRgbaString(rgba) {
return Color.fromColorChannels(parseRgbaColor(rgba));
}
/**
* Creates a new Color for color channels values
*
* @param red number from 0 to 255
* @param green number from 0 to 255
* @param blue number from 0 to 255
* @param alpha number from 0 (transparent) to 255 (opaque = default)
* @returns Color object
*/
static fromValues(red, green, blue, alpha = 255) {
return Color.fromColorChannels({ red, green, blue, alpha });
}
/**
* Checks if the given value is a valid Color object.
*
* @param {unknown} value - The value to check.
* @return {value is WithTake<Color>} Returns true if the value is a valid Color object, false otherwise.
*/
static isColor(value) {
if (typeof value !== 'object') {
return false;
}
if (value === null) {
return false;
}
if (typeof value.red !== 'number' ||
typeof value.green !== 'number' ||
typeof value.blue !== 'number' ||
typeof value.alpha !== 'number') {
return false;
}
if (typeof value.then !== 'function') {
return false;
}
return true;
}
/**
* Checks if the given value is a valid hex color string
*
* @param value - value to check
* @returns true if the value is a valid hex color string (e.g., `#009edd`, `#fff`, etc.)
*/
static isHexColorString(value) {
return isHexColorString(value);
}
/**
* Creates new Color object
*
* Note: Consider using one of static methods like `from` or `fromString`
*
* @param red number from 0 to 255
* @param green number from 0 to 255
* @param blue number from 0 to 255
* @param alpha number from 0 (transparent) to 255 (opaque)
*/
constructor(red, green, blue, alpha = 255) {
super(red, green, blue, alpha);
}
createColor(red, green, blue, alpha) {
return new Color(red, green, blue, alpha);
}
static fromColorChannels({ red, green, blue, alpha }) {
return take(new Color(red, green, blue, alpha));
}
}
/**
* Makes color transformer which returns a grayscale version of the color
*
* @param amount from 0 to 1
*
* @public exported from `@promptbook/color`
*/
function grayscale(amount) {
return ({ red, green, blue, alpha }) => {
const average = (red + green + blue) / 3;
red = Math.round(average * amount + red * (1 - amount));
green = Math.round(average * amount + green * (1 - amount));
blue = Math.round(average * amount + blue * (1 - amount));
return Color.fromValues(red, green, blue, alpha);
};
}
/**
* Converts HSL values to RGB values
*
* @param hue [0-1]
* @param saturation [0-1]
* @param lightness [0-1]
* @returns [red, green, blue] [0-255]
*
* @private util of `@promptbook/color`
*/
function hslToRgb(hue, saturation, lightness) {
let red;
let green;
let blue;
if (saturation === 0) {
// achromatic
red = lightness;
green = lightness;
blue = lightness;
}
else {
// TODO: Extract to separate function
const hue2rgb = (p, q, t) => {
if (t < 0)
t += 1;
if (t > 1)
t -= 1;
if (t < 1 / 6)
return p + (q - p) * 6 * t;
if (t < 1 / 2)
return q;
if (t < 2 / 3)
return p + (q - p) * (2 / 3 - t) * 6;
return p;
};
const q = lightness < 0.5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation;
const p = 2 * lightness - q;
red = hue2rgb(p, q, hue + 1 / 3);
green = hue2rgb(p, q, hue);
blue = hue2rgb(p, q, hue - 1 / 3);
}
return [Math.round(red * 255), Math.round(green * 255), Math.round(blue * 255)];
}
// TODO: Properly name all used internal variables
/**
* Converts RGB values to HSL values
*
* @param red [0-255]
* @param green [0-255]
* @param blue [0-255]
* @returns [hue, saturation, lightness] [0-1]
*
* @private util of `@promptbook/color`
*/
function rgbToHsl(red, green, blue) {
red /= 255;
green /= 255;
blue /= 255;
const max = Math.max(red, green, blue);
const min = Math.min(red, green, blue);
let hue;
let saturation;
const lightness = (max + min) / 2;
if (max === min) {
// achromatic
hue = 0;
saturation = 0;
}
else {
const d = max - min;
saturation = lightness > 0.5 ? d / (2 - max - min) : d / (max + min);
switch (max) {
case red:
hue = (green - blue) / d + (green < blue ? 6 : 0);
break;
case green:
hue = (blue - red) / d + 2;
break;
case blue:
hue = (red - green) / d + 4;
break;
default:
hue = 0;
}
hue /= 6;
}
return [hue, saturation, lightness];
}
// TODO: Properly name all used internal variables
/**
* Makes color transformer which lighten the given color
*
* @param amount from 0 to 1
*
* @public exported from `@promptbook/color`
*/
function lighten(amount) {
return ({ red, green, blue, alpha }) => {
const [h, s, lInitial] = rgbToHsl(red, green, blue);
let l = lInitial + amount;
l = Math.max(0, Math.min(l, 1)); // Replace lodash clamp with Math.max and Math.min
const [r, g, b] = hslToRgb(h, s, l);
return Color.fromValues(r, g, b, alpha);
};
}
// TODO: Maybe implement by mix+hsl
/**
* Makes color transformer which saturate the given color
*
* @param amount from -1 to 1
*
* @public exported from `@promptbook/color`
*/
function saturate(amount) {
return ({ red, green, blue, alpha }) => {
const [h, sInitial, l] = rgbToHsl(red, green, blue);
let s = sInitial + amount;
s = Math.max(0, Math.min(s, 1));
const [r, g, b] = hslToRgb(h, s, l);
return Color.fromValues(r, g, b, alpha);
};
}
// TODO: Maybe implement by mix+hsl
/**
* Stable root directory used for Promptbook-owned temporary files and caches.
*
* @private internal utility for Promptbook temporary folders
*/
const PROMPTBOOK_TEMPORARY_DIRECTORY = '.promptbook';
/**
* Builds one normalized project-relative path inside Promptbook's dedicated temporary root.
*
* The returned path intentionally uses `/` separators so the same helper can be reused from
* Node.js and edge-safe code without depending on the Node `path` module.
*
* @private internal utility for Promptbook temporary folders
*/
function getPromptbookTemporaryPath(...pathSegments) {
const normalizedPathSegments = pathSegments.flatMap(splitPathSegments).filter(Boolean);
return [PROMPTBOOK_TEMPORARY_DIRECTORY, ...normalizedPathSegments].join('/');
}
/**
* Normalizes one raw path segment into slash-delimited pieces without empty items.
*/
function splitPathSegments(pathSegment) {
return pathSegment
.split(/[\\/]+/u)
.map((segment) => segment.trim())
.filter(Boolean);
}
// Note: [💞] Ignore a discrepancy between file name and entity name
/**
* Returns the same value that is passed as argument.
* No side effects.
*
* Note: It can be useful for:
*
* 1) Leveling indentation
* 2) Putting always-true or always-false conditions without getting eslint errors
*
* @param value any values
* @returns the same values
*
* @private within the repository
*/
function just(value) {
if (value === undefined) {
return undefined;
}
return value;
}
/**
* Name for the Promptbook
*
* TODO: [🗽] Unite branding and make single place for it
*
* @public exported from `@promptbook/core`
*/
const NAME = `Promptbook`;
/**
* Email of the responsible person
*
* @public exported from `@promptbook/core`
*/
const ADMIN_EMAIL = 'pavol@ptbk.io';
/**
* Name of the responsible person for the Promptbook on GitHub
*
* @public exported from `@promptbook/core`
*/
const ADMIN_GITHUB_NAME = 'hejny';
// <- TODO: [🐊] Pick the best claim
/**
* Color of the Promptbook
*
* TODO: [🗽] Unite branding and make single place for it
*
* @public exported from `@promptbook/core`
*/
const PROMPTBOOK_COLOR = Color.fromString('promptbook');
// <- TODO: [🧠][🈵] Using `Color` here increases the package size approx 3kb, maybe remove it
/**
* Colors for syntax highlighting in the `<BookEditor/>`
*
* TODO: [🗽] Unite branding and make single place for it
*
* @public exported from `@promptbook/core`
*/
({
TITLE: Color.fromHex('#244EA8'),
LINE: Color.fromHex('#eeeeee'),
SEPARATOR: Color.fromHex('#cccccc'),
COMMITMENT: Color.fromHex('#DA0F78'),
NOTE_COMMITMENT: Color.fromHex('#8080807e'),
TODO_COMMITMENT_TEXT: Color.fromHex('#000000'),
TODO_COMMITMENT_BACKGROUND: Color.fromHex('#FFEB3B'),
PARAMETER: Color.fromHex('#8e44ad'),
CODE_BLOCK: Color.fromHex('#7700ffff'),
});
// <- TODO: [🧠][🈵] Using `Color` here increases the package size approx 3kb, maybe remove it
/**
* Chat color of the Promptbook (in chat)
*
* TODO: [🗽] Unite branding and make single place for it
*
* @public exported from `@promptbook/core`
*/
PROMPTBOOK_COLOR.then(lighten(0.1)).then(saturate(0.9)).then(grayscale(0.9));
// <- TODO: [🧠][🈵] Using `Color` and `lighten`, `saturate`,... here increases the package size approx 3kb, maybe remove it
/**
* Color of the user (in chat)
*
* TODO: [🗽] Unite branding and make single place for it
*
* @public exported from `@promptbook/core`
*/
Color.fromHex('#1D4ED8');
// <- TODO: [🧠] Better system for generator warnings - not always "code" and "by `@promptbook/cli`"
/**
* The maximum number of iterations for a loops
*
* @private within the repository - too low-level in comparison with other `MAX_...`
*/
const LOOP_LIMIT = 1000;
// <- TODO: [🕝] Make also `AGENTS_DIRNAME_ALTERNATIVES`
/**
* Where to store the temporary downloads
*
* Note: When the folder does not exist, it is created recursively
*
* @public exported from `@promptbook/core`
*/
`./${getPromptbookTemporaryPath('download-cache')}`;
/**
* Where to store the cache of executions for promptbook CLI
*
* Note: When the folder does not exist, it is created recursively
*
* @public exported from `@promptbook/core`
*/
`./${getPromptbookTemporaryPath('execution-cache')}`;
/**
* Where to store the scrape cache
*
* Note: When the folder does not exist, it is created recursively
*
* @public exported from `@promptbook/core`
*/
`./${getPromptbookTemporaryPath('scrape-cache')}`;
// <- TODO: [🧜♂️]
/**
* Default settings for parsing and generating CSV files in Promptbook.
*
* @public exported from `@promptbook/core`
*/
Object.freeze({
delimiter: ',',
quoteChar: '"',
newline: '\n',
skipEmptyLines: true,
});
/**
* API request timeout in milliseconds
* Can be overridden via API_REQUEST_TIMEOUT environment variable
*
* @public exported from `@promptbook/core`
*/
parseInt(process.env.API_REQUEST_TIMEOUT || '90000');
/**
* Indicates whether pipeline logic validation is enabled. When true, the pipeline logic is checked for consistency.
*
* @private within the repository
*/
const IS_PIPELINE_LOGIC_VALIDATED = just(
/**/
// Note: In normal situations, we check the pipeline logic:
true);
/**
* Note: [💞] Ignore a discrepancy between file name and entity name
* TODO: [🧠][🧜♂️] Maybe join remoteServerUrl and path into single value
*/
/**
* Make error report URL for the given error
*
* @private private within the repository
*/
function getErrorReportUrl(error) {
const report = {
title: `🐜 Error report from ${NAME}`,
body: spaceTrim$1((block) => `
\`${error.name || 'Error'}\` has occurred in the [${NAME}], please look into it @${ADMIN_GITHUB_NAME}.
\`\`\`
${block(error.message || '(no error message)')}
\`\`\`
## More info:
- **Promptbook engine version:** ${PROMPTBOOK_ENGINE_VERSION}
- **Book language version:** ${BOOK_LANGUAGE_VERSION}
- **Time:** ${new Date().toISOString()}
<details>
<summary>Stack trace:</summary>
## Stack trace:
\`\`\`stacktrace
${block(error.stack || '(empty)')}
\`\`\`
</details>
`),
};
const reportUrl = new URL(`https://github.com/webgptorg/promptbook/issues/new`);
reportUrl.searchParams.set('labels', 'bug');
reportUrl.searchParams.set('assignees', ADMIN_GITHUB_NAME);
reportUrl.searchParams.set('title', report.title);
reportUrl.searchParams.set('body', report.body);
return reportUrl;
}
/**
* This error type indicates that the error should not happen and its last check before crashing with some other error
*
* @public exported from `@promptbook/core`
*/
class UnexpectedError extends Error {
constructor(message) {
super(spaceTrim$1((block) => `
${block(message)}
Note: This error should not happen.
It's probably a bug in the pipeline collection
Please report issue:
${block(getErrorReportUrl(new Error(message)).href)}
Or contact us on ${ADMIN_EMAIL}
`));
this.name = 'UnexpectedError';
Object.setPrototypeOf(this, UnexpectedError.prototype);
}
}
/**
* This error type indicates that somewhere in the code non-Error object was thrown and it was wrapped into the `WrappedError`
*
* @public exported from `@promptbook/core`
*/
class WrappedError extends Error {
constructor(whatWasThrown) {
const tag = `[🤮]`;
console.error(tag, whatWasThrown);
super(spaceTrim$1(`
Non-Error object was thrown
Note: Look for ${tag} in the console for more details
Please report issue on ${ADMIN_EMAIL}
`));
this.name = 'WrappedError';
Object.setPrototypeOf(this, WrappedError.prototype);
}
}
/**
* Helper used in catch blocks to assert that the error is an instance of `Error`
*
* @param whatWasThrown Any object that was thrown
* @returns Nothing if the error is an instance of `Error`
* @throws `WrappedError` or `UnexpectedError` if the error is not standard
*
* @private within the repository
*/
function assertsError(whatWasThrown) {
// Case 1: Handle error which was rethrown as `WrappedError`
if (whatWasThrown instanceof WrappedError) {
const wrappedError = whatWasThrown;
throw wrappedError;
}
// Case 2: Handle unexpected errors
if (whatWasThrown instanceof UnexpectedError) {
const unexpectedError = whatWasThrown;
throw unexpectedError;
}
// Case 3: Handle standard errors - keep them up to consumer
if (whatWasThrown instanceof Error) {
return;
}
// Case 4: Handle non-standard errors - wrap them into `WrappedError` and throw
throw new WrappedError(whatWasThrown);
}
/**
* Function isValidJsonString will tell you if the string is valid JSON or not
*
* @param value The string to check
* @returns `true` if the string is a valid JSON string, false otherwise
*
* @public exported from `@promptbook/utils`
*/
function isValidJsonString(value /* <- [👨⚖️] */) {
try {
JSON.parse(value);
return true;
}
catch (error) {
assertsError(error);
if (error.message.includes('Unexpected token')) {
return false;
}
return false;
}
}
/**
* Function `validatePipelineString` will validate the if the string is a valid pipeline string
* It does not check if the string is fully logically correct, but if it is a string that can be a pipeline string or the string looks completely different.
*
* Note: [🔂] This function is idempotent.
*
* @param {string} pipelineString the candidate for a pipeline string
* @returns {PipelineString} the same string as input, but validated as valid
* @throws {ParseError} if the string is not a valid pipeline string
*
* @public exported from `@promptbook/core`
*/
function validatePipelineString(pipelineString) {
if (isValidJsonString(pipelineString)) {
throw new ParseError('Expected a book, but got a JSON string');
}
else if (isValidUrl(pipelineString)) {
throw new ParseError(`Expected a book, but got just the URL "${pipelineString}"`);
}
else if (isValidFilePath(pipelineString)) {
throw new ParseError(`Expected a book, but got just the file path "${pipelineString}"`);
}
else if (isValidEmail(pipelineString)) {
throw new ParseError(`Expected a book, but got just the email "${pipelineString}"`);
}
// <- TODO: Implement the validation + add tests when the pipeline logic considered as invalid
return pipelineString;
}
// TODO: [🧠][🈴] Where is the best location for this file
/**
* Appends one markdown block to an existing markdown document.
*
* @private internal utility of `pipelineJsonToString`
*/
function appendMarkdownBlock(pipelineString, markdownBlock) {
return spaceTrim$1((block) => `
${block(pipelineString)}
${block(markdownBlock)}
`);
}
/**
* Collects pipeline-level commands in the existing serialization order.
*
* @private internal utility of `pipelineJsonToString`
*/
function createPipelineCommands(pipelineJson) {
const { pipelineUrl, bookVersion, parameters } = pipelineJson;
const commands = [];
if (pipelineUrl) {
commands.push(`PIPELINE URL ${pipelineUrl}`);
}
if (bookVersion !== `undefined`) {
commands.push(`BOOK VERSION ${bookVersion}`);
}
commands.push(...createParameterCommands(parameters, 'INPUT PARAMETER', ({ isInput }) => isInput));
commands.push(...createParameterCommands(parameters, 'OUTPUT PARAMETER', ({ isOutput }) => isOutput));
return commands;
}
/**
* Builds one group of parameter commands while preserving the original parameter order.
*
* @private internal utility of `createPipelineCommands`
*/
function createParameterCommands(parameters, commandPrefix, isIncluded) {
return parameters
.filter((parameter) => isIncluded(parameter))
.map((parameter) => `${commandPrefix} ${parameterJsonToString(parameter)}`);
}
/**
* Converts one parameter JSON declaration to the serialized inline form.
*
* @private internal utility of `createPipelineCommands`
*/
function parameterJsonToString(parameterJson) {
const { name, description } = parameterJson;
if (!description) {
return `{${name}}`;
}
return `{${name}} ${description}`;
}
/**
* Prettify the html code
*
* @param content raw html code
* @returns formatted html code
* @deprecated Prettier removed from Promptbook due to package size
*
* @private withing the package because of HUGE size of prettier dependency
*/
function prettifyMarkdown(content) {
return (content + `\n\n<!-- Note: Prettier removed from Promptbook -->`);
}
/**
* Creates the initial markdown heading and description of a pipeline.
*
* @private internal utility of `pipelineJsonToString`
*/
function createPipelineIntroduction(pipelineJson) {
const { title, description } = pipelineJson;
const pipelineIntroduction = spaceTrim$1((block) => `
# ${title}
${block(description || '')}
`);
// TODO: [main] !!5 This increases size of the bundle and is probably not necessary
return prettifyMarkdown(pipelineIntroduction);
}
/**
* Renders commands as markdown bullet items.
*
* @private internal utility of `pipelineJsonToString`
*/
function stringifyCommands(commands) {
return commands.map((command) => `- ${command}`).join('\n');
}
/**
* Makes first letter of a string uppercase
*
* Note: [🔂] This function is idempotent.
*
* @public exported from `@promptbook/utils`
*/
function capitalize(word) {
return word.substring(0, 1).toUpperCase() + word.substring(1);
}
/**
* Collects all task-specific serialization details.
*
* @private internal utility of `pipelineJsonToString`
*/
function createTaskSerialization(task) {
const taskTypeSerialization = createTaskTypeSerialization(task);
return {
commands: [
...taskTypeSerialization.commands,
...createJokerCommands(task),
...createPostprocessingCommands(task),
...createExpectationCommands(task),
...createFormatCommands(task),
],
contentLanguage: taskTypeSerialization.contentLanguage,
};
}
/**
* Collects commands and content language driven by the task type.
*
* @private internal utility of `createTaskSerialization`
*/
function createTaskTypeSerialization(task) {
if (task.taskType === 'PROMPT_TASK') {
return {
commands: createPromptTaskCommands(task),
contentLanguage: 'text',
};
}
if (task.taskType === 'SIMPLE_TASK') {
return {
commands: ['SIMPLE TEMPLATE'],
contentLanguage: 'text',
};
}
if (task.taskType === 'SCRIPT_TASK') {
return {
commands: ['SCRIPT'],
contentLanguage: task.contentLanguage || '',
};
}
if (task.taskType === 'DIALOG_TASK') {
return {
commands: ['DIALOG'],
contentLanguage: 'text',
};
}
return {
commands: [],
contentLanguage: 'text',
};
}
/**
* Collects prompt-task-specific commands.
*
* @private internal utility of `createTaskSerialization`
*/
function createPromptTaskCommands(task) {
const { modelName, modelVariant } = task.modelRequirements || {};
const commands = [];
// Note: Do nothing, it is default
// commands.push(`PROMPT`);
if (modelVariant) {
commands.push(`MODEL VARIANT ${capitalize(modelVariant)}`);
}
if (modelName) {
commands.push(`MODEL NAME \`${modelName}\``);
}
return commands;
}
/**
* Collects joker commands.
*
* @private internal utility of `createTaskSerialization`
*/
function createJokerCommands(task) {
var _a;
return ((_a = task.jokerParameterNames) === null || _a === void 0 ? void 0 : _a.map((joker) => `JOKER {${joker}}`)) || [];
}
/**
* Collects postprocessing commands.
*
* @private internal utility of `createTaskSerialization`
*/
function createPostprocessingCommands(task) {
var _a;
return (((_a = task.postprocessingFunctionNames) === null || _a === void 0 ? void 0 : _a.map((postprocessingFunctionName) => `POSTPROCESSING \`${postprocessingFunctionName}\``)) || []);
}
/**
* Collects expectation commands.
*
* @private internal utility of `createTaskSerialization`
*/
function createExpectationCommands(task) {
if (!task.expectations) {
return [];
}
return Object.entries(task.expectations).flatMap(([unit, expectation]) => createExpectationCommandsForUnit(unit, expectation.min, expectation.max));
}
/**
* Collects expectation commands for a single unit.
*
* @private internal utility of `createTaskSerialization`
*/
function createExpectationCommandsForUnit(unit, min, max) {
if (min === max) {
return [`EXPECT EXACTLY ${min} ${formatExpectationUnit(unit, min)}`];
}
const commands = [];
if (min !== undefined) {
commands.push(`EXPECT MIN ${min} ${formatExpectationUnit(unit, min)}`);
}
if (max !== undefined) {
commands.push(`EXPECT MAX ${max} ${formatExpectationUnit(unit, max)}`);
}
return commands;
}
/**
* Formats the expectation unit exactly as the legacy serializer does.
*
* @private internal utility of `createTaskSerialization`
*/
function formatExpectationUnit(unit, amount) {
return capitalize(unit + (amount > 1 ? 's' : ''));
}
/**
* Collects format commands.
*
* @private internal utility of `createTaskSerialization`
*/
function createFormatCommands(task) {
if (task.format === 'JSON') {
// TODO: @deprecated remove
return ['FORMAT JSON'];
}
return [];
}
/**
* Stringifies one task section of the pipeline.
*
* @private internal utility of `pipelineJsonToString`
*/
function stringifyTask(task) {
const { title, description, content, resultingParameterName } = task;
const { commands, contentLanguage } = createTaskSeriali