pi-ui-extend 0.1.70 → 0.1.71

package/dist/app/input/input-controller.js

@@ -1,3 +1,4 @@
+import { StringDecoder } from "node:string_decoder";
 import { InputPasteHandler } from "./input-paste-handler.js";
 import { hasTerminalCommandModifier, isNativeCommandPressed, isNativeShiftPressed } from "./native-modifiers.js";
 import { parseTerminalEditShortcutSequence, parseTerminalInterruptSequence, parseTerminalModifiedKeySequence, terminalKeyArrowDirection, terminalEditShortcutForControlChar, terminalKeyIsClipboardImagePaste, terminalKeyIsEscape, terminalKeyIsShiftEnter, terminalKeyShouldIgnore, } from "./terminal-edit-shortcuts.js";
@@ -5,13 +6,16 @@ const SHIFT_ENTER_ESCAPE_SEQUENCES = ["\x1b\r", "\x1b\n"];
 export class AppInputController {
     host;
     inputBuffer = "";
+    inputDecoder = new StringDecoder("utf8");
     pasteHandler;
     constructor(host) {
         this.host = host;
         this.pasteHandler = new InputPasteHandler(host);
     }
     handleChunk(chunk) {
-        let data = chunk.toString("utf8");
+        let data = this.inputDecoder.write(chunk);
+        if (!data)
+            return;
         const bufferedSharedEditorInput = this.consumeBufferedSharedEditorInput(data);
         if (bufferedSharedEditorInput.kind === "consumed" || bufferedSharedEditorInput.kind === "pending")
             return;
@@ -159,12 +163,52 @@ export class AppInputController {
                 continue;
             if (this.isPendingEscapeSequence())
                 return;
+            if (this.consumePrintableRun())
+                continue;
             const char = this.inputBuffer[0];
             this.inputBuffer = this.inputBuffer.slice(1);
             if (char)
                 this.handleChar(char);
         }
     }
+    consumePrintableRun() {
+        let length = 0;
+        while (length < this.inputBuffer.length) {
+            const char = this.inputBuffer[length];
+            if (!char || char < " " || char === "\u007f")
+                break;
+            // Native undo/redo shortcuts must retain their individual key behavior.
+            const lower = char.toLowerCase();
+            if ((lower === "z" || lower === "y") && isNativeCommandPressed())
+                break;
+            length += 1;
+        }
+        if (length === 0)
+            return false;
+        const text = this.inputBuffer.slice(0, length);
+        this.inputBuffer = this.inputBuffer.slice(length);
+        let editorChanged = false;
+        let pendingText = "";
+        const flushPendingText = () => {
+            if (!pendingText)
+                return;
+            this.host.resetRequestHistoryNavigation();
+            this.host.inputEditor.insert(pendingText);
+            pendingText = "";
+            editorChanged = true;
+        };
+        for (const char of text) {
+            if (this.host.handleDirectPopupInput(char)) {
+                flushPendingText();
+                continue;
+            }
+            pendingText += char;
+        }
+        flushPendingText();
+        if (editorChanged)
+            this.host.render();
+        return true;
+    }
     consumeBracketedPastePayload() {
         if (!this.host.inputEditor.isInBracketedPaste)
             return false;

package/dist/app/input/input-paste-handler.d.ts

@@ -2,6 +2,7 @@ import { InputEditor } from "../../input-editor.js";
 export type InputPasteHost = {
     readonly inputEditor: InputEditor;
     readonly cwd: string;
+    inputScopeKey?(): string | undefined;
     resetRequestHistoryNavigation(): void;
     render(): void;
 };
@@ -10,6 +11,7 @@ export declare class InputPasteHandler {
     private pasteBufferParts;
     private readonly recentPasteFingerprints;
     private suppressImagePathPasteUntil;
+    private bracketedPasteScopeKey;
     constructor(host: InputPasteHost);
     handlePlainData(data: string): boolean;
     beginBracketedPaste(): void;
@@ -23,6 +25,7 @@ export declare class InputPasteHandler {
     private handlePastedFilePath;
     private schedulePastedText;
     private handleFilePaste;
+    private scopeIsActive;
     private filePathForInput;
     private displayPathForInput;
     private insertPastedPathText;

package/dist/app/input/input-paste-handler.js

@@ -10,6 +10,7 @@ export class InputPasteHandler {
     pasteBufferParts = [];
     recentPasteFingerprints = new Map();
     suppressImagePathPasteUntil = 0;
+    bracketedPasteScopeKey;
     constructor(host) {
         this.host = host;
     }
@@ -25,6 +26,7 @@ export class InputPasteHandler {
     beginBracketedPaste() {
         this.host.inputEditor.beginBracketedPaste();
         this.pasteBufferParts = [];
+        this.bracketedPasteScopeKey = this.host.inputScopeKey?.();
     }
     appendBracketedPasteText(text) {
         if (text)
@@ -34,11 +36,16 @@ export class InputPasteHandler {
         this.host.inputEditor.endBracketedPaste();
         const text = this.pasteBufferParts.join("");
         this.pasteBufferParts = [];
+        const scopeKey = this.bracketedPasteScopeKey;
+        this.bracketedPasteScopeKey = undefined;
+        if (!this.scopeIsActive(scopeKey))
+            return;
         this.handlePasteEnd(text);
     }
     async handleClipboardImagePaste() {
+        const scopeKey = this.host.inputScopeKey?.();
         const image = await readClipboardImage();
-        if (!image)
+        if (!image || !this.scopeIsActive(scopeKey))
             return;
         if (this.isDuplicatePaste(`image:${image.mimeType}`, image.data)) {
             this.host.render();
@@ -101,26 +108,28 @@ export class InputPasteHandler {
             this.host.render();
             return true;
         }
-        void this.handleFilePaste(filePath);
+        void this.handleFilePaste(filePath, this.host.inputScopeKey?.());
         return true;
     }
     schedulePastedText(text) {
-        const timer = setTimeout(() => {
-            if (this.isDuplicatePaste("text", text)) {
-                this.host.render();
-                return;
-            }
-            this.host.resetRequestHistoryNavigation();
-            this.host.inputEditor.attachPastedText(text);
+        if (this.isDuplicatePaste("text", text)) {
             this.host.render();
-        }, 0);
-        timer.unref?.();
+            return;
+        }
+        this.host.resetRequestHistoryNavigation();
+        this.host.inputEditor.attachPastedText(text);
+        this.host.render();
     }
-    async handleFilePaste(filePath) {
+    async handleFilePaste(filePath, scopeKey = this.host.inputScopeKey?.()) {
         const inputPath = await this.filePathForInput(filePath);
+        if (!this.scopeIsActive(scopeKey))
+            return;
         this.insertPastedPathText(inputPath);
         this.host.render();
     }
+    scopeIsActive(scopeKey) {
+        return !this.host.inputScopeKey || this.host.inputScopeKey() === scopeKey;
+    }
     async filePathForInput(filePath) {
         const resolved = resolve(this.host.cwd, filePath);
         try {

package/dist/app/input/prompt-enhancer-controller.d.ts

@@ -8,6 +8,7 @@ export type AppPromptEnhancerControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     inputEditor(): InputEditor;
     activeInputTabId(): string | undefined;
+    isInputTabOwnedByRuntime(tabId: string | undefined, runtime: AgentSessionRuntime, session: AgentSessionRuntime["session"]): boolean;
     inputStateForTab(tabId: string | undefined): TabInputState | undefined;
     setInputStateForTab(tabId: string | undefined, state: TabInputState): void;
     promptEnhancerConfig(): PromptEnhancerConfig;

package/dist/app/input/prompt-enhancer-controller.js

@@ -47,6 +47,7 @@ export class AppPromptEnhancerController {
             this.host.toast.error("Prompt enhancer unavailable: runtime is not initialized");
             return;
         }
+        const session = runtime.session;
         const target = this.currentTarget();
         if (!target) {
             this.host.toast.warning(`Type at least ${PROMPT_ENHANCER_MIN_TEXT_LENGTH} characters to enhance`);
@@ -58,21 +59,26 @@ export class AppPromptEnhancerController {
         this.host.render();
         try {
             const enhanced = await this.enhancePromptWithPi(runtime, target.text, this.host.promptEnhancerConfig());
+            if (!this.host.isInputTabOwnedByRuntime(target.tabId, runtime, session))
+                return;
             const currentInputState = this.host.inputStateForTab(target.tabId);
             if (!currentInputState || currentInputState.text !== target.originalEditorText) {
                 this.host.toast.warning("Prompt was changed before enhancement completed; result was not applied");
                 return;
             }
-            this.applyEnhancedPrompt(target, enhanced);
+            this.applyEnhancedPrompt(target, enhanced, currentInputState);
             this.host.resetInputAfterProgrammaticEdit();
             this.host.toast.success(target.kind === "selection" ? "Selection enhanced" : "Prompt enhanced");
         }
         catch (error) {
+            if (!this.host.isInputTabOwnedByRuntime(target.tabId, runtime, session))
+                return;
             this.host.toast.error(`Prompt enhance failed: ${stringifyUnknown(error)}`);
         }
         finally {
             this.enhancing = false;
-            this.restoreSessionState();
+            if (this.host.runtime() === runtime && runtime.session === session)
+                this.restoreSessionState(session);
             this.host.render();
         }
     }
@@ -106,15 +112,15 @@ export class AppPromptEnhancerController {
             end: originalEditorText.length,
         };
     }
-    applyEnhancedPrompt(target, enhanced) {
+    applyEnhancedPrompt(target, enhanced, currentState) {
         const nextText = `${target.originalEditorText.slice(0, target.start)}${enhanced}${target.originalEditorText.slice(target.end)}`;
         this.host.setInputStateForTab(target.tabId, {
             text: nextText,
             cursor: target.start + enhanced.length,
+            ...(currentState.attachments ? { attachments: currentState.attachments } : {}),
         });
     }
-    restoreSessionState() {
-        const session = this.host.runtime()?.session;
+    restoreSessionState(session) {
         this.host.setSessionStatus(session);
         this.host.setSessionActivity(session?.isStreaming || session?.isCompacting ? "running" : "idle");
     }

package/dist/app/input/voice-controller.d.ts

@@ -3,6 +3,7 @@ import { savePixDictationLanguage, type DictationConfig, type DictationLanguageM
 export type VoiceLanguage = string;
 export type VoiceInputState = "idle" | "installing" | "downloading" | "loading" | "listening";
 export type AppVoiceControllerHost = {
+    activeInputScope(): string | undefined;
     insertTranscript(text: string): void;
     setPartialTranscript(text: string | undefined): void;
     addSystemMessage(message: string): void;
@@ -68,6 +69,7 @@ export declare class AppVoiceController {
     private partialTranscript;
     private partialTranscriptTimer;
     private startGeneration;
+    private recordingScope;
     constructor(host: AppVoiceControllerHost, dictationConfig: DictationConfig);
     updateDictationConfig(dictationConfig: DictationConfig): void;
     statusWidgetText(): string;
@@ -95,7 +97,9 @@ export declare class AppVoiceController {
     private clearPartialTranscript;
     private schedulePartialTranscriptEmit;
     private isCurrentStart;
+    private continueStart;
     private isCurrentAudioProcess;
+    private isScopeActive;
 }
 declare function ensureModel(language: VoiceLanguage, definition: VoiceModelDefinition): Promise<string>;
 declare function tryLoadVosk(): VoskLoadAttempt;

package/dist/app/input/voice-controller.js

@@ -45,6 +45,7 @@ export class AppVoiceController {
     partialTranscript;
     partialTranscriptTimer;
     startGeneration = 0;
+    recordingScope;
     constructor(host, dictationConfig) {
         this.host = host;
         this.modelDefinitions = dictationConfig.languages;
@@ -97,9 +98,12 @@ export class AppVoiceController {
     async toggleLanguage() {
         if (!this.showLanguageSwitcher())
             return;
+        const scope = this.host.activeInputScope();
         const wasActive = this.state !== "idle";
         if (wasActive)
             await this.stopRecording();
+        if (!this.isScopeActive(scope))
+            return;
         this.language = this.nextLanguage();
         this.saveLanguageSelection(this.language);
         this.host.showToast(`Voice language: ${this.modelDefinition(this.language).label}`, "info");
@@ -109,21 +113,24 @@ export class AppVoiceController {
     }
     async stopRecording() {
         this.startGeneration += 1;
+        const scope = this.recordingScope;
         const audioProcess = this.audioProcess;
         const recognizer = this.recognizer;
         this.audioProcess = undefined;
         this.recognizer = undefined;
+        this.recordingScope = undefined;
         if (audioProcess && !audioProcess.killed)
             audioProcess.kill("SIGTERM");
         if (recognizer) {
-            this.clearPartialTranscript();
-            this.emitTranscript(recognizer.finalResult());
+            this.clearPartialTranscript(scope);
+            this.emitTranscript(recognizer.finalResult(), scope);
             recognizer.free?.();
         }
         if (this.state !== "idle") {
             this.clearProgressMessage();
             this.state = "idle";
-            this.host.render();
+            if (this.isScopeActive(scope))
+                this.host.render();
         }
     }
     async dispose() {
@@ -134,25 +141,29 @@ export class AppVoiceController {
     }
     async startRecording() {
         const language = this.language;
+        const scope = this.host.activeInputScope();
         const generation = this.startGeneration + 1;
         this.startGeneration = generation;
+        this.recordingScope = scope;
         try {
             const initialVosk = voiceControllerDeps.tryLoadVosk();
             const vosk = initialVosk.ok
                 ? initialVosk.module
-                : await this.installAndLoadVosk(initialVosk.error, generation);
-            if (!this.isCurrentStart(generation))
+                : await this.installAndLoadVosk(initialVosk.error, generation, scope);
+            if (!this.continueStart(generation, scope))
                 return;
             vosk.setLogLevel?.(-1);
             this.state = "downloading";
             this.host.render();
             const modelPath = await voiceControllerDeps.ensureModel(language, this.modelDefinition(language));
-            if (!this.isCurrentStart(generation))
+            if (!this.continueStart(generation, scope))
                 return;
             this.state = "loading";
             this.host.render();
             const model = this.cachedModel(language, modelPath, vosk);
             const recorder = await voiceControllerDeps.selectRecorderCommand();
+            if (!this.continueStart(generation, scope))
+                return;
             const recognizer = new vosk.Recognizer({ model, sampleRate: SAMPLE_RATE });
             const audioProcess = voiceControllerDeps.spawn(recorder.command, recorder.args, { stdio: ["ignore", "pipe", "pipe"] });
             this.recognizer = recognizer;
@@ -160,10 +171,10 @@ export class AppVoiceController {
             this.state = "listening";
             this.host.render();
             this.host.showToast(`Voice input on (${this.modelDefinition(language).label}, ${recorder.description})`, "info");
-            this.bindAudioProcess(audioProcess, recognizer, generation);
+            this.bindAudioProcess(audioProcess, recognizer, generation, scope);
         }
         catch (error) {
-            if (!this.isCurrentStart(generation))
+            if (!this.continueStart(generation, scope))
                 return;
             this.clearProgressMessage();
             this.cleanupRecognizer();
@@ -205,31 +216,31 @@ export class AppVoiceController {
             throw new Error(`dictation language is not configured: ${language}`);
         return definition;
     }
-    async installAndLoadVosk(initialError, generation) {
+    async installAndLoadVosk(initialError, generation, scope) {
         this.state = "installing";
-        this.setProgressMessage("Installing Vosk voice bindings...");
+        this.setProgressMessage("Installing Vosk voice bindings...", generation, scope);
         const vosk = await loadVoskWithAutoInstall(initialError, (message) => {
-            if (this.isCurrentStart(generation))
-                this.setProgressMessage(message);
+            if (this.isCurrentStart(generation, scope))
+                this.setProgressMessage(message, generation, scope);
         });
-        if (this.isCurrentStart(generation))
+        if (this.isCurrentStart(generation, scope))
             this.addProgressSystemMessage("Vosk voice bindings are ready.");
-        if (this.isCurrentStart(generation))
+        if (this.isCurrentStart(generation, scope))
             this.clearProgressMessage();
         return vosk;
     }
-    bindAudioProcess(audioProcess, recognizer, generation) {
+    bindAudioProcess(audioProcess, recognizer, generation, scope = this.recordingScope) {
         let stderr = "";
         audioProcess.stdout.on("data", (chunk) => {
-            if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation))
+            if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
                 return;
             try {
                 if (recognizer.acceptWaveform(chunk)) {
-                    this.clearPartialTranscript();
-                    this.emitTranscript(recognizer.result());
+                    this.clearPartialTranscript(scope);
+                    this.emitTranscript(recognizer.result(), scope);
                 }
                 else {
-                    this.emitPartialTranscript(recognizer.partialResult?.());
+                    this.emitPartialTranscript(recognizer.partialResult?.(), audioProcess, recognizer, generation, scope);
                 }
             }
             catch (error) {
@@ -241,9 +252,9 @@ export class AppVoiceController {
             stderr = `${stderr}${chunk.toString("utf8")}`.slice(-600);
         });
         audioProcess.once("error", (error) => {
-            if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation))
+            if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
                 return;
-            this.clearPartialTranscript();
+            this.clearPartialTranscript(scope);
             this.cleanupRecognizer();
             this.audioProcess = undefined;
             this.state = "idle";
@@ -251,10 +262,10 @@ export class AppVoiceController {
             this.host.render();
         });
         audioProcess.once("close", (code, signal) => {
-            if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation))
+            if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
                 return;
-            this.clearPartialTranscript();
-            this.emitTranscript(recognizer.finalResult());
+            this.clearPartialTranscript(scope);
+            this.emitTranscript(recognizer.finalResult(), scope);
             this.cleanupRecognizer();
             this.audioProcess = undefined;
             this.state = "idle";
@@ -269,11 +280,13 @@ export class AppVoiceController {
         this.recognizer?.free?.();
         this.recognizer = undefined;
     }
-    setProgressMessage(message) {
+    setProgressMessage(message, generation = this.startGeneration, scope = this.recordingScope) {
         this.progressMessage = message;
         this.addProgressSystemMessage(message);
         if (!this.progressTimer) {
             this.progressTimer = setInterval(() => {
+                if (!this.isCurrentStart(generation, scope))
+                    return;
                 this.progressFrame += 1;
                 this.host.render();
             }, 120);
@@ -296,20 +309,26 @@ export class AppVoiceController {
         this.lastSystemProgressMessage = text;
         this.host.addSystemMessage(text);
     }
-    emitTranscript(result) {
+    emitTranscript(result, scope = this.recordingScope) {
+        if (!this.isScopeActive(scope))
+            return;
         const text = transcriptText(result);
         if (!text)
             return;
         this.host.insertTranscript(text);
     }
-    emitPartialTranscript(result) {
+    emitPartialTranscript(result, audioProcess = this.audioProcess, recognizer = this.recognizer, generation = this.startGeneration, scope = this.recordingScope) {
+        if (audioProcess || recognizer) {
+            if (!audioProcess || !recognizer || !this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
+                return;
+        }
         const text = partialTranscriptText(result);
         if (text === this.partialTranscript)
             return;
         this.partialTranscript = text;
-        this.schedulePartialTranscriptEmit();
+        this.schedulePartialTranscriptEmit(audioProcess, recognizer, generation, scope);
     }
-    clearPartialTranscript() {
+    clearPartialTranscript(scope = this.recordingScope) {
         if (!this.partialTranscript)
             return;
         this.partialTranscript = undefined;
@@ -317,22 +336,44 @@ export class AppVoiceController {
             clearTimeout(this.partialTranscriptTimer);
             this.partialTranscriptTimer = undefined;
         }
-        this.host.setPartialTranscript(undefined);
+        if (this.isScopeActive(scope))
+            this.host.setPartialTranscript(undefined);
     }
-    schedulePartialTranscriptEmit() {
+    schedulePartialTranscriptEmit(audioProcess, recognizer, generation, scope) {
         if (this.partialTranscriptTimer)
             return;
         this.partialTranscriptTimer = setTimeout(() => {
             this.partialTranscriptTimer = undefined;
+            if (audioProcess && recognizer) {
+                if (!this.isCurrentAudioProcess(audioProcess, recognizer, generation, scope))
+                    return;
+            }
+            else if (!this.isScopeActive(scope)) {
+                return;
+            }
             this.host.setPartialTranscript(this.partialTranscript);
         }, VOICE_PARTIAL_TRANSCRIPT_THROTTLE_MS);
         this.partialTranscriptTimer.unref?.();
     }
-    isCurrentStart(generation) {
-        return this.startGeneration === generation;
+    isCurrentStart(generation, scope = this.recordingScope) {
+        return this.startGeneration === generation && this.recordingScope === scope && this.isScopeActive(scope);
+    }
+    continueStart(generation, scope) {
+        if (this.startGeneration !== generation || this.recordingScope !== scope)
+            return false;
+        if (this.isScopeActive(scope))
+            return true;
+        this.startGeneration += 1;
+        this.recordingScope = undefined;
+        this.clearProgressMessage();
+        this.state = "idle";
+        return false;
+    }
+    isCurrentAudioProcess(audioProcess, recognizer, generation, scope = this.recordingScope) {
+        return this.isCurrentStart(generation, scope) && this.audioProcess === audioProcess && this.recognizer === recognizer;
     }
-    isCurrentAudioProcess(audioProcess, recognizer, generation) {
-        return this.startGeneration === generation && this.audioProcess === audioProcess && this.recognizer === recognizer;
+    isScopeActive(scope) {
+        return this.host.activeInputScope() === scope;
     }
 }
 async function ensureModel(language, definition) {

package/dist/app/popup/popup-action-controller.d.ts

@@ -39,6 +39,9 @@ export declare class AppPopupActionController {
     private submitSelectedResume;
     private formatSlashCommandLine;
     private executeResourceSlashCommand;
+    private captureScope;
+    private isScopeActive;
+    private isRuntimeActive;
     private getRuntime;
     private getIdleRuntime;
 }