feat: add rayforce memory bridge

Author: singaraiona

Cargo.toml

@@ -1,7 +1,9 @@
 [workspace]
 members = [
+    "crates/rayforce-sys",
     "crates/raysense-cli",
     "crates/raysense-core",
+    "crates/raysense-memory",
 ]
 resolver = "2"
 

crates/rayforce-sys/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "rayforce-sys"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+links = "rayforce"
+
+[build-dependencies]
+

crates/rayforce-sys/build.rs

@@ -0,0 +1,39 @@
+use std::env;
+use std::path::PathBuf;
+
+fn main() {
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+    let rayforce_dir = env::var_os("RAYFORCE_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|| manifest_dir.join("../../..").join("rayforce"));
+
+    let include_dir = rayforce_dir.join("include");
+    let lib_dir = rayforce_dir.clone();
+    let lib_path = lib_dir.join("librayforce.a");
+
+    if !lib_path.exists() {
+        panic!(
+            "missing {}; build it with `make -C {} lib` or set RAYFORCE_DIR",
+            lib_path.display(),
+            rayforce_dir.display()
+        );
+    }
+
+    println!("cargo:include={}", include_dir.display());
+    println!("cargo:rustc-link-search=native={}", lib_dir.display());
+    println!("cargo:rustc-link-lib=static=rayforce");
+
+    if env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("linux") {
+        println!("cargo:rustc-link-lib=m");
+        println!("cargo:rustc-link-lib=pthread");
+    } else {
+        println!("cargo:rustc-link-lib=m");
+    }
+
+    println!("cargo:rerun-if-env-changed=RAYFORCE_DIR");
+    println!("cargo:rerun-if-changed={}", lib_path.display());
+    println!(
+        "cargo:rerun-if-changed={}",
+        include_dir.join("rayforce.h").display()
+    );
+}

crates/rayforce-sys/src/lib.rs

@@ -0,0 +1,55 @@
+#![allow(non_camel_case_types)]
+
+use std::ffi::CStr;
+use std::os::raw::{c_char, c_int};
+
+pub const RAY_I32: i8 = 4;
+pub const RAY_I64: i8 = 5;
+pub const RAY_STR: i8 = 13;
+pub const RAY_TABLE: i8 = 98;
+
+#[repr(C)]
+pub struct ray_t {
+    _private: [u8; 0],
+}
+
+unsafe extern "C" {
+    pub fn ray_version_major() -> c_int;
+    pub fn ray_version_minor() -> c_int;
+    pub fn ray_version_patch() -> c_int;
+    pub fn ray_version_string() -> *const c_char;
+
+    pub fn ray_release(v: *mut ray_t);
+
+    pub fn ray_sym_init() -> ray_err_t;
+    pub fn ray_sym_destroy();
+    pub fn ray_sym_intern(str: *const c_char, len: usize) -> i64;
+
+    pub fn ray_vec_new(type_: i8, capacity: i64) -> *mut ray_t;
+    pub fn ray_vec_append(vec: *mut ray_t, elem: *const std::ffi::c_void) -> *mut ray_t;
+    pub fn ray_str_vec_append(vec: *mut ray_t, s: *const c_char, len: usize) -> *mut ray_t;
+
+    pub fn ray_table_new(ncols: i64) -> *mut ray_t;
+    pub fn ray_table_add_col(tbl: *mut ray_t, name_id: i64, col_vec: *mut ray_t) -> *mut ray_t;
+    pub fn ray_table_ncols(tbl: *mut ray_t) -> i64;
+    pub fn ray_table_nrows(tbl: *mut ray_t) -> i64;
+}
+
+pub type ray_err_t = c_int;
+
+pub const RAY_OK: ray_err_t = 0;
+
+pub fn version_string() -> String {
+    unsafe {
+        let ptr = ray_version_string();
+        if ptr.is_null() {
+            return format!(
+                "{}.{}.{}",
+                ray_version_major(),
+                ray_version_minor(),
+                ray_version_patch()
+            );
+        }
+        CStr::from_ptr(ptr).to_string_lossy().into_owned()
+    }
+}

crates/raysense-cli/Cargo.toml

@@ -11,5 +11,7 @@ path = "src/main.rs"
 [dependencies]
 anyhow.workspace = true
 clap.workspace = true
+rayforce-sys = { path = "../rayforce-sys" }
 raysense-core = { path = "../raysense-core" }
+raysense-memory = { path = "../raysense-memory" }
 serde_json.workspace = true

crates/raysense-cli/src/main.rs

@@ -17,26 +17,58 @@ enum Command {
         path: PathBuf,
         #[arg(long)]
         json: bool,
+        #[arg(long)]
+        memory: bool,
+    },
+    RayforceVersion,
+    Memory {
+        path: PathBuf,
     },
 }
 
 fn main() -> Result<()> {
     let args = Args::parse();
 
     match args.command {
-        Command::Observe { path, json } => {
+        Command::Observe { path, json, memory } => {
             let report = scan_path(path)?;
             if json {
                 println!("{}", serde_json::to_string_pretty(&report)?);
+            } else if memory {
+                let memory = raysense_memory::RayMemory::from_report(&report)?;
+                print_memory_summary(&memory.summary());
             } else {
                 print_summary(&report);
             }
         }
+        Command::RayforceVersion => {
+            println!("{}", rayforce_sys::version_string());
+        }
+        Command::Memory { path } => {
+            let report = scan_path(path)?;
+            let memory = raysense_memory::RayMemory::from_report(&report)?;
+            print_memory_summary(&memory.summary());
+        }
     }
 
     Ok(())
 }
 
+fn print_memory_summary(summary: &raysense_memory::MemorySummary) {
+    println!(
+        "files rows={} cols={}",
+        summary.files.rows, summary.files.columns
+    );
+    println!(
+        "functions rows={} cols={}",
+        summary.functions.rows, summary.functions.columns
+    );
+    println!(
+        "imports rows={} cols={}",
+        summary.imports.rows, summary.imports.columns
+    );
+}
+
 fn print_summary(report: &raysense_core::ScanReport) {
     println!("snapshot {}", report.snapshot.snapshot_id);
     println!("root {}", report.snapshot.root.display());

crates/raysense-memory/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "raysense-memory"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+rayforce-sys = { path = "../rayforce-sys" }
+raysense-core = { path = "../raysense-core" }
+thiserror.workspace = true