pi-rtk-optimizer 0.3.0

package/src/output-compactor.ts

@@ -0,0 +1,343 @@
+import {
+	aggregateLinterOutput,
+	aggregateTestOutput,
+	compactGitOutput,
+	detectLanguage,
+	filterBuildOutput,
+	filterSourceCode,
+	groupSearchResults,
+	smartTruncate,
+	stripAnsiFast,
+	truncate,
+} from "./techniques/index.js";
+import { trackOutputSavings } from "./output-metrics.js";
+import type { RtkIntegrationConfig } from "./types.js";
+
+interface ContentBlock {
+	type: string;
+	text?: string;
+	[key: string]: unknown;
+}
+
+interface ToolResultLikeEvent {
+	toolName: string;
+	input?: unknown;
+	content?: unknown;
+}
+
+export interface ToolResultCompactionMetadata {
+	applied: boolean;
+	techniques: string[];
+	truncated: boolean;
+	originalCharCount: number;
+	compactedCharCount: number;
+	originalLineCount: number;
+	compactedLineCount: number;
+}
+
+export interface ToolResultCompactionOutcome {
+	changed: boolean;
+	content?: unknown[];
+	techniques: string[];
+	metadata?: ToolResultCompactionMetadata;
+}
+
+const LOSSY_TECHNIQUE_PREFIXES = [
+	"build",
+	"test",
+	"git",
+	"linter",
+	"search",
+	"truncate",
+	"smart-truncate",
+	"source:",
+] as const;
+
+const READ_EXACT_OUTPUT_LINE_THRESHOLD = 80;
+const READ_COMPACTION_BANNER_PREFIX = "[RTK compacted output:";
+
+function toRecord(value: unknown): Record<string, unknown> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return {};
+	}
+	return value as Record<string, unknown>;
+}
+
+function toArray(value: unknown): unknown[] {
+	return Array.isArray(value) ? value : [];
+}
+
+function normalizeCommand(input: Record<string, unknown>): string | undefined {
+	const raw = input.command;
+	if (typeof raw === "string" && raw.trim()) {
+		return raw;
+	}
+	return undefined;
+}
+
+function normalizePath(input: Record<string, unknown>): string {
+	const raw = input.path;
+	if (typeof raw === "string") {
+		return raw;
+	}
+	return "";
+}
+
+function hasExplicitReadRange(input: Record<string, unknown>): boolean {
+	return input.offset !== undefined || input.limit !== undefined;
+}
+
+function shouldPreserveExactReadOutput(text: string, input: Record<string, unknown>): boolean {
+	if (hasExplicitReadRange(input)) {
+		return true;
+	}
+
+	return countLines(text) <= READ_EXACT_OUTPUT_LINE_THRESHOLD;
+}
+
+function formatReadCompactionBanner(techniques: string[]): string {
+	return `${READ_COMPACTION_BANNER_PREFIX} ${techniques.join(", ")}]`;
+}
+
+function countLines(text: string): number {
+	if (!text) {
+		return 0;
+	}
+	return text.split("\n").length;
+}
+
+function hasLossyCompaction(techniques: string[]): boolean {
+	return techniques.some((technique) =>
+		LOSSY_TECHNIQUE_PREFIXES.some((prefix) =>
+			prefix.endsWith(":") ? technique.startsWith(prefix) : technique === prefix,
+		),
+	);
+}
+
+function compactBashText(
+	text: string,
+	command: string | undefined,
+	config: RtkIntegrationConfig,
+): { text: string; techniques: string[] } {
+	let nextText = text;
+	const techniques: string[] = [];
+	const compaction = config.outputCompaction;
+
+	if (compaction.stripAnsi) {
+		const stripped = stripAnsiFast(nextText);
+		if (stripped !== nextText) {
+			nextText = stripped;
+			techniques.push("ansi");
+		}
+	}
+
+	if (compaction.filterBuildOutput) {
+		const compacted = filterBuildOutput(nextText, command);
+		if (compacted !== null && compacted !== nextText) {
+			nextText = compacted;
+			techniques.push("build");
+		}
+	}
+
+	if (compaction.aggregateTestOutput) {
+		const compacted = aggregateTestOutput(nextText, command);
+		if (compacted !== null && compacted !== nextText) {
+			nextText = compacted;
+			techniques.push("test");
+		}
+	}
+
+	if (compaction.compactGitOutput) {
+		const compacted = compactGitOutput(nextText, command);
+		if (compacted !== null && compacted !== nextText) {
+			nextText = compacted;
+			techniques.push("git");
+		}
+	}
+
+	if (compaction.aggregateLinterOutput) {
+		const compacted = aggregateLinterOutput(nextText, command);
+		if (compacted !== null && compacted !== nextText) {
+			nextText = compacted;
+			techniques.push("linter");
+		}
+	}
+
+	if (compaction.truncate.enabled && nextText.length > compaction.truncate.maxChars) {
+		nextText = truncate(nextText, compaction.truncate.maxChars);
+		techniques.push("truncate");
+	}
+
+	return { text: nextText, techniques };
+}
+
+function compactReadText(
+	text: string,
+	filePath: string,
+	config: RtkIntegrationConfig,
+	preserveExactReadOutput: boolean,
+): { text: string; techniques: string[] } {
+	if (preserveExactReadOutput) {
+		return { text, techniques: [] };
+	}
+
+	let nextText = text;
+	const techniques: string[] = [];
+	const compaction = config.outputCompaction;
+
+	if (compaction.stripAnsi) {
+		const stripped = stripAnsiFast(nextText);
+		if (stripped !== nextText) {
+			nextText = stripped;
+			techniques.push("ansi");
+		}
+	}
+
+	const language = detectLanguage(filePath);
+	if (compaction.sourceCodeFilteringEnabled && compaction.sourceCodeFiltering !== "none") {
+		const filtered = filterSourceCode(nextText, language, compaction.sourceCodeFiltering);
+		if (filtered !== nextText) {
+			nextText = filtered;
+			techniques.push(`source:${compaction.sourceCodeFiltering}`);
+		}
+	}
+
+	if (compaction.smartTruncate.enabled) {
+		const lineCount = nextText.split("\n").length;
+		if (lineCount > compaction.smartTruncate.maxLines) {
+			const compacted = smartTruncate(nextText, compaction.smartTruncate.maxLines, language);
+			if (compacted !== nextText) {
+				nextText = compacted;
+				techniques.push("smart-truncate");
+			}
+		}
+	}
+
+	if (compaction.truncate.enabled && nextText.length > compaction.truncate.maxChars) {
+		nextText = truncate(nextText, compaction.truncate.maxChars);
+		techniques.push("truncate");
+	}
+
+	if (techniques.length > 0 && !nextText.startsWith(READ_COMPACTION_BANNER_PREFIX)) {
+		nextText = `${formatReadCompactionBanner(techniques)}\n${nextText}`;
+	}
+
+	return { text: nextText, techniques };
+}
+
+function compactGrepText(text: string, config: RtkIntegrationConfig): { text: string; techniques: string[] } {
+	let nextText = text;
+	const techniques: string[] = [];
+	const compaction = config.outputCompaction;
+
+	if (compaction.stripAnsi) {
+		const stripped = stripAnsiFast(nextText);
+		if (stripped !== nextText) {
+			nextText = stripped;
+			techniques.push("ansi");
+		}
+	}
+
+	if (compaction.groupSearchOutput) {
+		const grouped = groupSearchResults(nextText);
+		if (grouped !== null && grouped !== nextText) {
+			nextText = grouped;
+			techniques.push("search");
+		}
+	}
+
+	if (compaction.truncate.enabled && nextText.length > compaction.truncate.maxChars) {
+		nextText = truncate(nextText, compaction.truncate.maxChars);
+		techniques.push("truncate");
+	}
+
+	return { text: nextText, techniques };
+}
+
+export function compactToolResult(
+	event: ToolResultLikeEvent,
+	config: RtkIntegrationConfig,
+): ToolResultCompactionOutcome {
+	if (!config.outputCompaction.enabled) {
+		return { changed: false, techniques: [] };
+	}
+
+	const input = toRecord(event.input);
+	const sourceContent = toArray(event.content);
+	if (sourceContent.length === 0) {
+		return { changed: false, techniques: [] };
+	}
+
+	let changed = false;
+	const allTechniques = new Set<string>();
+	const originalChunks: string[] = [];
+	const filteredChunks: string[] = [];
+
+	const nextContent = sourceContent.map((block) => {
+		if (!block || typeof block !== "object" || Array.isArray(block)) {
+			return block;
+		}
+
+		const contentBlock = block as ContentBlock;
+		if (contentBlock.type !== "text" || typeof contentBlock.text !== "string") {
+			return block;
+		}
+
+		let transformed = { text: contentBlock.text, techniques: [] as string[] };
+		if (event.toolName === "bash") {
+			transformed = compactBashText(contentBlock.text, normalizeCommand(input), config);
+		} else if (event.toolName === "read") {
+			transformed = compactReadText(
+				contentBlock.text,
+				normalizePath(input),
+				config,
+				shouldPreserveExactReadOutput(contentBlock.text, input),
+			);
+		} else if (event.toolName === "grep") {
+			transformed = compactGrepText(contentBlock.text, config);
+		}
+
+		for (const technique of transformed.techniques) {
+			allTechniques.add(technique);
+		}
+
+		originalChunks.push(contentBlock.text);
+		filteredChunks.push(transformed.text);
+
+		if (transformed.text !== contentBlock.text) {
+			changed = true;
+			return { ...contentBlock, text: transformed.text };
+		}
+
+		return block;
+	});
+
+	if (!changed) {
+		return { changed: false, techniques: [] };
+	}
+
+	const techniques = Array.from(allTechniques);
+	const originalText = originalChunks.join("\n");
+	const compactedText = filteredChunks.join("\n");
+
+	if (config.outputCompaction.trackSavings) {
+		trackOutputSavings(originalText, compactedText, event.toolName, techniques);
+	}
+
+	const metadata: ToolResultCompactionMetadata = {
+		applied: true,
+		techniques,
+		truncated: hasLossyCompaction(techniques),
+		originalCharCount: originalText.length,
+		compactedCharCount: compactedText.length,
+		originalLineCount: countLines(originalText),
+		compactedLineCount: countLines(compactedText),
+	};
+
+	return {
+		changed: true,
+		content: nextContent,
+		techniques,
+		metadata,
+	};
+}

package/src/output-metrics.ts

@@ -0,0 +1,69 @@
+export interface OutputMetricRecord {
+	timestamp: string;
+	tool: string;
+	techniques: string;
+	originalChars: number;
+	filteredChars: number;
+	savingsPercent: number;
+}
+
+const outputMetrics: OutputMetricRecord[] = [];
+
+export function trackOutputSavings(
+	original: string,
+	filtered: string,
+	tool: string,
+	techniques: string[],
+): OutputMetricRecord {
+	const originalChars = original.length;
+	const filteredChars = filtered.length;
+	const savingsPercent =
+		originalChars > 0 ? Math.round((((originalChars - filteredChars) / originalChars) * 100) * 100) / 100 : 0;
+
+	const record: OutputMetricRecord = {
+		timestamp: new Date().toISOString(),
+		tool,
+		techniques: techniques.join(",") || "none",
+		originalChars,
+		filteredChars,
+		savingsPercent,
+	};
+
+	outputMetrics.push(record);
+	return record;
+}
+
+export function clearOutputMetrics(): void {
+	outputMetrics.length = 0;
+}
+
+export function getOutputMetricsSummary(): string {
+	if (outputMetrics.length === 0) {
+		return "RTK output compaction metrics: no data yet.";
+	}
+
+	const totalOriginal = outputMetrics.reduce((sum, metric) => sum + metric.originalChars, 0);
+	const totalFiltered = outputMetrics.reduce((sum, metric) => sum + metric.filteredChars, 0);
+	const totalSaved = totalOriginal - totalFiltered;
+	const savingsPercent = totalOriginal > 0 ? (totalSaved / totalOriginal) * 100 : 0;
+
+	const byTool = new Map<string, { count: number; originalChars: number; filteredChars: number }>();
+	for (const metric of outputMetrics) {
+		const existing = byTool.get(metric.tool) ?? { count: 0, originalChars: 0, filteredChars: 0 };
+		existing.count += 1;
+		existing.originalChars += metric.originalChars;
+		existing.filteredChars += metric.filteredChars;
+		byTool.set(metric.tool, existing);
+	}
+
+	let result = "RTK output compaction metrics\n";
+	result += `calls=${outputMetrics.length}, saved=${totalSaved.toLocaleString()} chars (${savingsPercent.toFixed(1)}%)\n`;
+
+	for (const [tool, stats] of byTool.entries()) {
+		const toolSaved = stats.originalChars - stats.filteredChars;
+		const toolSavingsPercent = stats.originalChars > 0 ? (toolSaved / stats.originalChars) * 100 : 0;
+		result += `- ${tool}: ${stats.count} calls, saved ${toolSaved.toLocaleString()} chars (${toolSavingsPercent.toFixed(1)}%)\n`;
+	}
+
+	return result.trimEnd();
+}

package/src/rewrite-rules.ts

@@ -0,0 +1,248 @@
+export type RtkRewriteCategory =
+	| "gitGithub"
+	| "filesystem"
+	| "rust"
+	| "javascript"
+	| "python"
+	| "go"
+	| "containers"
+	| "network"
+	| "packageManagers";
+
+export interface RtkRewriteRule {
+	id: string;
+	category: RtkRewriteCategory;
+	matcher: RegExp;
+	replacement: string;
+	description: string;
+}
+
+export const RTK_REWRITE_RULES: RtkRewriteRule[] = [
+	// Git / GitHub
+	{
+		id: "git-leading-flags-proxy",
+		category: "gitGithub",
+		matcher: /^git\s+-(.+)$/,
+		replacement: "rtk proxy git -$1",
+		description: "git with leading flags (e.g. -C, --no-pager) -> proxy",
+	},
+	{
+		id: "git-any",
+		category: "gitGithub",
+		matcher: /^git\s+(.+)$/,
+		replacement: "rtk git $1",
+		description: "git <args> -> rtk git",
+	},
+	{
+		id: "gh-leading-flags-proxy",
+		category: "gitGithub",
+		matcher: /^gh\s+-(.+)$/,
+		replacement: "rtk proxy gh -$1",
+		description: "gh with leading flags -> proxy",
+	},
+	{
+		id: "gh-any",
+		category: "gitGithub",
+		matcher: /^gh\s+(.+)$/,
+		replacement: "rtk gh $1",
+		description: "gh <args> -> rtk gh",
+	},
+
+	// Filesystem / shell helpers
+	{ id: "cat", category: "filesystem", matcher: /^cat\s+/, replacement: "rtk read ", description: "cat" },
+	{
+		id: "head-short-lines",
+		category: "filesystem",
+		matcher: /^head\s+-([0-9]+)\s+(.+)$/,
+		replacement: "rtk read $2 --max-lines $1",
+		description: "head -N <file>",
+	},
+	{
+		id: "head-long-lines",
+		category: "filesystem",
+		matcher: /^head\s+--lines=([0-9]+)\s+(.+)$/,
+		replacement: "rtk read $2 --max-lines $1",
+		description: "head --lines=N <file>",
+	},
+	{
+		id: "tail-short-lines",
+		category: "filesystem",
+		matcher: /^tail\s+-n\s*([0-9]+)\s+(.+)$/,
+		replacement: "rtk read $2 --max-lines $1",
+		description: "tail -n N <file>",
+	},
+	{
+		id: "tail-long-lines",
+		category: "filesystem",
+		matcher: /^tail\s+--lines=([0-9]+)\s+(.+)$/,
+		replacement: "rtk read $2 --max-lines $1",
+		description: "tail --lines=N <file>",
+	},
+	{ id: "grep", category: "filesystem", matcher: /^(rg|grep)\s+/, replacement: "rtk grep ", description: "rg/grep" },
+	{ id: "ls", category: "filesystem", matcher: /^ls\b/, replacement: "rtk ls", description: "ls" },
+	{ id: "tree", category: "filesystem", matcher: /^tree\b/, replacement: "rtk tree", description: "tree" },
+	{ id: "find", category: "filesystem", matcher: /^find\s+/, replacement: "rtk find ", description: "find" },
+	{ id: "diff", category: "filesystem", matcher: /^diff\s+/, replacement: "rtk diff ", description: "diff" },
+	{ id: "wc", category: "filesystem", matcher: /^wc\b/, replacement: "rtk wc", description: "wc" },
+	{
+		id: "powershell-proxy",
+		category: "filesystem",
+		matcher: /^(powershell(?:\.exe)?)\s+(.+)$/i,
+		replacement: "rtk proxy $1 $2",
+		description: "powershell -> proxy",
+	},
+	{
+		id: "cmd-proxy",
+		category: "filesystem",
+		matcher: /^(cmd(?:\.exe)?)\s+(.+)$/i,
+		replacement: "rtk proxy $1 $2",
+		description: "cmd -> proxy",
+	},
+	{ id: "bash-proxy", category: "filesystem", matcher: /^bash\s+(.+)$/i, replacement: "rtk proxy bash $1", description: "bash -> proxy" },
+
+	// Rust
+	{
+		id: "cargo-any",
+		category: "rust",
+		matcher: /^cargo\s+(.+)$/,
+		replacement: "rtk cargo $1",
+		description: "cargo <args> -> rtk cargo",
+	},
+
+	// JavaScript / TypeScript ecosystem
+	{ id: "vitest", category: "javascript", matcher: /^vitest(?:\s+run)?\b/, replacement: "rtk vitest run", description: "vitest" },
+	{ id: "npx-vitest", category: "javascript", matcher: /^npx\s+vitest(?:\s+run)?\b/, replacement: "rtk vitest run", description: "npx vitest" },
+	{ id: "bunx-vitest", category: "javascript", matcher: /^bunx\s+vitest(?:\s+run)?\b/, replacement: "rtk vitest run", description: "bunx vitest" },
+	{ id: "pnpm-vitest", category: "javascript", matcher: /^pnpm\s+(?:exec\s+)?vitest(?:\s+run)?\b/, replacement: "rtk vitest run", description: "pnpm vitest" },
+	{
+		id: "npm-run",
+		category: "javascript",
+		matcher: /^npm\s+run\s+(.+)$/,
+		replacement: "rtk proxy npm run $1",
+		description: "npm run <script> -> proxy",
+	},
+	{
+		id: "npm-script-shorthand",
+		category: "javascript",
+		matcher: /^npm\s+(test|start|build|lint)\b(.*)$/,
+		replacement: "rtk proxy npm $1$2",
+		description: "npm test/start/build/lint -> proxy",
+	},
+	{ id: "tsc", category: "javascript", matcher: /^tsc\b/, replacement: "rtk tsc", description: "tsc" },
+	{ id: "npx-tsc", category: "javascript", matcher: /^npx\s+tsc\b/, replacement: "rtk tsc", description: "npx tsc" },
+	{ id: "bunx-tsc", category: "javascript", matcher: /^bunx\s+tsc\b/, replacement: "rtk tsc", description: "bunx tsc" },
+	{ id: "pnpm-tsc", category: "javascript", matcher: /^pnpm\s+(?:exec\s+)?tsc\b/, replacement: "rtk tsc", description: "pnpm tsc" },
+	{ id: "pnpm-typecheck", category: "javascript", matcher: /^pnpm\s+typecheck\b/, replacement: "rtk tsc", description: "pnpm typecheck" },
+	{ id: "eslint", category: "javascript", matcher: /^eslint\b/, replacement: "rtk lint", description: "eslint" },
+	{ id: "npx-eslint", category: "javascript", matcher: /^npx\s+eslint\b/, replacement: "rtk lint", description: "npx eslint" },
+	{ id: "bunx-eslint", category: "javascript", matcher: /^bunx\s+eslint\b/, replacement: "rtk lint", description: "bunx eslint" },
+	{ id: "pnpm-lint", category: "javascript", matcher: /^pnpm\s+lint\b/, replacement: "rtk lint", description: "pnpm lint" },
+	{ id: "next", category: "javascript", matcher: /^next\b/, replacement: "rtk next", description: "next" },
+	{ id: "npx-next", category: "javascript", matcher: /^npx\s+next\b/, replacement: "rtk next", description: "npx next" },
+	{ id: "bunx-next", category: "javascript", matcher: /^bunx\s+next\b/, replacement: "rtk next", description: "bunx next" },
+	{ id: "prettier", category: "javascript", matcher: /^prettier\b/, replacement: "rtk prettier", description: "prettier" },
+	{ id: "npx-prettier", category: "javascript", matcher: /^npx\s+prettier\b/, replacement: "rtk prettier", description: "npx prettier" },
+	{ id: "bunx-prettier", category: "javascript", matcher: /^bunx\s+prettier\b/, replacement: "rtk prettier", description: "bunx prettier" },
+	{ id: "playwright", category: "javascript", matcher: /^playwright\b/, replacement: "rtk playwright", description: "playwright" },
+	{ id: "npx-playwright", category: "javascript", matcher: /^npx\s+playwright\b/, replacement: "rtk playwright", description: "npx playwright" },
+	{ id: "bunx-playwright", category: "javascript", matcher: /^bunx\s+playwright\b/, replacement: "rtk playwright", description: "bunx playwright" },
+	{ id: "pnpm-playwright", category: "javascript", matcher: /^pnpm\s+playwright\b/, replacement: "rtk playwright", description: "pnpm playwright" },
+	{ id: "prisma", category: "javascript", matcher: /^prisma\b/, replacement: "rtk prisma", description: "prisma" },
+	{ id: "npx-prisma", category: "javascript", matcher: /^npx\s+prisma\b/, replacement: "rtk prisma", description: "npx prisma" },
+	{ id: "bunx-prisma", category: "javascript", matcher: /^bunx\s+prisma\b/, replacement: "rtk prisma", description: "bunx prisma" },
+	{ id: "pnpm-prisma", category: "javascript", matcher: /^pnpm\s+prisma\b/, replacement: "rtk prisma", description: "pnpm prisma" },
+	{ id: "bun-proxy", category: "javascript", matcher: /^bun\s+(.+)$/, replacement: "rtk proxy bun $1", description: "bun -> proxy" },
+	{ id: "node-proxy", category: "javascript", matcher: /^node\s+(.+)$/, replacement: "rtk proxy node $1", description: "node -> proxy" },
+	{ id: "tsx-proxy", category: "javascript", matcher: /^tsx\s+(.+)$/, replacement: "rtk proxy tsx $1", description: "tsx -> proxy" },
+	{ id: "npx-proxy", category: "javascript", matcher: /^npx\s+(.+)$/, replacement: "rtk proxy npx $1", description: "npx fallback -> proxy" },
+	{ id: "bunx-proxy", category: "javascript", matcher: /^bunx\s+(.+)$/, replacement: "rtk proxy bunx $1", description: "bunx fallback -> proxy" },
+
+	// Python
+	{ id: "pytest", category: "python", matcher: /^pytest\b/, replacement: "rtk pytest", description: "pytest" },
+	{ id: "python-pytest", category: "python", matcher: /^python(?:3(?:\.\d+)?)?\s+-m\s+pytest\b/, replacement: "rtk pytest", description: "python -m pytest" },
+	{ id: "ruff", category: "python", matcher: /^ruff\b/, replacement: "rtk ruff", description: "ruff" },
+	{ id: "python-ruff", category: "python", matcher: /^python(?:3(?:\.\d+)?)?\s+-m\s+ruff\b/, replacement: "rtk ruff", description: "python -m ruff" },
+	{
+		id: "pip",
+		category: "python",
+		matcher: /^pip\s+(list|outdated|install|uninstall|show)\b/,
+		replacement: "rtk pip $1",
+		description: "pip supported commands",
+	},
+	{
+		id: "uv-pip",
+		category: "python",
+		matcher: /^uv\s+pip\s+(list|outdated|install|uninstall|show)\b/,
+		replacement: "rtk pip $1",
+		description: "uv pip supported commands",
+	},
+	{
+		id: "python-pip",
+		category: "python",
+		matcher: /^python(?:3(?:\.\d+)?)?\s+-m\s+pip\s+(list|outdated|install|uninstall|show)\b/,
+		replacement: "rtk pip $1",
+		description: "python -m pip supported commands",
+	},
+	{
+		id: "python-proxy",
+		category: "python",
+		matcher: /^python(?:3(?:\.\d+)?)?\s+(.+)$/,
+		replacement: "rtk proxy python $1",
+		description: "python fallback -> proxy",
+	},
+	{ id: "poetry-proxy", category: "python", matcher: /^poetry\s+(.+)$/, replacement: "rtk proxy poetry $1", description: "poetry -> proxy" },
+
+	// Go
+	{ id: "go-any", category: "go", matcher: /^go\s+(.+)$/, replacement: "rtk go $1", description: "go <args> -> rtk go" },
+	{ id: "golangci", category: "go", matcher: /^golangci-lint\b/, replacement: "rtk golangci-lint", description: "golangci-lint" },
+
+	// Containers
+	{
+		id: "docker-compose",
+		category: "containers",
+		matcher: /^docker\s+compose\s+(.+)$/,
+		replacement: "rtk docker compose $1",
+		description: "docker compose",
+	},
+	{
+		id: "docker",
+		category: "containers",
+		matcher: /^docker\s+(.+)$/,
+		replacement: "rtk docker $1",
+		description: "docker",
+	},
+	{
+		id: "kubectl",
+		category: "containers",
+		matcher: /^kubectl\s+(.+)$/,
+		replacement: "rtk kubectl $1",
+		description: "kubectl",
+	},
+
+	// Network
+	{ id: "curl", category: "network", matcher: /^curl\s+/, replacement: "rtk curl ", description: "curl" },
+	{ id: "wget", category: "network", matcher: /^wget\s+/, replacement: "rtk wget ", description: "wget" },
+
+	// Package managers
+	{
+		id: "npm-proxy",
+		category: "packageManagers",
+		matcher: /^npm\s+(.+)$/,
+		replacement: "rtk proxy npm $1",
+		description: "npm fallback -> proxy",
+	},
+	{
+		id: "pnpm-leading-flags-proxy",
+		category: "packageManagers",
+		matcher: /^pnpm\s+-(.+)$/,
+		replacement: "rtk proxy pnpm -$1",
+		description: "pnpm with leading flags -> proxy",
+	},
+	{
+		id: "pnpm-any",
+		category: "packageManagers",
+		matcher: /^pnpm\s+(.+)$/,
+		replacement: "rtk pnpm $1",
+		description: "pnpm <args> -> rtk pnpm",
+	},
+];

package/src/techniques/ansi.ts

@@ -0,0 +1,13 @@
+export function stripAnsi(text: string): string {
+	return text
+		.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "")
+		.replace(/\x1b\][0-9;]*(?:\x07|\x1b\\)/g, "")
+		.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "");
+}
+
+export function stripAnsiFast(text: string): string {
+	if (!text.includes("\x1b")) {
+		return text;
+	}
+	return stripAnsi(text);
+}