@selesai/code 0.8.5 → 0.8.7

package/dist/extensions/question/tests/batch.test.ts

@@ -1,75 +1,113 @@
-import test from "node:test";
-import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
 
 import { buildQuestionAnswers, prepareQuestions, saveDraftQuestion } from "../batch.ts";
 import type { DraftQuestionState } from "../types.ts";
 
-test("prepareQuestions: normalizes typed questions and generated ids", () => {
-	const result = prepareQuestions([
-		{ type: "select", question: "Pick a color", options: [{ value: "red", label: "Red" }, { value: "blue", label: "Blue" }] },
-		{ type: "text", id: "notes", label: "Notes", question: "Anything else?" },
-	]);
-	assert.ok("questions" in result);
-	if (!("questions" in result)) return;
-	assert.deepEqual(result.questions, [
-		{
-			id: "q1",
-			label: "Q1",
-			question: "Pick a color",
-			context: undefined,
+describe("question batch helpers", () => {
+	it("prepareQuestions: normalizes typed questions and generated ids", () => {
+		const result = prepareQuestions([
+			{ type: "select", question: "Pick a color", options: [{ value: "red", label: "Red" }, { value: "blue", label: "Blue" }] },
+			{ type: "text", id: "notes", label: "Notes", question: "Anything else?" },
+		]);
+		expect("questions" in result).toBe(true);
+		if (!("questions" in result)) return;
+		expect(result.questions).toEqual([
+			{
+				id: "q1",
+				label: "Q1",
+				question: "Pick a color",
+				context: undefined,
+				type: "select",
+				options: [
+					{ value: "red", label: "Red", description: undefined },
+					{ value: "blue", label: "Blue", description: undefined },
+				],
+				allowOther: false,
+			},
+			{
+				id: "notes",
+				label: "Notes",
+				question: "Anything else?",
+				context: undefined,
+				type: "text",
+				options: [],
+				allowOther: false,
+			},
+		]);
+	});
+
+	it("prepareQuestions: rejects empty batches, generated-id collisions, and duplicate option values", () => {
+		expect(prepareQuestions([])).toEqual({ error: "questions must contain at least one question." });
+		expect((prepareQuestions([
+			{ type: "text", id: "q2", question: "One" },
+			{ type: "text", question: "Two" },
+		]) as { error: string }).error).toMatch(/duplicate id: q2/);
+		expect((prepareQuestions([{
 			type: "select",
-			options: [
-				{ value: "red", label: "Red", description: undefined },
-				{ value: "blue", label: "Blue", description: undefined },
-			],
-			allowOther: false,
-		},
-		{
-			id: "notes",
-			label: "Notes",
-			question: "Anything else?",
-			context: undefined,
-			type: "text",
-			options: [],
+			question: "Choose",
+			options: [{ value: "same", label: "A" }, { value: "same", label: "B" }],
+		}]) as { error: string }).error).toMatch(/duplicate value: same/);
+	});
+
+	it("prepareQuestions: rejects missing question, bad type, empty options, and bad option fields", () => {
+		expect((prepareQuestions([{ type: "text" }]) as { error: string }).error).toMatch(/non-empty question/);
+		expect((prepareQuestions([{ type: "radio", question: "X", options: [{ value: "a", label: "A" }] }]) as { error: string }).error).toMatch(/type must be select, multiselect, or text/);
+		expect((prepareQuestions([{ type: "select", question: "X", options: [] }]) as { error: string }).error).toMatch(/at least one option/);
+		expect((prepareQuestions([{ type: "select", question: "X", options: [{ value: "", label: "A" }] }]) as { error: string }).error).toMatch(/value and label must be non-empty/);
+		expect((prepareQuestions([{ type: "select", question: "X", options: [{ value: "a", label: "" }] }]) as { error: string }).error).toMatch(/value and label must be non-empty/);
+	});
+
+	it("prepareQuestions: trims id/label/context and defaults allowOther", () => {
+		const result = prepareQuestions([
+			{ type: "multiselect", id: "  m1  ", label: "  Multi  ", question: "  Pick many  ", context: "  ctx  ", options: [{ value: "a", label: "A", description: "  desc  " }] },
+		]);
+		expect("questions" in result).toBe(true);
+		if (!("questions" in result)) return;
+		expect(result.questions[0]).toEqual({
+			id: "m1",
+			label: "Multi",
+			question: "Pick many",
+			context: "ctx",
+			type: "multiselect",
+			options: [{ value: "a", label: "A", description: "desc" }],
 			allowOther: false,
-		},
-	]);
-});
+		});
+	});
 
-test("prepareQuestions: rejects empty batches, generated-id collisions, and duplicate option values", () => {
-	assert.deepEqual(prepareQuestions([]), { error: "questions must contain at least one question." });
-	assert.match((prepareQuestions([
-		{ type: "text", id: "q2", question: "One" },
-		{ type: "text", question: "Two" },
-	]) as { error: string }).error, /duplicate id: q2/);
-	assert.match((prepareQuestions([{
-		type: "select",
-		question: "Choose",
-		options: [{ value: "same", label: "A" }, { value: "same", label: "B" }],
-	}]) as { error: string }).error, /duplicate value: same/);
-});
+	it("saveDraftQuestion: clearing an answer while navigating back leaves it unanswered", () => {
+		const states = new Map<string, DraftQuestionState>([["q1", { status: "answered", response: { kind: "text", text: "old" } }]]);
+		saveDraftQuestion(states, "q1", null, false);
+		expect(states.has("q1")).toBe(false);
+	});
 
-test("saveDraftQuestion: clearing an answer while navigating back leaves it unanswered", () => {
-	const states = new Map<string, DraftQuestionState>([["q1", { status: "answered", response: { kind: "text", text: "old" } }]]);
-	saveDraftQuestion(states, "q1", null, false);
-	assert.equal(states.has("q1"), false);
-});
+	it("saveDraftQuestion: blank answer with markBlankSkipped marks skipped", () => {
+		const states = new Map<string, DraftQuestionState>();
+		saveDraftQuestion(states, "q1", null, true);
+		expect(states.get("q1")).toEqual({ status: "skipped" });
+	});
+
+	it("saveDraftQuestion: response marks answered", () => {
+		const states = new Map<string, DraftQuestionState>();
+		saveDraftQuestion(states, "q1", { kind: "text", text: "answer" }, true);
+		expect(states.get("q1")).toEqual({ status: "answered", response: { kind: "text", text: "answer" } });
+	});
 
-test("buildQuestionAnswers: preserves answered, skipped, and unvisited states", () => {
-	const prepared = prepareQuestions([
-		{ type: "text", id: "a", question: "A" },
-		{ type: "text", id: "b", question: "B" },
-		{ type: "text", id: "c", question: "C" },
-	]);
-	assert.ok("questions" in prepared);
-	if (!("questions" in prepared)) return;
-	const states = new Map<string, DraftQuestionState>([
-		["a", { status: "answered", response: { kind: "text", text: "answer" } }],
-		["b", { status: "skipped" }],
-	]);
-	assert.deepEqual(buildQuestionAnswers(prepared.questions, states), [
-		{ id: "a", status: "answered", response: { kind: "text", text: "answer" } },
-		{ id: "b", status: "skipped" },
-		{ id: "c", status: "unanswered" },
-	]);
+	it("buildQuestionAnswers: preserves answered, skipped, and unvisited states", () => {
+		const prepared = prepareQuestions([
+			{ type: "text", id: "a", question: "A" },
+			{ type: "text", id: "b", question: "B" },
+			{ type: "text", id: "c", question: "C" },
+		]);
+		expect("questions" in prepared).toBe(true);
+		if (!("questions" in prepared)) return;
+		const states = new Map<string, DraftQuestionState>([
+			["a", { status: "answered", response: { kind: "text", text: "answer" } }],
+			["b", { status: "skipped" }],
+		]);
+		expect(buildQuestionAnswers(prepared.questions, states)).toEqual([
+			{ id: "a", status: "answered", response: { kind: "text", text: "answer" } },
+			{ id: "b", status: "skipped" },
+			{ id: "c", status: "unanswered" },
+		]);
+	});
 });

package/dist/extensions/question/tests/exp.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+
+import questionExtension from "../index.ts";
+
+const theme = {
+	fg: (_name: string, value: string) => value,
+	bg: (_name: string, value: string) => value,
+	bold: (value: string) => value,
+};
+const tui = { requestRender() {}, terminal: { rows: 24 } };
+const keybindings = {
+	matches: (data: string, action: string) =>
+		(data === "\r" && action === "tui.select.confirm") ||
+		(data === "\x1b" && action === "tui.select.cancel"),
+	getKeys: () => ["Enter"],
+};
+
+async function runWizard(params: unknown) {
+	let tool: any;
+	let component: any;
+	let done!: (value: unknown) => void;
+	questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+	const execution = tool.execute("call", params, undefined, undefined, {
+		mode: "tui",
+		ui: {
+			custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => {
+				done = resolve;
+				component = factory(tui, theme, keybindings, done);
+			}),
+		},
+	} as any);
+	return { component: () => component, execution };
+}
+
+describe("exp", () => {
+	it("text question focused=false", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		component().focused = false;
+		component().focused = true;
+		component().focused = false;
+		component().handleInput("x");
+		component().handleInput("\r");
+		await execution;
+		expect(true).toBe(true);
+	});
+
+	it("multiselect empty confirm", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "multiselect", question: "Pick", options: [{ value: "a", label: "A" }] }],
+		});
+		component().handleInput("\r"); // empty confirm → no commit
+		component().handleInput(" ");
+		component().handleInput("\r"); // now commits
+		await execution;
+		expect(true).toBe(true);
+	});
+
+	it("text empty submit", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		component().handleInput("\r"); // empty submit → no commit
+		component().handleInput("a");
+		component().handleInput("\r");
+		await execution;
+		expect(true).toBe(true);
+	});
+});

package/dist/extensions/question/tests/exp2.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+
+import questionExtension from "../index.ts";
+
+const theme = {
+	fg: (_name: string, value: string) => value,
+	bg: (_name: string, value: string) => value,
+	bold: (value: string) => value,
+};
+const tui = { requestRender() {}, terminal: { rows: 24 } };
+const keybindings = {
+	matches: (data: string, action: string) =>
+		(data === "\r" && action === "tui.select.confirm") ||
+		(data === "\x1b" && action === "tui.select.cancel"),
+	getKeys: () => ["Enter"],
+};
+
+async function runWizard(params: unknown) {
+	let tool: any;
+	let component: any;
+	let done!: (value: unknown) => void;
+	questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+	const execution = tool.execute("call", params, undefined, undefined, {
+		mode: "tui",
+		ui: {
+			custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => {
+				done = resolve;
+				component = factory(tui, theme, keybindings, done);
+			}),
+		},
+	} as any);
+	return { component: () => component, execution };
+}
+
+describe("exp2", () => {
+	it("text question construction only", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		component().render(120);
+		component().handleInput("a");
+		component().handleInput("\r");
+		await execution;
+		expect(true).toBe(true);
+	});
+
+	it("blur then non-enter key", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		component().handleInput("\x1b"); // blur
+		component().handleInput("x"); // non-enter while blurred
+		component().handleInput("\r"); // re-focus
+		component().handleInput("a");
+		component().handleInput("\r");
+		await execution;
+		expect(true).toBe(true);
+	});
+});

package/dist/extensions/question/tests/exp3.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+
+import questionExtension from "../index.ts";
+
+const theme = {
+	fg: (_name: string, value: string) => value,
+	bg: (_name: string, value: string) => value,
+	bold: (value: string) => value,
+};
+const tui = { requestRender() {}, terminal: { rows: 24 } };
+const keybindings = {
+	matches: (data: string, action: string) =>
+		(data === "\r" && action === "tui.select.confirm") ||
+		(data === "\x1b" && action === "tui.select.cancel"),
+	getKeys: () => ["Enter"],
+};
+
+async function runWizard(params: unknown) {
+	let tool: any;
+	let component: any;
+	let done!: (value: unknown) => void;
+	questionExtension({ registerTool: (entry: unknown) => (tool = entry), events: { emit() {} } } as any);
+	const execution = tool.execute("call", params, undefined, undefined, {
+		mode: "tui",
+		ui: {
+			custom: (factory: (...args: any[]) => unknown) => new Promise((resolve) => {
+				done = resolve;
+				component = factory(tui, theme, keybindings, done);
+			}),
+		},
+	} as any);
+	return { component: () => component, execution };
+}
+
+describe("exp3", () => {
+	it("focused true then false on text", async () => {
+		const { component, execution } = await runWizard({
+			questions: [{ type: "text", question: "Type" }],
+		});
+		component().focused = true; // editor.focused = true && true
+		component().focused = false; // editor.focused = false && true
+		component().handleInput("a");
+		component().handleInput("\r");
+		await execution;
+		expect(true).toBe(true);
+	});
+});

package/dist/extensions/question/tests/helpers.test.ts

@@ -1,53 +1,93 @@
-import test from "node:test";
-import assert from "node:assert/strict";
+import { describe, expect, it } from "vitest";
 
 import {
 	createSelectionResponse,
 	createTextResponse,
 	formatQuestionResponse,
 	formatResponseSummary,
+	formatOptionsForMessage,
 	oneLine,
 	previewText,
+	trimText,
 } from "../helpers.ts";
 import type { PreparedQuestion } from "../types.ts";
 
-test("createTextResponse trims edges and rejects blank text", () => {
-	assert.equal(createTextResponse("  "), null);
-	assert.deepEqual(createTextResponse("  hello\nworld  "), { kind: "text", text: "hello\nworld" });
-});
+describe("question helpers", () => {
+	it("trimText trims and returns undefined for blank", () => {
+		expect(trimText("  ")).toBeUndefined();
+		expect(trimText(undefined)).toBeUndefined();
+		expect(trimText(null)).toBeUndefined();
+		expect(trimText("  hello  ")).toBe("hello");
+	});
 
-test("createSelectionResponse supports values plus Other and rejects empty", () => {
-	assert.equal(createSelectionResponse([], "  "), null);
-	assert.deepEqual(createSelectionResponse([" a ", "b"], " other "), {
-		kind: "selection",
-		values: ["a", "b"],
-		otherText: "other",
+	it("createTextResponse trims edges and rejects blank text", () => {
+		expect(createTextResponse("  ")).toBeNull();
+		expect(createTextResponse(undefined)).toBeNull();
+		expect(createTextResponse("  hello\nworld  ")).toEqual({ kind: "text", text: "hello\nworld" });
 	});
-});
 
-test("formatResponseSummary returns machine values", () => {
-	assert.equal(formatResponseSummary({ kind: "selection", values: ["a", "b"], otherText: "c" }), "a, b, c");
-	assert.equal(formatResponseSummary({ kind: "text", text: "hello" }), "hello");
-});
+	it("createSelectionResponse supports values plus Other and rejects empty", () => {
+		expect(createSelectionResponse([], "  ")).toBeNull();
+		expect(createSelectionResponse([], undefined)).toBeNull();
+		expect(createSelectionResponse([" a ", "b"], " other ")).toEqual({
+			kind: "selection",
+			values: ["a", "b"],
+			otherText: "other",
+		});
+		expect(createSelectionResponse(["a"], undefined)).toEqual({ kind: "selection", values: ["a"] });
+	});
 
-test("formatQuestionResponse maps stable values to labels", () => {
-	const question: PreparedQuestion = {
-		id: "q1",
-		label: "Q1",
-		question: "Pick",
-		type: "multiselect",
-		options: [{ value: "a", label: "Alpha" }, { value: "b", label: "Beta" }],
-		allowOther: true,
-	};
-	assert.equal(formatQuestionResponse(question, { kind: "selection", values: ["b"], otherText: "Gamma" }), "Beta, Other: Gamma");
-});
+	it("formatResponseSummary returns machine values", () => {
+		expect(formatResponseSummary({ kind: "selection", values: ["a", "b"], otherText: "c" })).toBe("a, b, c");
+		expect(formatResponseSummary({ kind: "selection", values: ["a"] })).toBe("a");
+		expect(formatResponseSummary({ kind: "text", text: "hello" })).toBe("hello");
+	});
 
-test("previewText bounds multiline summaries", () => {
-	assert.equal(previewText("one\ntwo\nthree", 160, 2), "one\ntwo…");
-	assert.equal(previewText("a".repeat(200), 10, 2), `${"a".repeat(9)}…`);
-});
+	it("formatQuestionResponse maps stable values to labels", () => {
+		const question: PreparedQuestion = {
+			id: "q1",
+			label: "Q1",
+			question: "Pick",
+			type: "multiselect",
+			options: [{ value: "a", label: "Alpha" }, { value: "b", label: "Beta" }],
+			allowOther: true,
+		};
+		expect(formatQuestionResponse(question, { kind: "selection", values: ["b"], otherText: "Gamma" })).toBe("Beta, Other: Gamma");
+		expect(formatQuestionResponse(question, { kind: "selection", values: ["unknown"] })).toBe("unknown");
+		expect(formatQuestionResponse(question, { kind: "text", text: "plain" })).toBe("plain");
+	});
 
-test("oneLine collapses whitespace and truncates", () => {
-	assert.equal(oneLine("  hello   world  "), "hello world");
-	assert.equal(oneLine("a".repeat(20), 10), `${"a".repeat(9)}…`);
+	it("formatOptionsForMessage numbers options with descriptions", () => {
+		expect(formatOptionsForMessage([
+			{ value: "a", label: "Alpha" },
+			{ value: "b", label: "Beta", description: "the beta" },
+		])).toBe("1. Alpha\n2. Beta — the beta");
+	});
+
+	it("previewText bounds multiline summaries", () => {
+		expect(previewText("one\ntwo\nthree", 160, 2)).toBe("one\ntwo…");
+		expect(previewText("a".repeat(200), 10, 2)).toBe(`${"a".repeat(9)}…`);
+		expect(previewText("short", 160, 2)).toBe("short");
+		expect(previewText("", 160, 2)).toBe("");
+	});
+
+	it("oneLine collapses whitespace and truncates", () => {
+		expect(oneLine("  hello   world  ")).toBe("hello world");
+		expect(oneLine("a".repeat(20), 10)).toBe(`${"a".repeat(9)}…`);
+		expect(oneLine(undefined)).toBe("");
+		expect(oneLine(42)).toBe("42");
+	});
+
+	it("previewText handles single-line and exact-boundary text", () => {
+		expect(previewText("one line", 160, 2)).toBe("one line");
+		expect(previewText("a".repeat(10), 10, 2)).toBe("a".repeat(10));
+		expect(previewText("a".repeat(11), 10, 2)).toBe(`${"a".repeat(9)}…`);
+	});
+
+	it("previewText handles nullish values", () => {
+		expect(previewText(null)).toBe("");
+		expect(previewText(undefined)).toBe("");
+		expect(previewText(null, 10, 1)).toBe("");
+		expect(previewText(undefined, 10, 1)).toBe("");
+	});
 });