@promptbook/cli 0.88.0-1 → 0.88.0-9

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

@@ -40,6 +40,7 @@ import type { ExecutionReportString } from '../execution/execution-report/Execut
 import type { ExecutionReportStringOptions } from '../execution/execution-report/ExecutionReportStringOptions';
 import type { ExecutionTask } from '../execution/ExecutionTask';
 import type { PreparationTask } from '../execution/ExecutionTask';
+import type { task_status } from '../execution/ExecutionTask';
 import type { AbstractTask } from '../execution/ExecutionTask';
 import type { Task } from '../execution/ExecutionTask';
 import type { ExecutionTools } from '../execution/ExecutionTools';
@@ -322,6 +323,7 @@ export type { ExecutionReportString };
 export type { ExecutionReportStringOptions };
 export type { ExecutionTask };
 export type { PreparationTask };
+export type { task_status };
 export type { AbstractTask };
 export type { Task };
 export type { ExecutionTools };

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

@@ -62,6 +62,7 @@ import { clonePipeline } from '../utils/serialization/clonePipeline';
 import { deepClone } from '../utils/serialization/deepClone';
 import { exportJson } from '../utils/serialization/exportJson';
 import { isSerializableAsJson } from '../utils/serialization/isSerializableAsJson';
+import { jsonStringsToJsons } from '../utils/serialization/jsonStringsToJsons';
 import { difference } from '../utils/sets/difference';
 import { intersection } from '../utils/sets/intersection';
 import { union } from '../utils/sets/union';
@@ -143,6 +144,7 @@ export { clonePipeline };
 export { deepClone };
 export { exportJson };
 export { isSerializableAsJson };
+export { jsonStringsToJsons };
 export { difference };
 export { intersection };
 export { union };

package/esm/typings/src/cli/cli-commands/common/handleActionErrors.d.ts

@@ -0,0 +1,11 @@
+import type { Command as Program } from 'commander';
+type actionCallbackFunction = Parameters<Program['action']>[0];
+/**
+ * Wraps action to handle error console logging and exit process with error code
+ *
+ * @param action Action to be wrapped in error handling
+ * @returns Wrapped action
+ * @private internal helper function for CLI commands
+ */
+export declare function handleActionErrors(action: actionCallbackFunction): actionCallbackFunction;
+export {};

package/esm/typings/src/execution/ExecutionTask.d.ts

@@ -40,6 +40,10 @@ export type PreparationTask = AbstractTask<PipelineExecutorResult> & {
     readonly taskType: 'PREPARATION';
     readonly taskId: `prep-${task_id}`;
 };
+/**
+ * Status of a task
+ */
+export type task_status = 'RUNNING' | 'FINISHED' | 'ERROR';
 /**
  * Base interface for all task types
  */
@@ -52,6 +56,18 @@ export type AbstractTask<TTaskResult extends AbstractTaskResult> = {
      * Unique identifier for the task
      */
     readonly taskId: task_id;
+    /**
+     * Status of the task
+     */
+    readonly status: task_status;
+    /**
+     * Date when the task was created
+     */
+    readonly createdAt: Date;
+    /**
+     * Date when the task was last updated
+     */
+    readonly updatedAt: Date;
     /**
      * Gets a promise that resolves with the task result
      */
@@ -66,6 +82,14 @@ export type AbstractTask<TTaskResult extends AbstractTaskResult> = {
      * Gets just the current value which is mutated during the task processing
      */
     currentValue: PartialDeep<TTaskResult>;
+    /**
+     * List of errors that occurred during the task processing
+     */
+    readonly errors: Array<Error>;
+    /**
+     * List of warnings that occurred during the task processing
+     */
+    readonly warnings: Array<Error>;
 };
 export type Task = ExecutionTask | PreparationTask;
 export {};

package/esm/typings/src/utils/serialization/jsonStringsToJsons.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Recursively converts JSON strings to JSON objects
+
+ * @public exported from `@promptbook/utils`
+ */
+export declare function jsonStringsToJsons<T>(object: T): T;
+/**
+ * TODO: Type the return type correctly
+ */

package/esm/typings/src/utils/serialization/jsonStringsToJsons.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/cli",
-    "version": "0.88.0-1",
+    "version": "0.88.0-9",
     "description": "It's time for a paradigm shift. The future of software in plain English, French or Latin",
     "private": false,
     "sideEffects": false,

package/umd/index.umd.js

@@ -54,7 +54,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.88.0-1';
+    const PROMPTBOOK_ENGINE_VERSION = '0.88.0-9';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -407,6 +407,30 @@
      * TODO: [🎺]
      */
 
+    /**
+     * Wraps action to handle error console logging and exit process with error code
+     *
+     * @param action Action to be wrapped in error handling
+     * @returns Wrapped action
+     * @private internal helper function for CLI commands
+     */
+    function handleActionErrors(action) {
+        return async (...args) => {
+            try {
+                await action(...args);
+                return process.exit(0);
+            }
+            catch (error) {
+                if (!(error instanceof Error)) {
+                    throw error;
+                }
+                // console.error(colors.bgRed(error.name));
+                console.error(colors__default["default"].red(/* error.stack || */ error.message));
+                return process.exit(1);
+            }
+        };
+    }
+
     /**
      * Initializes `about` command for Promptbook CLI utilities
      *
@@ -419,7 +443,7 @@
         makeCommand.description(spaceTrim__default["default"](`
             Tells about Promptbook CLI and its abilities
         `));
-        makeCommand.action(async () => {
+        makeCommand.action(handleActionErrors(async () => {
             console.info(colors__default["default"].bold(colors__default["default"].blue(`Promptbook: ${CLAIM}`)));
             console.info(colors__default["default"].cyan(`Book language version: ${BOOK_LANGUAGE_VERSION}`));
             console.info(colors__default["default"].cyan(`Promptbook engine version: ${PROMPTBOOK_ENGINE_VERSION}`));
@@ -446,7 +470,7 @@
             console.info(colors__default["default"].gray(`https://github.com/webgptorg/promptbook`));
             console.info(colors__default["default"].gray(`https://ptbk.io`));
             return process.exit(0);
-        });
+        }));
     }
     /**
      * TODO: [🗽] Unite branding and make single place for it
@@ -469,12 +493,12 @@
         helloCommand.alias('hi');
         helloCommand.argument('[name]', 'Your name', 'Paul');
         helloCommand.option('-g, --greeting <greeting>', `Greeting`, 'Hello');
-        helloCommand.action(async (name, { greeting }) => {
+        helloCommand.action(handleActionErrors(async (name, { greeting }) => {
             console.info(colors__default["default"].cyan(`${greeting} ${name}`));
             await waitasecond.forTime(1000);
             console.info(colors__default["default"].rainbow(`Nice to meet you!`));
             return process.exit(0);
-        });
+        }));
     }
     /**
      * TODO: [🧠][🐣] Make here some easter egg with generated hello greeting via LLM models
@@ -2563,13 +2587,13 @@
         `));
         listModelsCommand.alias('models');
         listModelsCommand.alias('llm');
-        listModelsCommand.action(async () => {
+        listModelsCommand.action(handleActionErrors(async () => {
             const llm = await $provideLlmToolsForWizzardOrCli({});
             $sideEffect(llm);
             // <- Note: Providing LLM tools will make a side effect of registering all available LLM tools to show the message
             console.info($registeredLlmToolsMessage());
             return process.exit(0);
-        });
+        }));
     }
     /**
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3095,7 +3119,7 @@
             List all available and configured scrapers and executables
         `));
         listModelsCommand.alias('scrapers');
-        listModelsCommand.action(async () => {
+        listModelsCommand.action(handleActionErrors(async () => {
             const scrapers = await $provideScrapersForNode({});
             const executables = await $provideExecutablesForNode();
             console.info(spaceTrim__default["default"]((block) => `
@@ -3112,7 +3136,7 @@
             .join('\n'))}
                 `));
             return process.exit(0);
-        });
+        }));
     }
     /**
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -4074,6 +4098,36 @@
      * TODO: Maybe use nanoid instead https://github.com/ai/nanoid
      */
 
+    /**
+     * Recursively converts JSON strings to JSON objects
+
+     * @public exported from `@promptbook/utils`
+     */
+    function jsonStringsToJsons(object) {
+        if (object === null) {
+            return object;
+        }
+        if (Array.isArray(object)) {
+            return object.map(jsonStringsToJsons);
+        }
+        if (typeof object !== 'object') {
+            return object;
+        }
+        const newObject = { ...object };
+        for (const [key, value] of Object.entries(object)) {
+            if (typeof value === 'string' && isValidJsonString(value)) {
+                newObject[key] = JSON.parse(value);
+            }
+            else {
+                newObject[key] = jsonStringsToJsons(value);
+            }
+        }
+        return newObject;
+    }
+    /**
+     * TODO: Type the return type correctly
+     */
+
     /**
      * This error indicates problems parsing the format value
      *
@@ -4290,21 +4344,43 @@
     function createTask(options) {
         const { taskType, taskProcessCallback } = options;
         const taskId = `${taskType.toLowerCase().substring(0, 4)}-${$randomToken(8 /* <- TODO: To global config + Use Base58 to avoid simmilar char conflicts   */)}`;
-        const partialResultSubject = new rxjs.BehaviorSubject({});
+        let status = 'RUNNING';
+        const createdAt = new Date();
+        let updatedAt = createdAt;
+        const errors = [];
+        const warnings = [];
+        let currentValue = {};
+        const partialResultSubject = new rxjs.Subject();
+        // <- Note: Not using `BehaviorSubject` because on error we can't access the last value
         const finalResultPromise = /* not await */ taskProcessCallback((newOngoingResult) => {
+            Object.assign(currentValue, newOngoingResult);
+            // <- TODO: assign deep
             partialResultSubject.next(newOngoingResult);
         });
         finalResultPromise
             .catch((error) => {
+            errors.push(error);
             partialResultSubject.error(error);
         })
-            .then((value) => {
-            if (value) {
+            .then((executionResult) => {
+            if (executionResult) {
                 try {
-                    assertsTaskSuccessful(value);
-                    partialResultSubject.next(value);
+                    updatedAt = new Date();
+                    errors.push(...executionResult.errors);
+                    warnings.push(...executionResult.warnings);
+                    // <- TODO: !!! Only unique errors and warnings should be added (or filtered)
+                    // TODO: [🧠] !!! errors, warning, isSuccessful  are redundant both in `ExecutionTask` and `ExecutionTask.currentValue`
+                    //            Also maybe move `ExecutionTask.currentValue.usage` -> `ExecutionTask.usage`
+                    //            And delete `ExecutionTask.currentValue.preparedPipeline`
+                    assertsTaskSuccessful(executionResult);
+                    status = 'FINISHED';
+                    currentValue = jsonStringsToJsons(executionResult);
+                    // <- TODO: Convert JSON values in string to JSON objects
+                    partialResultSubject.next(executionResult);
                 }
                 catch (error) {
+                    status = 'ERROR';
+                    errors.push(error);
                     partialResultSubject.error(error);
                 }
             }
@@ -4321,12 +4397,33 @@
         return {
             taskType,
             taskId,
+            get status() {
+                return status;
+                // <- Note: [1] Theese must be getters to allow changing the value in the future
+            },
+            get createdAt() {
+                return createdAt;
+                // <- Note: [1]
+            },
+            get updatedAt() {
+                return updatedAt;
+                // <- Note: [1]
+            },
             asPromise,
             asObservable() {
                 return partialResultSubject.asObservable();
             },
+            get errors() {
+                return errors;
+                // <- Note: [1]
+            },
+            get warnings() {
+                return warnings;
+                // <- Note: [1]
+            },
             get currentValue() {
-                return partialResultSubject.value;
+                return currentValue;
+                // <- Note: [1]
             },
         };
     }
@@ -5522,7 +5619,7 @@
                         Last result:
                         ${block($ongoingTaskResult.$resultString === null
                     ? 'null'
-                    : $ongoingTaskResult.$resultString
+                    : spaceTrim.spaceTrim($ongoingTaskResult.$resultString)
                         .split('\n')
                         .map((line) => `> ${line}`)
                         .join('\n'))}
@@ -11239,7 +11336,7 @@
             Note: This can be used only with "javascript" or "typescript" format
 
         `), DEFAULT_GET_PIPELINE_COLLECTION_FUNCTION_NAME);
-        makeCommand.action(async (path$1, { projectName, rootUrl, format, functionName, validation, reload: isCacheReloaded, verbose: isVerbose, output, }) => {
+        makeCommand.action(handleActionErrors(async (path$1, { projectName, rootUrl, format, functionName, validation, reload: isCacheReloaded, verbose: isVerbose, output, }) => {
             if (!isValidJavascriptName(functionName)) {
                 console.error(colors__default["default"].red(`Function name "${functionName}" is not valid javascript name`));
                 return process.exit(1);
@@ -11266,9 +11363,9 @@
                 isVerbose,
                 isCacheReloaded,
             }; /* <- TODO: ` satisfies PrepareAndScrapeOptions` */
-            const fs = $provideFilesystemForNode();
+            const fs = $provideFilesystemForNode(prepareAndScrapeOptions);
             const llm = await $provideLlmToolsForWizzardOrCli(prepareAndScrapeOptions);
-            const executables = await $provideExecutablesForNode();
+            const executables = await $provideExecutablesForNode(prepareAndScrapeOptions);
             const tools = {
                 llm,
                 fs,
@@ -11426,7 +11523,7 @@
                 console.info(colors__default["default"].cyan(usageToHuman(llm.getTotalUsage())));
             }
             return process.exit(0);
-        });
+        }));
     }
     /**
      * TODO: [🥃][main] !!3 Allow `ptbk make` without configuring any llm tools
@@ -11533,7 +11630,7 @@
         'Pipelines to prettify as glob pattern');
         prettifyCommand.option('-i, --ignore <glob>', `Ignore as glob pattern`);
         prettifyCommand.option('-v, --verbose', `Is output verbose`, false);
-        prettifyCommand.action(async (filesGlob, { ignore, verbose: isVerbose }) => {
+        prettifyCommand.action(handleActionErrors(async (filesGlob, { ignore, verbose: isVerbose }) => {
             const filenames = await glob__default["default"](filesGlob, { ignore });
             //                       <- TODO: [😶]
             for (const filename of filenames) {
@@ -11565,7 +11662,7 @@
             }
             console.info(colors__default["default"].green(`All pipelines are prettified`));
             return process.exit(0);
-        });
+        }));
     }
     /**
      * TODO: [😶] Unite floder listing
@@ -12139,7 +12236,7 @@
         runCommand.option('--no-formfactor', `When set, behavior of the interactive mode is not changed by the formfactor of the pipeline`);
         runCommand.option('-j, --json <json>', `Pass all or some input parameters as JSON record, if used the output is also returned as JSON`);
         runCommand.option('-s, --save-report <path>', `Save report to file`);
-        runCommand.action(async (pipelineSource, options) => {
+        runCommand.action(handleActionErrors(async (pipelineSource, options) => {
             const { reload: isCacheReloaded, interactive: isInteractive, formfactor: isFormfactorUsed, json, verbose: isVerbose, saveReport, } = options;
             if (pipelineSource.includes('-') && normalizeToKebabCase(pipelineSource) === pipelineSource) {
                 console.error(colors__default["default"].red(`""${pipelineSource}" is not a valid command or book. See 'ptbk --help'.`));
@@ -12162,7 +12259,7 @@
             if (isVerbose) {
                 console.info(colors__default["default"].gray('--- Preparing tools ---'));
             }
-            const fs = $provideFilesystemForNode();
+            const fs = $provideFilesystemForNode(prepareAndScrapeOptions);
             let llm;
             try {
                 llm = await $provideLlmToolsForWizzardOrCli(prepareAndScrapeOptions);
@@ -12216,7 +12313,7 @@
             if (isVerbose) {
                 console.info(colors__default["default"].gray('--- Getting the tools ---'));
             }
-            const executables = await $provideExecutablesForNode();
+            const executables = await $provideExecutablesForNode(prepareAndScrapeOptions);
             const tools = {
                 llm,
                 fs,
@@ -12365,7 +12462,7 @@
                 console.info(JSON.stringify(outputParameters, null, 4));
             }
             return process.exit(0);
-        });
+        }));
     }
     /**
      * TODO: !!5 Catch and wrap all errors from CLI
@@ -12553,8 +12650,35 @@
                     .send({ error: serializeError(error) });
             }
         });
+        function exportExecutionTask(executionTask, isFull) {
+            // <- TODO: [🧠] This should be maybe method of `ExecutionTask` itself
+            const { taskType, taskId, status, errors, warnings, createdAt, updatedAt, currentValue } = executionTask;
+            if (isFull) {
+                return {
+                    nonce: '✨',
+                    taskId,
+                    taskType,
+                    status,
+                    errors: errors.map(serializeError),
+                    warnings: warnings.map(serializeError),
+                    createdAt,
+                    updatedAt,
+                    currentValue,
+                };
+            }
+            else {
+                return {
+                    nonce: '✨',
+                    taskId,
+                    taskType,
+                    status,
+                    createdAt,
+                    updatedAt,
+                };
+            }
+        }
         app.get(`${rootPath}/executions`, async (request, response) => {
-            response.send(runningExecutionTasks);
+            response.send(runningExecutionTasks.map((runningExecutionTask) => exportExecutionTask(runningExecutionTask, false)));
         });
         app.get(`${rootPath}/executions/last`, async (request, response) => {
             // TODO: [🤬] Filter only for user
@@ -12562,20 +12686,20 @@
                 response.status(404).send('No execution tasks found');
                 return;
             }
-            const lastExecution = runningExecutionTasks[runningExecutionTasks.length - 1];
-            response.send(lastExecution);
+            const lastExecutionTask = runningExecutionTasks[runningExecutionTasks.length - 1];
+            response.send(exportExecutionTask(lastExecutionTask, true));
         });
         app.get(`${rootPath}/executions/:taskId`, async (request, response) => {
             const { taskId } = request.params;
             // TODO: [🤬] Filter only for user
-            const execution = runningExecutionTasks.find((executionTask) => executionTask.taskId === taskId);
-            if (execution === undefined) {
+            const executionTask = runningExecutionTasks.find((executionTask) => executionTask.taskId === taskId);
+            if (executionTask === undefined) {
                 response
                     .status(404)
                     .send(`Execution "${taskId}" not found`);
                 return;
             }
-            response.send(execution.currentValue);
+            response.send(exportExecutionTask(executionTask, true));
         });
         app.post(`${rootPath}/executions/new`, async (request, response) => {
             try {
@@ -12809,7 +12933,7 @@
             Starts a remote server to execute books
         `));
         startServerCommand.alias('server');
-        startServerCommand.action(async (path, { port: portRaw, url: rawUrl, allowAnonymous: isAnonymousModeAllowed, reload: isCacheReloaded, verbose: isVerbose, }) => {
+        startServerCommand.action(handleActionErrors(async (path, { port: portRaw, url: rawUrl, allowAnonymous: isAnonymousModeAllowed, reload: isCacheReloaded, verbose: isVerbose, }) => {
             if (rawUrl && !isValidUrl(rawUrl)) {
                 console.error(colors__default["default"].red(`Invalid URL: ${rawUrl}`));
                 return process.exit(1);
@@ -12836,9 +12960,9 @@
                 isVerbose,
                 isCacheReloaded,
             }; /* <- TODO: ` satisfies PrepareAndScrapeOptions` */
-            const fs = $provideFilesystemForNode();
+            const fs = $provideFilesystemForNode(prepareAndScrapeOptions);
             const llm = await $provideLlmToolsForWizzardOrCli(prepareAndScrapeOptions);
-            const executables = await $provideExecutablesForNode();
+            const executables = await $provideExecutablesForNode(prepareAndScrapeOptions);
             const tools = {
                 llm,
                 fs,
@@ -12855,20 +12979,23 @@
                 // <- TODO: [🍖] Add `intermediateFilesStrategy`
             });
             // console.log(path, await collection.listPipelines());
-            startRemoteServer({
+            const server = startRemoteServer({
                 rootPath,
                 port,
                 isAnonymousModeAllowed,
                 isApplicationModeAllowed: true,
                 collection,
                 createLlmExecutionTools(options) {
+                    const { appId, userId } = options;
+                    TODO_USE({ appId, userId });
                     return llm;
                 },
             });
+            keepUnused(server);
             // Note: Already logged by `startRemoteServer`
             // console.error(colors.green(`Server started on port ${port}`));
             return await waitasecond.forEver();
-        });
+        }));
     }
     /**
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -12895,7 +13022,7 @@
         testCommand.option('--no-prepare', `Do not prepare the pipelines, ideal when no LLM tools or scrapers available`, true);
         testCommand.option('-r, --reload', `Call LLM models even if same prompt with result is in the cache `, false);
         testCommand.option('-v, --verbose', `Is output verbose`, false);
-        testCommand.action(async (filesGlob, { ignore: ignoreRaw = '', validation: isValidated, prepare: isPrepared, reload: isCacheReloaded, verbose: isVerbose, }) => {
+        testCommand.action(handleActionErrors(async (filesGlob, { ignore: ignoreRaw = '', validation: isValidated, prepare: isPrepared, reload: isCacheReloaded, verbose: isVerbose, }) => {
             let tools = undefined;
             if (isPrepared) {
                 // TODO: DRY [◽]
@@ -12903,9 +13030,9 @@
                     isVerbose,
                     isCacheReloaded,
                 }; /* <- TODO: ` satisfies PrepareAndScrapeOptions` */
-                const fs = $provideFilesystemForNode();
+                const fs = $provideFilesystemForNode(prepareAndScrapeOptions);
                 const llm = await $provideLlmToolsForWizzardOrCli(prepareAndScrapeOptions);
-                const executables = await $provideExecutablesForNode();
+                const executables = await $provideExecutablesForNode(prepareAndScrapeOptions);
                 tools = {
                     llm,
                     fs,
@@ -12954,7 +13081,7 @@
             }
             console.info(colors__default["default"].green(`All pipelines are valid`));
             return process.exit(0);
-        });
+        }));
     }
     /**
      * TODO: [😶] Unite floder listing