lsd-pi 1.1.4 → 1.1.6

package/packages/pi-coding-agent/src/modes/interactive/components/embedded-terminal.ts

@@ -0,0 +1,224 @@
+/**
+ * Embedded PTY terminal for user-triggered bash commands.
+ * Renders a framed terminal surface and forwards keystrokes to a PTY handle.
+ */
+
+import { decodeKittyPrintable, matchesKey, parseKey, type Focusable, type TUI } from "@gsd/pi-tui";
+import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+import type { PtyExecutionHandle } from "../../../core/pty-executor.js";
+import { createHeadlessTerminal, snapshotTerminalLines, type HeadlessTerminal } from "../../../utils/terminal-screen.js";
+import { theme } from "../theme/theme.js";
+
+type ToolOutputMode = "minimal" | "normal";
+
+export class EmbeddedTerminalComponent implements Focusable {
+    public focused = false;
+
+    private command: string;
+    private status: "running" | "complete" | "cancelled" | "error" = "running";
+    private exitCode: number | undefined;
+    private focusKeyLabel: string;
+    private renderedLines: string[] = [];
+    private rawOutput = "";
+    private terminal: HeadlessTerminal;
+    private terminalWriteChain: Promise<void> = Promise.resolve();
+    private handle?: PtyExecutionHandle;
+    private releaseFocus?: () => void;
+    private statusOverride?: string;
+
+    constructor(
+        command: string,
+        _ui: TUI,
+        _renderMode: ToolOutputMode,
+        focusKeyLabel: string,
+        _excludeFromContext = false,
+    ) {
+        this.command = command;
+        this.focusKeyLabel = focusKeyLabel;
+        this.terminal = createHeadlessTerminal();
+    }
+
+    setHandle(handle: PtyExecutionHandle, releaseFocus: () => void): void {
+        this.handle = handle;
+        this.releaseFocus = releaseFocus;
+    }
+
+    setScreenText(text: string): void {
+        this.rawOutput = text;
+        this.renderedLines = text ? text.split("\n") : [];
+    }
+
+    setStatusOverride(text: string | undefined): void {
+        this.statusOverride = text;
+    }
+
+    resize(cols: number, rows: number): void {
+        const safeCols = Math.max(20, cols);
+        const safeRows = Math.max(5, rows);
+        this.handle?.resize(safeCols, safeRows);
+        this.terminal.resize(safeCols, safeRows);
+        this.renderedLines = snapshotTerminalLines(this.terminal);
+    }
+
+    setExpanded(_expanded: boolean): void {
+        // Interactive terminals are always rendered expanded for now.
+    }
+
+    setRenderMode(_mode: ToolOutputMode): void {
+        // Interactive terminals are always rendered expanded for now.
+    }
+
+    appendOutput(chunk: string): void {
+        this.rawOutput += chunk;
+        this.terminalWriteChain = this.terminalWriteChain.then(
+            () =>
+                new Promise<void>((resolve) => {
+                    this.terminal.write(chunk, () => {
+                        this.renderedLines = snapshotTerminalLines(this.terminal);
+                        resolve();
+                    });
+                }),
+        );
+    }
+
+    setComplete(exitCode: number | undefined, cancelled: boolean): void {
+        this.exitCode = exitCode;
+        this.status = cancelled
+            ? "cancelled"
+            : exitCode !== undefined && exitCode !== 0
+                ? "error"
+                : "complete";
+    }
+
+    getOutput(): string {
+        return this.rawOutput;
+    }
+
+    handleInput(data: string): void {
+        if (matchesKey(data, "escape") || matchesKey(data, "tab")) {
+            this.releaseFocus?.();
+            return;
+        }
+
+        const kittyPrintable = decodeKittyPrintable(data);
+        if (kittyPrintable !== undefined) {
+            this.handle?.write(kittyPrintable);
+            return;
+        }
+
+        const key = parseKey(data);
+        switch (key) {
+            case "enter":
+            case "shift+enter":
+                this.handle?.write("\r");
+                return;
+            case "shift+tab":
+            case "tab":
+                this.handle?.write("\t");
+                return;
+            case "backspace":
+            case "shift+backspace":
+                this.handle?.write("\x7f");
+                return;
+            case "up":
+                this.handle?.write("\x1b[A");
+                return;
+            case "down":
+                this.handle?.write("\x1b[B");
+                return;
+            case "right":
+                this.handle?.write("\x1b[C");
+                return;
+            case "left":
+                this.handle?.write("\x1b[D");
+                return;
+            case "ctrl+c":
+                this.handle?.write("\x03");
+                return;
+            case "ctrl+d":
+                this.handle?.write("\x04");
+                return;
+        }
+
+        if (data.length === 1 && data >= " " && data !== "\x7f") {
+            this.handle?.write(data);
+        }
+    }
+
+    invalidate(): void {
+        // No-op; render reads directly from current state.
+    }
+
+    render(width: number): string[] {
+        const innerWidth = Math.max(10, width - 2);
+        const frameColor = this.status === "error"
+            ? "error"
+            : this.focused
+                ? "success"
+                : "success";
+        const border = (text: string) => theme.fg(frameColor, text);
+
+        const lines: string[] = [];
+        lines.push(border(`╭${"─".repeat(innerWidth)}╮`));
+
+        for (const line of this.buildBodyLines(innerWidth)) {
+            const content = truncateToWidth(line, innerWidth, "", true);
+            lines.push(`${border("│")}${content}${border("│")}`);
+        }
+
+        lines.push(border(`╰${"─".repeat(innerWidth)}╯`));
+        return lines;
+    }
+
+    private buildBodyLines(innerWidth: number): string[] {
+        const body: string[] = [];
+        body.push(this.buildHeaderText(innerWidth));
+        body.push("");
+
+        if (this.renderedLines.length > 0) {
+            body.push(...this.renderedLines);
+        } else if (this.status === "running") {
+            body.push(theme.fg("dim", "Terminal waiting for output…"));
+        }
+
+        body.push("");
+        body.push(this.buildStatusText(innerWidth));
+        return body;
+    }
+
+    private buildHeaderText(innerWidth: number): string {
+        const prefix = this.focused
+            ? theme.fg("success", theme.bold(" TERMINAL "))
+            : theme.fg("success", " terminal ");
+        const command = theme.bold(`$ ${this.command}`);
+        const hint = this.focused
+            ? theme.fg("muted", "Tab/Esc return · Shift+Tab sends Tab")
+            : theme.fg("muted", `${this.focusKeyLabel} focus`);
+
+        const left = `${prefix} ${command}`;
+        const leftWidth = visibleWidth(left);
+        const hintWidth = visibleWidth(hint);
+        if (leftWidth + 2 + hintWidth <= innerWidth) {
+            return left + " ".repeat(innerWidth - leftWidth - hintWidth) + hint;
+        }
+        return truncateToWidth(`${left}  ${hint}`, innerWidth, "...");
+    }
+
+    private buildStatusText(innerWidth: number): string {
+        let statusText: string;
+        if (this.status === "running") {
+            statusText = this.statusOverride
+                ? this.statusOverride
+                : this.focused
+                    ? theme.fg("success", theme.bold("INPUT CAPTURED")) + theme.fg("muted", " — typing goes to the terminal")
+                    : theme.fg("muted", `Press ${this.focusKeyLabel} to focus this terminal`);
+        } else if (this.status === "cancelled") {
+            statusText = theme.fg("warning", "(cancelled)");
+        } else if (this.status === "error") {
+            statusText = theme.fg("error", `(exit ${this.exitCode})`);
+        } else {
+            statusText = theme.fg("success", "(done)");
+        }
+        return truncateToWidth(statusText, innerWidth, "...");
+    }
+}

package/packages/pi-coding-agent/src/modes/interactive/components/settings-selector.ts

@@ -35,6 +35,7 @@ export interface SettingsConfig {
 	enableSkillCommands: boolean;
 	codexRotate: boolean;
 	cacheTimer: boolean;
+	pinLastPrompt: boolean;
 	steeringMode: "all" | "one-at-a-time";
 	followUpMode: "all" | "one-at-a-time";
 	transport: Transport;
@@ -58,6 +59,8 @@ export interface SettingsConfig {
 	toolOutputMode: "minimal" | "normal";
 	rtk: boolean;
 	editorScheme: "auto" | "vscode" | "cursor" | "zed" | "jetbrains" | "sublime" | "file";
+	autoDream: boolean;
+	autoMemory: boolean;
 	sandboxEnabled?: boolean;
 	sandboxNetworkMode?: "allow" | "ask" | "deny";
 	classifierModelSubmenu?: (currentValue: string, done: (selectedValue?: string) => void) => Component;
@@ -71,6 +74,8 @@ export interface SettingsCallbacks {
 	onClassifierModelChange: (modelRef: string) => void;
 	onBudgetSubagentModelChange: (modelRef: string) => void;
 	onPlanModeReasoningModelChange: (modelRef: string) => void;
+	onAutoDreamChange: (enabled: boolean) => void;
+	onAutoMemoryChange: (enabled: boolean) => void;
 	onSandboxEnabledChange?: (enabled: boolean) => void;
 	onSandboxNetworkModeChange?: (mode: "allow" | "ask" | "deny") => void;
 	onShowImagesChange: (enabled: boolean) => void;
@@ -79,6 +84,7 @@ export interface SettingsCallbacks {
 	onEnableSkillCommandsChange: (enabled: boolean) => void;
 	onCodexRotateChange: (enabled: boolean) => void;
 	onCacheTimerChange: (enabled: boolean) => void;
+	onPinLastPromptChange: (enabled: boolean) => void;
 	onSteeringModeChange: (mode: "all" | "one-at-a-time") => void;
 	onFollowUpModeChange: (mode: "all" | "one-at-a-time") => void;
 	onTransportChange: (transport: Transport) => void;
@@ -427,6 +433,36 @@ export class SettingsSelectorComponent extends Container {
 			values: ["true", "false"],
 		});
 
+		// Pin last prompt toggle (insert after cache-timer)
+		const cacheTimerIdx = items.findIndex((item) => item.id === "cache-timer");
+		items.splice(cacheTimerIdx + 1, 0, {
+			id: "pin-last-prompt",
+			label: "Pin last prompt",
+			description: "Show your last sent message above the editor so you remember the topic",
+			currentValue: config.pinLastPrompt ? "true" : "false",
+			values: ["true", "false"],
+		});
+
+		// Auto-dream toggle (insert after pin-last-prompt)
+		const pinLastPromptIdx = items.findIndex((item) => item.id === "pin-last-prompt");
+		items.splice(pinLastPromptIdx + 1, 0, {
+			id: "auto-dream",
+			label: "Auto dream",
+			description: "Automatically consolidate and refine memory after sessions",
+			currentValue: config.autoDream ? "true" : "false",
+			values: ["true", "false"],
+		});
+
+		// Auto-memory toggle (insert after auto-dream)
+		const autoDreamIdx = items.findIndex((item) => item.id === "auto-dream");
+		items.splice(autoDreamIdx + 1, 0, {
+			id: "auto-memory",
+			label: "Auto memory",
+			description: "Automatically extract and save memories from session transcripts",
+			currentValue: config.autoMemory ? "true" : "false",
+			values: ["true", "false"],
+		});
+
 		// RTK toggle (insert after cache-timer)
 		const cacheTimerIndex = items.findIndex((item) => item.id === "cache-timer");
 		items.splice(cacheTimerIndex + 1, 0, {
@@ -549,6 +585,15 @@ export class SettingsSelectorComponent extends Container {
 					case "cache-timer":
 						callbacks.onCacheTimerChange(newValue === "true");
 						break;
+					case "pin-last-prompt":
+						callbacks.onPinLastPromptChange(newValue === "true");
+						break;
+					case "auto-dream":
+						callbacks.onAutoDreamChange(newValue === "true");
+						break;
+					case "auto-memory":
+						callbacks.onAutoMemoryChange(newValue === "true");
+						break;
 					case "rtk":
 						callbacks.onRtkChange(newValue === "true");
 						break;

package/packages/pi-coding-agent/src/modes/interactive/components/skill-invocation-message.ts

@@ -44,11 +44,10 @@ export class SkillInvocationMessageComponent extends Box {
 				}),
 			);
 		} else {
-			// Collapsed: single line - [skill] name (hint to expand)
+			// Collapsed: single line - [skill] name
 			const line =
 				theme.fg("customMessageLabel", `\x1b[1m[skill]\x1b[22m `) +
-				theme.fg("customMessageText", this.skillBlock.name) +
-				theme.fg("dim", ` (${editorKey("expandTools")} to expand)`);
+				theme.fg("customMessageText", this.skillBlock.name);
 			this.addChild(new Text(line, 0, 0));
 		}
 	}