osdy-pi 1.4.0 → 1.5.0

package/extensions/osdy-pi/modal-frame.test.ts

@@ -0,0 +1,78 @@
+import assert from "node:assert/strict";
+import { existsSync, readFileSync } from "node:fs";
+import { registerHooks } from "node:module";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { visibleWidth } from "@earendil-works/pi-tui";
+import ts from "typescript";
+
+registerHooks({
+	resolve(specifier, context, nextResolve) {
+		if (
+			specifier.startsWith(".") &&
+			specifier.endsWith(".js") &&
+			context.parentURL?.endsWith(".ts")
+		) {
+			const sourceUrl = new URL(`${specifier.slice(0, -3)}.ts`, context.parentURL);
+			if (existsSync(fileURLToPath(sourceUrl))) {
+				return { shortCircuit: true, url: sourceUrl.href };
+			}
+		}
+		return nextResolve(specifier, context);
+	},
+	load(url, context, nextLoad) {
+		if (url.endsWith(".ts")) {
+			const source = readFileSync(fileURLToPath(url), "utf8");
+			return {
+				format: "module",
+				shortCircuit: true,
+				source: ts.transpileModule(source, {
+					compilerOptions: {
+						module: ts.ModuleKind.ESNext,
+						target: ts.ScriptTarget.ES2022,
+					},
+				}).outputText,
+			};
+		}
+		return nextLoad(url, context);
+	},
+});
+
+const { doubleBorderBox, MODAL_OVERLAY_OPTIONS } = await import("./modal-frame.js");
+
+void test("shares the centered usage overlay dimensions", () => {
+	assert.deepEqual(MODAL_OVERLAY_OPTIONS, {
+		anchor: "center",
+		width: 96,
+		minWidth: 48,
+		maxHeight: "92%",
+		margin: 1,
+	});
+});
+
+void test("preserves the themed usage heading and pads ANSI content by visible width", () => {
+	const theme = {
+		fg: (name: string, text: string): string =>
+			`\u001B[${name === "border" ? 34 : 36}m${text}\u001B[0m`,
+	};
+	const lines = doubleBorderBox(theme, 12, "Hi", ["\u001B[31m界\u001B[0m!"]);
+	const strip = (line: string): string =>
+		line.replace(new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g"), "");
+	assert.deepEqual(lines.map(strip), [
+		"╔ Hi       ╗",
+		"║界!       ║",
+		"╚══════════╝",
+	]);
+	assert.ok(lines[0]?.includes("\u001B[36m Hi       \u001B[0m"));
+	assert.ok(lines[1]?.startsWith("\u001B[34m║\u001B[0m"));
+	assert.ok(lines.every((line) => visibleWidth(line) === 12));
+});
+
+void test("truncates long titles and content in narrow frames", () => {
+	const theme = { fg: (_name: string, text: string): string => text };
+	const lines = doubleBorderBox(theme, 6, "Long title", ["long content"]);
+	const strip = (line: string): string =>
+		line.replace(new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g"), "");
+	assert.deepEqual(lines.map(strip), ["╔ ...╗", "║l...║", "╚════╝"]);
+	assert.ok(lines.every((line) => visibleWidth(line) === 6));
+});

package/extensions/osdy-pi/modal-frame.ts

@@ -0,0 +1,35 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { SimpleTheme } from "./types.js";
+
+export const MODAL_OVERLAY_OPTIONS = {
+	anchor: "center",
+	width: 96,
+	minWidth: 48,
+	maxHeight: "92%",
+	margin: 1,
+} as const;
+
+export function doubleBorderBox(
+	theme: SimpleTheme,
+	width: number,
+	title: string,
+	lines: string[],
+): string[] {
+	const innerWidth = Math.max(1, width - 2);
+	const heading = truncateToWidth(` ${title} `, innerWidth, "...", true);
+	const leftWidth = Math.floor(
+		Math.max(0, innerWidth - visibleWidth(heading)) / 2,
+	);
+	const rightWidth = Math.max(0, innerWidth - visibleWidth(heading) - leftWidth);
+	const pad = (line: string): string => {
+		const text = truncateToWidth(line, innerWidth, "...", true);
+		return `${text}${" ".repeat(Math.max(0, innerWidth - visibleWidth(text)))}`;
+	};
+	return [
+		`${theme.fg("border", `╔${"═".repeat(leftWidth)}`)}${theme.fg("accent", heading)}${theme.fg("border", `${"═".repeat(rightWidth)}╗`)}`,
+		...lines.map(
+			(line) => `${theme.fg("border", "║")}${pad(line)}${theme.fg("border", "║")}`,
+		),
+		theme.fg("border", `╚${"═".repeat(innerWidth)}╝`),
+	];
+}

package/extensions/osdy-pi/runtime.test.ts

@@ -81,6 +81,20 @@ class TestSessionContextProvider {
 	}
 }
 
+void test("runtime wires standalone role markers to the existing enabled state", () => {
+ const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+ assert.match(source, /registerMessageRoleMarkers\(pi, \(\) => state\.enabled\)/);
+ assert.equal(source.match(/registerMessageRoleMarkers\(pi, /g)?.length, 1);
+});
+
+void test("runtime passes one session store to exactly one todo tool and command", () => {
+ const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+ assert.equal(source.match(/createTodoSessionStore\(\)/g)?.length, 1);
+ assert.equal(source.match(/registerTodoTool\(pi, todoStore\)/g)?.length, 1);
+ assert.equal(source.match(/registerTodosCommand\(pi, todoStore\)/g)?.length, 1);
+ assert.equal(source.match(/registerTodoWidget\(pi, todoStore\)/g)?.length, 1);
+});
+
 void test("agents setup requires interactive confirmation and reloads only after success", async () => {
 	const notices: string[] = [];
 	let installs = 0;
@@ -349,6 +363,13 @@ void test("enable, disable, and their on/off aliases persist the complete visual
 	);
 });
 
+void test("registers session-backed todo surfaces without the old ODD tool", () => {
+ const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
+ assert.match(source, /import \{ registerTodoTool \} from "\.\/todo-tool\.js"/);
+ assert.match(source, /import \{ registerTodosCommand \} from "\.\/todo-command\.js"/);
+ assert.doesNotMatch(source, /registerOddTodo|odd-todo-ui/);
+});
+
 void test("does not import or register the response-card Markdown transformer", () => {
 	const source = readFileSync(new URL("./runtime.ts", import.meta.url), "utf8");
 
@@ -356,7 +377,7 @@ void test("does not import or register the response-card Markdown transformer",
 	assert.doesNotMatch(source, /pi\.registerMarkdownTransformer\(/);
 });
 
-void test("every registered theme defines non-empty assistant message tokens", () => {
+void test("every registered theme defines native user message colors", () => {
 	const manifest = JSON.parse(
 		readFileSync(new URL("../../package.json", import.meta.url), "utf8"),
 	) as { pi: { themes: string[] } };
@@ -369,11 +390,7 @@ void test("every registered theme defines non-empty assistant message tokens", (
 				"utf8",
 			),
 		) as { colors: Record<string, unknown> };
-		for (const token of [
-			"assistantMessageBg",
-			"assistantMessageAccentBg",
-			"assistantMessageText",
-		]) {
+		for (const token of ["userMessageBg", "userMessageText"]) {
 			const value = theme.colors[token];
 			assert.equal(
 				typeof value === "string" && value.trim() !== "",
@@ -381,20 +398,10 @@ void test("every registered theme defines non-empty assistant message tokens", (
 				`${themePath} must define a non-empty ${token}`,
 			);
 		}
-		assert.equal(
-			theme.colors.assistantMessageAccentBg,
-			theme.colors.accent,
-			`${themePath} assistant stripe must match its accent`,
-		);
-		assert.equal(
-			theme.colors.userMessageAccentBg,
-			"#FFFFFF",
-			`${themePath} user stripe must be white`,
-		);
 	}
 });
 
-void test("Tokyo Night uses original palette tokens for message stripes", () => {
+void test("Tokyo Night retains its approved native user card colors", () => {
 	const theme = JSON.parse(
 		readFileSync(
 			new URL("../../themes/osdy-pi-tokyo-night.json", import.meta.url),
@@ -404,19 +411,11 @@ void test("Tokyo Night uses original palette tokens for message stripes", () =>
 
 	assert.deepEqual(
 		{
-			assistantMessageBg: theme.colors.assistantMessageBg,
-			assistantMessageAccentBg: theme.colors.assistantMessageAccentBg,
-			assistantMessageText: theme.colors.assistantMessageText,
-			userMessageAccentBg: theme.colors.userMessageAccentBg,
 			userMessageBg: theme.colors.userMessageBg,
 			userMessageText: theme.colors.userMessageText,
 		},
 		{
-			assistantMessageBg: "elevated",
-			assistantMessageAccentBg: "blue",
-			assistantMessageText: "text",
-			userMessageAccentBg: "#FFFFFF",
-			userMessageBg: "panel",
+			userMessageBg: "#283b59",
 			userMessageText: "text",
 		},
 	);

package/extensions/osdy-pi/runtime.ts

@@ -56,6 +56,11 @@ import {
 	createWorkingController,
 	type WorkingController,
 } from "./working-controller.js";
+import { registerTodoTool } from "./todo-tool.js";
+import { registerTodosCommand } from "./todo-command.js";
+import { createTodoSessionStore } from "./todo-session.js";
+import { registerMessageRoleMarkers } from "./message-role-markers.js";
+import { registerTodoWidget } from "./todo-widget.js";
 
 function scheduleOsdyRefresh(
 	delayMs: number,
@@ -899,6 +904,11 @@ export function registerOsdyPi(pi: ExtensionAPI): void {
 	const settingsStore = createAudioSoundSettingsStore();
 	const editorSettingsStore = createEditorSettingsStore();
 	registerAudioNotificationFlags(pi);
+	registerMessageRoleMarkers(pi, () => state.enabled);
+	const todoStore = createTodoSessionStore();
+	registerTodoTool(pi, todoStore);
+	registerTodosCommand(pi, todoStore);
+	registerTodoWidget(pi, todoStore);
 	const audioRouter = createAudioEventRouter(
 		createAudioNotificationService(
 			pi,

package/extensions/osdy-pi/todo-command.test.ts

@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import { registerHooks } from "node:module";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TodoI18n } from "./todo-i18n.js";
+
+registerHooks({ resolve(specifier, context, next) {
+ if (specifier.startsWith(".") && specifier.endsWith(".js") && context.parentURL?.endsWith(".ts")) {
+  const url = new URL(`${specifier.slice(0, -3)}.ts`, context.parentURL);
+  if (existsSync(fileURLToPath(url))) return { shortCircuit: true, url: url.href };
+ }
+ return next(specifier, context);
+} });
+
+const { registerTodoTool } = await import("./todo-tool.js");
+const { registerTodosCommand } = await import("./todo-command.js");
+const { createTodoSessionStore } = await import("./todo-session.js");
+
+type Context = { sessionManager: { getSessionId: () => string; getBranch: () => unknown[] }; mode: string; hasUI: boolean; ui: { notify: (text: string, level: string) => void; custom: (factory: (...args: unknown[]) => unknown, options: unknown) => Promise<void> } };
+function harness(i18n?: TodoI18n) {
+ const notices: Array<[string, string]> = [];
+ const modals: Array<{ factory: (...args: unknown[]) => unknown; options: unknown }> = [];
+ const commands = new Map<string, { handler: (args: string, ctx: Context) => Promise<void> }>();
+ let execute: ((...args: unknown[]) => Promise<unknown>) | undefined;
+ const events = new Map<string, (event: unknown, ctx: Context) => void>();
+ const pi = {
+  registerTool: (tool: { execute: (...args: unknown[]) => Promise<unknown> }) => { execute = tool.execute; },
+  registerCommand: (name: string, command: { handler: (args: string, ctx: Context) => Promise<void> }) => { commands.set(name, command); },
+  on: (name: string, handler: (event: unknown, ctx: Context) => void) => { events.set(name, handler); },
+ } as unknown as ExtensionAPI;
+ const store = createTodoSessionStore();
+ registerTodoTool(pi, store);
+ registerTodosCommand(pi, store, i18n);
+ const context = (id: string, hasUI = true, mode = "rpc"): Context => ({ sessionManager: { getSessionId: () => id, getBranch: () => [] }, mode, hasUI, ui: { notify: (text, level) => { notices.push([text, level]); }, custom: (factory, options) => { modals.push({ factory, options }); return Promise.resolve(); } } });
+ const run = async (ctx: Context, params: Record<string, unknown>) => { assert.ok(execute); await execute("call", params, undefined, undefined, ctx); };
+ const show = async (ctx: Context, args = "") => { const command = commands.get("todos"); assert.ok(command); await command.handler(args, ctx); return notices.at(-1); };
+ return { commands, notices, modals, context, run, show, events };
+}
+
+void test("/todos reads the same store after tool create, without interpreting arguments", async () => {
+ const h = harness();
+ assert.deepEqual([...h.commands.keys()], ["todos"]);
+ const parent = h.context("parent");
+ await h.run(parent, { action: "create", subject: "Write tests" });
+ assert.deepEqual(await h.show(parent, "clear all"), ["1 pending\n── Pending ──\n  ○ #1 Write tests", "info"]);
+ assert.deepEqual(await h.show(parent), ["1 pending\n── Pending ──\n  ○ #1 Write tests", "info"]);
+ const child = h.context("child");
+ assert.deepEqual(await h.show(child), ["No todos yet. Ask the agent to add some!", "info"]);
+ await h.run(child, { action: "create", subject: "Child only" });
+ assert.deepEqual(await h.show(child), ["1 pending\n── Pending ──\n  ○ #1 Child only", "info"]);
+ assert.deepEqual(await h.show(parent), ["1 pending\n── Pending ──\n  ○ #1 Write tests", "info"]);
+ assert.deepEqual(await h.show(h.context("parent", false)), ["/todos requires interactive mode", "error"]);
+});
+
+void test("/todos groups visible statuses and treats deleted-only as empty", async () => {
+ const h = harness();
+ const ctx = h.context("parent");
+ await h.run(ctx, { action: "create", subject: "First" });
+ await h.run(ctx, { action: "create", subject: "Build", blockedBy: [1] });
+ await h.run(ctx, { action: "update", id: 2, status: "in_progress", activeForm: "building" });
+ await h.run(ctx, { action: "update", id: 1, status: "completed" });
+ await h.run(ctx, { action: "create", subject: "Next", blockedBy: [2] });
+ assert.deepEqual(await h.show(ctx), ["1/3 completed · 1 in progress · 1 pending\n── Pending ──\n  ○ #3 Next    ⛓ #2\n── In Progress ──\n  ◐ #2 Build (building)    ⛓ #1\n── Completed ──\n  ✓ #1 First", "info"]);
+ await h.run(ctx, { action: "delete", id: 1 });
+ await h.run(ctx, { action: "delete", id: 2 });
+ await h.run(ctx, { action: "delete", id: 3 });
+ assert.deepEqual(await h.show(ctx), ["No todos yet. Ask the agent to add some!", "info"]);
+});
+
+void test("/todos translates UI at invocation time without changing tool responses", async () => {
+ let language = "es";
+ const dictionary: Record<string, string> = { "status.pending": "pendientes", "status.completed": "completadas", "command.section.pending": "── Pendientes ──", "command.no_todos": "Sin tareas", "command.requires_interactive": "Modo interactivo requerido" };
+ const i18n: TodoI18n = { t: (key, fallback) => language === "es" ? dictionary[key] ?? fallback : fallback, status: (status) => language === "es" ? dictionary[`status.${status}`] ?? status : status };
+ const h = harness(i18n); const ctx = h.context("main");
+ assert.deepEqual(await h.show(ctx), ["Sin tareas", "info"]);
+ assert.deepEqual(await h.show(h.context("main", false)), ["Modo interactivo requerido", "error"]);
+ await h.run(ctx, { action: "create", subject: "Write tests" });
+ assert.deepEqual(await h.show(ctx), ["1 pendientes\n── Pendientes ──\n  ○ #1 Write tests", "info"]);
+ language = "en";
+ assert.deepEqual(await h.show(ctx), ["1 pending\n── Pending ──\n  ○ #1 Write tests", "info"]);
+});
+
+void test("TUI /todos opens the shared overlay for an empty session and never notifies", async () => {
+ const h = harness();
+ await h.show(h.context("main", true, "tui"));
+ assert.deepEqual(h.notices, []);
+ assert.equal(h.modals.length, 1);
+ assert.deepEqual(h.modals[0]?.options, { overlay: true, overlayOptions: { anchor: "center", width: 96, minWidth: 48, maxHeight: "92%", margin: 1 } });
+ const panel = h.modals[0]?.factory({ terminal: { rows: 20 }, requestRender() {} }, { fg: (_color: string, text: string) => text }, null, () => {} ) as { render: (width: number) => string[] };
+ assert.match(panel.render(50).join("\n"), /Todos[\s\S]*No todos yet/);
+});
+
+void test("TUI /todos gets localized grouped read-only content without mutating the store", async () => {
+ const i18n: TodoI18n = { t: (key, fallback) => ({ "overlay.heading": "Tareas", "command.section.pending": "── Pendientes ──" })[key] ?? fallback, status: (status) => status === "pending" ? "pendientes" : status };
+ const h = harness(i18n); const ctx = h.context("main", true, "tui");
+ await h.run(ctx, { action: "create", subject: "Write tests" });
+ await h.show(ctx, "clear all");
+ assert.deepEqual(h.notices, []);
+ const panel = h.modals[0]?.factory({ terminal: { rows: 20 }, requestRender() {} }, { fg: (_color: string, text: string) => text }, null, () => {}) as { render: (width: number) => string[] };
+ assert.match(panel.render(60).join("\n"), /Tareas[\s\S]*1 pendientes[\s\S]*── Pendientes ──[\s\S]*○ #1 Write tests/);
+ assert.deepEqual(await h.show(h.context("main", true, "rpc")), ["1 pendientes\n── Pendientes ──\n  ○ #1 Write tests", "info"]);
+});
+
+void test("TUI /todos supplies semantic rows while RPC keeps its exact grouped notification", async () => {
+ const h = harness(); const ctx = h.context("main", true, "tui");
+ await h.run(ctx, { action: "create", subject: "First" });
+ await h.run(ctx, { action: "create", subject: "Second" });
+ await h.run(ctx, { action: "update", id: 2, status: "completed" });
+ await h.show(ctx);
+ const colors: string[] = [];
+ const panel = h.modals[0]?.factory({ terminal: { rows: 20 }, requestRender() {} },
+  { fg: (color: string, text: string) => { colors.push(`${color}:${text}`); return text; } }, null, () => {}) as { render(width: number): string[] };
+ const frame = panel.render(48).join("\n");
+ assert.match(frame, /█████░░░░░ 1\/2 completed/);
+ assert.match(frame, /Pending[\s\S]*Completed/);
+ assert.ok(colors.some((line) => line === "warning:── Pending ──"));
+ assert.ok(colors.some((line) => line === "success:  ✓ #2 Second"));
+ assert.deepEqual(await h.show(h.context("main")), ["1/2 completed · 1 pending\n── Pending ──\n  ○ #1 First\n── Completed ──\n  ✓ #2 Second", "info"]);
+});
+
+void test("command reflects lifecycle replay and shutdown eviction via shared tool store", async () => {
+ const h = harness();
+ const parent = h.context("parent");
+ await h.run(parent, { action: "create", subject: "Live" });
+ h.events.get("session_tree")?.({}, parent);
+ assert.deepEqual(await h.show(parent), ["No todos yet. Ask the agent to add some!", "info"]);
+ await h.run(parent, { action: "create", subject: "New" });
+ h.events.get("session_shutdown")?.({}, parent);
+ assert.deepEqual(await h.show(parent), ["No todos yet. Ask the agent to add some!", "info"]);
+});

package/extensions/osdy-pi/todo-command.ts

@@ -0,0 +1,60 @@
+// /todos display adapted from @juicesharp/rpiv-todo@2.11.0 (MIT); see root LICENSE.
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { listTasks, type TodoStatus, type TodoTask } from "./todo-domain.js";
+import { todoSessionId, type createTodoSessionStore } from "./todo-session.js";
+import { todoI18n, type TodoI18n } from "./todo-i18n.js";
+import { safe } from "./todo-tool.js";
+import { showTodoPanel, type TodoPanelRow } from "./todo-panel.js";
+
+const sections: readonly { status: TodoStatus; heading: string; glyph: string }[] = [
+ { status: "pending", heading: "── Pending ──", glyph: "○" },
+ { status: "in_progress", heading: "── In Progress ──", glyph: "◐" },
+ { status: "completed", heading: "── Completed ──", glyph: "✓" },
+];
+
+function line(task: TodoTask, glyph: string): string {
+ const form = task.status === "in_progress" && task.activeForm ? ` (${safe(task.activeForm)})` : "";
+ const block = task.blockedBy?.length ? `    ⛓ ${task.blockedBy.map((id) => `#${id}`).join(",")}` : "";
+ return `  ${glyph} #${task.id} ${safe(task.subject)}${form}${block}`;
+}
+
+export function registerTodosCommand(pi: ExtensionAPI, store: ReturnType<typeof createTodoSessionStore>, i18n: TodoI18n = todoI18n): void {
+ pi.registerCommand("todos", {
+  description: "Show all todos on the current branch, grouped by status",
+  handler: (_args, ctx) => {
+   if (!ctx.hasUI) {
+    ctx.ui.notify(i18n.t("command.requires_interactive", "/todos requires interactive mode"), "error");
+    return Promise.resolve();
+   }
+   const tasks = listTasks(store.get(todoSessionId(ctx.sessionManager.getSessionId())));
+   if (!tasks.length) {
+    const empty = i18n.t("command.no_todos", "No todos yet. Ask the agent to add some!");
+    if (ctx.mode === "tui") return showTodoPanel(ctx, () => [empty], i18n.t("overlay.heading", "Todos"));
+    ctx.ui.notify(empty, "info");
+    return Promise.resolve();
+   }
+   const pending = tasks.filter((task) => task.status === "pending").length;
+   const inProgress = tasks.filter((task) => task.status === "in_progress").length;
+   const completed = tasks.filter((task) => task.status === "completed").length;
+   const counts = [
+    completed ? `${completed}/${tasks.length} ${i18n.status("completed")}` : "",
+    inProgress ? `${inProgress} ${i18n.status("in_progress")}` : "",
+    pending ? `${pending} ${i18n.status("pending")}` : "",
+   ].filter(Boolean);
+   const summary = counts.join(" · ");
+   const lines = [summary];
+   const rows: TodoPanelRow[] = [{ text: summary, kind: "summary", done: completed, total: tasks.length }];
+   for (const section of sections) {
+    const group = tasks.filter((task) => task.status === section.status);
+    if (!group.length) continue;
+    const heading = i18n.t(`command.section.${section.status}`, section.heading);
+    lines.push(heading, ...group.map((task) => line(task, section.glyph)));
+    rows.push({ text: "", kind: "space" }, { text: heading, kind: "section", status: section.status },
+     ...group.map((task): TodoPanelRow => ({ text: line(task, section.glyph), kind: "task", status: section.status })));
+   }
+   if (ctx.mode === "tui") return showTodoPanel(ctx, () => rows, i18n.t("overlay.heading", "Todos"));
+   ctx.ui.notify(lines.join("\n"), "info");
+   return Promise.resolve();
+  },
+ });
+}

package/extensions/osdy-pi/todo-config.test.ts

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import { registerHooks } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+registerHooks({ resolve(specifier, context, next) {
+ if (specifier.startsWith(".") && specifier.endsWith(".js") && context.parentURL?.endsWith(".ts")) {
+  const url = new URL(`${specifier.slice(0, -3)}.ts`, context.parentURL);
+  if (existsSync(fileURLToPath(url))) return { shortCircuit: true, url: url.href };
+ }
+ return next(specifier, context);
+} });
+
+const { loadTodoConfig, getMaxWidgetLines, resolveCollapseKey, validateGuidance } = await import("./todo-config.js");
+
+function fixture(files: Record<string, string>, xdg?: string) {
+ const home = join(tmpdir(), "osdy-todo-config-test-home");
+ return { home, env: xdg === undefined ? {} : { XDG_CONFIG_HOME: xdg }, readFile(path: string) {
+  if (!(path in files)) throw Object.assign(new Error("missing"), { code: "ENOENT" });
+  return files[path]!;
+ } };
+}
+const legacy = join(tmpdir(), "osdy-todo-config-test-home", ".config", "rpiv-todo", "config.json");
+const xdg = join(tmpdir(), "osdy-todo-config-test-xdg");
+const primary = join(xdg, "rpiv-todo", "config.json");
+
+void test("XDG wins, legacy is used only when XDG is missing; relative XDG uses legacy", () => {
+ assert.equal(loadTodoConfig(fixture({ [legacy]: '{"maxWidgetLines":5}', [primary]: '{"maxWidgetLines":7}' }, xdg)).maxWidgetLines, 7);
+ assert.equal(loadTodoConfig(fixture({ [legacy]: '{"maxWidgetLines":5}' }, xdg)).maxWidgetLines, 5);
+ assert.equal(loadTodoConfig(fixture({ [legacy]: '{"maxWidgetLines":5}' }, "relative/path")).maxWidgetLines, 5);
+ assert.equal(loadTodoConfig(fixture({ [legacy]: '{"maxWidgetLines":5}' }, "~other/.config")).maxWidgetLines, 5);
+ assert.equal(loadTodoConfig(fixture({ [legacy]: '{"maxWidgetLines":5}' }, "   ")).maxWidgetLines, 5);
+ assert.equal(loadTodoConfig(fixture({ [legacy]: '{"maxWidgetLines":5}' }, "~/not-installed")).maxWidgetLines, 5);
+ assert.deepEqual(loadTodoConfig(fixture({}, xdg)), {});
+});
+
+void test("invalid JSON warns and defaults without falling back; non-object JSON silently defaults", () => {
+ const warnings: string[] = [];
+ const bad = fixture({ [primary]: "{", [legacy]: '{"maxWidgetLines":5}' }, xdg);
+ assert.equal(getMaxWidgetLines(loadTodoConfig({ ...bad, warn: (message: string) => warnings.push(message) })), 7);
+ assert.match(warnings[0] ?? "", /rpiv-config: invalid JSON at .*config.json/);
+ for (const value of ["null", "[]", '"hello"', "42"]) {
+  assert.equal(getMaxWidgetLines(loadTodoConfig(fixture({ [primary]: value }, xdg))), 7);
+ }
+});
+
+void test("widget budget and collapse key validate independently", () => {
+ for (const value of [undefined, null, "3", 2, -1]) assert.equal(getMaxWidgetLines({ maxWidgetLines: value }), 7);
+ assert.equal(getMaxWidgetLines({ maxWidgetLines: 3 }), 3);
+ assert.equal(getMaxWidgetLines({ maxWidgetLines: 100 }), 100);
+ for (const value of [undefined, null, "", "  ", "ctr+]", "ctrl+ctrl+t", "ctrl+f13", "ctrl++t", "ctrl+unknown+t", "~user"]) {
+  assert.equal(resolveCollapseKey({ collapseKey: value }), "ctrl+shift+t");
+ }
+ assert.equal(resolveCollapseKey({ collapseKey: " ALT+F5 " }), "alt+f5");
+ assert.equal(resolveCollapseKey({ collapseKey: "off" }), "off");
+ assert.equal(resolveCollapseKey({ collapseKey: "ctrl+]" }), "ctrl+]");
+});
+
+void test("guidance requires non-empty strings and all-or-nothing guideline arrays", () => {
+ assert.deepEqual(validateGuidance({ promptSnippet: "custom", promptGuidelines: ["one", "two"] }), { promptSnippet: "custom", promptGuidelines: ["one", "two"] });
+ assert.deepEqual(validateGuidance({ promptSnippet: "", promptGuidelines: ["one", ""] }), {});
+ assert.deepEqual(validateGuidance({ promptSnippet: " ", promptGuidelines: [" "] }), { promptSnippet: " ", promptGuidelines: [" "] });
+ assert.deepEqual(validateGuidance(null), {});
+});

package/extensions/osdy-pi/todo-config.ts

@@ -0,0 +1,78 @@
+// Configuration behavior implemented against @juicesharp/rpiv-todo@2.11.0 (MIT); see root LICENSE.
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+
+export const DEFAULT_MAX_WIDGET_LINES = 7;
+export const DEFAULT_COLLAPSE_KEY = "ctrl+shift+t";
+export const COLLAPSE_KEY_OFF = "off";
+
+export interface TodoConfig {
+ maxWidgetLines?: unknown;
+ collapseKey?: unknown;
+ guidance?: unknown;
+}
+
+// The optional sources let tests exercise path selection without touching real home files.
+interface ConfigSources {
+ home?: string;
+ env?: { XDG_CONFIG_HOME?: string };
+ readFile?: (path: string) => string;
+ warn?: (message: string) => void;
+}
+
+export function loadTodoConfig(sources: ConfigSources = {}): TodoConfig {
+ const home = sources.home ?? homedir();
+ const xdg = (sources.env ?? process.env).XDG_CONFIG_HOME?.trim();
+ const expanded = xdg === "~" ? home : xdg?.startsWith("~/") ? join(home, xdg.slice(2)) : xdg;
+ const directory = expanded && isAbsolute(expanded) ? expanded : join(home, ".config");
+ const primary = join(directory, "rpiv-todo", "config.json");
+ const legacy = join(home, ".config", "rpiv-todo", "config.json");
+ const read = sources.readFile ?? ((path: string) => readFileSync(path, "utf8"));
+ const warn = sources.warn ?? console.warn;
+ for (const path of new Set([primary, legacy])) {
+  let text: string;
+  try { text = read(path); }
+  catch (error) {
+   if ((error as NodeJS.ErrnoException).code === "ENOENT") continue;
+   warn(`rpiv-config: invalid JSON at ${path}, using default ({}) — ${String(error)}`);
+   return {};
+  }
+  try {
+   const parsed: unknown = JSON.parse(text);
+   return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch (error) {
+   warn(`rpiv-config: invalid JSON at ${path}, using default ({}) — ${String(error)}`);
+   return {};
+  }
+ }
+ return {};
+}
+
+export function getMaxWidgetLines(config: TodoConfig = loadTodoConfig()): number {
+ const lines = config.maxWidgetLines;
+ return typeof lines === "number" && lines >= 3 ? lines : DEFAULT_MAX_WIDGET_LINES;
+}
+
+const namedKeys = new Set(["escape", "esc", "enter", "return", "tab", "space", "backspace", "delete", "insert", "clear", "home", "end", "pageup", "pagedown", "up", "down", "left", "right", ...Array.from({ length: 12 }, (_, i) => `f${i + 1}`)]);
+const modifiers = new Set(["ctrl", "shift", "alt", "super"]);
+
+export function resolveCollapseKey(config: TodoConfig = loadTodoConfig()): string {
+ const spec = typeof config.collapseKey === "string" ? config.collapseKey.trim().toLowerCase() : "";
+ if (!spec) return DEFAULT_COLLAPSE_KEY;
+ if (spec === COLLAPSE_KEY_OFF) return COLLAPSE_KEY_OFF;
+ const parts = spec.split("+");
+ const base = parts.pop() ?? "";
+ const mods = new Set(parts);
+ const printable = base.length === 1 && base.charCodeAt(0) >= 33 && base.charCodeAt(0) <= 126;
+ return mods.size === parts.length && parts.every((part) => modifiers.has(part)) && (printable || namedKeys.has(base)) ? spec : DEFAULT_COLLAPSE_KEY;
+}
+
+export function validateGuidance(value: unknown): { promptSnippet?: string; promptGuidelines?: string[] } {
+ if (value === null || typeof value !== "object" || Array.isArray(value)) return {};
+ const fields = value as Record<string, unknown>;
+ const result: { promptSnippet?: string; promptGuidelines?: string[] } = {};
+ if (typeof fields.promptSnippet === "string" && fields.promptSnippet.length > 0) result.promptSnippet = fields.promptSnippet;
+ if (Array.isArray(fields.promptGuidelines) && fields.promptGuidelines.length > 0 && fields.promptGuidelines.every((item: unknown) => typeof item === "string" && item.length > 0)) result.promptGuidelines = fields.promptGuidelines as string[];
+ return result;
+}