feat: implement grep using ripgrep

- Add search and searchFile functions for pattern matching in files and directories.
- Introduce validatePattern function to check regex validity.
- Create SearchOptions and SearchResult types for better search configuration and results handling.
- Update package metadata and dependencies in Cargo.toml and package.json.
- Add benchmark scripts and sample files for performance testing.
- Remove obsolete simple-test.js file.
- Create .envrc and update .gitignore for environment management.
- Add flake.nix and flake.lock for Nix package management.

Author: yaonyan

.envrc

@@ -0,0 +1 @@
+use flake

.gitignore

@@ -193,3 +193,5 @@ Temporary Items
 ### macOS Patch ###
 # iCloud generated files
 *.icloud
+
+.direnv/

Cargo.toml

@@ -1,8 +1,11 @@
 [package]
-authors = ["LongYinan <lynweklm@gmail.com>"]
+authors = ["yaonyan"]
 edition = "2021"
-name = "napi-package-template"
+name = "ripgrep-napi"
 version = "0.1.0"
+description = "NAPI bindings for ripgrep - fast line-oriented search"
+license = "MIT"
+repository = "https://github.com/yaonyan/ripgrep-napi"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -13,6 +16,16 @@ crate-type = ["cdylib"]
 napi = "3.0.0"
 napi-derive = "3.0.0"
 
+# Core grep functionality
+grep = "0.3"
+grep-searcher = "0.1"
+
+# File system traversal
+ignore = "0.4"
+
+# Serialization for NAPI objects
+serde = { version = "1.0", features = ["derive"] }
+
 [build-dependencies]
 napi-build = "2"
 

__test__/index.spec.ts

@@ -1,8 +1,42 @@
 import test from 'ava'
 
-import { plus100 } from '../index.js'
+import { search, searchFile, validatePattern, getSupportedFileTypes } from '../index.js'
 
-test('sync function from native code', (t) => {
-  const fixture = 42
-  t.is(plus100(fixture), fixture + 100)
+test('validate pattern function', (t) => {
+  t.true(validatePattern('hello'))
+  t.true(validatePattern('\\d+'))
+  t.false(validatePattern('['))
+})
+
+test('get supported file types function', (t) => {
+  const types = getSupportedFileTypes()
+  t.true(Array.isArray(types))
+  t.true(types.length > 0)
+  t.true(types.includes('rust'))
+  t.true(types.includes('javascript'))
+})
+
+test('search function with basic pattern', async (t) => {
+  // Search for 'use' in the current source file
+  const result = search('use', ['./src/lib.rs'])
+  
+  t.true(result.success)
+  t.is(typeof result.filesSearched, 'number')
+  t.is(typeof result.filesWithMatches, 'number')
+  t.is(typeof result.totalMatches, 'number')
+  t.true(Array.isArray(result.matches))
+})
+
+test('search file function', async (t) => {
+  // Search for 'fn' in the source file
+  const result = searchFile('fn', './src/lib.rs')
+  
+  t.true(result.success)
+  t.true(result.matches.length > 0)
+  
+  // Check first match structure
+  const firstMatch = result.matches[0]
+  t.is(typeof firstMatch.path, 'string')
+  t.is(typeof firstMatch.lineNumber, 'number')
+  t.is(typeof firstMatch.line, 'string')
 })

benchmark/bench.ts

@@ -1,21 +1,206 @@
 import { Bench } from 'tinybench'
+import fs from 'fs'
 
-import { plus100 } from '../index.js'
+import { search, searchFile, validatePattern } from '../index.js'
 
-function add(a: number) {
-  return a + 100
+// Create large test content to showcase Rust's performance
+const createLargeContent = (baseContent: string, multiplier: number) => {
+  return baseContent.repeat(multiplier)
 }
 
+// JavaScript implementation for comparison (including file read time)
+function jsSearchWithFileRead(pattern: string, filePath: string) {
+  const content = fs.readFileSync(filePath, 'utf-8')
+  const lines = content.split('\n')
+  const matches = []
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (line.includes(pattern)) {
+      matches.push({
+        lineNumber: i + 1,
+        line: line,
+        start: line.indexOf(pattern),
+        end: line.indexOf(pattern) + pattern.length
+      })
+    }
+  }
+  
+  return matches
+}
+
+// JavaScript multi-file search (naive implementation)
+function jsMultiFileSearch(pattern: string, filePaths: string[]) {
+  const allMatches = []
+  let filesSearched = 0
+  let filesWithMatches = 0
+  
+  for (const filePath of filePaths) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8')
+      const lines = content.split('\n')
+      const fileMatches = []
+      
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i]
+        if (line.includes(pattern)) {
+          fileMatches.push({
+            path: filePath,
+            lineNumber: i + 1,
+            line: line,
+            start: line.indexOf(pattern),
+            end: line.indexOf(pattern) + pattern.length
+          })
+        }
+      }
+      
+      filesSearched++
+      if (fileMatches.length > 0) {
+        filesWithMatches++
+        allMatches.push(...fileMatches)
+      }
+    } catch (err) {
+      // Skip files that can't be read
+    }
+  }
+  
+  return {
+    matches: allMatches,
+    filesSearched,
+    filesWithMatches,
+    totalMatches: allMatches.length
+  }
+}
+
+// Complex regex search in JavaScript
+function jsComplexRegexSearch(pattern: string, filePath: string) {
+  const content = fs.readFileSync(filePath, 'utf-8')
+  const regex = new RegExp(pattern, 'gm')
+  const lines = content.split('\n')
+  const matches = []
+  
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    let match
+    regex.lastIndex = 0
+    while ((match = regex.exec(line)) !== null) {
+      matches.push({
+        lineNumber: i + 1,
+        line: line,
+        start: match.index,
+        end: match.index + match[0].length
+      })
+    }
+  }
+  
+  return matches
+}
+
+// Setup: Create large test files to showcase performance differences
+const baseContent = fs.readFileSync('./src/lib.rs', 'utf-8')
+const largeContent = createLargeContent(baseContent, 50) // 50x larger
+const veryLargeContent = createLargeContent(baseContent, 200) // 200x larger
+
+// Write test files
+if (!fs.existsSync('./benchmark/temp')) {
+  fs.mkdirSync('./benchmark/temp')
+}
+
+fs.writeFileSync('./benchmark/temp/large.rs', largeContent)
+fs.writeFileSync('./benchmark/temp/very_large.rs', veryLargeContent)
+
+// Create multiple test files for multi-file search
+for (let i = 0; i < 20; i++) {
+  fs.writeFileSync(`./benchmark/temp/test_${i}.rs`, baseContent)
+}
+
+const testFiles = Array.from({ length: 20 }, (_, i) => `./benchmark/temp/test_${i}.rs`)
+
 const bench = new Bench()
 
-bench.add('Native a + 100', () => {
-  plus100(10)
+// 1. Large file search - where Rust's memory efficiency shines
+bench.add('🦀 ripgrep-napi: search in large file (50x)', () => {
+  searchFile('pub fn', './benchmark/temp/large.rs')
+})
+
+bench.add('🐌 JavaScript: search in large file (50x)', () => {
+  jsSearchWithFileRead('pub fn', './benchmark/temp/large.rs')
+})
+
+// 2. Very large file search - pushing the limits
+bench.add('🦀 ripgrep-napi: search in very large file (200x)', () => {
+  searchFile('struct', './benchmark/temp/very_large.rs')
+})
+
+bench.add('🐌 JavaScript: search in very large file (200x)', () => {
+  jsSearchWithFileRead('struct', './benchmark/temp/very_large.rs')
 })
 
-bench.add('JavaScript a + 100', () => {
-  add(10)
+// 3. Multi-file search - ripgrep's bread and butter
+bench.add('🦀 ripgrep-napi: search across 20 files', () => {
+  search('fn', testFiles)
+})
+
+bench.add('🐌 JavaScript: search across 20 files', () => {
+  jsMultiFileSearch('fn', testFiles)
+})
+
+// 4. Complex regex patterns - where ripgrep's regex engine excels
+const complexPattern = '(?:pub\\s+)?(?:async\\s+)?fn\\s+\\w+\\s*\\([^)]*\\)\\s*(?:->\\s*[^{]+)?\\s*\\{'
+
+bench.add('🦀 ripgrep-napi: complex regex pattern', () => {
+  searchFile(complexPattern, './src/lib.rs')
+})
+
+bench.add('🐌 JavaScript: complex regex pattern', () => {
+  jsComplexRegexSearch(complexPattern, './src/lib.rs')
+})
+
+// 5. Case-insensitive search with options
+bench.add('🦀 ripgrep-napi: case-insensitive + word boundaries', () => {
+  searchFile('FUNCTION', './benchmark/temp/large.rs', { 
+    caseSensitive: false, 
+    wordRegexp: true 
+  })
+})
+
+// 6. Search with file traversal (directory search)
+bench.add('🦀 ripgrep-napi: directory traversal search', () => {
+  search('use', ['./src', './__test__'], { 
+    maxDepth: 3,
+    hidden: false 
+  })
+})
+
+// 7. Pattern validation (Rust's regex compilation)
+const patterns = [
+  '\\d{3}-\\d{2}-\\d{4}',
+  '(?i)hello\\s+world',
+  '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}',
+  '\\b(?:pub|private|protected)\\s+(?:static\\s+)?\\w+\\s*\\(',
+  '^\\s*(?:#\\[\\w+(?:\\([^)]*\\))?\\]\\s*)*(?:pub\\s+)?(?:async\\s+)?fn\\s+\\w+'
+]
+
+bench.add('🦀 ripgrep-napi: validate complex patterns', () => {
+  patterns.forEach(pattern => validatePattern(pattern))
+})
+
+// 8. Large directory with ignore patterns
+bench.add('🦀 ripgrep-napi: search with ignore patterns', () => {
+  search('fn', ['./'], {
+    maxDepth: 2,
+    ignorePatterns: ['target', 'node_modules', '*.lock', '*.log']
+  })
 })
 
 await bench.run()
 
+console.log('\n🏆 Performance Results:')
 console.table(bench.table())
+
+// Cleanup
+try {
+  fs.rmSync('./benchmark/temp', { recursive: true, force: true })
+} catch (err) {
+  console.log('Note: Cleanup failed, you may need to manually remove ./benchmark/temp')
+}

benchmark/create-samples.js

@@ -0,0 +1,25 @@
+import fs from 'fs';
+
+// Create sample files for benchmarking
+const sampleData = `
+function hello() {
+  console.log("Hello, world!");
+}
+
+function goodbye() {
+  console.log("Goodbye, world!");
+}
+
+const message = "This is a test file for benchmarking ripgrep-napi";
+const numbers = [1, 2, 3, 4, 5];
+
+// Some patterns to search for
+const patterns = ["function", "console", "test", "hello", "world"];
+`;
+
+// Create benchmark sample files
+fs.writeFileSync('./benchmark/sample1.js', sampleData);
+fs.writeFileSync('./benchmark/sample2.js', sampleData.repeat(10));
+fs.writeFileSync('./benchmark/sample3.js', sampleData.repeat(100));
+
+console.log('Sample files created for benchmarking');