@oh-my-pi/pi-tui 18.2.4 → 18.2.6

package/src/overlays/plan-save-overlay.ts

@@ -0,0 +1,74 @@
+import { type Component, CURSOR_MARKER, type Focusable, Input, truncateToWidth, visibleWidth } from "../index";
+import { theme } from "../theme/theme";
+import { OverlayPanel, PanelRows } from "../chrome/overlay-box";
+
+/** A confirmed destination chosen from {@link PlanSaveOverlay}. */
+export interface PlanSaveOverlayResult {
+	path: string;
+}
+
+/** Collects a destination path before saving a plan and starting a new session. */
+export class PlanSaveOverlay implements Component, Focusable {
+	#input = new Input();
+	#suggestedPath: string;
+	#done: (result: PlanSaveOverlayResult | undefined) => void;
+	#focused = false;
+	readonly #panel: OverlayPanel;
+	readonly #body: PanelRows;
+
+	constructor(suggestedPath: string, done: (result: PlanSaveOverlayResult | undefined) => void) {
+		this.#suggestedPath = suggestedPath;
+		this.#done = done;
+		this.#input.prompt = theme.fg("dim", "Path: ");
+		this.#input.onSubmit = value => this.#done({ path: value.trim() || this.#suggestedPath });
+		this.#input.onEscape = () => this.#done(undefined);
+		this.#panel = new OverlayPanel("Save and quit");
+		this.#body = new PanelRows();
+		this.#body.setHeight(2);
+		this.#panel.addChild(this.#body);
+	}
+
+	get focused(): boolean {
+		return this.#focused;
+	}
+
+	set focused(value: boolean) {
+		this.#focused = value;
+	}
+
+	/** Replaces the dimmed path accepted when the operator submits an empty input. */
+	setSuggestedPath(path: string): void {
+		this.#suggestedPath = path;
+	}
+
+	handleInput(data: string): void {
+		this.#input.handleInput(data);
+	}
+
+	/** Routes enhanced clipboard pastes into the path input. */
+	pasteText(text: string): void {
+		this.#input.pasteText(text);
+	}
+
+	invalidate(): void {
+		this.#input.invalidate();
+		this.#panel.invalidate();
+	}
+
+	render(width: number): readonly string[] {
+		const innerWidth = Math.max(0, width - 4);
+		this.#input.focused = this.#focused;
+		this.#body.setLines([this.#renderInput(innerWidth), theme.fg("dim", "Enter save and quit · Esc cancel")]);
+		return this.#panel.render(width);
+	}
+
+	#renderInput(width: number): string {
+		if (this.#input.getValue().length > 0) return this.#input.render(width)[0] ?? "";
+		const prompt = this.#input.prompt;
+		const available = width - visibleWidth(prompt);
+		if (available <= 0) return prompt;
+		const marker = this.#focused ? CURSOR_MARKER : "";
+		const suggested = truncateToWidth(this.#suggestedPath, Math.max(0, available - 1));
+		return `${prompt}${marker}\x1b[7m \x1b[27m${theme.fg("dim", suggested)}`;
+	}
+}

package/src/overlays/plan-toc.ts

@@ -0,0 +1,139 @@
+/**
+ * Pure heading/section parser for the plan-review overlay. It splits a plan's
+ * markdown into a flat list of sections — a leading preamble (text before the
+ * first heading) followed by one entry per ATX heading — preserving the exact
+ * source bytes of each section so the overlay can render, reorder-free delete,
+ * and round-trip the document without a full markdown re-render.
+ *
+ * No TUI dependencies: this module is unit-tested in isolation.
+ */
+
+/** ATX heading: 1-6 `#`, required whitespace, a title, optional closing `#`s. */
+const HEADING_RE = /^(#{1,6})[ \t]+(.+?)[ \t]*#*[ \t]*$/;
+/** Opening/closing code fence run (``` or ~~~), allowing up to 3 lead spaces. */
+const FENCE_RE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+
+export interface PlanSection {
+	/** `0` = preamble (no heading, no ToC entry); `1..6` = heading depth. */
+	level: number;
+	/** Plain-text heading label with inline markdown lightly stripped. */
+	title: string;
+	/** Exact source slice for this section, including its trailing newline(s). */
+	raw: string;
+}
+
+/**
+ * Collapse inline markdown emphasis/link/code syntax to readable text. This is
+ * a deliberately light strip (not a full markdown render) just so ToC entries
+ * read cleanly — `**Goal** & [docs](x)` becomes `Goal & docs`.
+ */
+export function stripInlineMarkdown(text: string): string {
+	let out = text;
+	// Images first (so the link pass below does not eat the `(url)`), then links.
+	out = out.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1");
+	out = out.replace(/\[([^\]]*)\]\([^)]*\)/g, "$1");
+	out = out.replace(/\[([^\]]*)\]\[[^\]]*\]/g, "$1");
+	// Autolinks `<https://…>` keep their URL as the readable text.
+	out = out.replace(/<([^>\s]+)>/g, "$1");
+	// Inline code, then bold/italic/strikethrough emphasis runs.
+	out = out.replace(/`([^`]+)`/g, "$1");
+	out = out.replace(/(\*\*|__)(.+?)\1/g, "$2");
+	out = out.replace(/(\*|_)(.+?)\1/g, "$2");
+	out = out.replace(/~~(.+?)~~/g, "$1");
+	return out.replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Split `text` into preamble + heading sections. `#` characters inside fenced
+ * code blocks are never treated as headings. Concatenating every section's
+ * `raw` reproduces the original text exactly.
+ */
+export function parsePlanSections(text: string): PlanSection[] {
+	const lines = text.split("\n");
+	// Character offset of each line start so section `raw` can slice the source.
+	// oxlint-disable-next-line unicorn/no-new-array -- length preallocation
+	const offsets: number[] = new Array(lines.length);
+	let cursor = 0;
+	for (let i = 0; i < lines.length; i++) {
+		offsets[i] = cursor;
+		cursor += lines[i]!.length + 1; // +1 for the "\n" join separator
+	}
+
+	// Heading line indices (start of each heading section), with metadata.
+	const heads: { line: number; level: number; title: string }[] = [];
+	let fenceChar: string | null = null;
+	let fenceLen = 0;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]!;
+		const fence = FENCE_RE.exec(line);
+		if (fenceChar === null) {
+			if (fence) {
+				fenceChar = fence[1]![0]!;
+				fenceLen = fence[1]!.length;
+			}
+			// Opening-fence lines are body, not headings.
+			if (fence) continue;
+		} else {
+			// Inside a fence: only a matching-or-longer run of the same char closes.
+			if (fence && fence[1]![0] === fenceChar && fence[1]!.length >= fenceLen && fence[2]!.trim() === "") {
+				fenceChar = null;
+				fenceLen = 0;
+			}
+			continue;
+		}
+		const heading = HEADING_RE.exec(line);
+		if (heading) {
+			heads.push({ line: i, level: heading[1]!.length, title: stripInlineMarkdown(heading[2]!) });
+		}
+	}
+
+	const sections: PlanSection[] = [];
+	const sliceRaw = (startLine: number, endLine: number): string => {
+		const startOffset = offsets[startLine]!;
+		const endOffset = endLine < lines.length ? offsets[endLine]! : text.length;
+		return text.slice(startOffset, endOffset);
+	};
+
+	// Preamble: everything before the first heading (only when non-empty).
+	const firstHeadLine = heads.length > 0 ? heads[0]!.line : lines.length;
+	if (firstHeadLine > 0) {
+		const raw = sliceRaw(0, firstHeadLine);
+		if (raw.length > 0) sections.push({ level: 0, title: "", raw });
+	}
+
+	for (let h = 0; h < heads.length; h++) {
+		const head = heads[h]!;
+		const endLine = h + 1 < heads.length ? heads[h + 1]!.line : lines.length;
+		sections.push({ level: head.level, title: head.title, raw: sliceRaw(head.line, endLine) });
+	}
+
+	return sections;
+}
+
+/**
+ * Concatenate every section's `raw` back into a single document and guarantee a
+ * single trailing newline. Inverse of {@link parsePlanSections} for any input
+ * that already ends with a newline.
+ */
+export function joinPlanSections(sections: readonly PlanSection[]): string {
+	let joined = "";
+	for (const section of sections) joined += section.raw;
+	if (joined.length === 0) return "";
+	return joined.endsWith("\n") ? joined : `${joined}\n`;
+}
+
+/**
+ * Indices to remove when deleting `sections[index]`: the heading itself plus
+ * every following section nested deeper than it (its sub-headings). The
+ * preamble (level 0) is never a deletion target and yields an empty span.
+ */
+export function sectionDeletionSpan(sections: readonly PlanSection[], index: number): number[] {
+	const target = sections[index];
+	if (!target || target.level === 0) return [];
+	const span = [index];
+	for (let j = index + 1; j < sections.length; j++) {
+		if (sections[j]!.level > target.level) span.push(j);
+		else break;
+	}
+	return span;
+}

package/src/overlays/plugin-selector.ts

@@ -0,0 +1,97 @@
+/**
+ * Interactive marketplace plugin selector.
+ *
+ * Shows available plugins from all configured marketplaces in a SelectList.
+ * Selecting a plugin triggers installation. Esc cancels.
+ */
+import { type SelectItem, SelectList, type SgrMouseEvent } from "../index";
+import { getSelectListTheme } from "../theme/theme";
+import { OverlayPanel } from "../chrome/overlay-box";
+import { routeSelectListMouseWithTopBorder } from "../chrome/select-list-mouse-routing";
+
+export interface PluginSelectorCallbacks {
+	onSelect: (pluginName: string, marketplace: string, scope?: "user" | "project") => void;
+	onCancel: () => void;
+}
+
+export interface PluginItem {
+	plugin: { name: string; version?: string; description?: string };
+	marketplace: string;
+	/** Scope of this entry. When set, appended to the label and forwarded to onSelect. */
+	scope?: "user" | "project";
+}
+
+export class PluginSelectorComponent extends OverlayPanel {
+	#selectList: SelectList;
+
+	constructor(
+		marketplaceCount: number,
+		plugins: PluginItem[],
+		installedIds: Set<string>,
+		callbacks: PluginSelectorCallbacks,
+	) {
+		super("Plugins");
+
+		const items: SelectItem[] = plugins.map(({ plugin, marketplace, scope }) => {
+			// Encode scope into the value so onSelect can recover it without a parallel Map.
+			// Format: "name@marketplace" or "name@marketplace#scope"
+			const id = scope ? `${plugin.name}@${marketplace}#${scope}` : `${plugin.name}@${marketplace}`;
+			const installed = installedIds.has(`${plugin.name}@${marketplace}`);
+			const version = plugin.version ? `@${plugin.version}` : "";
+			const status = installed ? " [installed]" : "";
+			const scopeTag = scope ? ` [${scope}]` : "";
+
+			return {
+				value: id,
+				label: `${plugin.name}${version}${status}${scopeTag}`,
+				description: plugin.description,
+				hint: marketplace,
+			};
+		});
+
+		if (items.length === 0) {
+			items.push({
+				value: "__empty__",
+				label: "No plugins available",
+				description:
+					marketplaceCount === 0
+						? "Add a marketplace first: /marketplace add <source>"
+						: "Configured marketplaces have no plugins",
+				disabled: true,
+			});
+		}
+
+		this.#selectList = new SelectList(items, Math.min(items.length, 20), getSelectListTheme());
+
+		this.#selectList.onSelect = item => {
+			const [name, marketplace, scope] = splitPluginId(item.value);
+			if (name && marketplace) {
+				callbacks.onSelect(name, marketplace, scope);
+			}
+		};
+
+		this.#selectList.onCancel = () => {
+			callbacks.onCancel();
+		};
+
+		this.addChild(this.#selectList);
+	}
+
+	getSelectList(): SelectList {
+		return this.#selectList;
+	}
+
+	routeMouse(event: SgrMouseEvent, line: number, col: number): void {
+		routeSelectListMouseWithTopBorder(this.#selectList, event, line, col);
+	}
+}
+
+function splitPluginId(id: string): [string, string, "user" | "project" | undefined] | [null, null, null] {
+	// value format: "name@marketplace" or "name@marketplace#scope"
+	const hashIdx = id.indexOf("#");
+	const base = hashIdx >= 0 ? id.slice(0, hashIdx) : id;
+	const scope = hashIdx >= 0 ? (id.slice(hashIdx + 1) as "user" | "project") : undefined;
+	const atIdx = base.lastIndexOf("@");
+	if (atIdx <= 0) return [null, null, null];
+	return [base.slice(0, atIdx), base.slice(atIdx + 1), scope];
+}