@promptbook/cli 0.112.0-45 → 0.112.0-46

package/esm/scripts/run-codex-prompts/git/commitChanges.d.ts

@@ -1,7 +1,9 @@
 /**
  * Commits staged changes with the provided message using the dedicated coding-agent identity when configured,
- * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`.
+ * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`,
+ * while `options.excludePaths` can keep temporary artifacts out of the created commit.
  */
 export declare function commitChanges(message: string, options?: {
     autoPush?: boolean;
+    excludePaths?: ReadonlyArray<string>;
 }): Promise<void>;

package/esm/scripts/run-codex-prompts/ui/coderRunUiRefresh.d.ts

@@ -0,0 +1,17 @@
+import type { CoderRunPauseState } from './buildCoderRunUiFrame';
+import type { CoderRunPhase } from './CoderRunUiState';
+/**
+ * Refresh cadence used only while the rich coder UI needs animated updates.
+ *
+ * @private internal constant of coder run UI
+ */
+export declare const ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS = 1000;
+/**
+ * Returns the automatic refresh interval for the current UI state.
+ *
+ * Waiting, paused, and completed states return `undefined` so the rich UI stays
+ * perfectly still until actual state changes arrive.
+ *
+ * @private internal utility of coder run UI
+ */
+export declare function getCoderRunUiAutoRefreshInterval(phase: CoderRunPhase, pauseState: CoderRunPauseState): number | undefined;

package/esm/scripts/run-codex-prompts/ui/renderCoderRunUi.d.ts

@@ -20,9 +20,10 @@ export type CoderRunUiHandle = {
 /**
  * Boots the ANSI terminal UI for `ptbk coder run`.
  *
- * The UI reserves a fixed number of terminal lines and repaints them periodically.
- * Between repaints, any console output from runners is captured and fed into the
- * scrolling agent-output area.
+ * The UI reserves a fixed number of terminal lines and refreshes them incrementally.
+ * While a prompt is actively running, it schedules lightweight timed refreshes for
+ * the spinner/progress area; otherwise it redraws only when real state changes arrive.
+ * Any console output from runners is captured and fed into the scrolling agent-output area.
  *
  * On non-interactive (non-TTY) terminals the UI is skipped entirely and
  * only the state object is provided.

package/esm/src/avatars/types/AvatarVisualDefinition.d.ts

@@ -5,7 +5,7 @@ import type { AvatarDefinition } from './AvatarDefinition';
  *
  * @private shared contract for the avatar rendering system
  */
-export type AvatarVisualId = 'pixel-art' | 'octopus' | 'minecraft';
+export type AvatarVisualId = 'pixel-art' | 'octopus' | 'octopus2' | 'minecraft' | 'fractal';
 /**
  * Derived color palette used by avatar visuals.
  *

package/esm/src/avatars/visuals/avatarVisualRegistry.test.d.ts

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

package/esm/src/avatars/visuals/fractalAvatarVisual.d.ts

@@ -0,0 +1,7 @@
+import type { AvatarVisualDefinition } from '../types/AvatarVisualDefinition';
+/**
+ * Fractal avatar visual.
+ *
+ * @private built-in avatar visual
+ */
+export declare const fractalAvatarVisual: AvatarVisualDefinition;

package/esm/src/avatars/visuals/octopus2AvatarVisual.d.ts

@@ -0,0 +1,7 @@
+import type { AvatarVisualDefinition } from '../types/AvatarVisualDefinition';
+/**
+ * Octopus2 avatar visual.
+ *
+ * @private built-in avatar visual
+ */
+export declare const octopus2AvatarVisual: AvatarVisualDefinition;

package/esm/src/version.d.ts

@@ -15,7 +15,7 @@ export declare const BOOK_LANGUAGE_VERSION: string_semantic_version;
 export declare const PROMPTBOOK_ENGINE_VERSION: string_promptbook_version;
 /**
  * Represents the version string of the Promptbook engine.
- * It follows semantic versioning (e.g., `0.112.0-44`).
+ * It follows semantic versioning (e.g., `0.112.0-45`).
  *
  * @generated
  */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/cli",
-    "version": "0.112.0-45",
+    "version": "0.112.0-46",
     "description": "Promptbook: Turn your company's scattered knowledge into AI ready books",
     "private": false,
     "sideEffects": false,

package/umd/index.umd.js

@@ -60,7 +60,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-45';
+    const PROMPTBOOK_ENGINE_VERSION = '0.112.0-46';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -45446,7 +45446,8 @@
 
     /**
      * Commits staged changes with the provided message using the dedicated coding-agent identity when configured,
-     * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`.
+     * otherwise falls back to the default Git configuration. Remote pushing is opt-in via `options.autoPush`,
+     * while `options.excludePaths` can keep temporary artifacts out of the created commit.
      */
     async function commitChanges(message, options) {
         const projectPath = process.cwd();
@@ -45456,11 +45457,7 @@
         try {
             const agentEnv = buildAgentGitEnv();
             const signingFlag = buildAgentGitSigningFlag();
-            await runGitCommand({
-                command: 'git add .',
-                cwd: projectPath,
-                env: agentEnv,
-            });
+            await stageCommitChanges(projectPath, agentEnv, options === null || options === void 0 ? void 0 : options.excludePaths);
             await runGitCommand({
                 command: buildGitCommitCommand(commitMessagePath, signingFlag),
                 cwd: projectPath,
@@ -45474,6 +45471,56 @@
             await promises.unlink(commitMessagePath).catch(() => undefined);
         }
     }
+    /**
+     * Stages repository changes and optionally unstages temporary files that should not end up inside the commit.
+     */
+    async function stageCommitChanges(projectPath, agentEnv, excludePaths) {
+        await runGitCommand({
+            command: 'git add .',
+            cwd: projectPath,
+            env: agentEnv,
+        });
+        const excludedGitPaths = normalizeExcludedGitPaths(projectPath, excludePaths);
+        if (excludedGitPaths.length === 0) {
+            return;
+        }
+        await runGitCommand({
+            command: `git reset --quiet HEAD -- ${excludedGitPaths.map(quoteShellPath).join(' ')}`,
+            cwd: projectPath,
+            env: agentEnv,
+            isVerbose: false,
+        });
+    }
+    /**
+     * Converts excluded filesystem paths into unique repository-relative Git paths.
+     */
+    function normalizeExcludedGitPaths(projectPath, excludePaths) {
+        if (!excludePaths || excludePaths.length === 0) {
+            return [];
+        }
+        return [
+            ...new Set(excludePaths
+                .map((excludePath) => normalizeExcludedGitPath(projectPath, excludePath))
+                .filter((gitPath) => Boolean(gitPath))),
+        ];
+    }
+    /**
+     * Converts one excluded filesystem path into a Git-friendly repository-relative path.
+     */
+    function normalizeExcludedGitPath(projectPath, excludePath) {
+        const absoluteExcludePath = path.resolve(projectPath, excludePath);
+        const relativeExcludePath = path.relative(projectPath, absoluteExcludePath).replace(/\\/gu, '/');
+        if (relativeExcludePath === '' || relativeExcludePath === '.' || relativeExcludePath.startsWith('../')) {
+            return undefined;
+        }
+        return relativeExcludePath;
+    }
+    /**
+     * Quotes one Git path for safe shell execution.
+     */
+    function quoteShellPath(path) {
+        return JSON.stringify(path);
+    }
     /**
      * Branded error used when pushing committed changes fails.
      */
@@ -48744,9 +48791,7 @@ bash "$1"
                 ...options.detailLines.map((detailLine) => `• ${detailLine}`),
             ]
             : [options.statusMessage, ...options.detailLines.map((detailLine) => `• ${detailLine}`)];
-        const visibleOutputLines = options.agentOutputLines.length > 0
-            ? options.agentOutputLines.slice(-MAX_VISIBLE_OUTPUT_LINES).map((line) => `› ${stripAnsi(line)}`)
-            : ['No live agent output yet.'];
+        const visibleOutputLines = buildVisibleOutputLines(options.agentOutputLines);
         const controls = buildControlPills(options.pauseState, options.pendingEnterLabel).join('  ');
         const frame = [
             ...renderBox('Brand', runnerDetails, totalWidth, colors__default["default"].cyan.bold),
@@ -48760,6 +48805,18 @@ bash "$1"
         frame.push(...renderBox('Controls', [controls], totalWidth, colors__default["default"].white.bold));
         return frame;
     }
+    /**
+     * Builds the fixed-height live output section so streaming updates do not keep resizing the frame.
+     */
+    function buildVisibleOutputLines(agentOutputLines) {
+        const visibleOutputLines = agentOutputLines.length > 0
+            ? agentOutputLines.slice(-MAX_VISIBLE_OUTPUT_LINES).map((line) => `› ${stripAnsi(line)}`)
+            : ['No live agent output yet.'];
+        while (visibleOutputLines.length < MAX_VISIBLE_OUTPUT_LINES) {
+            visibleOutputLines.push('');
+        }
+        return visibleOutputLines;
+    }
     /**
      * Renders a framed box with a colored title and padded body lines.
      */
@@ -49026,11 +49083,33 @@ bash "$1"
     }
 
     /**
-     * Refresh interval for the terminal UI in milliseconds.
+     * Refresh cadence used only while the rich coder UI needs animated updates.
+     *
+     * @private internal constant of coder run UI
+     */
+    const ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS = 1000;
+    /**
+     * Phases that still benefit from automatic refreshes because the frame can change
+     * over time even without new runner output.
      *
      * @private internal constant of coder run UI
      */
-    const UI_REFRESH_INTERVAL_MS = 200;
+    const AUTO_REFRESH_PHASES = ['initializing', 'loading', 'running', 'verifying'];
+    /**
+     * Returns the automatic refresh interval for the current UI state.
+     *
+     * Waiting, paused, and completed states return `undefined` so the rich UI stays
+     * perfectly still until actual state changes arrive.
+     *
+     * @private internal utility of coder run UI
+     */
+    function getCoderRunUiAutoRefreshInterval(phase, pauseState) {
+        if (pauseState !== 'RUNNING') {
+            return undefined;
+        }
+        return AUTO_REFRESH_PHASES.includes(phase) ? ACTIVE_CODER_RUN_UI_REFRESH_INTERVAL_MS : undefined;
+    }
+
     /**
      * Spinner animation frames.
      *
@@ -49059,9 +49138,10 @@ bash "$1"
     /**
      * Boots the ANSI terminal UI for `ptbk coder run`.
      *
-     * The UI reserves a fixed number of terminal lines and repaints them periodically.
-     * Between repaints, any console output from runners is captured and fed into the
-     * scrolling agent-output area.
+     * The UI reserves a fixed number of terminal lines and refreshes them incrementally.
+     * While a prompt is actively running, it schedules lightweight timed refreshes for
+     * the spinner/progress area; otherwise it redraws only when real state changes arrive.
+     * Any console output from runners is captured and fed into the scrolling agent-output area.
      *
      * On non-interactive (non-TTY) terminals the UI is skipped entirely and
      * only the state object is provided.
@@ -49111,72 +49191,139 @@ bash "$1"
             process.stdin.setRawMode(true);
         }
         let spinnerFrame = 0;
-        let previousFrameLineCount = 0;
+        let previousFrameLines = [];
         let isRendering = false;
         let renderScheduled = false;
+        let autoRefreshTimeout;
+        let isDisposed = false;
         /**
          * Schedules a render on the next tick if one isn't already pending.
          * Prevents overlapping renders that cause cursor desync.
          */
         function scheduleRender() {
-            if (renderScheduled) {
+            if (renderScheduled || isDisposed) {
                 return;
             }
             renderScheduled = true;
             setImmediate(() => {
                 renderScheduled = false;
+                if (isDisposed) {
+                    return;
+                }
                 render();
             });
         }
         /**
-         * Clears previously rendered lines and writes a new frame.
+         * Re-schedules automatic animation refreshes only while the frame can change by itself.
          */
-        function render() {
-            if (isRendering) {
+        function scheduleAutoRefresh() {
+            if (autoRefreshTimeout) {
+                clearTimeout(autoRefreshTimeout);
+                autoRefreshTimeout = undefined;
+            }
+            const autoRefreshInterval = getCoderRunUiAutoRefreshInterval(state.phase, getPauseState());
+            if (autoRefreshInterval === undefined) {
+                return;
+            }
+            autoRefreshTimeout = setTimeout(() => {
+                autoRefreshTimeout = undefined;
+                scheduleRender();
+            }, autoRefreshInterval);
+        }
+        /**
+         * Moves the cursor relative to the bottom of the current frame and rewrites one line in place.
+         */
+        function rewriteFrameLine(frameLineCount, lineIndex, line) {
+            const linesUpFromBottom = Math.max(0, frameLineCount - 1 - lineIndex);
+            if (linesUpFromBottom > 0) {
+                process.stdout.write(`\x1b[${linesUpFromBottom}A`);
+            }
+            readline.clearLine(process.stdout, 0);
+            readline.cursorTo(process.stdout, 0);
+            process.stdout.write(line);
+            readline.cursorTo(process.stdout, 0);
+            if (linesUpFromBottom > 0) {
+                process.stdout.write(`\x1b[${linesUpFromBottom}B`);
+                readline.cursorTo(process.stdout, 0);
+            }
+        }
+        /**
+         * Fully rewrites the reserved frame area.
+         */
+        function renderFullFrame(lines) {
+            var _a;
+            const previousFrameLineCount = previousFrameLines.length;
+            const linesToRewriteCount = Math.max(previousFrameLineCount, lines.length);
+            if (previousFrameLineCount > 1) {
+                process.stdout.write(`\x1b[${previousFrameLineCount - 1}A`);
+            }
+            for (let i = 0; i < linesToRewriteCount; i++) {
+                readline.clearLine(process.stdout, 0);
+                readline.cursorTo(process.stdout, 0);
+                process.stdout.write((_a = lines[i]) !== null && _a !== void 0 ? _a : '');
+                if (i < linesToRewriteCount - 1) {
+                    process.stdout.write('\n');
+                }
+            }
+            const clearedTrailingLines = linesToRewriteCount - lines.length;
+            if (clearedTrailingLines > 0) {
+                process.stdout.write(`\x1b[${clearedTrailingLines}A`);
+            }
+            readline.cursorTo(process.stdout, 0);
+        }
+        /**
+         * Updates only the frame rows whose visible content changed.
+         */
+        function renderChangedLines(lines) {
+            for (let i = 0; i < lines.length; i++) {
+                if (previousFrameLines[i] === lines[i]) {
+                    continue;
+                }
+                rewriteFrameLine(lines.length, i, lines[i]);
+            }
+        }
+        /**
+         * Builds the current frame snapshot from the latest state.
+         */
+        function buildFrameLines() {
+            return buildCoderRunUiFrame({
+                terminalWidth: getTerminalWidth(),
+                spinner: SPINNER_FRAMES[spinnerFrame],
+                pauseState: getPauseState(),
+                config: state.config,
+                phase: state.phase,
+                currentPromptLabel: state.currentPromptLabel,
+                currentAttempt: state.currentAttempt,
+                maxAttempts: state.maxAttempts,
+                statusMessage: state.statusMessage,
+                detailLines: state.detailLines,
+                pendingEnterLabel: state.pendingEnterLabel,
+                agentOutputLines: state.agentOutputLines,
+                errors: state.errors,
+                progress: state.getProgress(),
+            });
+        }
+        /**
+         * Clears previously rendered lines and writes a new frame only where needed.
+         */
+        function render(options) {
+            if (isRendering || isDisposed) {
                 return;
             }
             isRendering = true;
             try {
-                const lines = buildCoderRunUiFrame({
-                    terminalWidth: getTerminalWidth(),
-                    spinner: SPINNER_FRAMES[spinnerFrame],
-                    pauseState: getPauseState(),
-                    config: state.config,
-                    phase: state.phase,
-                    currentPromptLabel: state.currentPromptLabel,
-                    currentAttempt: state.currentAttempt,
-                    maxAttempts: state.maxAttempts,
-                    statusMessage: state.statusMessage,
-                    detailLines: state.detailLines,
-                    pendingEnterLabel: state.pendingEnterLabel,
-                    agentOutputLines: state.agentOutputLines,
-                    errors: state.errors,
-                    progress: state.getProgress(),
-                });
-                if (previousFrameLineCount > 0) {
-                    process.stdout.write(`\x1b[${previousFrameLineCount}A`);
-                }
-                for (let i = 0; i < lines.length; i++) {
-                    readline.clearLine(process.stdout, 0);
-                    readline.cursorTo(process.stdout, 0);
-                    process.stdout.write(lines[i]);
-                    if (i < lines.length - 1) {
-                        process.stdout.write('\n');
-                    }
+                const lines = buildFrameLines();
+                if (previousFrameLines.length === 0 || previousFrameLines.length !== lines.length) {
+                    renderFullFrame(lines);
                 }
-                if (lines.length < previousFrameLineCount) {
-                    for (let i = lines.length; i < previousFrameLineCount; i++) {
-                        process.stdout.write('\n');
-                        readline.clearLine(process.stdout, 0);
-                        readline.cursorTo(process.stdout, 0);
-                    }
-                    const overshoot = previousFrameLineCount - lines.length;
-                    if (overshoot > 0) {
-                        process.stdout.write(`\x1b[${overshoot}A`);
-                    }
+                else {
+                    renderChangedLines(lines);
                 }
-                previousFrameLineCount = lines.length;
+                previousFrameLines = [...lines];
                 spinnerFrame = (spinnerFrame + 1) % SPINNER_FRAMES.length;
+                if (!(options === null || options === void 0 ? void 0 : options.skipAutoRefresh)) {
+                    scheduleAutoRefresh();
+                }
             }
             finally {
                 isRendering = false;
@@ -49194,6 +49341,7 @@ bash "$1"
                 else {
                     requestResume();
                 }
+                scheduleRender();
                 return;
             }
             if ((key.name === 'return' || key.name === 'enter') && pendingEnterResolver) {
@@ -49204,17 +49352,24 @@ bash "$1"
             }
         };
         process.stdin.on('keypress', keypressHandler);
+        process.stdout.on('resize', scheduleRender);
         process.stdout.write('\n');
         render();
-        const interval = setInterval(scheduleRender, UI_REFRESH_INTERVAL_MS);
         state.on('change', scheduleRender);
         /**
          * Tears down the terminal UI and restores console / stdin state.
          */
         function cleanup() {
-            clearInterval(interval);
+            if (isDisposed) {
+                return;
+            }
+            if (autoRefreshTimeout) {
+                clearTimeout(autoRefreshTimeout);
+                autoRefreshTimeout = undefined;
+            }
             state.off('change', scheduleRender);
             process.stdin.off('keypress', keypressHandler);
+            process.stdout.off('resize', scheduleRender);
             if (process.stdin.isTTY) {
                 process.stdin.setRawMode(false);
             }
@@ -49226,8 +49381,9 @@ bash "$1"
             console.warn = originalConsoleWarn;
             console.error = originalConsoleError;
             console.log = originalConsoleLog;
-            render();
+            render({ skipAutoRefresh: true });
             process.stdout.write('\n');
+            isDisposed = true;
         }
         return {
             state,
@@ -49574,7 +49730,11 @@ bash "$1"
                             progressDisplay === null || progressDisplay === void 0 ? void 0 : progressDisplay.resumeTimer();
                             uiHandle === null || uiHandle === void 0 ? void 0 : uiHandle.state.resumeTimer();
                         }
-                        await commitChanges(commitMessage, { autoPush: options.autoPush });
+                        await commitChanges(commitMessage, {
+                            autoPush: options.autoPush,
+                            // Keep the live runtime log out of default commits because it is deleted after a successful round.
+                            excludePaths: options.preserveLogs ? undefined : [logPath],
+                        });
                         await runPostPromptAutoMigrationIfEnabled(options);
                     }
                     catch (error) {