code-gauge 4.6.0 → 4.7.1

package/native/src/wasm.rs

@@ -0,0 +1,128 @@
+//! The WebAssembly binding for runtimes without N-API, such as Cloudflare Workers
+//! (src/wasmBinding.ts). Strings cross linear memory as UTF-8: the host copies each input into a
+//! buffer from `alloc`, whose ownership passes to the called function, and reads the JSON result
+//! (status 0) or error message (status 1) through `result_ptr`/`result_len` before the next call.
+
+use std::cell::RefCell;
+
+thread_local! {
+    static RESULT: RefCell<String> = const { RefCell::new(String::new()) };
+}
+
+#[no_mangle]
+pub extern "C" fn payload_version() -> u32 {
+    crate::payload_version()
+}
+
+/// Allocates with an exact layout: `Vec::with_capacity` may over-allocate, so rebuilding a `Vec`
+/// from the pointer and `len` would not be sound.
+#[no_mangle]
+pub extern "C" fn alloc(len: usize) -> *mut u8 {
+    if len == 0 {
+        return std::ptr::NonNull::dangling().as_ptr();
+    }
+    let pointer = unsafe { std::alloc::alloc(byte_layout(len)) };
+    if pointer.is_null() {
+        std::alloc::handle_alloc_error(byte_layout(len));
+    }
+    pointer
+}
+
+#[no_mangle]
+pub extern "C" fn result_ptr() -> *const u8 {
+    RESULT.with_borrow(|result| result.as_ptr())
+}
+
+#[no_mangle]
+pub extern "C" fn result_len() -> usize {
+    RESULT.with_borrow(|result| result.len())
+}
+
+/// Optional settings arrive as f64 (exact for every u32) with a negative value for "absent", so
+/// the host needs no BigInt or presence flags.
+#[no_mangle]
+#[allow(clippy::too_many_arguments)]
+pub unsafe extern "C" fn measure_code(
+    code_ptr: *mut u8,
+    code_len: usize,
+    language_ptr: *mut u8,
+    language_len: usize,
+    include_syntax_tree: u32,
+    min_tokens: f64,
+    max_gap_tokens: f64,
+    min_similarity_percent: f64,
+    include_cross_file_data: u32,
+) -> u32 {
+    // Both buffers are taken before `?` so that neither leaks when the other is invalid.
+    let code = take_string(code_ptr, code_len);
+    let language = take_string(language_ptr, language_len);
+    store_result((|| {
+        crate::measure_code(
+            &code?,
+            &language?,
+            include_syntax_tree != 0,
+            to_option(min_tokens),
+            to_option(max_gap_tokens),
+            to_option(min_similarity_percent),
+            include_cross_file_data != 0,
+        )
+    })())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn collect_cross_file_data(
+    code_ptr: *mut u8,
+    code_len: usize,
+    language_ptr: *mut u8,
+    language_len: usize,
+    min_tokens: f64,
+) -> u32 {
+    let code = take_string(code_ptr, code_len);
+    let language = take_string(language_ptr, language_len);
+    store_result((|| {
+        crate::collect_cross_file_data(&code?, &language?, to_option(min_tokens))
+    })())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn collect_function_token_sequences(
+    code_ptr: *mut u8,
+    code_len: usize,
+    language_ptr: *mut u8,
+    language_len: usize,
+) -> u32 {
+    let code = take_string(code_ptr, code_len);
+    let language = take_string(language_ptr, language_len);
+    store_result((|| {
+        crate::collect_function_token_sequences(&code?, &language?)
+    })())
+}
+
+/// Takes ownership of a buffer returned by `alloc(len)` and filled by the host.
+unsafe fn take_string(ptr: *mut u8, len: usize) -> Result<String, String> {
+    if len == 0 {
+        return Ok(String::new());
+    }
+    let text = std::str::from_utf8(std::slice::from_raw_parts(ptr, len))
+        .map(str::to_owned)
+        .map_err(|error| error.to_string());
+    std::alloc::dealloc(ptr, byte_layout(len));
+    text
+}
+
+fn byte_layout(len: usize) -> std::alloc::Layout {
+    std::alloc::Layout::array::<u8>(len).expect("buffer size overflows isize")
+}
+
+fn to_option(value: f64) -> Option<u32> {
+    (value >= 0.0).then_some(value as u32)
+}
+
+fn store_result(result: Result<String, String>) -> u32 {
+    let (status, text) = match result {
+        Ok(json) => (0, json),
+        Err(message) => (1, message),
+    };
+    RESULT.set(text);
+    status
+}

package/native/src/worker_pool.rs

@@ -0,0 +1,53 @@
+use std::num::NonZeroUsize;
+use std::sync::{mpsc, Arc, Mutex, OnceLock};
+use std::thread;
+
+type Job = Box<dyn FnOnce() + Send>;
+
+/// The metric passes recurse per tree level (TreeIndex refuses trees deeper than 5,000), so workers
+/// get the stack size of a typical main thread instead of Rust's 2 MiB default.
+const STACK_SIZE: usize = 8 * 1024 * 1024;
+
+/// Runs the job on a process-wide pool with one thread per available core. A dedicated pool rather
+/// than libuv's (4 threads by default) lets measurements use every core without the embedding
+/// process having to raise UV_THREADPOOL_SIZE before its first I/O. The pool keeps however many
+/// workers the OS allows (a thread or PID limit may refuse some); with none, the job runs on the
+/// calling thread instead.
+pub fn spawn(job: impl FnOnce() + Send + 'static) {
+    static SENDER: OnceLock<Option<mpsc::Sender<Job>>> = OnceLock::new();
+    let sender = SENDER.get_or_init(|| {
+        let (sender, receiver) = mpsc::channel::<Job>();
+        let receiver = Arc::new(Mutex::new(receiver));
+        let mut started = 0;
+        for _ in 0..thread::available_parallelism().map_or(1, NonZeroUsize::get) {
+            let receiver = Arc::clone(&receiver);
+            let spawned = thread::Builder::new()
+                .name("code-gauge-worker".to_string())
+                .stack_size(STACK_SIZE)
+                .spawn(move || loop {
+                    let job = receiver
+                        .lock()
+                        .expect("jobs run after the lock is released, so it is never poisoned")
+                        .recv();
+                    match job {
+                        Ok(job) => job(),
+                        Err(_) => return,
+                    }
+                });
+            if spawned.is_err() {
+                break;
+            }
+            started += 1;
+        }
+        (started > 0).then_some(sender)
+    });
+    let job: Job = Box::new(job);
+    match sender {
+        Some(sender) => {
+            if let Err(mpsc::SendError(job)) = sender.send(job) {
+                job();
+            }
+        }
+        None => job(),
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-gauge",
-  "version": "4.6.0",
+  "version": "4.7.1",
   "description": "Measure code metrics with tree-sitter.",
   "keywords": [
     "cli",
@@ -24,6 +24,7 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "workerd": "./dist/worker.js",
       "require": "./dist/index.cjs",
       "import": "./dist/index.js"
     }
@@ -37,14 +38,17 @@
     "native/build.rs",
     "native/Cargo.lock",
     "native/Cargo.toml",
+    "native/code-gauge.wasm",
     "native/src/",
     "scripts/buildNative.mjs",
-    "scripts/installNative.mjs"
+    "scripts/installNative.mjs",
+    "THIRD-PARTY-NOTICES.txt"
   ],
   "scripts": {
     "benchmark": "node scripts/benchmark.mjs",
-    "build": "build-ts lib -i src/index.ts -i src/cli.ts",
+    "build": "build-ts lib -i src/index.ts -i src/cli.ts -i src/worker.ts --external ../native/code-gauge.wasm",
     "build-native": "node scripts/buildNative.mjs",
+    "build-wasm": "node scripts/buildWasm.mjs",
     "cleanup": "bun wb lint --fix --format",
     "format": "bun wb lint --format",
     "postinstall": "node scripts/installNative.mjs",
@@ -79,7 +83,8 @@
     "semantic-release": "25.0.5",
     "sort-package-json": "4.0.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.9"
+    "vitest": "4.1.9",
+    "wrangler": "4.135.0"
   },
   "engines": {
     "node": ">=24"
@@ -89,12 +94,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "optionalDependencies": {
-    "code-gauge-linux-x64-gnu": "4.6.0",
-    "code-gauge-linux-arm64-gnu": "4.6.0",
-    "code-gauge-linux-x64-musl": "4.6.0",
-    "code-gauge-linux-arm64-musl": "4.6.0",
-    "code-gauge-darwin-x64": "4.6.0",
-    "code-gauge-darwin-arm64": "4.6.0",
-    "code-gauge-win32-x64-msvc": "4.6.0"
+    "code-gauge-linux-x64-gnu": "4.7.1",
+    "code-gauge-linux-arm64-gnu": "4.7.1",
+    "code-gauge-linux-x64-musl": "4.7.1",
+    "code-gauge-linux-arm64-musl": "4.7.1",
+    "code-gauge-darwin-x64": "4.7.1",
+    "code-gauge-darwin-arm64": "4.7.1",
+    "code-gauge-win32-x64-msvc": "4.7.1"
   }
 }