@hheei/pi-ask-user 0.0.0-stage → 0.1.0

package/dist/format.js

@@ -0,0 +1,84 @@
+import { formatOptionsForMessage, formatResponseSummary, isSelectionResponse, } from "./response";
+export function formatBatchAnswers(details) {
+    const heading = details.heading ? [details.heading] : [];
+    const lines = details.questions.map((subject, index) => {
+        const answer = details.answers[index];
+        const summary = answer?.status === "answered" ? formatResponseSummary(answer.response) : "(skipped)";
+        return `${index + 1}. ${subject.question} \u2192 ${summary}`;
+    });
+    const answered = details.answers.filter((answer) => answer.status === "answered").length;
+    return [
+        ...heading,
+        `User answered ${answered} of ${details.questions.length} questions:`,
+        ...lines,
+    ].join("\n");
+}
+/** Non-interactive hosts get the whole prompt as text, so the model can still ask. */
+export function formatSingleForMessage(input) {
+    const optionText = input.options.length > 0 ? `\n\nOptions:\n${formatOptionsForMessage(input.options)}` : "";
+    const freeformHint = input.allowFreeform ? "\n\nYou can also answer freely." : "";
+    const contextText = input.context ? `\n\nContext:\n${input.context}` : "";
+    return `Ask requires interactive mode. Please answer:\n\n${input.question}${contextText}${optionText}${freeformHint}`;
+}
+export function formatBatchForMessage(questions, heading) {
+    const blocks = questions.map((entry, index) => {
+        const lines = [`${index + 1}. ${entry.question}`];
+        if (entry.context)
+            lines.push(`   Context: ${entry.context.replace(/\n/g, "\n   ")}`);
+        if (entry.options.length > 0) {
+            lines.push(`   Options${entry.allowMultiple ? " (choose one or more)" : ""}:`);
+            lines.push(...formatOptionsForMessage(entry.options)
+                .split("\n")
+                .map((line) => `   ${line}`));
+            if (entry.allowFreeform)
+                lines.push("   You can also answer freely.");
+        }
+        return lines.join("\n");
+    });
+    const intro = heading ? `\n\n${heading}` : "";
+    return `Ask requires interactive mode. Please answer these questions:${intro}\n\n${blocks.join("\n\n")}`;
+}
+/** Expanded-result block: every option with the selected ones marked. */
+export function formatOptionMarkers(theme, options, response, indent = "") {
+    const selectedTitles = new Set(response.selections);
+    let text = `\n${indent}${theme.fg("dim", "Options:")}`;
+    for (const opt of options) {
+        const desc = opt.description ? ` \u2014 ${opt.description}` : "";
+        const marker = selectedTitles.has(opt.title)
+            ? theme.fg("success", "\u25cf")
+            : theme.fg("dim", "\u25cb");
+        text += `\n${indent}  ${marker} ${theme.fg("dim", opt.title)}${theme.fg("dim", desc)}`;
+    }
+    return text;
+}
+export function formatBatchResult(theme, details, expanded) {
+    if (details.cancelled)
+        return theme.fg("warning", "Cancelled");
+    const answered = details.answers.filter((answer) => answer.status === "answered").length;
+    let text = theme.fg("success", "\u2713 ") +
+        theme.fg("accent", `${answered} of ${details.questions.length} answered`);
+    details.questions.forEach((subject, index) => {
+        const answer = details.answers[index];
+        if (!answer)
+            return;
+        text += `\n${theme.fg("dim", `${index + 1}.`)} ${theme.fg("muted", subject.question)}${theme.fg("dim", " \u2192 ")}`;
+        if (answer.status === "skipped") {
+            text += theme.fg("warning", "(skipped)");
+            return;
+        }
+        const response = answer.response;
+        if (response.kind === "freeform") {
+            text += theme.fg("muted", "(wrote) ");
+        }
+        text += theme.fg("accent", formatResponseSummary(response));
+        if (!expanded)
+            return;
+        if (subject.context) {
+            text += `\n   ${theme.fg("dim", subject.context)}`;
+        }
+        if (isSelectionResponse(response) && subject.options.length > 0) {
+            text += formatOptionMarkers(theme, subject.options, response, "   ");
+        }
+    });
+    return text;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export default function askUser(pi: ExtensionAPI): void;

package/dist/index.js

@@ -0,0 +1,6 @@
+import { registerAskUserSettings } from "./settings-provider";
+import { registerAskUserTool } from "./tool";
+export default function askUser(pi) {
+    registerAskUserTool(pi);
+    registerAskUserSettings(pi);
+}

package/dist/multi-select-list.d.ts

@@ -0,0 +1,25 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, type KeybindingsManager } from "@earendil-works/pi-tui";
+import type { QuestionOption } from "./single-select-layout";
+export declare class MultiSelectList implements Component {
+    private options;
+    private theme;
+    private keybindings;
+    private readonly rows;
+    private checked;
+    private cachedWidth;
+    private cachedLines;
+    onCancel?: () => void;
+    onSubmit?: (result: string[]) => void;
+    onEnterFreeform?: () => void;
+    constructor(options: QuestionOption[], allowFreeform: boolean, theme: Theme, keybindings: KeybindingsManager);
+    setMaxVisibleRows(count: number): void;
+    invalidate(): void;
+    private toggle;
+    handleInput(data: string): void;
+    /** Space on the selected row: tick the option, or open the custom response. */
+    private activate;
+    /** Submit the ticked options, or the selected one when none is ticked. */
+    submit(): void;
+    render(width: number): string[];
+}

package/dist/multi-select-list.js

@@ -0,0 +1,155 @@
+import { Key, matchesKey, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
+import { fitRow } from "@hheei/pi-ext-core";
+import { FREEFORM_HINT, FREEFORM_LABEL } from "./constants";
+import { OptionRows, visibleBlockWindow } from "./option-rows";
+import { digitKey, matchesSelectDown, matchesSelectUp } from "./shortcuts";
+export class MultiSelectList {
+    options;
+    theme;
+    keybindings;
+    rows;
+    checked = new Set();
+    cachedWidth;
+    cachedLines;
+    onCancel;
+    onSubmit;
+    onEnterFreeform;
+    constructor(options, allowFreeform, theme, keybindings) {
+        this.options = options;
+        this.theme = theme;
+        this.keybindings = keybindings;
+        this.rows = new OptionRows(allowFreeform, 10);
+    }
+    setMaxVisibleRows(count) {
+        if (this.rows.setMaxVisibleRows(count))
+            this.invalidate();
+    }
+    invalidate() {
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    toggle(index) {
+        if (index < 0 || index >= this.options.length)
+            return;
+        if (this.checked.has(index))
+            this.checked.delete(index);
+        else
+            this.checked.add(index);
+    }
+    handleInput(data) {
+        if (this.keybindings.matches(data, "tui.select.cancel")) {
+            this.onCancel?.();
+            return;
+        }
+        const optionCount = this.options.length;
+        const count = this.rows.count(optionCount);
+        if (count === 0) {
+            this.onCancel?.();
+            return;
+        }
+        if (matchesSelectUp(data, this.keybindings) && this.rows.moveSelection(-1, count)) {
+            this.invalidate();
+            return;
+        }
+        if (matchesSelectDown(data, this.keybindings) && this.rows.moveSelection(1, count)) {
+            this.invalidate();
+            return;
+        }
+        const digit = digitKey(data);
+        if (digit !== null) {
+            if (digit <= optionCount) {
+                this.toggle(digit - 1);
+                this.rows.selected = Math.min(digit - 1, count - 1);
+                this.invalidate();
+            }
+            return;
+        }
+        if (matchesKey(data, Key.space)) {
+            this.activate();
+            return;
+        }
+        if (this.keybindings.matches(data, "tui.select.confirm")) {
+            if (this.rows.isFreeformRow(this.rows.selected, optionCount)) {
+                this.activate();
+                return;
+            }
+            this.submit();
+        }
+    }
+    /** Space on the selected row: tick the option, or open the custom response. */
+    activate() {
+        const index = this.rows.selected;
+        if (this.rows.isFreeformRow(index, this.options.length)) {
+            this.onEnterFreeform?.();
+            return;
+        }
+        this.toggle(index);
+        this.invalidate();
+    }
+    /** Submit the ticked options, or the selected one when none is ticked. */
+    submit() {
+        const selectedTitles = Array.from(this.checked)
+            .sort((a, b) => a - b)
+            .map((i) => this.options[i]?.title)
+            .filter((title) => !!title);
+        const fallback = this.options[this.rows.selected]?.title;
+        const result = selectedTitles.length > 0 ? selectedTitles : fallback ? [fallback] : [];
+        if (result.length > 0)
+            this.onSubmit?.(result);
+        else
+            this.onCancel?.();
+    }
+    render(width) {
+        if (this.cachedLines && this.cachedWidth === width)
+            return this.cachedLines;
+        const theme = this.theme;
+        const optionCount = this.options.length;
+        const count = this.rows.count(optionCount);
+        if (count === 0) {
+            this.cachedLines = [theme.fg("warning", "No options")];
+            this.cachedWidth = width;
+            return this.cachedLines;
+        }
+        this.rows.clampSelection(count);
+        const blocks = [];
+        for (let i = 0; i < count; i++) {
+            const isSelected = i === this.rows.selected;
+            const prefix = isSelected ? theme.fg("accent", "→") : " ";
+            const block = [];
+            if (this.rows.isFreeformRow(i, optionCount)) {
+                const label = theme.fg("text", theme.bold(FREEFORM_LABEL));
+                const desc = theme.fg("muted", FREEFORM_HINT);
+                block.push(fitRow(`${prefix}   ${label} ${theme.fg("dim", "—")} ${desc}`, width, ""));
+            }
+            else {
+                const option = this.options[i];
+                if (option) {
+                    const checkbox = this.checked.has(i)
+                        ? theme.fg("success", "[✓]")
+                        : theme.fg("dim", "[ ]");
+                    const num = theme.fg("dim", `${i + 1}.`);
+                    const title = isSelected
+                        ? theme.fg("accent", theme.bold(option.title))
+                        : theme.fg("text", theme.bold(option.title));
+                    block.push(fitRow(`${prefix} ${num} ${checkbox} ${title}`, width, ""));
+                    if (option.description) {
+                        const indent = "      ";
+                        for (const line of wrapTextWithAnsi(option.description, Math.max(8, width - indent.length))) {
+                            block.push(fitRow(indent + theme.fg("muted", line), width, ""));
+                        }
+                    }
+                }
+            }
+            blocks.push({ itemIndex: i, lines: block });
+        }
+        const maxRows = this.rows.visibleRows;
+        const window = visibleBlockWindow(blocks, this.rows.selected, maxRows);
+        const lines = window.flatMap((block) => block.lines);
+        if (window !== blocks && maxRows > 1) {
+            lines.push(theme.fg("dim", fitRow(`  (${this.rows.selected + 1}/${count})`, width, "")));
+        }
+        this.cachedWidth = width;
+        this.cachedLines = lines;
+        return lines;
+    }
+}

package/dist/option-rows.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Row model shared by the single- and multi-select lists: option rows followed
+ * by the optional freeform row, plus the selection cursor and the row budget.
+ */
+export declare class OptionRows {
+    readonly allowFreeform: boolean;
+    selected: number;
+    private maxVisibleRows;
+    constructor(allowFreeform: boolean, maxVisibleRows: number);
+    get visibleRows(): number;
+    /** Rows shown for `optionCount` options: the options plus the trailing freeform row. */
+    count(optionCount: number): number;
+    freeformIndex(optionCount: number): number;
+    isFreeformRow(index: number, optionCount: number): boolean;
+    setMaxVisibleRows(rows: number): boolean;
+    /** Move the cursor by `delta` rows, wrapping around `count` rows. */
+    moveSelection(delta: number, count: number): boolean;
+    /** Keep the cursor inside `count` rows after the row set changed. */
+    clampSelection(count: number): boolean;
+}
+/** One item's rendered rows: an option or the freeform row. */
+export interface RowBlock<T = string> {
+    itemIndex: number;
+    lines: T[];
+}
+/**
+ * The blocks that fit in `maxRows`, keeping the selected block visible and
+ * filling the budget with following blocks first and preceding ones after
+ * that. The last row is reserved for the caller's overflow indicator, so the
+ * selected block is cut when it alone exceeds the budget. Returns the input
+ * array unchanged when everything fits.
+ */
+export declare function visibleBlockWindow<T>(blocks: RowBlock<T>[], selectedIndex: number, maxRows: number): RowBlock<T>[];

package/dist/option-rows.js

@@ -0,0 +1,89 @@
+/**
+ * Row model shared by the single- and multi-select lists: option rows followed
+ * by the optional freeform row, plus the selection cursor and the row budget.
+ */
+export class OptionRows {
+    allowFreeform;
+    selected = 0;
+    maxVisibleRows;
+    constructor(allowFreeform, maxVisibleRows) {
+        this.allowFreeform = allowFreeform;
+        this.maxVisibleRows = maxVisibleRows;
+    }
+    get visibleRows() {
+        return this.maxVisibleRows;
+    }
+    /** Rows shown for `optionCount` options: the options plus the trailing freeform row. */
+    count(optionCount) {
+        return optionCount + (this.allowFreeform ? 1 : 0);
+    }
+    freeformIndex(optionCount) {
+        return optionCount;
+    }
+    isFreeformRow(index, optionCount) {
+        return this.allowFreeform && index === this.freeformIndex(optionCount);
+    }
+    setMaxVisibleRows(rows) {
+        const next = Math.max(1, Math.floor(rows));
+        if (next === this.maxVisibleRows)
+            return false;
+        this.maxVisibleRows = next;
+        return true;
+    }
+    /** Move the cursor by `delta` rows, wrapping around `count` rows. */
+    moveSelection(delta, count) {
+        if (count <= 0)
+            return false;
+        const next = (this.selected + delta + count) % count;
+        if (next === this.selected)
+            return false;
+        this.selected = next;
+        return true;
+    }
+    /** Keep the cursor inside `count` rows after the row set changed. */
+    clampSelection(count) {
+        const next = count > 0 ? Math.max(0, Math.min(this.selected, count - 1)) : 0;
+        if (next === this.selected)
+            return false;
+        this.selected = next;
+        return true;
+    }
+}
+/**
+ * The blocks that fit in `maxRows`, keeping the selected block visible and
+ * filling the budget with following blocks first and preceding ones after
+ * that. The last row is reserved for the caller's overflow indicator, so the
+ * selected block is cut when it alone exceeds the budget. Returns the input
+ * array unchanged when everything fits.
+ */
+export function visibleBlockWindow(blocks, selectedIndex, maxRows) {
+    const totalRows = blocks.reduce((sum, block) => sum + block.lines.length, 0);
+    if (totalRows <= maxRows)
+        return blocks;
+    const availableRows = maxRows > 1 ? maxRows - 1 : 1;
+    const selected = blocks[selectedIndex] ?? blocks[0];
+    if (!selected)
+        return [];
+    if (selected.lines.length >= availableRows) {
+        return [{ itemIndex: selected.itemIndex, lines: selected.lines.slice(0, availableRows) }];
+    }
+    let startIndex = selectedIndex;
+    let endIndex = selectedIndex + 1;
+    let usedRows = selected.lines.length;
+    while (true) {
+        const nextBlock = blocks[endIndex];
+        if (nextBlock && usedRows + nextBlock.lines.length <= availableRows) {
+            usedRows += nextBlock.lines.length;
+            endIndex += 1;
+            continue;
+        }
+        const previousBlock = blocks[startIndex - 1];
+        if (previousBlock && usedRows + previousBlock.lines.length <= availableRows) {
+            startIndex -= 1;
+            usedRows += previousBlock.lines.length;
+            continue;
+        }
+        break;
+    }
+    return blocks.slice(startIndex, endIndex);
+}

package/dist/preferences.d.ts

@@ -0,0 +1,8 @@
+import { SETTINGS_SECTION } from "./constants";
+import type { AskDisplayMode, AskParams } from "./schema";
+export { SETTINGS_SECTION };
+export interface PromptSettings {
+    displayMode: AskDisplayMode;
+}
+/** Resolve presentation preferences: call parameter, then the askUser section of ext_settings.json, then the field default. */
+export declare function resolvePromptSettings(params: AskParams, signal?: AbortSignal): Promise<PromptSettings>;

package/dist/preferences.js

@@ -0,0 +1,25 @@
+import { defaultExtensionSettingsPaths, readMergedJsonSettingsSection, } from "@hheei/pi-ext-core";
+import { SETTINGS_SECTION } from "./constants";
+import { ASK_USER_FIELDS } from "./settings-provider";
+export { SETTINGS_SECTION };
+function pickEnum(raw, field) {
+    // ext-core types option values as SettingPrimitive; an enum field only ever lists its own T.
+    const matched = field.options?.find((option) => option.value === raw)?.value;
+    return matched ?? field.defaultValue;
+}
+/** Read on every ask_user call so edits apply without restarting Pi. */
+async function readAskUserSettings(signal) {
+    const { merged } = await readMergedJsonSettingsSection({
+        paths: defaultExtensionSettingsPaths(),
+        section: SETTINGS_SECTION,
+        ...(signal ? { signal } : {}),
+    });
+    return merged;
+}
+/** Resolve presentation preferences: call parameter, then the askUser section of ext_settings.json, then the field default. */
+export async function resolvePromptSettings(params, signal) {
+    const raw = await readAskUserSettings(signal);
+    return {
+        displayMode: params.displayMode ?? pickEnum(raw.displayMode, ASK_USER_FIELDS.displayMode),
+    };
+}

package/dist/presentation.d.ts

@@ -0,0 +1,6 @@
+import type { AgentToolResult, ExtensionAPI, Theme, ToolRenderers } from "@earendil-works/pi-coding-agent";
+import { type ToolPresentation, type ToolPresentationContext } from "@hheei/pi-ext-core";
+/** Presentation facts for one ask_user call or result; ext-ui frames them, the host shows them plain. */
+export declare function presentAskUser(args: unknown, result: AgentToolResult<unknown> | undefined, theme: Theme, context: ToolPresentationContext): ToolPresentation;
+/** Native renderers plus the presentation provider ext-ui decorates when installed. */
+export declare function createAskUserRenderers(pi: ExtensionAPI): ToolRenderers;

package/dist/presentation.js

@@ -0,0 +1,129 @@
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { createToolPresentationRenderers, } from "@hheei/pi-ext-core";
+import { formatBatchResult, formatOptionMarkers } from "./format";
+import { formatResponseSummary, isBatchDetails, isSelectionResponse, } from "./response";
+import { coerceOptions } from "./schema";
+function detailsOf(result) {
+    const details = result?.details;
+    return typeof details === "object" && details !== null ? details : undefined;
+}
+function errorText(result, details) {
+    return (details?.error ??
+        result?.content
+            ?.map((part) => (part.type === "text" ? part.text : ""))
+            .join("\n")
+            .trim() ??
+        "");
+}
+function callSections(args, theme) {
+    const questions = Array.isArray(args.questions) ? args.questions : undefined;
+    if (questions === undefined) {
+        const question = typeof args.question === "string" ? args.question.trim() : "";
+        const lines = coerceOptions(Array.isArray(args.options) ? args.options : []).map((option, index) => theme.fg("text", `${index + 1}. ${option.title}`));
+        return {
+            summary: question,
+            sections: lines.length === 0
+                ? []
+                : [{ railToken: "muted", content: [theme.fg("dim", "Options:"), ...lines] }],
+        };
+    }
+    const heading = typeof args.question === "string" ? args.question.trim() : "";
+    const lines = questions.map((entry, index) => {
+        const record = (entry ?? {});
+        const question = typeof record.question === "string" ? record.question : "";
+        const optionCount = Array.isArray(record.options) ? record.options.length : 0;
+        const notes = optionCount > 0 ? ` (${optionCount} option(s))` : "";
+        return theme.fg("text", `${index + 1}. ${question}${notes}`);
+    });
+    return {
+        summary: `${questions.length} questions${heading ? ` · ${heading}` : ""}`,
+        sections: lines.length === 0 ? [] : [{ railToken: "muted", content: lines }],
+    };
+}
+function singleResult(details, theme) {
+    const response = details.response;
+    if (details.cancelled || response === null) {
+        return {
+            summary: "cancelled",
+            status: "warn",
+            collapsedRows: [theme.fg("warning", "Cancelled")],
+            output: "Cancelled",
+            copy: { primary: "Cancelled" },
+        };
+    }
+    const summary = formatResponseSummary(response);
+    const prefix = response.kind === "freeform" ? "(wrote) " : "";
+    const sections = [];
+    const plain = [`✓ ${prefix}${summary}`];
+    const addSection = (railToken, lines) => {
+        if (lines.length === 0)
+            return;
+        sections.push({ railToken, content: lines });
+        plain.push(...lines);
+    };
+    addSection("dim", [theme.fg("dim", `Q: ${details.question}`)]);
+    if (details.context)
+        addSection("dim", [theme.fg("dim", details.context)]);
+    if (isSelectionResponse(response)) {
+        addSection("accent", formatOptionMarkers(theme, details.options, response).split("\n"));
+    }
+    return {
+        summary,
+        status: "ok",
+        collapsedRows: [
+            `${theme.fg("success", "✓ ")}${theme.fg("muted", prefix)}${theme.fg("accent", summary)}`,
+        ],
+        sections,
+        output: stripTerminalSequences(plain.join("\n")),
+        copy: { primary: summary },
+    };
+}
+function batchResult(details, theme) {
+    const collapsed = formatBatchResult(theme, details, false);
+    const expanded = formatBatchResult(theme, details, true);
+    const answered = details.answers.filter((answer) => answer.status === "answered").length;
+    return {
+        summary: details.cancelled
+            ? "cancelled"
+            : `${answered} of ${details.questions.length} answered`,
+        status: details.cancelled ? "warn" : "ok",
+        collapsedRows: collapsed.split("\n"),
+        sections: expanded === collapsed ? [] : [{ railToken: "dim", content: expanded.split("\n") }],
+        output: stripTerminalSequences(expanded),
+        copy: { primary: stripTerminalSequences(collapsed) },
+    };
+}
+/** Presentation facts for one ask_user call or result; ext-ui frames them, the host shows them plain. */
+export function presentAskUser(args, result, theme, context) {
+    const details = detailsOf(result);
+    const failed = result?.isError === true || details?.error !== undefined;
+    if (failed) {
+        const message = errorText(result, details);
+        return {
+            summary: message === "" ? "failed" : (message.split("\n")[0] ?? "failed"),
+            status: "error",
+            output: message === "" ? "ask_user failed" : message,
+        };
+    }
+    if (result === undefined) {
+        const call = callSections(typeof args === "object" && args !== null ? args : {}, theme);
+        return { summary: call.summary, status: "running", sections: call.sections };
+    }
+    if (context.isPartial) {
+        return {
+            summary: "waiting for user input",
+            status: "running",
+            replaceCallOnPartial: true,
+            collapsedRows: [theme.fg("muted", "Waiting for user input...")],
+        };
+    }
+    if (details === undefined)
+        return { summary: "", status: "ok" };
+    if (isBatchDetails(details))
+        return batchResult(details, theme);
+    return singleResult(details, theme);
+}
+/** Native renderers plus the presentation provider ext-ui decorates when installed. */
+export function createAskUserRenderers(pi) {
+    return createToolPresentationRenderers(pi, "ask_user", presentAskUser);
+}

package/dist/prompt-context.d.ts

@@ -0,0 +1,26 @@
+import { type Theme } from "@earendil-works/pi-coding-agent";
+import { type KeyId, Markdown } from "@earendil-works/pi-tui";
+/**
+ * Owns the question's context block: the component that renders it, whether it is
+ * long enough to collapse, and the expand/collapse state the user toggles with the
+ * context shortcut. The prompt only asks for display lines; the pane never decides
+ * layout, scrolling, or which mode is active.
+ */
+export declare class PromptContextPane {
+    readonly component: Markdown | undefined;
+    private readonly text;
+    private readonly theme;
+    private readonly onChange;
+    private collapsibleState;
+    private expandedState;
+    constructor(text: string | undefined, theme: Theme, onChange: () => void);
+    get collapsible(): boolean;
+    get expanded(): boolean;
+    fullLines(width: number): string[];
+    displayLines(fullContextLines: string[], width: number): string[];
+    toggleKey(): KeyId;
+    /** Marks the block as long enough to collapse; a new state starts collapsed. */
+    setCollapsible(value: boolean): void;
+    toggle(): boolean;
+    updateText(): void;
+}

package/dist/prompt-context.js

@@ -0,0 +1,68 @@
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { Markdown } from "@earendil-works/pi-tui";
+import { fitRow } from "@hheei/pi-ext-core";
+import { CONTEXT_TOGGLE_KEYS } from "./constants";
+/**
+ * Owns the question's context block: the component that renders it, whether it is
+ * long enough to collapse, and the expand/collapse state the user toggles with the
+ * context shortcut. The prompt only asks for display lines; the pane never decides
+ * layout, scrolling, or which mode is active.
+ */
+export class PromptContextPane {
+    component;
+    text;
+    theme;
+    onChange;
+    collapsibleState = false;
+    expandedState = false;
+    constructor(text, theme, onChange) {
+        this.text = text;
+        this.theme = theme;
+        this.onChange = onChange;
+        if (!text) {
+            this.component = undefined;
+            return;
+        }
+        this.component = new Markdown("", 1, 0, getMarkdownTheme());
+    }
+    get collapsible() {
+        return this.collapsibleState;
+    }
+    get expanded() {
+        return this.expandedState;
+    }
+    fullLines(width) {
+        return this.component ? this.component.render(width) : [];
+    }
+    displayLines(fullContextLines, width) {
+        if (fullContextLines.length === 0)
+            return [];
+        if (!this.collapsibleState || this.expandedState)
+            return fullContextLines;
+        const label = `Context (${fullContextLines.length} lines) — ${this.toggleKey()} expand`;
+        return [fitRow(this.theme.fg("dim", label), width, "")];
+    }
+    toggleKey() {
+        return CONTEXT_TOGGLE_KEYS[0];
+    }
+    /** Marks the block as long enough to collapse; a new state starts collapsed. */
+    setCollapsible(value) {
+        if (this.collapsibleState === value)
+            return;
+        this.collapsibleState = value;
+        this.expandedState = false;
+        this.onChange();
+    }
+    toggle() {
+        if (!this.collapsibleState)
+            return false;
+        this.expandedState = !this.expandedState;
+        this.onChange();
+        return true;
+    }
+    updateText() {
+        if (!this.component || !this.text)
+            return;
+        this.component.setText(`**Context:**\n${this.text}`);
+    }
+}