@promptbook/cli 0.112.0-45 → 0.112.0-46

package/esm/index.es.js

@@ -58,7 +58,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @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
@@ -45444,7 +45444,8 @@ function stringifyUnknownError$1(error) {
 
 /**
  * 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();
@@ -45454,11 +45455,7 @@ async function commitChanges(message, options) {
     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,
@@ -45472,6 +45469,56 @@ async function commitChanges(message, options) {
         await 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 = resolve(projectPath, excludePath);
+    const relativeExcludePath = 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.
  */
@@ -48742,9 +48789,7 @@ function buildCoderRunUiFrame(options) {
             ...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.cyan.bold),
@@ -48758,6 +48803,18 @@ function buildCoderRunUiFrame(options) {
     frame.push(...renderBox('Controls', [controls], totalWidth, colors.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.
  */
@@ -49024,11 +49081,33 @@ class CoderRunUiState extends EventEmitter {
 }
 
 /**
- * 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.
  *
@@ -49057,9 +49136,10 @@ function getTerminalWidth() {
 /**
  * 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.
@@ -49109,72 +49189,139 @@ function renderCoderRunUi(startTime) {
         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`);
+        }
+        clearLine(process.stdout, 0);
+        cursorTo(process.stdout, 0);
+        process.stdout.write(line);
+        cursorTo(process.stdout, 0);
+        if (linesUpFromBottom > 0) {
+            process.stdout.write(`\x1b[${linesUpFromBottom}B`);
+            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++) {
+            clearLine(process.stdout, 0);
+            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`);
+        }
+        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++) {
-                clearLine(process.stdout, 0);
-                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');
-                    clearLine(process.stdout, 0);
-                    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;
@@ -49192,6 +49339,7 @@ function renderCoderRunUi(startTime) {
             else {
                 requestResume();
             }
+            scheduleRender();
             return;
         }
         if ((key.name === 'return' || key.name === 'enter') && pendingEnterResolver) {
@@ -49202,17 +49350,24 @@ function renderCoderRunUi(startTime) {
         }
     };
     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);
         }
@@ -49224,8 +49379,9 @@ function renderCoderRunUi(startTime) {
         console.warn = originalConsoleWarn;
         console.error = originalConsoleError;
         console.log = originalConsoleLog;
-        render();
+        render({ skipAutoRefresh: true });
         process.stdout.write('\n');
+        isDisposed = true;
     }
     return {
         state,
@@ -49572,7 +49728,11 @@ async function runCodexPrompts(providedOptions) {
                         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) {