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

package/src/prompt/image-references.ts

@@ -0,0 +1,102 @@
+import type { ImageContent } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
+import { blobExtensionForImageMimeType } from "./image-format";
+
+/** Materialized image destination returned by the host blob writer. */
+interface ImageBlobResult {
+	displayPath: string;
+}
+import { fileHyperlink } from "../render/hyperlink";
+
+/** Probed pixel dimensions riding on the draft image object itself; `null` records a failed
+ *  probe so the chips band never re-decodes a corrupt header every frame. */
+const kImageDims = Symbol("omp.imageDimensions");
+
+interface ImageContentWithDims extends ImageContent {
+	[kImageDims]?: { width: number; height: number } | null;
+}
+
+/** Cached probe result for a draft image: dimensions, `null` (probe failed), or `undefined`
+ *  (never probed). */
+export function cachedImageDimensions(image: ImageContent): { width: number; height: number } | null | undefined {
+	return (image as ImageContentWithDims)[kImageDims];
+}
+
+/** Record a probe result for a draft image (see {@link cachedImageDimensions}). */
+export function setCachedImageDimensions(image: ImageContent, dims: { width: number; height: number } | null): void {
+	(image as ImageContentWithDims)[kImageDims] = dims;
+}
+
+type ImageBlobWriter = (data: Buffer, options?: { extension?: string }) => Promise<ImageBlobResult>;
+type ImageBlobWriterSync = (data: Buffer, options?: { extension?: string }) => ImageBlobResult;
+
+export function imageReferenceHyperlink(
+	label: string,
+	index: number,
+	imageLinks: readonly (string | undefined)[] | undefined,
+	renderLabel: (text: string) => string,
+): string {
+	const rendered = renderLabel(label);
+	const target = imageLinks?.[index - 1];
+	return target ? fileHyperlink(target, rendered) : rendered;
+}
+
+async function materializeImageReferenceLinkAsync(
+	image: ImageContent,
+	index: number,
+	putBlob: ImageBlobWriter,
+): Promise<string | undefined> {
+	try {
+		const result = await putBlob(Buffer.from(image.data, "base64"), {
+			extension: blobExtensionForImageMimeType(image.mimeType),
+		});
+		return result.displayPath;
+	} catch (error) {
+		logger.warn("Failed to write image reference blob", {
+			index,
+			mimeType: image.mimeType,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return undefined;
+	}
+}
+
+function materializeImageReferenceLink(
+	image: ImageContent,
+	index: number,
+	putBlob: ImageBlobWriterSync,
+): string | undefined {
+	try {
+		const result = putBlob(Buffer.from(image.data, "base64"), {
+			extension: blobExtensionForImageMimeType(image.mimeType),
+		});
+		return result.displayPath;
+	} catch (error) {
+		logger.warn("Failed to write image reference blob", {
+			index,
+			mimeType: image.mimeType,
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return undefined;
+	}
+}
+
+export async function materializeImageReferenceLinks(
+	images: readonly ImageContent[] | undefined,
+	putBlob: ImageBlobWriter,
+): Promise<(string | undefined)[] | undefined> {
+	if (!images || images.length === 0) return undefined;
+	const links = await Promise.all(
+		images.map((image, index) => materializeImageReferenceLinkAsync(image, index + 1, putBlob)),
+	);
+	return links.some(link => link !== undefined) ? links : undefined;
+}
+
+export function materializeImageReferenceLinksSync(
+	images: readonly ImageContent[] | undefined,
+	putBlob: ImageBlobWriterSync,
+): (string | undefined)[] | undefined {
+	if (!images || images.length === 0) return undefined;
+	const links = images.map((image, index) => materializeImageReferenceLink(image, index + 1, putBlob));
+	return links.some(link => link !== undefined) ? links : undefined;
+}

package/src/prompt/interactive-context-helpers.ts

@@ -0,0 +1,126 @@
+/** Shared assistant transcript construction and model-authored link caching. */
+import type { AssistantMessage, Model } from "@oh-my-pi/pi-ai";
+import { getMarkdownLinkUrls } from "../index";
+import { EMPTY_LINK_TARGETS } from "../render/render-utils";
+import type { ImageBudget } from "../components/image";
+import type { AssistantThinkingRenderer } from "../chat/extension-types";
+import { AssistantMessageComponent } from "../chat/assistant-message";
+/** Session display capabilities supplied unchanged by the interactive host. */
+export interface AssistantMessageSession {
+	readonly model?: Model;
+	readonly extensionRunner?: { getAssistantThinkingRenderers(): readonly AssistantThinkingRenderer[] };
+}
+
+/** Host state required to construct and refresh assistant transcript segments. */
+export interface AssistantMessageHost {
+	readonly viewSession: AssistantMessageSession;
+	readonly effectiveHideThinkingBlock: boolean;
+	readonly proseOnlyThinking: boolean;
+	readonly assistantImagesVisible: boolean;
+	readonly hideToolActivity: boolean;
+	readonly toolOutputExpanded: boolean;
+	readonly ui: { requestRender(): void; readonly imageBudget: ImageBudget };
+	resolveAssistantMessageLinks(texts: readonly string[]): Promise<ReadonlyMap<string, string>>;
+}
+
+const kMarkdownLinkTargets = Symbol("markdownLinkTargets");
+type SessionWithMarkdownLinkTargets = AssistantMessageSession & {
+	[kMarkdownLinkTargets]?: ReadonlyMap<string, string>;
+};
+
+function assistantTextBlocks(messages: readonly AssistantMessage[]): string[] {
+	const texts: string[] = [];
+	for (const message of messages) {
+		for (const content of message.content) {
+			if (content.type === "text") texts.push(content.text);
+		}
+	}
+	return texts;
+}
+
+/**
+ * Resolve and cache the current session's model-authored prose links. Existing
+ * entries remain available to synchronous transcript rebuilds; links present in
+ * this batch are replaced atomically so missing resources cannot retain a stale
+ * destination.
+ */
+export async function refreshAssistantMessageLinkTargets(
+	ctx: AssistantMessageHost,
+	messages: readonly AssistantMessage[],
+): Promise<ReadonlyMap<string, string>> {
+	const session: SessionWithMarkdownLinkTargets = ctx.viewSession;
+	const previous = session[kMarkdownLinkTargets] ?? EMPTY_LINK_TARGETS;
+	const texts = assistantTextBlocks(messages);
+	const hrefs = new Set<string>();
+	for (const text of texts) {
+		for (const href of getMarkdownLinkUrls(text)) hrefs.add(href);
+	}
+	if (hrefs.size === 0) return previous;
+	const resolved = await ctx.resolveAssistantMessageLinks(texts);
+	let changed = false;
+	for (const href of hrefs) {
+		if (previous.get(href) !== resolved.get(href)) {
+			changed = true;
+			break;
+		}
+	}
+	if (!changed) return previous;
+	const next = new Map(previous);
+	for (const href of hrefs) next.delete(href);
+	for (const [href, target] of resolved) next.set(href, target);
+	session[kMarkdownLinkTargets] = next;
+	return next;
+}
+
+/** Current resolved destinations for synchronous component construction. */
+export function getAssistantMessageLinkTargets(ctx: AssistantMessageHost): ReadonlyMap<string, string> {
+	const session: SessionWithMarkdownLinkTargets = ctx.viewSession;
+	return session[kMarkdownLinkTargets] ?? EMPTY_LINK_TARGETS;
+}
+
+/** Limit a session snapshot to destinations authored by one rendered segment. */
+export function assistantMessageLinkTargets(
+	message: AssistantMessage,
+	targets: ReadonlyMap<string, string>,
+): ReadonlyMap<string, string> {
+	const selected = new Map<string, string>();
+	for (const content of message.content) {
+		if (content.type !== "text") continue;
+		for (const href of getMarkdownLinkUrls(content.text)) {
+			const target = targets.get(href);
+			if (target) selected.set(href, target);
+		}
+	}
+	return selected;
+}
+
+/**
+ * Construct an {@link AssistantMessageComponent} wired to the live context's
+ * thinking/image settings. `message` is omitted for the streaming placeholder
+ * component and supplied when rendering a persisted turn.
+ */
+export function createAssistantMessageComponent(
+	ctx: AssistantMessageHost,
+	message?: AssistantMessage,
+	linkTargets: ReadonlyMap<string, string> = getAssistantMessageLinkTargets(ctx),
+): AssistantMessageComponent {
+	const component = new AssistantMessageComponent(
+		message,
+		ctx.effectiveHideThinkingBlock,
+		() => ctx.ui.requestRender(),
+		ctx.viewSession.extensionRunner?.getAssistantThinkingRenderers(),
+		ctx.ui.imageBudget,
+		ctx.proseOnlyThinking,
+		linkTargets,
+	);
+	component.setImagesVisible(ctx.assistantImagesVisible);
+	component.setToolResultImagesVisible(!ctx.hideToolActivity);
+	component.setExpanded(ctx.toolOutputExpanded);
+	// A wire the `stream-revision` axis marks `possible` can rewrite text it has
+	// already streamed; published rows are unrecoverable once they reach native
+	// scrollback, so those wires keep finished lines in the live viewport.
+	const compat = ctx.viewSession.model?.compat;
+	const wireRevisable = compat !== undefined && "streamRevision" in compat && compat.streamRevision === "possible";
+	component.setMidStreamPublication(!wireRevisable);
+	return component;
+}

package/src/prompt/internal-url-autocomplete.ts

@@ -0,0 +1,155 @@
+/**
+ * Autocomplete for internal-url schemes (skill://, rule://, omp://, local://,
+ * memory://, agent://, artifact://) while composing a prompt.
+ *
+ * Detection here MUST stay in sync with the generic URL-scheme trigger in the
+ * TUI editor (`packages/tui/src/components/editor.ts`); the editor fires the
+ * popup, this module decides whether there are candidates to show.
+ */
+import { subsequenceMatch, subsequenceScore } from "../autocomplete";
+import type { AutocompleteItem } from "../index";
+/** Lazy runtime capabilities supplied by the internal URL host. */
+export interface InternalUrlCompletionHost {
+	completionSchemes(): string[];
+	resolveCompletions(
+		scheme: string,
+		query: string,
+		context: InternalUrlCallerContext & { signal?: AbortSignal },
+	): Promise<readonly { value: string; label?: string; description?: string }[] | null | undefined>;
+}
+
+let completionHost: InternalUrlCompletionHost | undefined;
+
+/** Install the runtime URL completion capabilities. */
+export function setInternalUrlCompletionHost(host: InternalUrlCompletionHost): void {
+	completionHost = host;
+}
+
+/** Upper bound on candidates surfaced in the dropdown. */
+const MAX_URL_SUGGESTIONS = 25;
+
+/**
+ * A URL token ending at the cursor: a known internal scheme followed by one or
+ * two slashes and the partially typed host/path. The boundary/rest character
+ * classes mirror the editor trigger so both agree on what counts as a token.
+ */
+const URL_TOKEN_RE = /(?:^|[\s"'`(<=])([a-z][a-z0-9+.-]*:\/{1,2}[^\s"'`()<>]*)$/i;
+const SCHEME_SPLIT_RE = /^([a-z][a-z0-9+.-]*):\/{1,2}(.*)$/i;
+
+export interface InternalUrlContext {
+	/** Lowercased scheme (e.g. `local`). */
+	scheme: string;
+	/** Text typed after the slashes so far (host + path); may be empty. */
+	query: string;
+	/** Exact buffer token from its boundary to the cursor (the completion prefix). */
+	token: string;
+}
+
+/** Decode a completion `value` for fuzzy matching (the inserted value may be
+ * percent-encoded, e.g. an ssh host `alice%40prod`); identity for plain values. */
+function decodeUrlCompletionValue(value: string): string {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+
+/**
+ * Detect a completable internal-url token immediately before the cursor.
+ * Returns `null` when the text is not a `scheme://` token whose scheme is
+ * registered with a completion-capable handler.
+ */
+export function extractInternalUrlContext(textBeforeCursor: string): InternalUrlContext | null {
+	const tokenMatch = URL_TOKEN_RE.exec(textBeforeCursor);
+	if (!tokenMatch) return null;
+	const token = tokenMatch[1]!;
+	const parts = SCHEME_SPLIT_RE.exec(token);
+	if (!parts) return null;
+	const scheme = parts[1]!.toLowerCase();
+	if (!completionHost?.completionSchemes().includes(scheme)) return null;
+	return { scheme, query: parts[2] ?? "", token };
+}
+
+/** Caller binding shared by tool execution and prompt completion. */
+export interface InternalUrlCallerContext {
+	cwd?: string;
+	sessionFile?: string;
+	sessionId?: string;
+}
+
+/**
+ * Suggestions for the internal-url token ending at the cursor, or `null` when
+ * the text is not such a token or no candidate matches the typed query.
+ * The optional lazy caller binding overrides cwd and is read only after
+ * recognizing an internal-URL token.
+ */
+export async function getInternalUrlSuggestions(
+	textBeforeCursor: string,
+	cwd?: string,
+	signal?: AbortSignal,
+	getCaller?: () => InternalUrlCallerContext,
+): Promise<{ items: AutocompleteItem[]; prefix: string } | null> {
+	if (signal?.aborted) return null;
+	const ctx = extractInternalUrlContext(textBeforeCursor);
+	if (!ctx) return null;
+
+	const candidates = await completionHost?.resolveCompletions(ctx.scheme, ctx.query, {
+		...(cwd === undefined ? {} : { cwd }),
+		...getCaller?.(),
+		...(signal ? { signal } : {}),
+	});
+	if (!candidates || candidates.length === 0) return null;
+
+	const query = ctx.query.toLowerCase();
+	const scored: Array<{ item: AutocompleteItem; score: number }> = [];
+	for (const candidate of candidates) {
+		const target = decodeUrlCompletionValue(candidate.value).toLowerCase();
+		if (!subsequenceMatch(query, target)) continue;
+		scored.push({
+			item: {
+				value: `${ctx.scheme}://${candidate.value}`,
+				label: candidate.label ?? candidate.value,
+				...(candidate.description ? { description: candidate.description } : {}),
+			},
+			score: subsequenceScore(query, target),
+		});
+	}
+	if (scored.length === 0) return null;
+
+	scored.sort((a, b) => b.score - a.score);
+	return {
+		items: scored.slice(0, MAX_URL_SUGGESTIONS).map(entry => entry.item),
+		prefix: ctx.token,
+	};
+}
+
+/** Whether `prefix` (the token a completion was offered for) is an internal-url token. */
+export function isInternalUrlPrefix(prefix: string): boolean {
+	return extractInternalUrlContext(prefix) !== null;
+}
+
+/**
+ * Replace the internal-url token with the selected candidate, appending a
+ * trailing space (matching `@` file-reference behavior) so the user can keep
+ * typing.
+ */
+export function applyInternalUrlCompletion(
+	lines: string[],
+	cursorLine: number,
+	cursorCol: number,
+	item: AutocompleteItem,
+	prefix: string,
+): { lines: string[]; cursorLine: number; cursorCol: number } {
+	const currentLine = lines[cursorLine] || "";
+	const beforePrefix = currentLine.slice(0, cursorCol - prefix.length);
+	const afterCursor = currentLine.slice(cursorCol);
+	const insert = `${item.value} `;
+	const newLines = [...lines];
+	newLines[cursorLine] = beforePrefix + insert + afterCursor;
+	return {
+		lines: newLines,
+		cursorLine,
+		cursorCol: beforePrefix.length + insert.length,
+	};
+}