pi-ui-extend 1.0.38 → 1.0.39

package/dist/app/extensions/extension-ui-controller.js

@@ -238,6 +238,9 @@ export class ExtensionUiController {
                 process.title = title;
                 renderIfRunning();
             },
+            // pi-tui 0.85 declares Component.handleMouse(TuiMouseEvent), while pix's
+            // input pipeline delivers its own ExtensionInputMouseEvent shape; the
+            // double cast bridges the two contracts at this adapter boundary.
             custom: (async (factory) => await this.showCustomUi(factory, { scopeKey: contextScopeKey })),
             pasteToEditor: (text) => {
                 if (!this.isScopeActive(contextScopeKey))

package/dist/app/rendering/extension-entry-renderer.js

@@ -86,6 +86,8 @@ function extensionRendererTheme(theme) {
         thinkingXhigh: colors.thinkingXHigh,
         thinkingMax: colors.thinkingMax,
         bashMode: colors.toolBash,
+        scrollbarTrack: colors.muted,
+        scrollbarThumb: colors.foreground,
     };
     const backgrounds = {
         selectedBg: colors.popupSelectedBackground,

package/dist/bundled-extensions/question/contract.d.ts

@@ -17,6 +17,9 @@ export declare const questionParameters: Type.TObject<{
             label: Type.TString;
             description: Type.TOptional<Type.TString>;
         }>>;
+        multiple: Type.TOptional<Type.TBoolean>;
+        minSelections: Type.TOptional<Type.TInteger>;
+        maxSelections: Type.TOptional<Type.TInteger>;
     }>>;
 }>;
 export declare function normalizeQuestionInput(input: QuestionToolInput): NormalizedQuestion[];

package/dist/bundled-extensions/question/contract.js

@@ -20,6 +20,9 @@ export const questionParameters = Type.Object({
             maxItems: MAX_CHOICES,
             description: "Two to five meaningful predefined choices.",
         }),
+        multiple: Type.Optional(Type.Boolean({ description: "Allow selecting more than one answer for this question." })),
+        minSelections: Type.Optional(Type.Integer({ minimum: 1, description: "Minimum answers required when multiple is true. The custom answer counts as one." })),
+        maxSelections: Type.Optional(Type.Integer({ minimum: 1, description: "Maximum answers allowed when multiple is true. The custom answer counts as one." })),
     }), {
         minItems: MIN_QUESTIONS,
         maxItems: MAX_QUESTIONS,
@@ -54,6 +57,19 @@ export function normalizeQuestionInput(input) {
         }
         const seenChoiceValues = new Set();
         const seenChoiceLabels = new Set();
+        const multiple = question.multiple ?? false;
+        if (typeof multiple !== "boolean")
+            throwInvalid(`Question "${id}" multiple must be a boolean.`, "Retry with multiple omitted, true, or false.");
+        if (!multiple && (question.minSelections !== undefined || question.maxSelections !== undefined)) {
+            throwInvalid(`Question "${id}" sets selection limits without multiple: true.`, "Remove minSelections/maxSelections or enable multiple selection.");
+        }
+        const maximumAvailable = question.choices.length + 1;
+        const minSelections = multiple ? normalizeSelectionLimit(question.minSelections, 1, `question "${id}" minSelections`) : 1;
+        const maxSelections = multiple ? normalizeSelectionLimit(question.maxSelections, maximumAvailable, `question "${id}" maxSelections`) : 1;
+        if (multiple && minSelections > maxSelections)
+            throwInvalid(`Question "${id}" has minSelections ${minSelections} greater than maxSelections ${maxSelections}.`, "Retry with minSelections less than or equal to maxSelections.");
+        if (multiple && maxSelections > maximumAvailable)
+            throwInvalid(`Question "${id}" has maxSelections ${maxSelections}, but only ${maximumAvailable} answers are available including the custom answer.`, `Retry with maxSelections at most ${maximumAvailable}.`);
         return {
             id,
             label,
@@ -77,9 +93,17 @@ export function normalizeQuestionInput(input) {
                     throwInvalid(`Question "${id}" Choice label "${choiceLabel}" collides with the implicit Custom Answer row label "${CUSTOM_ANSWER_LABEL}".`, "Retry with a different predefined Choice label; the Custom Answer row is added automatically.");
                 return description === undefined ? { value, label: choiceLabel } : { value, label: choiceLabel, description };
             }),
+            ...(multiple ? { multiple: true, minSelections, maxSelections } : {}),
         };
     });
 }
+function normalizeSelectionLimit(value, fallback, field) {
+    if (value === undefined)
+        return fallback;
+    if (!Number.isInteger(value) || value < 1)
+        throwInvalid(`${field} must be a positive integer.`, "Retry with a whole number greater than or equal to one.");
+    return value;
+}
 export function trimString(value, field) {
     const trimmed = value.trim();
     if (!trimmed)

package/dist/bundled-extensions/question/desktop.d.ts

@@ -0,0 +1,11 @@
+import type { NormalizedQuestion, QuestionSelection, QuestionUiContext } from "./types.js";
+export declare const PIX_QUESTION_RPC_ENV = "PIX_QUESTION_RPC_BRIDGE";
+export declare const PIX_QUESTION_EDITOR_TITLE = "__pix_question_v1__";
+export declare const PIX_QUESTION_PROTOCOL_VERSION = 1;
+export declare const MAX_DESKTOP_QUESTION_IMAGES = 10;
+export declare const MAX_DESKTOP_QUESTION_IMAGE_BYTES: number;
+export declare const MAX_DESKTOP_QUESTION_IMAGE_BYTES_TOTAL: number;
+export declare function shouldUseDesktopQuestionBridge(ctx: QuestionUiContext, environment?: NodeJS.ProcessEnv): boolean;
+export declare function runDesktopQuestionnaire(questions: NormalizedQuestion[], ctx: QuestionUiContext): Promise<QuestionSelection[] | null>;
+export declare function parseDesktopQuestionResponse(value: string, questions: NormalizedQuestion[]): QuestionSelection[] | null;
+export declare function createDesktopQuestionResponse(selections: QuestionSelection[]): string;

package/dist/bundled-extensions/question/desktop.js

@@ -0,0 +1,143 @@
+export const PIX_QUESTION_RPC_ENV = "PIX_QUESTION_RPC_BRIDGE";
+export const PIX_QUESTION_EDITOR_TITLE = "__pix_question_v1__";
+export const PIX_QUESTION_PROTOCOL_VERSION = 1;
+export const MAX_DESKTOP_QUESTION_IMAGES = 10;
+export const MAX_DESKTOP_QUESTION_IMAGE_BYTES = 25 * 1024 * 1024;
+export const MAX_DESKTOP_QUESTION_IMAGE_BYTES_TOTAL = 50 * 1024 * 1024;
+export function shouldUseDesktopQuestionBridge(ctx, environment = process.env) {
+    return environment[PIX_QUESTION_RPC_ENV] === "1" && typeof ctx.ui.editor === "function";
+}
+export async function runDesktopQuestionnaire(questions, ctx) {
+    const answer = await ctx.ui.editor?.(PIX_QUESTION_EDITOR_TITLE, JSON.stringify({ version: PIX_QUESTION_PROTOCOL_VERSION, questions }));
+    if (answer === undefined)
+        return null;
+    return parseDesktopQuestionResponse(answer, questions);
+}
+export function parseDesktopQuestionResponse(value, questions) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsed) || parsed.version !== PIX_QUESTION_PROTOCOL_VERSION || !Array.isArray(parsed.selections)) {
+        return null;
+    }
+    if (parsed.selections.length !== questions.length)
+        return null;
+    const questionById = new Map(questions.map((question) => [question.id, question]));
+    const seenIds = new Set();
+    const selections = [];
+    let imageCount = 0;
+    let imageBytes = 0;
+    for (const rawSelection of parsed.selections) {
+        if (!isRecord(rawSelection) || typeof rawSelection.id !== "string")
+            return null;
+        const question = questionById.get(rawSelection.id);
+        if (!question || seenIds.has(rawSelection.id))
+            return null;
+        seenIds.add(rawSelection.id);
+        if (question.multiple) {
+            if (Object.keys(rawSelection).some((key) => !["id", "choiceValues", "customText", "images"].includes(key)))
+                return null;
+            if (!Array.isArray(rawSelection.choiceValues) || rawSelection.choiceValues.some((choice) => typeof choice !== "string"))
+                return null;
+            const selectedValues = new Set(rawSelection.choiceValues);
+            if (selectedValues.size !== rawSelection.choiceValues.length)
+                return null;
+            if ([...selectedValues].some((value) => !question.choices.some((choice) => choice.value === value)))
+                return null;
+            if (rawSelection.customText !== undefined && typeof rawSelection.customText !== "string")
+                return null;
+            if (rawSelection.images !== undefined && (rawSelection.customText === undefined || !Array.isArray(rawSelection.images)))
+                return null;
+            const images = [];
+            for (const rawImage of rawSelection.images ?? []) {
+                const image = parseImage(rawImage);
+                if (!image)
+                    return null;
+                const bytes = decodedBase64Size(image.data);
+                imageCount += 1;
+                imageBytes += bytes;
+                if (imageCount > MAX_DESKTOP_QUESTION_IMAGES
+                    || bytes > MAX_DESKTOP_QUESTION_IMAGE_BYTES
+                    || imageBytes > MAX_DESKTOP_QUESTION_IMAGE_BYTES_TOTAL)
+                    return null;
+                images.push(image);
+            }
+            const hasCustom = rawSelection.customText !== undefined;
+            if (hasCustom && !rawSelection.customText.trim() && images.length === 0)
+                return null;
+            const selectionCount = selectedValues.size + (hasCustom ? 1 : 0);
+            if (selectionCount < (question.minSelections ?? 1) || selectionCount > (question.maxSelections ?? question.choices.length + 1))
+                return null;
+            selections.push({
+                id: rawSelection.id,
+                choiceValues: question.choices.filter((choice) => selectedValues.has(choice.value)).map((choice) => choice.value),
+                ...(hasCustom ? { customText: rawSelection.customText } : {}),
+                ...(images.length > 0 ? { images } : {}),
+            });
+            continue;
+        }
+        if (typeof rawSelection.choiceValue === "string") {
+            if (Object.keys(rawSelection).some((key) => !["id", "choiceValue"].includes(key)))
+                return null;
+            if (!question.choices.some((choice) => choice.value === rawSelection.choiceValue))
+                return null;
+            selections.push({ id: rawSelection.id, choiceValue: rawSelection.choiceValue });
+            continue;
+        }
+        if (typeof rawSelection.customText !== "string")
+            return null;
+        if (Object.keys(rawSelection).some((key) => !["id", "customText", "images"].includes(key)))
+            return null;
+        if (rawSelection.images !== undefined && !Array.isArray(rawSelection.images))
+            return null;
+        const images = [];
+        for (const rawImage of rawSelection.images ?? []) {
+            const image = parseImage(rawImage);
+            if (!image)
+                return null;
+            const bytes = decodedBase64Size(image.data);
+            imageCount += 1;
+            imageBytes += bytes;
+            if (imageCount > MAX_DESKTOP_QUESTION_IMAGES
+                || bytes > MAX_DESKTOP_QUESTION_IMAGE_BYTES
+                || imageBytes > MAX_DESKTOP_QUESTION_IMAGE_BYTES_TOTAL)
+                return null;
+            images.push(image);
+        }
+        if (!rawSelection.customText.trim() && images.length === 0)
+            return null;
+        selections.push({
+            id: rawSelection.id,
+            customText: rawSelection.customText,
+            ...(images.length > 0 ? { images } : {}),
+        });
+    }
+    return selections;
+}
+export function createDesktopQuestionResponse(selections) {
+    const response = { version: PIX_QUESTION_PROTOCOL_VERSION, selections };
+    return JSON.stringify(response);
+}
+function parseImage(value) {
+    if (!isRecord(value) || Object.keys(value).some((key) => !["type", "data", "mimeType"].includes(key)))
+        return null;
+    if (value.type !== "image" || typeof value.data !== "string" || typeof value.mimeType !== "string")
+        return null;
+    if (!/^image\/[a-z0-9.+-]+$/i.test(value.mimeType) || !isBase64(value.data))
+        return null;
+    return { type: "image", data: value.data, mimeType: value.mimeType };
+}
+function isBase64(value) {
+    return value.length > 0 && value.length % 4 === 0 && /^[A-Za-z0-9+/]*={0,2}$/.test(value);
+}
+function decodedBase64Size(value) {
+    const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+    return (value.length / 4) * 3 - padding;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/bundled-extensions/question/index.d.ts

@@ -3,5 +3,6 @@ interface ExtensionApiLike {
 }
 export default function questionExtension(pi: ExtensionApiLike): void;
 export { questionParameters, normalizeQuestionInput } from "./contract.js";
+export { createDesktopQuestionResponse, parseDesktopQuestionResponse } from "./desktop.js";
 export { createCanceledQuestionResult, createFallbackPrompt, createQuestionToolResult, createSuccessfulQuestionResult, summarizeQuestionResult } from "./result.js";
 export type { QuestionResultDetails, QuestionToolInput } from "./types.js";

package/dist/bundled-extensions/question/index.js

@@ -2,6 +2,7 @@ import { QUESTION_TOOL_DESCRIPTION } from "./tool-description.js";
 import { questionParameters, normalizeQuestionInput } from "./contract.js";
 import { renderQuestionCall, renderQuestionResult } from "./render.js";
 import { createCanceledQuestionResult, createQuestionToolResult, createSuccessfulQuestionResult } from "./result.js";
+import { runDesktopQuestionnaire, shouldUseDesktopQuestionBridge } from "./desktop.js";
 import { runQuestionnaire } from "./tui.js";
 export default function questionExtension(pi) {
     pi.registerTool({
@@ -17,7 +18,9 @@ export default function questionExtension(pi) {
             const questions = normalizeQuestionInput(params);
             if (!ctx.hasUI)
                 return createQuestionToolResult(createCanceledQuestionResult("ui_unavailable", questions), questions);
-            const selections = await runQuestionnaire(questions, ctx);
+            const selections = shouldUseDesktopQuestionBridge(ctx)
+                ? await runDesktopQuestionnaire(questions, ctx)
+                : await runQuestionnaire(questions, ctx);
             if (selections == null)
                 return createQuestionToolResult(createCanceledQuestionResult("user_canceled"), questions);
             const images = selections.flatMap((selection) => "customText" in selection ? selection.images ?? [] : []);
@@ -26,4 +29,5 @@ export default function questionExtension(pi) {
     });
 }
 export { questionParameters, normalizeQuestionInput } from "./contract.js";
+export { createDesktopQuestionResponse, parseDesktopQuestionResponse } from "./desktop.js";
 export { createCanceledQuestionResult, createFallbackPrompt, createQuestionToolResult, createSuccessfulQuestionResult, summarizeQuestionResult } from "./result.js";

package/dist/bundled-extensions/question/render.js

@@ -20,6 +20,12 @@ export function renderQuestionResult(result, theme, args) {
     const labels = new Map((Array.isArray(args?.questions) ? args.questions : []).map((question) => [question.id, question.label]));
     return new Text(details.answers.map((answer) => {
         const questionLabel = labels.get(answer.id) ?? answer.id;
+        if ("multiple" in answer) {
+            const selections = answer.selections.map((selection) => (selection.wasCustom
+                ? `custom ${selection.label}${selection.imageCount ? ` (+${selection.imageCount} image${selection.imageCount === 1 ? "" : "s"})` : ""}`
+                : `${selection.index}. ${selection.label}`)).join(", ");
+            return `${theme.fg("success", "✓ ")}${theme.fg("accent", `${questionLabel}:`)} ${selections}`;
+        }
         if (answer.wasCustom)
             return `${theme.fg("success", "✓ ")}${theme.fg("accent", `${questionLabel}:`)} ${theme.fg("muted", "custom ")}${answer.label}`;
         return `${theme.fg("success", "✓ ")}${theme.fg("accent", `${questionLabel}:`)} ${answer.index}. ${answer.label}`;

package/dist/bundled-extensions/question/result.js

@@ -3,24 +3,38 @@ function formatAttachedImages(count) {
     return `${count} image${count === 1 ? "" : "s"} attached`;
 }
 export function createSuccessfulQuestionResult(questions, selections) {
+    if (selections.length !== questions.length)
+        throwInvalid(`Expected ${questions.length} question selections; received ${selections.length}.`, "Retry with exactly one grouped selection for each normalized question.");
+    const questionIds = new Set(questions.map((question) => question.id));
+    const seenSelectionIds = new Set();
+    for (const selection of selections) {
+        if (!questionIds.has(selection.id))
+            throwInvalid(`Received an answer for unknown question "${selection.id}".`, "Retry with only normalized question ids.");
+        if (seenSelectionIds.has(selection.id))
+            throwInvalid(`Received duplicate grouped answers for question "${selection.id}".`, "Retry with one grouped selection for each question.");
+        seenSelectionIds.add(selection.id);
+    }
     const selectionsById = new Map(selections.map((selection) => [selection.id, selection]));
     return {
         answers: questions.map((question) => {
             const selection = selectionsById.get(question.id);
             if (!selection)
                 throwInvalid(`Missing answer for question "${question.id}".`, "Retry after collecting one answer for each normalized question.");
+            if (question.multiple) {
+                if (!("choiceValues" in selection))
+                    throwInvalid(`Question "${question.id}" requires multiple selections.`, "Retry with choiceValues and an optional custom answer for this multi-select question.");
+                return {
+                    id: question.id,
+                    multiple: true,
+                    selections: createMultipleAnswerSelections(question, selection),
+                };
+            }
+            if ("choiceValues" in selection)
+                throwInvalid(`Question "${question.id}" accepts only one selection.`, "Retry with one choiceValue or one custom answer for this single-select question.");
             if ("customText" in selection) {
-                const customText = selection.customText.trim();
-                const imageCount = selection.images?.length ?? 0;
-                if (!customText && imageCount === 0)
-                    throwInvalid(`Custom Answer for question "${question.id}" is empty after trimming.`, "Retry with non-empty Custom Answer text, an image, or choose a predefined Choice.");
-                const label = customText || formatAttachedImages(imageCount);
                 return {
                     id: question.id,
-                    value: customText || label,
-                    label,
-                    wasCustom: true,
-                    ...(imageCount > 0 ? { imageCount } : {}),
+                    ...createCustomAnswerSelection(question.id, selection.customText, selection.images),
                 };
             }
             const choiceIndex = question.choices.findIndex((choice) => choice.value === selection.choiceValue);
@@ -38,6 +52,41 @@ export function createSuccessfulQuestionResult(questions, selections) {
         canceled: false,
     };
 }
+function createMultipleAnswerSelections(question, selection) {
+    const uniqueValues = new Set(selection.choiceValues);
+    if (uniqueValues.size !== selection.choiceValues.length)
+        throwInvalid(`Question "${question.id}" contains duplicate predefined selections.`, "Retry with each choice value at most once.");
+    for (const value of uniqueValues) {
+        if (!question.choices.some((choice) => choice.value === value))
+            throwInvalid(`Question "${question.id}" has no predefined Choice with value "${value}".`, "Retry with only normalized predefined Choice values for that question.");
+    }
+    if (selection.images && selection.customText === undefined)
+        throwInvalid(`Question "${question.id}" includes custom images without a custom answer.`, "Retry with customText, which may be empty for an image-only answer.");
+    const answers = question.choices.flatMap((choice, index) => (uniqueValues.has(choice.value)
+        ? [{ value: choice.value, label: choice.label, wasCustom: false, index: index + 1 }]
+        : []));
+    if (selection.customText !== undefined)
+        answers.push(createCustomAnswerSelection(question.id, selection.customText, selection.images));
+    const minSelections = question.minSelections ?? 1;
+    const maxSelections = question.maxSelections ?? question.choices.length + 1;
+    if (answers.length < minSelections || answers.length > maxSelections) {
+        throwInvalid(`Question "${question.id}" requires ${minSelections} to ${maxSelections} selections; received ${answers.length}.`, "Retry with a number of answers inside the configured selection limits.");
+    }
+    return answers;
+}
+function createCustomAnswerSelection(questionId, text, images) {
+    const customText = text.trim();
+    const imageCount = images?.length ?? 0;
+    if (!customText && imageCount === 0)
+        throwInvalid(`Custom Answer for question "${questionId}" is empty after trimming.`, "Retry with non-empty Custom Answer text, an image, or choose a predefined Choice.");
+    const label = customText || formatAttachedImages(imageCount);
+    return {
+        value: customText || label,
+        label,
+        wasCustom: true,
+        ...(imageCount > 0 ? { imageCount } : {}),
+    };
+}
 export function createCanceledQuestionResult(reason, questions = []) {
     return {
         answers: [],
@@ -52,6 +101,8 @@ export function createFallbackPrompt(questions) {
     ];
     questions.forEach((question, index) => {
         lines.push("", `${index + 1}. ${question.label}: ${question.prompt}`);
+        if (question.multiple)
+            lines.push(`   Select ${question.minSelections ?? 1} to ${question.maxSelections ?? question.choices.length + 1} answers.`);
         question.choices.forEach((choice, choiceIndex) => {
             const suffix = choice.description ? ` — ${choice.description}` : "";
             lines.push(`   ${choiceIndex + 1}. ${choice.label}${suffix}`);
@@ -74,6 +125,9 @@ export function summarizeQuestionResult(result, questions = []) {
     const questionLabels = new Map(questions.map((question) => [question.id, question.label]));
     return `question answers: ${result.answers.map((answer) => {
         const questionLabel = questionLabels.get(answer.id) ?? answer.id;
+        if ("multiple" in answer) {
+            return `${questionLabel}: ${answer.selections.map((item) => summarizeAnswerSelection(item)).join(", ")}`;
+        }
         if (answer.wasCustom) {
             const imageLabel = answer.imageCount ? formatAttachedImages(answer.imageCount) : undefined;
             const imageSuffix = imageLabel && answer.label !== imageLabel ? `; ${imageLabel}` : "";
@@ -82,6 +136,14 @@ export function summarizeQuestionResult(result, questions = []) {
         return `${questionLabel}: ${answer.label} (choice ${answer.index})`;
     }).join("; ")}.`;
 }
+function summarizeAnswerSelection(answer) {
+    if (answer.wasCustom) {
+        const imageLabel = answer.imageCount ? formatAttachedImages(answer.imageCount) : undefined;
+        const imageSuffix = imageLabel && answer.label !== imageLabel ? `; ${imageLabel}` : "";
+        return `${answer.label} (custom answer${imageSuffix})`;
+    }
+    return `${answer.label} (choice ${answer.index})`;
+}
 export function createQuestionToolResult(details, questions = [], images = []) {
     return {
         content: [

package/dist/bundled-extensions/question/tool-description.js

@@ -1,10 +1,11 @@
 export const QUESTION_TOOL_DESCRIPTION = {
     name: "question",
     label: "Question",
-    description: "Ask the user one to five structured questions, each with two to five choices plus an implicit custom answer path.",
-    promptSnippet: "Gather structured user feedback with predefined choices and an always-available custom answer path.",
+    description: "Ask the user one to five structured single- or multi-select questions, each with two to five choices plus an implicit custom answer path.",
+    promptSnippet: "Gather structured user feedback with predefined single- or multi-select choices and an always-available custom answer path.",
     promptGuidelines: [
         "Use question to gather feedback, choose alternatives, confirm direction, or resolve ambiguity when you can provide at least two meaningful choices.",
-        "question accepts 1–5 questions with 2–5 choices each and an implicit custom answer path; avoid it for purely open-ended input or when normal conversation is clearer.",
+        "question accepts 1–5 questions with 2–5 choices each and an implicit custom answer path; set multiple: true with optional minSelections/maxSelections when several answers may apply.",
+        "For multi-select questions, the custom answer can be combined with predefined choices and counts as one selection toward the limits.",
     ],
 };