pi-rtk-optimizer 0.7.0 → 0.8.0

package/src/config-modal.ts

@@ -1,5 +1,5 @@
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
-import type { SettingItem } from "@mariozechner/pi-tui";
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { SettingItem } from "@earendil-works/pi-tui";
 import { toOnOff } from "./boolean-format.js";
 import { ZellijModal, ZellijSettingsModal } from "./zellij-modal.js";
 import { getRtkArgumentCompletions } from "./command-completions.js";
@@ -31,6 +31,70 @@ const TRUNCATE_MAX_CHAR_VALUES = ["4000", "8000", "12000", "20000", "50000", "10
 const SMART_TRUNCATE_LINE_VALUES = ["40", "80", "120", "160", "220", "320", "500", "1000", "2000", "4000"];
 const RTK_USAGE_TEXT =
 	"Usage: /rtk [show|path|verify|stats|clear-stats|reset|help] (or run /rtk with no args to open settings modal)";
+const SETTINGS_TAB_DEFINITIONS = [
+	{
+		label: "General",
+		settingIds: ["enabled", "mode", "showRewriteNotifications", "guardWhenRtkMissing"],
+	},
+	{
+		label: "Compaction",
+		settingIds: [
+			"outputCompactionEnabled",
+			"outputStripAnsi",
+			"outputAggregateTestOutput",
+			"outputFilterBuildOutput",
+			"outputCompactGitOutput",
+			"outputAggregateLinterOutput",
+			"outputGroupSearchOutput",
+			"outputTrackSavings",
+		],
+	},
+	{
+		label: "Read & Source",
+		settingIds: [
+			"outputReadCompactionEnabled",
+			"outputSourceFilteringEnabled",
+			"outputSourceFiltering",
+			"outputPreserveExactSkillReads",
+		],
+	},
+	{
+		label: "Truncation",
+		settingIds: [
+			"outputTruncateEnabled",
+			"outputTruncateMaxChars",
+			"outputSmartTruncate",
+			"outputSmartTruncateMaxLines",
+		],
+	},
+] as const;
+
+function buildTabbedSettingGroups(settings: SettingItem[]): Array<{ label: string; settings: SettingItem[] }> {
+	const byId = new Map(settings.map((setting) => [setting.id, setting]));
+	const assignedIds = new Set<string>();
+
+	const tabs = SETTINGS_TAB_DEFINITIONS.map(({ label, settingIds }) => ({
+		label,
+		settings: settingIds.map((id) => {
+			const setting = byId.get(id);
+			if (!setting) {
+				throw new Error(`Missing setting item for tab '${label}': ${id}`);
+			}
+			if (assignedIds.has(id)) {
+				throw new Error(`Setting item assigned to multiple tabs: ${id}`);
+			}
+			assignedIds.add(id);
+			return setting;
+		}),
+	}));
+
+	const unassignedIds = settings.map((setting) => setting.id).filter((id) => !assignedIds.has(id));
+	if (unassignedIds.length > 0) {
+		throw new Error(`Unassigned setting items: ${unassignedIds.join(", ")}`);
+	}
+
+	return tabs;
+}
 
 function parseSourceFilterLevel(
 	value: string,
@@ -53,12 +117,21 @@ function parseIntegerInRange(value: string, min: number, max: number): number |
 	return parsed;
 }
 
-function summarizeConfig(config: RtkIntegrationConfig, runtimeStatus: RuntimeStatus): string {
+function summarizeRuntimeStatus(runtimeStatus: RuntimeStatus): string {
 	const runtime = runtimeStatus.rtkAvailable
 		? "rtk=available"
 		: `rtk=missing${runtimeStatus.lastError ? ` (${runtimeStatus.lastError})` : ""}`;
+	const executable = runtimeStatus.rtkExecutablePath
+		? `, rtkPath=${runtimeStatus.rtkExecutablePath}`
+		: runtimeStatus.rtkExecutableResolutionWarning
+			? `, rtkPath=unresolved (${runtimeStatus.rtkExecutableResolutionWarning})`
+			: "";
 
-	return `enabled=${config.enabled}, mode=${config.mode}, rewriteSource=rtk, rewriteNotice=${config.showRewriteNotifications}, compaction=${config.outputCompaction.enabled}, readCompaction=${config.outputCompaction.readCompaction.enabled}, sourceFilterEnabled=${config.outputCompaction.sourceCodeFilteringEnabled}, preserveSkillReads=${config.outputCompaction.preserveExactSkillReads}, sourceFilter=${config.outputCompaction.sourceCodeFiltering}, ${runtime}`;
+	return `${runtime}${executable}`;
+}
+
+function summarizeConfig(config: RtkIntegrationConfig, runtimeStatus: RuntimeStatus): string {
+	return `enabled=${config.enabled}, mode=${config.mode}, rewriteSource=rtk, rewriteNotice=${config.showRewriteNotifications}, compaction=${config.outputCompaction.enabled}, readCompaction=${config.outputCompaction.readCompaction.enabled}, sourceFilterEnabled=${config.outputCompaction.sourceCodeFilteringEnabled}, preserveSkillReads=${config.outputCompaction.preserveExactSkillReads}, sourceFilter=${config.outputCompaction.sourceCodeFiltering}, ${summarizeRuntimeStatus(runtimeStatus)}`;
 }
 
 function buildSettingItems(config: RtkIntegrationConfig): SettingItem[] {
@@ -391,12 +464,14 @@ async function openSettingsModal(ctx: ExtensionCommandContext, controller: RtkIn
 		(tui, theme, _keybindings, done) => {
 			let current = controller.getConfig();
 			let settingsModal: ZellijSettingsModal | null = null;
+			const allSettings = buildSettingItems(current);
+			const tabs = buildTabbedSettingGroups(allSettings);
 
 			settingsModal = new ZellijSettingsModal(
 				{
-					title: "RTK Integration Settings",
-					description: "Bash rewrite + tool output compaction for lower token usage",
-					settings: buildSettingItems(current),
+					title: "Pi RTK Optimizer",
+					tabs,
+					activeTabIndex: 0,
 					onChange: (id, newValue) => {
 						current = applySetting(current, id, newValue);
 						controller.setConfig(current, ctx);
@@ -406,7 +481,7 @@ async function openSettingsModal(ctx: ExtensionCommandContext, controller: RtkIn
 						}
 					},
 					onClose: () => done(),
-					helpText: `/rtk show • /rtk verify • /rtk stats • /rtk reset • ${controller.getConfigPath()}`,
+					helpText: `Config: ${controller.getConfigPath()}`,
 					enableSearch: true,
 				},
 				theme,
@@ -417,11 +492,14 @@ async function openSettingsModal(ctx: ExtensionCommandContext, controller: RtkIn
 				{
 					borderStyle: "rounded",
 					titleBar: {
-						left: "RTK Integration Settings",
-						right: "pi-rtk-optimizer",
+						left: "Pi RTK Optimizer",
 					},
 					helpUndertitle: {
-						text: "Esc: close | ↑↓: navigate | Space: toggle",
+						variants: [
+							"←/→ tabs • Type to search • Enter/Space change • Esc close",
+							"←/→ tabs • Type to search • Esc close",
+							"←/→ tabs • Esc close",
+						],
 						color: "dim",
 					},
 					overlay: overlayOptions,
@@ -474,7 +552,8 @@ async function handleArgs(
 	if (normalized === "verify") {
 		const runtimeStatus = await controller.refreshRuntimeStatus();
 		if (runtimeStatus.rtkAvailable) {
-			ctx.ui.notify("RTK binary is available.", "info");
+			const pathDetail = runtimeStatus.rtkExecutablePath ? ` at ${runtimeStatus.rtkExecutablePath}` : "";
+			ctx.ui.notify(`RTK binary is available${pathDetail}.`, "info");
 		} else {
 			ctx.ui.notify(
 				`RTK binary is not available${runtimeStatus.lastError ? `: ${runtimeStatus.lastError}` : ""}.`,

package/src/constants.ts

@@ -1,4 +1,4 @@
-import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { join } from "node:path";
 
 export const EXTENSION_NAME = "pi-rtk-optimizer";

package/src/index-test.ts

@@ -3,13 +3,13 @@ import { mock } from "bun:test";
 
 import { runTest } from "./test-helpers.ts";
 
-mock.module("@mariozechner/pi-coding-agent", () => ({
+mock.module("@earendil-works/pi-coding-agent", () => ({
 	getAgentDir: () => "/tmp/.pi/agent",
 	getSettingsListTheme: () => ({}),
 	isToolCallEventType: (toolName: string, event: Record<string, unknown>) => event.toolName === toolName,
 }));
 
-mock.module("@mariozechner/pi-tui", () => ({
+mock.module("@earendil-works/pi-tui", () => ({
 	Box: class {},
 	Container: class {
 		addChild(): void {}
@@ -28,9 +28,33 @@ mock.module("@mariozechner/pi-tui", () => ({
 	visibleWidth: (text: string) => text.length,
 }));
 
-const { createBoundedNoticeTracker, shouldInjectSourceFilterTroubleshootingNote } = await import("./index.ts");
+const indexModule = await import("./index.ts");
+const { createBoundedNoticeTracker, shouldInjectSourceFilterTroubleshootingNote } = indexModule;
+const rtkIntegrationExtension = indexModule.default;
 const { DEFAULT_RTK_INTEGRATION_CONFIG } = await import("./types.ts");
 
+type Notification = { message: string; level: "info" | "warning" | "error" };
+type ExtensionHandler = (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<Record<string, unknown> | void>;
+
+function createNotificationContext(notifications: Notification[]): Record<string, unknown> {
+	return {
+		hasUI: true,
+		ui: {
+			notify(message: string, level: "info" | "warning" | "error") {
+				notifications.push({ message, level });
+			},
+		},
+	};
+}
+
+function firstText(content: unknown): string {
+	if (!Array.isArray(content) || content.length === 0) {
+		return "";
+	}
+	const block = content[0] as { type?: string; text?: string };
+	return block.type === "text" && typeof block.text === "string" ? block.text : "";
+}
+
 function configWith(overrides: {
 	enabled?: boolean;
 	compactionEnabled?: boolean;
@@ -160,4 +184,175 @@ runTest("source-filter note skipped when all read filtering safeguards are disab
 	);
 });
 
+await runTest("session_start refreshes RTK provenance and runtime guard skips missing rewrites", async () => {
+	const handlers: Record<string, ExtensionHandler> = {};
+	const notifications: Notification[] = [];
+	const execCommands: string[] = [];
+	let rtkAvailable = false;
+	let rewriteCalls = 0;
+
+	rtkIntegrationExtension({
+		exec: async (command: string, args: string[]) => {
+			execCommands.push(command);
+			if (command === "which" || command === "where") {
+				return { code: 0, stdout: "/opt/rtk/bin/rtk\n", stderr: "" };
+			}
+			if (args[0] === "--version") {
+				return rtkAvailable
+					? { code: 0, stdout: "rtk 1.0.0", stderr: "" }
+					: { code: 1, stdout: "", stderr: "missing rtk" };
+			}
+			if (args[0] === "rewrite") {
+				rewriteCalls += 1;
+				return { code: 3, stdout: "rtk git status", stderr: "" };
+			}
+			return { code: 1, stdout: "", stderr: "unexpected" };
+		},
+		on(eventName: string, handler: ExtensionHandler) {
+			handlers[eventName] = handler;
+		},
+		registerCommand() {},
+	} as never);
+
+	const sessionStartHandler = handlers.session_start;
+	const toolCallHandler = handlers.tool_call;
+	assert.ok(sessionStartHandler);
+	assert.ok(toolCallHandler);
+
+	await sessionStartHandler({}, createNotificationContext(notifications));
+	const skippedEvent = { toolName: "bash", input: { command: "git status" } };
+	await toolCallHandler(skippedEvent, createNotificationContext(notifications));
+
+	assert.equal((skippedEvent.input as { command: string }).command, "git status");
+	assert.equal(rewriteCalls, 0);
+	assert.ok(notifications.some((notice) => notice.message.includes("rtk binary unavailable")));
+
+	rtkAvailable = true;
+	await sessionStartHandler({}, createNotificationContext(notifications));
+	const rewrittenEvent = { toolName: "bash", input: { command: "git status" } };
+	await toolCallHandler(rewrittenEvent, createNotificationContext(notifications));
+
+	assert.equal(rewriteCalls, 1);
+	assert.ok((rewrittenEvent.input as { command: string }).command.includes("rtk git status"));
+	assert.ok(execCommands.includes("/opt/rtk/bin/rtk"));
+});
+
+await runTest("tool execution lifecycle sanitizes streamed bash output", async () => {
+	const handlers: Record<string, ExtensionHandler> = {};
+
+	rtkIntegrationExtension({
+		exec: async () => ({ code: 0, stdout: "rtk 1.0.0", stderr: "" }),
+		on(eventName: string, handler: ExtensionHandler) {
+			handlers[eventName] = handler;
+		},
+		registerCommand() {},
+	} as never);
+
+	const startHandler = handlers.tool_execution_start;
+	const updateHandler = handlers.tool_execution_update;
+	const endHandler = handlers.tool_execution_end;
+	assert.ok(startHandler);
+	assert.ok(updateHandler);
+	assert.ok(endHandler);
+
+	await startHandler(
+		{ toolName: "bash", toolCallId: "bash-1", args: { command: "rtk git status" } },
+		{},
+	);
+	const updateEvent = {
+		toolName: "bash",
+		toolCallId: "bash-1",
+		args: { command: "rtk git status" },
+		partialResult: {
+			content: [
+				{
+					type: "text",
+					text: "[rtk] /!\\ No hook installed — run `rtk init -g` for automatic token savings\n\nworking tree clean\n",
+				},
+			],
+		},
+	};
+	await updateHandler(updateEvent, {});
+	assert.equal(firstText(updateEvent.partialResult.content), "working tree clean\n");
+
+	const endEvent = {
+		toolName: "bash",
+		toolCallId: "bash-1",
+		result: { content: [{ type: "text", text: "📄 src/file.ts\n✅ Files are identical\n" }] },
+	};
+	await endHandler(endEvent, {});
+	assert.equal(firstText(endEvent.result.content), "> src/file.ts\n[OK] Files are identical\n");
+});
+
+await runTest("tool_result lifecycle merges compaction metadata with existing details", async () => {
+	const handlers: Record<string, ExtensionHandler> = {};
+	const notifications: Notification[] = [];
+
+	rtkIntegrationExtension({
+		exec: async () => ({ code: 0, stdout: "rtk 1.0.0", stderr: "" }),
+		on(eventName: string, handler: ExtensionHandler) {
+			handlers[eventName] = handler;
+		},
+		registerCommand() {},
+	} as never);
+
+	const toolResultHandler = handlers.tool_result;
+	assert.ok(toolResultHandler);
+	const result = await toolResultHandler(
+		{
+			toolName: "grep",
+			input: { pattern: "TODO" },
+			content: [{ type: "text", text: "src/a.ts:1:TODO\nsrc/b.ts:2:TODO\n" }],
+			details: { metadata: { requestId: "abc" }, traceId: "trace-1" },
+		},
+		createNotificationContext(notifications),
+	);
+
+	assert.ok(result);
+	assert.ok(firstText(result.content).startsWith("2 matches in 2 files:"));
+	assert.equal((result.details as { traceId?: string }).traceId, "trace-1");
+	const details = result.details as { rtkCompaction?: { applied: boolean }; metadata?: Record<string, unknown> };
+	assert.equal(details.rtkCompaction?.applied, true);
+	assert.deepEqual(details.metadata?.requestId, "abc");
+	assert.equal((details.metadata?.rtkCompaction as { applied?: boolean } | undefined)?.applied, true);
+	assert.equal(notifications.length, 0);
+});
+
+await runTest("tool_call surfaces RTK rewrite errors through existing UI warning path", async () => {
+	const handlers: Record<string, (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<Record<string, unknown> | void>> = {};
+	const notifications: Notification[] = [];
+
+	rtkIntegrationExtension({
+		exec: async (_command: string, args: string[]) => {
+			if (args[0] === "--version") {
+				return { code: 0, stdout: "rtk 1.0.0", stderr: "" };
+			}
+
+			return { code: 2, stdout: "", stderr: "denied unsafe rewrite" };
+		},
+		on(eventName: string, handler: (event: Record<string, unknown>, ctx: Record<string, unknown>) => Promise<Record<string, unknown> | void>) {
+			handlers[eventName] = handler;
+		},
+		registerCommand() {},
+	} as never);
+
+	const toolCallHandler = handlers.tool_call;
+	assert.ok(toolCallHandler);
+	const event = { toolName: "bash", input: { command: "git status" } };
+	await toolCallHandler(event, {
+		hasUI: true,
+		ui: {
+			notify(message: string, level: "info" | "warning" | "error") {
+				notifications.push({ message, level });
+			},
+		},
+	});
+
+	assert.equal((event.input as { command: string }).command, "git status");
+	assert.equal(notifications.length, 1);
+	assert.equal(notifications[0]?.level, "warning");
+	assert.ok(notifications[0]?.message.includes("rtk rewrite skipped"));
+	assert.ok(notifications[0]?.message.includes("denied unsafe rewrite"));
+});
+
 console.log("All index tests passed.");

package/src/index.ts

@@ -1,4 +1,4 @@
-import { isToolCallEventType, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { isToolCallEventType, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	ensureConfigExists,
 	getRtkIntegrationConfigPath,
@@ -13,6 +13,7 @@ import { clearOutputMetrics, getOutputMetricsSummary } from "./output-metrics.js
 import { compactToolResult, type ToolResultCompactionMetadata } from "./output-compactor.js";
 import { toRecord } from "./record-utils.js";
 import { applyRtkCommandEnvironment } from "./rtk-command-environment.js";
+import { resolveRtkExecutable, type RtkExecutableResolution } from "./rtk-executable-resolver.js";
 import { applyRewrittenCommandShellSafetyFixups } from "./rewrite-pipeline-safety.js";
 import { shouldRequireRtkAvailabilityForCommandHandling, shouldSkipCommandHandlingWhenRtkMissing } from "./runtime-guard.js";
 import { sanitizeStreamingBashExecutionResult } from "./tool-execution-sanitizer.js";
@@ -115,6 +116,12 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 		return `RTK rewrite: ${original} -> ${rewritten}`;
 	};
 
+	const formatRewriteWarning = (command: string, warning: string): string => {
+		const target = trimMessage(command, 100);
+		const detail = trimMessage(warning, 120);
+		return `${EXTENSION_NAME}: rtk rewrite skipped for '${target}' (${detail}).`;
+	};
+
 	const warnOnce = (
 		ctx: ExtensionContext | ExtensionCommandContext,
 		message: string,
@@ -190,12 +197,18 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 	};
 
 	const refreshRuntimeStatus = async (): Promise<RuntimeStatus> => {
+		let executableResolution: RtkExecutableResolution | undefined;
 		try {
-			const result = await pi.exec("rtk", ["--version"], { timeout: 5000 });
+			executableResolution = await resolveRtkExecutable(pi);
+			const result = await pi.exec(executableResolution.command, ["--version"], { timeout: 5000 });
 			if (result.code === 0) {
 				runtimeStatus = {
 					rtkAvailable: true,
 					lastCheckedAt: Date.now(),
+					rtkExecutablePath: executableResolution.resolvedPath,
+					rtkExecutableCommand: executableResolution.command,
+					rtkExecutableResolver: executableResolution.resolver,
+					rtkExecutableResolutionWarning: executableResolution.warning,
 				};
 				missingRtkWarningShown = false;
 				return runtimeStatus;
@@ -208,6 +221,10 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 				rtkAvailable: false,
 				lastCheckedAt: Date.now(),
 				lastError: detail || `exit ${result.code}`,
+				rtkExecutablePath: executableResolution.resolvedPath,
+				rtkExecutableCommand: executableResolution.command,
+				rtkExecutableResolver: executableResolution.resolver,
+				rtkExecutableResolutionWarning: executableResolution.warning,
 			};
 			return runtimeStatus;
 		} catch (error) {
@@ -216,6 +233,10 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 				rtkAvailable: false,
 				lastCheckedAt: Date.now(),
 				lastError: trimMessage(message),
+				rtkExecutablePath: executableResolution?.resolvedPath,
+				rtkExecutableCommand: executableResolution?.command,
+				rtkExecutableResolver: executableResolution?.resolver,
+				rtkExecutableResolutionWarning: executableResolution?.warning,
 			};
 			return runtimeStatus;
 		}
@@ -303,10 +324,13 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 		}
 
 		trackBashCommand(eventRecord.toolCallId, eventRecord.args);
-		sanitizeStreamingBashExecutionResult(
+		const sanitization = sanitizeStreamingBashExecutionResult(
 			eventRecord.partialResult,
 			getTrackedBashCommand(eventRecord.toolCallId),
 		);
+		if (sanitization.changed) {
+			eventRecord.partialResult = sanitization.result;
+		}
 	});
 
 	pi.on("tool_execution_end", async (event) => {
@@ -317,7 +341,13 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 
 		try {
 			if (config.enabled && config.outputCompaction.enabled) {
-				sanitizeStreamingBashExecutionResult(eventRecord.result, getTrackedBashCommand(eventRecord.toolCallId));
+				const sanitization = sanitizeStreamingBashExecutionResult(
+					eventRecord.result,
+					getTrackedBashCommand(eventRecord.toolCallId),
+				);
+				if (sanitization.changed) {
+					eventRecord.result = sanitization.result;
+				}
 			}
 		} finally {
 			forgetTrackedBashCommand(eventRecord.toolCallId);
@@ -362,8 +392,22 @@ export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
 			return {};
 		}
 
-		const decision = await computeRewriteDecision(event.input.command, config, pi);
+		let executableResolution: RtkExecutableResolution | undefined;
+		if (runtimeStatus.rtkExecutableCommand) {
+			const resolver: RtkExecutableResolution["resolver"] =
+				runtimeStatus.rtkExecutableResolver === "where" ? "where" : "which";
+			executableResolution = {
+				command: runtimeStatus.rtkExecutableCommand,
+				resolvedPath: runtimeStatus.rtkExecutablePath,
+				resolver,
+				warning: runtimeStatus.rtkExecutableResolutionWarning,
+			};
+		}
+		const decision = await computeRewriteDecision(event.input.command, config, pi, { executableResolution });
 		if (!decision.changed) {
+			if (decision.warning) {
+				warnOnce(ctx, formatRewriteWarning(decision.originalCommand, decision.warning));
+			}
 			return {};
 		}