pi-rtk-optimizer 0.3.3 → 0.5.0

package/src/techniques/linter.ts

@@ -1,161 +1,151 @@
-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;
-}
+import { matchesCommandPatterns, normalizeCommandForDetection } from "./command-detection.js";
+import { compactPath } from "./path-utils.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";
+}
+
+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 `[OK] ${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/path-utils.ts

@@ -0,0 +1,67 @@
+function detectPathSeparator(path: string): "/" | "\\" {
+	return path.includes("\\") && !path.includes("/") ? "\\" : "/";
+}
+
+function detectPathPrefix(path: string, separator: "/" | "\\"): string {
+	if (/^[A-Za-z]:[\\/]/.test(path)) {
+		return `${path.slice(0, 2)}${separator}`;
+	}
+
+	if (path.startsWith("\\\\") || path.startsWith("//")) {
+		const parts = path.split(/[\\/]+/).filter((part) => part.length > 0);
+		if (parts.length >= 2) {
+			return `${separator}${separator}${parts[0]}${separator}${parts[1]}${separator}`;
+		}
+		return `${separator}${separator}`;
+	}
+
+	if (path.startsWith("/") || path.startsWith("\\")) {
+		return separator;
+	}
+
+	return "";
+}
+
+function joinPathSegments(prefix: string, separator: "/" | "\\", segments: string[]): string {
+	if (segments.length === 0) {
+		return prefix || "";
+	}
+
+	const joined = segments.join(separator);
+	return prefix ? `${prefix}${joined}` : joined;
+}
+
+export function compactPath(path: string, maxLength: number): string {
+	if (path.length <= maxLength) {
+		return path;
+	}
+
+	if (maxLength < 2) {
+		return path.slice(0, maxLength);
+	}
+
+	const separator = detectPathSeparator(path);
+	const prefix = detectPathPrefix(path, separator);
+	const segments = path
+		.slice(prefix.length)
+		.split(/[\\/]+/)
+		.filter((segment) => segment.length > 0);
+
+	const lastSegment = segments[segments.length - 1] ?? path.slice(-(maxLength - 1));
+	const previousSegment = segments[segments.length - 2];
+
+	const candidates = [
+		joinPathSegments(prefix, separator, ["…", ...(previousSegment ? [previousSegment] : []), lastSegment]),
+		joinPathSegments("", separator, ["…", ...(previousSegment ? [previousSegment] : []), lastSegment]),
+		joinPathSegments("", separator, ["…", lastSegment]),
+		`…${path.slice(-(maxLength - 1))}`,
+	];
+
+	for (const candidate of candidates) {
+		if (candidate.length <= maxLength) {
+			return candidate;
+		}
+	}
+
+	return `…${lastSegment.slice(-(maxLength - 1))}`;
+}

package/src/techniques/rtk.ts

@@ -0,0 +1,136 @@
+const RTK_HOOK_WARNING_MESSAGES = [
+	"No hook installed — run `rtk init -g` for automatic token savings",
+	"Hook outdated — run `rtk init -g` to update",
+] as const;
+
+const RTK_HOOK_WARNING_PREFIX_MARKERS = ["[rtk] /!\\", "⚠", "[WARN]"] as const;
+
+type HookWarningLineStripResult =
+	| {
+			removed: false;
+			removedLine: false;
+			line: string;
+	  }
+	| {
+			removed: true;
+			removedLine: boolean;
+			line: string;
+	  };
+
+function outputContainsKnownHookWarning(output: string): boolean {
+	return RTK_HOOK_WARNING_MESSAGES.some((message) => output.includes(message));
+}
+
+function isQuotedPrefixBoundary(line: string, prefixIndex: number): boolean {
+	if (prefixIndex <= 0) {
+		return false;
+	}
+
+	const charBefore = line[prefixIndex - 1];
+	return charBefore === "\"" || charBefore === "'";
+}
+
+function findClosestWarningPrefixIndex(line: string, beforeIndex: number): number {
+	let closestIndex = -1;
+	for (const marker of RTK_HOOK_WARNING_PREFIX_MARKERS) {
+		const index = line.lastIndexOf(marker, beforeIndex);
+		if (index > closestIndex) {
+			closestIndex = index;
+		}
+	}
+
+	return closestIndex;
+}
+
+function stripHookWarningFromLine(line: string): HookWarningLineStripResult {
+	const trimmed = line.trim();
+	if (!trimmed) {
+		return { removed: false, removedLine: false, line };
+	}
+
+	if (RTK_HOOK_WARNING_MESSAGES.some((message) => trimmed === message)) {
+		return { removed: true, removedLine: true, line: "" };
+	}
+
+	for (const message of RTK_HOOK_WARNING_MESSAGES) {
+		const messageIndex = line.indexOf(message);
+		if (messageIndex === -1) {
+			continue;
+		}
+
+		const prefixIndex = findClosestWarningPrefixIndex(line, messageIndex);
+		if (prefixIndex === -1) {
+			continue;
+		}
+
+		if (isQuotedPrefixBoundary(line, prefixIndex)) {
+			continue;
+		}
+
+		let removalStart = prefixIndex;
+		while (removalStart > 0 && /\s/.test(line[removalStart - 1] ?? "")) {
+			removalStart -= 1;
+		}
+
+		const removalEnd = messageIndex + message.length;
+		const before = line.slice(0, removalStart);
+		const after = line.slice(removalEnd);
+
+		let nextLine = `${before}${after}`;
+		if (before.trim() !== "" && after.trim() !== "") {
+			nextLine = `${before.trimEnd()}\n${after}`;
+		}
+
+		if (!nextLine.trim()) {
+			return { removed: true, removedLine: true, line: "" };
+		}
+
+		return { removed: true, removedLine: false, line: nextLine };
+	}
+
+	return { removed: false, removedLine: false, line };
+}
+
+/**
+ * Removes only RTK hook status notices that are not actionable inside Pi.
+ * Other RTK warnings should remain visible so the agent can inspect them.
+ */
+export function stripRtkHookWarnings(output: string, _command: string | undefined | null): string | null {
+	if (!outputContainsKnownHookWarning(output)) {
+		return null;
+	}
+
+	const filteredLines: string[] = [];
+	let removedWarning = false;
+	let skipImmediateBlankLine = false;
+
+	for (const line of output.split("\n")) {
+		if (skipImmediateBlankLine && line.trim() === "") {
+			skipImmediateBlankLine = false;
+			continue;
+		}
+
+		const stripped = stripHookWarningFromLine(line);
+		if (stripped.removed) {
+			removedWarning = true;
+		}
+
+		if (stripped.removedLine) {
+			skipImmediateBlankLine = true;
+			continue;
+		}
+
+		skipImmediateBlankLine = false;
+		filteredLines.push(stripped.line);
+	}
+
+	if (!removedWarning) {
+		return null;
+	}
+
+	while (filteredLines.length > 0 && filteredLines[0]?.trim() === "") {
+		filteredLines.shift();
+	}
+
+	return filteredLines.join("\n");
+}

package/src/techniques/search.ts

@@ -1,76 +1,67 @@
-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;
-}
+import { compactPath } from "./path-utils.js";
+
+interface SearchResult {
+	file: string;
+	lineNumber: string;
+	content: string;
+}
+
+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;
+}