pi-rtk-optimizer 0.3.0

package/src/config-store.ts

@@ -0,0 +1,217 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { CONFIG_PATH } from "./constants.js";
+import {
+	DEFAULT_RTK_INTEGRATION_CONFIG,
+	RTK_MODES,
+	RTK_SOURCE_FILTER_LEVELS,
+	type ConfigLoadResult,
+	type ConfigSaveResult,
+	type EnsureConfigResult,
+	type RtkIntegrationConfig,
+	type RtkSourceFilterLevel,
+} from "./types.js";
+
+function toBoolean(value: unknown, fallback: boolean): boolean {
+	return typeof value === "boolean" ? value : fallback;
+}
+
+function toInteger(value: unknown, fallback: number, min: number, max: number): number {
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		return fallback;
+	}
+	const rounded = Math.round(value);
+	return Math.max(min, Math.min(max, rounded));
+}
+
+function toMode(value: unknown): RtkIntegrationConfig["mode"] {
+	return RTK_MODES.includes(value as RtkIntegrationConfig["mode"])
+		? (value as RtkIntegrationConfig["mode"])
+		: DEFAULT_RTK_INTEGRATION_CONFIG.mode;
+}
+
+function toSourceFilterLevel(value: unknown): RtkSourceFilterLevel {
+	return RTK_SOURCE_FILTER_LEVELS.includes(value as RtkSourceFilterLevel)
+		? (value as RtkSourceFilterLevel)
+		: DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.sourceCodeFiltering;
+}
+
+function toObject(value: unknown): Record<string, unknown> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return {};
+	}
+	return value as Record<string, unknown>;
+}
+
+export function normalizeRtkIntegrationConfig(raw: unknown): RtkIntegrationConfig {
+	const source = toObject(raw);
+	const outputCompactionSource = toObject(source.outputCompaction);
+	const truncateSource = toObject(outputCompactionSource.truncate);
+	const smartTruncateSource = toObject(outputCompactionSource.smartTruncate);
+
+	return {
+		enabled: toBoolean(source.enabled, DEFAULT_RTK_INTEGRATION_CONFIG.enabled),
+		mode: toMode(source.mode),
+		guardWhenRtkMissing: toBoolean(
+			source.guardWhenRtkMissing,
+			DEFAULT_RTK_INTEGRATION_CONFIG.guardWhenRtkMissing,
+		),
+		showRewriteNotifications: toBoolean(
+			source.showRewriteNotifications,
+			DEFAULT_RTK_INTEGRATION_CONFIG.showRewriteNotifications,
+		),
+		rewriteGitGithub: toBoolean(
+			source.rewriteGitGithub,
+			DEFAULT_RTK_INTEGRATION_CONFIG.rewriteGitGithub,
+		),
+		rewriteFilesystem: toBoolean(
+			source.rewriteFilesystem,
+			DEFAULT_RTK_INTEGRATION_CONFIG.rewriteFilesystem,
+		),
+		rewriteRust: toBoolean(source.rewriteRust, DEFAULT_RTK_INTEGRATION_CONFIG.rewriteRust),
+		rewriteJavaScript: toBoolean(
+			source.rewriteJavaScript,
+			DEFAULT_RTK_INTEGRATION_CONFIG.rewriteJavaScript,
+		),
+		rewritePython: toBoolean(source.rewritePython, DEFAULT_RTK_INTEGRATION_CONFIG.rewritePython),
+		rewriteGo: toBoolean(source.rewriteGo, DEFAULT_RTK_INTEGRATION_CONFIG.rewriteGo),
+		rewriteContainers: toBoolean(
+			source.rewriteContainers,
+			DEFAULT_RTK_INTEGRATION_CONFIG.rewriteContainers,
+		),
+		rewriteNetwork: toBoolean(source.rewriteNetwork, DEFAULT_RTK_INTEGRATION_CONFIG.rewriteNetwork),
+		rewritePackageManagers: toBoolean(
+			source.rewritePackageManagers,
+			DEFAULT_RTK_INTEGRATION_CONFIG.rewritePackageManagers,
+		),
+		outputCompaction: {
+			enabled: toBoolean(
+				outputCompactionSource.enabled,
+				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.enabled,
+			),
+			stripAnsi: toBoolean(
+				outputCompactionSource.stripAnsi,
+				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.stripAnsi,
+			),
+			sourceCodeFilteringEnabled: toBoolean(
+				outputCompactionSource.sourceCodeFilteringEnabled,
+				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.sourceCodeFilteringEnabled,
+			),
+			truncate: {
+				enabled: toBoolean(
+					truncateSource.enabled,
+					DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.truncate.enabled,
+				),
+				maxChars: toInteger(
+					truncateSource.maxChars,
+					DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.truncate.maxChars,
+					1_000,
+					200_000,
+				),
+			},
+			sourceCodeFiltering: toSourceFilterLevel(outputCompactionSource.sourceCodeFiltering),
+			smartTruncate: {
+				enabled: toBoolean(
+					smartTruncateSource.enabled,
+					DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.smartTruncate.enabled,
+				),
+				maxLines: toInteger(
+					smartTruncateSource.maxLines,
+					DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.smartTruncate.maxLines,
+					40,
+					4_000,
+				),
+			},
+			aggregateTestOutput: toBoolean(
+				outputCompactionSource.aggregateTestOutput,
+				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.aggregateTestOutput,
+			),
+			filterBuildOutput: toBoolean(
+				outputCompactionSource.filterBuildOutput,
+				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.filterBuildOutput,
+			),
+			compactGitOutput: toBoolean(
+				outputCompactionSource.compactGitOutput,
+				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.compactGitOutput,
+			),
+			aggregateLinterOutput: toBoolean(
+				outputCompactionSource.aggregateLinterOutput,
+				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.aggregateLinterOutput,
+			),
+			groupSearchOutput: toBoolean(
+				outputCompactionSource.groupSearchOutput,
+				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.groupSearchOutput,
+			),
+			trackSavings: toBoolean(
+				outputCompactionSource.trackSavings,
+				DEFAULT_RTK_INTEGRATION_CONFIG.outputCompaction.trackSavings,
+			),
+		},
+	};
+}
+
+export function ensureConfigExists(): EnsureConfigResult {
+	if (existsSync(CONFIG_PATH)) {
+		return { created: false };
+	}
+
+	try {
+		mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+		writeFileSync(CONFIG_PATH, `${JSON.stringify(DEFAULT_RTK_INTEGRATION_CONFIG, null, 2)}\n`, "utf-8");
+		return { created: true };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			created: false,
+			error: `Failed to create ${CONFIG_PATH}: ${message}`,
+		};
+	}
+}
+
+export function loadRtkIntegrationConfig(): ConfigLoadResult {
+	if (!existsSync(CONFIG_PATH)) {
+		return { config: { ...DEFAULT_RTK_INTEGRATION_CONFIG } };
+	}
+
+	try {
+		const rawText = readFileSync(CONFIG_PATH, "utf-8");
+		const parsed = JSON.parse(rawText) as unknown;
+		return { config: normalizeRtkIntegrationConfig(parsed) };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			config: { ...DEFAULT_RTK_INTEGRATION_CONFIG },
+			warning: `Failed to parse ${CONFIG_PATH}: ${message}`,
+		};
+	}
+}
+
+export function saveRtkIntegrationConfig(config: RtkIntegrationConfig): ConfigSaveResult {
+	const normalized = normalizeRtkIntegrationConfig(config);
+	const tmpPath = `${CONFIG_PATH}.tmp`;
+
+	try {
+		mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+		writeFileSync(tmpPath, `${JSON.stringify(normalized, null, 2)}\n`, "utf-8");
+		renameSync(tmpPath, CONFIG_PATH);
+		return { success: true };
+	} catch (error) {
+		try {
+			if (existsSync(tmpPath)) {
+				unlinkSync(tmpPath);
+			}
+		} catch {
+			// Ignore cleanup failures.
+		}
+
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			success: false,
+			error: `Failed to save ${CONFIG_PATH}: ${message}`,
+		};
+	}
+}
+
+export function getRtkIntegrationConfigPath(): string {
+	return CONFIG_PATH;
+}

package/src/constants.ts

@@ -0,0 +1,6 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const EXTENSION_NAME = "pi-rtk-optimizer";
+export const CONFIG_DIR = join(homedir(), ".pi", "agent", "extensions", EXTENSION_NAME);
+export const CONFIG_PATH = join(CONFIG_DIR, "config.json");

package/src/index.ts

@@ -0,0 +1,291 @@
+import { isToolCallEventType, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+	ensureConfigExists,
+	getRtkIntegrationConfigPath,
+	loadRtkIntegrationConfig,
+	normalizeRtkIntegrationConfig,
+	saveRtkIntegrationConfig,
+} from "./config-store.js";
+import { computeRewriteDecision } from "./command-rewriter.js";
+import { registerRtkIntegrationCommand } from "./config-modal.js";
+import { EXTENSION_NAME } from "./constants.js";
+import { clearOutputMetrics, getOutputMetricsSummary } from "./output-metrics.js";
+import { compactToolResult, type ToolResultCompactionMetadata } from "./output-compactor.js";
+import type { RtkIntegrationConfig, RuntimeStatus } from "./types.js";
+import { applyWindowsBashCompatibilityFixes } from "./windows-command-helpers.js";
+
+function trimMessage(raw: string, maxLength = 220): string {
+	const clean = raw.replace(/\s+/g, " ").trim();
+	if (clean.length <= maxLength) {
+		return clean;
+	}
+	return `${clean.slice(0, maxLength - 1)}…`;
+}
+
+const SOURCE_FILTER_TROUBLESHOOTING_NOTE =
+	"RTK note: If file edits repeatedly fail because old text does not match, run '/rtk', turn off 'Read source filtering enabled', re-read the file, apply the edit, then turn it back on.";
+
+function toRecord(value: unknown): Record<string, unknown> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return {};
+	}
+	return value as Record<string, unknown>;
+}
+
+function mergeCompactionDetails(
+	existingDetails: unknown,
+	compaction: ToolResultCompactionMetadata,
+): Record<string, unknown> {
+	const baseDetails = toRecord(existingDetails);
+	const baseMetadata = toRecord(baseDetails.metadata);
+
+	const nextDetails: Record<string, unknown> = {
+		...baseDetails,
+		rtkCompaction: compaction,
+		metadata: {
+			...baseMetadata,
+			rtkCompaction: compaction,
+		},
+	};
+
+	if (Object.keys(baseDetails).length === 0 && existingDetails !== undefined) {
+		nextDetails.rawDetails = existingDetails;
+	}
+
+	return nextDetails;
+}
+
+export default function rtkIntegrationExtension(pi: ExtensionAPI): void {
+	const initialLoad = loadRtkIntegrationConfig();
+	let config: RtkIntegrationConfig = initialLoad.config;
+	let pendingLoadWarning = initialLoad.warning;
+	let runtimeStatus: RuntimeStatus = { rtkAvailable: false };
+	const warnedMessages = new Set<string>();
+	const suggestionNotices = new Set<string>();
+	let missingRtkWarningShown = false;
+
+	const formatRewriteNotice = (originalCommand: string, rewrittenCommand: string): string => {
+		const original = trimMessage(originalCommand, 100);
+		const rewritten = trimMessage(rewrittenCommand, 120);
+		return `RTK rewrite: ${original} -> ${rewritten}`;
+	};
+
+	const warnOnce = (
+		ctx: ExtensionContext | ExtensionCommandContext,
+		message: string,
+		level: "warning" | "error" = "warning",
+	): void => {
+		if (warnedMessages.has(message)) {
+			return;
+		}
+
+		warnedMessages.add(message);
+		console.warn(`[${EXTENSION_NAME}] ${message}`);
+		if (ctx.hasUI) {
+			ctx.ui.notify(message, level);
+		}
+	};
+
+	const refreshConfig = (ctx?: ExtensionContext | ExtensionCommandContext): void => {
+		const ensured = ensureConfigExists();
+		if (ensured.error && ctx) {
+			warnOnce(ctx, ensured.error);
+		}
+
+		const loaded = loadRtkIntegrationConfig();
+		config = loaded.config;
+		pendingLoadWarning = loaded.warning;
+
+		if (pendingLoadWarning && ctx) {
+			warnOnce(ctx, pendingLoadWarning);
+			pendingLoadWarning = undefined;
+		}
+	};
+
+	const setConfig = (next: RtkIntegrationConfig, ctx: ExtensionCommandContext): void => {
+		config = normalizeRtkIntegrationConfig(next);
+		const saved = saveRtkIntegrationConfig(config);
+		if (!saved.success && saved.error) {
+			ctx.ui.notify(saved.error, "error");
+		}
+	};
+
+	const refreshRuntimeStatus = async (): Promise<RuntimeStatus> => {
+		try {
+			const result = await pi.exec("rtk", ["--version"], { timeout: 5000 });
+			if (result.code === 0) {
+				runtimeStatus = {
+					rtkAvailable: true,
+					lastCheckedAt: Date.now(),
+				};
+				missingRtkWarningShown = false;
+				return runtimeStatus;
+			}
+
+			const detail = trimMessage(
+				`${result.stderr || ""} ${result.stdout || ""} ${result.code ? `(exit ${result.code})` : ""}`,
+			);
+			runtimeStatus = {
+				rtkAvailable: false,
+				lastCheckedAt: Date.now(),
+				lastError: detail || `exit ${result.code}`,
+			};
+			return runtimeStatus;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			runtimeStatus = {
+				rtkAvailable: false,
+				lastCheckedAt: Date.now(),
+				lastError: trimMessage(message),
+			};
+			return runtimeStatus;
+		}
+	};
+
+	const maybeWarnRtkMissing = (ctx: ExtensionContext): void => {
+		if (!config.enabled || config.mode !== "rewrite" || !config.guardWhenRtkMissing) {
+			return;
+		}
+
+		if (runtimeStatus.rtkAvailable) {
+			missingRtkWarningShown = false;
+			return;
+		}
+
+		if (missingRtkWarningShown) {
+			return;
+		}
+
+		missingRtkWarningShown = true;
+		const reason = runtimeStatus.lastError ? ` (${runtimeStatus.lastError})` : "";
+		warnOnce(ctx, `${EXTENSION_NAME}: rtk binary unavailable, command rewrite bypassed${reason}.`);
+	};
+
+	const ensureRuntimeStatusFresh = async (): Promise<void> => {
+		if (!config.guardWhenRtkMissing) {
+			return;
+		}
+
+		const now = Date.now();
+		const isStale = !runtimeStatus.lastCheckedAt || now - runtimeStatus.lastCheckedAt > 30_000;
+		if (isStale) {
+			await refreshRuntimeStatus();
+		}
+	};
+
+	const controller = {
+		getConfig: () => config,
+		setConfig,
+		getConfigPath: getRtkIntegrationConfigPath,
+		getRuntimeStatus: () => runtimeStatus,
+		refreshRuntimeStatus,
+		getMetricsSummary: getOutputMetricsSummary,
+		clearMetrics: clearOutputMetrics,
+	};
+
+	registerRtkIntegrationCommand(pi, controller);
+
+	pi.on("session_start", async (_event, ctx) => {
+		refreshConfig(ctx);
+		await refreshRuntimeStatus();
+		maybeWarnRtkMissing(ctx);
+	});
+
+	pi.on("session_switch", async (_event, ctx) => {
+		refreshConfig(ctx);
+		await refreshRuntimeStatus();
+		maybeWarnRtkMissing(ctx);
+	});
+
+	pi.on("before_agent_start", async (event, ctx) => {
+		await ensureRuntimeStatusFresh();
+		maybeWarnRtkMissing(ctx);
+
+		if (event.systemPrompt.includes(SOURCE_FILTER_TROUBLESHOOTING_NOTE)) {
+			return {};
+		}
+
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n${SOURCE_FILTER_TROUBLESHOOTING_NOTE}`,
+		};
+	});
+
+	pi.on("tool_call", async (event, ctx) => {
+		if (!config.enabled) {
+			return {};
+		}
+
+		if (!isToolCallEventType("bash", event)) {
+			return {};
+		}
+
+		if (config.mode === "rewrite") {
+			const compatibility = applyWindowsBashCompatibilityFixes(event.input.command);
+			if (compatibility.command !== event.input.command) {
+				event.input.command = compatibility.command;
+			}
+		}
+
+		await ensureRuntimeStatusFresh();
+		if (config.guardWhenRtkMissing && !runtimeStatus.rtkAvailable) {
+			return {};
+		}
+
+		const decision = computeRewriteDecision(event.input.command, config);
+		if (!decision.changed || !decision.rule) {
+			return {};
+		}
+
+		if (config.mode === "rewrite") {
+			if (config.showRewriteNotifications && ctx.hasUI) {
+				ctx.ui.notify(formatRewriteNotice(decision.originalCommand, decision.rewrittenCommand), "info");
+			}
+			event.input.command = decision.rewrittenCommand;
+			return {};
+		}
+
+		if (config.mode === "suggest") {
+			const suggestionKey = `${decision.rule.id}:${decision.rewrittenCommand}`;
+			if (!suggestionNotices.has(suggestionKey)) {
+				suggestionNotices.add(suggestionKey);
+				if (ctx.hasUI) {
+					ctx.ui.notify(`RTK suggestion: ${decision.rewrittenCommand}`, "info");
+				}
+			}
+		}
+
+		return {};
+	});
+
+	pi.on("tool_result", async (event, ctx) => {
+		if (!config.enabled || !config.outputCompaction.enabled) {
+			return {};
+		}
+
+		try {
+			const outcome = compactToolResult(
+				{
+					toolName: event.toolName,
+					input: event.input,
+					content: event.content,
+				},
+				config,
+			);
+
+			if (!outcome.changed || !outcome.content) {
+				return {};
+			}
+
+			return {
+				content: outcome.content,
+				details: outcome.metadata
+					? mergeCompactionDetails((event as Record<string, unknown>).details, outcome.metadata)
+					: undefined,
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			warnOnce(ctx, `${EXTENSION_NAME}: output compaction failed, using raw output (${trimMessage(message)}).`);
+			return {};
+		}
+	});
+}

package/src/output-compactor-test.ts

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+
+import { compactToolResult } from "./output-compactor.ts";
+import { DEFAULT_RTK_INTEGRATION_CONFIG, type RtkIntegrationConfig } 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 buildReadContent(lineCount: number): string {
+	const lines: string[] = [];
+	for (let index = 0; index < lineCount; index += 1) {
+		if (index % 2 === 0) {
+			lines.push(`// comment ${index}`);
+		} else {
+			lines.push(`const value${index} = ${index};`);
+		}
+	}
+	return `${lines.join("\n")}\n`;
+}
+
+function firstTextBlock(content: unknown[] | undefined): string {
+	if (!Array.isArray(content) || content.length === 0) {
+		return "";
+	}
+	const first = content[0] as { type?: string; text?: string };
+	if (first?.type !== "text" || typeof first.text !== "string") {
+		return "";
+	}
+	return first.text;
+}
+
+runTest("precision read with offset keeps exact output (no source/smart/hard truncation)", () => {
+	const config = cloneConfig();
+	config.outputCompaction.truncate.enabled = true;
+	config.outputCompaction.truncate.maxChars = 500;
+	config.outputCompaction.smartTruncate.enabled = true;
+	config.outputCompaction.smartTruncate.maxLines = 40;
+
+	const content = buildReadContent(220);
+	const result = compactToolResult(
+		{
+			toolName: "read",
+			input: { path: "sample.ts", offset: 1 },
+			content: [{ type: "text", text: content }],
+		},
+		config,
+	);
+
+	assert.equal(result.changed, false);
+	assert.deepEqual(result.techniques, []);
+});
+
+runTest("precision read with limit keeps exact output", () => {
+	const config = cloneConfig();
+	config.outputCompaction.truncate.enabled = true;
+	config.outputCompaction.truncate.maxChars = 500;
+	config.outputCompaction.smartTruncate.enabled = true;
+	config.outputCompaction.smartTruncate.maxLines = 40;
+
+	const content = buildReadContent(220);
+	const result = compactToolResult(
+		{
+			toolName: "read",
+			input: { path: "sample.ts", limit: 200 },
+			content: [{ type: "text", text: content }],
+		},
+		config,
+	);
+
+	assert.equal(result.changed, false);
+	assert.deepEqual(result.techniques, []);
+});
+
+runTest("normal read compacts and adds banner", () => {
+	const config = cloneConfig();
+	config.outputCompaction.smartTruncate.enabled = true;
+	config.outputCompaction.smartTruncate.maxLines = 40;
+
+	const content = buildReadContent(220);
+	const result = compactToolResult(
+		{
+			toolName: "read",
+			input: { path: "sample.ts" },
+			content: [{ type: "text", text: content }],
+		},
+		config,
+	);
+
+	assert.equal(result.changed, true);
+	assert.ok(result.techniques.includes("source:minimal"));
+
+	const compacted = firstTextBlock(result.content);
+	assert.ok(compacted.startsWith("[RTK compacted output:"));
+	assert.ok(compacted.includes("source:minimal"));
+});
+
+runTest("short read output stays exact below threshold", () => {
+	const config = cloneConfig();
+	const content = buildReadContent(40);
+
+	const result = compactToolResult(
+		{
+			toolName: "read",
+			input: { path: "sample.ts" },
+			content: [{ type: "text", text: content }],
+		},
+		config,
+	);
+
+	assert.equal(result.changed, false);
+	assert.deepEqual(result.techniques, []);
+});
+
+console.log("All output-compactor tests passed.");