@promptbook/cli 0.114.0-1 → 0.114.0-3

package/src/remote-server/createRemoteClient.ts

@@ -1,10 +1,19 @@
 import type { Socket } from 'socket.io-client';
-import { io } from 'socket.io-client';
 import { spaceTrim } from 'spacetrim';
 import { CONNECTION_RETRIES_LIMIT, CONNECTION_TIMEOUT_MS } from '../config';
+import { createLazyModuleLoader } from '../utils/misc/createLazyModuleLoader';
 import { isValidUrl } from '../utils/validators/url/isValidUrl';
 import type { RemoteClientOptions } from './types/RemoteClientOptions';
 
+/**
+ * Loads the Socket.io client (`socket.io-client`) on demand
+ *
+ * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast
+ *
+ * @private internal utility of `createRemoteClient`
+ */
+const loadSocketIoClientModule = createLazyModuleLoader(() => import('socket.io-client'));
+
 /**
  * Creates a connection to the remote proxy server.
  *
@@ -44,6 +53,8 @@ export async function createRemoteClient<TCustomOptions = undefined>(
         );
     }
 
+    const { io } = await loadSocketIoClientModule();
+
     return new Promise((resolve, reject) => {
         const socket = io(remoteServerUrl, {
             retries: CONNECTION_RETRIES_LIMIT,

package/src/scrapers/website/WebsiteScraper.ts

@@ -4,8 +4,6 @@ import type { Converter } from '../_common/Converter';
 import type { Scraper, ScraperSourceHandler } from '../_common/Scraper';
 // TODO: [🏳‍🌈] Finally take pick of .json vs .ts
 // import PipelineCollection from '../../../books/books';
-import { Readability } from '@mozilla/readability';
-import { JSDOM } from 'jsdom';
 import type { Converter as ShowdownConverter } from 'showdown';
 import { DEFAULT_INTERMEDIATE_FILES_STRATEGY, DEFAULT_IS_VERBOSE, DEFAULT_SCRAPE_CACHE_DIRNAME } from '../../config';
 import { EnvironmentMismatchError } from '../../errors/EnvironmentMismatchError';
@@ -13,6 +11,7 @@ import { KnowledgeScrapeError } from '../../errors/KnowledgeScrapeError';
 import { UnexpectedError } from '../../errors/UnexpectedError';
 import type { ExecutionTools } from '../../execution/ExecutionTools';
 import type { PrepareAndScrapeOptions } from '../../prepare/PrepareAndScrapeOptions';
+import { createLazyModuleLoader } from '../../utils/misc/createLazyModuleLoader';
 import { MarkdownScraper } from '../markdown/MarkdownScraper';
 import type { ScraperAndConverterMetadata } from '../_common/register/ScraperAndConverterMetadata';
 import type { ScraperIntermediateSource } from '../_common/ScraperIntermediateSource';
@@ -20,6 +19,25 @@ import { getScraperIntermediateSource } from '../_common/utils/getScraperInterme
 import { websiteScraperMetadata } from './register-metadata';
 import { createShowdownConverter } from './utils/createShowdownConverter';
 
+/**
+ * Loads `jsdom` on demand
+ *
+ * Note: [🐌] `jsdom` is by far the heaviest dependency of Promptbook, loading it eagerly would slow down every single
+ *       run of the `ptbk` CLI utility even when no website is scraped
+ *
+ * @private internal utility of `WebsiteScraper`
+ */
+const loadJsdomModule = createLazyModuleLoader(() => import('jsdom'));
+
+/**
+ * Loads `@mozilla/readability` on demand
+ *
+ * Note: [🐌] Loaded lazily to keep the startup of the `ptbk` CLI utility fast
+ *
+ * @private internal utility of `WebsiteScraper`
+ */
+const loadReadabilityModule = createLazyModuleLoader(() => import('@mozilla/readability'));
+
 /**
  * Scraper for websites
  *
@@ -77,6 +95,8 @@ export class WebsiteScraper implements Converter, Scraper {
             throw new EnvironmentMismatchError('Can not scrape websites without filesystem tools');
         }
 
+        const [{ JSDOM }, { Readability }] = await Promise.all([loadJsdomModule(), loadReadabilityModule()]);
+
         const jsdom = new JSDOM(await source.asText(), {
             url: source.url,
         });

package/src/utils/agent-message-runtime/resolveAgentMessageRuntimeActivity.ts

@@ -21,6 +21,11 @@ type RuntimeLogEvent = {
             readonly text?: string;
         }>;
     };
+    readonly item?: {
+        readonly type?: string;
+        readonly command?: string;
+        readonly exit_code?: number | null;
+    };
 };
 
 /**
@@ -89,6 +94,11 @@ function parseRuntimeLogEvent(line: string): RuntimeLogEvent | null {
  * @private internal helper of `resolveAgentMessageRuntimeActivity`
  */
 function resolveRuntimeLogEventActivity(event: RuntimeLogEvent): string | null {
+    const codexActivity = resolveCodexRuntimeLogEventActivity(event);
+    if (codexActivity) {
+        return codexActivity;
+    }
+
     if (event.type !== 'assistant' || !Array.isArray(event.message?.content)) {
         return null;
     }
@@ -103,6 +113,97 @@ function resolveRuntimeLogEventActivity(event: RuntimeLogEvent): string | null {
     return assistantText.length > 0 ? assistantText : null;
 }
 
+/**
+ * Resolves one short user-facing status from a structured Codex JSONL event.
+ *
+ * Codex reasoning and raw command text deliberately remain private. The event type tells us
+ * enough to report a useful action without exposing the internal trace or a command payload.
+ *
+ * @private internal helper of `resolveAgentMessageRuntimeActivity`
+ */
+function resolveCodexRuntimeLogEventActivity(event: RuntimeLogEvent): string | null {
+    if (!event.item || !isCodexItemEvent(event.type)) {
+        return null;
+    }
+
+    const isCompleted = event.type === 'item.completed';
+
+    switch (event.item.type) {
+        case 'reasoning':
+            return isCompleted ? 'Considered the request.' : 'Considering the request.';
+        case 'command_execution':
+            return resolveCodexCommandActivity(event.item.command, isCompleted, event.item.exit_code);
+        case 'file_change':
+            return isCompleted ? 'Updated relevant files.' : 'Updating relevant files.';
+        case 'web_search':
+            return isCompleted ? 'Finished searching the web.' : 'Searching the web.';
+        case 'mcp_tool_call':
+            return isCompleted ? 'Finished using an integration.' : 'Using an integration.';
+        case 'plan_update':
+            return isCompleted ? 'Updated the plan.' : 'Planning the work.';
+        default:
+            return null;
+    }
+}
+
+/**
+ * Returns whether one runtime event is a Codex item lifecycle event.
+ *
+ * @private internal helper of `resolveAgentMessageRuntimeActivity`
+ */
+function isCodexItemEvent(eventType: string | undefined): boolean {
+    return eventType === 'item.started' || eventType === 'item.updated' || eventType === 'item.completed';
+}
+
+/**
+ * Maps one Codex command event to a concise action without revealing the command itself.
+ *
+ * @private internal helper of `resolveAgentMessageRuntimeActivity`
+ */
+function resolveCodexCommandActivity(
+    command: string | undefined,
+    isCompleted: boolean,
+    exitCode: number | null | undefined,
+): string {
+    if (isCompleted && exitCode !== undefined && exitCode !== null && exitCode !== 0) {
+        return 'A command needs attention.';
+    }
+
+    const activity = resolveCodexCommandActivityLabel(command);
+    return isCompleted ? activity.completed : activity.running;
+}
+
+/**
+ * Resolves the short running/completed labels for one safe command category.
+ *
+ * @private internal helper of `resolveAgentMessageRuntimeActivity`
+ */
+function resolveCodexCommandActivityLabel(command: string | undefined): { running: string; completed: string } {
+    const normalizedCommand = command?.toLowerCase() || '';
+
+    if (/(^|\s)(npm\s+(?:run\s+)?test|pnpm\s+(?:run\s+)?test|yarn\s+test|jest|vitest|pytest)\b/u.test(normalizedCommand)) {
+        return { running: 'Running tests.', completed: 'Finished running tests.' };
+    }
+
+    if (/(^|\s)(npm\s+run\s+build|pnpm\s+(?:run\s+)?build|yarn\s+build|next\s+build)\b/u.test(normalizedCommand)) {
+        return { running: 'Building the project.', completed: 'Finished building the project.' };
+    }
+
+    if (/(^|\s)(npm|pnpm|yarn)\s+(?:install|add)\b/u.test(normalizedCommand)) {
+        return { running: 'Installing dependencies.', completed: 'Finished installing dependencies.' };
+    }
+
+    if (/(^|\s)git\s+(?:status|diff|log|show)\b/u.test(normalizedCommand)) {
+        return { running: 'Reviewing changes.', completed: 'Finished reviewing changes.' };
+    }
+
+    if (/(^|\s)(ls|find|rg|grep|sed|cat|head|tail)\b/u.test(normalizedCommand)) {
+        return { running: 'Inspecting relevant files.', completed: 'Finished inspecting relevant files.' };
+    }
+
+    return { running: 'Running a task.', completed: 'Finished a task.' };
+}
+
 /**
  * Collapses one activity string to a single trimmed line, truncated for the progress card.
  *

package/src/utils/misc/createLazyModuleLoader.ts

@@ -0,0 +1,27 @@
+/**
+ * Creates a loader which imports one module on the first call and reuses the very same module afterwards
+ *
+ * Note: [🐌] Heavy third-party dependencies are imported lazily to keep the startup of the Promptbook CLI fast.
+ *       A statically imported dependency is loaded every single time the bundle is loaded, even when the running
+ *       command never touches it. A lazily imported dependency is loaded only when the feature is really used.
+ *
+ * @example
+ * const loadJsdomModule = createLazyModuleLoader(() => import('jsdom'));
+ * const { JSDOM } = await loadJsdomModule();
+ *
+ * @private internal utility of Promptbook
+ */
+export function createLazyModuleLoader<TModule>(importModule: () => Promise<TModule>): () => Promise<TModule> {
+    let importedModulePromise: Promise<TModule> | null = null;
+
+    return function loadModule(): Promise<TModule> {
+        if (importedModulePromise === null) {
+            importedModulePromise = importModule();
+        }
+
+        return importedModulePromise;
+    };
+}
+
+// Note: [🐌] Do not convert the lazy `import(...)` calls back to static `import` statements, it would bring back the
+//       slow startup of the `ptbk` CLI utility

package/src/version.ts

@@ -16,11 +16,11 @@ export const BOOK_LANGUAGE_VERSION: string_semantic_version = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-1';
+export const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version = '0.114.0-3';
 
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.113.1-0`).
+ * It follows semantic versioning (e.g., `0.114.0-2`).
  *
  * @generated
  */

package/src/versions.txt

@@ -1179,4 +1179,5 @@
 0.113.0-14
 0.113.0
 0.113.1-0
-0.114.0-1
+0.114.0-2
+0.114.0-3