@promptbook/components 0.113.0-6 → 0.113.0-7

package/esm/src/book-components/Chat/Chat/insertDictationChunk.d.ts

@@ -8,7 +8,7 @@ export declare function insertDictationChunk(params: {
     readonly dictatedText: string;
     readonly selectionStart: number;
     readonly selectionEnd: number;
-    readonly shouldReplaceSelection: boolean;
+    readonly isReplacingSelection: boolean;
 }): {
     nextValue: string;
     start: number;

package/esm/src/book-components/Chat/Chat/insertDictationChunk.test.d.ts

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

package/esm/src/book-components/Chat/Chat/learnDictationDictionary.test.d.ts

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

package/esm/src/book-components/Chat/Chat/refineFinalDictationChunk.test.d.ts

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

package/esm/src/cli/cli-commands/common/createPositiveIntegerOptionParser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a Commander argument parser that accepts only positive integers.
+ *
+ * The returned parser is meant to be passed as the coercion callback of `command.option(...)`.
+ * It throws a branded `NotAllowed` error with a clear message referencing the given option name
+ * when the provided value is not a positive integer.
+ *
+ * @private internal utility of `promptbookCli`
+ */
+export declare function createPositiveIntegerOptionParser(optionName: string): (value: string) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@promptbook/components",
-    "version": "0.113.0-6",
+    "version": "0.113.0-7",
     "description": "Promptbook: Create persistent AI agents that turn your company's scattered knowledge into action",
     "private": false,
     "sideEffects": false,

package/umd/index.umd.js

@@ -34,7 +34,7 @@
      * @generated
      * @see https://github.com/webgptorg/promptbook
      */
-    const PROMPTBOOK_ENGINE_VERSION = '0.113.0-6';
+    const PROMPTBOOK_ENGINE_VERSION = '0.113.0-7';
     /**
      * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
      * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -31158,9 +31158,9 @@
      * @private function of `useChatInputAreaDictation`
      */
     function insertDictationChunk(params) {
-        const { currentValue, dictatedText, selectionStart, selectionEnd, shouldReplaceSelection } = params;
+        const { currentValue, dictatedText, selectionStart, selectionEnd, isReplacingSelection } = params;
         const replaceStart = selectionStart;
-        const replaceEnd = shouldReplaceSelection ? selectionEnd : selectionStart;
+        const replaceEnd = isReplacingSelection ? selectionEnd : selectionStart;
         const prefix = currentValue.slice(0, replaceStart);
         const suffix = currentValue.slice(replaceEnd);
         const previousCharacter = prefix.slice(-1);
@@ -31202,7 +31202,7 @@
                 if (!previousWord || !correctedWord) {
                     continue;
                 }
-                if (previousWord.toLowerCase() !== correctedWord.toLowerCase()) {
+                if (previousWord !== correctedWord) {
                     nextDictionary[previousWord.toLowerCase()] = correctedWord;
                 }
             }
@@ -31696,17 +31696,73 @@
         pendingStopFallbackRef.current = null;
     }
     /**
-     * Captures whether the next finalized chunk should replace the current selection.
+     * Captures where the next finalized chunk should be inserted.
      *
      * @private function of `useChatInputAreaDictation`
      */
-    function captureSelectionReplacementIntent(textareaRef, replaceSelectionOnNextFinalRef) {
+    function captureDictationInsertionSelection(textareaRef, dictationInsertionSelectionRef) {
         const textarea = textareaRef.current;
         if (!textarea) {
             return;
         }
-        const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, 0);
-        replaceSelectionOnNextFinalRef.current = selectionStart !== selectionEnd;
+        const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, textarea.value.length);
+        dictationInsertionSelectionRef.current = {
+            selectionStart,
+            selectionEnd,
+            isReplacingSelection: selectionStart !== selectionEnd,
+        };
+    }
+    /**
+     * Resolves the insertion range for one finalized dictation chunk.
+     *
+     * @private function of `useChatInputAreaDictation`
+     */
+    function resolveDictationInsertionSelection(textareaElement, messageContentLength, dictationInsertionSelection) {
+        if (dictationInsertionSelection) {
+            return dictationInsertionSelection;
+        }
+        const { selectionStart, selectionEnd } = resolveTextareaSelection(textareaElement, messageContentLength);
+        return {
+            selectionStart,
+            selectionEnd,
+            isReplacingSelection: selectionStart !== selectionEnd,
+        };
+    }
+    /**
+     * Removes one tracked dictated chunk from the current composer value.
+     *
+     * @private function of `useChatInputAreaDictation`
+     */
+    function removeTrackedDictationChunk(currentValue, chunk) {
+        const trackedText = currentValue.slice(chunk.start, chunk.start + chunk.finalText.length);
+        if (trackedText === chunk.finalText) {
+            return `${currentValue.slice(0, chunk.start)}${currentValue.slice(chunk.start + chunk.finalText.length)}`;
+        }
+        return replaceLastOccurrence(currentValue, chunk.finalText, '');
+    }
+    /**
+     * Replaces one tracked dictated chunk inside the current composer value.
+     *
+     * @private function of `useChatInputAreaDictation`
+     */
+    function replaceTrackedDictationChunk(currentValue, chunk, correctedChunk) {
+        const trackedText = currentValue.slice(chunk.start, chunk.start + chunk.finalText.length);
+        if (trackedText === chunk.finalText) {
+            return `${currentValue.slice(0, chunk.start)}${correctedChunk}${currentValue.slice(chunk.start + chunk.finalText.length)}`;
+        }
+        return replaceLastOccurrence(currentValue, chunk.finalText, correctedChunk);
+    }
+    /**
+     * Stores the next append position after a programmatic dictation edit.
+     *
+     * @private function of `useChatInputAreaDictation`
+     */
+    function updateDictationInsertionCaret(dictationInsertionSelectionRef, caret) {
+        dictationInsertionSelectionRef.current = {
+            selectionStart: caret,
+            selectionEnd: caret,
+            isReplacingSelection: false,
+        };
     }
     /**
      * Produces the corrected chunk value only when a real correction should be applied.
@@ -31787,7 +31843,7 @@
      *
      * @private function of `useChatInputAreaDictation`
      */
-    function useChatInputAreaDictationFinalResultHandler({ textareaRef, messageContentRef, applyMessageContent, dictationSettings, dictationDictionary, replaceSelectionOnNextFinalRef, focusTextareaSelection, state, }) {
+    function useChatInputAreaDictationFinalResultHandler({ textareaRef, messageContentRef, applyMessageContent, dictationSettings, dictationDictionary, dictationInsertionSelectionRef, focusTextareaSelection, state, }) {
         const { setDictationUiState, setDictationInterimText, setDictationError, setDictationLastFinalChunk, setDictationEditableChunk, setDictationChunks, setIsDictationPanelExpanded, } = state;
         return react.useCallback((rawText) => {
             const textarea = textareaRef.current;
@@ -31799,15 +31855,15 @@
             if (!refinedText) {
                 return;
             }
-            const { selectionStart, selectionEnd } = resolveTextareaSelection(textarea, previousMessageContent.length);
+            const { selectionStart, selectionEnd, isReplacingSelection } = resolveDictationInsertionSelection(textarea, previousMessageContent.length, dictationInsertionSelectionRef.current);
             const insertion = insertDictationChunk({
                 currentValue: previousMessageContent,
                 dictatedText: refinedText,
                 selectionStart,
                 selectionEnd,
-                shouldReplaceSelection: replaceSelectionOnNextFinalRef.current,
+                isReplacingSelection,
             });
-            replaceSelectionOnNextFinalRef.current = false;
+            updateDictationInsertionCaret(dictationInsertionSelectionRef, insertion.caret);
             setDictationInterimText('');
             setDictationError(null);
             setDictationUiState('listening');
@@ -31827,10 +31883,10 @@
         }, [
             applyMessageContent,
             dictationDictionary,
+            dictationInsertionSelectionRef,
             dictationSettings,
             focusTextareaSelection,
             messageContentRef,
-            replaceSelectionOnNextFinalRef,
             setDictationChunks,
             setDictationEditableChunk,
             setDictationError,
@@ -31878,7 +31934,7 @@
                     return;
                 case 'STOP':
                     clearPendingStopFallback();
-                    setDictationUiState((currentState) => (currentState === 'disabled' ? currentState : 'idle'));
+                    setDictationUiState((currentState) => currentState === 'disabled' || currentState === 'error' ? currentState : 'idle');
                     setDictationInterimText('');
                     return;
             }
@@ -31919,13 +31975,13 @@
      *
      * @private function of `useChatInputAreaDictation`
      */
-    function useChatInputAreaDictationVoiceInputControls({ speechRecognition, textareaRef, resolvedSpeechRecognitionLanguage, whisperMode, pendingStopFallbackRef, replaceSelectionOnNextFinalRef, clearPendingStopFallback, state, }) {
+    function useChatInputAreaDictationVoiceInputControls({ speechRecognition, textareaRef, resolvedSpeechRecognitionLanguage, whisperMode, pendingStopFallbackRef, dictationInsertionSelectionRef, clearPendingStopFallback, state, }) {
         const { dictationUiState, setDictationUiState, setDictationInterimText, setDictationError } = state;
         const startVoiceInput = react.useCallback(() => {
             if (!speechRecognition) {
                 return;
             }
-            captureSelectionReplacementIntent(textareaRef, replaceSelectionOnNextFinalRef);
+            captureDictationInsertionSelection(textareaRef, dictationInsertionSelectionRef);
             setDictationError(null);
             setDictationInterimText('');
             setDictationUiState('listening');
@@ -31935,7 +31991,7 @@
                 whisperMode,
             });
         }, [
-            replaceSelectionOnNextFinalRef,
+            dictationInsertionSelectionRef,
             resolvedSpeechRecognitionLanguage,
             setDictationError,
             setDictationInterimText,
@@ -31987,7 +32043,7 @@
      *
      * @private function of `useChatInputAreaDictation`
      */
-    function useChatInputAreaDictationCorrectionHandlers({ dictationChunks, dictationLastFinalChunk, dictationEditableChunk, dictationDictionary, messageContentRef, applyMessageContent, focusTextareaSelection, setDictationChunks, setDictationLastFinalChunk, setDictationEditableChunk, setDictationDictionary, }) {
+    function useChatInputAreaDictationCorrectionHandlers({ dictationChunks, dictationLastFinalChunk, dictationEditableChunk, dictationDictionary, dictationInsertionSelectionRef, messageContentRef, applyMessageContent, focusTextareaSelection, setDictationChunks, setDictationLastFinalChunk, setDictationEditableChunk, setDictationDictionary, }) {
         const handleBacktrackLastChunk = react.useCallback(() => {
             var _a;
             const previousChunks = [...dictationChunks];
@@ -31995,35 +32051,51 @@
             if (!lastChunk) {
                 return;
             }
+            const nextMessageContent = removeTrackedDictationChunk(messageContentRef.current, lastChunk);
+            const nextCaret = Math.min(lastChunk.start, nextMessageContent.length);
             setDictationChunks(previousChunks);
-            applyMessageContent(lastChunk.beforeValue);
+            applyMessageContent(nextMessageContent);
             const previousFinalChunk = ((_a = previousChunks[previousChunks.length - 1]) === null || _a === void 0 ? void 0 : _a.finalText) || '';
             setDictationLastFinalChunk(previousFinalChunk);
             setDictationEditableChunk(previousFinalChunk);
-            focusTextareaSelection(lastChunk.start, lastChunk.start);
+            updateDictationInsertionCaret(dictationInsertionSelectionRef, nextCaret);
+            focusTextareaSelection(nextCaret, nextCaret);
         }, [
             applyMessageContent,
+            dictationInsertionSelectionRef,
             dictationChunks,
             focusTextareaSelection,
+            messageContentRef,
             setDictationChunks,
             setDictationEditableChunk,
             setDictationLastFinalChunk,
         ]);
         const handleApplyCorrection = react.useCallback(() => {
+            var _a;
             const correctedChunk = resolveCorrectedDictationChunk(dictationEditableChunk, dictationLastFinalChunk);
             if (!correctedChunk) {
                 return;
             }
-            const nextMessageContent = replaceLastOccurrence(messageContentRef.current, dictationLastFinalChunk, correctedChunk);
+            const lastChunk = dictationChunks[dictationChunks.length - 1];
+            const nextMessageContent = lastChunk
+                ? replaceTrackedDictationChunk(messageContentRef.current, lastChunk, correctedChunk)
+                : replaceLastOccurrence(messageContentRef.current, dictationLastFinalChunk, correctedChunk);
+            const correctionStart = (_a = lastChunk === null || lastChunk === void 0 ? void 0 : lastChunk.start) !== null && _a !== void 0 ? _a : nextMessageContent.length;
+            const correctionCaret = Math.min(correctionStart + correctedChunk.length, nextMessageContent.length);
             applyMessageContent(nextMessageContent);
             setDictationLastFinalChunk(correctedChunk);
             setDictationChunks((previousChunks) => replaceLastDictationChunk(previousChunks, correctedChunk));
             setDictationDictionary(learnDictationDictionary(dictationLastFinalChunk, correctedChunk, dictationDictionary));
+            updateDictationInsertionCaret(dictationInsertionSelectionRef, correctionCaret);
+            focusTextareaSelection(correctionCaret, correctionCaret);
         }, [
             applyMessageContent,
             dictationDictionary,
             dictationEditableChunk,
+            dictationChunks,
+            dictationInsertionSelectionRef,
             dictationLastFinalChunk,
+            focusTextareaSelection,
             messageContentRef,
             setDictationChunks,
             setDictationDictionary,
@@ -32041,7 +32113,7 @@
      */
     function useChatInputAreaDictation({ speechRecognition, speechRecognitionLanguage, textareaRef, messageContentRef, applyMessageContent, }) {
         const pendingStopFallbackRef = react.useRef(null);
-        const replaceSelectionOnNextFinalRef = react.useRef(false);
+        const dictationInsertionSelectionRef = react.useRef(null);
         const [dictationUiState, setDictationUiState] = react.useState('idle');
         const [dictationInterimText, setDictationInterimText] = react.useState('');
         const [dictationError, setDictationError] = react.useState(null);
@@ -32074,7 +32146,7 @@
             applyMessageContent,
             dictationSettings,
             dictationDictionary,
-            replaceSelectionOnNextFinalRef,
+            dictationInsertionSelectionRef,
             focusTextareaSelection,
             state: dictationState,
         });
@@ -32094,7 +32166,7 @@
             resolvedSpeechRecognitionLanguage,
             whisperMode: dictationSettings.whisperMode,
             pendingStopFallbackRef,
-            replaceSelectionOnNextFinalRef,
+            dictationInsertionSelectionRef,
             clearPendingStopFallback,
             state: {
                 dictationUiState,
@@ -32108,6 +32180,7 @@
             dictationLastFinalChunk,
             dictationEditableChunk,
             dictationDictionary,
+            dictationInsertionSelectionRef,
             messageContentRef,
             applyMessageContent,
             focusTextareaSelection,