pi-ui-extend 0.1.1

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

@@ -0,0 +1,267 @@
+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 "./message-content.js";
+import { sanitizeText } from "./render-text.js";
+import { createSessionSearchMenuItems, searchSessions } from "./session-search.js";
+export class NavigationCommandActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async runForkCommand(argumentsText) {
+        const runtime = getIdleRuntime(this.host, "fork");
+        if (!runtime)
+            return;
+        let entryId = argumentsText.trim();
+        if (!entryId) {
+            const userMessages = runtime.session.getUserMessagesForForking();
+            entryId = userMessages[userMessages.length - 1]?.entryId ?? "";
+        }
+        if (!entryId)
+            throw new Error("No user messages to fork from");
+        this.host.setStatus("forking session");
+        this.host.render();
+        const result = await runtime.fork(entryId);
+        if (result.cancelled) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Fork cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.resetSessionView();
+        this.host.loadSessionHistory();
+        if (result.selectedText)
+            this.host.setInput(result.selectedText);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Forked from entry ${entryId}.` });
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runCloneCommand() {
+        const runtime = getIdleRuntime(this.host, "clone");
+        if (!runtime)
+            return;
+        const leafId = runtime.session.sessionManager.getLeafId();
+        if (!leafId) {
+            this.host.toast.warning("Nothing to clone yet");
+            return;
+        }
+        this.host.setStatus("cloning session");
+        this.host.render();
+        const result = await runtime.fork(leafId, { position: "at" });
+        if (result.cancelled) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Clone cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.afterSessionReplacement("Cloned to a new session.");
+    }
+    async runTreeCommand(argumentsText) {
+        const runtime = getIdleRuntime(this.host, "tree");
+        if (!runtime)
+            return;
+        const targetId = argumentsText.trim();
+        if (!targetId) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: this.formatSessionTree(runtime) });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.setStatus("navigating tree");
+        this.host.render();
+        const result = await runtime.session.navigateTree(targetId);
+        if (result.aborted) {
+            this.host.toast.info("Tree navigation cancelled");
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        if (result.cancelled) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Tree navigation cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.resetSessionView();
+        this.host.loadSessionHistory();
+        if (result.editorText && !this.host.getInput().trim())
+            this.host.setInput(result.editorText);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Navigated to entry ${targetId}.` });
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runJumpCommand(argumentsText) {
+        const runtime = getRuntime(this.host, "jump");
+        if (!runtime)
+            return;
+        this.host.openDirectPopupMenu("user-message-jump", { preserveStatus: true });
+        this.host.setDirectPopupMenuQuery(argumentsText.trim());
+        this.host.render();
+    }
+    async runSearchCommand(argumentsText) {
+        const runtime = getIdleRuntime(this.host, "search");
+        if (!runtime)
+            return;
+        const query = argumentsText.trim();
+        if (!query) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Usage: /search <text>" });
+            this.host.toast.info("Enter text to search sessions");
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        let lastProgressText = "";
+        this.host.setStatus("searching sessions…");
+        this.host.render();
+        try {
+            const results = await searchSessions(query, {
+                cwd: this.host.options.cwd,
+                onProgress: (loaded, total) => {
+                    const progressText = total > 0 ? `searching sessions… ${loaded}/${total}` : "searching sessions…";
+                    if (progressText === lastProgressText)
+                        return;
+                    lastProgressText = progressText;
+                    this.host.setStatus(progressText);
+                    this.host.render();
+                },
+            });
+            if (results.length === 0) {
+                this.host.addEntry({ id: createId("system"), kind: "system", text: `No sessions found for: ${query}` });
+                this.host.toast.info("No matching sessions");
+                this.host.setSessionStatus(runtime.session);
+                this.host.render();
+                return;
+            }
+            const selected = await this.host.showMenu(createSessionSearchMenuItems(results), {
+                title: `Search sessions: ${query}`,
+                placeholder: "Filter results",
+                emptyText: "No matching search results",
+                searchable: true,
+            });
+            if (!selected) {
+                this.host.setSessionStatus(runtime.session);
+                return;
+            }
+            await this.host.openSearchResultInNewTab(selected);
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: `Session search failed: ${error instanceof Error ? error.message : String(error)}` });
+            this.host.toast.error("Session search failed");
+            this.host.setSessionStatus(runtime.session);
+            this.host.render();
+        }
+    }
+    async runUnsupportedBuiltinCommand(commandName, message) {
+        this.host.addEntry({ id: createId("system"), kind: "system", text: message });
+        this.host.toast.warning(`/${commandName} is not available in pix`);
+        this.host.setSessionStatus(this.host.runtime()?.session);
+    }
+    async runResumePathCommand(sessionPath) {
+        const runtime = getIdleRuntime(this.host, "resume");
+        if (!runtime)
+            return;
+        const resolvedSessionPath = resolve(runtime.cwd, sessionPath);
+        this.host.setStatus("switching session");
+        this.host.render();
+        const result = await runtime.switchSession(resolvedSessionPath);
+        if (result.cancelled) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Resume cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.resetSessionView();
+        this.host.loadSessionHistory();
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Resumed session ${resolvedSessionPath}` });
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runResumeCommand(queryOrOptions = "") {
+        const preserveStatus = typeof queryOrOptions === "object" && queryOrOptions.preserveStatus === true;
+        const placement = typeof queryOrOptions === "object" ? queryOrOptions.placement : undefined;
+        const initialQuery = typeof queryOrOptions === "string" ? queryOrOptions : "";
+        const runtime = preserveStatus ? this.host.runtime() : getIdleRuntime(this.host, "resume");
+        if (!runtime) {
+            if (!preserveStatus)
+                this.host.render();
+            return;
+        }
+        if (runtime.session.isStreaming) {
+            if (!preserveStatus) {
+                this.host.toast.warning("/resume is unavailable while the agent is running");
+                this.host.render();
+            }
+            return;
+        }
+        if (this.host.getResumeLoading()) {
+            if (!preserveStatus)
+                this.host.setStatus("loading sessions…");
+            this.host.render();
+            return;
+        }
+        this.host.setResumeLoading(true);
+        if (!preserveStatus)
+            this.host.setStatus("loading sessions…");
+        this.host.openDirectPopupMenu("resume", { preserveStatus, ...(placement === undefined ? {} : { placement }) });
+        this.host.setDirectPopupMenuQuery(initialQuery);
+        this.host.render();
+        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();
+        }
+        catch (error) {
+            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)
+                this.host.toast.error("Failed to load sessions");
+            if (!preserveStatus)
+                this.host.setSessionStatus(runtime.session);
+            this.host.render();
+        }
+    }
+    formatSessionTree(runtime) {
+        const tree = runtime.session.sessionManager.getTree();
+        const leafId = runtime.session.sessionManager.getLeafId();
+        if (tree.length === 0)
+            return "Session tree is empty.";
+        const lines = ["Session tree", "Use /tree <entry-id> to navigate."];
+        const walk = (node, depth) => {
+            const marker = node.entry.id === leafId ? "*" : " ";
+            const label = node.label ? ` [${node.label}]` : "";
+            lines.push(`${"  ".repeat(depth)}${marker} ${node.entry.id.slice(0, 8)} ${this.describeSessionTreeEntry(node.entry)}${label}`);
+            for (const child of node.children)
+                walk(child, depth + 1);
+        };
+        for (const node of tree)
+            walk(node, 0);
+        return lines.join("\n");
+    }
+    describeSessionTreeEntry(entry) {
+        if (!isRecord(entry))
+            return "entry";
+        const type = typeof entry.type === "string" ? entry.type : "entry";
+        if (type === "message" && isRecord(entry.message)) {
+            const role = typeof entry.message.role === "string" ? entry.message.role : "message";
+            const content = entry.message.content;
+            let text = "";
+            if (typeof content === "string")
+                text = content;
+            else if (Array.isArray(content))
+                text = renderContent(content);
+            return `${role}: ${sanitizeText(text).slice(0, 80)}`;
+        }
+        if (type === "model_change")
+            return `model: ${String(entry.provider ?? "")}/${String(entry.modelId ?? "")}`;
+        if (type === "thinking_level_change")
+            return `thinking: ${String(entry.thinkingLevel ?? "")}`;
+        if (type === "compaction")
+            return "compaction";
+        if (type === "branch_summary")
+            return "branch summary";
+        return type.replaceAll("_", " ");
+    }
+}

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

@@ -0,0 +1,32 @@
+import type { CommandControllerHost } from "./command-host.js";
+import type { SlashCommand } from "./types.js";
+export type CommandRegistryActions = {
+    runSettingsCommand(): Promise<void>;
+    runModelSlashCommand(argumentsText: string): Promise<void>;
+    runScopedModelsCommand(argumentsText: string): Promise<void>;
+    runThinkingSlashCommand(argumentsText: string): Promise<void>;
+    runEnhanceCommand(): Promise<void>;
+    runExportCommand(argumentsText: string): Promise<void>;
+    runImportCommand(argumentsText: string): Promise<void>;
+    runShareCommand(): Promise<void>;
+    runCopyCommand(): Promise<void>;
+    runNameCommand(argumentsText: string): Promise<void>;
+    runSessionInfoCommand(): Promise<void>;
+    runUsageCommand(): Promise<void>;
+    runChangelogCommand(): Promise<void>;
+    runUpdateCommand(argumentsText: string): Promise<void>;
+    runHotkeysCommand(): Promise<void>;
+    runForkCommand(argumentsText: string): Promise<void>;
+    runCloneCommand(): Promise<void>;
+    runTreeCommand(argumentsText: string): Promise<void>;
+    runJumpCommand(argumentsText: string): Promise<void>;
+    runSearchCommand(argumentsText: string): Promise<void>;
+    runUnsupportedBuiltinCommand(commandName: string, message: string): Promise<void>;
+    runReloadCommand(): Promise<void>;
+    runResumePathCommand(sessionPath: string): Promise<void>;
+    runResumeCommand(): Promise<void>;
+    runNewSessionCommand(): Promise<void>;
+    runNewTabCommand(): Promise<void>;
+    runCompactCommand(customInstructions?: string): Promise<void>;
+};
+export declare function createSlashCommands(actions: CommandRegistryActions, host: CommandControllerHost): readonly SlashCommand[];

package/dist/app/command-registry.js

@@ -0,0 +1,225 @@
+import { parsePathArgument } from "./command-runtime.js";
+export function createSlashCommands(actions, host) {
+    return [
+        {
+            name: "settings",
+            description: "Show renderer and Pi settings summary",
+            kind: "builtin",
+            keywords: ["config", "preferences", "options"],
+            run: () => actions.runSettingsCommand(),
+        },
+        {
+            name: "model",
+            description: "Select the active model",
+            kind: "builtin",
+            keywords: ["provider", "llm", "ai", "switch"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runModelSlashCommand(argumentsText),
+        },
+        {
+            name: "scoped-models",
+            description: "Show or set models used by the model selector/cycling",
+            kind: "builtin",
+            keywords: ["models", "enabled", "favorite", "scope", "cycle"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runScopedModelsCommand(argumentsText),
+        },
+        {
+            name: "thinking",
+            description: "Select the thinking level",
+            kind: "builtin",
+            keywords: ["reasoning", "effort", "level", "minimal", "medium", "high"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runThinkingSlashCommand(argumentsText),
+        },
+        {
+            name: "enhance",
+            description: "Improve the current prompt draft",
+            kind: "builtin",
+            keywords: ["prompt", "rewrite", "improve", "kilocode"],
+            run: () => actions.runEnhanceCommand(),
+        },
+        {
+            name: "export",
+            description: "Export session (HTML default, or .jsonl path)",
+            kind: "builtin",
+            keywords: ["save", "html", "jsonl", "transcript"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runExportCommand(argumentsText),
+        },
+        {
+            name: "import",
+            description: "Import and resume a session from a JSONL file",
+            kind: "builtin",
+            keywords: ["load", "jsonl", "resume", "session"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runImportCommand(argumentsText),
+        },
+        {
+            name: "share",
+            description: "Share session as a secret GitHub gist",
+            kind: "builtin",
+            keywords: ["gist", "github", "publish", "url"],
+            run: () => actions.runShareCommand(),
+        },
+        {
+            name: "copy",
+            description: "Copy last agent message to clipboard",
+            kind: "builtin",
+            keywords: ["clipboard", "assistant", "message"],
+            run: () => actions.runCopyCommand(),
+        },
+        {
+            name: "name",
+            description: "Show or set the session display name",
+            kind: "builtin",
+            keywords: ["rename", "title", "session"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runNameCommand(argumentsText),
+        },
+        {
+            name: "session",
+            description: "Show session info and stats",
+            kind: "builtin",
+            keywords: ["stats", "info", "tokens", "cost"],
+            run: () => actions.runSessionInfoCommand(),
+        },
+        {
+            name: "usage",
+            description: "Show local account quota usage",
+            kind: "builtin",
+            keywords: ["quota", "limits", "tokens", "context"],
+            suppressCommandEcho: true,
+            run: () => actions.runUsageCommand(),
+        },
+        {
+            name: "changelog",
+            description: "Show Pi package changelog",
+            kind: "builtin",
+            keywords: ["release", "version", "whats new"],
+            run: () => actions.runChangelogCommand(),
+        },
+        {
+            name: "update",
+            description: "Check for Pix package updates",
+            kind: "builtin",
+            keywords: ["upgrade", "version", "release", "external"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runUpdateCommand(argumentsText),
+        },
+        {
+            name: "hotkeys",
+            description: "Show renderer keyboard shortcuts",
+            kind: "builtin",
+            keywords: ["keys", "shortcuts", "help"],
+            run: () => actions.runHotkeysCommand(),
+        },
+        {
+            name: "fork",
+            description: "Fork from the latest or specified user-message entry",
+            kind: "builtin",
+            keywords: ["branch", "session", "previous"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runForkCommand(argumentsText),
+        },
+        {
+            name: "clone",
+            description: "Duplicate the current session at the current position",
+            kind: "builtin",
+            keywords: ["fork", "duplicate", "branch"],
+            run: () => actions.runCloneCommand(),
+        },
+        {
+            name: "tree",
+            description: "Show tree entries or navigate to an entry id",
+            kind: "builtin",
+            keywords: ["branch", "navigate", "history"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runTreeCommand(argumentsText),
+        },
+        {
+            name: "jump",
+            description: "Jump to a previous user message",
+            kind: "builtin",
+            keywords: ["user", "message", "messages", "history", "scroll", "goto", "navigate"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runJumpCommand(argumentsText),
+        },
+        {
+            name: "search",
+            description: "Search sessions and open a match in a new tab",
+            kind: "builtin",
+            keywords: ["session", "history", "find", "grep", "text", "scroll", "goto"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runSearchCommand(argumentsText),
+        },
+        {
+            name: "login",
+            description: "Configure provider authentication (not yet in pix UI)",
+            kind: "builtin",
+            keywords: ["auth", "oauth", "api key"],
+            run: () => actions.runUnsupportedBuiltinCommand("login", "Provider authentication dialogs are not implemented in pix yet. Use the stock `pi` TUI or configure API keys in settings, then run /reload."),
+        },
+        {
+            name: "logout",
+            description: "Remove provider authentication (not yet in pix UI)",
+            kind: "builtin",
+            keywords: ["auth", "oauth", "api key"],
+            run: () => actions.runUnsupportedBuiltinCommand("logout", "Provider authentication dialogs are not implemented in pix yet. Use the stock `pi` TUI or edit auth storage outside pix, then run /reload."),
+        },
+        {
+            name: "reload",
+            description: "Reload keybindings, extensions, skills, prompts, and themes",
+            kind: "builtin",
+            keywords: ["restart", "refresh", "resources", "extensions", "skills", "prompts"],
+            run: () => actions.runReloadCommand(),
+        },
+        {
+            name: "resume",
+            description: "Resume a different session",
+            kind: "builtin",
+            keywords: ["session", "history", "switch", "restore"],
+            allowArguments: true,
+            run: (argumentsText) => {
+                const sessionPath = parsePathArgument(argumentsText);
+                return sessionPath ? actions.runResumePathCommand(sessionPath) : actions.runResumeCommand();
+            },
+        },
+        {
+            name: "new",
+            description: "Start a fresh session",
+            kind: "builtin",
+            keywords: ["session", "fresh", "clear"],
+            run: () => actions.runNewSessionCommand(),
+        },
+        {
+            name: "new_tab",
+            description: "Open a fresh session in a new tab",
+            kind: "builtin",
+            keywords: ["tab", "session", "fresh", "new"],
+            run: () => actions.runNewTabCommand(),
+        },
+        {
+            name: "compact",
+            description: "Manually compact the session context",
+            kind: "builtin",
+            keywords: ["context", "compress", "summary", "summarize"],
+            allowArguments: true,
+            run: (argumentsText) => actions.runCompactCommand(argumentsText.trim() || undefined),
+        },
+        {
+            name: "quit",
+            description: "Quit the renderer",
+            kind: "builtin",
+            keywords: ["exit", "close"],
+            run: async () => { await host.stop(); },
+        },
+        {
+            name: "exit",
+            description: "Quit the renderer",
+            kind: "builtin",
+            keywords: ["quit", "close"],
+            run: async () => { await host.stop(); },
+        },
+    ];
+}

package/dist/app/command-runtime.d.ts

@@ -0,0 +1,5 @@
+import type { AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import type { CommandControllerHost } from "./command-host.js";
+export declare function getRuntime(host: CommandControllerHost, commandName: string): AgentSessionRuntime | undefined;
+export declare function getIdleRuntime(host: CommandControllerHost, commandName: string): AgentSessionRuntime | undefined;
+export declare function parsePathArgument(argumentsText: string): string | undefined;

package/dist/app/command-runtime.js

@@ -0,0 +1,32 @@
+import { createId } from "./id.js";
+export function getRuntime(host, commandName) {
+    const runtime = host.runtime();
+    if (!runtime) {
+        host.toast.error(`/${commandName} unavailable`);
+        host.addEntry({ id: createId("error"), kind: "error", text: "Runtime is not initialized" });
+        return undefined;
+    }
+    return runtime;
+}
+export function getIdleRuntime(host, commandName) {
+    const runtime = getRuntime(host, commandName);
+    if (!runtime)
+        return undefined;
+    if (runtime.session.isStreaming) {
+        host.toast.warning(`/${commandName} is unavailable while the agent is running`);
+        return undefined;
+    }
+    return runtime;
+}
+export function parsePathArgument(argumentsText) {
+    const trimmed = argumentsText.trim();
+    if (!trimmed)
+        return undefined;
+    const quote = trimmed[0];
+    if (quote === '"' || quote === "'") {
+        const end = trimmed.indexOf(quote, 1);
+        return end < 0 ? trimmed.slice(1) : trimmed.slice(1, end);
+    }
+    const whitespace = trimmed.search(/\s/);
+    return whitespace < 0 ? trimmed : trimmed.slice(0, whitespace);
+}

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

@@ -0,0 +1,20 @@
+import type { CommandControllerHost } from "./command-host.js";
+export declare class SessionCommandActions {
+    private readonly host;
+    constructor(host: CommandControllerHost);
+    runExportCommand(argumentsText: string): Promise<void>;
+    runImportCommand(argumentsText: string): Promise<void>;
+    runShareCommand(): Promise<void>;
+    runCopyCommand(): Promise<void>;
+    runNameCommand(argumentsText: string): Promise<void>;
+    runSessionInfoCommand(): Promise<void>;
+    runUsageCommand(): Promise<void>;
+    runChangelogCommand(): Promise<void>;
+    runUpdateCommand(argumentsText: string): Promise<void>;
+    runHotkeysCommand(): Promise<void>;
+    runReloadCommand(): Promise<void>;
+    runNewSessionCommand(): Promise<void>;
+    runCompactCommand(customInstructions?: string): Promise<void>;
+    private piPackageRoot;
+    private formatContextUsageLines;
+}