pi-rtk-optimizer 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.3] - 2026-06-16
+
+### Fixed
+- Added a runtime-agnostic `mock.module` shim so tests using `node:test` module mocking also pass under Bun's `bun:test` compatibility layer.
+- Deep-cloned fallback default config objects in `config-store.ts` to prevent caller mutations from leaking into subsequent config loads.
+
 ## [0.8.2] - 2026-06-01
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-rtk-optimizer",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "Pi extension that optimizes RTK command rewriting and tool output compaction for the coding agent.",
   "type": "module",
   "main": "./index.ts",
@@ -52,7 +52,7 @@
     "access": "public"
   },
   "devDependencies": {
-    "esbuild": "0.28.0",
+    "esbuild": "0.28.1",
     "typescript": "6.0.3"
   },
   "pi": {
@@ -61,7 +61,7 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.74.0 || ^0.75.0",
-    "@earendil-works/pi-tui": "^0.74.0 || ^0.75.0"
+    "@earendil-works/pi-coding-agent": "^0.74.0 || ^0.75.0 || ^0.78.0 || ^0.79.0",
+    "@earendil-works/pi-tui": "^0.74.0 || ^0.75.0 || ^0.78.0 || ^0.79.0"
   }
 }

package/src/additional-coverage-test.ts

@@ -1,9 +1,8 @@
 import assert from "node:assert/strict";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { mock } from "node:test";
 
 import { clearOutputMetrics, getOutputMetricsSummary, trackOutputSavings } from "./output-metrics.ts";
-import { runTest } from "./test-helpers.ts";
+import { mock, runTest } from "./test-helpers.ts";
 import { matchesCommandPatterns, normalizeCommandForDetection } from "./techniques/command-detection.ts";
 import { compactPath } from "./techniques/path-utils.ts";
 import { applyWindowsBashCompatibilityFixes } from "./windows-command-helpers.ts";
@@ -143,6 +142,25 @@ runTest("config-store falls back to defaults when JSON is invalid", () => {
 	}
 });
 
+runTest("config-store malformed-file defaults are isolated from caller mutation", () => {
+	const tempPath = makeTempConfigPath();
+	cleanupFile(tempPath);
+
+	try {
+		writeFileSync(tempPath, "{not valid json", "utf-8");
+		const firstLoad = loadRtkIntegrationConfig(tempPath);
+		firstLoad.config.outputCompaction.truncate.maxChars = 42_424;
+		firstLoad.config.outputCompaction.readCompaction.enabled = true;
+
+		const secondLoad = loadRtkIntegrationConfig(tempPath);
+
+		assert.equal(secondLoad.config.outputCompaction.truncate.maxChars, 12_000);
+		assert.equal(secondLoad.config.outputCompaction.readCompaction.enabled, false);
+	} finally {
+		cleanupFile(tempPath);
+	}
+});
+
 runTest("output metrics summarize tracked savings and clear state", () => {
 	clearOutputMetrics();
 	assert.equal(getOutputMetricsSummary(), "RTK output compaction metrics: no data yet.");

package/src/command-register.ts

@@ -1,31 +1,31 @@
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { getRtkArgumentCompletions } from "./command-completions.js";
-import type { RtkIntegrationConfig, RuntimeStatus } from "./types.js";
-
-export interface RtkIntegrationController {
-	getConfig(): RtkIntegrationConfig;
-	setConfig(next: RtkIntegrationConfig, ctx: ExtensionCommandContext): void;
-	getConfigPath(): string;
-	getRuntimeStatus(): RuntimeStatus;
-	refreshRuntimeStatus(): Promise<RuntimeStatus>;
-	getMetricsSummary(): string;
-	clearMetrics(): void;
-}
-
-let commandModalModulePromise: Promise<typeof import("./config-modal.js")> | undefined;
-
-function loadCommandModalModule(): Promise<typeof import("./config-modal.js")> {
-	commandModalModulePromise ??= import("./config-modal.js");
-	return commandModalModulePromise;
-}
-
-export function registerRtkIntegrationCommand(pi: ExtensionAPI, controller: RtkIntegrationController): void {
-	pi.registerCommand("rtk", {
-		description: "Configure RTK rewrite and output compaction integration",
-		getArgumentCompletions: getRtkArgumentCompletions,
-		handler: async (args, ctx) => {
-			const { handleRtkIntegrationCommand } = await loadCommandModalModule();
-			await handleRtkIntegrationCommand(args, ctx, controller);
-		},
-	});
-}
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { getRtkArgumentCompletions } from "./command-completions.js";
+import type { RtkIntegrationConfig, RuntimeStatus } from "./types.js";
+
+export interface RtkIntegrationController {
+	getConfig(): RtkIntegrationConfig;
+	setConfig(next: RtkIntegrationConfig, ctx: ExtensionCommandContext): void;
+	getConfigPath(): string;
+	getRuntimeStatus(): RuntimeStatus;
+	refreshRuntimeStatus(): Promise<RuntimeStatus>;
+	getMetricsSummary(): string;
+	clearMetrics(): void;
+}
+
+let commandModalModulePromise: Promise<typeof import("./config-modal.js")> | undefined;
+
+function loadCommandModalModule(): Promise<typeof import("./config-modal.js")> {
+	commandModalModulePromise ??= import("./config-modal.js");
+	return commandModalModulePromise;
+}
+
+export function registerRtkIntegrationCommand(pi: ExtensionAPI, controller: RtkIntegrationController): void {
+	pi.registerCommand("rtk", {
+		description: "Configure RTK rewrite and output compaction integration",
+		getArgumentCompletions: getRtkArgumentCompletions,
+		handler: async (args, ctx) => {
+			const { handleRtkIntegrationCommand } = await loadCommandModalModule();
+			await handleRtkIntegrationCommand(args, ctx, controller);
+		},
+	});
+}

package/src/command-rewriter-test.ts

@@ -89,6 +89,26 @@ await runTest("already rtk unchanged", async () => {
 	assert.equal(decision.reason, "already_rtk");
 });
 
+await runTest("env-prefixed rtk command is treated as already RTK and never re-rewritten", async () => {
+	let execCallCount = 0;
+	const pi = {
+		exec: async () => {
+			execCallCount += 1;
+			return { code: 0, stdout: "rtk rtk status", stderr: "" };
+		},
+	} as unknown as ExtensionAPI;
+
+	const command = "CI=1 RTK_DB_PATH=/tmp/history.db rtk status";
+	const decision = await computeRewriteDecision(command, cloneDefaultConfig(), pi, {
+		executableResolution: { command: "rtk", resolver: "which" },
+	});
+
+	assert.equal(decision.changed, false);
+	assert.equal(decision.rewrittenCommand, command);
+	assert.equal(decision.reason, "already_rtk");
+	assert.equal(execCallCount, 0);
+});
+
 await runTest("rtk unsupported heredoc result leaves command unchanged", async () => {
 	const config = cloneDefaultConfig();
 	const decision = await computeRewriteDecision("cat <<EOF", config, createMockPi({ code: 1 }));
@@ -109,6 +129,25 @@ await runTest("quoted heredoc marker is delegated to RTK rewrite", async () => {
 	assert.equal(decision.reason, "ok");
 });
 
+await runTest("rg rewrite keeps the RTK ripgrep proxy instead of the grep proxy", async () => {
+	const config = cloneDefaultConfig();
+	const command = "cd /workspace && rg -n --glob '!node_modules/**' --glob '!dist/**' \"needle\" src";
+	const decision = await computeRewriteDecision(
+		command,
+		config,
+		createMockPi({
+			code: 3,
+			stdout: "cd /workspace && rtk grep -n --glob '!node_modules/**' --glob '!dist/**' \"needle\" src",
+		}),
+	);
+	assert.equal(decision.changed, true);
+	assert.equal(
+		decision.rewrittenCommand,
+		"cd /workspace && rtk rg -n --glob '!node_modules/**' --glob '!dist/**' \"needle\" src",
+	);
+	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" }));

package/src/command-rewriter.ts

@@ -1,4 +1,5 @@
 import { resolveRtkRewrite, type RtkRewriteProviderOptions } from "./rtk-rewrite-provider.js";
+import { splitLeadingEnvAssignments } from "./shell-env-prefix.js";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { RtkIntegrationConfig } from "./types.js";
 
@@ -21,7 +22,8 @@ export async function computeRewriteDecision(
 	}
 
 	const trimmedStart = command.trimStart();
-	if (trimmedStart === "rtk" || trimmedStart.startsWith("rtk ")) {
+	const effectiveCommand = splitLeadingEnvAssignments(trimmedStart).command.trimStart();
+	if (effectiveCommand === "rtk" || effectiveCommand.startsWith("rtk ")) {
 		return { changed: false, originalCommand: command, rewrittenCommand: command, reason: "already_rtk" };
 	}
 

package/src/config-modal-test.ts

@@ -1,7 +1,6 @@
 import assert from "node:assert/strict";
-import { mock } from "node:test";
 
-import { cloneDefaultConfig, runTest } from "./test-helpers.ts";
+import { cloneDefaultConfig, mock, runTest } from "./test-helpers.ts";
 
 mock.module("@earendil-works/pi-coding-agent", {
 	namedExports: {

package/src/config-store.ts

@@ -177,7 +177,7 @@ export function ensureConfigExists(configPath = CONFIG_PATH): EnsureConfigResult
 
 export function loadRtkIntegrationConfig(configPath = CONFIG_PATH): ConfigLoadResult {
 	if (!existsSync(configPath)) {
-		return { config: { ...DEFAULT_RTK_INTEGRATION_CONFIG } };
+		return { config: structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG) };
 	}
 
 	try {
@@ -187,7 +187,7 @@ export function loadRtkIntegrationConfig(configPath = CONFIG_PATH): ConfigLoadRe
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		return {
-			config: { ...DEFAULT_RTK_INTEGRATION_CONFIG },
+			config: structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG),
 			warning: `Failed to parse ${configPath}: ${message}`,
 		};
 	}

package/src/index-test.ts

@@ -1,7 +1,6 @@
 import assert from "node:assert/strict";
-import { mock } from "node:test";
 
-import { runTest } from "./test-helpers.ts";
+import { mock, runTest } from "./test-helpers.ts";
 
 mock.module("@earendil-works/pi-coding-agent", {
 	namedExports: {

package/src/output-compactor-test.ts

@@ -1,8 +1,7 @@
 import assert from "node:assert/strict";
 import { join } from "node:path";
-import { mock } from "node:test";
 
-import { cloneDefaultConfig, runTest } from "./test-helpers.ts";
+import { cloneDefaultConfig, mock, runTest } from "./test-helpers.ts";
 
 const TEST_AGENT_DIR = "/tmp/.pi/agent";
 

package/src/rtk-rewrite-provider.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { resolveRtkExecutable, type RtkExecutableResolution } from "./rtk-executable-resolver.js";
+import { splitLeadingEnvAssignments } from "./shell-env-prefix.js";
 
 export interface RtkRewriteProviderResult {
 	changed: boolean;
@@ -29,6 +30,113 @@ function normalizeOptions(optionsOrTimeout: number | RtkRewriteProviderOptions):
 	return optionsOrTimeout;
 }
 
+interface ShellSegmentSplit {
+	segments: string[];
+	separators: string[];
+}
+
+function splitTopLevelShellSegments(command: string): ShellSegmentSplit {
+	const segments: string[] = [];
+	const separators: string[] = [];
+	let quote: '"' | "'" | "`" | null = null;
+	let escaped = false;
+	let segmentStart = 0;
+
+	for (let index = 0; index < command.length; index += 1) {
+		const character = command[index] ?? "";
+		const nextCharacter = command[index + 1] ?? "";
+		const previousCharacter = index > 0 ? (command[index - 1] ?? "") : "";
+
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+
+		if (quote !== null) {
+			if (character === "\\" && quote !== "'") {
+				escaped = true;
+				continue;
+			}
+			if (character === quote) {
+				quote = null;
+			}
+			continue;
+		}
+
+		if (character === "\\") {
+			escaped = true;
+			continue;
+		}
+
+		if (character === '"' || character === "'" || character === "`") {
+			quote = character;
+			continue;
+		}
+
+		const twoCharacterOperator = `${character}${nextCharacter}`;
+		const separator =
+			twoCharacterOperator === "&&" || twoCharacterOperator === "||" || twoCharacterOperator === "|&"
+				? twoCharacterOperator
+				: character === ";" || (character === "|" && previousCharacter !== ">")
+					? character
+					: null;
+
+		if (separator === null) {
+			continue;
+		}
+
+		segments.push(command.slice(segmentStart, index));
+		separators.push(separator);
+		index += separator.length - 1;
+		segmentStart = index + 1;
+	}
+
+	segments.push(command.slice(segmentStart));
+	return { segments, separators };
+}
+
+function startsWithRipgrepCommand(segment: string): boolean {
+	const trimmed = segment.trimStart();
+	const effectiveCommand = splitLeadingEnvAssignments(trimmed).command.trimStart();
+	return /^rg(?=\s|$)/u.test(effectiveCommand);
+}
+
+function replaceRtkGrepProxyWithRtkRg(segment: string): string {
+	const leadingWhitespace = segment.match(/^\s*/u)?.[0] ?? "";
+	const withoutLeadingWhitespace = segment.slice(leadingWhitespace.length);
+	const { envPrefix, command } = splitLeadingEnvAssignments(withoutLeadingWhitespace);
+	const nextCommand = command.replace(/^(rtk)(\s+)grep(?=\s|$)/u, "$1$2rg");
+	return nextCommand === command ? segment : `${leadingWhitespace}${envPrefix}${nextCommand}`;
+}
+
+function normalizeRipgrepRewrite(originalCommand: string, rewrittenCommand: string): string {
+	const original = splitTopLevelShellSegments(originalCommand);
+	const rewritten = splitTopLevelShellSegments(rewrittenCommand);
+	if (original.segments.length !== rewritten.segments.length) {
+		return rewrittenCommand;
+	}
+
+	let changed = false;
+	const rewrittenSegments = rewritten.segments.map((segment, index) => {
+		if (!startsWithRipgrepCommand(original.segments[index] ?? "")) {
+			return segment;
+		}
+
+		const nextSegment = replaceRtkGrepProxyWithRtkRg(segment);
+		changed ||= nextSegment !== segment;
+		return nextSegment;
+	});
+
+	if (!changed) {
+		return rewrittenCommand;
+	}
+
+	return rewrittenSegments.reduce((accumulator, segment, index) => {
+		const separator = rewritten.separators[index - 1];
+		return separator === undefined ? segment : `${accumulator}${separator}${segment}`;
+	}, "");
+}
+
 export async function resolveRtkRewrite(
 	pi: ExtensionAPI,
 	command: string,
@@ -76,8 +184,8 @@ export async function resolveRtkRewrite(
 		}
 
 		if (result.code === 0 || result.code === 3) {
-			const rewritten = result.stdout?.trim();
-			if (!rewritten) {
+			const rewrittenOutput = result.stdout?.trim();
+			if (!rewrittenOutput) {
 				return {
 					changed: false,
 					originalCommand: command,
@@ -87,6 +195,7 @@ export async function resolveRtkRewrite(
 					executableResolution,
 				};
 			}
+			const rewritten = normalizeRipgrepRewrite(command, rewrittenOutput);
 			if (rewritten === command) {
 				return {
 					changed: false,

package/src/test-helpers.ts

@@ -1,6 +1,9 @@
+import { mock as nodeTestMockRaw } from "node:test";
+
 import { DEFAULT_RTK_INTEGRATION_CONFIG, type RtkIntegrationConfig } from "./types.ts";
 
 type TestResult = void | Promise<void>;
+type MockModuleOptions = { namedExports?: Record<string, unknown>; defaultExport?: unknown };
 
 function isPromiseLike(value: TestResult): value is Promise<void> {
 	return Boolean(value && typeof (value as Promise<void>).then === "function");
@@ -21,3 +24,35 @@ export function runTest(name: string, testFn: () => TestResult): TestResult {
 export function cloneDefaultConfig(): RtkIntegrationConfig {
 	return structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG);
 }
+
+// Runtime-agnostic module-mocking helper. The tests use the node:test-shaped
+// API (`mock.module(specifier, { namedExports, defaultExport })`). Bun's
+// implementation of `node:test` does not expose `mock.module`, but `bun:test`
+// provides an equivalent that accepts a factory function. We detect the
+// capability and adapt the options form to the factory form when needed.
+const nodeTestMock = nodeTestMockRaw as unknown as { module?: unknown };
+
+let mockModuleImpl: (specifier: string, options: MockModuleOptions) => void;
+
+if (typeof nodeTestMock.module === "function") {
+	mockModuleImpl = nodeTestMock.module as (specifier: string, options: MockModuleOptions) => void;
+} else {
+	const bunTest = (await import("bun:test")) as unknown as {
+		mock: { module: (specifier: string, factory: () => Record<string, unknown>) => void };
+	};
+
+	mockModuleImpl = (specifier, options) => {
+		bunTest.mock.module(specifier, () => {
+			const moduleExports: Record<string, unknown> = {};
+			if (options.defaultExport !== undefined) {
+				moduleExports.default = options.defaultExport;
+			}
+			if (options.namedExports) {
+				Object.assign(moduleExports, options.namedExports);
+			}
+			return moduleExports;
+		});
+	};
+}
+
+export const mock = { module: mockModuleImpl };

package/src/tool-execution-sanitizer.ts

@@ -1,82 +1,82 @@
-import { toRecord } from "./record-utils.js";
-import { stripAnsiFast } from "./techniques/ansi.js";
-import { sanitizeRtkEmojiOutput } from "./techniques/emoji.js";
-import { stripRtkHookWarnings } from "./techniques/rtk.js";
-
-interface ToolResultTextBlock {
-	type: string;
-	text?: string;
-	[key: string]: unknown;
-}
-
-export interface StreamingBashExecutionSanitizationResult {
-	changed: boolean;
-	result: unknown;
-}
-
-function sanitizeStreamingBashText(text: string, command: string | undefined | null): string {
-	let nextText = stripAnsiFast(text);
-
-	const withoutRtkHookWarnings = stripRtkHookWarnings(nextText, command);
-	if (withoutRtkHookWarnings !== null) {
-		nextText = withoutRtkHookWarnings;
-	}
-
-	const withoutRtkEmoji = sanitizeRtkEmojiOutput(nextText, command);
-	if (withoutRtkEmoji !== null) {
-		nextText = withoutRtkEmoji;
-	}
-
-	return nextText;
-}
-
-/**
- * Returns a sanitized shallow copy of streamed bash result blocks before the
- * TUI renders them so RTK self-diagnostics never flash in partial or final
- * tool output. The input object is not mutated.
- */
-export function sanitizeStreamingBashExecutionResult(
-	result: unknown,
-	command: string | undefined | null,
-): StreamingBashExecutionSanitizationResult {
-	const resultRecord = toRecord(result);
-	const sourceContent = Array.isArray(resultRecord.content) ? resultRecord.content : null;
-	if (!sourceContent || sourceContent.length === 0) {
-		return { changed: false, result };
-	}
-
-	let changed = false;
-	const nextContent = sourceContent.map((block) => {
-		if (!block || typeof block !== "object" || Array.isArray(block)) {
-			return block;
-		}
-
-		const contentBlock = block as ToolResultTextBlock;
-		if (contentBlock.type !== "text" || typeof contentBlock.text !== "string") {
-			return block;
-		}
-
-		const sanitizedText = sanitizeStreamingBashText(contentBlock.text, command);
-		if (sanitizedText === contentBlock.text) {
-			return block;
-		}
-
-		changed = true;
-		return {
-			...contentBlock,
-			text: sanitizedText,
-		};
-	});
-
-	if (!changed) {
-		return { changed: false, result };
-	}
-
-	return {
-		changed: true,
-		result: {
-			...resultRecord,
-			content: nextContent,
-		},
-	};
-}
+import { toRecord } from "./record-utils.js";
+import { stripAnsiFast } from "./techniques/ansi.js";
+import { sanitizeRtkEmojiOutput } from "./techniques/emoji.js";
+import { stripRtkHookWarnings } from "./techniques/rtk.js";
+
+interface ToolResultTextBlock {
+	type: string;
+	text?: string;
+	[key: string]: unknown;
+}
+
+export interface StreamingBashExecutionSanitizationResult {
+	changed: boolean;
+	result: unknown;
+}
+
+function sanitizeStreamingBashText(text: string, command: string | undefined | null): string {
+	let nextText = stripAnsiFast(text);
+
+	const withoutRtkHookWarnings = stripRtkHookWarnings(nextText, command);
+	if (withoutRtkHookWarnings !== null) {
+		nextText = withoutRtkHookWarnings;
+	}
+
+	const withoutRtkEmoji = sanitizeRtkEmojiOutput(nextText, command);
+	if (withoutRtkEmoji !== null) {
+		nextText = withoutRtkEmoji;
+	}
+
+	return nextText;
+}
+
+/**
+ * Returns a sanitized shallow copy of streamed bash result blocks before the
+ * TUI renders them so RTK self-diagnostics never flash in partial or final
+ * tool output. The input object is not mutated.
+ */
+export function sanitizeStreamingBashExecutionResult(
+	result: unknown,
+	command: string | undefined | null,
+): StreamingBashExecutionSanitizationResult {
+	const resultRecord = toRecord(result);
+	const sourceContent = Array.isArray(resultRecord.content) ? resultRecord.content : null;
+	if (!sourceContent || sourceContent.length === 0) {
+		return { changed: false, result };
+	}
+
+	let changed = false;
+	const nextContent = sourceContent.map((block) => {
+		if (!block || typeof block !== "object" || Array.isArray(block)) {
+			return block;
+		}
+
+		const contentBlock = block as ToolResultTextBlock;
+		if (contentBlock.type !== "text" || typeof contentBlock.text !== "string") {
+			return block;
+		}
+
+		const sanitizedText = sanitizeStreamingBashText(contentBlock.text, command);
+		if (sanitizedText === contentBlock.text) {
+			return block;
+		}
+
+		changed = true;
+		return {
+			...contentBlock,
+			text: sanitizedText,
+		};
+	});
+
+	if (!changed) {
+		return { changed: false, result };
+	}
+
+	return {
+		changed: true,
+		result: {
+			...resultRecord,
+			content: nextContent,
+		},
+	};
+}

package/src/types-shims.d.ts

@@ -168,6 +168,12 @@ declare module "node:test" {
 	};
 }
 
+declare module "bun:test" {
+	export const mock: {
+		module(specifier: string, factory: () => Record<string, unknown>): void;
+	};
+}
+
 declare const process: {
 	platform: string;
 	env: Record<string, string | undefined>;