pi-rtk-optimizer 0.3.2 → 0.3.3

package/src/rewrite-bypass.ts

@@ -0,0 +1,173 @@
+import type { RtkRewriteRule } from "./rewrite-rules.js";
+
+const COMMAND_WORD_PATTERN = /"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|`(?:\\.|[^`])*`|[^\s]+/g;
+const BYPASSED_CARGO_SUBCOMMANDS = new Set(["help", "install", "publish"]);
+const GH_STRUCTURED_OUTPUT_FLAGS = ["--json", "--jq", "--template"] as const;
+const INTERACTIVE_CONTAINER_SHELLS = new Set([
+	"ash",
+	"bash",
+	"cmd",
+	"cmd.exe",
+	"fish",
+	"powershell",
+	"powershell.exe",
+	"pwsh",
+	"pwsh.exe",
+	"sh",
+	"zsh",
+]);
+
+function splitCommandWords(commandBody: string): string[] {
+	return commandBody.match(COMMAND_WORD_PATTERN) ?? [];
+}
+
+function shouldBypassCargoRewrite(tokens: string[]): boolean {
+	let index = 1;
+
+	while (index < tokens.length && tokens[index].startsWith("+")) {
+		index += 1;
+	}
+
+	while (index < tokens.length && tokens[index].startsWith("-")) {
+		index += 1;
+	}
+
+	const subcommand = tokens[index]?.toLowerCase();
+	if (!subcommand) {
+		return true;
+	}
+
+	return BYPASSED_CARGO_SUBCOMMANDS.has(subcommand);
+}
+
+function normalizeCommandWord(token: string): string {
+	const unwrapped = token.replace(/^(?:["'`])|(?:["'`])$/g, "");
+	const lastPathSeparator = Math.max(unwrapped.lastIndexOf("/"), unwrapped.lastIndexOf("\\"));
+	const basename = lastPathSeparator >= 0 ? unwrapped.slice(lastPathSeparator + 1) : unwrapped;
+	return basename.toLowerCase();
+}
+
+function findInteractiveShellIndex(tokens: string[], startIndex: number, endIndex: number): number {
+	for (let index = startIndex; index < endIndex; index += 1) {
+		if (INTERACTIVE_CONTAINER_SHELLS.has(normalizeCommandWord(tokens[index] ?? ""))) {
+			return index;
+		}
+	}
+
+	return -1;
+}
+
+function hasTrailingArguments(tokens: string[], startIndex: number, endIndex: number): boolean {
+	return startIndex >= 0 && startIndex < endIndex - 1;
+}
+
+function hasStructuredGhOutputFlag(tokens: string[]): boolean {
+	return tokens.some((token) => {
+		const normalized = token.toLowerCase();
+		return GH_STRUCTURED_OUTPUT_FLAGS.some((flag) => normalized === flag || normalized.startsWith(`${flag}=`));
+	});
+}
+
+function hasShortInteractiveFlag(token: string, flag: "i" | "t"): boolean {
+	if (!token.startsWith("-") || token.startsWith("--")) {
+		return false;
+	}
+
+	return token.slice(1).includes(flag);
+}
+
+function hasInteractiveFlagPair(tokens: string[], startIndex: number, endIndex: number): boolean {
+	let interactive = false;
+	let tty = false;
+
+	for (let index = startIndex; index < endIndex; index += 1) {
+		const token = tokens[index] ?? "";
+		if (token === "--interactive") {
+			interactive = true;
+			continue;
+		}
+		if (token === "--tty") {
+			tty = true;
+			continue;
+		}
+		if (hasShortInteractiveFlag(token, "i")) {
+			interactive = true;
+		}
+		if (hasShortInteractiveFlag(token, "t")) {
+			tty = true;
+		}
+	}
+
+	return interactive && tty;
+}
+
+function shouldBypassInteractiveContainerRewrite(tokens: string[]): boolean {
+	const command = tokens[0]?.toLowerCase();
+	if (!command) {
+		return false;
+	}
+
+	if (command === "docker" || command === "podman") {
+		const subcommand = tokens[1]?.toLowerCase();
+		if (subcommand === "run" || subcommand === "exec") {
+			const interactiveShellIndex = findInteractiveShellIndex(tokens, 2, tokens.length);
+			return (
+				interactiveShellIndex >= 0 &&
+				!hasTrailingArguments(tokens, interactiveShellIndex, tokens.length) &&
+				!hasInteractiveFlagPair(tokens, 2, interactiveShellIndex)
+			);
+		}
+
+		if (subcommand === "compose") {
+			const composeSubcommand = tokens[2]?.toLowerCase();
+			if (composeSubcommand === "run" || composeSubcommand === "exec") {
+				const interactiveShellIndex = findInteractiveShellIndex(tokens, 3, tokens.length);
+				return (
+					interactiveShellIndex >= 0 &&
+					!hasTrailingArguments(tokens, interactiveShellIndex, tokens.length) &&
+					!hasInteractiveFlagPair(tokens, 3, interactiveShellIndex)
+				);
+			}
+		}
+	}
+
+	if (command === "kubectl" && tokens[1]?.toLowerCase() === "exec") {
+		const separatorIndex = tokens.indexOf("--");
+		if (separatorIndex === -1 || separatorIndex >= tokens.length - 1) {
+			return false;
+		}
+
+		const interactiveShellIndex = findInteractiveShellIndex(tokens, separatorIndex + 1, tokens.length);
+		if (interactiveShellIndex === -1) {
+			return false;
+		}
+
+		return !hasTrailingArguments(tokens, interactiveShellIndex, tokens.length) && !hasInteractiveFlagPair(tokens, 2, separatorIndex);
+	}
+
+	return false;
+}
+
+/**
+ * Skips RTK rewrites for command shapes that do not map cleanly to RTK wrappers.
+ */
+export function shouldBypassRewriteForCommand(commandBody: string, rule: RtkRewriteRule): boolean {
+	const tokens = splitCommandWords(commandBody.trim());
+	if (tokens.length === 0) {
+		return false;
+	}
+
+	if (tokens[0]?.toLowerCase() === "gh" && hasStructuredGhOutputFlag(tokens)) {
+		return true;
+	}
+
+	if (rule.category === "rust" && tokens[0]?.toLowerCase() === "cargo") {
+		return shouldBypassCargoRewrite(tokens);
+	}
+
+	if (rule.category === "containers") {
+		return shouldBypassInteractiveContainerRewrite(tokens);
+	}
+
+	return false;
+}

package/src/rewrite-rules.ts

@@ -238,6 +238,13 @@ export const RTK_REWRITE_RULES: RtkRewriteRule[] = [
 		replacement: "rtk proxy pnpm -$1",
 		description: "pnpm with leading flags -> proxy",
 	},
+	{
+		id: "pnpm-dlx-proxy",
+		category: "packageManagers",
+		matcher: /^pnpm\s+dlx\b(.*)$/,
+		replacement: "rtk proxy pnpm dlx$1",
+		description: "pnpm dlx -> proxy",
+	},
 	{
 		id: "pnpm-any",
 		category: "packageManagers",

package/src/runtime-guard-test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+
+import {
+	shouldRequireRtkAvailabilityForCommandHandling,
+	shouldSkipCommandHandlingWhenRtkMissing,
+} from "./runtime-guard.ts";
+import { DEFAULT_RTK_INTEGRATION_CONFIG, type RtkIntegrationConfig, type RuntimeStatus } from "./types.ts";
+
+function runTest(name: string, testFn: () => void): void {
+	testFn();
+	console.log(`[PASS] ${name}`);
+}
+
+function cloneConfig(): RtkIntegrationConfig {
+	return structuredClone(DEFAULT_RTK_INTEGRATION_CONFIG);
+}
+
+function runtimeStatus(rtkAvailable: boolean): RuntimeStatus {
+	return { rtkAvailable };
+}
+
+runTest("rewrite mode still requires RTK availability when guard is enabled", () => {
+	const config = cloneConfig();
+	config.mode = "rewrite";
+	config.guardWhenRtkMissing = true;
+
+	assert.equal(shouldRequireRtkAvailabilityForCommandHandling(config), true);
+	assert.equal(shouldSkipCommandHandlingWhenRtkMissing(config, runtimeStatus(false)), true);
+	assert.equal(shouldSkipCommandHandlingWhenRtkMissing(config, runtimeStatus(true)), false);
+});
+
+runTest("suggest mode does not suppress suggestions when RTK is missing", () => {
+	const config = cloneConfig();
+	config.mode = "suggest";
+	config.guardWhenRtkMissing = true;
+
+	assert.equal(shouldRequireRtkAvailabilityForCommandHandling(config), false);
+	assert.equal(shouldSkipCommandHandlingWhenRtkMissing(config, runtimeStatus(false)), false);
+});
+
+runTest("guard disabled never blocks command handling", () => {
+	const config = cloneConfig();
+	config.mode = "rewrite";
+	config.guardWhenRtkMissing = false;
+
+	assert.equal(shouldRequireRtkAvailabilityForCommandHandling(config), false);
+	assert.equal(shouldSkipCommandHandlingWhenRtkMissing(config, runtimeStatus(false)), false);
+});
+
+console.log("All runtime-guard tests passed.");

package/src/runtime-guard.ts

@@ -0,0 +1,14 @@
+import type { RtkIntegrationConfig, RuntimeStatus } from "./types.js";
+
+export function shouldRequireRtkAvailabilityForCommandHandling(
+	config: Pick<RtkIntegrationConfig, "mode" | "guardWhenRtkMissing">,
+): boolean {
+	return config.mode === "rewrite" && config.guardWhenRtkMissing;
+}
+
+export function shouldSkipCommandHandlingWhenRtkMissing(
+	config: Pick<RtkIntegrationConfig, "mode" | "guardWhenRtkMissing">,
+	runtimeStatus: Pick<RuntimeStatus, "rtkAvailable">,
+): boolean {
+	return shouldRequireRtkAvailabilityForCommandHandling(config) && !runtimeStatus.rtkAvailable;
+}

package/src/techniques/source.ts

@@ -66,9 +66,32 @@ export function filterMinimal(content: string, language: Language): string {
 	const result: string[] = [];
 	let inBlockComment = false;
 	let inDocstring = false;
+	let inUserscriptMetadataBlock = false;
+	const userscriptMetadataStartPattern = /^\/\/\s*==\s*userscript\s*==$/i;
+	const userscriptMetadataContentPattern = /^\/\/\s*@\w+/;
+	const userscriptMetadataEndPattern = /^\/\/\s*==\s*\/userscript\s*==$/i;
 
 	for (const line of lines) {
 		const trimmed = line.trim();
+		const isUserscriptMetadataStart = userscriptMetadataStartPattern.test(trimmed);
+		const isUserscriptMetadataContent = userscriptMetadataContentPattern.test(trimmed);
+		const isUserscriptMetadataEnd = userscriptMetadataEndPattern.test(trimmed);
+
+		if (isUserscriptMetadataStart) {
+			inUserscriptMetadataBlock = true;
+			result.push(line);
+			continue;
+		}
+
+		if (inUserscriptMetadataBlock) {
+			result.push(line);
+			if (isUserscriptMetadataEnd) {
+				inUserscriptMetadataBlock = false;
+			} else if (isUserscriptMetadataContent) {
+				// Preserve metadata key/value lines (e.g. // @name) within the userscript block.
+			}
+			continue;
+		}
 
 		if (patterns.blockStart && patterns.blockEnd) {
 			if (

package/src/types-shims.d.ts

@@ -12,6 +12,35 @@ declare module "@mariozechner/pi-tui" {
 		label: string;
 		description?: string;
 	}
+
+	export class Box {
+		constructor(...args: unknown[]);
+		addChild(child: unknown): void;
+	}
+
+	export class Container {
+		constructor(...args: unknown[]);
+		addChild(child: unknown): void;
+		render(width: number): string[];
+		invalidate(): void;
+	}
+
+	export class SettingsList {
+		constructor(...args: unknown[]);
+		handleInput(data: string): void;
+		updateValue(id: string, value: string): void;
+	}
+
+	export class Spacer {
+		constructor(...args: unknown[]);
+	}
+
+	export class Text {
+		constructor(...args: unknown[]);
+	}
+
+	export function truncateToWidth(text: string, width: number, suffix?: string, pad?: boolean): string;
+	export function visibleWidth(text: string): number;
 }
 
 declare module "@mariozechner/pi-coding-agent" {
@@ -20,7 +49,7 @@ declare module "@mariozechner/pi-coding-agent" {
 		custom<T>(
 			renderer: (
 				tui: { requestRender(): void },
-				theme: unknown,
+				theme: Theme,
 				keybindings: unknown,
 				done: () => void,
 			) => {
@@ -54,6 +83,14 @@ declare module "@mariozechner/pi-coding-agent" {
 
 	type MaybePromise<T> = T | Promise<T>;
 
+	export interface Theme {
+		fg(color: string, text: string): string;
+		bold(text: string): string;
+		getFgAnsi?(name: string): string;
+	}
+
+	export function getSettingsListTheme(): unknown;
+
 	export interface ExtensionAPI {
 		exec(
 			command: string,
@@ -112,6 +149,21 @@ declare module "@mariozechner/pi-coding-agent" {
 }
 
 
+declare module "node:assert/strict" {
+	const assert: {
+		equal(actual: unknown, expected: unknown, message?: string): void;
+		deepEqual(actual: unknown, expected: unknown, message?: string): void;
+		ok(value: unknown, message?: string): void;
+	};
+
+	export default assert;
+}
+
+declare const process: {
+	platform: string;
+	env: Record<string, string | undefined>;
+};
+
 declare module "node:os" {
 	export function homedir(): string;
 }