pi-rtk 0.1.0

package/techniques/git.ts

@@ -0,0 +1,245 @@
+const GIT_COMMANDS = ["git diff", "git status", "git log", "git show", "git stash"];
+
+export function isGitCommand(command: string | undefined | null): boolean {
+	if (typeof command !== "string" || command.length === 0) {
+		return false;
+	}
+
+	const cmdLower = command.toLowerCase();
+	return GIT_COMMANDS.some((gc) => cmdLower.startsWith(gc));
+}
+
+export function compactDiff(output: string, maxLines: number = 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;
+		}
+
+		// New file
+		if (line.startsWith("diff --git")) {
+			// Flush previous file stats
+			if (currentFile && (added > 0 || removed > 0)) {
+				result.push(`  +${added} -${removed}`);
+			}
+
+			// Extract filename
+			const match = line.match(/diff --git a\/(.+) b\/(.+)/);
+			currentFile = match ? match[2] : "unknown";
+			result.push(`\n📄 ${currentFile}`);
+			added = 0;
+			removed = 0;
+			inHunk = false;
+			continue;
+		}
+
+		// Hunk header
+		if (line.startsWith("@@")) {
+			inHunk = true;
+			hunkLines = 0;
+			const hunkInfo = line.match(/@@ .+ @@/)?.[0] || "@@";
+			result.push(`  ${hunkInfo}`);
+			continue;
+		}
+
+		// Hunk content
+		if (inHunk) {
+			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++;
+			}
+		}
+	}
+
+	// Flush last file stats
+	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) {
+		// Extract branch name from first line
+		if (line.startsWith("##")) {
+			const match = line.match(/## (.+)/);
+			if (match) {
+				branchName = match[1].split("...")[0];
+			}
+			continue;
+		}
+
+		if (line.length < 3) {
+			continue;
+		}
+
+		const status = line.slice(0, 2);
+		const filename = line.slice(3);
+
+		// Parse two-character status
+		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);
+		}
+	}
+
+	// Build summary
+	let result = `📌 ${branchName}\n`;
+
+	if (stats.staged > 0) {
+		result += `✅ Staged: ${stats.staged} files\n`;
+		const shown = stats.stagedFiles.slice(0, 5);
+		for (const file of shown) {
+			result += `  ${file}\n`;
+		}
+		if (stats.staged > 5) {
+			result += `  ... +${stats.staged - 5} more\n`;
+		}
+	}
+
+	if (stats.modified > 0) {
+		result += `📝 Modified: ${stats.modified} files\n`;
+		const shown = stats.modifiedFiles.slice(0, 5);
+		for (const file of shown) {
+			result += `  ${file}\n`;
+		}
+		if (stats.modified > 5) {
+			result += `  ... +${stats.modified - 5} more\n`;
+		}
+	}
+
+	if (stats.untracked > 0) {
+		result += `❓ Untracked: ${stats.untracked} files\n`;
+		const shown = stats.untrackedFiles.slice(0, 3);
+		for (const file of shown) {
+			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: number = 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 (typeof command !== "string" || !isGitCommand(command)) {
+		return null;
+	}
+
+	const cmdLower = command.toLowerCase();
+
+	if (cmdLower.startsWith("git diff")) {
+		return compactDiff(output);
+	}
+
+	if (cmdLower.startsWith("git status")) {
+		return compactStatus(output);
+	}
+
+	if (cmdLower.startsWith("git log")) {
+		return compactLog(output);
+	}
+
+	return null;
+}

package/techniques/index.ts

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

package/techniques/linter.ts

@@ -0,0 +1,191 @@
+const LINTER_COMMANDS = [
+	"eslint",
+	"prettier",
+	"ruff",
+	"pylint",
+	"mypy",
+	"flake8",
+	"black",
+	"clippy",
+	"golangci-lint",
+];
+
+interface Issue {
+	severity: "ERROR" | "WARNING";
+	rule: string;
+	file: string;
+	line?: number;
+	message: string;
+}
+
+export function isLinterCommand(command: string | undefined | null): boolean {
+	if (typeof command !== "string" || command.length === 0) {
+		return false;
+	}
+
+	const cmdLower = command.toLowerCase();
+	return LINTER_COMMANDS.some((lc) => cmdLower.includes(lc));
+}
+
+function parseIssues(output: string, linterType: string): Issue[] {
+	const issues: Issue[] = [];
+	const lines = output.split("\n");
+
+	for (const line of lines) {
+		const issue = parseLine(line, linterType);
+		if (issue) {
+			issues.push(issue);
+		}
+	}
+
+	return issues;
+}
+
+function parseLine(line: string, linterType: string): Issue | null {
+	// ESLint: /path/to/file.js:10:5: Error message [rule-id]
+	// Ruff: /path/to/file.py:10:5: E501 Error message
+	// Pylint: /path/to/file.py:10:5: E0001: Error message (rule-id)
+	// Clippy: error: message at src/main.rs:10:5
+
+	const patterns = [
+		// file:line:col: message [rule]
+		{
+			pattern: /^(.+):(\d+):(\d+):\s*(.+)$/,
+			extract: (match: RegExpMatchArray) => ({
+				file: match[1],
+				line: parseInt(match[2], 10),
+				content: match[4],
+			}),
+		},
+		// error: message at file:line:col
+		{
+			pattern: /^(error|warning):\s*(.+?)\s+at\s+(.+):(\d+):(\d+)$/,
+			extract: (match: RegExpMatchArray) => ({
+				severity: match[1].toUpperCase() as "ERROR" | "WARNING",
+				message: match[2],
+				file: match[3],
+				line: parseInt(match[4], 10),
+				content: match[2],
+			}),
+		},
+	];
+
+	for (const { pattern, extract } of patterns) {
+		const match = line.match(pattern);
+		if (match) {
+			const extracted = extract(match);
+			return {
+				severity: extracted.severity || "ERROR",
+				rule: extracted.content?.match(/\[(.+?)\]$/)?.[1] || "unknown",
+				file: extracted.file,
+				line: extracted.line,
+				message: extracted.content || extracted.message || line,
+			};
+		}
+	}
+
+	return null;
+}
+
+export function aggregateLinterOutput(
+	output: string,
+	command: string | undefined | null
+): string | null {
+	if (typeof command !== "string" || !isLinterCommand(command)) {
+		return null;
+	}
+
+	// Detect linter type from command
+	const linterType = detectLinterType(command);
+
+	// Parse issues
+	const issues = parseIssues(output, linterType);
+
+	if (issues.length === 0) {
+		return `✓ ${linterType}: No issues found`;
+	}
+
+	// Count by severity
+	const errors = issues.filter((i) => i.severity === "ERROR").length;
+	const warnings = issues.filter((i) => i.severity === "WARNING").length;
+
+	// Group by rule
+	const byRule = new Map<string, number>();
+	for (const issue of issues) {
+		byRule.set(issue.rule, (byRule.get(issue.rule) || 0) + 1);
+	}
+
+	// Group by file
+	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);
+	}
+
+	// Build output
+	let result = `${linterType}: ${errors} errors, ${warnings} warnings in ${byFile.size} files\n`;
+	result += "═══════════════════════════════════════\n";
+
+	// Top rules
+	const sortedRules = Array.from(byRule.entries())
+		.sort((a, b) => b[1] - a[1])
+		.slice(0, 10);
+	result += "Top rules:\n";
+	for (const [rule, count] of sortedRules) {
+		result += `  ${rule} (${count}x)\n`;
+	}
+
+	// Top files
+	result += "\nTop files:\n";
+	const sortedFiles = Array.from(byFile.entries())
+		.sort((a, b) => b[1].length - a[1].length)
+		.slice(0, 10);
+
+	for (const [file, fileIssues] of sortedFiles) {
+		const compact = compactPath(file, 40);
+		result += `  ${compact} (${fileIssues.length} issues)\n`;
+
+		// Show top 3 rules per file
+		const fileRules = new Map<string, number>();
+		for (const issue of fileIssues) {
+			fileRules.set(issue.rule, (fileRules.get(issue.rule) || 0) + 1);
+		}
+
+		const sortedFileRules = Array.from(fileRules.entries())
+			.sort((a, b) => b[1] - a[1])
+			.slice(0, 3);
+
+		for (const [rule, count] of sortedFileRules) {
+			result += `    ${rule} (${count})\n`;
+		}
+	}
+
+	return result;
+}
+
+function detectLinterType(command: string): string {
+	const cmdLower = command.toLowerCase();
+	if (cmdLower.includes("eslint")) return "ESLint";
+	if (cmdLower.includes("ruff")) return "Ruff";
+	if (cmdLower.includes("pylint")) return "Pylint";
+	if (cmdLower.includes("mypy")) return "MyPy";
+	if (cmdLower.includes("flake8")) return "Flake8";
+	if (cmdLower.includes("clippy")) return "Clippy";
+	if (cmdLower.includes("golangci")) return "GolangCI-Lint";
+	if (cmdLower.includes("prettier")) 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]}`;
+}

package/techniques/search.ts

@@ -0,0 +1,100 @@
+const SEARCH_COMMANDS = ["grep", "rg", "find", "ack", "ag"];
+
+export function isSearchCommand(command: string | undefined | null): boolean {
+	if (typeof command !== "string" || command.length === 0) {
+		return false;
+	}
+
+	const cmdLower = command.toLowerCase();
+	return SEARCH_COMMANDS.some((sc) => cmdLower.includes(sc));
+}
+
+interface SearchResult {
+	file: string;
+	lineNumber: string;
+	content: string;
+}
+
+export function groupSearchResults(
+	output: string,
+	maxResults: number = 50
+): string | null {
+	const lines = output.split("\n");
+	const results: SearchResult[] = [];
+
+	// Parse search results
+	for (const line of lines) {
+		if (!line.trim()) continue;
+
+		// Match patterns like: file:line:content or file:content
+		const match = line.match(/^(.+?):(\d+)?:(.+)$/);
+		if (match) {
+			results.push({
+				file: match[1],
+				lineNumber: match[2] || "?",
+				content: match[3],
+			});
+		}
+	}
+
+	if (results.length === 0) {
+		return null;
+	}
+
+	// Group by file
+	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);
+	}
+
+	// Build output
+	let output_text = `🔍 ${results.length} matches in ${byFile.size} files:\n\n`;
+
+	const files = Array.from(byFile.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+	let shown = 0;
+
+	for (const [file, matches] of files) {
+		if (shown >= maxResults) {
+			break;
+		}
+
+		const compactFile = compactPath(file, 50);
+		output_text += `📄 ${compactFile} (${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) + "...";
+			}
+			output_text += `    ${match.lineNumber}: ${cleaned}\n`;
+			shown++;
+		}
+
+		if (matches.length > 10) {
+			output_text += `  +${matches.length - 10} more\n`;
+		}
+
+		output_text += "\n";
+	}
+
+	if (results.length > shown) {
+		output_text += `... +${results.length - shown} more\n`;
+	}
+
+	return output_text;
+}
+
+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]}`;
+}