rust-anything 0.0.0-stage → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/LICENSE ADDED
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 the rust-anything authors
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
package/README.md CHANGED
@@ -1,3 +1,357 @@
1
- # Temporary Holding Version
1
+ <p align="center">
2
+ <img src="docs/assets/hero.png" alt="rust-anything: Your app isn't slow. One loop is. rust-anything finds it, moves it to Rust, and proves nothing else changed." width="820">
3
+ </p>
2
4
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
5
+ **Make the slow part of your app fast in Rust, without rewriting the app.** For TypeScript/JavaScript,
6
+ Python, C, Go, Ruby and Java codebases, one hot path at a time, proven identical by recorded
7
+ behavior.
8
+
9
+ | Real workload, same results as the original | Original | With rust-anything |
10
+ | --- | ---: | ---: |
11
+ | x18n's sidebar search, 50,000 keys (TypeScript, Node) | 10 ms per query | **0.5 ms: 20x faster** |
12
+ | The same search in the browser (wasm, one thread) | 10 ms | **0.95 ms: 11.5x** |
13
+ | `slugify` over 20,000 strings (Python) | 98 ms | **17x faster** |
14
+ | `Shellwords.shellescape` from Ruby's standard library, 50,000 values | 88 ms | **11.8x faster** |
15
+ | `Slugify` over 50,000 strings (Go) | 49 ms | **4x faster** |
16
+ | `slugify` over 50,000 strings (Java) | 43 ms | **3x faster** |
17
+
18
+ <p align="center">
19
+ <img src="docs/assets/race.gif" alt="Typing user.profile into x18n's search over 50,000 keys: TypeScript spends 143 ms, the rust-anything batch 6.9 ms, with the same results at every keystroke." width="820">
20
+ </p>
21
+
22
+ Measured on 4 cores; every number has a benchmark in [`demo/`](./demo) that first checks the
23
+ results are identical. Calling Rust once per small function is usually *slower* than a JIT;
24
+ rust-anything finds the loop worth moving, and moves it.
25
+
26
+ > rust-anything is an independent project, not affiliated with or endorsed by the Rust Project
27
+ > or the Rust Foundation. "Rust" is a trademark of the Rust Foundation.
28
+
29
+ ## Quick start
30
+
31
+ Paste this into Claude Code, Codex, Cursor or Gemini CLI and let your agent install it:
32
+
33
+ ```text
34
+ Install rust-anything: run `cargo install --git https://github.com/erkamyaman/rust-anything`,
35
+ then `rust-anything setup`. Tell me when to restart you.
36
+ ```
37
+
38
+ Or yourself:
39
+
40
+ ```sh
41
+ npm install -g rust-anything # prebuilt binary for macOS, Linux and Windows
42
+ # or: cargo install --git https://github.com/erkamyaman/rust-anything
43
+ rust-anything setup # registers it with Claude Code, Codex, Cursor and Gemini CLI
44
+ ```
45
+
46
+ Prebuilt binaries are also attached to each [GitHub release](https://github.com/erkamyaman/rust-anything/releases).
47
+
48
+ In Claude Code you can also install it as a plugin (the MCP server and the skill; the CLI above
49
+ must be on your `PATH`):
50
+
51
+ ```text
52
+ /plugin install rust-anything --marketplace erkamyaman/rust-anything
53
+ ```
54
+
55
+ `setup` adds the MCP server to each agent it finds and installs the workflow skill where the agent
56
+ reads skills. It keeps your other settings, is safe to run again, and `--remove` undoes it.
57
+ Then ask your agent, for example:
58
+
59
+ - *"This search feels slow. Profile it with rust-anything and move the hot loop to Rust."*
60
+ - *"Plan a migration of `src/parser/` to Rust with rust-anything; port the first unit and prove it."*
61
+ - *"Bench the Rust port in `rust/text-rs` against the original and tell me whether to ship it."*
62
+
63
+ ### Works with
64
+
65
+ | Agent | `rust-anything setup` adds |
66
+ | --- | --- |
67
+ | Claude Code | MCP server in `~/.claude.json`, skill in `~/.claude/skills/` |
68
+ | Codex | MCP server in `~/.codex/config.toml`, skill in `~/.codex/skills/` |
69
+ | Cursor | MCP server in `~/.cursor/mcp.json` |
70
+ | Gemini CLI | MCP server in `~/.gemini/settings.json` |
71
+ | Any other MCP client | add `rust-anything mcp` as a stdio server by hand (see [Install](#install)) |
72
+
73
+ Before changing a file that exists, `setup` saves a copy beside it (`<file>.rust-anything.bak`).
74
+
75
+ Or run the steps yourself:
76
+
77
+ <p align="center">
78
+ <img src="docs/assets/terminal.gif" alt="rust-anything profile finds fuzzyScore in a loop, bridge --batch generates the Rust crate, gate passes with 2000/2000 recorded cases, and the benchmark shows 20.7x faster than TS." width="820">
79
+ </p>
80
+
81
+
82
+ ```sh
83
+ rust-anything profile . -- node bench.mjs # what is hot, and who calls it
84
+ rust-anything bridge . src/fuzzy.ts --batch fuzzyScore:text
85
+ # write src/port.rs (or let your agent), then:
86
+ rust-anything record rust/fuzzy-rs && rust-anything build rust/fuzzy-rs
87
+ rust-anything diff rust/fuzzy-rs # every recorded case must match
88
+ rust-anything bench rust/fuzzy-rs # faster? the verdict says
89
+ rust-anything gate rust/fuzzy-rs # done means this passes
90
+ ```
91
+
92
+ rust-anything does not translate code: your coding agent (Claude Code, Codex, Cursor, ...) or you write
93
+ the Rust. rust-anything supplies what an agent cannot guess reliably: where the time goes, what to port
94
+ first and in which order, a bridge so the rest of the code calls the Rust with its API unchanged,
95
+ the exact behavior the port must match, a safe way to ship it, and a gate that says when a port is
96
+ done.
97
+
98
+ ## Languages
99
+
100
+ | Language | Unit | Bridge | Recorded and replayed by |
101
+ | --- | --- | --- | --- |
102
+ | TypeScript/JavaScript | folder or file | napi-rs or wasm-bindgen with a generated binary wire; classes and async included | Node, running the `.ts` sources |
103
+ | Python | package or module | PyO3 (abi3), direct conversion, typed exceptions | Python, importing the original |
104
+ | C | `.c` file | `extern "C"` functions with the original names and a header | the original compiled to a shared library, called through ctypes, one fork per case |
105
+ | Go | package | typed cgo calls and a generated binary wire, in a package with the original API | a generated Go driver, built as its own module |
106
+ | Ruby | file or folder of module functions | a magnus extension under the original modules | a generated Ruby driver |
107
+ | Java | package of `public static` methods | typed JNI and a generated binary wire, in wrapper classes with the original methods | a generated reflection driver |
108
+
109
+ Every language except C also gets batch classes (`--batch`): the items cross once and stay in
110
+ Rust, and each call runs over all of them on all cores.
111
+
112
+ The language is detected from the repository (`go.mod`, `pom.xml`, `pyproject.toml`, `Gemfile`,
113
+ `package.json`, else the most common source files); `--lang` overrides it. Types come from the
114
+ source: TS types, Python hints, C and Go and Java signatures, Ruby YARD tags; untyped parameters
115
+ used as numbers are inferred as numbers.
116
+
117
+ ## How it works
118
+
119
+ ```
120
+ profile ──> analyze ──> bridge ──> record ──> port.rs ──> diff ──> bench ──> shadow ──> gate
121
+ where the what to the Rust what the you or every faster? both side done means
122
+ time goes port first crate and original your agent recorded the by side in this passes
123
+ wrapper does write it case verdict production
124
+ ```
125
+
126
+ The original stays the source of truth: `record` runs it on edge cases (and your own inputs) and
127
+ saves what it returns or throws; `diff` replays every case against the Rust; nothing ships until
128
+ they all match and `gate` passes. Callers keep the original API throughout.
129
+
130
+ ## The loop
131
+
132
+ | Step | Command | What it does |
133
+ | --- | --- | --- |
134
+ | 0. Profile | `rust-anything profile <repo> -- node bench.mjs` | Runs a real workload under the language's profiler (node, cProfile, `go test` pprof, JFR, a Ruby tracer): hot functions by inclusive time, their callers, and which loops to batch |
135
+ | 1. Plan | `rust-anything analyze <repo>` | Units, port order, risks with `file:line`, bridge per unit, dependency-to-crate fit, best first ports |
136
+ | 2. Bridge | `rust-anything bridge <repo> <unit>` | Crate with the bindings (`lib.rs`, plus the wrapper the source language loads) and stubs to port (`port.rs`); `--batch fn:param` adds a class that keeps many `param` values in Rust |
137
+ | 3. Record | `rust-anything record <crate>` | Runs the original on generated edge cases (non-ASCII, emoji, `-0`, `NaN`, ints where floats are expected, ...) and saves `cases.jsonl` |
138
+ | 3. Build | `rust-anything build <crate>` | Builds the Rust side: `.node`, wasm package, Python extension or shared library |
139
+ | 3. Diff | `rust-anything diff <crate>` | Replays the recorded cases against Rust, called the way the original's callers call it; lists mismatches |
140
+ | 3. Bench | `rust-anything bench <crate>` | Times the recorded cases on the original and on Rust, bridge included |
141
+ | 4. Shadow | `rust-anything shadow <crate>` | Drop-in that runs both, returns the original's result, reports mismatches; `RUST_ANYTHING_MODE=old\|shadow\|new` |
142
+ | 5. Gate | `rust-anything gate <crate>` | fmt, clippy `-D warnings`, tests, `unsafe` audit, nothing unported, build, API, behavior |
143
+ | Agents | `rust-anything setup` | Registers the MCP server (`rust-anything mcp`, every step as a tool) and the workflow skill ([`skills/rust-anything/SKILL.md`](./skills/rust-anything/SKILL.md)) with your coding agents |
144
+
145
+ ## Case study: x18n's core
146
+
147
+ All 29 functions of x18n's core that can move without an API change were ported with rust-anything:
148
+ every gate passes and 7,925 recorded cases match exactly. `rust-anything bench` then showed the ports
149
+ are slower than the TS as called from JS, because the bridge costs more than the work. Full report:
150
+ [`demo/x18n-core`](./demo/x18n-core/README.md). The lesson is built in: measure with `bench` before
151
+ shipping a port.
152
+
153
+ ## Hot paths: keep the data in Rust
154
+
155
+ A port called once per item pays the bridge once per item, and loses to a JIT. What wins is
156
+ moving the loop: `profile` finds it, and `--batch` generates a class that takes the items once
157
+ and runs the function over all of them per call, on all cores, with typed-array results.
158
+
159
+ ```sh
160
+ rust-anything profile ../x18n -- node --experimental-strip-types $PWD/demo/x18n-search/search.ts .
161
+ # -> fuzzyScore: a quarter of the run, called per key by `matched`: batch it
162
+ rust-anything bridge ../x18n packages/core/src/fuzzy.ts --batch fuzzyScore:text
163
+ ```
164
+
165
+ ```js
166
+ const search = new FuzzyScoreBatch(keys) // once
167
+ const order = search.rank(query, 0) // per keystroke: indexes, best first
168
+ ```
169
+
170
+ A `FuzzyScoreIndex` struct in `port.rs` replaces the default loop with one that prepares the
171
+ items once, and can rank by itself (`rank`): it keeps the keys lowercased with a character mask
172
+ each, a table of each key's first position of every common character (a one-letter query is one
173
+ column), and the last query's matches (typing `se` after `s` rescores only what `s` matched). On
174
+ x18n's sidebar search over 50,000 keys, typed letter by letter, with identical results:
175
+
176
+ | | Per query | vs TS |
177
+ | --- | ---: | ---: |
178
+ | TS: `map(fuzzyScore)`, filter, sort | 10 ms | 1x |
179
+ | TS with the same narrowing as the index | 4.1-5.4 ms | 2x |
180
+ | The same port, called per key | - | 0.2-0.4x |
181
+ | `FuzzyScoreBatch`, default index (4 cores) | 5.1 ms | 1.7x |
182
+ | `FuzzyScoreBatch` with `FuzzyScoreIndex` (napi, 4 cores) | 0.45-0.56 ms | **18-22x** |
183
+ | The same with wasm (one thread) | 0.95 ms | **11.5x** |
184
+
185
+ Against TS doing the same narrowing, Rust is still 7-12x faster (wasm 5x). Turn the returned
186
+ indexes into keys with a plain loop: `Array.from(order, i => keys[i])` cost 20x more, 0.4 ms.
187
+
188
+ Every language gets batches, and they beat the original even where per-call ports lose. The
189
+ same work on 4 cores, identical results and errors (benchmarks in each demo folder):
190
+
191
+ | Language | Workload | Original | Per-call port vs original | Batch vs original |
192
+ | --- | --- | ---: | ---: | ---: |
193
+ | TS | x18n search, 50,000 keys | 10 ms | 0.2-0.4x | **20x** |
194
+ | Python | `slugify`, 20,000 strings | 98 ms | - | **17x** |
195
+ | Ruby | `slugify`, 20,000 strings | 110 ms | - | **12.7x** |
196
+ | Ruby | `shellescape` (stdlib), 50,000 mixed values | 88 ms | - | **11.8x** |
197
+ | Go | `Slugify`, 50,000 strings | 49 ms | 0.93x | **4x** |
198
+ | Java | `slugify`, 50,000 strings | 43 ms | 0.68x | **3x** |
199
+
200
+ Compiled originals gain less: the per-item work is already fast, so the batch wins by the number of
201
+ cores. Batch crates allocate with mimalloc: with the system allocator the Go batch was slower than
202
+ one thread. Demo: [`demo/x18n-search`](./demo/x18n-search/README.md).
203
+
204
+ ## Real code in six languages
205
+
206
+ Go's `path`, Ruby's `shellwords`, Python's `colorsys`, JDK and glibc behavior behind small
207
+ facades: every port passes its gate, 13,010 recorded cases in all. The runs found and fixed
208
+ bugs in rust-anything (floats off by one ULP through `serde_json`, C crashes during recording,
209
+ untyped code getting garbage inputs). Called per function, the Ruby port runs 4.4x faster than
210
+ Ruby and the Python port 1.35x faster than CPython, while Go and Java leaf functions stay faster
211
+ in their own language; as batches, all of them win (see the table above).
212
+ Report: [`docs/real-world-languages.md`](./docs/real-world-languages.md).
213
+
214
+ ## Example: a real module from x18n
215
+
216
+ `packages/core/src/fuzzy.ts` from [x18n](https://github.com/x18n-dev/x18n), ported both ways in
217
+ [`demo/`](./demo):
218
+
219
+ ```sh
220
+ rust-anything analyze ../x18n # fuzzy.ts: ready, wasm-bindgen (core runs in browsers)
221
+ rust-anything bridge ../x18n packages/core/src/fuzzy.ts --out demo/fuzzy-rs
222
+ rust-anything record demo/fuzzy-rs --count 2000
223
+ # write src/port.rs
224
+ rust-anything gate demo/fuzzy-rs
225
+ ```
226
+
227
+ A first port that indexed by Rust `char` passed simple tests but failed `diff`:
228
+
229
+ ```
230
+ 198/200 cases match
231
+ - fuzzyScore("b😀", "a😀b😀c"): expected {"ok":1997}, got {"ok":1998}
232
+ ```
233
+
234
+ JS `indexOf` counts UTF-16 code units, so an emoji is two positions. The port in
235
+ `demo/*/src/port.rs` uses the generated `utf16` helpers and passes 2000/2000 cases and the gate,
236
+ as napi-rs (`demo/fuzzy-napi`) and as wasm-bindgen (`demo/fuzzy-rs`).
237
+
238
+ The plan rust-anything writes for all of x18n: [`docs/examples/x18n.md`](./docs/examples/x18n.md).
239
+
240
+ ## Install
241
+
242
+ ```sh
243
+ cargo install --path .
244
+ ```
245
+
246
+ `record`, `diff` and `bench` run the original in its own runtime: Node 22.6+ for TS (it runs `.ts`
247
+ sources directly), Python 3.9+ for Python and C (ctypes), Go 1.21+, Ruby 3+, JDK 17+
248
+ (`javac` and `java`). C also needs a C compiler. wasm bridges also need `rustup target add wasm32-unknown-unknown` and
249
+ `cargo install wasm-bindgen-cli --version <the crate's wasm-bindgen version> --locked`; `build` names
250
+ the exact version.
251
+
252
+ For agents, `rust-anything setup` registers everything (see Quick start). To add the MCP server to
253
+ one project by hand instead (`.mcp.json`):
254
+
255
+ ```json
256
+ { "mcpServers": { "rust-anything": { "command": "rust-anything", "args": ["mcp"] } } }
257
+ ```
258
+
259
+ ## What `bridge` decides
260
+
261
+ - Exports that cannot cross a bridge stay in the source language, with the reason, and the shadow
262
+ module re-exports the original. For TS:
263
+ functions that take or return functions, generators and iterators, RegExp, `instanceof` checks,
264
+ generics, and values whose types (followed through imports, re-exports and `extends`) hold
265
+ functions. `--keep "name: reason"` keeps more, e.g. code that depends on `Intl` data.
266
+ - TS types map to Rust types, with type aliases resolved through imports and parameter types
267
+ inferred from default values; structured values cross as a generated binary wire (JSON only
268
+ as a fallback for shapes the wire does not model).
269
+ - JSON cannot express `undefined`, NaN, Infinity, -0 or lone surrogates: structured values carry
270
+ markers (`{"$undefined": true}`, `{"$num": "NaN"}`, `{"$utf16": [...]}`) that the generated
271
+ `index.cjs` translates, with helpers in the crate's `js.rs`.
272
+
273
+ `record` runs TS sources as they are: a Node resolve hook follows bundler-style imports
274
+ (`./errors` to `./errors.ts`), `--resolve-from` supplies npm packages when the repo has none
275
+ installed, and TS that needs transforming (enums, parameter properties) is retried with
276
+ `--experimental-transform-types`.
277
+
278
+ ## What `analyze` looks at
279
+
280
+ - Packages (`package.json`) and source files; skips `node_modules`, build output, fixtures,
281
+ playgrounds, tool configs. Vue/Svelte/Astro `<script>` blocks are parsed for imports.
282
+ - **Units**: a folder of source files, or a file at a package's source root.
283
+ - **Waves**: a unit's imports come in earlier waves; import cycles are ported together.
284
+ - **Bridge**: napi-rs when the unit or anything it imports needs Node; wasm-bindgen for portable
285
+ code; keep in JS for UI and editor code.
286
+ - **Readiness** (how safe) and **priority** (safe and worth it: loops and string work, tests, size).
287
+
288
+ | Risk | Severity | Example |
289
+ | --- | --- | --- |
290
+ | String offsets | high | `slice`, `indexOf`, `matchAll`, the `d` flag: UTF-16 vs UTF-8 |
291
+ | Regex syntax | high | lookaround, backreferences, `y`: not in the `regex` crate |
292
+ | Dynamic regex | high | `new RegExp(userPattern)`: JS syntax at runtime |
293
+ | Dynamic code | high | `eval`, `new Function`, computed `import()` |
294
+ | Dynamic typing | medium | `any`, `'key' in value` |
295
+ | Ordered collections | medium | `Map`, `Set`, `Object.keys`: insertion order |
296
+ | Async, generators | medium | promise and generator boundaries |
297
+ | Class inheritance, reflection | medium | `extends`, `Proxy`, `Reflect`, `Symbol` |
298
+ | Callback-shaped APIs | medium | function-typed params and methods: chatty bridges |
299
+ | Exceptions, numbers, JSON | low | `throw`, bitwise ops, `JSON.stringify` order |
300
+
301
+ ## Development
302
+
303
+ ```sh
304
+ cargo test # unit tests, fixture repo, record/diff/shadow loop (needs node)
305
+ cargo clippy --all-targets -- -D warnings
306
+ cargo fmt
307
+ ```
308
+
309
+ Design choices and their reasons: [DECISIONS.md](./DECISIONS.md).
310
+
311
+
312
+ ## Update or remove
313
+
314
+ ```sh
315
+ npm install -g rust-anything@latest # update (npm)
316
+ cargo install --git https://github.com/erkamyaman/rust-anything --force # update (Cargo)
317
+ rust-anything setup # refresh agent settings
318
+ rust-anything setup --remove && npm uninstall -g rust-anything # remove (npm)
319
+ rust-anything setup --remove && cargo uninstall rust-anything # remove (Cargo)
320
+ ```
321
+
322
+ `setup --remove` takes out only rust-anything's entries; the copies it saved
323
+ (`<file>.rust-anything.bak`) stay until you delete them.
324
+
325
+ ## FAQ
326
+
327
+ **Does it rewrite my code automatically?** No. It finds what to move, generates the bridge,
328
+ records what the original does and checks the Rust against it. You or your agent write the Rust
329
+ in `port.rs`; `diff` and `gate` decide when it is right.
330
+
331
+ **Will my app's API change?** No. Callers import the same functions (or the shadow module, which
332
+ runs both and returns the original's result while you build confidence).
333
+
334
+ **Is Rust always faster?** No, and rust-anything says so. A small function called once per item
335
+ is often slower in Rust, because each call crosses a bridge; V8, the JVM and Go run such functions
336
+ in nanoseconds. `profile` finds the loop around it, `--batch` moves the whole loop, and `bench`
337
+ gives a verdict before you ship.
338
+
339
+ **Does my code leave my machine?** No: rust-anything runs locally and sends none of your code
340
+ anywhere. Cargo downloads crates as usual, and your agent's model provider sees what your agent
341
+ sends it, under its own policy.
342
+
343
+ **What does it need installed?** Rust, plus the runtime of the language you port (see
344
+ [Install](#install)).
345
+
346
+ **Something broke.** Open an issue with the command, its output and your platform.
347
+
348
+ ## Contributing
349
+
350
+ Issues and pull requests are welcome. Before a pull request: `cargo fmt`, `cargo clippy
351
+ --all-targets -- -D warnings` and `cargo test` must pass (see [Development](#development)); design
352
+ choices and their reasons are in [DECISIONS.md](./DECISIONS.md). Case studies of real ports are
353
+ especially welcome.
354
+
355
+ ## License
356
+
357
+ [MIT](./LICENSE). Ports and generated code in your repository are yours.
@@ -0,0 +1,26 @@
1
+ #!/usr/bin/env node
2
+ 'use strict'
3
+ const fs = require('node:fs')
4
+ const path = require('node:path')
5
+ const { spawnSync } = require('node:child_process')
6
+
7
+ const key = `${process.platform}-${process.arch}`
8
+ const exe = process.platform === 'win32' ? 'rust-anything.exe' : 'rust-anything'
9
+ const bin = path.join(__dirname, '..', 'binaries', key, exe)
10
+ if (!fs.existsSync(bin)) {
11
+ console.error(
12
+ `rust-anything: no prebuilt binary for ${key}.\n` +
13
+ 'Install it with Cargo instead: cargo install --git https://github.com/erkamyaman/rust-anything',
14
+ )
15
+ process.exit(1)
16
+ }
17
+
18
+ const result = spawnSync(bin, process.argv.slice(2), { stdio: 'inherit' })
19
+ if (result.error) {
20
+ console.error(`rust-anything: ${result.error.message}`)
21
+ process.exit(1)
22
+ }
23
+ if (result.signal) {
24
+ process.kill(process.pid, result.signal)
25
+ }
26
+ process.exit(result.status ?? 1)
Binary file
package/package.json CHANGED
@@ -1,6 +1,32 @@
1
1
  {
2
2
  "name": "rust-anything",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
3
+ "version": "1.0.1",
4
+ "description": "Make the slow part of your app fast in Rust, without rewriting the app. TypeScript, Python, C, Go, Ruby, Java.",
5
+ "keywords": [
6
+ "rust",
7
+ "performance",
8
+ "migration",
9
+ "ffi",
10
+ "napi",
11
+ "pyo3",
12
+ "mcp",
13
+ "claude-code",
14
+ "codex"
15
+ ],
16
+ "license": "MIT",
17
+ "repository": {
18
+ "type": "git",
19
+ "url": "git+https://github.com/erkamyaman/rust-anything.git"
20
+ },
21
+ "homepage": "https://github.com/erkamyaman/rust-anything",
22
+ "bin": {
23
+ "rust-anything": "bin/rust-anything.js"
24
+ },
25
+ "files": [
26
+ "bin",
27
+ "binaries"
28
+ ],
29
+ "engines": {
30
+ "node": ">=18"
31
+ }
32
+ }