pi-rtk-optimizer 0.7.0 → 0.8.0

package/src/command-rewriter-test.ts

@@ -1,118 +1,187 @@
-import assert from "node:assert/strict";
-
-import { computeRewriteDecision } from "./command-rewriter.ts";
-import { cloneDefaultConfig, runTest } from "./test-helpers.ts";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-
-function createMockPi(execResult: { code: number; stdout?: string; stderr?: string }): ExtensionAPI {
-	return { exec: async () => execResult } as unknown as ExtensionAPI;
-}
-
-runTest("empty command unchanged", async () => {
-	const config = cloneDefaultConfig();
-	const decision = await computeRewriteDecision("", config, createMockPi({ code: 1 }));
-	assert.equal(decision.changed, false);
-	assert.equal(decision.reason, "empty");
-});
-
-runTest("already rtk unchanged", async () => {
-	const config = cloneDefaultConfig();
-	const decision = await computeRewriteDecision("rtk status", config, createMockPi({ code: 1 }));
-	assert.equal(decision.changed, false);
-	assert.equal(decision.reason, "already_rtk");
-});
-
-runTest("rtk unsupported heredoc result leaves command unchanged", async () => {
-	const config = cloneDefaultConfig();
-	const decision = await computeRewriteDecision("cat <<EOF", config, createMockPi({ code: 1 }));
-	assert.equal(decision.changed, false);
-	assert.equal(decision.reason, "no_match");
-});
-
-runTest("quoted heredoc marker is delegated to RTK rewrite", async () => {
-	const config = cloneDefaultConfig();
-	const command = 'echo "<<not heredoc" && git status';
-	const decision = await computeRewriteDecision(
-		command,
-		config,
-		createMockPi({ code: 3, stdout: 'echo "<<not heredoc" && rtk git status' }),
-	);
-	assert.equal(decision.changed, true);
-	assert.equal(decision.rewrittenCommand, 'echo "<<not heredoc" && rtk git status');
-	assert.equal(decision.reason, "ok");
-});
-
-runTest("legacy category toggles do not pre-filter RTK rewrite source of truth", async () => {
-	const config = { ...cloneDefaultConfig(), rewriteGitGithub: false };
-	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 3, stdout: "rtk git status" }));
-	assert.equal(decision.changed, true);
-	assert.equal(decision.rewrittenCommand, "rtk git status");
-	assert.equal(decision.reason, "ok");
-});
-
-runTest("rtk exit 0 rewrites", async () => {
-	const config = cloneDefaultConfig();
-	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 0, stdout: "rtk git status" }));
-	assert.equal(decision.changed, true);
-	assert.equal(decision.rewrittenCommand, "rtk git status");
-	assert.equal(decision.reason, "ok");
-});
-
-runTest("rtk exit 3 rewrites", async () => {
-	const config = cloneDefaultConfig();
-	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 3, stdout: "rtk git status" }));
-	assert.equal(decision.changed, true);
-	assert.equal(decision.rewrittenCommand, "rtk git status");
-	assert.equal(decision.reason, "ok");
-});
-
-runTest("exit 1 leaves unchanged", async () => {
-	const config = cloneDefaultConfig();
-	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 1 }));
-	assert.equal(decision.changed, false);
-	assert.equal(decision.reason, "no_match");
-});
-
-runTest("exit 2 leaves unchanged", async () => {
-	const config = cloneDefaultConfig();
-	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 2, stderr: "denied" }));
-	assert.equal(decision.changed, false);
-	assert.equal(decision.reason, "no_match");
-});
-
-runTest("unknown category passes through to RTK", async () => {
-	const config = cloneDefaultConfig();
-	const pi = createMockPi({ code: 0, stdout: "rtk custom" });
-	const decision = await computeRewriteDecision("custom-cmd", config, pi);
-	assert.equal(decision.changed, true);
-	assert.equal(decision.rewrittenCommand, "rtk custom");
-	assert.equal(decision.reason, "ok");
-});
-
-runTest("exec error/timeout leaves unchanged", async () => {
-	const config = cloneDefaultConfig();
-	const pi = {
-		exec: async () => {
-			throw new Error("timeout");
-		},
-	} as unknown as ExtensionAPI;
-	const decision = await computeRewriteDecision("git status", config, pi);
-	assert.equal(decision.changed, false);
-	assert.equal(decision.reason, "no_match");
-});
-
-runTest("compound commands forwarded to RTK", async () => {
-	const config = cloneDefaultConfig();
-	let capturedArgs: string[] = [];
-	const pi = {
-		exec: async (_cmd: string, args: string[]) => {
-			capturedArgs = args;
-			return { code: 0, stdout: "rtk result" };
-		},
-	} as unknown as ExtensionAPI;
-	const decision = await computeRewriteDecision("git status && cargo test", config, pi);
-	assert.equal(decision.changed, true);
-	assert.deepEqual(capturedArgs, ["rewrite", "git status && cargo test"]);
-});
-
-console.log("All command-rewriter tests passed.");
+import assert from "node:assert/strict";
+
+import { computeRewriteDecision } from "./command-rewriter.ts";
+import { resolveRtkRewrite } from "./rtk-rewrite-provider.ts";
+import { cloneDefaultConfig, runTest } from "./test-helpers.ts";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+function createMockPi(execResult: { code: number; stdout?: string; stderr?: string }): ExtensionAPI {
+	return {
+		exec: async (command: string) => {
+			if (command === "which" || command === "where") {
+				return { code: 0, stdout: "/usr/local/bin/rtk\n", stderr: "" };
+			}
+			return execResult;
+		},
+	} as unknown as ExtensionAPI;
+}
+
+await runTest("rtk rewrite uses resolved POSIX executable path", async () => {
+	const calls: Array<{ command: string; args: string[] }> = [];
+	const pi = {
+		exec: async (command: string, args: string[]) => {
+			calls.push({ command, args });
+			if (command === "which") {
+				return { code: 0, stdout: "/opt/rtk/bin/rtk\n", stderr: "" };
+			}
+			return { code: 3, stdout: "rtk git status", stderr: "" };
+		},
+	} as unknown as ExtensionAPI;
+
+	const result = await resolveRtkRewrite(pi, "git status", { platform: "linux" });
+
+	assert.equal(result.changed, true);
+	assert.equal(result.rewrittenCommand, "rtk git status");
+	assert.equal(result.executableResolution?.resolvedPath, "/opt/rtk/bin/rtk");
+	assert.deepEqual(calls.map((call) => call.command), ["which", "/opt/rtk/bin/rtk"]);
+});
+
+await runTest("rtk rewrite uses resolved Windows executable path", async () => {
+	const calls: Array<{ command: string; args: string[] }> = [];
+	const pi = {
+		exec: async (command: string, args: string[]) => {
+			calls.push({ command, args });
+			if (command === "where") {
+				return { code: 0, stdout: "C:\\Tools\\rtk.exe\r\nC:\\Other\\rtk.exe\r\n", stderr: "" };
+			}
+			return { code: 3, stdout: "rtk git status", stderr: "" };
+		},
+	} as unknown as ExtensionAPI;
+
+	const result = await resolveRtkRewrite(pi, "git status", { platform: "win32" });
+
+	assert.equal(result.changed, true);
+	assert.equal(result.executableResolution?.resolvedPath, "C:\\Tools\\rtk.exe");
+	assert.deepEqual(calls.map((call) => call.command), ["where", "C:\\Tools\\rtk.exe"]);
+});
+
+await runTest("rtk rewrite preserves behavior when executable path resolution fails", async () => {
+	const calls: Array<{ command: string; args: string[] }> = [];
+	const pi = {
+		exec: async (command: string, args: string[]) => {
+			calls.push({ command, args });
+			if (command === "which") {
+				return { code: 1, stdout: "", stderr: "not found" };
+			}
+			return { code: 3, stdout: "rtk git status", stderr: "" };
+		},
+	} as unknown as ExtensionAPI;
+
+	const result = await resolveRtkRewrite(pi, "git status", { platform: "linux" });
+
+	assert.equal(result.changed, true);
+	assert.equal(result.executableResolution?.command, "rtk");
+	assert.ok(result.executableResolution?.warning?.includes("which failed"));
+	assert.deepEqual(calls.map((call) => call.command), ["which", "rtk"]);
+});
+
+await runTest("empty command unchanged", async () => {
+	const config = cloneDefaultConfig();
+	const decision = await computeRewriteDecision("", config, createMockPi({ code: 1 }));
+	assert.equal(decision.changed, false);
+	assert.equal(decision.reason, "empty");
+});
+
+await runTest("already rtk unchanged", async () => {
+	const config = cloneDefaultConfig();
+	const decision = await computeRewriteDecision("rtk status", config, createMockPi({ code: 1 }));
+	assert.equal(decision.changed, false);
+	assert.equal(decision.reason, "already_rtk");
+});
+
+await runTest("rtk unsupported heredoc result leaves command unchanged", async () => {
+	const config = cloneDefaultConfig();
+	const decision = await computeRewriteDecision("cat <<EOF", config, createMockPi({ code: 1 }));
+	assert.equal(decision.changed, false);
+	assert.equal(decision.reason, "no_match");
+});
+
+await runTest("quoted heredoc marker is delegated to RTK rewrite", async () => {
+	const config = cloneDefaultConfig();
+	const command = 'echo "<<not heredoc" && git status';
+	const decision = await computeRewriteDecision(
+		command,
+		config,
+		createMockPi({ code: 3, stdout: 'echo "<<not heredoc" && rtk git status' }),
+	);
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rewrittenCommand, 'echo "<<not heredoc" && rtk git status');
+	assert.equal(decision.reason, "ok");
+});
+
+await runTest("legacy category toggles do not pre-filter RTK rewrite source of truth", async () => {
+	const config = { ...cloneDefaultConfig(), rewriteGitGithub: false };
+	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 3, stdout: "rtk git status" }));
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rewrittenCommand, "rtk git status");
+	assert.equal(decision.reason, "ok");
+});
+
+await runTest("rtk exit 0 rewrites", async () => {
+	const config = cloneDefaultConfig();
+	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 0, stdout: "rtk git status" }));
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rewrittenCommand, "rtk git status");
+	assert.equal(decision.reason, "ok");
+});
+
+await runTest("rtk exit 3 rewrites", async () => {
+	const config = cloneDefaultConfig();
+	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 3, stdout: "rtk git status" }));
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rewrittenCommand, "rtk git status");
+	assert.equal(decision.reason, "ok");
+});
+
+await runTest("exit 1 leaves unchanged", async () => {
+	const config = cloneDefaultConfig();
+	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 1 }));
+	assert.equal(decision.changed, false);
+	assert.equal(decision.reason, "no_match");
+});
+
+await runTest("exit 2 leaves unchanged and surfaces RTK detail", async () => {
+	const config = cloneDefaultConfig();
+	const decision = await computeRewriteDecision("git status", config, createMockPi({ code: 2, stderr: "denied" }));
+	assert.equal(decision.changed, false);
+	assert.equal(decision.reason, "no_match");
+	assert.equal(decision.warning, "denied");
+});
+
+await runTest("unknown category passes through to RTK", async () => {
+	const config = cloneDefaultConfig();
+	const pi = createMockPi({ code: 0, stdout: "rtk custom" });
+	const decision = await computeRewriteDecision("custom-cmd", config, pi);
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rewrittenCommand, "rtk custom");
+	assert.equal(decision.reason, "ok");
+});
+
+await runTest("exec error/timeout leaves unchanged and surfaces error detail", async () => {
+	const config = cloneDefaultConfig();
+	const pi = {
+		exec: async () => {
+			throw new Error("timeout");
+		},
+	} as unknown as ExtensionAPI;
+	const decision = await computeRewriteDecision("git status", config, pi);
+	assert.equal(decision.changed, false);
+	assert.equal(decision.reason, "no_match");
+	assert.equal(decision.warning, "timeout");
+});
+
+await runTest("compound commands forwarded to RTK", async () => {
+	const config = cloneDefaultConfig();
+	let capturedArgs: string[] = [];
+	const pi = {
+		exec: async (_cmd: string, args: string[]) => {
+			capturedArgs = args;
+			return { code: 0, stdout: "rtk result" };
+		},
+	} as unknown as ExtensionAPI;
+	const decision = await computeRewriteDecision("git status && cargo test", config, pi);
+	assert.equal(decision.changed, true);
+	assert.deepEqual(capturedArgs, ["rewrite", "git status && cargo test"]);
+});
+
+console.log("All command-rewriter tests passed.");

package/src/command-rewriter.ts

@@ -1,43 +1,46 @@
-import { resolveRtkRewrite } from "./rtk-rewrite-provider.js";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import type { RtkIntegrationConfig } from "./types.js";
-
-export interface RewriteDecision {
-	changed: boolean;
-	originalCommand: string;
-	rewrittenCommand: string;
-	reason: "ok" | "empty" | "already_rtk" | "no_match";
-}
-
-export async function computeRewriteDecision(
-	command: string,
-	_config: RtkIntegrationConfig,
-	pi: ExtensionAPI,
-): Promise<RewriteDecision> {
-	if (!command || !command.trim()) {
-		return { changed: false, originalCommand: command, rewrittenCommand: command, reason: "empty" };
-	}
-
-	const trimmedStart = command.trimStart();
-	if (trimmedStart === "rtk" || trimmedStart.startsWith("rtk ")) {
-		return { changed: false, originalCommand: command, rewrittenCommand: command, reason: "already_rtk" };
-	}
-
-	const result = await resolveRtkRewrite(pi, command);
-
-	if (result.changed && result.rewrittenCommand) {
-		return {
-			changed: true,
-			originalCommand: command,
-			rewrittenCommand: result.rewrittenCommand,
-			reason: "ok",
-		};
-	}
-
-	return {
-		changed: false,
-		originalCommand: command,
-		rewrittenCommand: command,
-		reason: "no_match",
-	};
-}
+import { resolveRtkRewrite, type RtkRewriteProviderOptions } from "./rtk-rewrite-provider.js";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { RtkIntegrationConfig } from "./types.js";
+
+export interface RewriteDecision {
+	changed: boolean;
+	originalCommand: string;
+	rewrittenCommand: string;
+	reason: "ok" | "empty" | "already_rtk" | "no_match";
+	warning?: string;
+}
+
+export async function computeRewriteDecision(
+	command: string,
+	_config: RtkIntegrationConfig,
+	pi: ExtensionAPI,
+	rewriteOptions: RtkRewriteProviderOptions = {},
+): Promise<RewriteDecision> {
+	if (!command || !command.trim()) {
+		return { changed: false, originalCommand: command, rewrittenCommand: command, reason: "empty" };
+	}
+
+	const trimmedStart = command.trimStart();
+	if (trimmedStart === "rtk" || trimmedStart.startsWith("rtk ")) {
+		return { changed: false, originalCommand: command, rewrittenCommand: command, reason: "already_rtk" };
+	}
+
+	const result = await resolveRtkRewrite(pi, command, rewriteOptions);
+
+	if (result.changed && result.rewrittenCommand) {
+		return {
+			changed: true,
+			originalCommand: command,
+			rewrittenCommand: result.rewrittenCommand,
+			reason: "ok",
+		};
+	}
+
+	return {
+		changed: false,
+		originalCommand: command,
+		rewrittenCommand: command,
+		reason: "no_match",
+		warning: result.error,
+	};
+}

package/src/config-modal-test.ts

@@ -3,31 +3,45 @@ import { mock } from "bun:test";
 
 import { cloneDefaultConfig, runTest } from "./test-helpers.ts";
 
-mock.module("@mariozechner/pi-coding-agent", () => ({
+mock.module("@earendil-works/pi-coding-agent", () => ({
 	getAgentDir: () => "/tmp/.pi/agent",
 	getSettingsListTheme: () => ({}),
 }));
 
-mock.module("@mariozechner/pi-tui", () => ({
-	Box: class {},
+const settingsListInputs: string[] = [];
+const settingsListUpdates: Array<{ id: string; value: string }> = [];
+
+mock.module("@earendil-works/pi-tui", () => ({
+	Box: class {
+		addChild(): void {}
+	},
 	Container: class {
 		addChild(): void {}
 		render(): string[] {
-			return [];
+			return ["settings-content"];
 		}
 		invalidate(): void {}
 	},
 	SettingsList: class {
-		handleInput(): void {}
-		updateValue(): void {}
+		handleInput(data: string): void {
+			settingsListInputs.push(data);
+		}
+		updateValue(id: string, value: string): void {
+			settingsListUpdates.push({ id, value });
+		}
 	},
 	Spacer: class {},
 	Text: class {},
-	truncateToWidth: (text: string) => text,
+	truncateToWidth: (text: string, width: number) => text.slice(0, width),
 	visibleWidth: (text: string) => text.length,
 }));
 
+function stripAnsi(text: string): string {
+	return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
 const { registerRtkIntegrationCommand } = await import("./config-modal.ts");
+const { ZellijModal, ZellijSettingsModal } = await import("./zellij-modal.ts");
 const { getRtkArgumentCompletions } = await import("./command-completions.ts");
 
 type Notification = { message: string; level: "info" | "warning" | "error" };
@@ -62,6 +76,60 @@ function lastNotification(notifications: Notification[]): Notification {
 	return notifications[notifications.length - 1] as Notification;
 }
 
+function createThemeStub(): { fg: (_name: string, text: string) => string; bold: (text: string) => string } {
+	return {
+		fg: (_name: string, text: string) => text,
+		bold: (text: string) => text,
+	};
+}
+
+runTest("zellij settings modal renders overlay frame and delegates non-enter input", () => {
+	settingsListInputs.length = 0;
+	settingsListUpdates.length = 0;
+	const settingsModal = new ZellijSettingsModal(
+		{
+			title: "RTK Integration Settings",
+			settings: [
+				{
+					id: "enabled",
+					label: "Enabled",
+					description: "Enable integration",
+					currentValue: "on",
+					values: ["on", "off"],
+				},
+			],
+			onChange: () => {},
+			onClose: () => {},
+			helpText: "Esc: close",
+		},
+		createThemeStub() as never,
+	);
+	const modal = new ZellijModal(settingsModal, {
+		titleBar: {
+			left: { text: "RTK Integration Settings", maxWidth: 30, color: "accent" },
+			right: { text: "pi-rtk-optimizer", maxWidth: 20, color: "dim" },
+		},
+		helpUndertitle: { text: "Esc: close", color: "dim" },
+		overlay: { anchor: "center", width: 86, maxHeight: "85%", margin: 1 },
+	});
+
+	const rendered = modal.renderModal(86);
+	settingsModal.handleInput("\r");
+	settingsModal.handleInput("j");
+	settingsModal.updateValue("enabled", "off");
+
+	assert.equal(rendered.visibleWidth, 86);
+	assert.equal(rendered.contentWidth, 82);
+	assert.ok(stripAnsi(rendered.lines[0] ?? "").includes("RTK Integration Settings"));
+	assert.ok(stripAnsi(rendered.lines[rendered.lines.length - 1] ?? "").includes("Esc: close"));
+	assert.deepEqual(modal.getOverlayOptions(), {
+		overlay: true,
+		overlayOptions: { anchor: "center", width: 86, maxHeight: "85%", margin: 1 },
+	});
+	assert.deepEqual(settingsListInputs, ["j"]);
+	assert.deepEqual(settingsListUpdates, [{ id: "enabled", value: "off" }]);
+});
+
 runTest("command completions return top-level and filtered RTK subcommands", () => {
 	const topLevel = getRtkArgumentCompletions("");
 	assert.ok(Array.isArray(topLevel));
@@ -77,12 +145,7 @@ runTest("command completions return top-level and filtered RTK subcommands", ()
 	assert.equal(getRtkArgumentCompletions("zzz"), null);
 });
 
-async function runAsyncTest(name: string, testFn: () => Promise<void>): Promise<void> {
-	await testFn();
-	console.log(`[PASS] ${name}`);
-}
-
-await runAsyncTest("config modal command handlers route RTK subcommands to controller actions", async () => {
+await runTest("config modal command handlers route RTK subcommands to controller actions", async () => {
 	const config = cloneDefaultConfig();
 	const controllerState = {
 		config,
@@ -101,7 +164,7 @@ await runAsyncTest("config modal command handlers route RTK subcommands to contr
 		getRuntimeStatus: () => ({ rtkAvailable: false, lastError: "not found" }),
 		refreshRuntimeStatus: async () => {
 			controllerState.refreshed += 1;
-			return { rtkAvailable: false, lastError: "not found" };
+			return { rtkAvailable: true, rtkExecutablePath: "C:/Tools/rtk.exe" };
 		},
 		getMetricsSummary: () => "metrics summary",
 		clearMetrics: () => {
@@ -110,15 +173,16 @@ await runAsyncTest("config modal command handlers route RTK subcommands to contr
 	};
 
 	let registeredName = "";
-	let definition: {
+	type RegisteredCommandDefinition = {
 		description: string;
 		getArgumentCompletions?: (argumentPrefix: string) => Array<{ value: string; label: string; description?: string }> | null;
 		handler: (args: string, ctx: CommandContextStub) => Promise<void>;
-	} | null = null;
+	};
+	let definition: RegisteredCommandDefinition | undefined;
 
 	registerRtkIntegrationCommand(
 		{
-			registerCommand(name: string, nextDefinition: typeof definition) {
+			registerCommand(name: string, nextDefinition: RegisteredCommandDefinition) {
 				registeredName = name;
 				definition = nextDefinition;
 			},
@@ -127,44 +191,46 @@ await runAsyncTest("config modal command handlers route RTK subcommands to contr
 	);
 
 	assert.equal(registeredName, "rtk");
-	assert.ok(definition !== null);
-	assert.ok((definition?.description ?? "").includes("Configure RTK rewrite"));
-	assert.ok(typeof definition?.getArgumentCompletions === "function");
+	if (!definition) {
+		throw new Error("Expected /rtk command definition to be registered");
+	}
+	assert.ok(definition.description.includes("Configure RTK rewrite"));
+	assert.ok(typeof definition.getArgumentCompletions === "function");
 
 	const infoCtx = createNotifyContext(true);
-	await definition?.handler("help", infoCtx.ctx);
+	await definition.handler("help", infoCtx.ctx);
 	assert.ok(lastNotification(infoCtx.notifications).message.includes("Usage: /rtk"));
 
-	await definition?.handler("show", infoCtx.ctx);
+	await definition.handler("show", infoCtx.ctx);
 	assert.ok(lastNotification(infoCtx.notifications).message.includes("mode=rewrite"));
 	assert.ok(lastNotification(infoCtx.notifications).message.includes("rewriteSource=rtk"));
 	assert.equal(lastNotification(infoCtx.notifications).message.includes("categories="), false);
 
-	await definition?.handler("path", infoCtx.ctx);
+	await definition.handler("path", infoCtx.ctx);
 	assert.equal(lastNotification(infoCtx.notifications).message, "rtk config: C:/tmp/pi-rtk-optimizer/config.json");
 
-	await definition?.handler("verify", infoCtx.ctx);
+	await definition.handler("verify", infoCtx.ctx);
 	assert.equal(controllerState.refreshed, 1);
-	assert.equal(lastNotification(infoCtx.notifications).level, "warning");
-	assert.ok(lastNotification(infoCtx.notifications).message.includes("not available: not found"));
+	assert.equal(lastNotification(infoCtx.notifications).level, "info");
+	assert.ok(lastNotification(infoCtx.notifications).message.includes("available at C:/Tools/rtk.exe"));
 
-	await definition?.handler("stats", infoCtx.ctx);
+	await definition.handler("stats", infoCtx.ctx);
 	assert.equal(lastNotification(infoCtx.notifications).message, "metrics summary");
 
-	await definition?.handler("clear-stats", infoCtx.ctx);
+	await definition.handler("clear-stats", infoCtx.ctx);
 	assert.equal(controllerState.cleared, 1);
 	assert.equal(lastNotification(infoCtx.notifications).message, "RTK metrics cleared.");
 
-	await definition?.handler("reset", infoCtx.ctx);
+	await definition.handler("reset", infoCtx.ctx);
 	assert.equal(controllerState.lastSavedMode, "rewrite");
 	assert.equal(lastNotification(infoCtx.notifications).message, "RTK integration settings reset to defaults.");
 
-	await definition?.handler("unknown", infoCtx.ctx);
+	await definition.handler("unknown", infoCtx.ctx);
 	assert.equal(lastNotification(infoCtx.notifications).level, "warning");
 	assert.ok(lastNotification(infoCtx.notifications).message.includes("Usage: /rtk"));
 
 	const headlessCtx = createNotifyContext(false);
-	await definition?.handler("", headlessCtx.ctx);
+	await definition.handler("", headlessCtx.ctx);
 	assert.equal(lastNotification(headlessCtx.notifications).message, "/rtk requires interactive TUI mode.");
 });