feat: expose baseline table reads over mcp

Author: singaraiona

README.md

@@ -85,7 +85,8 @@ automatically. `--config` overrides that path.
 `raysense mcp` runs a stdio MCP server for agents. It exposes tools to read and
 write config, run health, inspect scan facts, list dependency edges, read
 hotspots, read rule findings, read DSM module edges, and materialize memory
-table summaries. It can also save and diff baselines.
+table summaries. It can also save/diff baselines and read saved baseline
+tables.
 
 Baselines are stored under `<path>/.raysense/baseline` by default. The manifest
 is JSON for fast agent diffs, and baseline tables are written under `tables/`
@@ -141,7 +142,8 @@ codebases:
 - Rule thresholds can be configured with TOML.
 - Forbidden top-level module dependencies can be configured with TOML.
 - Config read/write, health runs, scan facts, edges, hotspots, rule findings,
-  module edges, and memory summaries are exposed through the MCP interface.
+  module edges, memory summaries, and saved baseline tables are exposed through
+  the MCP interface.
 - Baseline save/diff is available through the CLI and MCP, with Rayforce
   splayed-table storage for baseline tables.
 - Rayforce table materialization for scan facts, call facts, call edges,

crates/rayforce-sys/src/lib.rs

@@ -28,12 +28,20 @@ use std::os::raw::{c_char, c_int};
 
 pub const RAY_I32: i8 = 4;
 pub const RAY_I64: i8 = 5;
+pub const RAY_F64: i8 = 8;
 pub const RAY_STR: i8 = 13;
 pub const RAY_TABLE: i8 = 98;
+pub const RAY_ERROR: i8 = 127;
 
 #[repr(C)]
 pub struct ray_t {
-    _private: [u8; 0],
+    pub header: [u8; 16],
+    pub mmod: u8,
+    pub order: u8,
+    pub type_: i8,
+    pub attrs: u8,
+    pub rc: u32,
+    pub len: i64,
 }
 
 unsafe extern "C" {
@@ -43,17 +51,24 @@ unsafe extern "C" {
     pub fn ray_version_string() -> *const c_char;
 
     pub fn ray_release(v: *mut ray_t);
+    pub fn ray_err_code(err: *mut ray_t) -> *const c_char;
 
     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_sym_str(id: i64) -> *mut ray_t;
 
     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_str_vec_get(vec: *mut ray_t, idx: i64, out_len: *mut usize) -> *const c_char;
+    pub fn ray_str_ptr(s: *mut ray_t) -> *const c_char;
+    pub fn ray_str_len(s: *mut ray_t) -> usize;
 
     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_get_col_idx(tbl: *mut ray_t, idx: i64) -> *mut ray_t;
+    pub fn ray_table_col_name(tbl: *mut ray_t, idx: i64) -> i64;
     pub fn ray_table_ncols(tbl: *mut ray_t) -> i64;
     pub fn ray_table_nrows(tbl: *mut ray_t) -> i64;
 

crates/raysense-cli/src/mcp.rs

@@ -191,6 +191,16 @@ fn tools_list() -> Value {
                 "name": "raysense_baseline_diff",
                 "description": "Diff the current project health against a saved baseline.",
                 "inputSchema": baseline_schema("Baseline directory. Defaults to <path>/.raysense/baseline.")
+            },
+            {
+                "name": "raysense_baseline_tables",
+                "description": "List Rayforce splayed tables saved in a Raysense baseline.",
+                "inputSchema": baseline_table_schema(false)
+            },
+            {
+                "name": "raysense_baseline_table_read",
+                "description": "Read rows from a Rayforce splayed table saved in a Raysense baseline.",
+                "inputSchema": baseline_table_schema(true)
             }
         ]
     })
@@ -218,6 +228,8 @@ fn call_tool(params: &Value) -> Result<Value> {
         "raysense_memory_summary" => memory_summary_tool(&args),
         "raysense_baseline_save" => baseline_save_tool(&args),
         "raysense_baseline_diff" => baseline_diff_tool(&args),
+        "raysense_baseline_tables" => baseline_tables_tool(&args),
+        "raysense_baseline_table_read" => baseline_table_read_tool(&args),
         _ => Err(anyhow!("unknown tool {name}")),
     }
 }
@@ -429,6 +441,49 @@ fn baseline_diff_tool(args: &Value) -> Result<Value> {
     }))
 }
 
+fn baseline_tables_tool(args: &Value) -> Result<Value> {
+    let root = root_arg(args)?;
+    let baseline_dir = baseline_dir_arg(args, &root)?;
+    let tables_dir = baseline_dir.join("tables");
+    let tables = raysense_memory::list_baseline_tables(&tables_dir)
+        .with_context(|| format!("failed to list baseline tables {}", tables_dir.display()))?;
+
+    Ok(json!({
+        "baseline_path": baseline_dir,
+        "tables_path": tables_dir,
+        "tables": tables
+    }))
+}
+
+fn baseline_table_read_tool(args: &Value) -> Result<Value> {
+    let root = root_arg(args)?;
+    let baseline_dir = baseline_dir_arg(args, &root)?;
+    let tables_dir = baseline_dir.join("tables");
+    let table = args
+        .get("table")
+        .and_then(Value::as_str)
+        .ok_or_else(|| anyhow!("table must be a string"))?;
+    let offset = args
+        .get("offset")
+        .map(|value| {
+            value
+                .as_u64()
+                .map(|value| value as usize)
+                .ok_or_else(|| anyhow!("offset must be a non-negative integer"))
+        })
+        .transpose()?
+        .unwrap_or(0);
+    let limit = limit_arg(args, 100)?;
+    let table_rows = raysense_memory::read_baseline_table(&tables_dir, table, offset, limit)
+        .with_context(|| format!("failed to read baseline table {}", tables_dir.display()))?;
+
+    Ok(json!({
+        "baseline_path": baseline_dir,
+        "tables_path": tables_dir,
+        "table": table_rows
+    }))
+}
+
 fn health_from_args(args: &Value) -> Result<(PathBuf, raysense_core::HealthSummary)> {
     let root = root_arg(args)?;
     let config = effective_config(args, &root)?;
@@ -660,6 +715,23 @@ fn baseline_schema(path_description: &str) -> Value {
     })
 }
 
+fn baseline_table_schema(require_table: bool) -> Value {
+    let mut schema = json!({
+        "type": "object",
+        "properties": {
+            "path": {"type": "string", "description": "Project root. Defaults to the current directory."},
+            "baseline_path": {"type": "string", "description": "Baseline directory. Defaults to <path>/.raysense/baseline."},
+            "table": {"type": "string", "description": "Baseline table name, such as files, functions, imports, calls, call_edges, health, hotspots, rules, module_edges, or changed_files."},
+            "offset": {"type": "integer", "minimum": 0, "description": "First row offset. Defaults to 0."},
+            "limit": {"type": "integer", "minimum": 1, "description": "Maximum rows to return. Defaults to 100."}
+        }
+    });
+    if require_table {
+        schema["required"] = json!(["table"]);
+    }
+    schema
+}
+
 fn limited<T: serde::Serialize>(items: &[T], limit: usize) -> Vec<Value> {
     items
         .iter()
@@ -695,6 +767,8 @@ mod tests {
         assert!(names.contains(&"raysense_memory_summary"));
         assert!(names.contains(&"raysense_baseline_save"));
         assert!(names.contains(&"raysense_baseline_diff"));
+        assert!(names.contains(&"raysense_baseline_tables"));
+        assert!(names.contains(&"raysense_baseline_table_read"));
     }
 
     #[test]

crates/raysense-memory/Cargo.toml

@@ -29,4 +29,5 @@ license.workspace = true
 rayforce-sys = { path = "../rayforce-sys" }
 raysense-core = { path = "../raysense-core" }
 serde.workspace = true
+serde_json.workspace = true
 thiserror.workspace = true