PWV Portfolio Feed

Run research at scale. Got 30 compounds to check or 20 hypotheses to test? Write a short script and get structured results for all of them instead of running each one manually.

this is possibly the coolest place I have ever visited

If you're building Node.js tools that search files, stop spawning subprocesses. Call a function.

While it has feature parity with ripgrep, i'm still building out a couple of optimizations that will make it even faster on large codebases.

ignoreCase: true,
}));
// 17μs. No subprocess. 
// No IPC. 
// No stdout parsing.
```

Zod validates at the boundary. 
Types inferred from schemas. 
`readonly SearchResult[]` out, no mutation.

$ npm i grepts
$ pnpm i grepts

`grepts-async` beats ripgrep 1.34x on common patterns, 3.33x on large files. Worker pool saturates I/O without subprocess setup per query.

```
import { search, searchOptionsSchema } from 'grepts';

const results = search(searchOptionsSchema.parse({
pattern: 'TODO',
paths: ['./src'],

Per-invocation cost:
grepts (in-process)  17μs 🤘
ripgrep (subprocess)  7.6ms
grep (subprocess)  5.9ms

435x less overhead vs ripgrep. 1000 searches: 
16ms vs 7.6s.

`.gitignore` handling is hierarchical: each dir inherits parent's ignore instance, reuses it if no local `.gitignore` exists.

Async mode: worker pool (`Math.min(cpus().length, 10)`), files chunked across workers. 

Fallback: 64-way concurrent `readFile` with manual backpressure.

2) Regex path: `searchForwardScan()` walks by `\n`, runs `regex.exec()` per line. One pass, no line array allocation.

Walker uses `readdirSync` with `withFileTypes: true` (Dirent objects, no extra `stat` calls). 

Binary detection is Set lookup by extension, O(1).

Two search paths, picked at runtime:

1) Literal fast path: pattern has no regex metacharacters? Drops to `indexOf` scanning. No RegExp allocated. Line numbers tracked incrementally in one forward pass.

$ pnpm i grepts

Pipeline:
node ──fork──► sh ──exec──► rg
pipe stdout back
parse string output
~7.6ms per call

grepts from Node.js:

node ──► search()
same process
same V8 heap
~17μs per call

1 search:    who cares
100 searches: 760ms vs 1.7ms
1000 searches: 7.6s vs 17ms

Introducing `grepts` 🔍 
A fast TypeScript grep - ripgrep reimagined for Node.js.

I kept spawning ripgrep from Node.js and watching 5ms vanish per call. Fork, exec, pipe, parse stdout. So I built a grep that runs as a function call. 17μs.

Built with Command Code.

$ npm i grepts

#ZedEditor

🚀 We just shipped v0.226!

Configure the project panel to show error and warning counts next to its entries.
`"project_panel": { "diagnostic_badges": true }` 

Thanks Obli04!

Didn't see this coming. Apple is winning the hardware race. 
$599 Macbook Neo is perfect for starters
M5 Pro Max with 128GB is perfect for pros

There are quite a few hacks going on but overall I am happy with the approach!

Will be using it for a lot more cool shit