pi-ui-extend 0.1.9 → 0.1.11

package/dist/app/commands/command-navigation-actions.js

@@ -1,15 +1,23 @@
 import { resolve } from "node:path";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { getIdleRuntime, getRuntime } from "./command-runtime.js";
 import { createId } from "../id.js";
 import { isRecord } from "../guards.js";
 import { renderContent } from "../rendering/message-content.js";
 import { sanitizeText } from "../rendering/render-text.js";
 import { createSessionSearchMenuItems, searchSessions } from "../session/session-search.js";
+import { loadResumeSessionsInChunks } from "../session/resume-session-loader.js";
+function nextTick() {
+    return new Promise((resolve) => {
+        setImmediate(resolve);
+    });
+}
 export class NavigationCommandActions {
     host;
-    constructor(host) {
+    resumeSessionLoader;
+    resumeLoadId = 0;
+    constructor(host, resumeSessionLoader = loadResumeSessionsInChunks) {
         this.host = host;
+        this.resumeSessionLoader = resumeSessionLoader;
     }
     async runForkCommand(argumentsText) {
         const runtime = getIdleRuntime(this.host, "fork");
@@ -197,29 +205,44 @@ export class NavigationCommandActions {
             this.host.setStatus("loading sessions…");
         this.host.openDirectPopupMenu("resume", { preserveStatus, ...(placement === undefined ? {} : { placement }) });
         this.host.setDirectPopupMenuQuery(initialQuery);
+        if (this.host.getResumeSessions().length > 0) {
+            this.host.openResumeMenuWithQuery(initialQuery);
+        }
         this.host.render();
+        const loadId = ++this.resumeLoadId;
+        void this.loadResumeSessionsInBackground({ loadId, preserveStatus, session: runtime.session });
+    }
+    async loadResumeSessionsInBackground(options) {
         try {
-            const sessions = await SessionManager.list(this.host.options.cwd);
-            this.host.setResumeSessions(sessions);
-            this.host.setResumeLoading(false);
-            if (this.host.getDirectPopupMenu() !== "resume")
-                return;
-            this.host.openResumeMenuWithQuery(this.host.getDirectPopupMenuQuery());
-            if (!preserveStatus)
-                this.host.setSessionStatus(runtime.session);
-            this.host.render();
+            await nextTick();
+            await this.resumeSessionLoader({
+                cwd: this.host.options.cwd,
+                onChunk: (sessions, progress) => {
+                    if (options.loadId !== this.resumeLoadId)
+                        return;
+                    this.host.setResumeSessions([...sessions]);
+                    if (progress.done) {
+                        this.host.setResumeLoading(false);
+                        if (!options.preserveStatus)
+                            this.host.setSessionStatus(options.session);
+                    }
+                    this.host.render();
+                },
+            });
         }
         catch (error) {
+            if (options.loadId !== this.resumeLoadId)
+                return;
             this.host.setResumeLoading(false);
             this.host.setDirectPopupMenu(undefined);
             this.host.setDirectPopupMenuPreserveStatus(false);
             this.host.setDirectPopupMenuQuery("");
             this.host.closeResumeMenu();
             this.host.addEntry({ id: createId("error"), kind: "error", text: `Session list failed: ${error instanceof Error ? error.message : String(error)}` });
-            if (!preserveStatus)
+            if (!options.preserveStatus)
                 this.host.toast.error("Failed to load sessions");
-            if (!preserveStatus)
-                this.host.setSessionStatus(runtime.session);
+            if (!options.preserveStatus)
+                this.host.setSessionStatus(options.session);
             this.host.render();
         }
     }

package/dist/app/commands/command-registry.d.ts

@@ -3,13 +3,17 @@ import type { SlashCommand } from "../types.js";
 export type CommandRegistryActions = {
     runSettingsCommand(): Promise<void>;
     runModelSlashCommand(argumentsText: string): Promise<void>;
+    runDefaultModelSlashCommand(argumentsText: string): Promise<void>;
+    runAutocompleteSlashCommand(argumentsText: string): Promise<void>;
     runScopedModelsCommand(argumentsText: string): Promise<void>;
     runThinkingSlashCommand(argumentsText: string): Promise<void>;
+    runDefaultThinkingSlashCommand(argumentsText: string): Promise<void>;
     runEnhanceCommand(): Promise<void>;
     runExportCommand(argumentsText: string): Promise<void>;
     runImportCommand(argumentsText: string): Promise<void>;
     runShareCommand(): Promise<void>;
     runCopyCommand(): Promise<void>;
+    runQueueCommand(argumentsText: string): Promise<void>;
     runNameCommand(argumentsText: string): Promise<void>;
     runSessionInfoCommand(): Promise<void>;
     runUsageCommand(): Promise<void>;

package/dist/app/commands/command-registry.js

@@ -16,6 +16,22 @@ export function createSlashCommands(actions, host) {
             allowArguments: true,
             run: (argumentsText) => actions.runModelSlashCommand(argumentsText),
         },
+        {
+            name: "default-model",
+            description: "Set the default model for new sessions",
+            kind: "builtin",
+            keywords: ["model", "provider", "startup", "config"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runDefaultModelSlashCommand(argumentsText),
+        },
+        {
+            name: "autocomplete",
+            description: "Set inline autocomplete model, or empty to disable",
+            kind: "builtin",
+            keywords: ["complete", "ghost", "suggest", "llm", "model"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runAutocompleteSlashCommand(argumentsText),
+        },
         {
             name: "scoped-models",
             description: "Show or set models used by the model selector/cycling",
@@ -32,6 +48,14 @@ export function createSlashCommands(actions, host) {
             allowArguments: true,
             run: (argumentsText) => actions.runThinkingSlashCommand(argumentsText),
         },
+        {
+            name: "default-thinking",
+            description: "Set the default thinking level for new sessions",
+            kind: "builtin",
+            keywords: ["thinking", "reasoning", "startup", "config"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runDefaultThinkingSlashCommand(argumentsText),
+        },
         {
             name: "enhance",
             description: "Improve the current prompt draft",
@@ -69,6 +93,14 @@ export function createSlashCommands(actions, host) {
             keywords: ["clipboard", "assistant", "message"],
             run: () => actions.runCopyCommand(),
         },
+        {
+            name: "queue",
+            description: "Queue a message for manual sending later",
+            kind: "builtin",
+            keywords: ["defer", "delayed", "message", "send later"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runQueueCommand(argumentsText),
+        },
         {
             name: "name",
             description: "Show or set the session display name",

package/dist/app/commands/command-session-actions.d.ts

@@ -6,6 +6,7 @@ export declare class SessionCommandActions {
     runImportCommand(argumentsText: string): Promise<void>;
     runShareCommand(): Promise<void>;
     runCopyCommand(): Promise<void>;
+    runQueueCommand(argumentsText: string): Promise<void>;
     runNameCommand(argumentsText: string): Promise<void>;
     runSessionInfoCommand(): Promise<void>;
     runUsageCommand(): Promise<void>;

package/dist/app/commands/command-session-actions.js

@@ -1,11 +1,12 @@
-import { spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rm } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { copyToClipboard, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { getIdleRuntime, getRuntime, parsePathArgument } from "./command-runtime.js";
 import { createId } from "../id.js";
+import { runProcess } from "../process.js";
+import { copyTextToClipboard } from "../screen/clipboard.js";
 import { formatAccountUsageReport, queryAccountUsageReport } from "../model/model-usage-status.js";
 import { checkPixUpdate, formatPixUpdateCheck, parsePixUpdateArgs, pixUpdateUsage } from "../cli/update.js";
 export class SessionCommandActions {
@@ -50,7 +51,7 @@ export class SessionCommandActions {
         const runtime = getIdleRuntime(this.host, "share");
         if (!runtime)
             return;
-        const authResult = spawnSync("gh", ["auth", "status"], { encoding: "utf8" });
+        const authResult = await runProcess("gh", ["auth", "status"], { maxBufferBytes: 32 * 1024 });
         if (authResult.status !== 0)
             throw new Error("GitHub CLI is not installed or is not logged in. Run `gh auth login` first.");
         const shareDir = join(getAgentDir(), "pix");
@@ -60,7 +61,7 @@ export class SessionCommandActions {
             this.host.setStatus("creating share gist");
             this.host.render();
             await runtime.session.exportToHtml(tmpFile);
-            const gistResult = spawnSync("gh", ["gist", "create", "--public=false", tmpFile], { encoding: "utf8" });
+            const gistResult = await runProcess("gh", ["gist", "create", "--public=false", tmpFile], { maxBufferBytes: 64 * 1024 });
             if (gistResult.status !== 0)
                 throw new Error(gistResult.stderr?.trim() || "Failed to create gist");
             const gistUrl = gistResult.stdout.trim();
@@ -79,11 +80,19 @@ export class SessionCommandActions {
         const text = runtime.session.getLastAssistantText();
         if (!text)
             throw new Error("No agent messages to copy yet");
-        await copyToClipboard(text);
+        await copyTextToClipboard(text);
         this.host.addEntry({ id: createId("system"), kind: "system", text: "Copied last agent message to clipboard." });
         this.host.setSessionStatus(runtime.session);
         this.host.toast.success("Copied last agent message");
     }
+    async runQueueCommand(argumentsText) {
+        const text = argumentsText.trim();
+        if (!text)
+            throw new Error("Usage: /queue <message to send later>");
+        this.host.queueUserMessage(text);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: "Queued message for manual sending." });
+        this.host.setSessionStatus(this.host.runtime()?.session);
+    }
     async runNameCommand(argumentsText) {
         const runtime = getRuntime(this.host, "name");
         if (!runtime)
@@ -201,6 +210,7 @@ export class SessionCommandActions {
                 "Enter: send message / run selected command",
                 "!command: run a local shell command in chat (not saved to the session)",
                 "while shell is running: Enter sends editor text to stdin; Ctrl-C interrupts; !!command uses the raw terminal",
+                "/queue <message>: save a delayed message; send it later from the queued-message menu or status button",
                 "Tab: autocomplete selected popup item",
                 "Esc: close popup; abort running work when input is empty",
                 "Up/Down: history or popup navigation",

package/dist/app/commands/shell-controller.d.ts

@@ -9,6 +9,7 @@ export type AppShellControllerHost = {
     setSessionActivity(activity: SessionActivity): void;
     restoreSessionStatus(): void;
     render(): void;
+    scheduleRender(): void;
 };
 export declare class AppShellController {
     private readonly host;

package/dist/app/commands/shell-controller.js

@@ -89,7 +89,7 @@ export class AppShellController {
         this.renderTimer = setTimeout(() => {
             this.renderTimer = undefined;
             if (this.host.isRunning())
-                this.host.render();
+                this.host.scheduleRender();
         }, SHELL_RENDER_THROTTLE_MS);
         this.renderTimer.unref?.();
     }

package/dist/app/constants.d.ts

@@ -38,7 +38,7 @@ export declare const SUBAGENTS_POLL_INTERVAL_MS = 1500;
 export declare const SUBAGENTS_WIDGET_MAX_ROWS = 8;
 export declare const DEFAULT_THINKING_TOOL_RULE: ResolvedToolRule;
 export declare const TERMINAL_COMMAND_MODIFIER_FLAG = 8;
-export declare const GIT_BRANCH_CACHE_MS = 2000;
+export declare const GIT_BRANCH_CACHE_MS = 30000;
 export declare const TODO_TOOL_NAME = "todo";
 export declare const TODO_ACTIONS: readonly ["create", "update", "batch_create", "batch_update", "list", "get", "delete", "clear", "export", "import"];
 export declare const TODO_STATUSES: readonly ["pending", "in_progress", "deferred", "completed", "deleted"];

package/dist/app/constants.js

@@ -75,7 +75,7 @@ export const DEFAULT_THINKING_TOOL_RULE = {
     color: "accent",
 };
 export const TERMINAL_COMMAND_MODIFIER_FLAG = 8;
-export const GIT_BRANCH_CACHE_MS = 2_000;
+export const GIT_BRANCH_CACHE_MS = 30_000;
 export const TODO_TOOL_NAME = "todo";
 export const TODO_ACTIONS = [
     "create",

package/dist/app/icons.js

@@ -53,7 +53,7 @@ const FALLBACK_ICONS = {
     compactTools: "≡",
     thinkingExpanded: ">",
     stopCircle: "■",
-    timerSand: "…",
+    timerSand: "⏳",
     down: "v",
 };
 export const APP_ICON_THEMES = {

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

@@ -0,0 +1,52 @@
+import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { AutocompleteConfig } from "../../config.js";
+import type { InputEditor } from "../../input-editor.js";
+export type AppAutocompleteControllerHost = {
+    runtime(): AgentSessionRuntime | undefined;
+    inputEditor(): InputEditor;
+    autocompleteConfig(): AutocompleteConfig;
+    isRunning(): boolean;
+    render(): void;
+};
+export type AutocompleteHistoryMessage = {
+    role: "user" | "assistant";
+    text: string;
+};
+type AutocompleteRunner = typeof completeInputWithPi;
+export type AppAutocompleteControllerOptions = {
+    completeInputWithPi?: AutocompleteRunner;
+    debounceMs?: number;
+};
+export declare class AppAutocompleteController {
+    private readonly host;
+    private timer;
+    private lastObservedKey;
+    private requestSeq;
+    private suggestion;
+    private activeAbortController;
+    private readonly completeInputWithPi;
+    private readonly debounceOverrideMs;
+    constructor(host: AppAutocompleteControllerHost, options?: AppAutocompleteControllerOptions);
+    observeInput(): void;
+    suggestionText(): string | undefined;
+    acceptSuggestion(): boolean;
+    dispose(): void;
+    private runAutocomplete;
+    private currentTarget;
+    private targetKey;
+    private sameTarget;
+    private currentDebounceMs;
+    private clearTimer;
+    private cancelInFlight;
+}
+export declare function completeInputWithPi(runtime: AgentSessionRuntime, draft: string, config: AutocompleteConfig, signal?: AbortSignal): Promise<string>;
+export declare function autocompleteHistoryFromMessages(messages: readonly unknown[], includeRecentMessages: number): AutocompleteHistoryMessage[];
+export declare function buildAutocompletePrompt(input: {
+    cwd: string;
+    draft: string;
+    history: readonly AutocompleteHistoryMessage[];
+    maxPromptTokens?: number;
+}): string;
+export declare function autocompletePromptTokenEstimate(prompt: string, systemPrompt?: string): number;
+export declare function cleanupCompletion(output: string, draft: string, config?: Pick<AutocompleteConfig, "maxTokens">): string;
+export {};