PWV Portfolio Feed

Build on top of Elicit. Now you can build research dashboards or combine Elicit evidence with your own datasets.

Integrate Elicit into your workflow. Call the API from Claude or ChatGPT to get real citations while writing a paper, or build a Slack bot that pulls evidence into team discussions. We built one internally to settle debates with data instead of anecdotes.

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