@selesai/code 0.1.19 → 0.2.1

package/dist/extensions/question/tests/row-layout.test.ts

@@ -0,0 +1,136 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { wrapPlain, buildItemBlocks, flattenBlocks, renderSingleSelectRows } from "../row-layout.ts";
+import type { ItemBlock, QuestionOption } from "../types.ts";
+
+const opts = (labels: string[]): QuestionOption[] => labels.map((label) => ({ label }));
+
+test("wrapPlain: empty → ['']", () => {
+	assert.deepEqual(wrapPlain("", 20), [""]);
+	assert.deepEqual(wrapPlain("   ", 20), [""]);
+});
+
+test("wrapPlain: single word fits", () => {
+	assert.deepEqual(wrapPlain("hello", 20), ["hello"]);
+});
+
+test("wrapPlain: word longer than width → chunked", () => {
+	assert.deepEqual(wrapPlain("abcdefgh", 3), ["abc", "def", "gh"]);
+});
+
+test("wrapPlain: multiple words wrapping", () => {
+	assert.deepEqual(wrapPlain("hello world foo", 7), ["hello", "world", "foo"]);
+	assert.deepEqual(wrapPlain("hello world foo", 11), ["hello world", "foo"]);
+});
+
+test("wrapPlain: width=1 → char-by-char", () => {
+	assert.deepEqual(wrapPlain("abc", 1), ["a", "b", "c"]);
+});
+
+test("buildItemBlocks: 3 options, selected=0 → arrow on block 0", () => {
+	const blocks = buildItemBlocks(opts(["a", "b", "c"]), 80, false, false, false, 0);
+	assert.equal(blocks.length, 3);
+	assert.equal(blocks[0]!.itemIndex, 0);
+	assert.ok(blocks[0]!.lines[0]!.startsWith("→"));
+	assert.ok(blocks[0]!.lines[0]!.includes("1. a"));
+	assert.ok(blocks[1]!.lines[0]!.startsWith(" "));
+});
+
+test("buildItemBlocks: selected=1 → arrow pointer on block 1", () => {
+	const blocks = buildItemBlocks(opts(["a", "b", "c"]), 80, false, false, false, 1);
+	assert.ok(blocks[1]!.lines[0]!.startsWith("→"));
+	assert.ok(blocks[0]!.lines[0]!.startsWith(" "));
+});
+
+test("buildItemBlocks: with description → description lines included", () => {
+	const blocks = buildItemBlocks(
+		[{ label: "a", description: "some desc" }],
+		80,
+		false,
+		false,
+		false,
+		0,
+	);
+	assert.ok(blocks[0]!.lines.length > 1);
+	assert.ok(blocks[0]!.lines.some((l) => l.includes("some desc")));
+});
+
+test("buildItemBlocks: hideDescriptions=true → no description lines", () => {
+	const blocks = buildItemBlocks(
+		[{ label: "a", description: "some desc" }],
+		80,
+		false,
+		false,
+		false,
+		0,
+		true,
+	);
+	// Only the title line, no description
+	assert.equal(blocks[0]!.lines.length, 1);
+});
+
+test("buildItemBlocks: allowFreeform → freeform block appended", () => {
+	const blocks = buildItemBlocks(opts(["a"]), 80, true, false, false, 0);
+	assert.equal(blocks.length, 2);
+	assert.ok(blocks[1]!.lines[0]!.includes("Type custom answer"));
+});
+
+test("buildItemBlocks: allowComment → comment-toggle block appended", () => {
+	const blocks = buildItemBlocks(opts(["a"]), 80, false, true, false, 0);
+	assert.equal(blocks.length, 2);
+	assert.ok(blocks[1]!.lines[0]!.includes("[ ]"));
+	assert.ok(blocks[1]!.lines[0]!.includes("Add extra context"));
+});
+
+test("buildItemBlocks: allowComment + commentEnabled → [✓]", () => {
+	const blocks = buildItemBlocks(opts(["a"]), 80, false, true, true, 0);
+	assert.ok(blocks[1]!.lines[0]!.includes("[✓]"));
+});
+
+test("flattenBlocks: correct selected flags", () => {
+	const blocks: ItemBlock[] = [
+		{ itemIndex: 0, lines: ["a", "b"] },
+		{ itemIndex: 1, lines: ["c"] },
+	];
+	const rows = flattenBlocks(blocks, 1);
+	assert.equal(rows.length, 3);
+	assert.equal(rows[0]!.selected, false);
+	assert.equal(rows[1]!.selected, false);
+	assert.equal(rows[2]!.selected, true);
+});
+
+test("renderSingleSelectRows: few rows, all visible", () => {
+	const rows = renderSingleSelectRows({
+		options: opts(["a", "b"]),
+		selectedIndex: 0,
+		width: 80,
+		allowFreeform: false,
+	});
+	assert.equal(rows.length, 2);
+});
+
+test("renderSingleSelectRows: maxRows truncation with indicator", () => {
+	const rows = renderSingleSelectRows({
+		options: opts(["a", "b", "c", "c", "e", "f", "g", "h"]),
+		selectedIndex: 0,
+		width: 80,
+		allowFreeform: false,
+		maxRows: 3,
+	});
+	assert.ok(rows.length <= 3);
+	// Last row should be the indicator
+	assert.ok(rows[rows.length - 1]!.line.includes("("));
+});
+
+test("renderSingleSelectRows: selected block larger than available → only selected + indicator", () => {
+	const rows = renderSingleSelectRows({
+		options: [{ label: "a".repeat(100) }],
+		selectedIndex: 0,
+		width: 10,
+		allowFreeform: false,
+		maxRows: 3,
+	});
+	assert.ok(rows.length <= 3);
+	assert.ok(rows.every((r) => r.selected || r.line.includes("(")));
+});

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

@@ -0,0 +1,85 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { normalizeShortcutSpec, isValidShortcutSpec, resolveShortcut } from "../shortcuts.ts";
+import { DISABLED_SHORTCUT } from "../constants.ts";
+
+test("normalizeShortcutSpec: undefined → undefined", () => {
+	assert.equal(normalizeShortcutSpec(undefined), undefined);
+});
+
+test("normalizeShortcutSpec: null → null", () => {
+	assert.equal(normalizeShortcutSpec(null), null);
+});
+
+test("normalizeShortcutSpec: disable values → null", () => {
+	assert.equal(normalizeShortcutSpec("off"), null);
+	assert.equal(normalizeShortcutSpec("none"), null);
+	assert.equal(normalizeShortcutSpec("disabled"), null);
+	assert.equal(normalizeShortcutSpec(""), null);
+	assert.equal(normalizeShortcutSpec("  off  "), null);
+});
+
+test("normalizeShortcutSpec: normalizes case and trims", () => {
+	assert.equal(normalizeShortcutSpec("Alt+O"), "alt+o");
+	assert.equal(normalizeShortcutSpec("  Ctrl+G  "), "ctrl+g");
+});
+
+test("isValidShortcutSpec: empty → false", () => {
+	assert.equal(isValidShortcutSpec(""), false);
+	assert.equal(isValidShortcutSpec(" "), false);
+});
+
+test("isValidShortcutSpec: valid specs", () => {
+	assert.equal(isValidShortcutSpec("alt+o"), true);
+	assert.equal(isValidShortcutSpec("ctrl+g"), true);
+	assert.equal(isValidShortcutSpec("shift+f1"), true);
+});
+
+test("isValidShortcutSpec: leading/trailing + → false", () => {
+	assert.equal(isValidShortcutSpec("+o"), false);
+	assert.equal(isValidShortcutSpec("o+"), false);
+});
+
+test("isValidShortcutSpec: double + → false", () => {
+	assert.equal(isValidShortcutSpec("alt++o"), false);
+});
+
+test("resolveShortcut: uses param when valid", () => {
+	const result = resolveShortcut("alt+o", undefined, "alt+o");
+	assert.equal(result.disabled, false);
+	assert.equal(result.spec, "alt+o");
+});
+
+test("resolveShortcut: param undefined, uses env", () => {
+	const result = resolveShortcut(undefined, "ctrl+x", "alt+o");
+	assert.equal(result.disabled, false);
+	assert.equal(result.spec, "ctrl+x");
+});
+
+test("resolveShortcut: param null → disabled", () => {
+	const result = resolveShortcut(null, "ctrl+x", "alt+o");
+	assert.equal(result, DISABLED_SHORTCUT);
+});
+
+test("resolveShortcut: param undefined, env undefined, uses default", () => {
+	const result = resolveShortcut(undefined, undefined, "alt+o");
+	assert.equal(result.disabled, false);
+	assert.equal(result.spec, "alt+o");
+});
+
+test("resolveShortcut: param 'off' → disabled", () => {
+	const result = resolveShortcut("off", "ctrl+x", "alt+o");
+	assert.equal(result, DISABLED_SHORTCUT);
+});
+
+test("resolveShortcut: invalid param falls through to env", () => {
+	const result = resolveShortcut("invalid++", "ctrl+x", "alt+o");
+	assert.equal(result.disabled, false);
+	assert.equal(result.spec, "ctrl+x");
+});
+
+test("resolveShortcut: all invalid → disabled", () => {
+	const result = resolveShortcut("invalid++", "also++", "default++");
+	assert.equal(result, DISABLED_SHORTCUT);
+});

package/dist/extensions/question/tests/ui-protocol.test.ts

@@ -0,0 +1,143 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { DialogFallback } from "../dialog-adapter.ts";
+import type { QuestionResponse, ResolvedQuestionParams } from "../types.ts";
+import type { UIProtocol } from "../ui-protocol.ts";
+
+// ---------------------------------------------------------------------------
+// Fake UIProtocol — queues return values, captures calls
+// ---------------------------------------------------------------------------
+
+function fakeProtocol(overrides: Partial<UIProtocol> = {}): UIProtocol {
+	const calls: { method: string; args: any[] }[] = [];
+	return {
+		hasUI: true,
+		theme: { fg: (_n: string, s: string) => s, bold: (s: string) => s } as any,
+		custom: async () => undefined,
+		select: async (prompt: string, options: string[], opts?: any) => {
+			calls.push({ method: "select", args: [prompt, options, opts] });
+			return overrides.select?.(prompt, options, opts);
+		},
+		input: async (prompt: string, placeholder?: string, opts?: any) => {
+			calls.push({ method: "input", args: [prompt, placeholder, opts] });
+			return overrides.input?.(prompt, placeholder, opts);
+		},
+		setStatus: () => {},
+		notify: () => {},
+		...overrides,
+	} as UIProtocol;
+}
+
+function makeParams(overrides: Partial<ResolvedQuestionParams> = {}): ResolvedQuestionParams {
+	return {
+		question: "Pick one",
+		context: undefined,
+		options: [{ label: "Option A" }, { label: "Option B" }],
+		allowMultiple: false,
+		allowFreeform: false,
+		allowComment: false,
+		displayMode: "overlay",
+		shortcuts: {
+			overlayToggle: { disabled: true, spec: null, matches: () => false },
+			commentToggle: { disabled: true, spec: null, matches: () => false },
+		},
+		timeout: undefined,
+		...overrides,
+	};
+}
+
+// ---------------------------------------------------------------------------
+// Single-select dialog fallback
+// ---------------------------------------------------------------------------
+
+test("DialogFallback: single-select returns selection", async () => {
+	const protocol = fakeProtocol({
+		select: async () => "Option A",
+	});
+	const result = await DialogFallback.ask(makeParams(), protocol);
+	assert.deepEqual(result, { kind: "selection", selections: ["Option A"] });
+});
+
+test("DialogFallback: single-select + comment", async () => {
+	const protocol = fakeProtocol({
+		select: async () => "Option A",
+		input: async () => "my note",
+	});
+	const result = await DialogFallback.ask(makeParams({ allowComment: true }), protocol);
+	assert.deepEqual(result, {
+		kind: "selection",
+		selections: ["Option A"],
+		comment: "my note",
+	});
+});
+
+test("DialogFallback: single-select cancel (select returns undefined)", async () => {
+	const protocol = fakeProtocol({
+		select: async () => undefined,
+	});
+	const result = await DialogFallback.ask(makeParams(), protocol);
+	assert.equal(result, null);
+});
+
+// ---------------------------------------------------------------------------
+// Multi-select dialog fallback
+// ---------------------------------------------------------------------------
+
+test("DialogFallback: multi-select returns selections from input", async () => {
+	const protocol = fakeProtocol({
+		input: async () => "Option A,Option B",
+	});
+	const result = await DialogFallback.ask(makeParams({ allowMultiple: true }), protocol);
+	assert.deepEqual(result, {
+		kind: "selection",
+		selections: ["Option A", "Option B"],
+	});
+});
+
+test("DialogFallback: multi-select + comment", async () => {
+	let inputCall = 0;
+	const protocol = fakeProtocol({
+		input: async () => {
+			inputCall++;
+			return inputCall === 1 ? "Option A" : "extra context";
+		},
+	});
+	const result = await DialogFallback.ask(makeParams({ allowMultiple: true, allowComment: true }), protocol);
+	assert.deepEqual(result, {
+		kind: "selection",
+		selections: ["Option A"],
+		comment: "extra context",
+	});
+});
+
+test("DialogFallback: multi-select cancel (input returns undefined)", async () => {
+	const protocol = fakeProtocol({
+		input: async () => undefined,
+	});
+	const result = await DialogFallback.ask(makeParams({ allowMultiple: true }), protocol);
+	assert.equal(result, null);
+});
+
+// ---------------------------------------------------------------------------
+// Freeform dialog fallback
+// ---------------------------------------------------------------------------
+
+test("DialogFallback: freeform via select 'custom' option", async () => {
+	let selectCall = 0;
+	const protocol = fakeProtocol({
+		select: async () => "✏️ Type custom response...",
+		input: async () => "my custom answer",
+	});
+	const result = await DialogFallback.ask(makeParams({ allowFreeform: true }), protocol);
+	assert.deepEqual(result, { kind: "freeform", text: "my custom answer" });
+});
+
+test("DialogFallback: freeform cancel (input returns undefined after selecting custom)", async () => {
+	const protocol = fakeProtocol({
+		select: async () => "✏️ Type custom response...",
+		input: async () => undefined,
+	});
+	const result = await DialogFallback.ask(makeParams({ allowFreeform: true }), protocol);
+	assert.equal(result, null);
+});

package/dist/extensions/question/tui-adapter.ts

@@ -0,0 +1,33 @@
+// TUI protocol adapter — wraps ctx.ui into UIProtocol.
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { OverlayHandle } from "@earendil-works/pi-tui";
+
+import { OVERLAY_MIN_WIDTH, OVERLAY_OVERLAY_MAX_HEIGHT, OVERLAY_WIDTH } from "./constants.ts";
+import type { DisplayMode, QuestionResponse } from "./types.ts";
+import type { CustomUIOptions, UIProtocol } from "./ui-protocol.ts";
+
+export function buildCustomUIOptions(
+	displayMode: DisplayMode,
+	onHandle?: (handle: OverlayHandle) => void,
+): CustomUIOptions | undefined {
+	if (displayMode === "inline") return undefined;
+	return {
+		overlay: true,
+		overlayOptions: { anchor: "center", width: OVERLAY_WIDTH, minWidth: OVERLAY_MIN_WIDTH, maxHeight: OVERLAY_OVERLAY_MAX_HEIGHT, margin: 1 },
+		...(onHandle ? { onHandle } : {}),
+	};
+}
+
+export function createTUIProtocol(ctx: ExtensionContext): UIProtocol {
+	return {
+		hasUI: ctx.hasUI,
+		theme: ctx.ui.theme,
+		custom: (factory, options) => ctx.ui.custom(factory as any, options as any) as Promise<QuestionResponse | null | undefined>,
+		select: (prompt, options, opts) => ctx.ui.select(prompt, options, opts),
+		input: (prompt, placeholder, opts) => ctx.ui.input(prompt, placeholder, opts),
+		onTerminalInput: typeof ctx.ui.onTerminalInput === "function" ? ctx.ui.onTerminalInput.bind(ctx.ui) : undefined,
+		setStatus: (key, text) => ctx.ui.setStatus(key, text),
+		notify: (msg, level) => ctx.ui.notify(msg, level),
+	};
+}

package/dist/extensions/question/types.ts

@@ -0,0 +1,102 @@
+// Shared type definitions for the question extension.
+
+import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
+
+export type RawOption = string | { label: string; description?: string };
+
+export interface QuestionOption {
+	label: string;
+	description?: string;
+}
+
+export type QuestionResponse =
+	| { kind: "selection"; selections: string[]; comment?: string }
+	| { kind: "freeform"; text: string };
+
+export interface QuestionDetails {
+	question: string;
+	context?: string;
+	options: QuestionOption[];
+	response: QuestionResponse | null;
+	cancelled: boolean;
+}
+
+export type DisplayMode = "overlay" | "inline";
+
+export interface QuestionParams {
+	question: string;
+	context?: string;
+	options?: RawOption[];
+	allowMultiple?: boolean;
+	allowFreeform?: boolean;
+	allowComment?: boolean;
+	displayMode?: DisplayMode;
+	overlayToggleKey?: string | null;
+	commentToggleKey?: string | null;
+	timeout?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Shortcut resolution
+// ---------------------------------------------------------------------------
+
+export type ResolvedShortcut =
+	| { disabled: false; spec: string; matches: (data: string) => boolean }
+	| { disabled: true; spec: null; matches: (data: string) => false };
+
+export interface ResolvedShortcuts {
+	overlayToggle: ResolvedShortcut;
+	commentToggle: ResolvedShortcut;
+}
+
+// ---------------------------------------------------------------------------
+// Single-select row layout
+// ---------------------------------------------------------------------------
+
+export interface AnnotatedRow {
+	line: string;
+	selected: boolean;
+}
+
+export interface ItemBlock {
+	itemIndex: number;
+	lines: string[];
+}
+
+export type ListItem =
+	| { type: "option"; option: QuestionOption }
+	| { type: "comment-toggle"; option: QuestionOption }
+	| { type: "freeform"; option: QuestionOption };
+
+export interface RenderRowsParams {
+	options: QuestionOption[];
+	selectedIndex: number;
+	width: number;
+	allowFreeform: boolean;
+	allowComment?: boolean;
+	commentEnabled?: boolean;
+	maxRows?: number;
+	hideDescriptions?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Question component
+// ---------------------------------------------------------------------------
+
+export type QuestionMode = "select" | "freeform" | "comment";
+
+// ---------------------------------------------------------------------------
+// UI protocol (port for TUI vs dialog/RPC)
+// ---------------------------------------------------------------------------
+
+export interface ResolvedQuestionParams {
+	question: string;
+	context: string | undefined;
+	options: QuestionOption[];
+	allowMultiple: boolean;
+	allowFreeform: boolean;
+	allowComment: boolean;
+	displayMode: DisplayMode;
+	shortcuts: ResolvedShortcuts;
+	timeout: number | undefined;
+}

package/dist/extensions/question/ui-protocol.ts

@@ -0,0 +1,46 @@
+// UIProtocol port — abstracts TUI vs dialog/RPC transport.
+
+import type { KeybindingsManager } from "@earendil-works/pi-coding-agent";
+import type { OverlayHandle, Theme, TUI } from "@earendil-works/pi-tui";
+
+import type { QuestionResponse, ResolvedQuestionParams } from "./types.ts";
+
+export interface CustomFactoryResult {
+	handleInput(data: string): void;
+	render(width: number): string[];
+	focused: boolean;
+}
+
+export type CustomFactory = (
+	tui: TUI,
+	theme: Theme,
+	keybindings: KeybindingsManager,
+	done: (result: QuestionResponse | null) => void,
+) => CustomFactoryResult;
+
+export interface CustomUIOptions {
+	overlay?: boolean;
+	overlayOptions?: {
+		anchor: string;
+		width: string;
+		minWidth: number;
+		maxHeight: string;
+		margin: number;
+	};
+	onHandle?: (handle: OverlayHandle) => void;
+}
+
+export interface UIProtocol {
+	readonly hasUI: boolean;
+	readonly theme: Theme;
+	custom(factory: CustomFactory, options?: CustomUIOptions): Promise<QuestionResponse | null | undefined>;
+	select(prompt: string, options: string[], opts?: { timeout?: number }): Promise<string | undefined>;
+	input(prompt: string, placeholder?: string, opts?: { timeout?: number }): Promise<string | undefined>;
+	onTerminalInput?(handler: (data: string) => { consume: boolean } | void): () => void;
+	setStatus(key: string, text: string): void;
+	notify(message: string, level: "info" | "warning" | "error"): void;
+}
+
+export interface FallbackProtocol {
+	ask(params: ResolvedQuestionParams, protocol: UIProtocol): Promise<QuestionResponse | null>;
+}