pi-ui-extend 0.1.1

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

@@ -0,0 +1,295 @@
+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 { getIdleRuntime, getRuntime, parsePathArgument } from "./command-runtime.js";
+import { createId } from "./id.js";
+import { formatAccountUsageReport, queryAccountUsageReport } from "./model-usage-status.js";
+import { checkPixUpdate, formatPixUpdateCheck, parsePixUpdateArgs, pixUpdateUsage } from "./update.js";
+export class SessionCommandActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async runExportCommand(argumentsText) {
+        const runtime = getIdleRuntime(this.host, "export");
+        if (!runtime)
+            return;
+        const outputPath = parsePathArgument(argumentsText);
+        const resolvedOutputPath = outputPath ? resolve(runtime.cwd, outputPath) : undefined;
+        this.host.setStatus("exporting session");
+        this.host.render();
+        const filePath = resolvedOutputPath?.endsWith(".jsonl")
+            ? runtime.session.exportToJsonl(resolvedOutputPath)
+            : await runtime.session.exportToHtml(resolvedOutputPath);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Session exported to: ${filePath}` });
+        this.host.setSessionStatus(runtime.session);
+        this.host.toast.success("Session exported");
+    }
+    async runImportCommand(argumentsText) {
+        const runtime = getIdleRuntime(this.host, "import");
+        if (!runtime)
+            return;
+        const inputPath = parsePathArgument(argumentsText);
+        if (!inputPath)
+            throw new Error("Usage: /import <path.jsonl>");
+        const resolvedInputPath = resolve(runtime.cwd, inputPath);
+        this.host.setStatus("importing session");
+        this.host.render();
+        const result = await runtime.importFromJsonl(resolvedInputPath);
+        if (result.cancelled) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Import cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.afterSessionReplacement(`Session imported from: ${resolvedInputPath}`);
+    }
+    async runShareCommand() {
+        const runtime = getIdleRuntime(this.host, "share");
+        if (!runtime)
+            return;
+        const authResult = spawnSync("gh", ["auth", "status"], { encoding: "utf8" });
+        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");
+        await mkdir(shareDir, { recursive: true });
+        const tmpFile = join(shareDir, `session-share-${randomUUID()}.html`);
+        try {
+            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" });
+            if (gistResult.status !== 0)
+                throw new Error(gistResult.stderr?.trim() || "Failed to create gist");
+            const gistUrl = gistResult.stdout.trim();
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `Shared session gist: ${gistUrl}` });
+            this.host.setSessionStatus(runtime.session);
+            this.host.toast.success("Session shared");
+        }
+        finally {
+            await rm(tmpFile, { force: true }).catch(() => undefined);
+        }
+    }
+    async runCopyCommand() {
+        const runtime = getRuntime(this.host, "copy");
+        if (!runtime)
+            return;
+        const text = runtime.session.getLastAssistantText();
+        if (!text)
+            throw new Error("No agent messages to copy yet");
+        await copyToClipboard(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 runNameCommand(argumentsText) {
+        const runtime = getRuntime(this.host, "name");
+        if (!runtime)
+            return;
+        const name = argumentsText.trim();
+        if (!name) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: `Session name: ${runtime.session.sessionName ?? "(none)"}` });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        runtime.session.setSessionName(name);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Session name set: ${name}` });
+        this.host.setSessionStatus(runtime.session);
+        this.host.render();
+    }
+    async runSessionInfoCommand() {
+        const runtime = getRuntime(this.host, "session");
+        if (!runtime)
+            return;
+        const stats = runtime.session.getSessionStats();
+        const lines = [
+            "Session info",
+            ...(runtime.session.sessionName ? [`name: ${runtime.session.sessionName}`] : []),
+            `file: ${stats.sessionFile ?? "in-memory"}`,
+            `id: ${stats.sessionId}`,
+            "",
+            "Messages",
+            `user: ${stats.userMessages.toLocaleString()}`,
+            `assistant: ${stats.assistantMessages.toLocaleString()}`,
+            `tool calls: ${stats.toolCalls.toLocaleString()}`,
+            `tool results: ${stats.toolResults.toLocaleString()}`,
+            `total: ${stats.totalMessages.toLocaleString()}`,
+            "",
+            "Tokens",
+            `input: ${stats.tokens.input.toLocaleString()}`,
+            `output: ${stats.tokens.output.toLocaleString()}`,
+            `cache read: ${stats.tokens.cacheRead.toLocaleString()}`,
+            `cache write: ${stats.tokens.cacheWrite.toLocaleString()}`,
+            `total: ${stats.tokens.total.toLocaleString()}`,
+            ...(stats.cost > 0 ? ["", `cost: ${stats.cost.toFixed(4)}`] : []),
+        ];
+        this.host.addEntry({ id: createId("system"), kind: "system", text: lines.join("\n") });
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runUsageCommand() {
+        const runtime = getRuntime(this.host, "usage");
+        if (!runtime)
+            return;
+        this.host.setStatus("loading usage");
+        this.host.render();
+        const accountReport = await queryAccountUsageReport();
+        const accountUsage = formatAccountUsageReport(accountReport);
+        if (accountUsage) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: accountUsage });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        const stats = runtime.session.getSessionStats();
+        const contextUsage = stats.contextUsage ?? runtime.session.getContextUsage();
+        const model = runtime.session.model ? this.host.modelRef(runtime.session.model) : "not selected";
+        const lines = [
+            "Usage",
+            `model: ${model}`,
+            "",
+            "Tokens",
+            `input: ${stats.tokens.input.toLocaleString()}`,
+            `output: ${stats.tokens.output.toLocaleString()}`,
+            `cache read: ${stats.tokens.cacheRead.toLocaleString()}`,
+            `cache write: ${stats.tokens.cacheWrite.toLocaleString()}`,
+            `total: ${stats.tokens.total.toLocaleString()}`,
+            ...(stats.cost > 0 ? [`cost: ${stats.cost.toFixed(4)}`] : []),
+            "",
+            "Context",
+            ...this.formatContextUsageLines(contextUsage),
+        ];
+        this.host.addEntry({ id: createId("system"), kind: "system", text: lines.join("\n") });
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runChangelogCommand() {
+        const changelogPath = join(this.piPackageRoot(), "CHANGELOG.md");
+        const raw = await readFile(changelogPath, "utf8");
+        const lines = raw.trim().split(/\r?\n/).slice(0, 140);
+        this.host.addEntry({ id: createId("system"), kind: "system", text: lines.join("\n") });
+        this.host.setSessionStatus(this.host.runtime()?.session);
+    }
+    async runUpdateCommand(argumentsText) {
+        const runtime = getRuntime(this.host, "update");
+        if (!runtime)
+            return;
+        const options = parsePixUpdateArgs(splitUpdateArguments(argumentsText));
+        if (options.help) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: pixUpdateUsage() });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.setStatus("checking updates");
+        this.host.render();
+        const result = await checkPixUpdate();
+        const forceHint = options.force ? "\n\n/update is check-only. To force a reinstall, run `pix update --force` in your shell and restart Pix." : "";
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `${formatPixUpdateCheck(result)}${forceHint}` });
+        this.host.setSessionStatus(runtime.session);
+        if (result.status === "newer")
+            this.host.toast.info("Pix update available");
+        else if (result.status === "current")
+            this.host.toast.success("Pix is up to date");
+        else
+            this.host.toast.warning("Pix update check incomplete");
+    }
+    async runHotkeysCommand() {
+        this.host.addEntry({
+            id: createId("system"),
+            kind: "system",
+            text: [
+                "Keyboard shortcuts",
+                "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",
+                "Tab: autocomplete selected popup item",
+                "Esc: close popup; abort running work when input is empty",
+                "Up/Down: history or popup navigation",
+                "PageUp/PageDown or Cmd+Up/Cmd+Down: scroll conversation by page",
+                "Mouse wheel or right scrollbar: scroll conversation/popup",
+                "/enhance or status magic-wand icon: improve the current prompt draft",
+                "Status model/thinking/session/enhance/voice areas are clickable when shown.",
+            ].join("\n"),
+        });
+        this.host.setSessionStatus(this.host.runtime()?.session);
+    }
+    async runReloadCommand() {
+        const runtime = getIdleRuntime(this.host, "reload");
+        if (!runtime)
+            return;
+        this.host.setStatus("reloading");
+        this.host.render();
+        try {
+            await runtime.session.reload();
+            this.host.setSessionStatus(runtime.session);
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "Reloaded keybindings, extensions, skills, prompts, themes" });
+            this.host.toast.success("Reloaded resources");
+        }
+        catch (error) {
+            this.host.setSessionStatus(runtime.session);
+            this.host.addEntry({ id: createId("error"), kind: "error", text: `Reload failed: ${error instanceof Error ? error.message : String(error)}` });
+            this.host.toast.error("Reload failed");
+        }
+    }
+    async runNewSessionCommand() {
+        const runtime = getIdleRuntime(this.host, "new");
+        if (!runtime)
+            return;
+        this.host.setStatus("starting new session");
+        this.host.render();
+        const result = await runtime.newSession();
+        if (result.cancelled) {
+            this.host.addEntry({ id: createId("system"), kind: "system", text: "New session cancelled." });
+            this.host.setSessionStatus(runtime.session);
+            return;
+        }
+        this.host.resetSessionView();
+        this.host.addEntry({ id: createId("system"), kind: "system", text: `Started a new session. cwd=${runtime.cwd}` });
+        if (runtime.modelFallbackMessage)
+            this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
+        for (const diag of runtime.diagnostics ?? []) {
+            const kind = diag.type === "error" ? "error" : "system";
+            this.host.addEntry({ id: createId("system"), kind, text: `[${diag.type}] ${diag.message}` });
+        }
+        this.host.setSessionStatus(runtime.session);
+    }
+    async runCompactCommand(customInstructions) {
+        const runtime = getRuntime(this.host, "compact");
+        if (!runtime)
+            return;
+        if (runtime.session.isCompacting) {
+            this.host.toast.warning("Compaction already running");
+            return;
+        }
+        this.host.setStatus(customInstructions ? "compacting with instructions" : "compacting");
+        this.host.render();
+        const result = await runtime.session.compact(customInstructions);
+        this.host.addEntry({
+            id: createId("system"),
+            kind: "system",
+            text: `Compacted context (${result.tokensBefore} tokens before compaction).`,
+        });
+        this.host.setSessionStatus(runtime.session);
+        this.host.toast.success(`Compacted ${result.tokensBefore} tokens`);
+    }
+    piPackageRoot() {
+        return dirname(dirname(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))));
+    }
+    formatContextUsageLines(usage) {
+        if (!usage)
+            return ["unavailable"];
+        const tokens = usage.tokens == null ? "unknown" : usage.tokens.toLocaleString();
+        const percent = usage.percent == null ? "unknown" : `${trimDecimal(usage.percent)}%`;
+        return [
+            `tokens: ${tokens}`,
+            `window: ${usage.contextWindow.toLocaleString()}`,
+            `used: ${percent}`,
+        ];
+    }
+}
+function trimDecimal(value) {
+    return value.toFixed(1).replace(/\.0$/, "");
+}
+function splitUpdateArguments(argumentsText) {
+    const trimmed = argumentsText.trim();
+    return trimmed ? trimmed.split(/\s+/u) : [];
+}

package/dist/app/constants.d.ts

@@ -0,0 +1,52 @@
+import type { ResolvedToolRule } from "../config.js";
+export declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh"];
+export declare const THINKING_MENU_MAX_ROWS: number;
+export declare const PI_FAVORITE_MODEL_REFS: readonly ["amazon-bedrock/us.anthropic.claude-opus-4-6-v1", "anthropic/claude-opus-4-8", "openai/gpt-5.4", "azure-openai-responses/gpt-5.4", "openai-codex/gpt-5.5", "deepseek/deepseek-v4-pro", "google/gemini-3.1-pro-preview", "google-vertex/gemini-3.1-pro-preview", "github-copilot/gpt-5.4", "openrouter/moonshotai/kimi-k2.6", "vercel-ai-gateway/zai/glm-5.1", "xai/grok-4.20-0309-reasoning", "groq/openai/gpt-oss-120b", "cerebras/zai-glm-4.7", "zai/glm-5.1", "mistral/devstral-medium-latest", "minimax/MiniMax-M2.7", "minimax-cn/MiniMax-M2.7", "moonshotai/kimi-k2.6", "moonshotai-cn/kimi-k2.6", "huggingface/moonshotai/Kimi-K2.6", "fireworks/accounts/fireworks/models/kimi-k2p6", "together/moonshotai/Kimi-K2.6", "opencode/kimi-k2.6", "opencode-go/kimi-k2.6", "kimi-coding/kimi-for-coding", "cloudflare-workers-ai/@cf/moonshotai/kimi-k2.6", "cloudflare-ai-gateway/workers-ai/@cf/moonshotai/kimi-k2.6", "xiaomi/mimo-v2.5-pro", "xiaomi-token-plan-cn/mimo-v2.5-pro", "xiaomi-token-plan-ams/mimo-v2.5-pro", "xiaomi-token-plan-sgp/mimo-v2.5-pro"];
+export declare const SLASH_COMMAND_MENU_MAX_ROWS = 6;
+export declare const RESUME_MENU_MAX_ROWS = 20;
+export declare const RESUME_MENU_INITIAL_SESSION_ROWS = 30;
+export declare const RESUME_MENU_LOAD_BATCH_ROWS = 10;
+export declare const RESUME_MENU_LOAD_THRESHOLD_ROWS = 10;
+export declare const SLASH_COMMAND_DESCRIPTION_COLUMN = 36;
+export declare const INPUT_MAX_ROWS = 8;
+export declare const RUNTIME_DISPOSE_GRACE_MS = 250;
+export declare const PASTE_DUPLICATE_WINDOW_MS = 1200;
+export declare const TOAST_DURATION_MS = 5000;
+export declare const STATUS_BLINK_INTERVAL_MS = 500;
+export declare const MODEL_USAGE_STATUS_TICK_MS = 60000;
+export declare const MODEL_USAGE_POLL_INTERVAL_MS: number;
+export declare const REQUEST_HISTORY_VERSION = 1;
+export declare const REQUEST_HISTORY_MAX_ENTRIES = 200;
+export declare const REQUEST_HISTORY_MAX_BYTES: number;
+export declare const REQUEST_HISTORY_MAX_ENTRY_BYTES: number;
+export declare const ENABLE_TERMINAL_KEY_REPORTING = "\u001B[>7u\u001B[>4;2m";
+export declare const DISABLE_TERMINAL_KEY_REPORTING = "\u001B[<u\u001B[>4;0m";
+export declare const ENABLE_BRACKETED_PASTE = "\u001B[?2004h";
+export declare const DISABLE_BRACKETED_PASTE = "\u001B[?2004l";
+export declare const DISABLE_TERMINAL_WRAP = "\u001B[?7l";
+export declare const ENABLE_TERMINAL_WRAP = "\u001B[?7h";
+export declare const HIDE_CURSOR = "\u001B[?25l";
+export declare const SHOW_CURSOR = "\u001B[?25h";
+export declare const CLEAR_TERMINAL = "\u001B[2J\u001B[3J\u001B[H";
+export declare const THINKING_TOOL_NAME = "thinking";
+export declare const SUBAGENTS_TOOL_NAME = "subagents";
+export declare const SUBAGENTS_TOOL_NAME_PREFIX = "async_subagents_";
+export declare const SUBAGENTS_RUN_ROOT: string;
+export declare const SUBAGENTS_REGISTRY_FILE = "registry.json";
+export declare const SUBAGENT_PARENT_SESSION_FILE = "parent_session";
+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 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"];
+export declare const TODO_PRIORITIES: readonly ["low", "medium", "high", "urgent"];
+export declare const SUBAGENT_STATUSES: readonly ["planned", "running", "retrying", "done", "failed", "stopped"];
+export declare const SUBAGENT_ACTIVE_STATUSES: readonly ["planned", "running", "retrying"];
+export declare const SUBAGENT_TERMINAL_STATUSES: readonly ["done", "failed", "stopped"];
+export declare const SUBAGENT_RENDER_MODES: readonly ["spawn", "status", "wait", "stop", "completion"];
+export declare const ABOVE_EDITOR_WIDGET_KEY_GROUPS: readonly (readonly string[])[];
+export declare const LEGACY_TODO_WIDGET_KEYS: Set<string>;
+export declare const BUILT_IN_SUBAGENTS_WIDGET_KEYS: Set<string>;

package/dist/app/constants.js

@@ -0,0 +1,103 @@
+import { join } from "node:path";
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
+export const THINKING_MENU_MAX_ROWS = THINKING_LEVELS.length + 1;
+export const PI_FAVORITE_MODEL_REFS = [
+    "amazon-bedrock/us.anthropic.claude-opus-4-6-v1",
+    "anthropic/claude-opus-4-8",
+    "openai/gpt-5.4",
+    "azure-openai-responses/gpt-5.4",
+    "openai-codex/gpt-5.5",
+    "deepseek/deepseek-v4-pro",
+    "google/gemini-3.1-pro-preview",
+    "google-vertex/gemini-3.1-pro-preview",
+    "github-copilot/gpt-5.4",
+    "openrouter/moonshotai/kimi-k2.6",
+    "vercel-ai-gateway/zai/glm-5.1",
+    "xai/grok-4.20-0309-reasoning",
+    "groq/openai/gpt-oss-120b",
+    "cerebras/zai-glm-4.7",
+    "zai/glm-5.1",
+    "mistral/devstral-medium-latest",
+    "minimax/MiniMax-M2.7",
+    "minimax-cn/MiniMax-M2.7",
+    "moonshotai/kimi-k2.6",
+    "moonshotai-cn/kimi-k2.6",
+    "huggingface/moonshotai/Kimi-K2.6",
+    "fireworks/accounts/fireworks/models/kimi-k2p6",
+    "together/moonshotai/Kimi-K2.6",
+    "opencode/kimi-k2.6",
+    "opencode-go/kimi-k2.6",
+    "kimi-coding/kimi-for-coding",
+    "cloudflare-workers-ai/@cf/moonshotai/kimi-k2.6",
+    "cloudflare-ai-gateway/workers-ai/@cf/moonshotai/kimi-k2.6",
+    "xiaomi/mimo-v2.5-pro",
+    "xiaomi-token-plan-cn/mimo-v2.5-pro",
+    "xiaomi-token-plan-ams/mimo-v2.5-pro",
+    "xiaomi-token-plan-sgp/mimo-v2.5-pro",
+];
+export const SLASH_COMMAND_MENU_MAX_ROWS = 6;
+export const RESUME_MENU_MAX_ROWS = 20;
+export const RESUME_MENU_INITIAL_SESSION_ROWS = 30;
+export const RESUME_MENU_LOAD_BATCH_ROWS = 10;
+export const RESUME_MENU_LOAD_THRESHOLD_ROWS = 10;
+export const SLASH_COMMAND_DESCRIPTION_COLUMN = 36;
+export const INPUT_MAX_ROWS = 8;
+export const RUNTIME_DISPOSE_GRACE_MS = 250;
+export const PASTE_DUPLICATE_WINDOW_MS = 1200;
+export const TOAST_DURATION_MS = 5000;
+export const STATUS_BLINK_INTERVAL_MS = 500;
+export const MODEL_USAGE_STATUS_TICK_MS = 60_000;
+export const MODEL_USAGE_POLL_INTERVAL_MS = 5 * 60_000;
+export const REQUEST_HISTORY_VERSION = 1;
+export const REQUEST_HISTORY_MAX_ENTRIES = 200;
+export const REQUEST_HISTORY_MAX_BYTES = 128 * 1024;
+export const REQUEST_HISTORY_MAX_ENTRY_BYTES = 16 * 1024;
+export const ENABLE_TERMINAL_KEY_REPORTING = "\x1b[>7u\x1b[>4;2m";
+export const DISABLE_TERMINAL_KEY_REPORTING = "\x1b[<u\x1b[>4;0m";
+export const ENABLE_BRACKETED_PASTE = "\x1b[?2004h";
+export const DISABLE_BRACKETED_PASTE = "\x1b[?2004l";
+export const DISABLE_TERMINAL_WRAP = "\x1b[?7l";
+export const ENABLE_TERMINAL_WRAP = "\x1b[?7h";
+export const HIDE_CURSOR = "\x1b[?25l";
+export const SHOW_CURSOR = "\x1b[?25h";
+export const CLEAR_TERMINAL = "\x1b[2J\x1b[3J\x1b[H";
+export const THINKING_TOOL_NAME = "thinking";
+export const SUBAGENTS_TOOL_NAME = "subagents";
+export const SUBAGENTS_TOOL_NAME_PREFIX = "async_subagents_";
+export const SUBAGENTS_RUN_ROOT = join(".pi", "subagents");
+export const SUBAGENTS_REGISTRY_FILE = "registry.json";
+export const SUBAGENT_PARENT_SESSION_FILE = "parent_session";
+export const SUBAGENTS_POLL_INTERVAL_MS = 1_500;
+export const SUBAGENTS_WIDGET_MAX_ROWS = 8;
+export const DEFAULT_THINKING_TOOL_RULE = {
+    previewLines: 0,
+    direction: "head",
+    color: "accent",
+};
+export const TERMINAL_COMMAND_MODIFIER_FLAG = 8;
+export const GIT_BRANCH_CACHE_MS = 2_000;
+export const TODO_TOOL_NAME = "todo";
+export const TODO_ACTIONS = [
+    "create",
+    "update",
+    "batch_create",
+    "batch_update",
+    "list",
+    "get",
+    "delete",
+    "clear",
+    "export",
+    "import",
+];
+export const TODO_STATUSES = ["pending", "in_progress", "deferred", "completed", "deleted"];
+export const TODO_PRIORITIES = ["low", "medium", "high", "urgent"];
+export const SUBAGENT_STATUSES = ["planned", "running", "retrying", "done", "failed", "stopped"];
+export const SUBAGENT_ACTIVE_STATUSES = ["planned", "running", "retrying"];
+export const SUBAGENT_TERMINAL_STATUSES = ["done", "failed", "stopped"];
+export const SUBAGENT_RENDER_MODES = ["spawn", "status", "wait", "stop", "completion"];
+export const ABOVE_EDITOR_WIDGET_KEY_GROUPS = [
+    ["rpiv-todos", "plan-todos"],
+    ["async-subagents-live"],
+];
+export const LEGACY_TODO_WIDGET_KEYS = new Set(["rpiv-todos", "plan-todos"]);
+export const BUILT_IN_SUBAGENTS_WIDGET_KEYS = new Set(["async-subagents-live"]);

package/dist/app/conversation-entry-renderer.d.ts

@@ -0,0 +1,21 @@
+import { type PixConfig } from "../config.js";
+import type { Theme } from "../theme.js";
+import type { Entry, RenderedLine } from "./types.js";
+export type InlineUserMessageMenuContext = {
+    userContentWidth: number;
+    userContentLeft: number;
+    userLine: (text: string, entryId?: string, syntaxHighlight?: RenderedLine["syntaxHighlight"]) => RenderedLine;
+};
+export type ConversationEntryRenderOptions = {
+    cwd: string;
+    colors: Theme["colors"];
+    pixConfig: PixConfig;
+    outputFilters: readonly RegExp[];
+    suppressPendingDcpIdMetadata: boolean;
+    superCompactTools?: boolean;
+    allThinkingExpanded?: boolean;
+    renderInlineUserMessageMenu: (entry: Extract<Entry, {
+        kind: "user";
+    }>, context: InlineUserMessageMenuContext) => RenderedLine[];
+};
+export declare function renderConversationEntry(entry: Entry, width: number, options: ConversationEntryRenderOptions): RenderedLine[];

package/dist/app/conversation-entry-renderer.js

@@ -0,0 +1,81 @@
+import { applyOutputFilters, stripDcpDisplayMetadata, suppressPendingDcpIdMetadataLine } from "../config.js";
+import { renderMarkdownTextLines } from "../markdown-format.js";
+import { attachImageClickTargets } from "./image-click-targets.js";
+import { horizontalPaddingLayout, padHorizontalText, wrapText } from "./render-text.js";
+import { renderConversationShellEntry } from "./conversation-shell-renderer.js";
+import { renderConversationToolEntry, renderThinkingEntry } from "./conversation-tool-renderer.js";
+export function renderConversationEntry(entry, width, options) {
+    const { left: userContentLeft, contentWidth: userContentWidth } = horizontalPaddingLayout(width);
+    const userLine = (text, entryId, syntaxHighlight, segments) => ({
+        text: padHorizontalText(text, width),
+        colorOverride: options.colors.inputForeground,
+        backgroundOverride: options.colors.userMessageBackground,
+        ...(segments && segments.length > 0 ? { segments: segments.map((segment) => ({ ...segment, start: segment.start + userContentLeft, end: segment.end + userContentLeft })) } : {}),
+        ...(syntaxHighlight === undefined ? {} : { syntaxHighlight }),
+        ...(entryId === undefined ? {} : { target: { kind: "user-message", id: entryId } }),
+    });
+    const queuedLine = (text, entryId) => ({
+        text: padHorizontalText(text, width),
+        variant: "muted",
+        backgroundOverride: options.colors.userMessageBackground,
+        target: { kind: "queue-message", id: entryId },
+    });
+    const userMessageLines = (userEntry) => {
+        const lines = [
+            userLine("", userEntry.id),
+            ...renderMarkdownTextLines(userEntry.text, userContentWidth, userContentLeft).map((line) => userLine(line.text, userEntry.id, line.syntaxHighlight, line.segments)),
+        ];
+        lines.push(...options.renderInlineUserMessageMenu(userEntry, { userContentWidth, userContentLeft, userLine }));
+        lines.push(userLine("", userEntry.id));
+        return attachImageClickTargets(lines, userEntry.id, userEntry.images, { foreground: options.colors.info, underline: true });
+    };
+    const queuedMessageLines = (queuedEntry) => [
+        queuedLine("", queuedEntry.id),
+        ...wrapText(`↳ queued ${queuedEntry.mode}: ${queuedEntry.text}`, userContentWidth).map((text) => queuedLine(text, queuedEntry.id)),
+        queuedLine("", queuedEntry.id),
+    ];
+    switch (entry.kind) {
+        case "system":
+            return wrapText(`system: ${entry.text}`, width).map((text) => ({ text, variant: "muted" }));
+        case "user":
+            return userMessageLines(entry);
+        case "queued":
+            return queuedMessageLines(entry);
+        case "assistant":
+            return renderAssistantLines(entry.text, width, options);
+        case "custom":
+            return renderCustomEntry(entry, width);
+        case "session-aborted":
+            return wrapText(entry.text, width).map((text) => ({ text, variant: "error" }));
+        case "shell":
+            return renderConversationShellEntry(entry, width, options);
+        case "thinking":
+            return renderThinkingEntry(entry, width, options);
+        case "error":
+            return wrapText(`error: ${entry.text}`, width).map((text) => ({ text, variant: "error" }));
+        case "tool":
+            return renderConversationToolEntry(entry, width, options);
+    }
+}
+function renderCustomEntry(entry, width) {
+    const label = `[${entry.customType}]`;
+    return wrapText(`${label}\n${entry.text}`, width).map((text, index) => ({
+        text,
+        variant: index === 0 ? "accent" : "normal",
+    }));
+}
+function renderAssistantLines(text, width, options) {
+    const displayText = displayAssistantText(text, options.outputFilters, options.suppressPendingDcpIdMetadata);
+    if (!displayText)
+        return [];
+    return renderMarkdownTextLines(displayText, width).map((line) => ({
+        text: line.text,
+        colorOverride: options.colors.assistantForeground,
+        ...(line.segments && line.segments.length > 0 ? { segments: line.segments } : {}),
+        ...(line.syntaxHighlight ? { syntaxHighlight: line.syntaxHighlight } : {}),
+    }));
+}
+function displayAssistantText(text, outputFilters, suppressPendingDcpIdMetadata) {
+    const filtered = stripDcpDisplayMetadata(applyOutputFilters(text, outputFilters)).trimEnd();
+    return suppressPendingDcpIdMetadata ? suppressPendingDcpIdMetadataLine(filtered) : filtered;
+}

package/dist/app/conversation-shell-renderer.d.ts

@@ -0,0 +1,5 @@
+import type { Entry, RenderedLine } from "./types.js";
+import type { ConversationToolRenderOptions } from "./conversation-tool-renderer.js";
+export declare function renderConversationShellEntry(entry: Extract<Entry, {
+    kind: "shell";
+}>, width: number, options: ConversationToolRenderOptions): RenderedLine[];

package/dist/app/conversation-shell-renderer.js

@@ -0,0 +1,43 @@
+import { resolveToolRule } from "../config.js";
+import { renderToolBlock } from "./tool-block-renderer.js";
+export function renderConversationShellEntry(entry, width, options) {
+    const body = shellEntryBody(entry);
+    return renderToolBlock({
+        id: entry.id,
+        toolName: "shell",
+        headerArgs: entry.command,
+        expanded: entry.expanded,
+        status: entry.status,
+        isError: shellEntryIsError(entry),
+        output: body,
+        collapsedBody: body,
+        expandedText: body,
+        preserveAnsi: true,
+    }, resolveToolRule("shell", options.pixConfig.toolRenderer), width, options.colors, { superCompact: Boolean(options.superCompactTools) });
+}
+function shellEntryBody(entry) {
+    const output = entry.output.trimEnd();
+    const status = shellEntryStatusLine(entry);
+    if (!output)
+        return status;
+    return `${output}\n${status}`;
+}
+function shellEntryStatusLine(entry) {
+    return `\x1b[90m[pix] ${shellEntryStatusText(entry)}\x1b[0m`;
+}
+function shellEntryStatusText(entry) {
+    if (entry.status === "running")
+        return "running — submit editor text to send stdin, Ctrl-C to interrupt";
+    if (entry.error)
+        return `failed to start: ${entry.error}`;
+    if (entry.signal)
+        return `terminated by ${entry.signal}`;
+    return `exit ${entry.exitCode ?? 0}`;
+}
+function shellEntryIsError(entry) {
+    if (entry.status !== "done")
+        return false;
+    if (entry.error || entry.signal)
+        return true;
+    return (entry.exitCode ?? 0) !== 0;
+}

package/dist/app/conversation-tool-renderer.d.ts

@@ -0,0 +1,16 @@
+import { type PixConfig } from "../config.js";
+import type { Theme } from "../theme.js";
+import type { Entry, RenderedLine } from "./types.js";
+export type ConversationToolRenderOptions = {
+    cwd: string;
+    pixConfig: PixConfig;
+    colors: Theme["colors"];
+    superCompactTools?: boolean;
+    allThinkingExpanded?: boolean;
+};
+export declare function renderConversationToolEntry(entry: Extract<Entry, {
+    kind: "tool";
+}>, width: number, options: ConversationToolRenderOptions): RenderedLine[];
+export declare function renderThinkingEntry(entry: Extract<Entry, {
+    kind: "thinking";
+}>, width: number, options: ConversationToolRenderOptions): RenderedLine[];