@oh-my-pi/pi-natives 9.4.0 → 9.6.0

package/README.md

@@ -1,12 +1,12 @@
 # @oh-my-pi/pi-natives
 
-Native Rust functionality compiled to WebAssembly via wasm-bindgen.
+Native Rust functionality via N-API.
 
 ## What's Inside
 
-- **Grep**: Regex-based search powered by ripgrep's engine (WASM handles matching, JS handles I/O + gitignore-aware file walking)
+- **Grep**: Regex-based search powered by ripgrep's engine with native file walking and matching
 - **Find**: Glob-based file/directory discovery with gitignore support (pure TypeScript via `globPaths`)
-- **Image**: Image processing via photon-rs (resize, format conversion)
+- **Image**: Image processing via photon-rs (resize, format conversion) exposed through N-API
 
 ## Usage
 
@@ -37,8 +37,8 @@ const pngBytes = await resized.get_bytes();
 ## Building
 
 ```bash
-# Build WASM from workspace root (requires Rust + wasm-pack)
-bun run build:wasm
+# Build native addon from workspace root (requires Rust)
+bun run build:native
 
 # Type check
 bun run check
@@ -48,16 +48,13 @@ bun run check
 
 ```
 crates/pi-natives/       # Rust source (workspace member)
-  src/lib.rs             # Grep/search + wasm-bindgen bindings
+  src/lib.rs             # N-API exports
   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
+native/                  # Native addon binaries
+  pi_natives.<platform>-<arch>.node
+  pi_natives.node
 src/                     # TypeScript wrappers
+  native.ts              # Native addon loader
   index.ts               # Public API
-  grep/                  # Grep with worker pool
-  image/                 # Async image processing via worker
-  pool.ts                # Generic worker pool infrastructure
 ```

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@oh-my-pi/pi-natives",
-	"version": "9.4.0",
-	"description": "Native Rust functionality compiled to WebAssembly via wasm-bindgen",
+	"version": "9.6.0",
+	"description": "Native Rust functionality via N-API",
 	"type": "module",
 	"main": "./src/index.ts",
 	"types": "./src/index.ts",
@@ -13,13 +13,13 @@
 	},
 	"files": [
 		"src",
-		"wasm"
+		"native"
 	],
 	"scripts": {
-		"build:wasm": "bun scripts/build-wasm.ts",
+		"build:native": "bun scripts/build-native.ts",
 		"check": "biome check . && tsgo -p tsconfig.json",
 		"fix": "biome check --write --unsafe .",
-		"test": "bun test",
+		"test": "bun run build:native && bun test",
 		"bench": "bun bench/grep.ts"
 	},
 	"author": "Can Bölük",
@@ -30,7 +30,7 @@
 		"directory": "packages/natives"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-utils": "9.4.0"
+		"@oh-my-pi/pi-utils": "9.6.0"
 	},
 	"devDependencies": {
 		"@types/node": "^25.0.10"

package/src/find/types.ts

@@ -0,0 +1,31 @@
+/**
+ * Types for native find API.
+ */
+
+export interface FindOptions {
+	/** Glob pattern to match (e.g., `*.ts`) */
+	pattern: string;
+	/** Directory to search */
+	path: string;
+	/** Filter by file type: "file", "dir", or "symlink" */
+	fileType?: "file" | "dir" | "symlink";
+	/** Include hidden files (default: false) */
+	hidden?: boolean;
+	/** Maximum number of results */
+	maxResults?: number;
+	/** Respect .gitignore files (default: true) */
+	gitignore?: boolean;
+	/** Sort results by mtime (most recent first) before applying limit */
+	sortByMtime?: boolean;
+}
+
+export interface FindMatch {
+	path: string;
+	fileType: "file" | "dir" | "symlink";
+	mtime?: number;
+}
+
+export interface FindResult {
+	matches: FindMatch[];
+	totalMatches: number;
+}

package/src/grep/index.ts

@@ -1,329 +1,71 @@
 /**
- * Native ripgrep wrapper using wasm-bindgen.
- *
- * JS handles filesystem operations (directory walking, file reading).
- * WASM handles pure regex matching using ripgrep's engine.
+ * Native ripgrep wrapper using N-API.
  */
 
-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 { resolveWorkerSpecifier } from "../worker-resolver";
-import { FileReader } from "./file-reader";
-import { buildGlobPattern, matchesTypeFilter, resolveTypeFilter } from "./filters";
+import { native } from "../native";
+import { wrapRequestOptions } from "../request-options";
 import type {
 	ContextLine,
+	FuzzyFindMatch,
+	FuzzyFindOptions,
+	FuzzyFindResult,
 	GrepMatch,
 	GrepOptions,
 	GrepResult,
 	GrepSummary,
-	WasmSearchResult,
-	WorkerRequest,
-	WorkerResponse,
+	SearchOptions,
+	SearchResult,
 } 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;
-})();
+export type {
+	ContextLine,
+	FuzzyFindMatch,
+	FuzzyFindOptions,
+	FuzzyFindResult,
+	GrepMatch,
+	GrepOptions,
+	GrepResult,
+	GrepSummary,
+	SearchOptions,
+	SearchResult,
+};
 
 /**
- * Search files for a regex pattern (direct, single-threaded).
+ * Search files for a regex pattern with optional streaming callback.
  */
-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 fileReader = new FileReader();
-		const content = await fileReader.read(searchPath);
-		if (!content) {
-			return {
-				matches,
-				totalMatches,
-				filesWithMatches,
-				filesSearched,
-				limitReached: limitReached || undefined,
-			};
-		}
-		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,
-		});
-
-		const fileReader = new FileReader();
-		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);
-
-			const content = await fileReader.read(fullPath);
-			if (!content) 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,
-	};
+export async function grep(options: GrepOptions, onMatch?: (match: GrepMatch) => void): Promise<GrepResult> {
+	return wrapRequestOptions(() => native.grep(options, onMatch), options);
 }
 
-// =============================================================================
-// Content Search (lower-level API)
-// =============================================================================
-
 /**
  * Search a single file's content for a pattern.
  * Lower-level API for when you already have file content.
+ *
+ * Accepts `Uint8Array`/`Buffer` for zero-copy when content is already UTF-8 encoded.
  */
-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;
+export function searchContent(content: string | Uint8Array, options: SearchOptions): SearchResult {
+	return native.search(content, options);
 }
 
 /**
  * Quick check if content contains a pattern match.
+ *
+ * Accepts `Uint8Array`/`Buffer` for zero-copy when content/pattern are already UTF-8 encoded.
  */
 export function hasMatch(
-	content: string,
-	pattern: string,
+	content: string | Uint8Array,
+	pattern: string | Uint8Array,
 	options?: { ignoreCase?: boolean; multiline?: boolean },
 ): boolean {
-	return wasmHasMatch(content, pattern, options?.ignoreCase ?? false, options?.multiline ?? false);
+	return native.hasMatch(content, pattern, options?.ignoreCase ?? false, options?.multiline ?? false);
 }
 
-// =============================================================================
-// Public API
-// =============================================================================
-
 /**
- * Search files for a regex pattern.
+ * Fuzzy file path search for autocomplete.
  *
- * Uses worker pool by default. Set `OMP_GREP_WORKERS=0` to disable.
+ * Searches for files and directories whose paths contain the query substring
+ * (case-insensitive). Respects .gitignore by default.
  */
-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>({
-	createWorker: () =>
-		new Worker(
-			resolveWorkerSpecifier({
-				compiled: "./packages/natives/src/grep/worker.ts",
-				dev: new URL("./worker.ts", import.meta.url),
-			}),
-		),
-	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;
+export async function fuzzyFind(options: FuzzyFindOptions): Promise<FuzzyFindResult> {
+	return wrapRequestOptions(() => native.fuzzyFind(options), options);
 }
-
-/** Terminate all grep workers. */
-export function terminate(): void {
-	pool.terminate();
-}
-
-export { grepDirect };

package/src/grep/types.ts

@@ -1,5 +1,7 @@
+import type { RequestOptions } from "../request-options";
+
 /** Options for searching files. */
-export interface GrepOptions {
+export interface GrepOptions extends RequestOptions {
 	/** Regex pattern to search for */
 	pattern: string;
 	/** Directory or file to search */
@@ -52,31 +54,69 @@ export interface GrepResult extends GrepSummary {
 	matches: GrepMatch[];
 }
 
-/** WASM match result from the compiled pattern. */
-export interface WasmMatch {
+export interface SearchOptions {
+	/** Regex pattern to search for */
+	pattern: string;
+	/** Case-insensitive search */
+	ignoreCase?: boolean;
+	/** Enable multiline matching */
+	multiline?: 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" | "count";
+}
+
+export interface SearchMatch {
 	lineNumber: number;
 	line: string;
-	contextBefore: ContextLine[];
-	contextAfter: ContextLine[];
-	truncated: boolean;
+	contextBefore?: ContextLine[];
+	contextAfter?: ContextLine[];
+	truncated?: boolean;
 }
 
-/** WASM search result. */
-export interface WasmSearchResult {
-	matches: WasmMatch[];
+export interface SearchResult {
+	matches: SearchMatch[];
 	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" };
+export type WasmMatch = SearchMatch;
+export type WasmSearchResult = SearchResult;
 
-/** 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 };
+/** Options for fuzzy file path search. */
+export interface FuzzyFindOptions extends RequestOptions {
+	/** Substring query to match against file paths (case-insensitive). */
+	query: string;
+	/** Directory to search. */
+	path: string;
+	/** Include hidden files (default: false). */
+	hidden?: boolean;
+	/** Respect .gitignore (default: true). */
+	gitignore?: boolean;
+	/** Maximum number of matches to return (default: 100). */
+	maxResults?: number;
+}
+
+/** A single match in fuzzy find results. */
+export interface FuzzyFindMatch {
+	/** Relative path from the search root (uses `/` separators). */
+	path: string;
+	/** Whether this entry is a directory. */
+	isDirectory: boolean;
+}
+
+/** Result of fuzzy file path search. */
+export interface FuzzyFindResult {
+	/** Matched entries (up to `maxResults`). */
+	matches: FuzzyFindMatch[];
+	/** Total number of matches found (may exceed `matches.length`). */
+	totalMatches: number;
+}

package/src/highlight/index.ts

@@ -1,16 +1,8 @@
 /**
- * Syntax highlighting powered by WASM (syntect).
+ * Syntax highlighting powered by native syntect bindings.
  */
 
-import * as wasm from "../../wasm/pi_natives";
-
-type WasmHighlightExports = typeof wasm & {
-	highlight_code: (code: string, lang: string | null | undefined, colors: HighlightColors) => string;
-	supports_language: (lang: string) => boolean;
-	get_supported_languages: () => string[];
-};
-
-const wasmHighlight = wasm as WasmHighlightExports;
+import { native } from "../native";
 
 /**
  * Theme colors for syntax highlighting.
@@ -41,19 +33,19 @@ export interface HighlightColors {
  * @returns Highlighted code as a single string with ANSI color codes
  */
 export function highlightCode(code: string, lang: string | undefined, colors: HighlightColors): string {
-	return wasmHighlight.highlight_code(code, lang, colors);
+	return native.highlightCode(code, lang, colors);
 }
 
 /**
  * Check if a language is supported for highlighting.
  */
 export function supportsLanguage(lang: string): boolean {
-	return wasmHighlight.supports_language(lang);
+	return native.supportsLanguage(lang);
 }
 
 /**
  * Get list of all supported languages.
  */
 export function getSupportedLanguages(): string[] {
-	return wasmHighlight.get_supported_languages();
+	return native.getSupportedLanguages();
 }

package/src/html/index.ts

@@ -1,27 +1,13 @@
 /**
- * HTML to Markdown conversion powered by WASM.
- *
- * Conversion happens in a worker thread to avoid blocking the main thread.
+ * HTML to Markdown conversion powered by native bindings.
  */
 
-import { type RequestOptions, WorkerPool } from "../pool";
-import { resolveWorkerSpecifier } from "../worker-resolver";
-import type { HtmlRequest, HtmlResponse, HtmlToMarkdownOptions } from "./types";
+import { native } from "../native";
+import { type RequestOptions, wrapRequestOptions } from "../request-options";
+import type { HtmlToMarkdownOptions } from "./types";
 
 export type { HtmlToMarkdownOptions } from "./types";
 
-const pool = new WorkerPool<HtmlRequest, HtmlResponse>({
-	createWorker: () =>
-		new Worker(
-			resolveWorkerSpecifier({
-				compiled: "./packages/natives/src/html/worker.ts",
-				dev: new URL("./worker.ts", import.meta.url),
-			}),
-		),
-	maxWorkers: 2,
-	idleTimeoutMs: 30_000,
-});
-
 /**
  * Convert HTML to Markdown.
  *
@@ -34,21 +20,5 @@ export async function htmlToMarkdown(
 	options?: HtmlToMarkdownOptions,
 	req?: RequestOptions,
 ): Promise<string> {
-	const response = await pool.request<Extract<HtmlResponse, { type: "converted" }>>(
-		{
-			type: "convert",
-			html,
-			options,
-		},
-		req,
-	);
-	return response.markdown;
-}
-
-/**
- * Terminate the HTML worker pool.
- * Call this when shutting down to clean up resources.
- */
-export function terminate(): void {
-	pool.terminate();
+	return wrapRequestOptions(() => native.htmlToMarkdown(html, options), req);
 }