@oh-my-pi/pi-natives 8.12.4

package/README.md

@@ -0,0 +1,63 @@
+# @oh-my-pi/pi-natives
+
+Native Rust functionality compiled to WebAssembly via wasm-bindgen.
+
+## What's Inside
+
+- **Grep**: Regex-based search powered by ripgrep's engine (WASM handles matching, JS handles I/O + gitignore-aware file walking)
+- **Find**: Glob-based file/directory discovery with gitignore support (pure TypeScript via `globPaths`)
+- **Image**: Image processing via photon-rs (resize, format conversion)
+
+## Usage
+
+```typescript
+import { grep, find, PhotonImage, resize, SamplingFilter } from "@oh-my-pi/pi-natives";
+
+// Grep for a pattern
+const results = await grep({
+	pattern: "TODO",
+	path: "/path/to/project",
+	glob: "*.ts",
+	context: 2,
+});
+
+// Find files
+const files = await find({
+	pattern: "*.rs",
+	path: "/path/to/project",
+	fileType: "file",
+});
+
+// Image processing
+using image = await PhotonImage.new_from_byteslice(bytes);
+using resized = await resize(image, 800, 600, SamplingFilter.Lanczos3);
+const pngBytes = await resized.get_bytes();
+```
+
+## Building
+
+```bash
+# Build WASM from workspace root (requires Rust + wasm-pack)
+bun run build:wasm
+
+# Type check
+bun run check
+```
+
+## Architecture
+
+```
+crates/pi-natives/       # Rust source (workspace member)
+  src/lib.rs             # Grep/search + wasm-bindgen bindings
+  src/image.rs           # Image processing (photon-rs)
+  Cargo.toml             # Rust dependencies
+wasm/                    # Generated WASM output
+  pi_natives.wasm        # Compiled WASM module
+  pi_natives.js          # wasm-bindgen generated JS glue
+  pi_natives.d.ts        # TypeScript definitions
+src/                     # TypeScript wrappers
+  index.ts               # Public API
+  grep/                  # Grep with worker pool
+  image/                 # Async image processing via worker
+  pool.ts                # Generic worker pool infrastructure
+```

package/package.json

@@ -0,0 +1,41 @@
+{
+	"name": "@oh-my-pi/pi-natives",
+	"version": "8.12.4",
+	"description": "Native Rust functionality compiled to WebAssembly via wasm-bindgen",
+	"type": "module",
+	"main": "./src/index.ts",
+	"types": "./src/index.ts",
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts"
+		}
+	},
+	"files": [
+		"src",
+		"wasm"
+	],
+	"scripts": {
+		"build:wasm": "bun scripts/build-wasm.ts",
+		"check": "biome check . && tsgo -p tsconfig.json",
+		"fix": "biome check --write --unsafe .",
+		"test": "bun test",
+		"bench": "bun bench/grep.ts"
+	},
+	"author": "Can Bölük",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/can1357/oh-my-pi.git",
+		"directory": "packages/natives"
+	},
+	"dependencies": {
+		"@oh-my-pi/pi-utils": "8.12.4"
+	},
+	"devDependencies": {
+		"@types/node": "^25.0.10"
+	},
+	"engines": {
+		"bun": ">=1.3.7"
+	}
+}

package/src/grep/filters.ts

@@ -0,0 +1,77 @@
+import * as path from "node:path";
+
+export interface TypeFilter {
+	extensions?: string[];
+	names?: string[];
+}
+
+const TYPE_ALIASES: Record<string, TypeFilter> = {
+	js: { extensions: ["js", "jsx", "mjs", "cjs"] },
+	javascript: { extensions: ["js", "jsx", "mjs", "cjs"] },
+	ts: { extensions: ["ts", "tsx", "mts", "cts"] },
+	typescript: { extensions: ["ts", "tsx", "mts", "cts"] },
+	json: { extensions: ["json", "jsonc", "json5"] },
+	yaml: { extensions: ["yaml", "yml"] },
+	yml: { extensions: ["yaml", "yml"] },
+	toml: { extensions: ["toml"] },
+	md: { extensions: ["md", "markdown", "mdx"] },
+	markdown: { extensions: ["md", "markdown", "mdx"] },
+	py: { extensions: ["py", "pyi"] },
+	python: { extensions: ["py", "pyi"] },
+	rs: { extensions: ["rs"] },
+	rust: { extensions: ["rs"] },
+	go: { extensions: ["go"] },
+	java: { extensions: ["java"] },
+	kt: { extensions: ["kt", "kts"] },
+	kotlin: { extensions: ["kt", "kts"] },
+	c: { extensions: ["c", "h"] },
+	cpp: { extensions: ["cpp", "cc", "cxx", "hpp", "hxx", "hh"] },
+	cxx: { extensions: ["cpp", "cc", "cxx", "hpp", "hxx", "hh"] },
+	cs: { extensions: ["cs", "csx"] },
+	csharp: { extensions: ["cs", "csx"] },
+	php: { extensions: ["php", "phtml"] },
+	rb: { extensions: ["rb", "rake", "gemspec"] },
+	ruby: { extensions: ["rb", "rake", "gemspec"] },
+	sh: { extensions: ["sh", "bash", "zsh", "fish"] },
+	bash: { extensions: ["sh", "bash", "zsh"] },
+	zsh: { extensions: ["zsh"] },
+	fish: { extensions: ["fish"] },
+	html: { extensions: ["html", "htm"] },
+	css: { extensions: ["css"] },
+	scss: { extensions: ["scss"] },
+	sass: { extensions: ["sass"] },
+	less: { extensions: ["less"] },
+	xml: { extensions: ["xml"] },
+	docker: { names: ["dockerfile"] },
+	dockerfile: { names: ["dockerfile"] },
+	make: { names: ["makefile"] },
+	makefile: { names: ["makefile"] },
+};
+
+export function buildGlobPattern(glob?: string): string {
+	const trimmed = glob?.trim();
+	if (!trimmed) return "**/*";
+	const normalized = trimmed.replace(/\\/g, "/");
+	if (normalized.includes("/") || normalized.startsWith("**/")) return normalized;
+	return `**/${normalized}`;
+}
+
+export function resolveTypeFilter(type?: string): TypeFilter | undefined {
+	if (!type) return undefined;
+	const trimmed = type.trim();
+	if (!trimmed) return undefined;
+	const normalized = trimmed.toLowerCase();
+	const withoutDot = normalized.startsWith(".") ? normalized.slice(1) : normalized;
+	return TYPE_ALIASES[withoutDot] ?? { extensions: [withoutDot] };
+}
+
+export function matchesTypeFilter(filePath: string, filter?: TypeFilter): boolean {
+	if (!filter) return true;
+	const baseName = path.basename(filePath).toLowerCase();
+	if (filter.names?.some(name => name.toLowerCase() === baseName)) {
+		return true;
+	}
+	const ext = path.extname(baseName).slice(1).toLowerCase();
+	if (!ext) return false;
+	return filter.extensions?.includes(ext) ?? false;
+}

package/src/grep/index.ts

@@ -0,0 +1,314 @@
+/**
+ * Native ripgrep wrapper using wasm-bindgen.
+ *
+ * JS handles filesystem operations (directory walking, file reading).
+ * WASM handles pure regex matching using ripgrep's engine.
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { globPaths } from "@oh-my-pi/pi-utils";
+import {
+	CompiledPattern as WasmCompiledPattern,
+	has_match as wasmHasMatch,
+	search as wasmSearch,
+} from "../../wasm/pi_natives";
+import { WorkerPool } from "../pool";
+import { buildGlobPattern, matchesTypeFilter, resolveTypeFilter } from "./filters";
+import type {
+	ContextLine,
+	GrepMatch,
+	GrepOptions,
+	GrepResult,
+	GrepSummary,
+	WasmSearchResult,
+	WorkerRequest,
+	WorkerResponse,
+} from "./types";
+
+export type { ContextLine, GrepMatch, GrepOptions, GrepResult, GrepSummary };
+
+// =============================================================================
+// File Walking
+// =============================================================================
+
+function filterUndefined<T extends Record<string, unknown>>(obj: T): T {
+	const result = {} as T;
+	for (const [key, value] of Object.entries(obj)) {
+		if (value !== undefined) {
+			(result as Record<string, unknown>)[key] = value;
+		}
+	}
+	return result;
+}
+
+// =============================================================================
+// Grep Implementation
+// =============================================================================
+
+const GREP_WORKERS = (() => {
+	const val = process.env.OMP_GREP_WORKERS;
+	if (val === undefined) return true;
+	const n = Number.parseInt(val, 10);
+	return Number.isNaN(n) || n > 0;
+})();
+
+/**
+ * Search files for a regex pattern (direct, single-threaded).
+ */
+async function grepDirect(options: GrepOptions, onMatch?: (match: GrepMatch) => void): Promise<GrepResult> {
+	const searchPath = path.resolve(options.path);
+	const outputMode = options.mode ?? "content";
+	const wasmMode = outputMode === "content" ? "content" : "count";
+
+	const stat = await fs.stat(searchPath);
+	const isFile = stat.isFile();
+
+	using compiledPattern = new WasmCompiledPattern(
+		filterUndefined({
+			pattern: options.pattern,
+			ignoreCase: options.ignoreCase,
+			multiline: options.multiline,
+			context: options.context,
+			maxColumns: options.maxColumns,
+			mode: wasmMode,
+		}),
+	);
+
+	const typeFilter = resolveTypeFilter(options.type);
+	const globPattern = buildGlobPattern(options.glob);
+
+	const matches: GrepMatch[] = [];
+	let totalMatches = 0;
+	let filesWithMatches = 0;
+	let filesSearched = 0;
+	let limitReached = false;
+	const maxCount = options.maxCount;
+	const globalOffset = options.offset ?? 0;
+
+	if (isFile) {
+		if (typeFilter && !matchesTypeFilter(searchPath, typeFilter)) {
+			return {
+				matches,
+				totalMatches,
+				filesWithMatches,
+				filesSearched,
+				limitReached: limitReached || undefined,
+			};
+		}
+
+		const content = Bun.mmap(searchPath);
+		filesSearched = 1;
+
+		const result = compiledPattern.search_bytes(
+			content,
+			maxCount,
+			globalOffset > 0 ? globalOffset : undefined,
+		) as WasmSearchResult;
+
+		if (result.error) {
+			throw new Error(result.error);
+		}
+
+		if (result.matchCount > 0) {
+			filesWithMatches = 1;
+			totalMatches = result.matchCount;
+
+			if (outputMode === "content") {
+				for (const m of result.matches) {
+					const match: GrepMatch = {
+						path: searchPath,
+						lineNumber: m.lineNumber,
+						line: m.line,
+						contextBefore: m.contextBefore?.length ? m.contextBefore : undefined,
+						contextAfter: m.contextAfter?.length ? m.contextAfter : undefined,
+						truncated: m.truncated || undefined,
+					};
+					matches.push(match);
+					onMatch?.(match);
+				}
+			} else {
+				const match: GrepMatch = {
+					path: searchPath,
+					lineNumber: 0,
+					line: "",
+					matchCount: result.matchCount,
+				};
+				matches.push(match);
+				onMatch?.(match);
+			}
+
+			limitReached = result.limitReached || (maxCount !== undefined && totalMatches >= maxCount);
+		}
+	} else {
+		const paths = await globPaths(globPattern, {
+			cwd: searchPath,
+			dot: options.hidden ?? true,
+			onlyFiles: true,
+			gitignore: true,
+		});
+
+		for (const relativePath of paths) {
+			if (limitReached) break;
+			if (typeFilter && !matchesTypeFilter(relativePath, typeFilter)) {
+				continue;
+			}
+
+			const normalizedPath = relativePath.replace(/\\/g, "/");
+			const fullPath = path.join(searchPath, normalizedPath);
+
+			let content: Uint8Array;
+			try {
+				content = Bun.mmap(fullPath);
+			} catch {
+				continue;
+			}
+
+			filesSearched++;
+
+			if (!compiledPattern.has_match_bytes(content)) {
+				continue;
+			}
+
+			const fileOffset = globalOffset > 0 ? Math.max(globalOffset - totalMatches, 0) : 0;
+			const remaining = maxCount !== undefined ? Math.max(maxCount - totalMatches, 0) : undefined;
+			if (remaining === 0) {
+				limitReached = true;
+				break;
+			}
+			const result = compiledPattern.search_bytes(
+				content,
+				remaining,
+				fileOffset > 0 ? fileOffset : undefined,
+			) as WasmSearchResult;
+
+			if (result.error) {
+				continue;
+			}
+
+			if (result.matchCount > 0) {
+				filesWithMatches++;
+				totalMatches += result.matchCount;
+
+				if (outputMode === "content") {
+					for (const m of result.matches) {
+						const match: GrepMatch = {
+							path: normalizedPath,
+							lineNumber: m.lineNumber,
+							line: m.line,
+							contextBefore: m.contextBefore?.length ? m.contextBefore : undefined,
+							contextAfter: m.contextAfter?.length ? m.contextAfter : undefined,
+							truncated: m.truncated || undefined,
+						};
+						matches.push(match);
+						onMatch?.(match);
+					}
+				} else {
+					const match: GrepMatch = {
+						path: normalizedPath,
+						lineNumber: 0,
+						line: "",
+						matchCount: result.matchCount,
+					};
+					matches.push(match);
+					onMatch?.(match);
+				}
+
+				if (result.limitReached || (maxCount !== undefined && totalMatches >= maxCount)) {
+					limitReached = true;
+				}
+			}
+		}
+	}
+
+	return {
+		matches,
+		totalMatches,
+		filesWithMatches,
+		filesSearched,
+		limitReached: limitReached || undefined,
+	};
+}
+
+// =============================================================================
+// Content Search (lower-level API)
+// =============================================================================
+
+/**
+ * Search a single file's content for a pattern.
+ * Lower-level API for when you already have file content.
+ */
+export function searchContent(
+	content: string,
+	options: {
+		pattern: string;
+		ignoreCase?: boolean;
+		multiline?: boolean;
+		maxCount?: number;
+		offset?: number;
+		context?: number;
+		maxColumns?: number;
+		mode?: "content" | "count";
+	},
+): WasmSearchResult {
+	return wasmSearch(content, filterUndefined(options)) as WasmSearchResult;
+}
+
+/**
+ * Quick check if content contains a pattern match.
+ */
+export function hasMatch(
+	content: string,
+	pattern: string,
+	options?: { ignoreCase?: boolean; multiline?: boolean },
+): boolean {
+	return wasmHasMatch(content, pattern, options?.ignoreCase ?? false, options?.multiline ?? false);
+}
+
+// =============================================================================
+// Public API
+// =============================================================================
+
+/**
+ * Search files for a regex pattern.
+ *
+ * Uses worker pool by default. Set `OMP_GREP_WORKERS=0` to disable.
+ */
+export async function grep(options: GrepOptions, onMatch?: (match: GrepMatch) => void): Promise<GrepResult> {
+	if (GREP_WORKERS) {
+		return await grepPoolInternal(options);
+	}
+	return await grepDirect(options, onMatch);
+}
+
+/**
+ * Search files using worker pool (always, ignores OMP_GREP_WORKERS).
+ */
+export async function grepPool(options: GrepOptions): Promise<GrepResult> {
+	return await grepPoolInternal(options);
+}
+
+// =============================================================================
+// Worker Pool
+// =============================================================================
+
+const pool = new WorkerPool<WorkerRequest, WorkerResponse>({
+	workerUrl: new URL("./worker.ts", import.meta.url).href,
+	maxWorkers: 4,
+	idleTimeoutMs: 30_000,
+});
+
+async function grepPoolInternal(request: GrepOptions): Promise<GrepResult> {
+	const response = await pool.request<Extract<WorkerResponse, { type: "result" }>>({
+		type: "grep",
+		request,
+	});
+	return response.result;
+}
+
+/** Terminate all grep workers. */
+export function terminate(): void {
+	pool.terminate();
+}
+
+export { grepDirect };

package/src/grep/types.ts

@@ -0,0 +1,82 @@
+/** Options for searching files. */
+export interface GrepOptions {
+	/** Regex pattern to search for */
+	pattern: string;
+	/** Directory or file to search */
+	path: string;
+	/** Glob filter for filenames (e.g., "*.ts") */
+	glob?: string;
+	/** Filter by file type (e.g., "js", "py", "rust") */
+	type?: string;
+	/** Case-insensitive search */
+	ignoreCase?: boolean;
+	/** Enable multiline matching */
+	multiline?: boolean;
+	/** Include hidden files (default: true) */
+	hidden?: boolean;
+	/** Maximum number of matches to return */
+	maxCount?: number;
+	/** Skip first N matches */
+	offset?: number;
+	/** Lines of context before/after matches */
+	context?: number;
+	/** Truncate lines longer than this (characters) */
+	maxColumns?: number;
+	/** Output mode */
+	mode?: "content" | "filesWithMatches" | "count";
+}
+
+export interface ContextLine {
+	lineNumber: number;
+	line: string;
+}
+
+export interface GrepMatch {
+	path: string;
+	lineNumber: number;
+	line: string;
+	contextBefore?: ContextLine[];
+	contextAfter?: ContextLine[];
+	truncated?: boolean;
+	matchCount?: number;
+}
+
+export interface GrepSummary {
+	totalMatches: number;
+	filesWithMatches: number;
+	filesSearched: number;
+	limitReached?: boolean;
+}
+
+export interface GrepResult extends GrepSummary {
+	matches: GrepMatch[];
+}
+
+/** WASM match result from the compiled pattern. */
+export interface WasmMatch {
+	lineNumber: number;
+	line: string;
+	contextBefore: ContextLine[];
+	contextAfter: ContextLine[];
+	truncated: boolean;
+}
+
+/** WASM search result. */
+export interface WasmSearchResult {
+	matches: WasmMatch[];
+	matchCount: number;
+	limitReached: boolean;
+	error?: string;
+}
+
+/** Message types from main thread to worker. */
+export type WorkerRequest =
+	| { type: "init"; id: number }
+	| { type: "grep"; id: number; request: GrepOptions }
+	| { type: "destroy" };
+
+/** Message types from worker to main thread. */
+export type WorkerResponse =
+	| { type: "ready"; id: number }
+	| { type: "result"; id: number; result: GrepResult }
+	| { type: "error"; id: number; error: string };