pi-rtk 0.1.0

package/techniques/source.ts

@@ -0,0 +1,246 @@
+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;
+	docComment?: string;
+}
+
+const COMMENT_PATTERNS: Record<Language, CommentPatterns> = {
+	typescript: { line: "//", blockStart: "/*", blockEnd: "*/", docComment: "/**" },
+	javascript: { line: "//", blockStart: "/*", blockEnd: "*/", docComment: "/**" },
+	python: { line: "#", docComment: '"""' },
+	rust: { line: "//", blockStart: "/*", blockEnd: "*/", docComment: "///" },
+	go: { line: "//", blockStart: "/*", blockEnd: "*/", docComment: "//" },
+	java: { line: "//", blockStart: "/*", blockEnd: "*/", docComment: "/**" },
+	c: { line: "//", blockStart: "/*", blockEnd: "*/", docComment: "/*" },
+	cpp: { line: "//", blockStart: "/*", blockEnd: "*/", docComment: "/*" },
+	unknown: {},
+};
+
+export function detectLanguage(filePath: string): Language {
+	const lastDot = filePath.lastIndexOf(".");
+	if (lastDot === -1) return "unknown";
+	const ext = filePath.slice(lastDot).toLowerCase();
+	return LANGUAGE_EXTENSIONS[ext] || "unknown";
+}
+
+export function filterMinimal(content: string, language: Language): string {
+	if (language === "unknown") {
+		return content;
+	}
+
+	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();
+
+		// Handle Python docstrings
+		if (language === "python" && patterns.docComment) {
+			if (trimmed.startsWith(patterns.docComment)) {
+				inDocstring = !inDocstring;
+				result.push(line);
+				continue;
+			}
+			if (inDocstring) {
+				result.push(line);
+				continue;
+			}
+		}
+
+		// Handle block comments
+		if (patterns.blockStart && trimmed.startsWith(patterns.blockStart)) {
+			// Check if it's a doc comment (keep it)
+			if (patterns.docComment && trimmed.startsWith(patterns.docComment)) {
+				result.push(line);
+				continue;
+			}
+			inBlockComment = true;
+		}
+
+		if (inBlockComment) {
+			if (patterns.blockEnd && trimmed.endsWith(patterns.blockEnd)) {
+				inBlockComment = false;
+			}
+			continue;
+		}
+
+		// Handle line comments
+		if (patterns.line) {
+			const commentIndex = line.indexOf(patterns.line);
+			if (commentIndex >= 0) {
+				// Check if it's a doc comment
+				if (patterns.docComment && trimmed.startsWith(patterns.docComment)) {
+					result.push(line);
+					continue;
+				}
+				// Remove the comment portion
+				result.push(line.slice(0, commentIndex));
+				continue;
+			}
+		}
+
+		result.push(line);
+	}
+
+	// Normalize multiple blank lines
+	const normalized = result
+		.join("\n")
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
+
+	return normalized;
+}
+
+export function filterAggressive(content: string, language: Language): string {
+	if (language === "unknown") {
+		return filterMinimal(content, language);
+	}
+
+	const minimal = filterMinimal(content, language);
+	const lines = minimal.split("\n");
+	const result: string[] = [];
+	let braceDepth = 0;
+	let inImplementation = false;
+
+	// Patterns to preserve
+	const importPattern = /^(use\s+|import\s+|from\s+|require\(|#include)/;
+	const signaturePattern =
+		/^(pub\s+)?(async\s+)?(fn|def|function|func|class|struct|enum|trait|interface|type)\s+\w+/;
+	const constPattern = /^(const|static|let|pub\s+const|pub\s+static)\s+/;
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+
+		// Always keep imports
+		if (importPattern.test(trimmed)) {
+			result.push(line);
+			continue;
+		}
+
+		// Keep function/type signatures
+		if (signaturePattern.test(trimmed)) {
+			result.push(line);
+			inImplementation = true;
+			braceDepth = 0;
+			continue;
+		}
+
+		// Track brace depth for bodies
+		if (inImplementation) {
+			const openBraces = (trimmed.match(/\{/g) || []).length;
+			const closeBraces = (trimmed.match(/\}/g) || []).length;
+			braceDepth += openBraces - closeBraces;
+
+			// Only keep opening/closing braces
+			if (braceDepth <= 1 && (trimmed === "{" || trimmed === "}" || trimmed.endsWith("{"))) {
+				result.push(line);
+			}
+
+			if (braceDepth <= 0) {
+				inImplementation = false;
+				if (trimmed !== "" && trimmed !== "}") {
+					result.push("    // ... implementation");
+				}
+			}
+			continue;
+		}
+
+		// Keep constants and type definitions
+		if (constPattern.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;
+
+	// Patterns for important lines
+	const importantPattern =
+		/^(import|use|from|require|#include|fn|def|function|func|class|struct|enum|trait|interface|type|const|static|let|pub\s)/;
+
+	for (const line of lines) {
+		const trimmed = line.trim();
+		const isImportant = importantPattern.test(trimmed);
+
+		if (isImportant || keptLines < maxLines / 2) {
+			if (skippedSection) {
+				result.push(`    // ... ${lines.length - result.length - keptLines} lines omitted`);
+				skippedSection = false;
+			}
+			result.push(line);
+			keptLines++;
+		} 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/techniques/test-output.ts

@@ -0,0 +1,172 @@
+interface TestSummary {
+	passed: number;
+	failed: number;
+	skipped: number;
+	failures: string[];
+}
+
+const TEST_COMMANDS = [
+	"test",
+	"jest",
+	"vitest",
+	"pytest",
+	"cargo test",
+	"bun test",
+	"go test",
+	"mocha",
+	"ava",
+	"tap",
+];
+
+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/,
+];
+
+export function isTestCommand(command: string | undefined | null): boolean {
+	if (typeof command !== "string" || command.length === 0) {
+		return false;
+	}
+
+	const cmdLower = command.toLowerCase();
+	return TEST_COMMANDS.some((tc) => cmdLower.includes(tc.toLowerCase()));
+}
+
+function isFailureStart(line: string): boolean {
+	return FAILURE_START_PATTERNS.some((pattern) => pattern.test(line));
+}
+
+function extractTestStats(output: string): Partial<TestSummary> {
+	const summary: Partial<TestSummary> = {};
+
+	for (const pattern of TEST_RESULT_PATTERNS) {
+		const match = output.match(pattern);
+		if (match) {
+			summary.passed = parseInt(match[1], 10) || 0;
+			summary.failed = parseInt(match[2], 10) || 0;
+			summary.skipped = parseInt(match[3], 10) || 0;
+			return summary;
+		}
+	}
+
+	return summary;
+}
+
+export function aggregateTestOutput(
+	output: string,
+	command: string | undefined | null
+): string | null {
+	if (typeof command !== "string" || !isTestCommand(command)) {
+		return null;
+	}
+
+	const lines = output.split("\n");
+	const summary: TestSummary = {
+		passed: 0,
+		failed: 0,
+		skipped: 0,
+		failures: [],
+	};
+
+	// Extract stats from output
+	const stats = extractTestStats(output);
+	summary.passed = stats.passed || 0;
+	summary.failed = stats.failed || 0;
+	summary.skipped = stats.skipped || 0;
+
+	// Fallback: count passes/fails manually if no stats found
+	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++;
+		}
+	}
+
+	// Extract failure details if tests 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) {
+				if (line.trim() === "") {
+					blankCount++;
+					if (blankCount >= 2 && currentFailure.length > 3) {
+						summary.failures.push(currentFailure.join("\n"));
+						inFailure = false;
+						currentFailure = [];
+					} else {
+						currentFailure.push(line);
+					}
+				} else if (line.match(/^\s/) || line.match(/^-/)) {
+					// Continuation of failure
+					currentFailure.push(line);
+					blankCount = 0;
+				} else {
+					// End of failure block
+					summary.failures.push(currentFailure.join("\n"));
+					inFailure = false;
+					currentFailure = [];
+				}
+			}
+		}
+
+		if (inFailure && currentFailure.length > 0) {
+			summary.failures.push(currentFailure.join("\n"));
+		}
+	}
+
+	// Format output
+	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 lines = failure.split("\n");
+			const firstLine = lines[0];
+			result.push(`   • ${firstLine.slice(0, 70)}${firstLine.length > 70 ? "..." : ""}`);
+			for (const line of lines.slice(1, 4)) {
+				if (line.trim()) {
+					result.push(`     ${line.slice(0, 65)}${line.length > 65 ? "..." : ""}`);
+				}
+			}
+			if (lines.length > 4) {
+				result.push(`     ... (${lines.length - 4} more lines)`);
+			}
+		}
+		if (summary.failures.length > 5) {
+			result.push(`   ... and ${summary.failures.length - 5} more failures`);
+		}
+	}
+
+	return result.join("\n");
+}

package/techniques/truncate.ts

@@ -0,0 +1,27 @@
+export function truncate(text: string, maxLength: number): string {
+	if (text.length <= maxLength) {
+		return text;
+	}
+
+	if (maxLength < 3) {
+		return "...";
+	}
+
+	return text.slice(0, maxLength - 3) + "...";
+}
+
+export function truncateLines(text: string, maxLines: number): string {
+	const lines = text.split("\n");
+	if (lines.length <= maxLines) {
+		return text;
+	}
+
+	const keepLines = Math.floor(maxLines / 2);
+	const result = [
+		...lines.slice(0, keepLines),
+		`\n... ${lines.length - maxLines} lines omitted ...\n`,
+		...lines.slice(-keepLines),
+	];
+
+	return result.join("\n");
+}