pi-rtk-optimizer 0.3.0

package/src/techniques/build.ts

@@ -0,0 +1,155 @@
+import { matchesCommandPatterns } from "./command-detection.js";
+
+interface BuildStats {
+	compiled: number;
+	errors: string[][];
+	warnings: string[];
+}
+
+const BUILD_COMMAND_PATTERNS = [
+	/^cargo\s+(build|check)\b/,
+	/^bun\s+build\b/,
+	/^npm\s+run\s+build\b/,
+	/^yarn\s+build\b/,
+	/^pnpm\s+build\b/,
+	/^(?:npx\s+)?tsc\b/,
+	/^make\b/,
+	/^cmake\b/,
+	/^gradle\b/,
+	/^mvn\b/,
+	/^go\s+(build|install)\b/,
+	/^python\s+setup\.py\s+build\b/,
+	/^pip\s+install\b/,
+] as const;
+
+const SKIP_PATTERNS = [
+	/^\s*Compiling\s+/,
+	/^\s*Checking\s+/,
+	/^\s*Downloading\s+/,
+	/^\s*Downloaded\s+/,
+	/^\s*Fetching\s+/,
+	/^\s*Fetched\s+/,
+	/^\s*Updating\s+/,
+	/^\s*Updated\s+/,
+	/^\s*Building\s+/,
+	/^\s*Generated\s+/,
+	/^\s*Creating\s+/,
+	/^\s*Running\s+/,
+];
+
+const ERROR_START_PATTERNS = [/^error\[/, /^error:/, /^\[ERROR\]/, /^FAIL/];
+const WARNING_PATTERNS = [/^warning:/, /^\[WARNING\]/, /^warn:/];
+
+function isSkipLine(line: string): boolean {
+	return SKIP_PATTERNS.some((pattern) => pattern.test(line));
+}
+
+function isErrorStart(line: string): boolean {
+	return ERROR_START_PATTERNS.some((pattern) => pattern.test(line));
+}
+
+function isWarning(line: string): boolean {
+	return WARNING_PATTERNS.some((pattern) => pattern.test(line));
+}
+
+export function isBuildCommand(command: string | undefined | null): boolean {
+	return matchesCommandPatterns(command, BUILD_COMMAND_PATTERNS);
+}
+
+export function filterBuildOutput(output: string, command: string | undefined | null): string | null {
+	if (!isBuildCommand(command)) {
+		return null;
+	}
+
+	const lines = output.split("\n");
+	const stats: BuildStats = {
+		compiled: 0,
+		errors: [],
+		warnings: [],
+	};
+
+	let inErrorBlock = false;
+	let currentError: string[] = [];
+	let blankCount = 0;
+
+	for (const line of lines) {
+		if (line.match(/^\s*(Compiling|Checking|Building)\s+/)) {
+			stats.compiled++;
+			continue;
+		}
+
+		if (isSkipLine(line)) {
+			continue;
+		}
+
+		if (isErrorStart(line)) {
+			if (inErrorBlock && currentError.length > 0) {
+				stats.errors.push([...currentError]);
+			}
+			inErrorBlock = true;
+			currentError = [line];
+			blankCount = 0;
+			continue;
+		}
+
+		if (isWarning(line)) {
+			stats.warnings.push(line);
+			continue;
+		}
+
+		if (!inErrorBlock) {
+			continue;
+		}
+
+		if (line.trim() === "") {
+			blankCount++;
+			if (blankCount >= 2 && currentError.length > 3) {
+				stats.errors.push([...currentError]);
+				inErrorBlock = false;
+				currentError = [];
+			} else {
+				currentError.push(line);
+			}
+			continue;
+		}
+
+		if (line.match(/^\s/) || line.match(/^-->/)) {
+			currentError.push(line);
+			blankCount = 0;
+			continue;
+		}
+
+		stats.errors.push([...currentError]);
+		inErrorBlock = false;
+		currentError = [];
+	}
+
+	if (inErrorBlock && currentError.length > 0) {
+		stats.errors.push(currentError);
+	}
+
+	if (stats.errors.length === 0 && stats.warnings.length === 0) {
+		return `✓ Build successful (${stats.compiled} units compiled)`;
+	}
+
+	const result: string[] = [];
+
+	if (stats.errors.length > 0) {
+		result.push(`❌ ${stats.errors.length} error(s):`);
+		for (const error of stats.errors.slice(0, 5)) {
+			result.push(...error.slice(0, 10));
+			if (error.length > 10) {
+				result.push("  ...");
+			}
+		}
+		if (stats.errors.length > 5) {
+			result.push(`... and ${stats.errors.length - 5} more errors`);
+		}
+	}
+
+	if (stats.warnings.length > 0) {
+		result.push(`\n⚠️  ${stats.warnings.length} warning(s)`);
+	}
+
+	return result.join("\n");
+}

package/src/techniques/command-detection.ts

@@ -0,0 +1,53 @@
+const ENV_PREFIX_PATTERN = /^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+)*/;
+const CHAIN_OPERATORS = ["&&", "||", ";", "|"] as const;
+
+function sliceFirstSegment(command: string): string {
+	let cutIndex = -1;
+	for (const operator of CHAIN_OPERATORS) {
+		const index = command.indexOf(operator);
+		if (index === -1) {
+			continue;
+		}
+		if (cutIndex === -1 || index < cutIndex) {
+			cutIndex = index;
+		}
+	}
+
+	if (cutIndex === -1) {
+		return command;
+	}
+	return command.slice(0, cutIndex);
+}
+
+export function normalizeCommandForDetection(command: string | undefined | null): string | null {
+	if (typeof command !== "string") {
+		return null;
+	}
+
+	const firstNonEmptyLine = command
+		.split(/\r?\n/)
+		.map((line) => line.trim())
+		.find((line) => line.length > 0);
+	if (!firstNonEmptyLine) {
+		return null;
+	}
+
+	const withoutEnvPrefix = firstNonEmptyLine.replace(ENV_PREFIX_PATTERN, "").trim();
+	if (!withoutEnvPrefix) {
+		return null;
+	}
+
+	const firstSegment = sliceFirstSegment(withoutEnvPrefix).trim().toLowerCase();
+	return firstSegment || null;
+}
+
+export function matchesCommandPatterns(
+	command: string | undefined | null,
+	patterns: readonly RegExp[],
+): boolean {
+	const normalized = normalizeCommandForDetection(command);
+	if (!normalized) {
+		return false;
+	}
+	return patterns.some((pattern) => pattern.test(normalized));
+}

package/src/techniques/git.ts

@@ -0,0 +1,229 @@
+import { matchesCommandPatterns, normalizeCommandForDetection } from "./command-detection.js";
+
+const GIT_COMMAND_PATTERNS = [/^git\s+(diff|status|log|show|stash)\b/] as const;
+
+export function isGitCommand(command: string | undefined | null): boolean {
+	return matchesCommandPatterns(command, GIT_COMMAND_PATTERNS);
+}
+
+export function compactDiff(output: string, maxLines = 50): string {
+	const lines = output.split("\n");
+	const result: string[] = [];
+	let currentFile = "";
+	let added = 0;
+	let removed = 0;
+	let inHunk = false;
+	let hunkLines = 0;
+	const maxHunkLines = 10;
+
+	for (const line of lines) {
+		if (result.length >= maxLines) {
+			result.push("\n... (more changes truncated)");
+			break;
+		}
+
+		if (line.startsWith("diff --git")) {
+			if (currentFile && (added > 0 || removed > 0)) {
+				result.push(`  +${added} -${removed}`);
+			}
+
+			const match = line.match(/diff --git a\/(.+) b\/(.+)/);
+			currentFile = match?.[2] ?? "unknown";
+			result.push(`\n📄 ${currentFile}`);
+			added = 0;
+			removed = 0;
+			inHunk = false;
+			continue;
+		}
+
+		if (line.startsWith("@@")) {
+			inHunk = true;
+			hunkLines = 0;
+			const hunkInfo = line.match(/@@ .+ @@/)?.[0] ?? "@@";
+			result.push(`  ${hunkInfo}`);
+			continue;
+		}
+
+		if (!inHunk) {
+			continue;
+		}
+
+		if (line.startsWith("+") && !line.startsWith("+++")) {
+			added++;
+			if (hunkLines < maxHunkLines) {
+				result.push(`  ${line}`);
+				hunkLines++;
+			}
+		} else if (line.startsWith("-") && !line.startsWith("---")) {
+			removed++;
+			if (hunkLines < maxHunkLines) {
+				result.push(`  ${line}`);
+				hunkLines++;
+			}
+		} else if (hunkLines < maxHunkLines && !line.startsWith("\\")) {
+			if (hunkLines > 0) {
+				result.push(`  ${line}`);
+				hunkLines++;
+			}
+		}
+
+		if (hunkLines === maxHunkLines) {
+			result.push("  ... (truncated)");
+			hunkLines++;
+		}
+	}
+
+	if (currentFile && (added > 0 || removed > 0)) {
+		result.push(`  +${added} -${removed}`);
+	}
+
+	return result.join("\n");
+}
+
+interface StatusStats {
+	staged: number;
+	modified: number;
+	untracked: number;
+	conflicts: number;
+	stagedFiles: string[];
+	modifiedFiles: string[];
+	untrackedFiles: string[];
+}
+
+export function compactStatus(output: string): string {
+	const lines = output.split("\n");
+
+	if (lines.length === 0 || (lines.length === 1 && lines[0]?.trim() === "")) {
+		return "Clean working tree";
+	}
+
+	const stats: StatusStats = {
+		staged: 0,
+		modified: 0,
+		untracked: 0,
+		conflicts: 0,
+		stagedFiles: [],
+		modifiedFiles: [],
+		untrackedFiles: [],
+	};
+
+	let branchName = "";
+
+	for (const line of lines) {
+		if (line.startsWith("##")) {
+			const match = line.match(/## (.+)/);
+			if (match?.[1]) {
+				branchName = match[1].split("...")[0] ?? match[1];
+			}
+			continue;
+		}
+
+		if (line.length < 3) {
+			continue;
+		}
+
+		const status = line.slice(0, 2);
+		const filename = line.slice(3);
+		const indexStatus = status[0];
+		const worktreeStatus = status[1];
+
+		if (["M", "A", "D", "R", "C"].includes(indexStatus)) {
+			stats.staged++;
+			stats.stagedFiles.push(filename);
+		}
+
+		if (indexStatus === "U") {
+			stats.conflicts++;
+		}
+
+		if (["M", "D"].includes(worktreeStatus)) {
+			stats.modified++;
+			stats.modifiedFiles.push(filename);
+		}
+
+		if (status === "??") {
+			stats.untracked++;
+			stats.untrackedFiles.push(filename);
+		}
+	}
+
+	let result = `📌 ${branchName}\n`;
+
+	if (stats.staged > 0) {
+		result += `✅ Staged: ${stats.staged} files\n`;
+		for (const file of stats.stagedFiles.slice(0, 5)) {
+			result += `  ${file}\n`;
+		}
+		if (stats.staged > 5) {
+			result += `  ... +${stats.staged - 5} more\n`;
+		}
+	}
+
+	if (stats.modified > 0) {
+		result += `📝 Modified: ${stats.modified} files\n`;
+		for (const file of stats.modifiedFiles.slice(0, 5)) {
+			result += `  ${file}\n`;
+		}
+		if (stats.modified > 5) {
+			result += `  ... +${stats.modified - 5} more\n`;
+		}
+	}
+
+	if (stats.untracked > 0) {
+		result += `❓ Untracked: ${stats.untracked} files\n`;
+		for (const file of stats.untrackedFiles.slice(0, 3)) {
+			result += `  ${file}\n`;
+		}
+		if (stats.untracked > 3) {
+			result += `  ... +${stats.untracked - 3} more\n`;
+		}
+	}
+
+	if (stats.conflicts > 0) {
+		result += `⚠️  Conflicts: ${stats.conflicts} files\n`;
+	}
+
+	return result.trim();
+}
+
+export function compactLog(output: string, limit = 20): string {
+	const lines = output.split("\n");
+	const result: string[] = [];
+
+	for (const line of lines.slice(0, limit)) {
+		if (line.length > 80) {
+			result.push(`${line.slice(0, 77)}...`);
+		} else {
+			result.push(line);
+		}
+	}
+
+	if (lines.length > limit) {
+		result.push(`... and ${lines.length - limit} more commits`);
+	}
+
+	return result.join("\n");
+}
+
+export function compactGitOutput(output: string, command: string | undefined | null): string | null {
+	if (!isGitCommand(command)) {
+		return null;
+	}
+
+	const normalized = normalizeCommandForDetection(command);
+	if (!normalized) {
+		return null;
+	}
+
+	if (normalized.startsWith("git diff")) {
+		return compactDiff(output);
+	}
+	if (normalized.startsWith("git status")) {
+		return compactStatus(output);
+	}
+	if (normalized.startsWith("git log")) {
+		return compactLog(output);
+	}
+
+	return null;
+}

package/src/techniques/index.ts

@@ -0,0 +1,16 @@
+export { stripAnsi, stripAnsiFast } from "./ansi.js";
+export { truncate } from "./truncate.js";
+export { filterBuildOutput, isBuildCommand } from "./build.js";
+export { aggregateTestOutput, isTestCommand } from "./test-output.js";
+export { aggregateLinterOutput, isLinterCommand } from "./linter.js";
+export {
+	detectLanguage,
+	filterMinimal,
+	filterAggressive,
+	smartTruncate,
+	filterSourceCode,
+	type Language,
+} from "./source.js";
+export { compactDiff, compactStatus, compactLog, compactGitOutput, isGitCommand } from "./git.js";
+export { groupSearchResults } from "./search.js";
+export { normalizeCommandForDetection, matchesCommandPatterns } from "./command-detection.js";

package/src/techniques/linter.ts

@@ -0,0 +1,161 @@
+import { matchesCommandPatterns, normalizeCommandForDetection } from "./command-detection.js";
+
+const LINTER_COMMAND_PATTERNS = [
+	/^(?:pnpm\s+)?(?:npx\s+)?eslint\b/,
+	/^(?:npx\s+)?prettier\b/,
+	/^ruff\b/,
+	/^pylint\b/,
+	/^mypy\b/,
+	/^flake8\b/,
+	/^black\b/,
+	/^cargo\s+clippy\b/,
+	/^golangci-lint\b/,
+] as const;
+
+interface Issue {
+	severity: "ERROR" | "WARNING";
+	rule: string;
+	file: string;
+	line?: number;
+	message: string;
+}
+
+export function isLinterCommand(command: string | undefined | null): boolean {
+	return matchesCommandPatterns(command, LINTER_COMMAND_PATTERNS);
+}
+
+function parseLine(line: string): Issue | null {
+	const fileLinePattern = /^(.+):(\d+):(\d+):\s*(.+)$/;
+	const rustPattern = /^(error|warning):\s*(.+?)\s+at\s+(.+):(\d+):(\d+)$/;
+
+	const fileLineMatch = line.match(fileLinePattern);
+	if (fileLineMatch) {
+		const file = fileLineMatch[1] ?? "unknown";
+		const lineNumber = Number.parseInt(fileLineMatch[2] ?? "0", 10);
+		const content = fileLineMatch[4] ?? line;
+		const severity = /warning/i.test(content) ? "WARNING" : "ERROR";
+		const rule = content.match(/\[(.+?)\]$/)?.[1] ?? "unknown";
+		return {
+			severity,
+			rule,
+			file,
+			line: Number.isNaN(lineNumber) ? undefined : lineNumber,
+			message: content,
+		};
+	}
+
+	const rustMatch = line.match(rustPattern);
+	if (rustMatch) {
+		const severity = (rustMatch[1]?.toUpperCase() ?? "ERROR") as "ERROR" | "WARNING";
+		const message = rustMatch[2] ?? line;
+		const file = rustMatch[3] ?? "unknown";
+		const lineNumber = Number.parseInt(rustMatch[4] ?? "0", 10);
+		return {
+			severity,
+			rule: "unknown",
+			file,
+			line: Number.isNaN(lineNumber) ? undefined : lineNumber,
+			message,
+		};
+	}
+
+	return null;
+}
+
+function parseIssues(output: string): Issue[] {
+	const issues: Issue[] = [];
+	for (const line of output.split("\n")) {
+		const parsed = parseLine(line);
+		if (parsed) {
+			issues.push(parsed);
+		}
+	}
+	return issues;
+}
+
+function detectLinterType(command: string | undefined | null): string {
+	const normalized = normalizeCommandForDetection(command);
+	if (!normalized) {
+		return "Linter";
+	}
+	if (/(?:^|\s)eslint\b/.test(normalized)) return "ESLint";
+	if (/^ruff\b/.test(normalized)) return "Ruff";
+	if (/^pylint\b/.test(normalized)) return "Pylint";
+	if (/^mypy\b/.test(normalized)) return "MyPy";
+	if (/^flake8\b/.test(normalized)) return "Flake8";
+	if (/clippy\b/.test(normalized)) return "Clippy";
+	if (/^golangci-lint\b/.test(normalized)) return "GolangCI-Lint";
+	if (/prettier\b/.test(normalized)) return "Prettier";
+	return "Linter";
+}
+
+function compactPath(path: string, maxLength: number): string {
+	if (path.length <= maxLength) {
+		return path;
+	}
+	const parts = path.split("/");
+	if (parts.length <= 3) {
+		return path;
+	}
+	return `${parts[0]}/.../${parts[parts.length - 2]}/${parts[parts.length - 1]}`;
+}
+
+export function aggregateLinterOutput(output: string, command: string | undefined | null): string | null {
+	if (!isLinterCommand(command)) {
+		return null;
+	}
+
+	const linterType = detectLinterType(command);
+	const issues = parseIssues(output);
+
+	if (issues.length === 0) {
+		return `✓ ${linterType}: No issues found`;
+	}
+
+	const errors = issues.filter((issue) => issue.severity === "ERROR").length;
+	const warnings = issues.filter((issue) => issue.severity === "WARNING").length;
+
+	const byRule = new Map<string, number>();
+	for (const issue of issues) {
+		byRule.set(issue.rule, (byRule.get(issue.rule) ?? 0) + 1);
+	}
+
+	const byFile = new Map<string, Issue[]>();
+	for (const issue of issues) {
+		const existing = byFile.get(issue.file) ?? [];
+		existing.push(issue);
+		byFile.set(issue.file, existing);
+	}
+
+	let result = `${linterType}: ${errors} errors, ${warnings} warnings in ${byFile.size} files\n`;
+	result += "═══════════════════════════════════════\n";
+
+	result += "Top rules:\n";
+	const sortedRules = Array.from(byRule.entries())
+		.sort((left, right) => right[1] - left[1])
+		.slice(0, 10);
+	for (const [rule, count] of sortedRules) {
+		result += `  ${rule} (${count}x)\n`;
+	}
+
+	result += "\nTop files:\n";
+	const sortedFiles = Array.from(byFile.entries())
+		.sort((left, right) => right[1].length - left[1].length)
+		.slice(0, 10);
+
+	for (const [file, fileIssues] of sortedFiles) {
+		result += `  ${compactPath(file, 40)} (${fileIssues.length} issues)\n`;
+		const fileRules = new Map<string, number>();
+		for (const issue of fileIssues) {
+			fileRules.set(issue.rule, (fileRules.get(issue.rule) ?? 0) + 1);
+		}
+		const topRules = Array.from(fileRules.entries())
+			.sort((left, right) => right[1] - left[1])
+			.slice(0, 3);
+		for (const [rule, count] of topRules) {
+			result += `    ${rule} (${count})\n`;
+		}
+	}
+
+	return result;
+}

package/src/techniques/search.ts

@@ -0,0 +1,76 @@
+interface SearchResult {
+	file: string;
+	lineNumber: string;
+	content: string;
+}
+
+function compactPath(path: string, maxLength: number): string {
+	if (path.length <= maxLength) {
+		return path;
+	}
+	const parts = path.split("/");
+	if (parts.length <= 3) {
+		return path;
+	}
+	return `${parts[0]}/.../${parts[parts.length - 2]}/${parts[parts.length - 1]}`;
+}
+
+export function groupSearchResults(output: string, maxResults = 50): string | null {
+	const results: SearchResult[] = [];
+	for (const line of output.split("\n")) {
+		if (!line.trim()) {
+			continue;
+		}
+		const match = line.match(/^(.+?):(\d+)?:(.+)$/);
+		if (!match) {
+			continue;
+		}
+		results.push({
+			file: match[1] ?? "unknown",
+			lineNumber: match[2] ?? "?",
+			content: match[3] ?? "",
+		});
+	}
+
+	if (results.length === 0) {
+		return null;
+	}
+
+	const byFile = new Map<string, SearchResult[]>();
+	for (const result of results) {
+		const existing = byFile.get(result.file) ?? [];
+		existing.push(result);
+		byFile.set(result.file, existing);
+	}
+
+	let outputText = `🔍 ${results.length} matches in ${byFile.size} files:\n\n`;
+	const sortedFiles = Array.from(byFile.entries()).sort((left, right) =>
+		left[0].localeCompare(right[0]),
+	);
+
+	let shown = 0;
+	for (const [file, matches] of sortedFiles) {
+		if (shown >= maxResults) {
+			break;
+		}
+		outputText += `📄 ${compactPath(file, 50)} (${matches.length} matches):\n`;
+		for (const match of matches.slice(0, 10)) {
+			let cleaned = match.content.trim();
+			if (cleaned.length > 70) {
+				cleaned = `${cleaned.slice(0, 67)}...`;
+			}
+			outputText += `    ${match.lineNumber}: ${cleaned}\n`;
+			shown++;
+		}
+		if (matches.length > 10) {
+			outputText += `  +${matches.length - 10} more\n`;
+		}
+		outputText += "\n";
+	}
+
+	if (results.length > shown) {
+		outputText += `... +${results.length - shown} more\n`;
+	}
+
+	return outputText;
+}