pi-rtk-optimizer 0.6.0 → 0.7.1

package/src/rtk-rewrite-provider.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { resolveRtkExecutable, type RtkExecutableResolution } from "./rtk-executable-resolver.js";
 
 export interface RtkRewriteProviderResult {
 	changed: boolean;
@@ -6,6 +7,14 @@ export interface RtkRewriteProviderResult {
 	rewrittenCommand: string;
 	exitCode: number;
 	error?: string;
+	executableResolution?: RtkExecutableResolution;
+}
+
+export interface RtkRewriteProviderOptions {
+	timeoutMs?: number;
+	resolverTimeoutMs?: number;
+	platform?: typeof process.platform;
+	executableResolution?: RtkExecutableResolution;
 }
 
 function isAlreadyRtk(command: string): boolean {
@@ -13,11 +22,21 @@ function isAlreadyRtk(command: string): boolean {
 	return trimmed === "rtk" || trimmed.startsWith("rtk ");
 }
 
+function normalizeOptions(optionsOrTimeout: number | RtkRewriteProviderOptions): RtkRewriteProviderOptions {
+	if (typeof optionsOrTimeout === "number") {
+		return { timeoutMs: optionsOrTimeout };
+	}
+	return optionsOrTimeout;
+}
+
 export async function resolveRtkRewrite(
 	pi: ExtensionAPI,
 	command: string,
-	timeoutMs = 3000,
+	optionsOrTimeout: number | RtkRewriteProviderOptions = {},
 ): Promise<RtkRewriteProviderResult> {
+	const options = normalizeOptions(optionsOrTimeout);
+	const timeoutMs = options.timeoutMs ?? 3000;
+
 	if (!command || !command.trim()) {
 		return { changed: false, originalCommand: command, rewrittenCommand: command, exitCode: 1 };
 	}
@@ -27,10 +46,22 @@ export async function resolveRtkRewrite(
 	}
 
 	try {
-		const result = await pi.exec("rtk", ["rewrite", command], { timeout: timeoutMs });
+		const executableResolution =
+			options.executableResolution ??
+			(await resolveRtkExecutable(pi, {
+				platform: options.platform,
+				timeoutMs: options.resolverTimeoutMs,
+			}));
+		const result = await pi.exec(executableResolution.command, ["rewrite", command], { timeout: timeoutMs });
 
 		if (result.code === 1) {
-			return { changed: false, originalCommand: command, rewrittenCommand: command, exitCode: 1 };
+			return {
+				changed: false,
+				originalCommand: command,
+				rewrittenCommand: command,
+				exitCode: 1,
+				executableResolution,
+			};
 		}
 
 		if (result.code === 2) {
@@ -40,6 +71,7 @@ export async function resolveRtkRewrite(
 				rewrittenCommand: command,
 				exitCode: 2,
 				error: result.stderr?.trim() || "rtk denied rewrite",
+				executableResolution,
 			};
 		}
 
@@ -52,6 +84,7 @@ export async function resolveRtkRewrite(
 					rewrittenCommand: command,
 					exitCode: result.code,
 					error: "rtk returned empty output",
+					executableResolution,
 				};
 			}
 			if (rewritten === command) {
@@ -60,6 +93,7 @@ export async function resolveRtkRewrite(
 					originalCommand: command,
 					rewrittenCommand: command,
 					exitCode: result.code,
+					executableResolution,
 				};
 			}
 			return {
@@ -67,6 +101,7 @@ export async function resolveRtkRewrite(
 				originalCommand: command,
 				rewrittenCommand: rewritten,
 				exitCode: result.code,
+				executableResolution,
 			};
 		}
 
@@ -76,6 +111,7 @@ export async function resolveRtkRewrite(
 			rewrittenCommand: command,
 			exitCode: result.code,
 			error: `unexpected exit code ${result.code}`,
+			executableResolution,
 		};
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);

package/src/shell-env-prefix.ts

@@ -1,4 +1,8 @@
-const LEADING_ENV_ASSIGNMENT_PATTERN = /^((?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+)*)/;
+const SINGLE_QUOTED_SHELL_VALUE_PATTERN = "'(?:'\\\\''|[^'])*'";
+const ENV_ASSIGNMENT_VALUE_PATTERN = `(?:"[^"]*"|${SINGLE_QUOTED_SHELL_VALUE_PATTERN}|[^\\s]+)`;
+const LEADING_ENV_ASSIGNMENT_PATTERN = new RegExp(
+	`^((?:[A-Za-z_][A-Za-z0-9_]*=${ENV_ASSIGNMENT_VALUE_PATTERN}\\s+)*)`,
+);
 
 export interface LeadingEnvAssignmentSplit {
 	envPrefix: string;

package/src/test-helpers.ts

@@ -1,10 +1,23 @@
-import { DEFAULT_RTK_INTEGRATION_CONFIG, type RtkIntegrationConfig } from "./types.ts";
-
-export function runTest(name: string, testFn: () => void): void {
-	testFn();
-	console.log(`[PASS] ${name}`);
-}
-
-export function cloneDefaultConfig(): RtkIntegrationConfig {
-	return structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG);
-}
+import { DEFAULT_RTK_INTEGRATION_CONFIG, type RtkIntegrationConfig } from "./types.ts";
+
+type TestResult = void | Promise<void>;
+
+function isPromiseLike(value: TestResult): value is Promise<void> {
+	return Boolean(value && typeof (value as Promise<void>).then === "function");
+}
+
+export function runTest(name: string, testFn: () => TestResult): TestResult {
+	const result = testFn();
+	if (!isPromiseLike(result)) {
+		console.log(`[PASS] ${name}`);
+		return;
+	}
+
+	return result.then(() => {
+		console.log(`[PASS] ${name}`);
+	});
+}
+
+export function cloneDefaultConfig(): RtkIntegrationConfig {
+	return structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG);
+}

package/src/tool-execution-sanitizer.ts

@@ -1,69 +1,80 @@
-import { toRecord } from "./record-utils.js";
-import { sanitizeRtkEmojiOutput, stripAnsiFast, stripRtkHookWarnings } from "./techniques/index.js";
-
-interface ToolResultTextBlock {
-	type: string;
-	text?: string;
-	[key: string]: 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;
-}
-
-/**
- * Sanitizes streamed bash result blocks before the TUI renders them so RTK
- * self-diagnostics never flash in partial or final tool output.
- */
-export function sanitizeStreamingBashExecutionResult(
-	result: unknown,
-	command: string | undefined | null,
-): boolean {
-	const resultRecord = toRecord(result);
-	const sourceContent = Array.isArray(resultRecord.content) ? resultRecord.content : null;
-	if (!sourceContent || sourceContent.length === 0) {
-		return false;
-	}
-
-	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 false;
-	}
-
-	resultRecord.content = nextContent;
-	return true;
-}
+import { toRecord } from "./record-utils.js";
+import { sanitizeRtkEmojiOutput, stripAnsiFast, stripRtkHookWarnings } from "./techniques/index.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.ts

@@ -7,6 +7,9 @@ export type RtkSourceFilterLevel = (typeof RTK_SOURCE_FILTER_LEVELS)[number];
 export interface RtkOutputCompactionConfig {
 	enabled: boolean;
 	stripAnsi: boolean;
+	readCompaction: {
+		enabled: boolean;
+	};
 	truncate: {
 		enabled: boolean;
 		maxChars: number;
@@ -42,15 +45,18 @@ export const DEFAULT_RTK_INTEGRATION_CONFIG: RtkIntegrationConfig = {
 	outputCompaction: {
 		enabled: true,
 		stripAnsi: true,
+		readCompaction: {
+			enabled: false,
+		},
 		truncate: {
 			enabled: true,
 			maxChars: 12_000,
 		},
-		sourceCodeFilteringEnabled: true,
+		sourceCodeFilteringEnabled: false,
 		preserveExactSkillReads: false,
-		sourceCodeFiltering: "minimal",
+		sourceCodeFiltering: "none",
 		smartTruncate: {
-			enabled: true,
+			enabled: false,
 			maxLines: 220,
 		},
 		aggregateTestOutput: true,
@@ -81,5 +87,9 @@ export interface RuntimeStatus {
 	rtkAvailable: boolean;
 	lastCheckedAt?: number;
 	lastError?: string;
+	rtkExecutablePath?: string;
+	rtkExecutableCommand?: string;
+	rtkExecutableResolver?: string;
+	rtkExecutableResolutionWarning?: string;
 }
 

package/src/windows-command-helpers.ts

@@ -3,6 +3,12 @@ interface WindowsBashCompatibilityResult {
 	applied: string[];
 }
 
+interface LeadingCdSlashDParse {
+	rawPath: string;
+	operator: string;
+	tail: string;
+}
+
 const PYTHON_UTF8_ENV_PREFIX = "PYTHONIOENCODING=utf-8";
 
 function normalizeWindowsPathForBash(rawPath: string): string {
@@ -20,29 +26,96 @@ function quoteForBash(value: string): string {
 	return `"${escaped}"`;
 }
 
+function parseLeadingCdSlashD(command: string): LeadingCdSlashDParse | null {
+	const prefixMatch = command.match(/^\s*cd\s+\/d\s+/i);
+	if (!prefixMatch) {
+		return null;
+	}
+
+	const pathStart = prefixMatch[0].length;
+	let quote: '"' | "'" | null = null;
+	let escaped = false;
+
+	for (let index = pathStart; index < command.length; index += 1) {
+		const character = command[index] ?? "";
+		const nextCharacter = 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 === "'") {
+			quote = character;
+			continue;
+		}
+
+		if (character === "&" && nextCharacter === "&") {
+			return {
+				rawPath: command.slice(pathStart, index),
+				operator: "&&",
+				tail: command.slice(index + 2),
+			};
+		}
+
+		if (character === "|" && nextCharacter === "|") {
+			return {
+				rawPath: command.slice(pathStart, index),
+				operator: "||",
+				tail: command.slice(index + 2),
+			};
+		}
+
+		if (character === "|" || character === ";") {
+			return {
+				rawPath: command.slice(pathStart, index),
+				operator: character,
+				tail: command.slice(index + 1),
+			};
+		}
+	}
+
+	return {
+		rawPath: command.slice(pathStart),
+		operator: "",
+		tail: "",
+	};
+}
+
 function rewriteLeadingCdSlashD(command: string): { command: string; changed: boolean } {
-	const withTailMatch = command.match(/^\s*cd\s+\/d\s+(.+?)\s*&&\s*([\s\S]+)$/i);
-	if (withTailMatch) {
-		const rawPath = withTailMatch[1] ?? "";
-		const tail = withTailMatch[2] ?? "";
-		const normalizedPath = quoteForBash(normalizeWindowsPathForBash(rawPath));
-		return {
-			command: `cd ${normalizedPath} && ${tail}`,
-			changed: true,
-		};
+	const parsed = parseLeadingCdSlashD(command);
+	if (!parsed) {
+		return { command, changed: false };
 	}
 
-	const onlyCdMatch = command.match(/^\s*cd\s+\/d\s+(.+)$/i);
-	if (onlyCdMatch) {
-		const rawPath = onlyCdMatch[1] ?? "";
-		const normalizedPath = quoteForBash(normalizeWindowsPathForBash(rawPath));
+	const normalizedPath = quoteForBash(normalizeWindowsPathForBash(parsed.rawPath));
+	if (!parsed.operator) {
 		return {
 			command: `cd ${normalizedPath}`,
 			changed: true,
 		};
 	}
 
-	return { command, changed: false };
+	return {
+		command: `cd ${normalizedPath} ${parsed.operator} ${parsed.tail.trimStart()}`,
+		changed: true,
+	};
 }
 
 function ensurePythonUtf8(command: string): { command: string; changed: boolean } {
@@ -60,8 +133,11 @@ function ensurePythonUtf8(command: string): { command: string; changed: boolean
 	};
 }
 
-export function applyWindowsBashCompatibilityFixes(command: string): WindowsBashCompatibilityResult {
-	if (process.platform !== "win32") {
+export function applyWindowsBashCompatibilityFixes(
+	command: string,
+	platform: string = process.platform,
+): WindowsBashCompatibilityResult {
+	if (platform !== "win32") {
 		return { command, applied: [] };
 	}
 

package/src/zellij-modal.ts

@@ -831,7 +831,7 @@ export class ZellijSettingsModal implements ZellijModalContentRenderer {
 			options.settings,
 			Math.min(Math.max(options.settings.length + 2, 6), 18),
 			getSettingsListTheme(),
-			(id, value) => {
+			(id: string, value: string) => {
 				this.options.onChange(id, value);
 			},
 			() => {