pi-ui-extend 0.1.1

package/dist/app/blink-controller.d.ts

@@ -0,0 +1,23 @@
+export type AppBlinkRenderScope = "status-line" | "full";
+export type AppBlinkControllerHost = {
+    render(): void;
+    renderStatusLine?(): void;
+};
+export declare class AppBlinkController {
+    private readonly host;
+    private readonly consumers;
+    private timer;
+    constructor(host: AppBlinkControllerHost);
+    setActive(key: string, active: boolean, options: {
+        scope: AppBlinkRenderScope;
+        initialVisible?: boolean;
+        resetVisible?: boolean;
+    }): void;
+    visible(key: string, fallback?: boolean): boolean;
+    dispose(): void;
+    private syncTimer;
+    private hasActiveConsumers;
+    private startTimer;
+    private stopTimer;
+    private tick;
+}

package/dist/app/blink-controller.js

@@ -0,0 +1,82 @@
+import { STATUS_BLINK_INTERVAL_MS } from "./constants.js";
+export class AppBlinkController {
+    host;
+    consumers = new Map();
+    timer;
+    constructor(host) {
+        this.host = host;
+    }
+    setActive(key, active, options) {
+        const initialVisible = options.initialVisible ?? true;
+        const consumer = this.consumers.get(key) ?? {
+            active: false,
+            visible: initialVisible,
+            initialVisible,
+            scope: options.scope,
+        };
+        consumer.scope = options.scope;
+        consumer.initialVisible = initialVisible;
+        if (consumer.active !== active || options.resetVisible === true) {
+            consumer.active = active;
+            consumer.visible = initialVisible;
+        }
+        this.consumers.set(key, consumer);
+        this.syncTimer();
+    }
+    visible(key, fallback = false) {
+        return this.consumers.get(key)?.visible ?? fallback;
+    }
+    dispose() {
+        this.stopTimer();
+        this.consumers.clear();
+    }
+    syncTimer() {
+        if (this.hasActiveConsumers()) {
+            this.startTimer();
+            return;
+        }
+        this.stopTimer();
+    }
+    hasActiveConsumers() {
+        return Array.from(this.consumers.values()).some((consumer) => consumer.active);
+    }
+    startTimer() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            this.tick();
+        }, STATUS_BLINK_INTERVAL_MS);
+        this.timer.unref?.();
+    }
+    stopTimer() {
+        if (!this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    tick() {
+        let renderScope;
+        for (const consumer of this.consumers.values()) {
+            if (!consumer.active)
+                continue;
+            consumer.visible = !consumer.visible;
+            renderScope = maxRenderScope(renderScope, consumer.scope);
+        }
+        if (renderScope === "full") {
+            this.host.render();
+            return;
+        }
+        if (renderScope === "status-line") {
+            if (this.host.renderStatusLine) {
+                this.host.renderStatusLine();
+                return;
+            }
+            this.host.render();
+        }
+    }
+}
+function maxRenderScope(current, next) {
+    if (current === "full" || next === "full")
+        return "full";
+    return "status-line";
+}

package/dist/app/cli.d.ts

@@ -0,0 +1,8 @@
+import type { AppOptions } from "./types.js";
+export type ResumeCommandOptions = {
+    cwd: string;
+    sessionPath: string;
+};
+export declare function usage(): string;
+export declare function parseArgs(argv: string[]): AppOptions;
+export declare function formatResumeCommand(options: ResumeCommandOptions): string;

package/dist/app/cli.js

@@ -0,0 +1,83 @@
+import { resolve } from "node:path";
+import { parseThemeName } from "../theme.js";
+export function usage() {
+    return `Usage: pix [--cwd <path>] [--no-session] [--session <path>] [--theme dark|light] [--model <provider/model[:thinking]>]
+	       pix update [--check] [--force]
+	       npm run dev -- [--cwd <path>] [--no-session] [--session <path>] [--theme dark|light] [--model <provider/model[:thinking]>]
+
+Examples:
+	  pix --cwd ../pi-mono
+	  pix --cwd ../pi-mono --theme light --model anthropic/claude-sonnet-4-20250514:medium
+	  pix update --check`;
+}
+export function parseArgs(argv) {
+    let cwd = process.cwd();
+    let sessionPath;
+    let modelRef;
+    let noSession = false;
+    let themeName = "dark";
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--help" || arg === "-h") {
+            console.log(usage());
+            process.exit(0);
+        }
+        if (arg === "--cwd") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new Error("Missing value for --cwd");
+            cwd = resolve(value);
+            index += 1;
+            continue;
+        }
+        if (arg === "--model") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new Error("Missing value for --model");
+            modelRef = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--session") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new Error("Missing value for --session");
+            sessionPath = resolve(value);
+            index += 1;
+            continue;
+        }
+        if (arg === "--theme") {
+            const value = argv[index + 1];
+            if (!value)
+                throw new Error("Missing value for --theme");
+            const parsedThemeName = parseThemeName(value);
+            if (!parsedThemeName)
+                throw new Error(`Unknown theme: ${value}`);
+            themeName = parsedThemeName;
+            index += 1;
+            continue;
+        }
+        if (arg === "--no-session") {
+            noSession = true;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}\n\n${usage()}`);
+    }
+    if (noSession && sessionPath)
+        throw new Error("--session cannot be used with --no-session");
+    return {
+        cwd,
+        themeName,
+        noSession,
+        ...(sessionPath === undefined ? {} : { sessionPath }),
+        ...(modelRef === undefined ? {} : { modelRef }),
+    };
+}
+export function formatResumeCommand(options) {
+    return ["pix", "--cwd", options.cwd, "--session", options.sessionPath].map(shellQuote).join(" ");
+}
+function shellQuote(value) {
+    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value))
+        return value;
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/dist/app/clipboard.d.ts

@@ -0,0 +1 @@
+export declare function copyTextToClipboard(text: string): void;

package/dist/app/clipboard.js

@@ -0,0 +1,24 @@
+import { spawnSync } from "node:child_process";
+export function copyTextToClipboard(text) {
+    const commands = clipboardCommands();
+    for (const [command, args] of commands) {
+        const result = spawnSync(command, args, { input: text, stdio: ["pipe", "ignore", "ignore"] });
+        if (!result.error && result.status === 0)
+            return;
+    }
+    throw new Error("No clipboard command found");
+}
+function clipboardCommands() {
+    switch (process.platform) {
+        case "darwin":
+            return [["pbcopy", []]];
+        case "win32":
+            return [["clip.exe", []]];
+        default:
+            return [
+                ["wl-copy", []],
+                ["xclip", ["-selection", "clipboard"]],
+                ["xsel", ["--clipboard", "--input"]],
+            ];
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { CommandControllerHost } from "./command-host.js";
+import type { PopupMenuPlacement, SessionModel, SlashCommand, ThinkingLevel } from "./types.js";
+export declare class AppCommandController {
+    private readonly host;
+    readonly slashCommands: readonly SlashCommand[];
+    private readonly modelActions;
+    private readonly sessionActions;
+    private readonly navigationActions;
+    constructor(host: CommandControllerHost);
+    runResumeCommand(queryOrOptions?: string | {
+        preserveStatus?: boolean;
+        placement?: PopupMenuPlacement;
+    }): Promise<void>;
+    runModelCommand(model: SessionModel): Promise<void>;
+    runThinkingCommand(level: ThinkingLevel): Promise<void>;
+    private registryActions;
+}
+export type { CommandControllerHost } from "./command-host.js";

package/dist/app/command-controller.js

@@ -0,0 +1,58 @@
+import { ModelCommandActions } from "./command-model-actions.js";
+import { NavigationCommandActions } from "./command-navigation-actions.js";
+import { createSlashCommands } from "./command-registry.js";
+import { SessionCommandActions } from "./command-session-actions.js";
+export class AppCommandController {
+    host;
+    slashCommands;
+    modelActions;
+    sessionActions;
+    navigationActions;
+    constructor(host) {
+        this.host = host;
+        this.modelActions = new ModelCommandActions(host);
+        this.sessionActions = new SessionCommandActions(host);
+        this.navigationActions = new NavigationCommandActions(host);
+        this.slashCommands = createSlashCommands(this.registryActions(), host);
+    }
+    async runResumeCommand(queryOrOptions = "") {
+        await this.navigationActions.runResumeCommand(queryOrOptions);
+    }
+    async runModelCommand(model) {
+        await this.modelActions.runModelCommand(model);
+    }
+    async runThinkingCommand(level) {
+        await this.modelActions.runThinkingCommand(level);
+    }
+    registryActions() {
+        return {
+            runSettingsCommand: () => this.modelActions.runSettingsCommand(),
+            runModelSlashCommand: (argumentsText) => this.modelActions.runModelSlashCommand(argumentsText),
+            runScopedModelsCommand: (argumentsText) => this.modelActions.runScopedModelsCommand(argumentsText),
+            runThinkingSlashCommand: (argumentsText) => this.modelActions.runThinkingSlashCommand(argumentsText),
+            runEnhanceCommand: () => this.host.enhancePrompt(),
+            runExportCommand: (argumentsText) => this.sessionActions.runExportCommand(argumentsText),
+            runImportCommand: (argumentsText) => this.sessionActions.runImportCommand(argumentsText),
+            runShareCommand: () => this.sessionActions.runShareCommand(),
+            runCopyCommand: () => this.sessionActions.runCopyCommand(),
+            runNameCommand: (argumentsText) => this.sessionActions.runNameCommand(argumentsText),
+            runSessionInfoCommand: () => this.sessionActions.runSessionInfoCommand(),
+            runUsageCommand: () => this.sessionActions.runUsageCommand(),
+            runChangelogCommand: () => this.sessionActions.runChangelogCommand(),
+            runUpdateCommand: (argumentsText) => this.sessionActions.runUpdateCommand(argumentsText),
+            runHotkeysCommand: () => this.sessionActions.runHotkeysCommand(),
+            runReloadCommand: () => this.sessionActions.runReloadCommand(),
+            runNewSessionCommand: () => this.sessionActions.runNewSessionCommand(),
+            runNewTabCommand: () => this.host.openNewTab(),
+            runCompactCommand: (customInstructions) => this.sessionActions.runCompactCommand(customInstructions),
+            runForkCommand: (argumentsText) => this.navigationActions.runForkCommand(argumentsText),
+            runCloneCommand: () => this.navigationActions.runCloneCommand(),
+            runTreeCommand: (argumentsText) => this.navigationActions.runTreeCommand(argumentsText),
+            runJumpCommand: (argumentsText) => this.navigationActions.runJumpCommand(argumentsText),
+            runSearchCommand: (argumentsText) => this.navigationActions.runSearchCommand(argumentsText),
+            runUnsupportedBuiltinCommand: (commandName, message) => this.navigationActions.runUnsupportedBuiltinCommand(commandName, message),
+            runResumePathCommand: (sessionPath) => this.navigationActions.runResumePathCommand(sessionPath),
+            runResumeCommand: () => this.navigationActions.runResumeCommand(),
+        };
+    }
+}

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

@@ -0,0 +1,44 @@
+import type { AgentSession, AgentSessionRuntime, SessionInfo } from "@earendil-works/pi-coding-agent";
+import type { SessionSearchResult } from "./session-search.js";
+import type { ActivePopupMenu, AppOptions, Entry, ModelMenuValue, PixMenuItem, PixMenuOptions, PopupMenuPlacement, ScopedSessionModel, SessionModel, ThinkingMenuValue } from "./types.js";
+import type { ToastNotifier } from "../ui.js";
+export type DirectPopupMenu = Exclude<ActivePopupMenu, "slash">;
+export type CommandControllerHost = {
+    readonly options: AppOptions;
+    runtime(): AgentSessionRuntime | undefined;
+    getInput(): string;
+    setInput(value: string): void;
+    promptEnhancerModelRef(): string;
+    enhancePrompt(): Promise<void>;
+    isRunning(): boolean;
+    stop(): void | Promise<void>;
+    addEntry(entry: Entry): void;
+    setStatus(status: string): void;
+    toast: ToastNotifier;
+    render(): void;
+    showMenu<T>(items: readonly PixMenuItem<T>[], options: PixMenuOptions): Promise<T | undefined>;
+    getModelMenuItems(query: string): readonly PixMenuItem<ModelMenuValue>[];
+    getThinkingMenuItems(query: string): readonly PixMenuItem<ThinkingMenuValue>[];
+    modelRef(model: SessionModel): string;
+    getFavoriteScopedModels(): ScopedSessionModel[];
+    setSessionStatus(session: AgentSession | undefined): void;
+    resetSessionView(): void;
+    loadSessionHistory(): void;
+    afterSessionReplacement(message?: string): void;
+    openDirectPopupMenu(menu: DirectPopupMenu, options?: {
+        preserveStatus?: boolean;
+        placement?: PopupMenuPlacement;
+    }): void;
+    getDirectPopupMenu(): DirectPopupMenu | undefined;
+    setDirectPopupMenu(menu: DirectPopupMenu | undefined): void;
+    setDirectPopupMenuPreserveStatus(preserveStatus: boolean): void;
+    getDirectPopupMenuQuery(): string;
+    setDirectPopupMenuQuery(query: string): void;
+    getResumeLoading(): boolean;
+    setResumeLoading(loading: boolean): void;
+    setResumeSessions(sessions: SessionInfo[]): void;
+    openResumeMenuWithQuery(query: string): void;
+    closeResumeMenu(): void;
+    openNewTab(): Promise<void>;
+    openSearchResultInNewTab(result: SessionSearchResult): Promise<void>;
+};

package/dist/app/command-host.js

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

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

@@ -0,0 +1,12 @@
+import type { CommandControllerHost } from "./command-host.js";
+import type { SessionModel, ThinkingLevel } from "./types.js";
+export declare class ModelCommandActions {
+    private readonly host;
+    constructor(host: CommandControllerHost);
+    runSettingsCommand(): Promise<void>;
+    runModelSlashCommand(argumentsText: string): Promise<void>;
+    runScopedModelsCommand(argumentsText: string): Promise<void>;
+    runThinkingSlashCommand(argumentsText: string): Promise<void>;
+    runModelCommand(model: SessionModel): Promise<void>;
+    runThinkingCommand(level: ThinkingLevel): Promise<void>;
+}

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

@@ -0,0 +1,176 @@
+import { getIdleRuntime, getRuntime } from "./command-runtime.js";
+import { createId } from "./id.js";
+import { isThinkingLevel, parseScopedModelRef } from "./model-ref.js";
+export class ModelCommandActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async runSettingsCommand() {
+        const runtime = getRuntime(this.host, "settings");
+        if (!runtime)
+            return;
+        const settings = runtime.services.settingsManager;
+        const currentModel = runtime.session.model ? this.host.modelRef(runtime.session.model) : "not selected";
+        const enabledModels = settings.getEnabledModels();
+        const scopedModelText = enabledModels && enabledModels.length > 0
+            ? enabledModels.map((model) => `  - ${model}`).join("\n")
+            : "  - default favorites";
+        const text = [
+            "Settings summary",
+            `cwd: ${runtime.cwd}`,
+            `session: ${runtime.session.sessionFile ?? "in-memory"}`,
+            `model: ${currentModel}`,
+            `prompt enhancer model: ${this.host.promptEnhancerModelRef()}`,
+            `thinking: ${runtime.session.thinkingLevel}`,
+            `theme: ${settings.getTheme() ?? this.host.options.themeName}`,
+            `skill commands: ${settings.getEnableSkillCommands() ? "enabled" : "disabled"}`,
+            `auto compaction: ${runtime.session.autoCompactionEnabled ? "enabled" : "disabled"}`,
+            `steering mode: ${runtime.session.steeringMode}`,
+            `follow-up mode: ${runtime.session.followUpMode}`,
+            "scoped models:",
+            scopedModelText,
+            "",
+            "Use /model, /thinking, /scoped-models, /export, /import, /reload for editable settings in pix.",
+        ].join("\n");
+        this.host.addEntry({ id: createId("system"), kind: "system", text });
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runModelSlashCommand(argumentsText) {
+        const modelRef = argumentsText.trim();
+        if (!modelRef) {
+            const selected = await this.host.showMenu(this.host.getModelMenuItems(""), {
+                title: "Select model",
+                placeholder: "Search models",
+                emptyText: "No matching models",
+            });
+            if (!selected) {
+                this.host.setSessionStatus(this.host.runtime()?.session);
+                this.host.render();
+                return;
+            }
+            await this.runModelCommand(selected.model);
+            this.host.render();
+            return;
+        }
+        const runtime = getRuntime(this.host, "model");
+        if (!runtime)
+            return;
+        const parsed = parseScopedModelRef(modelRef);
+        if (!parsed)
+            throw new Error("Model must use provider/model[:thinking] format");
+        runtime.services.modelRegistry.refresh();
+        const model = runtime.services.modelRegistry.find(parsed.provider, parsed.modelId);
+        if (!model)
+            throw new Error(`Model not found: ${parsed.provider}/${parsed.modelId}`);
+        await this.runModelCommand(model);
+        if (parsed.thinkingLevel !== undefined) {
+            runtime.session.setThinkingLevel(parsed.thinkingLevel);
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `Selected thinking level ${runtime.session.thinkingLevel}` });
+            this.host.setSessionStatus(runtime.session);
+        }
+    }
+    async runScopedModelsCommand(argumentsText) {
+        const runtime = getIdleRuntime(this.host, "scoped-models");
+        if (!runtime)
+            return;
+        const value = argumentsText.trim();
+        if (!value) {
+            const enabledModels = runtime.services.settingsManager.getEnabledModels();
+            const sessionModels = runtime.session.scopedModels.map((scoped) => {
+                const suffix = scoped.thinkingLevel === undefined ? "" : `:${scoped.thinkingLevel}`;
+                return `  - ${this.host.modelRef(scoped.model)}${suffix}`;
+            });
+            let scopedModelLines;
+            if (enabledModels && enabledModels.length > 0)
+                scopedModelLines = enabledModels.map((model) => `  - ${model}`);
+            else if (sessionModels.length > 0)
+                scopedModelLines = sessionModels;
+            else
+                scopedModelLines = ["  - default favorites"];
+            this.host.addEntry({
+                id: createId("system"),
+                kind: "system",
+                text: [
+                    "Scoped models",
+                    ...scopedModelLines,
+                    "",
+                    "Usage: /scoped-models <provider/model[:thinking]> [...more]",
+                    "Use /scoped-models reset to restore the default favorites.",
+                ].join("\n"),
+            });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        if (["reset", "default", "clear"].includes(value.toLowerCase())) {
+            runtime.services.settingsManager.setEnabledModels(undefined);
+            runtime.session.setScopedModels(this.host.getFavoriteScopedModels());
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Scoped models reset to default favorites." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        const refs = value.split(/[,\s]+/).map((ref) => ref.trim()).filter(Boolean);
+        const scopedModels = [];
+        const invalidRefs = [];
+        runtime.services.modelRegistry.refresh();
+        for (const ref of refs) {
+            const parsed = parseScopedModelRef(ref);
+            const model = parsed ? runtime.services.modelRegistry.find(parsed.provider, parsed.modelId) : undefined;
+            if (!parsed || !model) {
+                invalidRefs.push(ref);
+                continue;
+            }
+            scopedModels.push({ model, ...(parsed.thinkingLevel === undefined ? {} : { thinkingLevel: parsed.thinkingLevel }) });
+        }
+        if (invalidRefs.length > 0)
+            throw new Error(`Unknown model reference(s): ${invalidRefs.join(", ")}`);
+        if (scopedModels.length === 0)
+            throw new Error("No model references provided");
+        runtime.services.settingsManager.setEnabledModels(refs);
+        runtime.session.setScopedModels(scopedModels);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Scoped models set:\n${refs.map((ref) => `  - ${ref}`).join("\n")}` });
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runThinkingSlashCommand(argumentsText) {
+        const level = argumentsText.trim();
+        if (!level) {
+            const selected = await this.host.showMenu(this.host.getThinkingMenuItems(""), {
+                title: "Select thinking level",
+                placeholder: "Search thinking levels",
+                emptyText: "No matching thinking levels",
+            });
+            if (!selected) {
+                this.host.setSessionStatus(this.host.runtime()?.session);
+                this.host.render();
+                return;
+            }
+            await this.runThinkingCommand(selected.level);
+            this.host.render();
+            return;
+        }
+        if (!isThinkingLevel(level))
+            throw new Error(`Unknown thinking level: ${level}`);
+        await this.runThinkingCommand(level);
+    }
+    async runModelCommand(model) {
+        const runtime = getRuntime(this.host, "model");
+        if (!runtime)
+            return;
+        const ref = this.host.modelRef(model);
+        this.host.setStatus(`selecting model ${ref}`);
+        this.host.render();
+        await runtime.session.setModel(model);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Selected model ${ref}` });
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runThinkingCommand(level) {
+        const runtime = getRuntime(this.host, "thinking");
+        if (!runtime)
+            return;
+        this.host.setStatus(`selecting thinking ${level}`);
+        this.host.render();
+        runtime.session.setThinkingLevel(level);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Selected thinking level ${runtime.session.thinkingLevel}` });
+        this.host.setSessionStatus(runtime.session);
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { CommandControllerHost } from "./command-host.js";
+import type { PopupMenuPlacement } from "./types.js";
+export declare class NavigationCommandActions {
+    private readonly host;
+    constructor(host: CommandControllerHost);
+    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>;
+    runResumePathCommand(sessionPath: string): Promise<void>;
+    runResumeCommand(queryOrOptions?: string | {
+        preserveStatus?: boolean;
+        placement?: PopupMenuPlacement;
+    }): Promise<void>;
+    private formatSessionTree;
+    private describeSessionTreeEntry;
+}