pi-ui-extend 0.1.8 → 0.1.11

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

@@ -0,0 +1,352 @@
+import { streamSimple } from "@earendil-works/pi-ai";
+import { isRecord } from "../guards.js";
+import { parseModelRef } from "../model/model-ref.js";
+const AUTOCOMPLETE_DEBOUNCE_MS = 350;
+const AUTOCOMPLETE_MIN_TEXT_LENGTH = 3;
+const AUTOCOMPLETE_TIMEOUT_MS = 3_000;
+const AUTOCOMPLETE_MAX_TOKENS = 48;
+const AUTOCOMPLETE_MAX_PROMPT_TOKENS = 1_200;
+const AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES = 0;
+const AUTOCOMPLETE_MAX_SUFFIX_LENGTH = 320;
+const AUTOCOMPLETE_HISTORY_MESSAGE_MAX_CHARS = 700;
+const AUTOCOMPLETE_HISTORY_CONTEXT_MAX_CHARS = 3_600;
+const AUTOCOMPLETE_TOKEN_CHARS = 4;
+const AUTOCOMPLETE_SYSTEM_PROMPT = `You are an inline autocomplete engine for pix, a terminal UI for a coding agent.
+Use provided recent active-session messages only as optional context; the current draft is the source of truth.
+Continue only the user's current draft at the cursor.
+Output only the exact suffix to append after the draft.
+Do not repeat the draft. Do not answer the user. Do not explain.
+If the draft already looks complete or the continuation is uncertain, output an empty string.
+Keep the suffix short, in the user's language/style, and stop at a natural boundary.`;
+export class AppAutocompleteController {
+    host;
+    timer;
+    lastObservedKey = "";
+    requestSeq = 0;
+    suggestion;
+    activeAbortController;
+    completeInputWithPi;
+    debounceOverrideMs;
+    constructor(host, options = {}) {
+        this.host = host;
+        this.completeInputWithPi = options.completeInputWithPi ?? completeInputWithPi;
+        this.debounceOverrideMs = options.debounceMs;
+    }
+    observeInput() {
+        const target = this.currentTarget();
+        const key = target ? this.targetKey(target) : "";
+        if (key === this.lastObservedKey)
+            return;
+        this.lastObservedKey = key;
+        this.suggestion = undefined;
+        this.clearTimer();
+        this.cancelInFlight();
+        if (!target)
+            return;
+        const requestSeq = ++this.requestSeq;
+        this.timer = setTimeout(() => {
+            void this.runAutocomplete(target, requestSeq);
+        }, this.currentDebounceMs());
+        this.timer.unref?.();
+    }
+    suggestionText() {
+        const target = this.currentTarget();
+        if (!target || !this.suggestion)
+            return undefined;
+        return this.sameTarget(target, this.suggestion.target) ? this.suggestion.text : undefined;
+    }
+    acceptSuggestion() {
+        const suggestion = this.suggestionText();
+        if (!suggestion)
+            return false;
+        this.host.inputEditor().insert(suggestion);
+        this.suggestion = undefined;
+        this.lastObservedKey = "";
+        this.clearTimer();
+        this.host.render();
+        return true;
+    }
+    dispose() {
+        this.clearTimer();
+        this.cancelInFlight();
+        this.requestSeq += 1;
+        this.suggestion = undefined;
+    }
+    async runAutocomplete(target, requestSeq) {
+        const runtime = this.host.runtime();
+        const config = { ...this.host.autocompleteConfig() };
+        if (!runtime || !config.modelRef.trim())
+            return;
+        const abortController = new AbortController();
+        this.activeAbortController = abortController;
+        try {
+            const completion = await this.completeInputWithPi(runtime, target.text, config, abortController.signal);
+            if (requestSeq !== this.requestSeq)
+                return;
+            const current = this.currentTarget();
+            if (!current || !this.sameTarget(current, target))
+                return;
+            const suggestion = cleanupCompletion(completion, target.text, config);
+            if (!suggestion)
+                return;
+            this.suggestion = { target, text: suggestion };
+            if (this.host.isRunning())
+                this.host.render();
+        }
+        catch {
+            // Inline autocomplete is best-effort; avoid surfacing transient model/auth errors while typing.
+        }
+        finally {
+            if (this.activeAbortController === abortController)
+                this.activeAbortController = undefined;
+        }
+    }
+    currentTarget() {
+        const config = this.host.autocompleteConfig();
+        if (!config.modelRef.trim())
+            return undefined;
+        const editor = this.host.inputEditor();
+        const text = editor.text;
+        const cursor = editor.cursor;
+        if (editor.hasSelection || editor.hasAttachments)
+            return undefined;
+        if (cursor !== text.length)
+            return undefined;
+        if (text.trim().length < AUTOCOMPLETE_MIN_TEXT_LENGTH)
+            return undefined;
+        if (text.startsWith("/") || text.startsWith("!"))
+            return undefined;
+        return { text, cursor };
+    }
+    targetKey(target) {
+        return `${target.cursor}\u0000${target.text}`;
+    }
+    sameTarget(a, b) {
+        return a.cursor === b.cursor && a.text === b.text;
+    }
+    currentDebounceMs() {
+        return numberInRange(this.debounceOverrideMs ?? this.host.autocompleteConfig().debounceMs, AUTOCOMPLETE_DEBOUNCE_MS, 0, 5_000);
+    }
+    clearTimer() {
+        if (!this.timer)
+            return;
+        clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+    cancelInFlight() {
+        this.activeAbortController?.abort();
+        this.activeAbortController = undefined;
+    }
+}
+export async function completeInputWithPi(runtime, draft, config, signal) {
+    const parsedModel = parseModelRef(config.modelRef);
+    const registry = runtime.services.modelRegistry;
+    let model = registry.find(parsedModel.provider, parsedModel.modelId);
+    if (!model) {
+        registry.refresh();
+        model = registry.find(parsedModel.provider, parsedModel.modelId);
+    }
+    if (!model)
+        throw new Error(`Model not found: ${parsedModel.provider}/${parsedModel.modelId}`);
+    const auth = await registry.getApiKeyAndHeaders(model);
+    if (!auth.ok)
+        throw new Error(auth.error);
+    const timeoutMs = numberInRange(config.timeoutMs, AUTOCOMPLETE_TIMEOUT_MS, 250, 10_000);
+    const maxTokens = numberInRange(config.maxTokens, AUTOCOMPLETE_MAX_TOKENS, 8, 256);
+    const maxPromptTokens = numberInRange(config.maxPromptTokens, AUTOCOMPLETE_MAX_PROMPT_TOKENS, 256, 16_000);
+    const requestSignal = createTimeoutSignal(signal, timeoutMs);
+    const requestMaxTokens = model.maxTokens > 0 ? Math.min(model.maxTokens, maxTokens) : maxTokens;
+    const requestModel = { ...model, maxTokens: requestMaxTokens };
+    const includeRecentMessages = numberInRange(config.includeRecentMessages, AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES, 0, 20);
+    const history = includeRecentMessages > 0 ? autocompleteHistoryFromMessages(runtime.session.messages, includeRecentMessages) : [];
+    const prompt = buildAutocompletePrompt({ cwd: runtime.cwd, draft, history, maxPromptTokens });
+    if (!prompt)
+        return "";
+    let output = "";
+    let streamError;
+    try {
+        const stream = streamSimple(requestModel, {
+            systemPrompt: AUTOCOMPLETE_SYSTEM_PROMPT,
+            messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+        }, {
+            ...(auth.apiKey === undefined ? {} : { apiKey: auth.apiKey }),
+            ...(auth.headers === undefined ? {} : { headers: auth.headers }),
+            cacheRetention: "none",
+            maxRetryDelayMs: 0,
+            maxRetries: 0,
+            maxTokens: requestModel.maxTokens,
+            ...(parsedModel.thinkingLevel && parsedModel.thinkingLevel !== "off" ? { reasoning: parsedModel.thinkingLevel } : {}),
+            signal: requestSignal.signal,
+            temperature: 0.1,
+            timeoutMs,
+        });
+        for await (const event of stream) {
+            if (event.type === "text_delta")
+                output += event.delta;
+            else if (event.type === "done" && !output)
+                output = assistantMessageText(event.message);
+            else if (event.type === "error")
+                streamError = event.error.errorMessage ?? event.reason;
+        }
+        if (streamError)
+            throw new Error(streamError);
+        return output;
+    }
+    finally {
+        requestSignal.dispose();
+    }
+}
+export function autocompleteHistoryFromMessages(messages, includeRecentMessages) {
+    const limit = numberInRange(includeRecentMessages, AUTOCOMPLETE_INCLUDE_RECENT_MESSAGES, 0, 20);
+    if (limit <= 0)
+        return [];
+    const history = [];
+    for (let index = messages.length - 1; index >= 0 && history.length < limit; index -= 1) {
+        const message = messages[index];
+        if (!isRecord(message))
+            continue;
+        const role = message.role === "user" || message.role === "assistant" ? message.role : undefined;
+        if (!role)
+            continue;
+        const text = compactHistoryText(messageText(message, role));
+        if (!text)
+            continue;
+        history.push({ role, text: clipHistoryText(text, AUTOCOMPLETE_HISTORY_MESSAGE_MAX_CHARS) });
+    }
+    return trimHistoryContext(history.reverse(), AUTOCOMPLETE_HISTORY_CONTEXT_MAX_CHARS);
+}
+export function buildAutocompletePrompt(input) {
+    const maxPromptTokens = numberInRange(input.maxPromptTokens, AUTOCOMPLETE_MAX_PROMPT_TOKENS, 256, 16_000);
+    let history = input.history.slice();
+    let prompt = renderAutocompletePrompt({ ...input, history });
+    while (history.length > 0 && autocompletePromptTokenEstimate(prompt) > maxPromptTokens) {
+        history = history.slice(1);
+        prompt = renderAutocompletePrompt({ ...input, history });
+    }
+    return autocompletePromptTokenEstimate(prompt) <= maxPromptTokens ? prompt : "";
+}
+function renderAutocompletePrompt(input) {
+    const lines = [
+        "Complete the current terminal input for the active pix/pi coding-agent session.",
+        `cwd: ${input.cwd}`,
+    ];
+    if (input.history.length > 0) {
+        lines.push("", "Recent messages are context only; never continue them directly.", "<recent-active-session-messages>", formatAutocompleteHistory(input.history), "</recent-active-session-messages>");
+    }
+    return [
+        ...lines,
+        "",
+        "Return only the suffix to append after <cursor>. Return nothing if unsure.",
+        "<draft>",
+        input.draft,
+        "<cursor>",
+        "</draft>",
+    ].join("\n");
+}
+export function autocompletePromptTokenEstimate(prompt, systemPrompt = AUTOCOMPLETE_SYSTEM_PROMPT) {
+    return estimateTextTokens(systemPrompt) + estimateTextTokens(prompt);
+}
+function estimateTextTokens(text) {
+    return Math.ceil(text.length / AUTOCOMPLETE_TOKEN_CHARS);
+}
+export function cleanupCompletion(output, draft, config) {
+    let text = output.replace(/\r\n/gu, "\n").trimEnd();
+    const fenced = /^```[^\n`]*\n([\s\S]*?)\n```$/u.exec(text.trim());
+    if (fenced)
+        text = fenced[1].trimEnd();
+    if (text.startsWith(draft))
+        text = text.slice(draft.length);
+    text = text
+        .replace(/^<cursor>/iu, "")
+        .replace(/^\s*(?:completion|suffix|autocomplete|продолжение)\s*:\s*/iu, "")
+        .replace(/^\n+/u, "");
+    if (!text.trim())
+        return "";
+    const maxTokens = numberInRange(config?.maxTokens, AUTOCOMPLETE_MAX_TOKENS, 8, 256);
+    const maxChars = Math.min(AUTOCOMPLETE_MAX_SUFFIX_LENGTH, maxTokens * 8);
+    return text.slice(0, maxChars);
+}
+function formatAutocompleteHistory(history) {
+    if (history.length === 0)
+        return "(no previous user/assistant messages in this active session)";
+    return history.map((message) => [
+        `<message role="${message.role}">`,
+        message.text.replace(/<\/message>/giu, "</ message>"),
+        "</message>",
+    ].join("\n")).join("\n\n");
+}
+function assistantMessageText(message) {
+    return message.content
+        .flatMap((content) => content.type === "text" ? [content.text] : [])
+        .join("\n");
+}
+function messageText(message, role) {
+    return contentText(message.content, { includeImages: role === "user" });
+}
+function contentText(content, options) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content.flatMap((part) => {
+        if (!isRecord(part) || typeof part.type !== "string")
+            return [];
+        if (part.type === "text" && typeof part.text === "string")
+            return [part.text];
+        if (part.type === "image" && options.includeImages)
+            return ["[image]"];
+        return [];
+    }).join("\n");
+}
+function compactHistoryText(text) {
+    return text
+        .replace(/\r\n/gu, "\n")
+        .split("\n")
+        .filter((line) => !isMarkdownReferenceDefinition(line))
+        .join("\n")
+        .replace(/[\t ]+/gu, " ")
+        .replace(/\n{3,}/gu, "\n\n")
+        .trim();
+}
+function clipHistoryText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const headLength = Math.floor((maxChars - 3) / 2);
+    const tailLength = maxChars - 3 - headLength;
+    return `${text.slice(0, headLength).trimEnd()}\n…\n${text.slice(-tailLength).trimStart()}`;
+}
+function trimHistoryContext(history, maxChars) {
+    const trimmed = history.slice();
+    while (trimmed.length > 0 && historyContextChars(trimmed) > maxChars)
+        trimmed.shift();
+    return trimmed;
+}
+function historyContextChars(history) {
+    return history.reduce((sum, message) => sum + message.text.length + message.role.length + 32, 0);
+}
+function isMarkdownReferenceDefinition(line) {
+    return /^ {0,3}\[[^\]\n]+\]:[ \t]*\S.*$/u.test(line);
+}
+function numberInRange(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    const rounded = Math.round(value);
+    return Math.min(max, Math.max(min, rounded));
+}
+function createTimeoutSignal(parent, timeoutMs) {
+    const abortController = new AbortController();
+    const abort = () => abortController.abort();
+    if (parent?.aborted)
+        abort();
+    else
+        parent?.addEventListener("abort", abort, { once: true });
+    const timer = setTimeout(abort, timeoutMs);
+    timer.unref?.();
+    return {
+        signal: abortController.signal,
+        dispose: () => {
+            clearTimeout(timer);
+            parent?.removeEventListener("abort", abort);
+        },
+    };
+}

package/dist/app/{input-action-controller.d.ts → input/input-action-controller.d.ts}

@@ -1,11 +1,11 @@
-import type { InputEditor } from "../input-editor.js";
+import type { InputEditor } from "../../input-editor.js";
 import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
-import type { AppPopupActionController } from "./popup-action-controller.js";
-import type { AppPopupMenuController } from "./popup-menu-controller.js";
-import type { AppQueuedMessageController } from "./queued-message-controller.js";
-import type { AppRequestHistory } from "./request-history.js";
-import { type InteractiveShellCommandResult } from "./shell-command.js";
-import type { Entry, SessionActivity } from "./types.js";
+import type { AppPopupActionController } from "../popup/popup-action-controller.js";
+import type { AppPopupMenuController } from "../popup/popup-menu-controller.js";
+import type { AppQueuedMessageController } from "../session/queued-message-controller.js";
+import type { AppRequestHistory } from "../session/request-history.js";
+import { type InteractiveShellCommandResult } from "../commands/shell-command.js";
+import type { Entry, SessionActivity } from "../types.js";
 export type AppInputActionControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     isRunning(): boolean;
@@ -36,6 +36,7 @@ export declare class AppInputActionController {
     private abortInFlight;
     constructor(host: AppInputActionControllerHost, popupMenus: AppPopupMenuController, popupActions: AppPopupActionController, queuedMessages: AppQueuedMessageController);
     handleEnter(): void;
+    queueInputFromEditor(): Promise<void>;
     handleInterrupt(): Promise<void>;
     handleEscape(): Promise<void>;
     private abortStreamingSession;

package/dist/app/{input-action-controller.js → input/input-action-controller.js}

@@ -1,6 +1,6 @@
-import { createId } from "./id.js";
-import { stringifyUnknown } from "./message-content.js";
-import { bangShellCommandFromInput, formatShellCommandEntry, } from "./shell-command.js";
+import { createId } from "../id.js";
+import { stringifyUnknown } from "../rendering/message-content.js";
+import { bangShellCommandFromInput, formatShellCommandEntry, } from "../commands/shell-command.js";
 const ABORT_STATUS_RESTORE_MS = 1200;
 export class AppInputActionController {
     host;
@@ -21,6 +21,27 @@ export class AppInputActionController {
         }
         void this.submitInput();
     }
+    async queueInputFromEditor() {
+        await this.host.stopVoiceInput();
+        if (this.popupMenus.syncActivePopupMenu())
+            this.popupMenus.cancelActivePopupMenu();
+        const inputEditor = this.host.inputEditor();
+        const rawPromptText = inputEditor.promptText;
+        const rawDisplayText = inputEditor.expandedText;
+        const promptText = rawPromptText.trimEnd();
+        const displayText = rawDisplayText.trimEnd();
+        const images = [...inputEditor.images];
+        if (!promptText && images.length === 0)
+            return;
+        const message = this.queuedMessages.createSubmittedUserMessage(promptText, displayText, images);
+        this.host.requestHistory().add(message.displayText);
+        inputEditor.clear();
+        await this.host.clearPersistedInputDraft();
+        this.host.render();
+        this.queuedMessages.deferUserMessage(message);
+        if (this.host.isRunning())
+            this.host.render();
+    }
     async handleInterrupt() {
         if (this.host.interruptShellCommand()) {
             this.host.inputEditor().clear();

package/dist/app/{input-controller.d.ts → input/input-controller.d.ts}

@@ -1,6 +1,6 @@
-import { InputEditor } from "../input-editor.js";
-import type { ExtensionTerminalInputResult } from "./extension-ui-controller.js";
-import type { MouseEvent, ActivePopupMenu } from "./types.js";
+import { InputEditor } from "../../input-editor.js";
+import type { ExtensionTerminalInputResult } from "../extensions/extension-ui-controller.js";
+import type { MouseEvent, ActivePopupMenu } from "../types.js";
 type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
 export type InputControllerHost = {
     readonly inputEditor: InputEditor;
@@ -24,6 +24,7 @@ export type InputControllerHost = {
     handleDirectPopupInput(char: string): boolean;
     autocompleteModel(): boolean;
     autocompleteThinking(): boolean;
+    acceptAutocompleteSuggestion(): boolean;
     autocompleteSlashCommand(): void;
     toggleVoiceRecording(): void;
     stop(): Promise<void>;

package/dist/app/{input-controller.js → input/input-controller.js}

@@ -42,7 +42,7 @@ export class AppInputController {
     }
     drainInputBuffer() {
         while (this.inputBuffer.length > 0) {
-            const mouseMatch = /^\x1b\[<(\d+);(\d+);(\d+)([mM])/.exec(this.inputBuffer);
+            const mouseMatch = /^\x1b\[<(\d+);(-?\d+);(-?\d+)([mM])/.exec(this.inputBuffer);
             if (mouseMatch) {
                 this.inputBuffer = this.inputBuffer.slice(mouseMatch[0].length);
                 this.host.handleMouse({
@@ -357,6 +357,8 @@ export class AppInputController {
         if (char === "\t") {
             if (this.host.getDirectPopupMenu() === "sdk-menu")
                 return;
+            if (this.host.acceptAutocompleteSuggestion())
+                return;
             if (this.host.autocompleteModel())
                 return;
             if (this.host.autocompleteThinking())

package/dist/app/{input-paste-handler.d.ts → input/input-paste-handler.d.ts}

@@ -1,4 +1,4 @@
-import { InputEditor } from "../input-editor.js";
+import { InputEditor } from "../../input-editor.js";
 export type InputPasteHost = {
     readonly inputEditor: InputEditor;
     readonly cwd: string;
@@ -20,6 +20,7 @@ export declare class InputPasteHandler {
     private plainPasteFilePath;
     private isDuplicatePaste;
     private handlePasteEnd;
+    private schedulePastedText;
     private handleFilePaste;
     private filePathForInput;
     private displayPathForInput;

package/dist/app/{input-paste-handler.js → input/input-paste-handler.js}

@@ -1,9 +1,10 @@
 import { createHash } from "node:crypto";
 import { stat } from "node:fs/promises";
 import { isAbsolute, relative, resolve } from "node:path";
-import { isImagePath, looksLikeFilePath, quoteFilePathForInput, readClipboardImage } from "../input-editor.js";
-import { PASTE_DUPLICATE_WINDOW_MS } from "./constants.js";
-import { normalizePastedTextForDuplicateKey } from "./render-text.js";
+import { isImagePath, looksLikeFilePath, quoteFilePathForInput, readClipboardImage } from "../../input-editor.js";
+import { PASTE_DUPLICATE_WINDOW_MS } from "../constants.js";
+import { normalizePastedTextForDuplicateKey } from "../rendering/render-text.js";
+const PASTE_FINGERPRINT_PREFIX_CHARS = 64 * 1024;
 export class InputPasteHandler {
     host;
     pasteBuffer = "";
@@ -23,13 +24,7 @@ export class InputPasteHandler {
             return true;
         }
         if (!this.host.inputEditor.isInBracketedPaste && this.isPlainMultilinePasteChunk(data)) {
-            if (this.isDuplicatePaste("text", data)) {
-                this.host.render();
-                return true;
-            }
-            this.host.resetRequestHistoryNavigation();
-            this.host.inputEditor.attachPastedText(data);
-            this.host.render();
+            this.schedulePastedText(data);
             return true;
         }
         return false;
@@ -43,7 +38,9 @@ export class InputPasteHandler {
     }
     endBracketedPaste() {
         this.host.inputEditor.endBracketedPaste();
-        this.handlePasteEnd();
+        const text = this.pasteBuffer;
+        this.pasteBuffer = "";
+        this.handlePasteEnd(text);
     }
     async handleClipboardImagePaste() {
         const image = await readClipboardImage();
@@ -83,16 +80,17 @@ export class InputPasteHandler {
                 this.recentPasteFingerprints.delete(fingerprint);
         }
         const normalizedPayload = kind === "text" ? normalizePastedTextForDuplicateKey(payload) : payload;
-        const fingerprint = `${kind}:${createHash("sha256").update(normalizedPayload).digest("hex")}`;
+        const fingerprintPayload = normalizedPayload.length > PASTE_FINGERPRINT_PREFIX_CHARS
+            ? `${normalizedPayload.length}:${normalizedPayload.slice(0, PASTE_FINGERPRINT_PREFIX_CHARS)}`
+            : normalizedPayload;
+        const fingerprint = `${kind}:${createHash("sha256").update(fingerprintPayload).digest("hex")}`;
         const previousTimestamp = this.recentPasteFingerprints.get(fingerprint);
         if (previousTimestamp !== undefined && now - previousTimestamp <= PASTE_DUPLICATE_WINDOW_MS)
             return true;
         this.recentPasteFingerprints.set(fingerprint, now);
         return false;
     }
-    handlePasteEnd() {
-        const text = this.pasteBuffer;
-        this.pasteBuffer = "";
+    handlePasteEnd(text) {
         if (!text)
             return;
         const filePath = this.plainPasteFilePath(text);
@@ -104,13 +102,19 @@ export class InputPasteHandler {
             void this.handleFilePaste(filePath);
             return;
         }
-        if (this.isDuplicatePaste("text", text)) {
+        this.schedulePastedText(text);
+    }
+    schedulePastedText(text) {
+        const timer = setTimeout(() => {
+            if (this.isDuplicatePaste("text", text)) {
+                this.host.render();
+                return;
+            }
+            this.host.resetRequestHistoryNavigation();
+            this.host.inputEditor.attachPastedText(text);
             this.host.render();
-            return;
-        }
-        this.host.resetRequestHistoryNavigation();
-        this.host.inputEditor.attachPastedText(text);
-        this.host.render();
+        }, 0);
+        timer.unref?.();
     }
     async handleFilePaste(filePath) {
         const inputPath = await this.filePathForInput(filePath);

package/dist/app/{native-modifiers.js → input/native-modifiers.js}

@@ -1,8 +1,8 @@
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { TERMINAL_COMMAND_MODIFIER_FLAG } from "./constants.js";
-import { isRecord } from "./guards.js";
+import { TERMINAL_COMMAND_MODIFIER_FLAG } from "../constants.js";
+import { isRecord } from "../guards.js";
 const cjsRequire = createRequire(import.meta.url);
 let nativeModifiersHelper;
 export function isNativeShiftPressed() {

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

@@ -1,9 +1,9 @@
 import { type AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
-import type { PromptEnhancerConfig } from "../config.js";
-import type { InputEditor } from "../input-editor.js";
-import type { ToastNotifier } from "../ui.js";
-import type { TabInputState } from "./tabs-controller.js";
-import type { SessionActivity } from "./types.js";
+import type { PromptEnhancerConfig } from "../../config.js";
+import type { InputEditor } from "../../input-editor.js";
+import type { ToastNotifier } from "../../ui.js";
+import type { TabInputState } from "../session/tabs-controller.js";
+import type { SessionActivity } from "../types.js";
 export type AppPromptEnhancerControllerHost = {
     runtime(): AgentSessionRuntime | undefined;
     inputEditor(): InputEditor;

package/dist/app/{prompt-enhancer-controller.js → input/prompt-enhancer-controller.js}

@@ -1,7 +1,7 @@
 import { createAgentSessionFromServices, createAgentSessionServices, SessionManager, } from "@earendil-works/pi-coding-agent";
-import { APP_ICONS } from "./icons.js";
-import { stringifyUnknown } from "./message-content.js";
-import { parseModelRef } from "./model-ref.js";
+import { APP_ICONS } from "../icons.js";
+import { stringifyUnknown } from "../rendering/message-content.js";
+import { parseModelRef } from "../model/model-ref.js";
 const PROMPT_ENHANCER_SYSTEM_PROMPT = `You improve prompts for a coding agent.
 
 Rewrite the user's draft into a clearer, more actionable prompt.

package/dist/app/{voice-controller.d.ts → input/voice-controller.d.ts}

@@ -1,4 +1,4 @@
-import { type DictationConfig } from "../config.js";
+import { type DictationConfig } from "../../config.js";
 export type VoiceLanguage = string;
 export type VoiceInputState = "idle" | "installing" | "downloading" | "loading" | "listening";
 export type AppVoiceControllerHost = {
@@ -22,6 +22,7 @@ export declare class AppVoiceController {
     private progressTimer;
     private lastSystemProgressMessage;
     private partialTranscript;
+    private partialTranscriptTimer;
     private startGeneration;
     constructor(host: AppVoiceControllerHost, dictationConfig: DictationConfig);
     statusWidgetText(): string;
@@ -47,6 +48,7 @@ export declare class AppVoiceController {
     private emitTranscript;
     private emitPartialTranscript;
     private clearPartialTranscript;
+    private schedulePartialTranscriptEmit;
     private isCurrentStart;
     private isCurrentAudioProcess;
 }