@oh-my-pi/pi-tui 18.1.4 → 18.1.6

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [18.1.6] - 2026-09-03
+
+### Fixed
+
+- Fixed the band composer layout so the status line remains visible and no longer causes the prompt to shift unexpectedly when the top border is empty.
+
+## [18.1.5] - 2026-09-03
+
+### Fixed
+
+- Fixed terminal query support in supervised PTY processes, including cursor position reports.
+- Fixed paste-and-submit handling so an Enter keypress received with a bracketed paste is delivered to the previously focused component; `Editor.onLargePaste` now receives `PasteOptions` describing the queued submit.
+
 ## [18.1.3] - 2026-09-02
 
 ### Fixed

package/dist/types/components/editor.d.ts

@@ -57,6 +57,11 @@ export interface EditorTextAssistProvider {
     /** Return replacement candidates for the misspelled word at the cursor. */
     getWordReplacements?(lines: string[], cursorLine: number, cursorCol: number): EditorWordReplacements | null | Promise<EditorWordReplacements | null>;
 }
+/** What the paste transport knew about the input burst before the editor inserts the payload. */
+export interface PasteOptions {
+    /** A submit keypress arrived in the same input burst and will be dispatched right after the paste. */
+    submitAfterPaste?: boolean;
+}
 export declare class Editor implements Component, Focusable {
     #private;
     /** Focusable interface - set by TUI when focus changes */
@@ -89,8 +94,9 @@ export declare class Editor implements Component, Focusable {
      *  the editor inserts nothing and records no undo state, leaving insertion to the host (e.g. a
      *  "wrap in a code block / XML / attach as file" menu for very large pastes), which re-inserts
      *  via {@link insertPaste} or {@link insertText}. Return `false` (or leave unset) for the
-     *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count. */
-    onLargePaste?: (text: string, lineCount: number) => boolean;
+     *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count;
+     *  `options` carries what the paste transport knew about the burst. */
+    onLargePaste?: (text: string, lineCount: number, options: PasteOptions) => boolean;
     onAutocompleteCancel?: () => void;
     disableSubmit: boolean;
     constructor(theme: EditorTheme);
@@ -210,7 +216,7 @@ export declare class Editor implements Component, Focusable {
     /** Drop any volatile preview, then insert `text` as a single undoable edit. */
     commitVolatileText(text: string): void;
     /** Apply terminal paste semantics to text from non-bracketed paste transports. */
-    pasteText(text: string): void;
+    pasteText(text: string, options?: PasteOptions): void;
     /** Insert `content` as a collapsed `[Paste #N]` marker (stored for expansion on submit via
      *  {@link getExpandedText}). Hosts that intercept large pastes through {@link onLargePaste} use
      *  this to re-insert a (possibly transformed) paste without re-triggering the interception hook. */

package/dist/types/components/markdown.d.ts

@@ -12,6 +12,20 @@ export declare let fastTailSplices: number;
 export declare function resetFastTailSplices(): void;
 /** @internal exported for tests — the grown-line-start block-kind gate. */
 export declare function fastLineStartHazard(grownLine: string): boolean;
+/** A hyperlink as the renderer sees it: inline `[text](href)`, `<autolink>`, bare GFM URL, or reference link. */
+export interface MarkdownLink {
+    /** Visible link text (equals `href` for autolinks and bare URLs). */
+    text: string;
+    /** Destination exactly as marked resolved it (references resolved, no normalization). */
+    href: string;
+}
+/**
+ * Every link token in `text`, in document order, from the same configured
+ * lexer the renderer uses — so fenced code, code spans, escapes, reference
+ * definitions and the GFM autolink rules agree with what is drawn on screen.
+ * Duplicate hrefs are kept; callers decide how to fold them.
+ */
+export declare function extractMarkdownLinks(text: string): MarkdownLink[];
 /** Drop all L2 cache entries. Call on theme change to prevent stale styled output. */
 export declare function clearRenderCache(): void;
 /**

package/dist/types/stdin-buffer.d.ts

@@ -43,7 +43,12 @@ export type StdinBufferOptions = {
 };
 export type StdinBufferEventMap = {
     data: [string];
-    paste: [string];
+    /**
+     * A completed bracketed paste. `enter` carries an Enter keypress that shared
+     * the paste's stdin read, so the terminal can dispatch paste and submit to
+     * the same focused component before a paste-triggered overlay can take focus.
+     */
+    paste: [content: string, enter?: string];
 };
 /**
  * Buffers stdin input and emits complete sequences via the 'data' event.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-tui",
-	"version": "18.1.4",
+	"version": "18.1.6",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"homepage": "https://omp.sh",
 	"author": "Stencil Labs, Inc.",
@@ -37,8 +37,8 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.1.4",
-		"@oh-my-pi/pi-utils": "18.1.4"
+		"@oh-my-pi/pi-natives": "18.1.6",
+		"@oh-my-pi/pi-utils": "18.1.6"
 	},
 	"devDependencies": {
 		"kitty-vt-wasm": "^0.2.0"

package/src/components/composer/band.ts

@@ -24,9 +24,13 @@ export const bandComposerStyle: ComposerStyle = {
 		return 0;
 	},
 
-	renderTop(ctx: ComposerChromeContext): string | undefined {
+	renderTop(ctx: ComposerChromeContext): string {
 		const { topBorder, width } = ctx;
-		if (!topBorder?.content) return undefined;
+		// The band always owns one chrome row (`verticalChrome: 1`): keep it
+		// reserved while the status line has nothing to show yet — the startup
+		// prepaint mounts the editor before the session-aware status line
+		// attaches — so the band fills in later without shifting the layout.
+		if (!topBorder?.content) return "";
 		// The band builder already sizes its groups + gauge to the full width;
 		// truncation only guards against a stale provider during resize.
 		return topBorder.width > width ? truncateToWidth(topBorder.content, width) : topBorder.content;

package/src/components/editor.ts

@@ -467,6 +467,12 @@ export interface EditorTextAssistProvider {
 type HistoryCursorAnchor = "start" | "end";
 type AutocompleteRequest = { kind: "regular"; explicitTab: boolean } | { kind: "force" };
 
+/** What the paste transport knew about the input burst before the editor inserts the payload. */
+export interface PasteOptions {
+	/** A submit keypress arrived in the same input burst and will be dispatched right after the paste. */
+	submitAfterPaste?: boolean;
+}
+
 export class Editor implements Component, Focusable {
 	#state: EditorState = {
 		lines: [""],
@@ -581,8 +587,9 @@ export class Editor implements Component, Focusable {
 	 *  the editor inserts nothing and records no undo state, leaving insertion to the host (e.g. a
 	 *  "wrap in a code block / XML / attach as file" menu for very large pastes), which re-inserts
 	 *  via {@link insertPaste} or {@link insertText}. Return `false` (or leave unset) for the
-	 *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count. */
-	onLargePaste?: (text: string, lineCount: number) => boolean;
+	 *  default collapse-to-marker behavior. `lineCount` is the sanitized paste's line count;
+	 *  `options` carries what the paste transport knew about the burst. */
+	onLargePaste?: (text: string, lineCount: number, options: PasteOptions) => boolean;
 	onAutocompleteCancel?: () => void;
 	disableSubmit: boolean = false;
 
@@ -2148,8 +2155,8 @@ export class Editor implements Component, Focusable {
 	}
 
 	/** Apply terminal paste semantics to text from non-bracketed paste transports. */
-	pasteText(text: string): void {
-		this.#handlePaste(text);
+	pasteText(text: string, options: PasteOptions = {}): void {
+		this.#handlePaste(text, options);
 	}
 
 	/** Insert `content` as a collapsed `[Paste #N]` marker (stored for expansion on submit via
@@ -2289,7 +2296,7 @@ export class Editor implements Component, Focusable {
 		}
 	}
 
-	#handlePaste(pastedText: string): void {
+	#handlePaste(pastedText: string, options: PasteOptions = {}): void {
 		let filteredText = this.#sanitizePastedText(pastedText);
 
 		// If pasting a file path (starts with /, ~, or .) and the character before
@@ -2311,7 +2318,7 @@ export class Editor implements Component, Focusable {
 		// Let the host intercept marker-sized pastes (e.g. the large-paste menu). When it takes
 		// over, the editor inserts nothing and records no undo state — the host re-inserts via
 		// `insertPaste`/`insertText` once the user chooses.
-		if (isMarkerSized && this.onLargePaste?.(filteredText, pastedLines.length)) {
+		if (isMarkerSized && this.onLargePaste?.(filteredText, pastedLines.length, options)) {
 			return;
 		}
 

package/src/components/markdown.ts

@@ -1254,6 +1254,52 @@ function lexDocument(text: string): Token[] {
 	return lexWindowed(text);
 }
 
+/** A hyperlink as the renderer sees it: inline `[text](href)`, `<autolink>`, bare GFM URL, or reference link. */
+export interface MarkdownLink {
+	/** Visible link text (equals `href` for autolinks and bare URLs). */
+	text: string;
+	/** Destination exactly as marked resolved it (references resolved, no normalization). */
+	href: string;
+}
+
+/**
+ * Every link token in `text`, in document order, from the same configured
+ * lexer the renderer uses — so fenced code, code spans, escapes, reference
+ * definitions and the GFM autolink rules agree with what is drawn on screen.
+ * Duplicate hrefs are kept; callers decide how to fold them.
+ */
+export function extractMarkdownLinks(text: string): MarkdownLink[] {
+	const links: MarkdownLink[] = [];
+	const walk = (tokens: readonly Token[] | undefined): void => {
+		if (!tokens) return;
+		for (const token of tokens) {
+			if (token.type === "link") {
+				const link = token as Tokens.Link;
+				if (typeof link.href === "string" && link.href.length > 0) {
+					links.push({
+						text: typeof link.text === "string" && link.text.length > 0 ? link.text : link.href,
+						href: link.href,
+					});
+				}
+				continue;
+			}
+			// Containers: paragraphs, emphasis, lists, blockquotes, table cells.
+			const any = token as {
+				tokens?: Token[];
+				items?: Token[];
+				header?: Array<{ tokens?: Token[] }>;
+				rows?: Array<Array<{ tokens?: Token[] }>>;
+			};
+			walk(any.tokens);
+			walk(any.items);
+			if (any.header) for (const cell of any.header) walk(cell.tokens);
+			if (any.rows) for (const row of any.rows) for (const cell of row) walk(cell.tokens);
+		}
+	};
+	walk(lexDocument(text));
+	return links;
+}
+
 /** Drop all L2 cache entries. Call on theme change to prevent stale styled output. */
 export function clearRenderCache(): void {
 	renderCache.clear();

package/src/stdin-buffer.ts

@@ -375,9 +375,27 @@ export type StdinBufferOptions = {
 	pasteByteLimit?: number;
 };
 
+const KITTY_ENTER = /^\x1b\[13(?:;1)?u/u;
+
+/**
+ * The Enter keypress that immediately follows a bracketed-paste end marker in
+ * the same stdin read: legacy CR/LF, or the kitty CSI-u encoding with no
+ * modifier. Nothing else qualifies — any other trailing byte takes the normal
+ * data route.
+ */
+function leadingEnter(input: string): string | undefined {
+	if (input.startsWith("\r") || input.startsWith("\n")) return input[0];
+	return KITTY_ENTER.exec(input)?.[0];
+}
+
 export type StdinBufferEventMap = {
 	data: [string];
-	paste: [string];
+	/**
+	 * A completed bracketed paste. `enter` carries an Enter keypress that shared
+	 * the paste's stdin read, so the terminal can dispatch paste and submit to
+	 * the same focused component before a paste-triggered overlay can take focus.
+	 */
+	paste: [content: string, enter?: string];
 };
 
 /**
@@ -577,10 +595,15 @@ export class StdinBuffer extends EventEmitter<StdinBufferEventMap> {
 		this.#pasteBytes = 0;
 		this.#pendingKittyPrintableCodepoint = undefined;
 
-		this.emit("paste", pastedContent);
+		// A paste-and-Enter burst (automation, terminals that batch reads) must
+		// not split into two dispatches: the paste may open an overlay that
+		// would then swallow the Enter meant to submit it.
+		const enter = leadingEnter(remaining);
+		this.emit("paste", pastedContent, enter);
 
-		if (remaining.length > 0) {
-			this.process(remaining);
+		const rest = enter === undefined ? remaining : remaining.slice(enter.length);
+		if (rest.length > 0) {
+			this.process(rest);
 		}
 	}
 

package/src/terminal.ts

@@ -1359,10 +1359,13 @@ export class ProcessTerminal implements Terminal {
 			}
 		});
 
-		// Re-wrap paste content with bracketed paste markers for existing editor handling
-		this.#stdinBuffer.on("paste", (content: string) => {
+		// Re-wrap paste content with bracketed paste markers for existing editor
+		// handling. An Enter that shared the paste's stdin read rides along so
+		// paste and submit reach the component focused right now, not one the
+		// paste itself is about to open.
+		this.#stdinBuffer.on("paste", (content: string, enter?: string) => {
 			if (this.#inputHandler) {
-				this.#inputHandler(`\x1b[200~${content}\x1b[201~`);
+				this.#inputHandler(`\x1b[200~${content}\x1b[201~${enter ?? ""}`);
 			}
 		});