@ryan_nookpi/pi-extension-ask-user-question 0.1.0 → 0.2.0

package/output.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "vitest";
+
+import {
+	buildRenderCallText,
+	buildRenderResultText,
+	errorResult,
+	formatResultContent,
+	renderCall,
+	renderResult,
+} from "./output.ts";
+import type { FormResult, RenderTheme } from "./types.ts";
+
+const theme: RenderTheme = {
+	fg: (_color, text) => text,
+	bg: (_color, text) => `[${text}]`,
+	bold: (text) => `**${text}**`,
+};
+
+const formResult: FormResult = {
+	title: "Form",
+	cancelled: false,
+	questions: [
+		{ id: "q1", type: "radio", prompt: "Q1", label: "One", options: [], allowOther: true, required: true },
+		{ id: "q2", type: "checkbox", prompt: "Q2", label: "Two", options: [], allowOther: true, required: true },
+		{ id: "q3", type: "text", prompt: "Q3", label: "Three", options: [], allowOther: false, required: true },
+	],
+	answers: [
+		{ id: "q1", type: "radio", value: "custom", wasCustom: true },
+		{ id: "q2", type: "checkbox", value: [], wasCustom: false },
+		{ id: "q3", type: "text", value: "", wasCustom: true },
+	],
+};
+
+describe("ask-user-question/output", () => {
+	it("builds error results", () => {
+		expect(errorResult("boom")).toEqual({
+			content: [{ type: "text", text: "boom" }],
+			details: { questions: [], answers: [], cancelled: true },
+		});
+	});
+
+	it("formats successful result content", () => {
+		expect(formatResultContent(formResult)).toBe("One: (wrote) custom\nTwo: (none selected)\nThree: (empty)");
+		expect(
+			formatResultContent({
+				...formResult,
+				answers: [
+					{ id: "missing", type: "radio", value: "picked", wasCustom: false },
+					{ id: "q2", type: "checkbox", value: ["a", "b"], wasCustom: false },
+					{ id: "q3", type: "text", value: "filled", wasCustom: true },
+				],
+			}),
+		).toBe("missing: picked\nTwo: a, b\nThree: filled");
+		expect(
+			formatResultContent({
+				...formResult,
+				answers: [{ id: "q2", type: "checkbox", value: "solo", wasCustom: false }],
+			}),
+		).toBe("Two: solo");
+	});
+
+	it("builds render-call summaries", () => {
+		expect(
+			buildRenderCallText({ title: "Title", questions: [{ id: "x", type: "radio", prompt: "Q" }] }, theme),
+		).toContain("Title 1 question (radio)");
+		expect(buildRenderCallText({}, theme)).toContain("0 questions");
+		expect(renderCall({ title: "Title", questions: [] }, theme)).toBeTruthy();
+	});
+
+	it("builds render-result text across branches", () => {
+		expect(buildRenderResultText({ content: [{ type: "text", text: "plain" }] }, theme)).toBe("plain");
+		expect(buildRenderResultText({ content: [{ type: "text" }] }, theme)).toBe("");
+		expect(buildRenderResultText({ content: [{ type: "image", text: "ignored" }] }, theme)).toBe("");
+		expect(buildRenderResultText({}, theme)).toBe("");
+		expect(buildRenderResultText({ details: { ...formResult, cancelled: true } }, theme)).toBe("Cancelled");
+		expect(buildRenderResultText({ details: formResult }, theme)).toBe(
+			"✓ One: (wrote) custom\n✓ Two: (none)\n✓ Three: (empty)",
+		);
+		expect(
+			buildRenderResultText(
+				{
+					details: {
+						...formResult,
+						answers: [
+							{ id: "missing", type: "radio", value: "picked", wasCustom: false },
+							{ id: "q2", type: "checkbox", value: ["a"], wasCustom: false },
+							{ id: "q3", type: "text", value: "filled", wasCustom: true },
+						],
+					},
+				},
+				theme,
+			),
+		).toBe("✓ missing: picked\n✓ Two: a\n✓ Three: filled");
+		expect(
+			buildRenderResultText(
+				{ details: { ...formResult, answers: [{ id: "q2", type: "checkbox", value: "solo", wasCustom: false }] } },
+				theme,
+			),
+		).toBe("✓ Two: solo");
+		expect(renderResult({ details: formResult }, theme)).toBeTruthy();
+	});
+});

package/output.ts

@@ -0,0 +1,89 @@
+import { Text } from "@mariozechner/pi-tui";
+
+import { SYM } from "./constants.ts";
+import type { FormResult, Question, RenderTheme } from "./types.ts";
+
+export function errorResult(message: string): {
+	content: { type: "text"; text: string }[];
+	details: FormResult;
+} {
+	return {
+		content: [{ type: "text", text: message }],
+		details: { questions: [], answers: [], cancelled: true },
+	};
+}
+
+export function formatResultContent(result: FormResult): string {
+	return result.answers
+		.map((answer) => {
+			const question = result.questions.find((candidate) => candidate.id === answer.id);
+			const label = question?.label || answer.id;
+			if (answer.type === "radio") {
+				const prefix = answer.wasCustom ? "(wrote) " : "";
+				return `${label}: ${prefix}${answer.value}`;
+			}
+			if (answer.type === "checkbox") {
+				const values = Array.isArray(answer.value) ? answer.value : [answer.value];
+				return values.length === 0 ? `${label}: (none selected)` : `${label}: ${values.join(", ")}`;
+			}
+			return `${label}: ${answer.value || "(empty)"}`;
+		})
+		.join("\n");
+}
+
+export function buildRenderCallText(args: { questions?: Question[]; title?: string }, theme: RenderTheme): string {
+	const questions = args.questions || [];
+	let text = theme.fg("toolTitle", theme.bold("ask_user_question "));
+	if (args.title) {
+		text += `${theme.fg("accent", args.title)} `;
+	}
+	text += theme.fg("muted", `${questions.length} question${questions.length !== 1 ? "s" : ""}`);
+	const types = [...new Set(questions.map((question) => question.type))].join(", ");
+	if (types) {
+		text += theme.fg("dim", ` (${types})`);
+	}
+	return text;
+}
+
+export function buildRenderResultText(
+	result: { content?: Array<{ type: string; text?: string }>; details?: FormResult },
+	theme: RenderTheme,
+): string {
+	const details = result.details;
+	if (!details) {
+		const text = result.content?.[0];
+		return text?.type === "text" ? (text.text ?? "") : "";
+	}
+
+	if (details.cancelled) {
+		return theme.fg("warning", "Cancelled");
+	}
+
+	return details.answers
+		.map((answer) => {
+			const question = details.questions.find((candidate) => candidate.id === answer.id);
+			const label = question?.label || answer.id;
+			if (answer.type === "radio") {
+				const prefix = answer.wasCustom ? theme.fg("dim", "(wrote) ") : "";
+				return `${theme.fg("success", SYM.check)} ${theme.fg("accent", label)}: ${prefix}${answer.value}`;
+			}
+			if (answer.type === "checkbox") {
+				const values = Array.isArray(answer.value) ? answer.value : [answer.value];
+				const display = values.length ? values.join(", ") : theme.fg("dim", "(none)");
+				return `${theme.fg("success", SYM.check)} ${theme.fg("accent", label)}: ${display}`;
+			}
+			return `${theme.fg("success", SYM.check)} ${theme.fg("accent", label)}: ${answer.value || theme.fg("dim", "(empty)")}`;
+		})
+		.join("\n");
+}
+
+export function renderCall(args: { questions?: Question[]; title?: string }, theme: RenderTheme): Text {
+	return new Text(buildRenderCallText(args, theme), 0, 0);
+}
+
+export function renderResult(
+	result: { content?: Array<{ type: string; text?: string }>; details?: FormResult },
+	theme: RenderTheme,
+): Text {
+	return new Text(buildRenderResultText(result, theme), 0, 0);
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ryan_nookpi/pi-extension-ask-user-question",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "AskUserQuestion tool extension for pi.",
   "type": "module",
   "keywords": [
     "pi-package"
   ],
   "files": [
-    "index.ts",
+    "*.ts",
     "README.md"
   ],
   "pi": {

package/schema.ts

@@ -0,0 +1,37 @@
+import { StringEnum } from "@mariozechner/pi-ai";
+import { Type } from "@sinclair/typebox";
+
+export const OptionSchema = Type.Object({
+	value: Type.String({ description: "Value returned when selected" }),
+	label: Type.String({ description: "Display label" }),
+	description: Type.Optional(Type.String({ description: "Help text shown below the label" })),
+});
+
+export const QuestionSchema = Type.Object({
+	id: Type.String({ description: "Unique identifier for this question" }),
+	type: StringEnum(["radio", "checkbox", "text"] as const, {
+		description: "Question type: radio (single-select), checkbox (multi-select), or text (free input)",
+	}),
+	prompt: Type.String({ description: "The question text to display" }),
+	label: Type.Optional(Type.String({ description: "Short label for tab bar (defaults to Q1, Q2...)" })),
+	options: Type.Optional(Type.Array(OptionSchema, { description: "Options for radio/checkbox types" })),
+	allowOther: Type.Optional(
+		Type.Boolean({ description: "Add an 'Other...' option with text input (default: true for radio/checkbox)" }),
+	),
+	required: Type.Optional(Type.Boolean({ description: "Whether an answer is required (default: true)" })),
+	placeholder: Type.Optional(Type.String({ description: "Placeholder for text inputs" })),
+	default: Type.Optional(
+		Type.Union([Type.String(), Type.Array(Type.String())], {
+			description: "Default value(s). String for radio/text, string[] for checkbox",
+		}),
+	),
+});
+
+export const AskUserQuestionParams = Type.Object({
+	title: Type.Optional(Type.String({ description: "Form title displayed at the top" })),
+	description: Type.Optional(Type.String({ description: "Brief context or instructions shown under the title" })),
+	questions: Type.Array(QuestionSchema, {
+		description:
+			"One or more questions to ask. Use radio for single-select, checkbox for multi-select, text for free input",
+	}),
+});

package/state.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from "vitest";
+
+import {
+	allRequiredAnswered,
+	buildAnswers,
+	createAnswerState,
+	isAnswered,
+	normalizeQuestions,
+	optionCount,
+	saveOtherAnswer,
+	saveTextAnswer,
+} from "./state.ts";
+import type { Question } from "./types.ts";
+
+const baseQuestions: Question[] = [
+	{
+		id: "radio",
+		type: "radio",
+		prompt: "Pick one",
+		options: [
+			{ value: "a", label: "Alpha" },
+			{ value: "b", label: "Beta" },
+		],
+		default: "b",
+	},
+	{
+		id: "check",
+		type: "checkbox",
+		prompt: "Pick many",
+		options: [{ value: "a", label: "Alpha" }],
+		default: ["a", "a"],
+	},
+	{
+		id: "text",
+		type: "text",
+		prompt: "Tell me",
+		default: " hello ",
+		required: false,
+	},
+	{
+		id: "optional-radio",
+		type: "radio",
+		prompt: "Optional",
+		options: [{ value: "x", label: "X" }],
+		required: false,
+		allowOther: false,
+	},
+];
+
+describe("ask-user-question/state", () => {
+	it("normalizes questions and applies defaults", () => {
+		const questions = normalizeQuestions(baseQuestions);
+		const answerState = createAnswerState(questions);
+
+		expect(questions[0]).toMatchObject({ label: "Q1", allowOther: true, required: true });
+		expect(questions[2]).toMatchObject({ allowOther: false, required: false });
+		expect(questions[3]).toMatchObject({ label: "Q4", allowOther: false, required: false });
+		expect(answerState.radioAnswers.get("radio")).toEqual({ value: "b", label: "Beta", wasCustom: false });
+		expect(answerState.checkAnswers.get("check")).toEqual(new Set(["a"]));
+		expect(answerState.textAnswers.get("text")).toBe(" hello ");
+	});
+
+	it("ignores unmatched radio defaults and calculates option counts", () => {
+		const questions = normalizeQuestions([
+			{
+				id: "x",
+				type: "radio",
+				prompt: "Q",
+				options: [{ value: "a", label: "A" }],
+				default: "missing",
+				allowOther: false,
+			},
+			{ id: "y", type: "text", prompt: "Text" },
+		]);
+		const answerState = createAnswerState(questions);
+
+		expect(answerState.radioAnswers.has("x")).toBe(false);
+		expect(optionCount(questions[0])).toBe(1);
+		expect(optionCount(questions[1])).toBe(0);
+	});
+
+	it("tracks answered state and required completion", () => {
+		const questions = normalizeQuestions(baseQuestions);
+		const answerState = createAnswerState(questions);
+
+		expect(isAnswered(answerState, questions[0])).toBe(true);
+		expect(isAnswered(answerState, questions[1])).toBe(true);
+		expect(isAnswered(answerState, questions[2])).toBe(true);
+		expect(isAnswered(answerState, questions[3])).toBe(false);
+		expect(allRequiredAnswered(answerState, questions)).toBe(true);
+
+		saveTextAnswer(answerState, "text", "   ");
+		expect(isAnswered(answerState, questions[2])).toBe(false);
+		expect(allRequiredAnswered(answerState, questions)).toBe(true);
+	});
+
+	it("saves text answers and custom answers only when valid", () => {
+		const questions = normalizeQuestions(baseQuestions);
+		const answerState = createAnswerState(questions);
+
+		saveTextAnswer(answerState, "text", "  updated  ");
+		saveOtherAnswer(answerState, questions, "radio", "  custom radio  ");
+		saveOtherAnswer(answerState, questions, "check", "  custom check  ");
+		saveOtherAnswer(answerState, questions, "missing", "ignored");
+		saveOtherAnswer(answerState, questions, "text", "ignored");
+		saveOtherAnswer(answerState, questions, "check", "   ");
+
+		expect(answerState.textAnswers.get("text")).toBe("updated");
+		expect(answerState.radioAnswers.get("radio")).toEqual({
+			value: "custom radio",
+			label: "custom radio",
+			wasCustom: true,
+		});
+		expect(answerState.checkCustom.get("check")).toBe("custom check");
+	});
+
+	it("builds result answers for all question types", () => {
+		const questions = normalizeQuestions(baseQuestions);
+		const answerState = createAnswerState(questions);
+		saveOtherAnswer(answerState, questions, "radio", "custom radio");
+		saveOtherAnswer(answerState, questions, "check", "custom check");
+		saveTextAnswer(answerState, "text", "updated");
+
+		expect(buildAnswers(answerState, questions)).toEqual([
+			{ id: "radio", type: "radio", value: "custom radio", wasCustom: true },
+			{ id: "check", type: "checkbox", value: ["a", "custom check"], wasCustom: true },
+			{ id: "text", type: "text", value: "updated", wasCustom: true },
+			{ id: "optional-radio", type: "radio", value: "", wasCustom: false },
+		]);
+		const defaultState = createAnswerState(questions);
+		defaultState.checkAnswers.delete("check");
+		const defaultAnswers = buildAnswers(defaultState, questions);
+		expect(defaultAnswers[1]).toEqual({ id: "check", type: "checkbox", value: [], wasCustom: false });
+		expect(defaultAnswers[3]).toEqual({ id: "optional-radio", type: "radio", value: "", wasCustom: false });
+	});
+});

package/state.ts

@@ -0,0 +1,131 @@
+import type { Answer, AnswerState, NormalizedQuestion, Question } from "./types.ts";
+
+export function normalizeQuestions(questions: Question[]): NormalizedQuestion[] {
+	return questions.map((question, index) => ({
+		...question,
+		label: question.label || `Q${index + 1}`,
+		options: question.options || [],
+		allowOther: question.type === "text" ? false : question.allowOther !== false,
+		required: question.required !== false,
+	}));
+}
+
+export function createAnswerState(questions: NormalizedQuestion[]): AnswerState {
+	const answerState: AnswerState = {
+		radioAnswers: new Map(),
+		checkAnswers: new Map(),
+		checkCustom: new Map(),
+		textAnswers: new Map(),
+	};
+
+	for (const question of questions) {
+		if (question.type === "checkbox") {
+			const defaults = new Set<string>();
+			if (Array.isArray(question.default)) {
+				for (const value of question.default) defaults.add(value);
+			}
+			answerState.checkAnswers.set(question.id, defaults);
+			continue;
+		}
+
+		if (question.type === "text" && typeof question.default === "string") {
+			answerState.textAnswers.set(question.id, question.default);
+			continue;
+		}
+
+		if (question.type === "radio" && typeof question.default === "string") {
+			const option = question.options.find((candidate) => candidate.value === question.default);
+			if (option) {
+				answerState.radioAnswers.set(question.id, {
+					value: option.value,
+					label: option.label,
+					wasCustom: false,
+				});
+			}
+		}
+	}
+
+	return answerState;
+}
+
+export function optionCount(question: NormalizedQuestion): number {
+	if (question.type === "text") return 0;
+	return question.options.length + (question.allowOther ? 1 : 0);
+}
+
+export function saveTextAnswer(answerState: AnswerState, questionId: string, text: string): void {
+	const trimmed = text.trim();
+	if (trimmed) {
+		answerState.textAnswers.set(questionId, trimmed);
+		return;
+	}
+	answerState.textAnswers.delete(questionId);
+}
+
+export function saveOtherAnswer(
+	answerState: AnswerState,
+	questions: NormalizedQuestion[],
+	questionId: string,
+	text: string,
+): void {
+	const question = questions.find((candidate) => candidate.id === questionId);
+	const trimmed = text.trim();
+	if (!question || !trimmed) return;
+
+	if (question.type === "radio") {
+		answerState.radioAnswers.set(question.id, { value: trimmed, label: trimmed, wasCustom: true });
+		return;
+	}
+
+	if (question.type === "checkbox") {
+		answerState.checkCustom.set(question.id, trimmed);
+	}
+}
+
+export function isAnswered(answerState: AnswerState, question: NormalizedQuestion): boolean {
+	if (question.type === "radio") return answerState.radioAnswers.has(question.id);
+	if (question.type === "checkbox") {
+		const selected = answerState.checkAnswers.get(question.id);
+		const custom = answerState.checkCustom.get(question.id);
+		return (selected != null && selected.size > 0) || (custom != null && custom.trim().length > 0);
+	}
+	return (answerState.textAnswers.get(question.id)?.trim() ?? "").length > 0;
+}
+
+export function allRequiredAnswered(answerState: AnswerState, questions: NormalizedQuestion[]): boolean {
+	return questions.every((question) => !question.required || isAnswered(answerState, question));
+}
+
+export function buildAnswers(answerState: AnswerState, questions: NormalizedQuestion[]): Answer[] {
+	return questions.map((question) => {
+		if (question.type === "radio") {
+			const answer = answerState.radioAnswers.get(question.id);
+			return {
+				id: question.id,
+				type: "radio",
+				value: answer?.value ?? "",
+				wasCustom: answer?.wasCustom ?? false,
+			};
+		}
+
+		if (question.type === "checkbox") {
+			const selected = answerState.checkAnswers.get(question.id) ?? new Set<string>();
+			const custom = answerState.checkCustom.get(question.id)?.trim();
+			const values = [...selected];
+			if (custom) values.push(custom);
+			return {
+				id: question.id,
+				type: "checkbox",
+				value: values,
+				wasCustom: Boolean(custom),
+			};
+		}
+
+		return {
+			id: question.id,
+			type: "text",
+			value: answerState.textAnswers.get(question.id) ?? "",
+			wasCustom: true,
+		};
+	});
+}

package/types.ts

@@ -0,0 +1,85 @@
+export interface QuestionOption {
+	value: string;
+	label: string;
+	description?: string;
+}
+
+export interface Question {
+	id: string;
+	type: "radio" | "checkbox" | "text";
+	prompt: string;
+	label?: string;
+	options?: QuestionOption[];
+	allowOther?: boolean;
+	required?: boolean;
+	placeholder?: string;
+	default?: string | string[];
+}
+
+export interface AskUserQuestionParamsInput {
+	title?: string;
+	description?: string;
+	questions: Question[];
+}
+
+export interface NormalizedQuestion extends Question {
+	label: string;
+	options: QuestionOption[];
+	allowOther: boolean;
+	required: boolean;
+}
+
+export interface Answer {
+	id: string;
+	type: "radio" | "checkbox" | "text";
+	value: string | string[];
+	wasCustom: boolean;
+}
+
+export interface FormResult {
+	title?: string;
+	questions: NormalizedQuestion[];
+	answers: Answer[];
+	cancelled: boolean;
+}
+
+export interface RadioAnswer {
+	value: string;
+	label: string;
+	wasCustom: boolean;
+}
+
+export interface AnswerState {
+	radioAnswers: Map<string, RadioAnswer>;
+	checkAnswers: Map<string, Set<string>>;
+	checkCustom: Map<string, string>;
+	textAnswers: Map<string, string>;
+}
+
+export interface RenderTheme {
+	fg(color: string, text: string): string;
+	bg(color: string, text: string): string;
+	bold(text: string): string;
+}
+
+export interface EditorAdapter {
+	onSubmit?: (value: string) => void;
+	getText(): string;
+	setText(text: string): void;
+	handleInput(data: string): void;
+	render(width: number): string[];
+}
+
+export interface RenderFormInput {
+	title?: string;
+	description?: string;
+	questions: NormalizedQuestion[];
+	answerState: AnswerState;
+	currentTab: number;
+	cursorIdx: number;
+	otherMode: boolean;
+	width: number;
+	theme: RenderTheme;
+	editorLines: string[];
+	editorText: string;
+}