@selesai/code 0.1.19 → 0.2.1

package/dist/extensions/ponytail/test/helpers.test.js

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import {
+  filterSkillBodyForMode,
+  parsePonytailCommand,
+  readDefaultMode,
+  resolveSessionMode,
+  writeDefaultMode,
+} from "../index.js";
+
+test("parsePonytailCommand falls back to full when invoked bare and default is off", () => {
+  assert.deepEqual(parsePonytailCommand("", "off"), { type: "set-mode", mode: "full" });
+});
+
+test("parsePonytailCommand parses modes, status, and default subcommand", () => {
+  assert.deepEqual(parsePonytailCommand("ultra", "full"), { type: "set-mode", mode: "ultra" });
+  assert.deepEqual(parsePonytailCommand("status", "full"), { type: "status" });
+  assert.deepEqual(parsePonytailCommand("default lite", "full"), { type: "set-default", mode: "lite" });
+});
+
+test("resolveSessionMode prefers latest persisted session mode", () => {
+  const entries = [
+    { type: "custom", customType: "ponytail-mode", data: { mode: "lite" } },
+    { type: "custom", customType: "ponytail-mode", data: { mode: "ultra" } },
+  ];
+
+  assert.equal(resolveSessionMode(entries, "full"), "ultra");
+});
+
+test("resolveSessionMode returns fallback when entries is not an array", () => {
+  assert.equal(resolveSessionMode(null, "ultra"), "ultra");
+  assert.equal(resolveSessionMode(undefined, "lite"), "lite");
+  assert.equal(resolveSessionMode({}, "full"), "full");
+  assert.equal(resolveSessionMode("not an array"), "full"); // DEFAULT_MODE fallback
+});
+
+test("readDefaultMode and writeDefaultMode use XDG config path", () => {
+  const tempDir = mkdtempSync(join(tmpdir(), "ponytail-config-"));
+  const previousXdg = process.env.XDG_CONFIG_HOME;
+  const previousDefault = process.env.PONYTAIL_DEFAULT_MODE;
+  const configPath = join(tempDir, "ponytail", "config.json");
+  process.env.XDG_CONFIG_HOME = tempDir;
+  delete process.env.PONYTAIL_DEFAULT_MODE;
+
+  try {
+    assert.equal(readDefaultMode(), "full");
+    assert.equal(writeDefaultMode("ultra"), "ultra");
+    assert.equal(readDefaultMode(), "ultra");
+    assert.ok(existsSync(configPath));
+    assert.deepEqual(JSON.parse(readFileSync(configPath, "utf8")), { defaultMode: "ultra" });
+  } finally {
+    if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = previousXdg;
+    if (previousDefault === undefined) delete process.env.PONYTAIL_DEFAULT_MODE;
+    else process.env.PONYTAIL_DEFAULT_MODE = previousDefault;
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("filterSkillBodyForMode keeps only requested intensity examples and rows", () => {
+  const body = `---\nname: ponytail\n---\n| **lite** | keep lite |\n| **full** | keep full |\n| **ultra** | keep ultra |\n- lite: Lite example\n- full: Full example\n- ultra: Ultra example\nOther line`;
+
+  const filtered = filterSkillBodyForMode(body, "ultra");
+
+  assert.ok(!filtered.includes("keep lite"));
+  assert.ok(!filtered.includes("keep full"));
+  assert.ok(filtered.includes("keep ultra"));
+  assert.ok(!filtered.includes("Lite example"));
+  assert.ok(filtered.includes("Ultra example"));
+  assert.ok(filtered.includes("Other line"));
+});
+
+test("filterSkillBodyForMode keeps rule bullets that contain a colon", () => {
+  // Regression: rule bullets outside the Intensity section (e.g. the
+  // "No unrequested abstractions:" rule or the `ponytail:` comment convention)
+  // contain a colon and must not be mistaken for mode-example lines.
+  const skillPath = new URL("../../../skills/ponytail/SKILL.md", import.meta.url);
+  const body = readFileSync(skillPath, "utf8");
+
+  const filtered = filterSkillBodyForMode(body, "full");
+
+  assert.ok(filtered.includes("No unrequested abstractions"));
+  assert.ok(filtered.includes("Mark deliberate simplifications"));
+  // The Intensity examples are still filtered down to the active mode.
+  assert.ok(filtered.includes('full: "`@lru_cache'));
+  assert.ok(!filtered.includes('lite: "Done'));
+  assert.ok(!filtered.includes('ultra: "No cache'));
+});

package/dist/extensions/question/constants.ts

@@ -0,0 +1,38 @@
+// All constants for the question extension.
+
+import { Key } from "@earendil-works/pi-tui";
+import type { ResolvedShortcut } from "./types.ts";
+
+export const QUESTION_STATUS_KEY = "question";
+export const QUESTION_VERSION = "1";
+
+export const OVERLAY_MAX_HEIGHT_RATIO = 0.85;
+export const OVERLAY_WIDTH: `${number}%` = "92%";
+export const OVERLAY_OVERLAY_MAX_HEIGHT: `${number}%` = "85%";
+export const OVERLAY_MIN_WIDTH = 40;
+
+export const SPLIT_PANE_MIN_WIDTH = 84;
+export const SPLIT_PANE_LEFT_MIN_WIDTH = 32;
+export const SPLIT_PANE_RIGHT_MIN_WIDTH = 28;
+export const SPLIT_PANE_SEPARATOR = " │ ";
+
+export const FREEFORM_LABEL = "Type custom answer — enter a custom response";
+export const COMMENT_TOGGLE_LABEL = "Add extra context after selection";
+
+export const DEFAULT_OVERLAY_TOGGLE_KEY = "alt+o";
+export const DEFAULT_COMMENT_TOGGLE_KEY = "ctrl+g";
+
+export const BOX_BORDER_LEFT = "│ ";
+export const BOX_BORDER_RIGHT = " │";
+export const BOX_BORDER_OVERHEAD = BOX_BORDER_LEFT.length + BOX_BORDER_RIGHT.length;
+
+export const SHORTCUT_DISABLE_VALUES = new Set(["off", "none", "disabled", ""]);
+
+export const DISABLED_SHORTCUT: ResolvedShortcut = {
+	disabled: true,
+	spec: null,
+	matches: ((_data: string) => false) as (data: string) => false,
+};
+
+export const VIM_UP = Key.ctrl("k");
+export const VIM_DOWN = Key.ctrl("j");

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

@@ -0,0 +1,74 @@
+// Dialog/RPC fallback adapter — used when ctx.hasUI is false or custom() returns undefined.
+
+import {
+	buildCommentPrompt,
+	createFreeformResponse,
+	createSelectionResponse,
+	formatOptionsForMessage,
+	isCancelled,
+	parseDialogSelections,
+} from "./helpers.ts";
+import type { QuestionOption, QuestionResponse, ResolvedQuestionParams } from "./types.ts";
+import type { FallbackProtocol, UIProtocol } from "./ui-protocol.ts";
+
+const FREEFORM_DIALOG_OPTION = "✏️ Type custom response...";
+
+async function askViaDialogs(
+	ui: Pick<UIProtocol, "select" | "input">,
+	question: string,
+	context: string | undefined,
+	options: QuestionOption[],
+	allowMultiple: boolean,
+	allowFreeform: boolean,
+	allowComment: boolean,
+	timeout?: number,
+): Promise<QuestionResponse | null> {
+	const dialogOpts = timeout ? { timeout } : undefined;
+	const prompt = context ? `${question}\n\nContext:\n${context}` : question;
+
+	if (allowMultiple) {
+		const optionList = formatOptionsForMessage(options);
+		const raw = await ui.input(
+			`${prompt}\n\nOptions (select one or more):\n${optionList}`,
+			"Type your selection(s)...",
+			dialogOpts,
+		);
+		if (isCancelled(raw)) return null;
+		const selections = parseDialogSelections(raw);
+		if (selections.length === 0) return null;
+		if (!allowComment) return createSelectionResponse(selections);
+		const comment = await ui.input(buildCommentPrompt(prompt, selections), "Optional comment (press Enter to skip)...", dialogOpts);
+		return createSelectionResponse(selections, comment);
+	}
+
+	const selectOptions = options.map((o) => o.label);
+	if (allowFreeform) selectOptions.push(FREEFORM_DIALOG_OPTION);
+
+	const selected = await ui.select(prompt, selectOptions, dialogOpts);
+	if (isCancelled(selected)) return null;
+
+	if (selected === FREEFORM_DIALOG_OPTION) {
+		const answer = await ui.input(prompt, "Type your answer...", dialogOpts);
+		if (isCancelled(answer)) return null;
+		return createFreeformResponse(answer);
+	}
+
+	if (!allowComment) return createSelectionResponse([selected]);
+	const comment = await ui.input(buildCommentPrompt(prompt, [selected]), "Optional comment (press Enter to skip)...", dialogOpts);
+	return createSelectionResponse([selected], comment);
+}
+
+export const DialogFallback: FallbackProtocol = {
+	async ask(params, protocol) {
+		return askViaDialogs(
+			protocol,
+			params.question,
+			params.context,
+			params.options,
+			params.allowMultiple,
+			params.allowFreeform,
+			params.allowComment,
+			params.timeout,
+		);
+	},
+};

package/dist/extensions/question/helpers.ts

@@ -0,0 +1,102 @@
+// Pure helper functions for the question extension.
+
+import type { MarkdownTheme } from "@earendil-works/pi-coding-agent";
+
+import type { QuestionOption, QuestionResponse, RawOption } from "./types.ts";
+
+export function getOptionsFormatError(options: RawOption[] | undefined): string | null {
+	for (const option of options ?? []) {
+		if (typeof option !== "string") continue;
+		const text = option.trim();
+		if (!text.startsWith("[") && !text.startsWith("{")) continue;
+		try {
+			const parsed = JSON.parse(text);
+			const jsonOption = (value: unknown) => !!value && typeof value === "object" && typeof (value as { label?: unknown }).label === "string";
+			if (jsonOption(parsed) || (Array.isArray(parsed) && parsed.some(jsonOption))) {
+				return 'Invalid question.options: pass an array of strings or {label, description} objects, not a JSON-encoded string. Example: {"options":[{"label":"Yes","description":"..."}]}, not {"options":["[{\\"label\\":\\"Yes\\"}]"]}.';
+			}
+		} catch {}
+	}
+	return null;
+}
+
+export function normalizeOptions(options: RawOption[] | undefined): QuestionOption[] {
+	return (options ?? [])
+		.map((option) =>
+			typeof option === "string"
+				? { label: option }
+				: { label: option.label, description: option.description },
+		)
+		.filter((option) => option.label.trim().length > 0);
+}
+
+export function oneLine(value: unknown, max = 100): string {
+	const text = String(value ?? "").replace(/\s+/g, " ").trim();
+	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+// ponytail: lazy import avoids hard dependency on pi-coding-agent at module load
+// time (it may not be resolvable in dev/test environments). The function is
+// only called at runtime when the TUI is active.
+let _getMarkdownTheme: (() => MarkdownTheme) | null | undefined;
+export function safeMarkdownTheme(): MarkdownTheme | undefined {
+	try {
+		if (_getMarkdownTheme === undefined) {
+			// Dynamic require avoids breaking module load when package is absent.
+			_getMarkdownTheme = (globalThis as any).require
+				? (globalThis as any).require("@earendil-works/pi-coding-agent").getMarkdownTheme
+				: null;
+		}
+		if (!_getMarkdownTheme) return undefined;
+		const md = _getMarkdownTheme();
+		if (!md) return undefined;
+		md.bold("");
+		return md;
+	} catch {
+		return undefined;
+	}
+}
+
+export function createFreeformResponse(text: string | null | undefined): QuestionResponse | null {
+	const trimmed = text?.trim();
+	return trimmed ? { kind: "freeform", text: trimmed } : null;
+}
+
+export function createSelectionResponse(selections: string[], comment?: string | null): QuestionResponse | null {
+	const norm = selections.map((s) => s.trim()).filter(Boolean);
+	if (norm.length === 0) return null;
+	const c = comment?.trim();
+	return c ? { kind: "selection", selections: norm, comment: c } : { kind: "selection", selections: norm };
+}
+
+export function formatResponseSummary(response: QuestionResponse): string {
+	if (response.kind === "freeform") return response.text;
+	const selections = response.selections.join(", ");
+	return response.comment ? `${selections} — ${response.comment}` : selections;
+}
+
+export function formatOptionsForMessage(options: QuestionOption[]): string {
+	return options
+		.map((option, index) => {
+			const desc = option.description ? ` — ${option.description}` : "";
+			return `${index + 1}. ${option.label}${desc}`;
+		})
+		.join("\n");
+}
+
+export function buildCommentPrompt(prompt: string, selections: string[]): string {
+	const label = selections.length === 1 ? "Selected option" : "Selected options";
+	const lines = selections.map((selection) => `- ${selection}`).join("\n");
+	return `${prompt}\n\n${label}:\n${lines}`;
+}
+
+export function parseDialogSelections(input: string): string[] {
+	return input
+		.split(",")
+		.map((selection) => selection.trim())
+		.filter(Boolean);
+}
+
+export function isCancelled(value: unknown): value is null | undefined {
+	return value === null || value === undefined;
+}