pi-rtk-optimizer 0.3.2 → 0.4.0

package/config/config.example.json

@@ -1,35 +1,36 @@
-{
-  "enabled": true,
-  "mode": "rewrite",
-  "guardWhenRtkMissing": true,
-  "showRewriteNotifications": true,
-  "rewriteGitGithub": true,
-  "rewriteFilesystem": true,
-  "rewriteRust": true,
-  "rewriteJavaScript": true,
-  "rewritePython": true,
-  "rewriteGo": true,
-  "rewriteContainers": true,
-  "rewriteNetwork": true,
-  "rewritePackageManagers": true,
-  "outputCompaction": {
-    "enabled": true,
-    "stripAnsi": true,
-    "sourceCodeFilteringEnabled": true,
-    "truncate": {
-      "enabled": true,
-      "maxChars": 12000
-    },
-    "sourceCodeFiltering": "minimal",
-    "smartTruncate": {
-      "enabled": true,
-      "maxLines": 220
-    },
-    "aggregateTestOutput": true,
-    "filterBuildOutput": true,
-    "compactGitOutput": true,
-    "aggregateLinterOutput": true,
-    "groupSearchOutput": true,
-    "trackSavings": true
-  }
-}
+{
+  "enabled": true,
+  "mode": "rewrite",
+  "guardWhenRtkMissing": true,
+  "showRewriteNotifications": true,
+  "rewriteGitGithub": true,
+  "rewriteFilesystem": true,
+  "rewriteRust": true,
+  "rewriteJavaScript": true,
+  "rewritePython": true,
+  "rewriteGo": true,
+  "rewriteContainers": true,
+  "rewriteNetwork": true,
+  "rewritePackageManagers": true,
+  "outputCompaction": {
+    "enabled": true,
+    "stripAnsi": true,
+    "sourceCodeFilteringEnabled": true,
+    "preserveExactSkillReads": false,
+    "truncate": {
+      "enabled": true,
+      "maxChars": 12000
+    },
+    "sourceCodeFiltering": "minimal",
+    "smartTruncate": {
+      "enabled": true,
+      "maxLines": 220
+    },
+    "aggregateTestOutput": true,
+    "filterBuildOutput": true,
+    "compactGitOutput": true,
+    "aggregateLinterOutput": true,
+    "groupSearchOutput": true,
+    "trackSavings": true
+  }
+}

package/package.json

@@ -1,59 +1,60 @@
-{
-  "name": "pi-rtk-optimizer",
-  "version": "0.3.2",
-  "description": "Pi extension that optimizes RTK command rewriting and tool output compaction for the coding agent.",
-  "type": "module",
-  "main": "./index.ts",
-  "exports": {
-    ".": "./index.ts"
-  },
-  "files": [
-    "index.ts",
-    "src",
-    "config/config.example.json",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "npx --yes -p typescript@5.7.3 tsc -p tsconfig.json --noCheck",
-    "lint": "npm run build",
-    "test": "bun ./src/output-compactor-test.ts",
-    "check": "npm run lint && npm run test",
-    "build:check": "bunx esbuild ./index.ts --bundle --platform=node --format=esm --outfile=./.pi-rtk-optimizer-check.mjs --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-tui && bun -e \"import { unlinkSync } from 'node:fs'; unlinkSync('./.pi-rtk-optimizer-check.mjs');\""
-  },
-  "keywords": [
-    "pi-package",
-    "pi",
-    "pi-extension",
-    "rtk",
-    "token-optimization",
-    "tool-compaction",
-    "coding-agent"
-  ],
-  "author": "MasuRii",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MasuRii/pi-rtk-optimizer.git"
-  },
-  "bugs": {
-    "url": "https://github.com/MasuRii/pi-rtk-optimizer/issues"
-  },
-  "homepage": "https://github.com/MasuRii/pi-rtk-optimizer#readme",
-  "engines": {
-    "node": ">=20"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  },
-  "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*"
-  }
-}
+{
+  "name": "pi-rtk-optimizer",
+  "version": "0.4.0",
+  "description": "Pi extension that optimizes RTK command rewriting and tool output compaction for the coding agent.",
+  "type": "module",
+  "main": "./index.ts",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "config/config.example.json",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npx --yes -p typescript@5.7.3 tsc -p tsconfig.json --noCheck",
+    "lint": "npm run build",
+    "typecheck": "npx --yes -p typescript@5.7.3 tsc -p tsconfig.json",
+    "test": "bun ./src/output-compactor-test.ts && bun ./src/command-rewriter-test.ts && bun ./src/runtime-guard-test.ts && bun ./src/additional-coverage-test.ts && bun ./src/config-modal-test.ts && bun ./src/index-test.ts",
+    "check": "npm run lint && npm run typecheck && npm run test",
+    "build:check": "bunx esbuild ./index.ts --bundle --platform=node --format=esm --outfile=./.pi-rtk-optimizer-check.mjs --external:@mariozechner/pi-coding-agent --external:@mariozechner/pi-tui && bun -e \"import { unlinkSync } from 'node:fs'; unlinkSync('./.pi-rtk-optimizer-check.mjs');\""
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "rtk",
+    "token-optimization",
+    "tool-compaction",
+    "coding-agent"
+  ],
+  "author": "MasuRii",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MasuRii/pi-rtk-optimizer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MasuRii/pi-rtk-optimizer/issues"
+  },
+  "homepage": "https://github.com/MasuRii/pi-rtk-optimizer#readme",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
+  }
+}

package/src/additional-coverage-test.ts

@@ -0,0 +1,197 @@
+import assert from "node:assert/strict";
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+
+import {
+	ensureConfigExists,
+	getRtkIntegrationConfigPath,
+	loadRtkIntegrationConfig,
+	normalizeRtkIntegrationConfig,
+	saveRtkIntegrationConfig,
+} from "./config-store.ts";
+import { clearOutputMetrics, getOutputMetricsSummary, trackOutputSavings } from "./output-metrics.ts";
+import { 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";
+import { applyRewrittenCommandShellSafetyFixups } from "./rewrite-pipeline-safety.ts";
+
+function makeTempConfigPath(): string {
+	return `${getRtkIntegrationConfigPath()}.test-${Date.now()}-${Math.random().toString(16).slice(2)}.json`;
+}
+
+function cleanupFile(path: string): void {
+	for (const candidate of [path, `${path}.tmp`]) {
+		try {
+			if (existsSync(candidate)) {
+				unlinkSync(candidate);
+			}
+		} catch {
+			// Ignore cleanup failures in tests.
+		}
+	}
+}
+
+runTest("config-store normalizes invalid values and clamps numeric ranges", () => {
+	const normalized = normalizeRtkIntegrationConfig({
+		enabled: "yes",
+		mode: "invalid",
+		rewriteGitGithub: false,
+		outputCompaction: {
+			stripAnsi: false,
+			sourceCodeFilteringEnabled: "sometimes",
+			sourceCodeFiltering: "extreme",
+			truncate: {
+				enabled: true,
+				maxChars: 12,
+			},
+			smartTruncate: {
+				enabled: true,
+				maxLines: 999_999,
+			},
+			trackSavings: false,
+		},
+	});
+
+	assert.equal(normalized.enabled, true);
+	assert.equal(normalized.mode, "rewrite");
+	assert.equal(normalized.rewriteGitGithub, false);
+	assert.equal(normalized.outputCompaction.stripAnsi, false);
+	assert.equal(normalized.outputCompaction.sourceCodeFilteringEnabled, true);
+	assert.equal(normalized.outputCompaction.sourceCodeFiltering, "minimal");
+	assert.equal(normalized.outputCompaction.truncate.maxChars, 1_000);
+	assert.equal(normalized.outputCompaction.smartTruncate.maxLines, 4_000);
+	assert.equal(normalized.outputCompaction.trackSavings, false);
+});
+
+runTest("config-store can ensure, save, and reload isolated config files", () => {
+	const tempPath = makeTempConfigPath();
+	cleanupFile(tempPath);
+
+	try {
+		const ensured = ensureConfigExists(tempPath);
+		assert.equal(ensured.created, true);
+		assert.equal(existsSync(tempPath), true);
+
+		const defaultLoad = loadRtkIntegrationConfig(tempPath);
+		assert.equal(defaultLoad.warning, undefined);
+		assert.equal(defaultLoad.config.mode, "rewrite");
+
+		const saved = saveRtkIntegrationConfig(
+			{
+				...defaultLoad.config,
+				mode: "suggest",
+				outputCompaction: {
+					...defaultLoad.config.outputCompaction,
+					truncate: {
+						...defaultLoad.config.outputCompaction.truncate,
+						maxChars: 250_000,
+					},
+				},
+			},
+			tempPath,
+		);
+		assert.equal(saved.success, true);
+
+		const reloaded = loadRtkIntegrationConfig(tempPath);
+		assert.equal(reloaded.config.mode, "suggest");
+		assert.equal(reloaded.config.outputCompaction.truncate.maxChars, 200_000);
+		assert.ok(readFileSync(tempPath, "utf-8").endsWith("\n"));
+	} finally {
+		cleanupFile(tempPath);
+	}
+});
+
+runTest("config-store falls back to defaults when JSON is invalid", () => {
+	const tempPath = makeTempConfigPath();
+	cleanupFile(tempPath);
+
+	try {
+		writeFileSync(tempPath, "{not valid json", "utf-8");
+		const loaded = loadRtkIntegrationConfig(tempPath);
+		assert.equal(loaded.config.mode, "rewrite");
+		assert.ok((loaded.warning ?? "").includes(tempPath));
+		assert.ok((loaded.warning ?? "").includes("Failed to parse"));
+	} finally {
+		cleanupFile(tempPath);
+	}
+});
+
+runTest("output metrics summarize tracked savings and clear state", () => {
+	clearOutputMetrics();
+	assert.equal(getOutputMetricsSummary(), "RTK output compaction metrics: no data yet.");
+
+	const first = trackOutputSavings("1234567890", "12345", "bash", ["ansi", "truncate"]);
+	assert.equal(first.tool, "bash");
+	assert.equal(first.techniques, "ansi,truncate");
+	assert.equal(first.savingsPercent, 50);
+
+	trackOutputSavings("123456", "1234", "read", []);
+	const summary = getOutputMetricsSummary();
+	assert.ok(summary.includes("calls=2, saved=7 chars (43.8%)"));
+	assert.ok(summary.includes("- bash: 1 calls, saved 5 chars (50.0%)"));
+	assert.ok(summary.includes("- read: 1 calls, saved 2 chars (33.3%)"));
+
+	clearOutputMetrics();
+	assert.equal(getOutputMetricsSummary(), "RTK output compaction metrics: no data yet.");
+});
+
+runTest("command detection ignores env prefixes, blank lines, and chained suffixes", () => {
+	assert.equal(normalizeCommandForDetection("NODE_ENV=test FOO=bar npm test && echo done"), "npm test");
+	assert.equal(normalizeCommandForDetection("\n\n PYTHONPATH=src git status\n echo later"), "git status");
+	assert.equal(normalizeCommandForDetection("   "), null);
+	assert.equal(matchesCommandPatterns("CI=1 bun test | head -5", [/^bun test/]), true);
+	assert.equal(matchesCommandPatterns("echo hello", [/^bun test/]), false);
+});
+
+runTest("path compaction preserves the tail and handles Windows separators", () => {
+	const unixPath = "/Users/example/projects/pi-rtk-optimizer/src/techniques/path-utils.ts";
+	const compactUnixPath = compactPath(unixPath, 28);
+	assert.ok(compactUnixPath.length <= 28);
+	assert.ok(compactUnixPath.endsWith("path-utils.ts"));
+	assert.ok(compactUnixPath.includes("/"));
+
+	const windowsPath = "C:\\Users\\Administrator\\Documents\\pi-rtk-optimizer\\src\\windows-command-helpers.ts";
+	const compactWindowsPath = compactPath(windowsPath, 30);
+	assert.ok(compactWindowsPath.length <= 30);
+	assert.equal(compactWindowsPath.includes("\\"), true);
+	assert.ok(compactWindowsPath.endsWith("windows-command-helpers.ts"));
+
+	assert.equal(compactPath("src/file.ts", 40), "src/file.ts");
+});
+
+runTest("windows bash compatibility rewrites only when the runtime is Windows", () => {
+	const command = "cd /d C:\\Users\\Administrator\\project && python script.py";
+	const fixed = applyWindowsBashCompatibilityFixes(command);
+
+	if (process.platform === "win32") {
+		assert.deepEqual(fixed.applied, ["cd-/d", "python-utf8"]);
+		assert.equal(
+			fixed.command,
+			'PYTHONIOENCODING=utf-8 cd "C:/Users/Administrator/project" && python script.py',
+		);
+
+		const alreadyUtf8 = applyWindowsBashCompatibilityFixes("PYTHONIOENCODING=utf-8 python script.py");
+		assert.deepEqual(alreadyUtf8.applied, []);
+		assert.equal(alreadyUtf8.command, "PYTHONIOENCODING=utf-8 python script.py");
+	} else {
+		assert.deepEqual(fixed.applied, []);
+		assert.equal(fixed.command, command);
+	}
+});
+
+runTest("rewrite pipeline safety buffers rewritten Windows producer commands", () => {
+	const rewritten = applyRewrittenCommandShellSafetyFixups("rtk git diff | grep TODO");
+
+	if (process.platform === "win32") {
+		assert.ok(rewritten.includes('mktemp'));
+		assert.ok(rewritten.includes('trap'));
+		assert.ok(rewritten.includes('rtk git diff > "$__pi_rtk_pipe_tmp"'));
+		assert.ok(rewritten.includes('(grep TODO) < "$__pi_rtk_pipe_tmp"'));
+	} else {
+		assert.equal(rewritten, "rtk git diff | grep TODO");
+	}
+
+	assert.equal(applyRewrittenCommandShellSafetyFixups("git diff | grep TODO"), "git diff | grep TODO");
+});
+
+console.log("All additional coverage tests passed.");

package/src/boolean-format.ts

@@ -0,0 +1,3 @@
+export function toOnOff(value: boolean, truthyLabel = "on", falsyLabel = "off"): string {
+	return value ? truthyLabel : falsyLabel;
+}

package/src/command-rewriter-test.ts

@@ -0,0 +1,160 @@
+import assert from "node:assert/strict";
+
+import { computeRewriteDecision } from "./command-rewriter.ts";
+import { cloneDefaultConfig, runTest } from "./test-helpers.ts";
+
+function expectedProxyExecutable(base: string): string {
+	const windowsExecutables = new Set(["npm", "npx", "pnpm", "yarn"]);
+	return process.platform === "win32" && windowsExecutables.has(base) ? `${base}.cmd` : base;
+}
+
+runTest("pnpm dlx rewrites through RTK proxy instead of generic pnpm wrapper", () => {
+	const config = cloneDefaultConfig();
+	const decision = computeRewriteDecision("pnpm dlx create-vite@latest demo --template react-ts", config);
+
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rule?.id, "pnpm-dlx-proxy");
+	assert.equal(
+		decision.rewrittenCommand,
+		`rtk proxy ${expectedProxyExecutable("pnpm")} dlx create-vite@latest demo --template react-ts`,
+	);
+});
+
+runTest("docker run with shell command bypasses rewrite when interactive flags are missing", () => {
+	const config = cloneDefaultConfig();
+	const decision = computeRewriteDecision("docker run ubuntu bash", config);
+
+	assert.equal(decision.changed, false);
+	assert.equal(decision.rewrittenCommand, "docker run ubuntu bash");
+	assert.equal(decision.reason, "no_match");
+});
+
+runTest("docker run with -it keeps container rewrite enabled", () => {
+	const config = cloneDefaultConfig();
+	const decision = computeRewriteDecision("docker run -it ubuntu bash", config);
+
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rule?.id, "docker");
+	assert.equal(decision.rewrittenCommand, "rtk docker run -it ubuntu bash");
+});
+
+runTest("docker compose exec without -it bypasses interactive shell rewrite", () => {
+	const config = cloneDefaultConfig();
+	const decision = computeRewriteDecision("docker compose exec web bash", config);
+
+	assert.equal(decision.changed, false);
+	assert.equal(decision.rewrittenCommand, "docker compose exec web bash");
+});
+
+runTest("container rewrites stay enabled for scripted shells and non-shell commands", () => {
+	const config = cloneDefaultConfig();
+
+	const scriptedShell = computeRewriteDecision('docker run ubuntu bash -lc "echo hi"', config);
+	assert.equal(scriptedShell.changed, true);
+	assert.equal(scriptedShell.rule?.id, "docker");
+	assert.equal(scriptedShell.rewrittenCommand, 'rtk docker run ubuntu bash -lc "echo hi"');
+
+	const nonShell = computeRewriteDecision("docker run ubuntu python app.py", config);
+	assert.equal(nonShell.changed, true);
+	assert.equal(nonShell.rule?.id, "docker");
+	assert.equal(nonShell.rewrittenCommand, "rtk docker run ubuntu python app.py");
+});
+
+runTest("kubectl exec requires interactive flags before rewriting shell sessions", () => {
+	const config = cloneDefaultConfig();
+	const missingFlagsDecision = computeRewriteDecision("kubectl exec pod-123 -- bash", config);
+	assert.equal(missingFlagsDecision.changed, false);
+	assert.equal(missingFlagsDecision.rewrittenCommand, "kubectl exec pod-123 -- bash");
+
+	const interactiveDecision = computeRewriteDecision("kubectl exec -it pod-123 -- bash", config);
+	assert.equal(interactiveDecision.changed, true);
+	assert.equal(interactiveDecision.rule?.id, "kubectl");
+	assert.equal(interactiveDecision.rewrittenCommand, "rtk kubectl exec -it pod-123 -- bash");
+});
+
+runTest("sed scripts keep internal separators intact while later pipe segments still rewrite", () => {
+	const config = cloneDefaultConfig();
+	const decision = computeRewriteDecision("sed -e s/a/b/;d file.txt | git status", config);
+
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rewrittenCommand, "sed -e s/a/b/;d file.txt | rtk git status");
+	assert.equal(decision.rule?.id, "git-any");
+});
+
+runTest("background operators rewrite both command segments without misreading redirect ampersands", () => {
+	const config = cloneDefaultConfig();
+	const backgroundDecision = computeRewriteDecision("git status & cargo test", config);
+	assert.equal(backgroundDecision.changed, true);
+	assert.equal(backgroundDecision.rewrittenCommand, "rtk git status & rtk cargo test");
+
+	const redirectDecision = computeRewriteDecision("cargo test 2>&1 | head -5", config);
+	assert.equal(redirectDecision.changed, true);
+	assert.equal(redirectDecision.rewrittenCommand, "rtk cargo test 2>&1 | head -5");
+	assert.equal(redirectDecision.rule?.id, "cargo-any");
+});
+
+runTest("gh structured output commands bypass RTK rewrites", () => {
+	const config = cloneDefaultConfig();
+	const structuredCommands = [
+		"gh pr list --json number,title",
+		"gh issue list --jq '.[].title'",
+		"gh pr view 123 --template '{{.title}}'",
+	];
+
+	for (const command of structuredCommands) {
+		const decision = computeRewriteDecision(command, config);
+		assert.equal(decision.changed, false);
+		assert.equal(decision.rewrittenCommand, command);
+		assert.equal(decision.reason, "no_match");
+	}
+});
+
+runTest("compound find and search shell flows bypass rewrites when RTK parity is unsafe", () => {
+	const config = cloneDefaultConfig();
+	const auditedCommands = [
+		"find src -type f | xargs grep todo",
+		"find . -name '*.ts' -exec grep -n FIXME {} +",
+		"grep -R TODO src | head -n 5",
+		"rg TODO src && wc -l",
+	];
+
+	for (const command of auditedCommands) {
+		const decision = computeRewriteDecision(command, config);
+		assert.equal(decision.changed, false, command);
+		assert.equal(decision.rewrittenCommand, command, command);
+		assert.equal(decision.reason, "no_match", command);
+	}
+});
+
+runTest("formatting-sensitive ls flows bypass rewrites", () => {
+	const config = cloneDefaultConfig();
+	const auditedCommands = ["ls -la", "ls -l src | grep command-rewriter"];
+
+	for (const command of auditedCommands) {
+		const decision = computeRewriteDecision(command, config);
+		assert.equal(decision.changed, false, command);
+		assert.equal(decision.rewrittenCommand, command, command);
+		assert.equal(decision.reason, "no_match", command);
+	}
+});
+
+runTest("native bash shell proxy flows bypass rewrites when RTK parity is unsafe", () => {
+	const config = cloneDefaultConfig();
+	const command = 'bash -lc "find src -type f | xargs grep todo"';
+	const decision = computeRewriteDecision(command, config);
+
+	assert.equal(decision.changed, false);
+	assert.equal(decision.rewrittenCommand, command);
+	assert.equal(decision.reason, "no_match");
+});
+
+runTest("python proxy rewrites preserve the original executable token", () => {
+	const config = cloneDefaultConfig();
+	const decision = computeRewriteDecision('python3.11 -c "print(1)"', config);
+
+	assert.equal(decision.changed, true);
+	assert.equal(decision.rule?.id, "python-proxy");
+	assert.equal(decision.rewrittenCommand, `rtk proxy ${expectedProxyExecutable("python3.11")} -c "print(1)"`);
+});
+
+console.log("All command-rewriter tests passed.");