Implement plot metadata call (#998)

* plots metadata impl (WIP)

* use the jupyter execution id

* Apply suggestions from code review

Co-authored-by: Davis Vaughan <davis@rstudio.com>

* push execution context to plot device

* tests or it didn't happen

* move graphics kind detection to its own module

* remove superfluous type

* formatting; use 'plot' for base types

---------

Co-authored-by: Davis Vaughan <davis@rstudio.com>

Author: jmcphers

crates/amalthea/src/comm/plot_comm.rs

@@ -27,6 +27,22 @@ pub struct IntrinsicSize {
 	pub source: String
 }
 
+/// The plot's metadata
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct PlotMetadata {
+	/// A human-readable name for the plot
+	pub name: String,
+
+	/// The kind of plot e.g. 'Matplotlib', 'ggplot2', etc.
+	pub kind: String,
+
+	/// The ID of the code fragment that produced the plot
+	pub execution_id: String,
+
+	/// The code fragment that produced the plot
+	pub code: String
+}
+
 /// A rendered plot
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct PlotResult {
@@ -133,6 +149,12 @@ pub enum PlotBackendRequest {
 	#[serde(rename = "get_intrinsic_size")]
 	GetIntrinsicSize,
 
+	/// Get metadata for the plot
+	///
+	/// Get metadata for the plot
+	#[serde(rename = "get_metadata")]
+	GetMetadata,
+
 	/// Render a plot
 	///
 	/// Requests a plot to be rendered. The plot data is returned in a
@@ -151,6 +173,9 @@ pub enum PlotBackendReply {
 	/// The intrinsic size of a plot, if known
 	GetIntrinsicSizeReply(Option<IntrinsicSize>),
 
+	/// The plot's metadata
+	GetMetadataReply(PlotMetadata),
+
 	/// A rendered plot
 	RenderReply(PlotResult),
 

crates/amalthea/src/fixtures/dummy_frontend.rs

@@ -13,6 +13,7 @@ use crate::connection_file::ConnectionFile;
 use crate::registration_file::RegistrationFile;
 use crate::session::Session;
 use crate::socket::socket::Socket;
+use crate::wire::comm_msg::CommWireMsg;
 use crate::wire::execute_input::ExecuteInput;
 use crate::wire::execute_request::ExecuteRequest;
 use crate::wire::handshake_reply::HandshakeReply;
@@ -447,12 +448,41 @@ impl DummyFrontend {
         assert_matches!(msg, Message::DisplayData(_))
     }
 
+    /// Receive from IOPub and assert DisplayData message, returning the display_id
+    /// from the transient field.
+    #[track_caller]
+    pub fn recv_iopub_display_data_id(&self) -> String {
+        let msg = self.recv_iopub();
+        assert_matches!(msg, Message::DisplayData(data) => {
+            // Extract display_id from transient field
+            data.content.transient["display_id"]
+                .as_str()
+                .expect("display_id should be a string")
+                .to_string()
+        })
+    }
+
     #[track_caller]
     pub fn recv_iopub_update_display_data(&self) {
         let msg = self.recv_iopub();
         assert_matches!(msg, Message::UpdateDisplayData(_))
     }
 
+    /// Send a comm message on the Shell socket.
+    /// The `data` should contain an `id` field to make it an RPC request.
+    pub fn send_shell_comm_msg(&self, comm_id: String, data: Value) -> String {
+        self.send_shell(CommWireMsg { comm_id, data })
+    }
+
+    /// Receive a comm message reply from the IOPub socket
+    #[track_caller]
+    pub fn recv_iopub_comm_msg(&self) -> CommWireMsg {
+        let msg = self.recv_iopub();
+        assert_matches!(msg, Message::CommMsg(data) => {
+            data.content
+        })
+    }
+
     /// Receive from IOPub Stream
     ///
     /// Stdout and Stderr Stream messages are buffered, so to reliably test
@@ -635,6 +665,16 @@ impl DummyFrontend {
         }
     }
 
+    /// Receive from IOPub and assert CommOpen message.
+    /// Returns a tuple of (comm_id, target_name, data).
+    #[track_caller]
+    pub fn recv_iopub_comm_open(&self) -> (String, String, serde_json::Value) {
+        let msg = self.recv_iopub();
+        assert_matches!(msg, Message::CommOpen(data) => {
+            (data.content.comm_id, data.content.target_name, data.content.data)
+        })
+    }
+
     pub fn is_installed(&self, package: &str) -> bool {
         let code = format!(".ps.is_installed('{package}')");
         self.send_execute_request(&code, ExecuteRequestOptions::default());

crates/ark/src/interface.rs

@@ -876,6 +876,14 @@ impl RMain {
         &self.iopub_tx
     }
 
+    /// Get the current execution context if an active request exists.
+    /// Returns (execution_id, code) tuple where execution_id is the Jupyter message ID.
+    pub fn get_execution_context(&self) -> Option<(String, String)> {
+        self.active_request
+            .as_ref()
+            .map(|req| (req.originator.header.msg_id.clone(), req.request.code.clone()))
+    }
+
     fn init_execute_request(&mut self, req: &ExecuteRequest) -> (ConsoleInput, u32) {
         // Reset the autoprint buffer
         self.autoprint_output = String::new();
@@ -1306,11 +1314,17 @@ impl RMain {
                 // Save `ExecuteCode` request so we can respond to it at next prompt
                 self.active_request = Some(ActiveReadConsoleRequest {
                     exec_count,
-                    request: exec_req,
-                    originator,
+                    request: exec_req.clone(),
+                    originator: originator.clone(),
                     reply_tx,
                 });
 
+                // Push execution context to graphics device for plot attribution
+                graphics_device::on_execute_request(
+                    originator.header.msg_id.clone(),
+                    exec_req.code.clone(),
+                );
+
                 input
             },
 

crates/ark/src/modules/positron/graphics-kind.R

@@ -0,0 +1,185 @@
+#
+# graphics-kind.R
+#
+# Copyright (C) 2026 by Posit Software, PBC
+#
+#
+
+#' Detect the kind of plot from a recording
+#'
+#' Uses multiple strategies to determine plot type:
+#' 1. Check .Last.value for high-level plot objects (ggplot2, lattice)
+#' 2. Check recording's display list for base graphics patterns
+#' 3. Fall back to generic "plot"
+#'
+#' @param id The plot ID
+#' @return A string describing the plot kind
+#' @export
+.ps.graphics.detect_plot_kind <- function(id) {
+    # Strategy 1: Check .Last.value for recognizable plot objects
+    # This works for ggplot2, lattice, and some other packages
+    value <- tryCatch(
+        get(".Last.value", envir = globalenv()),
+        error = function(e) NULL
+    )
+
+    if (!is.null(value)) {
+        kind <- detect_kind_from_value(value)
+        if (!is.null(kind)) {
+            return(kind)
+        }
+    }
+
+    # Strategy 2: Check the recording itself
+    recording <- get_recording(id)
+    if (!is.null(recording)) {
+        # recordPlot() stores display list in first element
+        dl <- recording[[1]]
+        if (length(dl) > 0) {
+            kind <- detect_kind_from_display_list(dl)
+            if (!is.null(kind)) {
+                return(kind)
+            }
+        }
+    }
+
+    # Default fallback
+    "plot"
+}
+
+# Detect plot kind from .Last.value
+# Returns plot kind string or NULL
+detect_kind_from_value <- function(value) {
+    # ggplot2
+    if (inherits(value, "ggplot")) {
+        return(detect_ggplot_kind(value))
+    }
+
+    # lattice
+    if (inherits(value, "trellis")) {
+        # Extract lattice plot type from call
+        call_fn <- as.character(value$call[[1]])
+        kind_map <- c(
+            "xyplot" = "scatter plot",
+            "bwplot" = "box plot",
+            "histogram" = "histogram",
+            "densityplot" = "density plot",
+            "barchart" = "bar chart",
+            "dotplot" = "dot plot",
+            "levelplot" = "heatmap",
+            "contourplot" = "contour plot",
+            "cloud" = "3D scatter",
+            "wireframe" = "3D surface"
+        )
+        if (call_fn %in% names(kind_map)) {
+            return(paste0("lattice ", kind_map[call_fn]))
+        }
+        return("lattice")
+    }
+
+    # Base R objects that have class
+    if (inherits(value, "histogram")) {
+        return("histogram")
+    }
+    if (inherits(value, "density")) {
+        return("density")
+    }
+    if (inherits(value, "hclust")) {
+        return("dendrogram")
+    }
+    if (inherits(value, "acf")) {
+        return("autocorrelation")
+    }
+
+    NULL
+}
+
+# Detect ggplot2 plot kind from geom layers
+# Returns plot kind string
+detect_ggplot_kind <- function(gg) {
+    if (length(gg$layers) == 0) {
+        return("ggplot2")
+    }
+
+    # Get the first layer's geom class
+    geom_class <- class(gg$layers[[1]]$geom)[1]
+    geom_name <- tolower(gsub("^Geom", "", geom_class))
+
+    kind_map <- c(
+        "point" = "scatter plot",
+        "line" = "line chart",
+        "bar" = "bar chart",
+        "col" = "bar chart",
+        "histogram" = "histogram",
+        "boxplot" = "box plot",
+        "violin" = "violin plot",
+        "density" = "density plot",
+        "area" = "area chart",
+        "tile" = "heatmap",
+        "raster" = "raster",
+        "contour" = "contour plot",
+        "smooth" = "smoothed line",
+        "text" = "text",
+        "label" = "labels",
+        "path" = "path",
+        "polygon" = "polygon",
+        "ribbon" = "ribbon",
+        "segment" = "segments",
+        "abline" = "reference lines",
+        "hline" = "horizontal lines",
+        "vline" = "vertical lines"
+    )
+
+    if (geom_name %in% names(kind_map)) {
+        return(paste0("ggplot2 ", kind_map[geom_name]))
+    }
+
+    "ggplot2"
+}
+
+#' Retrieve plot metadata by display_id
+#'
+#' @param id The plot's display_id
+#' @return A named list with fields: name, kind, execution_id, code.
+#'   Returns NULL if no metadata is found for the given ID.
+#' @export
+.ps.graphics.get_metadata <- function(id) {
+    .ps.Call("ps_graphics_get_metadata", id)
+}
+
+# Detect plot kind from display list (base graphics)
+# Returns plot kind string or NULL
+detect_kind_from_display_list <- function(dl) {
+    # Display list entries are lists where first element is the C function name
+    call_names <- vapply(
+        dl,
+        function(x) {
+            if (is.list(x) && length(x) > 0) {
+                name <- x[[1]]
+                if (is.character(name)) name else ""
+            } else {
+                ""
+            }
+        },
+        character(1)
+    )
+
+    # Base graphics C functions to plot types
+    if (any(call_names == "C_plotHist")) {
+        return("histogram")
+    }
+    if (any(call_names == "C_image")) {
+        return("image")
+    }
+    if (any(call_names == "C_contour")) {
+        return("contour")
+    }
+    if (any(call_names == "C_persp")) {
+        return("3D surface")
+    }
+    if (any(call_names == "C_filledcontour")) {
+        return("filled contour")
+    }
+
+    NULL
+}

crates/ark/src/modules/positron/graphics.R

@@ -529,3 +529,4 @@ render_path <- function(id, format) {
     file <- paste0("render-", id, ".", format)
     file.path(directory, file)
 }
+