pi-rtk-optimizer 0.3.0

package/src/techniques/source.ts

@@ -0,0 +1,230 @@
+export type Language =
+	| "typescript"
+	| "javascript"
+	| "python"
+	| "rust"
+	| "go"
+	| "java"
+	| "c"
+	| "cpp"
+	| "unknown";
+
+const LANGUAGE_EXTENSIONS: Record<string, Language> = {
+	".ts": "typescript",
+	".tsx": "typescript",
+	".js": "javascript",
+	".jsx": "javascript",
+	".mjs": "javascript",
+	".py": "python",
+	".pyw": "python",
+	".rs": "rust",
+	".go": "go",
+	".java": "java",
+	".c": "c",
+	".h": "c",
+	".cpp": "cpp",
+	".hpp": "cpp",
+	".cc": "cpp",
+};
+
+interface CommentPatterns {
+	line?: string;
+	blockStart?: string;
+	blockEnd?: string;
+	docLine?: string;
+	docBlockStart?: string;
+}
+
+const COMMENT_PATTERNS: Record<Language, CommentPatterns> = {
+	typescript: { line: "//", blockStart: "/*", blockEnd: "*/", docBlockStart: "/**" },
+	javascript: { line: "//", blockStart: "/*", blockEnd: "*/", docBlockStart: "/**" },
+	python: { line: "#", blockStart: '"""', blockEnd: '"""', docBlockStart: '"""' },
+	rust: { line: "//", blockStart: "/*", blockEnd: "*/", docLine: "///", docBlockStart: "/**" },
+	go: { line: "//", blockStart: "/*", blockEnd: "*/", docBlockStart: "/**" },
+	java: { line: "//", blockStart: "/*", blockEnd: "*/", docBlockStart: "/**" },
+	c: { line: "//", blockStart: "/*", blockEnd: "*/", docBlockStart: "/**" },
+	cpp: { line: "//", blockStart: "/*", blockEnd: "*/", docBlockStart: "/**" },
+	unknown: { line: "//", blockStart: "/*", blockEnd: "*/" },
+};
+
+const IMPORT_PATTERN = /^(use\s+|import\s+|from\s+|require\(|#include)/;
+const SIGNATURE_PATTERN = /^(pub\s+)?(async\s+)?(fn|def|function|func|class|struct|enum|trait|interface|type)\s+\w+/;
+const CONST_PATTERN = /^(const|static|let|pub\s+const|pub\s+static)\s+/;
+
+export function detectLanguage(filePath: string): Language {
+	const lastDot = filePath.lastIndexOf(".");
+	if (lastDot === -1) {
+		return "unknown";
+	}
+	const extension = filePath.slice(lastDot).toLowerCase();
+	return LANGUAGE_EXTENSIONS[extension] ?? "unknown";
+}
+
+export function filterMinimal(content: string, language: Language): string {
+	const patterns = COMMENT_PATTERNS[language];
+	const lines = content.split("\n");
+	const result: string[] = [];
+	let inBlockComment = false;
+	let inDocstring = false;
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+
+		if (patterns.blockStart && patterns.blockEnd) {
+			if (
+				!inDocstring &&
+				trimmed.includes(patterns.blockStart) &&
+				!(patterns.docBlockStart && trimmed.startsWith(patterns.docBlockStart))
+			) {
+				inBlockComment = true;
+			}
+
+			if (inBlockComment) {
+				if (trimmed.includes(patterns.blockEnd)) {
+					inBlockComment = false;
+				}
+				continue;
+			}
+		}
+
+		if (language === "python" && trimmed.startsWith('"""')) {
+			inDocstring = !inDocstring;
+			result.push(line);
+			continue;
+		}
+
+		if (inDocstring) {
+			result.push(line);
+			continue;
+		}
+
+		if (patterns.line && trimmed.startsWith(patterns.line)) {
+			if (patterns.docLine && trimmed.startsWith(patterns.docLine)) {
+				result.push(line);
+			}
+			continue;
+		}
+
+		if (trimmed.length === 0) {
+			result.push("");
+			continue;
+		}
+
+		result.push(line);
+	}
+
+	return result
+		.join("\n")
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
+}
+
+export function filterAggressive(content: string, language: Language): string {
+	const minimal = filterMinimal(content, language);
+	const lines = minimal.split("\n");
+	const result: string[] = [];
+	let braceDepth = 0;
+	let inImplementation = false;
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+
+		if (IMPORT_PATTERN.test(trimmed)) {
+			result.push(line);
+			continue;
+		}
+
+		if (SIGNATURE_PATTERN.test(trimmed)) {
+			result.push(line);
+			inImplementation = true;
+			braceDepth = 0;
+			continue;
+		}
+
+		const openBraces = (trimmed.match(/\{/g) ?? []).length;
+		const closeBraces = (trimmed.match(/\}/g) ?? []).length;
+
+		if (inImplementation) {
+			braceDepth += openBraces;
+			braceDepth -= closeBraces;
+
+			if (braceDepth <= 1 && (trimmed === "{" || trimmed === "}" || trimmed.endsWith("{"))) {
+				result.push(line);
+			}
+
+			if (braceDepth <= 0) {
+				inImplementation = false;
+				if (trimmed.length > 0 && trimmed !== "}") {
+					result.push("    // ... implementation");
+				}
+			}
+			continue;
+		}
+
+		if (CONST_PATTERN.test(trimmed)) {
+			result.push(line);
+		}
+	}
+
+	return result.join("\n").trim();
+}
+
+export function smartTruncate(content: string, maxLines: number, _language: Language): string {
+	const lines = content.split("\n");
+	if (lines.length <= maxLines) {
+		return content;
+	}
+
+	const result: string[] = [];
+	let keptLines = 0;
+	let skippedSection = false;
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+		const isImportant =
+			SIGNATURE_PATTERN.test(trimmed) ||
+			IMPORT_PATTERN.test(trimmed) ||
+			trimmed.startsWith("pub ") ||
+			trimmed.startsWith("export ") ||
+			trimmed === "}" ||
+			trimmed === "{";
+
+		if (isImportant || keptLines < maxLines / 2) {
+			if (skippedSection) {
+				result.push(`    // ... ${lines.length - keptLines} lines omitted`);
+				skippedSection = false;
+			}
+			result.push(line);
+			keptLines += 1;
+		} else {
+			skippedSection = true;
+		}
+
+		if (keptLines >= maxLines - 1) {
+			break;
+		}
+	}
+
+	if (skippedSection || keptLines < lines.length) {
+		result.push(`// ... ${lines.length - keptLines} more lines (total: ${lines.length})`);
+	}
+
+	return result.join("\n");
+}
+
+export function filterSourceCode(
+	content: string,
+	language: Language,
+	level: "none" | "minimal" | "aggressive",
+): string {
+	switch (level) {
+		case "none":
+			return content;
+		case "minimal":
+			return filterMinimal(content, language);
+		case "aggressive":
+			return filterAggressive(content, language);
+		default:
+			return content;
+	}
+}

package/src/techniques/test-output.ts

@@ -0,0 +1,172 @@
+import { matchesCommandPatterns } from "./command-detection.js";
+
+interface TestSummary {
+	passed: number;
+	failed: number;
+	skipped: number;
+	failures: string[];
+}
+
+const TEST_COMMAND_PATTERNS = [
+	/^npm\s+test\b/,
+	/^pnpm\s+test\b/,
+	/^yarn\s+test\b/,
+	/^bun\s+test\b/,
+	/^cargo\s+test\b/,
+	/^go\s+test\b/,
+	/^pytest\b/,
+	/^python\s+-m\s+pytest\b/,
+	/^(?:pnpm\s+)?(?:npx\s+)?vitest\b/,
+	/^(?:npx\s+)?jest\b/,
+	/^mocha\b/,
+	/^ava\b/,
+	/^tap\b/,
+] as const;
+
+const TEST_RESULT_PATTERNS = [
+	/test result:\s*(\w+)\.\s*(\d+)\s*passed;\s*(\d+)\s*failed;/,
+	/(\d+)\s*passed(?:,\s*(\d+)\s*failed)?(?:,\s*(\d+)\s*skipped)?/i,
+	/(\d+)\s*pass(?:,\s*(\d+)\s*fail)?(?:,\s*(\d+)\s*skip)?/i,
+	/tests?:\s*(\d+)\s*passed(?:,\s*(\d+)\s*failed)?(?:,\s*(\d+)\s*skipped)?/i,
+];
+
+const FAILURE_START_PATTERNS = [
+	/^FAIL\s+/,
+	/^FAILED\s+/,
+	/^\s*●\s+/,
+	/^\s*✕\s+/,
+	/test\s+\w+\s+\.\.\.\s*FAILED/,
+	/thread\s+'\w+'\s+panicked/,
+];
+
+function isFailureStart(line: string): boolean {
+	return FAILURE_START_PATTERNS.some((pattern) => pattern.test(line));
+}
+
+function extractTestStats(output: string): Partial<TestSummary> {
+	for (const pattern of TEST_RESULT_PATTERNS) {
+		const match = output.match(pattern);
+		if (!match) {
+			continue;
+		}
+		return {
+			passed: Number.parseInt(match[1] ?? "0", 10) || 0,
+			failed: Number.parseInt(match[2] ?? "0", 10) || 0,
+			skipped: Number.parseInt(match[3] ?? "0", 10) || 0,
+		};
+	}
+	return {};
+}
+
+export function isTestCommand(command: string | undefined | null): boolean {
+	return matchesCommandPatterns(command, TEST_COMMAND_PATTERNS);
+}
+
+export function aggregateTestOutput(output: string, command: string | undefined | null): string | null {
+	if (!isTestCommand(command)) {
+		return null;
+	}
+
+	const lines = output.split("\n");
+	const summary: TestSummary = {
+		passed: 0,
+		failed: 0,
+		skipped: 0,
+		failures: [],
+	};
+
+	const stats = extractTestStats(output);
+	summary.passed = stats.passed ?? 0;
+	summary.failed = stats.failed ?? 0;
+	summary.skipped = stats.skipped ?? 0;
+
+	if (summary.passed === 0 && summary.failed === 0) {
+		for (const line of lines) {
+			if (line.match(/\b(ok|PASS|✓|✔)\b/)) {
+				summary.passed++;
+			}
+			if (line.match(/\b(FAIL|fail|✗|✕)\b/)) {
+				summary.failed++;
+			}
+		}
+	}
+
+	if (summary.failed > 0) {
+		let inFailure = false;
+		let currentFailure: string[] = [];
+		let blankCount = 0;
+
+		for (const line of lines) {
+			if (isFailureStart(line)) {
+				if (inFailure && currentFailure.length > 0) {
+					summary.failures.push(currentFailure.join("\n"));
+				}
+				inFailure = true;
+				currentFailure = [line];
+				blankCount = 0;
+				continue;
+			}
+
+			if (!inFailure) {
+				continue;
+			}
+
+			if (line.trim() === "") {
+				blankCount++;
+				if (blankCount >= 2 && currentFailure.length > 3) {
+					summary.failures.push(currentFailure.join("\n"));
+					inFailure = false;
+					currentFailure = [];
+				} else {
+					currentFailure.push(line);
+				}
+				continue;
+			}
+
+			if (line.match(/^\s/) || line.match(/^-/)) {
+				currentFailure.push(line);
+				blankCount = 0;
+				continue;
+			}
+
+			summary.failures.push(currentFailure.join("\n"));
+			inFailure = false;
+			currentFailure = [];
+		}
+
+		if (inFailure && currentFailure.length > 0) {
+			summary.failures.push(currentFailure.join("\n"));
+		}
+	}
+
+	const result: string[] = ["📋 Test Results:"];
+	result.push(`   ✅ ${summary.passed} passed`);
+	if (summary.failed > 0) {
+		result.push(`   ❌ ${summary.failed} failed`);
+	}
+	if (summary.skipped > 0) {
+		result.push(`   ⏭️  ${summary.skipped} skipped`);
+	}
+
+	if (summary.failed > 0 && summary.failures.length > 0) {
+		result.push("\n   Failures:");
+		for (const failure of summary.failures.slice(0, 5)) {
+			const failureLines = failure.split("\n");
+			const firstLine = failureLines[0] ?? "";
+			result.push(`   • ${firstLine.slice(0, 70)}${firstLine.length > 70 ? "..." : ""}`);
+			for (const detailLine of failureLines.slice(1, 4)) {
+				if (detailLine.trim()) {
+					result.push(`     ${detailLine.slice(0, 65)}${detailLine.length > 65 ? "..." : ""}`);
+				}
+			}
+			if (failureLines.length > 4) {
+				result.push(`     ... (${failureLines.length - 4} more lines)`);
+			}
+		}
+		if (summary.failures.length > 5) {
+			result.push(`   ... and ${summary.failures.length - 5} more failures`);
+		}
+	}
+
+	return result.join("\n");
+}

package/src/techniques/truncate.ts

@@ -0,0 +1,11 @@
+export function truncate(text: string, maxLength: number): string {
+	if (text.length <= maxLength) {
+		return text;
+	}
+
+	if (maxLength < 3) {
+		return "...";
+	}
+
+	return `${text.slice(0, maxLength - 3)}...`;
+}

package/src/types-shims.d.ts

@@ -0,0 +1,131 @@
+declare module "@mariozechner/pi-tui" {
+	export interface SettingItem {
+		id: string;
+		label: string;
+		description: string;
+		currentValue: string;
+		values: string[];
+	}
+
+	export interface AutocompleteItem {
+		value: string;
+		label: string;
+		description?: string;
+	}
+}
+
+declare module "@mariozechner/pi-coding-agent" {
+	interface UiLike {
+		notify(message: string, level: "info" | "warning" | "error"): void;
+		custom<T>(
+			renderer: (
+				tui: { requestRender(): void },
+				theme: unknown,
+				keybindings: unknown,
+				done: () => void,
+			) => {
+				render(width: number): string[];
+				invalidate?(): void;
+				handleInput(data: string): void;
+			},
+			options?: Record<string, unknown>,
+		): Promise<T>;
+	}
+
+	export interface ExtensionContext {
+		hasUI: boolean;
+		cwd?: string;
+		ui: UiLike;
+	}
+
+	export interface ExtensionCommandContext extends ExtensionContext {}
+
+	export interface ToolResultEvent {
+		toolName: string;
+		input: Record<string, unknown>;
+		content: Array<Record<string, unknown>>;
+		details?: unknown;
+	}
+
+	export interface BashToolCallEvent {
+		toolName: "bash";
+		input: { command: string } & Record<string, unknown>;
+	}
+
+	type MaybePromise<T> = T | Promise<T>;
+
+	export interface ExtensionAPI {
+		exec(
+			command: string,
+			args: string[],
+			options?: { timeout?: number },
+		): Promise<{ code: number; stdout: string; stderr: string }>;
+
+		on(
+			eventName: "tool_call",
+			handler: (
+				event: Record<string, unknown>,
+				ctx: ExtensionContext,
+			) => MaybePromise<Record<string, unknown> | void>,
+		): void;
+
+		on(
+			eventName: "tool_result",
+			handler: (
+				event: ToolResultEvent,
+				ctx: ExtensionContext,
+			) => MaybePromise<Record<string, unknown> | void>,
+		): void;
+
+		on(
+			eventName: "before_agent_start",
+			handler: (
+				event: { systemPrompt: string },
+				ctx: ExtensionContext,
+			) => MaybePromise<{ systemPrompt: string } | Record<string, unknown> | void>,
+		): void;
+
+		on(
+			eventName: string,
+			handler: (event: Record<string, unknown>, ctx: ExtensionContext) => MaybePromise<Record<string, unknown> | void>,
+		): void;
+
+		registerCommand(
+			name: string,
+			definition: {
+				description: string;
+				getArgumentCompletions?: (argumentPrefix: string) => Array<{ value: string; label: string; description?: string }> | null;
+				handler: (args: string, ctx: ExtensionCommandContext) => MaybePromise<void>;
+			},
+		): void;
+	}
+
+	export function isToolCallEventType(
+		toolName: "bash",
+		event: Record<string, unknown>,
+	): event is BashToolCallEvent;
+
+	export function isToolCallEventType(
+		toolName: string,
+		event: Record<string, unknown>,
+	): boolean;
+}
+
+
+declare module "node:os" {
+	export function homedir(): string;
+}
+
+declare module "node:path" {
+	export function join(...segments: string[]): string;
+	export function dirname(path: string): string;
+}
+
+declare module "node:fs" {
+	export function existsSync(path: string): boolean;
+	export function mkdirSync(path: string, options?: { recursive?: boolean }): void;
+	export function readFileSync(path: string, encoding: "utf-8"): string;
+	export function renameSync(oldPath: string, newPath: string): void;
+	export function unlinkSync(path: string): void;
+	export function writeFileSync(path: string, data: string, encoding: "utf-8"): void;
+}

package/src/types.ts

@@ -0,0 +1,114 @@
+export const RTK_MODES = ["rewrite", "suggest"] as const;
+export const RTK_SOURCE_FILTER_LEVELS = ["none", "minimal", "aggressive"] as const;
+
+export type RtkMode = (typeof RTK_MODES)[number];
+export type RtkSourceFilterLevel = (typeof RTK_SOURCE_FILTER_LEVELS)[number];
+
+export interface RtkOutputCompactionConfig {
+	enabled: boolean;
+	stripAnsi: boolean;
+	truncate: {
+		enabled: boolean;
+		maxChars: number;
+	};
+	sourceCodeFilteringEnabled: boolean;
+	sourceCodeFiltering: RtkSourceFilterLevel;
+	smartTruncate: {
+		enabled: boolean;
+		maxLines: number;
+	};
+	aggregateTestOutput: boolean;
+	filterBuildOutput: boolean;
+	compactGitOutput: boolean;
+	aggregateLinterOutput: boolean;
+	groupSearchOutput: boolean;
+	trackSavings: boolean;
+}
+
+export interface RtkIntegrationConfig {
+	enabled: boolean;
+	mode: RtkMode;
+	guardWhenRtkMissing: boolean;
+	showRewriteNotifications: boolean;
+	rewriteGitGithub: boolean;
+	rewriteFilesystem: boolean;
+	rewriteRust: boolean;
+	rewriteJavaScript: boolean;
+	rewritePython: boolean;
+	rewriteGo: boolean;
+	rewriteContainers: boolean;
+	rewriteNetwork: boolean;
+	rewritePackageManagers: boolean;
+	outputCompaction: RtkOutputCompactionConfig;
+}
+
+export const DEFAULT_RTK_INTEGRATION_CONFIG: RtkIntegrationConfig = {
+	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,
+		truncate: {
+			enabled: true,
+			maxChars: 12_000,
+		},
+		sourceCodeFilteringEnabled: true,
+		sourceCodeFiltering: "minimal",
+		smartTruncate: {
+			enabled: true,
+			maxLines: 220,
+		},
+		aggregateTestOutput: true,
+		filterBuildOutput: true,
+		compactGitOutput: true,
+		aggregateLinterOutput: true,
+		groupSearchOutput: true,
+		trackSavings: true,
+	},
+};
+
+export interface ConfigLoadResult {
+	config: RtkIntegrationConfig;
+	warning?: string;
+}
+
+export interface ConfigSaveResult {
+	success: boolean;
+	error?: string;
+}
+
+export interface EnsureConfigResult {
+	created: boolean;
+	error?: string;
+}
+
+export interface RuntimeStatus {
+	rtkAvailable: boolean;
+	lastCheckedAt?: number;
+	lastError?: string;
+}
+
+export const RTK_CATEGORY_KEYS = [
+	"git",
+	"files",
+	"rust",
+	"js",
+	"python",
+	"go",
+	"containers",
+	"network",
+	"packages",
+] as const;
+
+export type RtkCategoryKey = (typeof RTK_CATEGORY_KEYS)[number];