From 5215985b0b34fd19879820063786200fe431e7f1 Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Tue, 8 Jul 2025 14:29:43 +0200
Subject: [PATCH 01/14] Draft data structures

---
 crates/ark/src/lsp/inputs/mod.rs         |  9 ++++++++
 crates/ark/src/lsp/inputs/package.rs     | 26 ++++++++++++++++++++++++
 crates/ark/src/lsp/inputs/source_root.rs | 16 +++++++++++++++
 crates/ark/src/lsp/mod.rs                |  1 +
 crates/ark/src/lsp/state.rs              | 12 +++++++++++
 5 files changed, 64 insertions(+)
 create mode 100644 crates/ark/src/lsp/inputs/mod.rs
 create mode 100644 crates/ark/src/lsp/inputs/package.rs
 create mode 100644 crates/ark/src/lsp/inputs/source_root.rs

diff --git a/crates/ark/src/lsp/inputs/mod.rs b/crates/ark/src/lsp/inputs/mod.rs
new file mode 100644
index 000000000..689fd1068
--- /dev/null
+++ b/crates/ark/src/lsp/inputs/mod.rs
@@ -0,0 +1,9 @@
+//
+// mod.rs
+//
+// Copyright (C) 2025 by Posit Software, PBC
+//
+//
+
+pub mod package;
+pub mod source_root;
diff --git a/crates/ark/src/lsp/inputs/package.rs b/crates/ark/src/lsp/inputs/package.rs
new file mode 100644
index 000000000..5d7b25c03
--- /dev/null
+++ b/crates/ark/src/lsp/inputs/package.rs
@@ -0,0 +1,26 @@
+//
+// package.rs
+//
+// Copyright (C) 2025 by Posit Software, PBC
+//
+//
+
+use std::path::PathBuf;
+
+/// Represents an R package and its metadata relevant for static analysis.
+#[derive(Clone, Debug)]
+pub struct Package {
+    pub name: String,
+    pub version: String,
+
+    /// Path to the directory that contains `DESCRIPTION`. Could be an installed
+    /// package, or a package source.
+    pub path: PathBuf,
+
+    /// Imports and exports in `NAMESPACE`
+    pub imports: Vec<String>,
+    pub exports: Vec<String>,
+
+    /// `Depends` field in `DESCRIPTION`
+    pub depends: Vec<String>,
+}
diff --git a/crates/ark/src/lsp/inputs/source_root.rs b/crates/ark/src/lsp/inputs/source_root.rs
new file mode 100644
index 000000000..f3805c9db
--- /dev/null
+++ b/crates/ark/src/lsp/inputs/source_root.rs
@@ -0,0 +1,16 @@
+//
+// source_root.rs
+//
+// Copyright (C) 2025 by Posit Software, PBC
+//
+//
+
+use super::package::Package;
+
+/// The root of a source tree.
+/// Currently only supports packages, but can be extended to scripts.
+#[derive(Clone, Debug)]
+pub enum SourceRoot {
+    Package(Package),
+    // Scripts(Vec<Script>),   // For reference, to implement later on
+}
diff --git a/crates/ark/src/lsp/mod.rs b/crates/ark/src/lsp/mod.rs
index 46b695a2d..cdf230b4e 100644
--- a/crates/ark/src/lsp/mod.rs
+++ b/crates/ark/src/lsp/mod.rs
@@ -28,6 +28,7 @@ pub mod hover;
 pub mod indent;
 pub mod indexer;
 pub mod input_boundaries;
+pub mod inputs;
 pub mod main_loop;
 pub mod markdown;
 pub mod offset;
diff --git a/crates/ark/src/lsp/state.rs b/crates/ark/src/lsp/state.rs
index 9dc84afa4..c82cc7cf3 100644
--- a/crates/ark/src/lsp/state.rs
+++ b/crates/ark/src/lsp/state.rs
@@ -1,11 +1,14 @@
 use std::collections::HashMap;
 use std::path::Path;
+use std::path::PathBuf;
 
 use anyhow::anyhow;
 use url::Url;
 
 use crate::lsp::config::LspConfig;
 use crate::lsp::documents::Document;
+use crate::lsp::inputs::package::Package;
+use crate::lsp::inputs::source_root::SourceRoot;
 
 #[derive(Clone, Default, Debug)]
 /// The world state, i.e. all the inputs necessary for analysing or refactoring
@@ -48,6 +51,15 @@ pub(crate) struct WorldState {
     /// Currently installed packages
     pub(crate) installed_packages: Vec<String>,
 
+    /// The root of the source tree (e.g., a package).
+    pub(crate) _root: Option<SourceRoot>,
+
+    /// Map of package name to package metadata for installed libraries. Lazily populated.
+    pub(crate) _library: HashMap<String, Package>,
+
+    /// Paths to library directories, i.e. what `base::libPaths()` returns.
+    pub(crate) _library_paths: Vec<PathBuf>,
+
     pub(crate) config: LspConfig,
 }
 

From 80de5562057b0022c2750fa91978f349c628a573 Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Tue, 8 Jul 2025 15:17:52 +0200
Subject: [PATCH 02/14] Inspect library paths on LSP startup

---
 crates/ark/src/lsp/main_loop.rs | 21 +++++++++++++++++++--
 crates/ark/src/lsp/state.rs     |  2 +-
 crates/harp/src/lib.rs          |  2 ++
 3 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/crates/ark/src/lsp/main_loop.rs b/crates/ark/src/lsp/main_loop.rs
index 0ee4be1a3..06c30470d 100644
--- a/crates/ark/src/lsp/main_loop.rs
+++ b/crates/ark/src/lsp/main_loop.rs
@@ -7,6 +7,7 @@
 
 use std::collections::HashMap;
 use std::future;
+use std::path::PathBuf;
 use std::pin::Pin;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering;
@@ -174,13 +175,29 @@ impl GlobalState {
         // tower-lsp backend and the Jupyter kernel.
         let (events_tx, events_rx) = tokio_unbounded_channel::<Event>();
 
-        Self {
+        let mut state = Self {
             world: WorldState::default(),
             lsp_state: LspState::default(),
             client,
             events_tx,
             events_rx,
-        }
+        };
+
+        // FIXME: We shouldn't call R code in the kernel to figure this out
+        if let Err(err) = crate::r_task(|| -> anyhow::Result<()> {
+            let paths: Vec<String> = harp::RFunction::new("base", ".libPaths")
+                .call()?
+                .try_into()?;
+
+            log::info!("Using library paths: {paths:#?}");
+            state.world.library_paths = paths.into_iter().map(PathBuf::from).collect();
+
+            Ok(())
+        }) {
+            log::error!("Can't evaluate `libPaths()`: {err:?}");
+        };
+
+        state
     }
 
     /// Get `Event` transmission channel
diff --git a/crates/ark/src/lsp/state.rs b/crates/ark/src/lsp/state.rs
index c82cc7cf3..cf87273bc 100644
--- a/crates/ark/src/lsp/state.rs
+++ b/crates/ark/src/lsp/state.rs
@@ -58,7 +58,7 @@ pub(crate) struct WorldState {
     pub(crate) _library: HashMap<String, Package>,
 
     /// Paths to library directories, i.e. what `base::libPaths()` returns.
-    pub(crate) _library_paths: Vec<PathBuf>,
+    pub(crate) library_paths: Vec<PathBuf>,
 
     pub(crate) config: LspConfig,
 }
diff --git a/crates/harp/src/lib.rs b/crates/harp/src/lib.rs
index e1c4dacea..27d66141a 100644
--- a/crates/harp/src/lib.rs
+++ b/crates/harp/src/lib.rs
@@ -46,6 +46,8 @@ pub mod weak_ref;
 pub use column_names::*;
 pub use data_frame::*;
 pub use eval::*;
+pub use exec::RFunction;
+pub use exec::RFunctionExt;
 pub use matrix::*;
 pub use object::*;
 pub use parse::*;

From 6b2bf6ac2d5a0a32b7080e4b905d78c36ce4b1fd Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Tue, 8 Jul 2025 15:53:07 +0200
Subject: [PATCH 03/14] Extract structs from `Package`

---
 crates/ark/src/lsp/inputs/package.rs | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/crates/ark/src/lsp/inputs/package.rs b/crates/ark/src/lsp/inputs/package.rs
index 5d7b25c03..cc8b72037 100644
--- a/crates/ark/src/lsp/inputs/package.rs
+++ b/crates/ark/src/lsp/inputs/package.rs
@@ -10,17 +10,27 @@ use std::path::PathBuf;
 /// Represents an R package and its metadata relevant for static analysis.
 #[derive(Clone, Debug)]
 pub struct Package {
-    pub name: String,
-    pub version: String,
-
     /// Path to the directory that contains `DESCRIPTION`. Could be an installed
     /// package, or a package source.
     pub path: PathBuf,
 
-    /// Imports and exports in `NAMESPACE`
-    pub imports: Vec<String>,
-    pub exports: Vec<String>,
+    pub description: Description,
+    pub namespace: Namespace,
+}
 
-    /// `Depends` field in `DESCRIPTION`
+/// Parsed DESCRIPTION file
+#[derive(Clone, Debug)]
+pub struct Description {
+    pub name: String,
+    pub version: String,
+
+    /// `Depends` field
     pub depends: Vec<String>,
 }
+
+/// Parsed NAMESPACE file
+#[derive(Clone, Debug)]
+pub struct Namespace {
+    pub imports: Vec<String>,
+    pub exports: Vec<String>,
+}

From 7cf77bab020d0f0154130d4aa5eb90293bab0974 Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Tue, 8 Jul 2025 16:08:26 +0200
Subject: [PATCH 04/14] Add `NAMESPACE` parser

---
 crates/ark/src/lsp/inputs/package.rs | 149 ++++++++++++++++++++++++++-
 1 file changed, 148 insertions(+), 1 deletion(-)

diff --git a/crates/ark/src/lsp/inputs/package.rs b/crates/ark/src/lsp/inputs/package.rs
index cc8b72037..fe035e92c 100644
--- a/crates/ark/src/lsp/inputs/package.rs
+++ b/crates/ark/src/lsp/inputs/package.rs
@@ -7,6 +7,10 @@
 
 use std::path::PathBuf;
 
+use tree_sitter::Parser;
+
+use crate::treesitter::TSQuery;
+
 /// Represents an R package and its metadata relevant for static analysis.
 #[derive(Clone, Debug)]
 pub struct Package {
@@ -31,6 +35,149 @@ pub struct Description {
 /// Parsed NAMESPACE file
 #[derive(Clone, Debug)]
 pub struct Namespace {
-    pub imports: Vec<String>,
+    /// Names of objects exported with `export()`
     pub exports: Vec<String>,
+    /// Names of objects imported with `importFrom()`
+    pub imports: Vec<String>,
+    /// Names of packages bulk-imported with `import()`
+    pub bulk_imports: Vec<String>,
+}
+
+impl Namespace {
+    /// Parse a NAMESPACE file using tree-sitter to extract exports and imports.
+    pub fn parse(contents: &str) -> anyhow::Result<Self> {
+        let mut parser = Parser::new();
+        parser
+            .set_language(&tree_sitter_r::LANGUAGE.into())
+            .map_err(|err| anyhow::anyhow!("Failed to set tree-sitter language: {err:?}"))?;
+
+        let tree = parser
+            .parse(contents, None)
+            .ok_or_else(|| anyhow::anyhow!("Failed to parse NAMESPACE file"))?;
+        let root_node = tree.root_node();
+
+        let query_str = r#"
+            (call
+                function: (identifier) @fn_name
+                arguments: (arguments (argument value: (identifier) @exported))
+                (#eq? @fn_name "export")
+            )
+            (call
+                function: (identifier) @fn_name
+                arguments: (arguments (argument value: (identifier) @pkg) (argument value: (identifier) @imported))
+                (#eq? @fn_name "importFrom")
+            )
+            (call
+                function: (identifier) @fn_name
+                arguments: (arguments (argument value: (identifier) @bulk_imported))
+                (#eq? @fn_name "import")
+            )
+        "#;
+        let mut ts_query = TSQuery::new(query_str)?;
+
+        let mut exports = Vec::new();
+        for capture in ts_query.captures_for(root_node, "exported", contents.as_bytes()) {
+            let symbol = capture
+                .utf8_text(contents.as_bytes())
+                .unwrap_or("")
+                .to_string();
+            exports.push(symbol);
+        }
+
+        let mut imports = Vec::new();
+        for capture in ts_query.captures_for(root_node, "imported", contents.as_bytes()) {
+            let symbol = capture
+                .utf8_text(contents.as_bytes())
+                .unwrap_or("")
+                .to_string();
+            imports.push(symbol);
+        }
+
+        let mut bulk_imports = Vec::new();
+        for capture in ts_query.captures_for(root_node, "bulk_imported", contents.as_bytes()) {
+            let symbol = capture
+                .utf8_text(contents.as_bytes())
+                .unwrap_or("")
+                .to_string();
+            bulk_imports.push(symbol);
+        }
+
+        // Take unique values of imports and exports. In the future we'll lint
+        // this but for now just be defensive.
+        exports.sort();
+        exports.dedup();
+        imports.sort();
+        imports.dedup();
+        bulk_imports.sort();
+        bulk_imports.dedup();
+
+        Ok(Namespace {
+            imports,
+            exports,
+            bulk_imports,
+        })
+    }
+
+    /// TODO: Take a `Library` and incorporate bulk imports
+    pub(crate) fn _resolve_imports(&self) -> &Vec<String> {
+        &self.imports
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_exports() {
+        let ns = r#"
+            export(foo)
+            export(bar)
+            exports(baz) # typo
+        "#;
+        let parsed = Namespace::parse(ns).unwrap();
+        assert_eq!(parsed.exports, vec!["bar", "foo"]);
+        assert!(parsed.imports.is_empty());
+    }
+
+    #[test]
+    fn parses_importfrom() {
+        let ns = r#"
+            importFrom(stats, median)
+            importFrom(utils, head)
+            importsFrom(utils, tail) # typo
+        "#;
+        let parsed = Namespace::parse(ns).unwrap();
+        assert_eq!(parsed.imports, vec!["head", "median"]);
+        assert!(parsed.exports.is_empty());
+    }
+
+    #[test]
+    fn parses_mixed_namespace_with_duplicates() {
+        let ns = r#"
+            export(foo)
+            importFrom(stats, median)
+            export(bar)
+            importFrom(utils, head)
+            importFrom(utils, median)
+        "#;
+        let parsed = Namespace::parse(ns).unwrap();
+        assert_eq!(parsed.exports, vec!["bar", "foo"]);
+        assert_eq!(parsed.imports, vec!["head", "median"]);
+    }
+
+    #[test]
+    fn parses_bulk_imports() {
+        let ns = r#"
+                import(rlang)
+                import(utils)
+                export(foo)
+                import(utils)
+                importFrom(stats, median)
+            "#;
+        let parsed = Namespace::parse(ns).unwrap();
+        assert_eq!(parsed.bulk_imports, vec!["rlang", "utils"]);
+        assert_eq!(parsed.exports, vec!["foo"]);
+        assert_eq!(parsed.imports, vec!["median"]);
+    }
 }

From d33097c6644460ec4cbbfa9351e0040c3d27e280 Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Tue, 8 Jul 2025 17:40:30 +0200
Subject: [PATCH 05/14] Draft `Library`

---
 crates/ark/src/lsp/inputs/library.rs | 163 +++++++++++++++++++++++++++
 crates/ark/src/lsp/inputs/mod.rs     |   1 +
 crates/ark/src/lsp/main_loop.rs      |   4 +-
 crates/ark/src/lsp/state.rs          |   8 +-
 4 files changed, 169 insertions(+), 7 deletions(-)
 create mode 100644 crates/ark/src/lsp/inputs/library.rs

diff --git a/crates/ark/src/lsp/inputs/library.rs b/crates/ark/src/lsp/inputs/library.rs
new file mode 100644
index 000000000..c4dfb3ecb
--- /dev/null
+++ b/crates/ark/src/lsp/inputs/library.rs
@@ -0,0 +1,163 @@
+//
+// library.rs
+//
+// Copyright (C) 2025 by Posit Software, PBC
+//
+
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::sync::RwLock;
+
+use super::package::Package;
+use crate::lsp;
+use crate::lsp::inputs::package::Description;
+use crate::lsp::inputs::package::Namespace;
+
+/// Lazily manages a list of known R packages by name
+#[derive(Default, Clone, Debug)]
+pub struct Library {
+    /// Paths to library directories, i.e. what `base::libPaths()` returns.
+    pub library_paths: Arc<Vec<PathBuf>>,
+
+    packages: Arc<RwLock<HashMap<String, Option<Arc<Package>>>>>,
+}
+
+impl Library {
+    pub fn new(library_paths: Vec<PathBuf>) -> Self {
+        Self {
+            packages: Arc::new(RwLock::new(HashMap::new())),
+            library_paths: Arc::new(library_paths),
+        }
+    }
+
+    /// Get a package by name, loading and caching it if necessary.
+    /// Returns `None` if the package can't be found or loaded.
+    pub fn get(&self, name: &str) -> Option<Arc<Package>> {
+        // Try to get from cache first (could be `None` if we already tried to
+        // load a non-existent or broken package)
+        if let Some(entry) = self.packages.read().unwrap().get(name) {
+            return entry.clone();
+        }
+
+        // Not cached, try to load
+        let pkg = match self.load_package(name) {
+            Ok(Some(pkg)) => Some(Arc::new(pkg)),
+            Ok(None) => None,
+            Err(err) => {
+                lsp::log_error!("Can't load R package: {err:?}");
+                None
+            },
+        };
+
+        self.packages
+            .write()
+            .unwrap()
+            .insert(name.to_string(), pkg.clone());
+
+        pkg
+    }
+
+    fn load_package(&self, name: &str) -> anyhow::Result<Option<Package>> {
+        for lib_path in self.library_paths.iter() {
+            let package_path = lib_path.join(name);
+            let description_path = package_path.join("DESCRIPTION");
+            let namespace_path = package_path.join("NAMESPACE");
+
+            // Only consider libraries that have a folder named after the
+            // requested package and that contains a description file
+            if !description_path.is_file() {
+                continue;
+            }
+
+            // TODO
+            // let _desc_contents = fs::read_to_string(&description_path)?;
+
+            let description = Description {
+                name: name.to_string(),
+                version: "unknown".to_string(),
+                depends: vec![],
+            };
+
+            let namespace_contents = fs::read_to_string(&namespace_path)?;
+            let namespace = Namespace::parse(&namespace_contents)?;
+
+            return Ok(Some(Package {
+                path: package_path,
+                description,
+                namespace,
+            }));
+        }
+
+        Ok(None)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs::File;
+    use std::fs::{self};
+    use std::io::Write;
+
+    use tempfile::TempDir;
+
+    use super::*;
+
+    // Helper to create a temporary package directory with DESCRIPTION and NAMESPACE
+    fn create_temp_package(
+        pkg_name: &str,
+        description: &str,
+        namespace: &str,
+    ) -> (TempDir, PathBuf) {
+        let temp_dir = TempDir::new().unwrap();
+        let pkg_dir = temp_dir.path().join(pkg_name);
+        fs::create_dir(&pkg_dir).unwrap();
+
+        let desc_path = pkg_dir.join("DESCRIPTION");
+        let mut desc_file = File::create(&desc_path).unwrap();
+        desc_file.write_all(description.as_bytes()).unwrap();
+
+        let ns_path = pkg_dir.join("NAMESPACE");
+        let mut ns_file = File::create(&ns_path).unwrap();
+        ns_file.write_all(namespace.as_bytes()).unwrap();
+
+        (temp_dir, pkg_dir)
+    }
+
+    #[test]
+    fn test_load_and_cache_package() {
+        let pkg_name = "mypkg";
+        let description = r#"
+            Package: mypkg
+            Version: 1.0
+        "#;
+        let namespace = r#"
+            export(foo)
+            export(bar)
+            importFrom(pkg, baz)
+        "#;
+
+        let (temp_dir, _pkg_dir) = create_temp_package(pkg_name, description, namespace);
+
+        // Library should point to the temp_dir as its only library path
+        let lib = Library::new(vec![temp_dir.path().to_path_buf()]);
+
+        // First access loads from disk
+        let pkg = lib.get(pkg_name).expect("should load package");
+        assert_eq!(pkg.description.name, "mypkg");
+
+        // Second access uses cache (note that we aren't testing that we are
+        // indeed caching, just exercising the cache code path)
+        assert!(lib.get(pkg_name).is_some());
+
+        // Negative cache: missing package
+        assert!(lib.get("notapkg").is_none());
+        // Now cached as absent
+        assert!(lib.get("notapkg").is_none());
+
+        // Namespace is parsed
+        assert_eq!(pkg.namespace.exports, vec!["bar", "foo"]);
+        assert_eq!(pkg.namespace.imports, vec!["baz"]);
+    }
+}
diff --git a/crates/ark/src/lsp/inputs/mod.rs b/crates/ark/src/lsp/inputs/mod.rs
index 689fd1068..3d4952b81 100644
--- a/crates/ark/src/lsp/inputs/mod.rs
+++ b/crates/ark/src/lsp/inputs/mod.rs
@@ -5,5 +5,6 @@
 //
 //
 
+pub mod library;
 pub mod package;
 pub mod source_root;
diff --git a/crates/ark/src/lsp/main_loop.rs b/crates/ark/src/lsp/main_loop.rs
index 06c30470d..a2bd2c40d 100644
--- a/crates/ark/src/lsp/main_loop.rs
+++ b/crates/ark/src/lsp/main_loop.rs
@@ -33,6 +33,7 @@ use crate::lsp::capabilities::Capabilities;
 use crate::lsp::diagnostics;
 use crate::lsp::documents::Document;
 use crate::lsp::handlers;
+use crate::lsp::inputs::library::Library;
 use crate::lsp::state::WorldState;
 use crate::lsp::state_handlers;
 use crate::lsp::state_handlers::ConsoleInputs;
@@ -190,7 +191,8 @@ impl GlobalState {
                 .try_into()?;
 
             log::info!("Using library paths: {paths:#?}");
-            state.world.library_paths = paths.into_iter().map(PathBuf::from).collect();
+            let paths: Vec<PathBuf> = paths.into_iter().map(PathBuf::from).collect();
+            state.world.library = Library::new(paths);
 
             Ok(())
         }) {
diff --git a/crates/ark/src/lsp/state.rs b/crates/ark/src/lsp/state.rs
index cf87273bc..12f53c947 100644
--- a/crates/ark/src/lsp/state.rs
+++ b/crates/ark/src/lsp/state.rs
@@ -1,13 +1,12 @@
 use std::collections::HashMap;
 use std::path::Path;
-use std::path::PathBuf;
 
 use anyhow::anyhow;
 use url::Url;
 
 use crate::lsp::config::LspConfig;
 use crate::lsp::documents::Document;
-use crate::lsp::inputs::package::Package;
+use crate::lsp::inputs::library::Library;
 use crate::lsp::inputs::source_root::SourceRoot;
 
 #[derive(Clone, Default, Debug)]
@@ -55,10 +54,7 @@ pub(crate) struct WorldState {
     pub(crate) _root: Option<SourceRoot>,
 
     /// Map of package name to package metadata for installed libraries. Lazily populated.
-    pub(crate) _library: HashMap<String, Package>,
-
-    /// Paths to library directories, i.e. what `base::libPaths()` returns.
-    pub(crate) library_paths: Vec<PathBuf>,
+    pub(crate) library: Library,
 
     pub(crate) config: LspConfig,
 }

From 3edadb75669a82fb14468fd5a0111b2894c63bfa Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Thu, 10 Jul 2025 17:42:38 +0200
Subject: [PATCH 06/14] Handle `library()` calls in diagnostics

---
 crates/ark/src/lsp/diagnostics.rs        | 166 ++++++++++++++++++++++-
 crates/ark/src/lsp/diagnostics_syntax.rs |   3 +-
 crates/ark/src/lsp/inputs/library.rs     |  10 ++
 3 files changed, 173 insertions(+), 6 deletions(-)

diff --git a/crates/ark/src/lsp/diagnostics.rs b/crates/ark/src/lsp/diagnostics.rs
index c9296bc99..6c8d2d537 100644
--- a/crates/ark/src/lsp/diagnostics.rs
+++ b/crates/ark/src/lsp/diagnostics.rs
@@ -24,6 +24,7 @@ use crate::lsp::diagnostics_syntax::syntax_diagnostics;
 use crate::lsp::documents::Document;
 use crate::lsp::encoding::convert_tree_sitter_range_to_lsp_range;
 use crate::lsp::indexer;
+use crate::lsp::inputs::library::Library;
 use crate::lsp::state::WorldState;
 use crate::lsp::traits::rope::RopeExt;
 use crate::treesitter::node_has_error_or_missing;
@@ -55,6 +56,14 @@ pub struct DiagnosticContext<'a> {
     // The set of packages that are currently installed.
     pub installed_packages: HashSet<String>,
 
+    /// Reference to the library for looking up package exports.
+    pub library: &'a Library,
+
+    /// The symbols exported by packages loaded via `library()` calls in this
+    /// document. Currently global. TODO: Store individual exports in a BTreeMap
+    /// sorted by position in the source?
+    pub library_symbols: HashSet<String>,
+
     // Whether or not we're inside of a formula.
     pub in_formula: bool,
 
@@ -69,13 +78,15 @@ impl Default for DiagnosticsConfig {
 }
 
 impl<'a> DiagnosticContext<'a> {
-    pub fn new(contents: &'a Rope) -> Self {
+    pub fn new(contents: &'a Rope, library: &'a crate::lsp::inputs::library::Library) -> Self {
         Self {
             contents,
             document_symbols: Vec::new(),
             session_symbols: HashSet::new(),
             workspace_symbols: HashSet::new(),
             installed_packages: HashSet::new(),
+            library,
+            library_symbols: HashSet::new(),
             in_formula: false,
             in_call_like_arguments: false,
         }
@@ -86,19 +97,25 @@ impl<'a> DiagnosticContext<'a> {
         symbols.insert(name.to_string(), location);
     }
 
-    pub fn has_definition(&mut self, name: &str) -> bool {
+    pub fn has_definition(&self, name: &str) -> bool {
         // First, check document symbols.
-        for symbols in self.document_symbols.iter() {
+        for symbols in &self.document_symbols {
             if symbols.contains_key(name) {
                 return true;
             }
         }
 
-        // Next, check workspace symbols.
+        // Then, check workspace symbols.
         if self.workspace_symbols.contains(name) {
             return true;
         }
 
+        // Finally, check library symbols from library() calls.
+        // TODO: Take `Node` and check by position.
+        if self.library_symbols.contains(name) {
+            return true;
+        }
+
         // Finally, check session symbols.
         self.session_symbols.contains(name)
     }
@@ -118,7 +135,7 @@ pub(crate) fn generate_diagnostics(doc: Document, state: WorldState) -> Vec<Diag
         return diagnostics;
     }
 
-    let mut context = DiagnosticContext::new(&doc.contents);
+    let mut context = DiagnosticContext::new(&doc.contents, &state.library);
 
     // Add a 'root' context for the document.
     context.document_symbols.push(HashMap::new());
@@ -780,6 +797,10 @@ fn recurse_call(
     let fun = fun.as_str();
 
     match fun {
+        "library" => {
+            // Track symbols exported by `library()` calls
+            handle_library_call(node, context, diagnostics)?;
+        },
         // default case: recurse into each argument
         _ => recurse_call_like_arguments_default(node, context, diagnostics)?,
     };
@@ -787,6 +808,53 @@ fn recurse_call(
     ().ok()
 }
 
+fn handle_library_call(
+    node: Node,
+    context: &mut DiagnosticContext,
+    diagnostics: &mut Vec<Diagnostic>,
+) -> anyhow::Result<()> {
+    // Get the arguments node
+    let Some(arguments) = node.child_by_field_name("arguments") else {
+        return Ok(());
+    };
+
+    // Find the first argument (package name)
+    let mut cursor = arguments.walk();
+    let mut children = arguments.children_by_field_name("argument", &mut cursor);
+
+    let Some(first_arg) = children.next() else {
+        return Ok(());
+    };
+
+    // Get the package name from the argument value
+    let Some(value) = first_arg.child_by_field_name("value") else {
+        return Ok(());
+    };
+
+    let package_name = if value.is_identifier() {
+        context.contents.node_slice(&value)?.to_string()
+    } else if value.is_string() {
+        // Remove quotes from string literal
+        let raw = context.contents.node_slice(&value)?.to_string();
+        raw.trim_matches('"').trim_matches('\'').to_string()
+    } else {
+        return Ok(());
+    };
+
+    // Try to get the package from the library
+    if let Some(package) = context.library.get(&package_name) {
+        // Add all exported symbols to library_symbols
+        for symbol in &package.namespace.exports {
+            context.library_symbols.insert(symbol.clone());
+        }
+    }
+
+    // Continue with default recursion to handle any other arguments
+    recurse_call_like_arguments_default(node, context, diagnostics)?;
+
+    Ok(())
+}
+
 fn recurse_subset_or_subset2(
     node: Node,
     context: &mut DiagnosticContext,
@@ -1455,4 +1523,92 @@ foo
             );
         })
     }
+
+    #[test]
+    fn test_library_static_exports() {
+        r_task(|| {
+            use std::path::PathBuf;
+
+            use crate::lsp::inputs::library::Library;
+            use crate::lsp::inputs::package::Description;
+            use crate::lsp::inputs::package::Namespace;
+            use crate::lsp::inputs::package::Package;
+
+            // `mockpkg` exports `foo` and `bar`
+            let namespace = Namespace {
+                exports: vec!["foo".to_string(), "bar".to_string()],
+                imports: vec![],
+                bulk_imports: vec![],
+            };
+            let description = Description {
+                name: "mockpkg".to_string(),
+                version: "1.0.0".to_string(),
+                depends: vec![],
+            };
+            let package = Package {
+                path: PathBuf::from("/mock/path"),
+                description,
+                namespace,
+            };
+
+            // Create a library with `mockpkg` installed
+            let library = Library::new(vec![]).insert("mockpkg", package);
+
+            // Simulate a search path with `library` in scope
+            let console_scopes = vec![vec!["library".to_string()]];
+
+            // Whereas `DEFAULT_STATE` contains base package attached, this world state
+            // only contains `mockpkg` as installed package and `library()` on
+            // the search path.
+            let state = WorldState {
+                library,
+                console_scopes,
+                ..Default::default()
+            };
+
+            // Test that exported symbols are recognized
+            let code = "
+                library(mockpkg)
+                foo()
+                bar
+            ";
+            let document = Document::new(code, None);
+            let diagnostics = generate_diagnostics(document, state.clone());
+
+            assert_eq!(diagnostics.len(), 0);
+
+            // Test that non-exported symbols still generate diagnostics
+            let code = "
+                library(mockpkg)
+                undefined()
+                also_undefined
+            ";
+            let document = Document::new(code, None);
+
+            let diagnostics = generate_diagnostics(document, state.clone());
+            assert_eq!(diagnostics.len(), 2);
+
+            assert!(diagnostics
+                .get(0)
+                .unwrap()
+                .message
+                .contains("No symbol named 'undefined' in scope"));
+            assert!(diagnostics
+                .get(1)
+                .unwrap()
+                .message
+                .contains("No symbol named 'also_undefined' in scope"));
+
+            // Test duplicate call
+            let code = "
+                library(mockpkg)
+                library(mockpkg)  # duplicate is fine
+                foo()
+                bar
+            ";
+            let document = Document::new(code, None);
+            let diagnostics = generate_diagnostics(document, state);
+            assert_eq!(diagnostics.len(), 0);
+        });
+    }
 }
diff --git a/crates/ark/src/lsp/diagnostics_syntax.rs b/crates/ark/src/lsp/diagnostics_syntax.rs
index 508bf8f96..b2e8e9c7e 100644
--- a/crates/ark/src/lsp/diagnostics_syntax.rs
+++ b/crates/ark/src/lsp/diagnostics_syntax.rs
@@ -312,7 +312,8 @@ mod tests {
 
     fn text_diagnostics(text: &str) -> Vec<Diagnostic> {
         let document = Document::new(text, None);
-        let context = DiagnosticContext::new(&document.contents);
+        let library = crate::lsp::inputs::library::Library::default();
+        let context = DiagnosticContext::new(&document.contents, &library);
         let diagnostics = syntax_diagnostics(document.ast.root_node(), &context).unwrap();
         diagnostics
     }
diff --git a/crates/ark/src/lsp/inputs/library.rs b/crates/ark/src/lsp/inputs/library.rs
index c4dfb3ecb..32192d749 100644
--- a/crates/ark/src/lsp/inputs/library.rs
+++ b/crates/ark/src/lsp/inputs/library.rs
@@ -59,6 +59,16 @@ impl Library {
         pkg
     }
 
+    /// Insert a package in the library for testing purposes.
+    #[cfg(test)]
+    pub fn insert(self, name: &str, package: Package) -> Self {
+        self.packages
+            .write()
+            .unwrap()
+            .insert(name.to_string(), Some(Arc::new(package)));
+        self
+    }
+
     fn load_package(&self, name: &str) -> anyhow::Result<Option<Package>> {
         for lib_path in self.library_paths.iter() {
             let package_path = lib_path.join(name);

From ae1cae6140057ce55ca835b06d8ad98d5256d99f Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Fri, 11 Jul 2025 11:30:14 +0200
Subject: [PATCH 07/14] Simplify argument extraction

---
 crates/ark/src/lsp/diagnostics.rs | 53 +++++++------------------
 crates/ark/src/lsp/traits/node.rs | 66 +++++++++++++++++++++++++++++--
 crates/ark/src/treesitter.rs      | 15 +++++++
 3 files changed, 92 insertions(+), 42 deletions(-)

diff --git a/crates/ark/src/lsp/diagnostics.rs b/crates/ark/src/lsp/diagnostics.rs
index 6c8d2d537..35b1a25ec 100644
--- a/crates/ark/src/lsp/diagnostics.rs
+++ b/crates/ark/src/lsp/diagnostics.rs
@@ -19,6 +19,7 @@ use tower_lsp::lsp_types::DiagnosticSeverity;
 use tree_sitter::Node;
 use tree_sitter::Range;
 
+use crate::lsp;
 use crate::lsp::declarations::top_level_declare;
 use crate::lsp::diagnostics_syntax::syntax_diagnostics;
 use crate::lsp::documents::Document;
@@ -26,6 +27,7 @@ use crate::lsp::encoding::convert_tree_sitter_range_to_lsp_range;
 use crate::lsp::indexer;
 use crate::lsp::inputs::library::Library;
 use crate::lsp::state::WorldState;
+use crate::lsp::traits::node::NodeExt;
 use crate::lsp::traits::rope::RopeExt;
 use crate::treesitter::node_has_error_or_missing;
 use crate::treesitter::BinaryOperatorType;
@@ -799,59 +801,34 @@ fn recurse_call(
     match fun {
         "library" => {
             // Track symbols exported by `library()` calls
-            handle_library_call(node, context, diagnostics)?;
+            handle_library_call(node, context)?;
         },
-        // default case: recurse into each argument
-        _ => recurse_call_like_arguments_default(node, context, diagnostics)?,
+        _ => {},
     };
 
+    // Continue with default recursion to handle any other arguments
+    recurse_call_like_arguments_default(node, context, diagnostics)?;
+
     ().ok()
 }
 
-fn handle_library_call(
-    node: Node,
-    context: &mut DiagnosticContext,
-    diagnostics: &mut Vec<Diagnostic>,
-) -> anyhow::Result<()> {
-    // Get the arguments node
-    let Some(arguments) = node.child_by_field_name("arguments") else {
-        return Ok(());
-    };
-
-    // Find the first argument (package name)
-    let mut cursor = arguments.walk();
-    let mut children = arguments.children_by_field_name("argument", &mut cursor);
-
-    let Some(first_arg) = children.next() else {
-        return Ok(());
-    };
-
-    // Get the package name from the argument value
-    let Some(value) = first_arg.child_by_field_name("value") else {
-        return Ok(());
+fn handle_library_call(node: Node, context: &mut DiagnosticContext) -> anyhow::Result<()> {
+    // Find the first argument (package name). Positionally for now.
+    let Some(value) = node.arguments_values().nth(0) else {
+        return Err(anyhow::anyhow!("Can't unpack `library()` argument"));
     };
 
-    let package_name = if value.is_identifier() {
-        context.contents.node_slice(&value)?.to_string()
-    } else if value.is_string() {
-        // Remove quotes from string literal
-        let raw = context.contents.node_slice(&value)?.to_string();
-        raw.trim_matches('"').trim_matches('\'').to_string()
-    } else {
-        return Ok(());
-    };
+    let package_name = value.get_identifier_or_string_text(context.contents)?;
 
-    // Try to get the package from the library
+    // Insert exports globablly for now
     if let Some(package) = context.library.get(&package_name) {
-        // Add all exported symbols to library_symbols
         for symbol in &package.namespace.exports {
             context.library_symbols.insert(symbol.clone());
         }
+    } else {
+        lsp::log_warn!("Can't get exports from package {package_name} because it is not installed.")
     }
 
-    // Continue with default recursion to handle any other arguments
-    recurse_call_like_arguments_default(node, context, diagnostics)?;
-
     Ok(())
 }
 
diff --git a/crates/ark/src/lsp/traits/node.rs b/crates/ark/src/lsp/traits/node.rs
index bac6c38d6..5cd1500a2 100644
--- a/crates/ark/src/lsp/traits/node.rs
+++ b/crates/ark/src/lsp/traits/node.rs
@@ -90,6 +90,9 @@ pub trait NodeExt: Sized {
     fn bwd_leaf_iter(&self) -> BwdLeafIterator<'_>;
 
     fn ancestors(&self) -> impl Iterator<Item = Self>;
+    fn children_of(node: Self) -> impl Iterator<Item = Self>;
+    fn next_siblings(&self) -> impl Iterator<Item = Self>;
+    fn arguments_values(&self) -> impl Iterator<Item = Self>;
 }
 
 impl<'tree> NodeExt for Node<'tree> {
@@ -199,13 +202,68 @@ impl<'tree> NodeExt for Node<'tree> {
         BwdLeafIterator { node: *self }
     }
 
-    // From rowan. Note that until we switch to rowan, each `parent()` call
-    // causes a linear traversal of the whole tree to find the parent node.
-    // We could do better in the future:
-    // https://github.com/tree-sitter/tree-sitter/pull/3214
     fn ancestors(&self) -> impl Iterator<Item = Node<'tree>> {
+        // We'd ideally use the cursor API here too but
+        // `ts_tree_cursor_goto_parent()` doesn't behave like
+        // `ts_node_parent()`: the latter traverses `ERROR` nodes but not the
+        // former. So for now we accept the performance hit of tree traversal at
+        // each `parent()` call.
         std::iter::successors(Some(*self), |p| p.parent())
     }
+
+    fn next_siblings(&self) -> impl Iterator<Item = Node<'tree>> {
+        let mut cursor = self.walk();
+
+        let first = if cursor.goto_next_sibling() {
+            Some(cursor.node())
+        } else {
+            None
+        };
+
+        std::iter::successors(first, move |_| {
+            if cursor.goto_next_sibling() {
+                Some(cursor.node())
+            } else {
+                None
+            }
+        })
+    }
+
+    fn children_of(node: Node<'tree>) -> impl Iterator<Item = Node<'tree>> {
+        let mut cursor = node.walk();
+        let mut first = true;
+
+        std::iter::from_fn(move || {
+            let advanced = if first {
+                first = false;
+                cursor.goto_first_child()
+            } else {
+                cursor.goto_next_sibling()
+            };
+
+            if advanced {
+                Some(cursor.node())
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Takes a call node and iterates over the values of its arguments
+    fn arguments_values(&self) -> impl Iterator<Item = Node<'tree>> {
+        self.child_by_field_name("arguments")
+            // Create iterator that unpacks Option with `flat_map()`
+            .into_iter()
+            .flat_map(Self::children_of)
+            .filter_map(|node| {
+                // This takes care of non-argument nodes like `(` and `)`
+                if node.kind() == "argument" {
+                    node.child_by_field_name("value")
+                } else {
+                    None
+                }
+            })
+    }
 }
 
 /// First, recurse through children to find the smallest
diff --git a/crates/ark/src/treesitter.rs b/crates/ark/src/treesitter.rs
index cfa5875c8..67c29ac61 100644
--- a/crates/ark/src/treesitter.rs
+++ b/crates/ark/src/treesitter.rs
@@ -283,6 +283,7 @@ pub trait NodeTypeExt: Sized {
     fn is_identifier(&self) -> bool;
     fn is_string(&self) -> bool;
     fn is_identifier_or_string(&self) -> bool;
+    fn get_identifier_or_string_text(&self, contents: &ropey::Rope) -> anyhow::Result<String>;
     fn is_keyword(&self) -> bool;
     fn is_call(&self) -> bool;
     fn is_subset(&self) -> bool;
@@ -325,6 +326,20 @@ impl NodeTypeExt for Node<'_> {
         matches!(self.node_type(), NodeType::Identifier | NodeType::String)
     }
 
+    fn get_identifier_or_string_text(&self, contents: &ropey::Rope) -> anyhow::Result<String> {
+        match self.node_type() {
+            NodeType::Identifier => return Ok(contents.node_slice(self)?.to_string()),
+            NodeType::String => {
+                // Remove quotes from string literal
+                let string = contents.node_slice(self)?.to_string();
+                Ok(string.trim_matches('"').trim_matches('\'').to_string())
+            },
+            _ => {
+                return Err(anyhow::anyhow!("Not an identifier or string"));
+            },
+        }
+    }
+
     fn is_keyword(&self) -> bool {
         matches!(
             self.node_type(),

From 5bdc6412c87bb2da671fed818da2648ba12e682d Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Fri, 11 Jul 2025 15:20:38 +0200
Subject: [PATCH 08/14] Take into account position of `library()` calls

---
 crates/ark/src/lsp/diagnostics.rs | 121 +++++++++++++++++++++++++-----
 1 file changed, 104 insertions(+), 17 deletions(-)

diff --git a/crates/ark/src/lsp/diagnostics.rs b/crates/ark/src/lsp/diagnostics.rs
index 35b1a25ec..9831d858e 100644
--- a/crates/ark/src/lsp/diagnostics.rs
+++ b/crates/ark/src/lsp/diagnostics.rs
@@ -5,6 +5,7 @@
 //
 //
 
+use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::HashSet;
 
@@ -17,6 +18,7 @@ use stdext::*;
 use tower_lsp::lsp_types::Diagnostic;
 use tower_lsp::lsp_types::DiagnosticSeverity;
 use tree_sitter::Node;
+use tree_sitter::Point;
 use tree_sitter::Range;
 
 use crate::lsp;
@@ -64,7 +66,7 @@ pub struct DiagnosticContext<'a> {
     /// The symbols exported by packages loaded via `library()` calls in this
     /// document. Currently global. TODO: Store individual exports in a BTreeMap
     /// sorted by position in the source?
-    pub library_symbols: HashSet<String>,
+    pub library_symbols: BTreeMap<Point, HashSet<String>>,
 
     // Whether or not we're inside of a formula.
     pub in_formula: bool,
@@ -88,7 +90,7 @@ impl<'a> DiagnosticContext<'a> {
             workspace_symbols: HashSet::new(),
             installed_packages: HashSet::new(),
             library,
-            library_symbols: HashSet::new(),
+            library_symbols: BTreeMap::new(),
             in_formula: false,
             in_call_like_arguments: false,
         }
@@ -99,8 +101,8 @@ impl<'a> DiagnosticContext<'a> {
         symbols.insert(name.to_string(), location);
     }
 
-    pub fn has_definition(&self, name: &str) -> bool {
-        // First, check document symbols.
+    // First, check document symbols.
+    pub fn has_definition(&self, name: &str, start_position: Point) -> bool {
         for symbols in &self.document_symbols {
             if symbols.contains_key(name) {
                 return true;
@@ -112,10 +114,15 @@ impl<'a> DiagnosticContext<'a> {
             return true;
         }
 
-        // Finally, check library symbols from library() calls.
-        // TODO: Take `Node` and check by position.
-        if self.library_symbols.contains(name) {
-            return true;
+        // Finally, check package symbols from `library()` calls.
+        // Check all symbols exported by `library()` before the given position.
+        for (library_position, exports) in self.library_symbols.iter() {
+            if *library_position > start_position {
+                break;
+            }
+            if exports.contains(name) {
+                return true;
+            }
         }
 
         // Finally, check session symbols.
@@ -823,7 +830,12 @@ fn handle_library_call(node: Node, context: &mut DiagnosticContext) -> anyhow::R
     // Insert exports globablly for now
     if let Some(package) = context.library.get(&package_name) {
         for symbol in &package.namespace.exports {
-            context.library_symbols.insert(symbol.clone());
+            let pos = node.end_position();
+            context
+                .library_symbols
+                .entry(pos)
+                .or_insert_with(HashSet::new)
+                .insert(symbol.clone());
         }
     } else {
         lsp::log_warn!("Can't get exports from package {package_name} because it is not installed.")
@@ -990,7 +1002,7 @@ fn check_symbol_in_scope(
 
     // Skip if a symbol with this name is in scope.
     let name = context.contents.node_slice(&node)?.to_string();
-    if context.has_definition(name.as_str()) {
+    if context.has_definition(name.as_str(), node.start_position()) {
         return false.ok();
     }
 
@@ -1008,6 +1020,8 @@ fn check_symbol_in_scope(
 
 #[cfg(test)]
 mod tests {
+    use std::path::PathBuf;
+
     use harp::eval::RParseEvalOptions;
     use once_cell::sync::Lazy;
     use tower_lsp::lsp_types::Position;
@@ -1015,6 +1029,10 @@ mod tests {
     use crate::interface::console_inputs;
     use crate::lsp::diagnostics::generate_diagnostics;
     use crate::lsp::documents::Document;
+    use crate::lsp::inputs::library::Library;
+    use crate::lsp::inputs::package::Description;
+    use crate::lsp::inputs::package::Namespace;
+    use crate::lsp::inputs::package::Package;
     use crate::lsp::state::WorldState;
     use crate::r_task;
 
@@ -1504,13 +1522,6 @@ foo
     #[test]
     fn test_library_static_exports() {
         r_task(|| {
-            use std::path::PathBuf;
-
-            use crate::lsp::inputs::library::Library;
-            use crate::lsp::inputs::package::Description;
-            use crate::lsp::inputs::package::Namespace;
-            use crate::lsp::inputs::package::Package;
-
             // `mockpkg` exports `foo` and `bar`
             let namespace = Namespace {
                 exports: vec!["foo".to_string(), "bar".to_string()],
@@ -1588,4 +1599,80 @@ foo
             assert_eq!(diagnostics.len(), 0);
         });
     }
+
+    #[test]
+    fn test_library_static_exports_multiple_packages() {
+        r_task(|| {
+            // pkg1 exports `foo` and `bar`
+            let namespace1 = Namespace {
+                exports: vec!["foo".to_string(), "bar".to_string()],
+                imports: vec![],
+                bulk_imports: vec![],
+            };
+            let description1 = Description {
+                name: "pkg1".to_string(),
+                version: "1.0.0".to_string(),
+                depends: vec![],
+            };
+            let package1 = Package {
+                path: PathBuf::from("/mock/path1"),
+                description: description1,
+                namespace: namespace1,
+            };
+
+            // pkg2 exports `bar` and `baz`
+            let namespace2 = Namespace {
+                exports: vec!["bar".to_string(), "baz".to_string()],
+                imports: vec![],
+                bulk_imports: vec![],
+            };
+            let description2 = Description {
+                name: "pkg2".to_string(),
+                version: "1.0.0".to_string(),
+                depends: vec![],
+            };
+            let package2 = Package {
+                path: PathBuf::from("/mock/path2"),
+                description: description2,
+                namespace: namespace2,
+            };
+
+            let library = Library::new(vec![])
+                .insert("pkg1", package1)
+                .insert("pkg2", package2);
+
+            let console_scopes = vec![vec!["library".to_string()]];
+            let state = WorldState {
+                library,
+                console_scopes,
+                ..Default::default()
+            };
+
+            // Code with two library calls at different points
+            let code = "
+                    foo           # not in scope
+                    bar           # not in scope
+                    baz           # not in scope
+
+                    library(pkg1)
+                    foo           # in scope
+                    bar           # in scope
+                    baz           # not in scope
+
+                    library(pkg2)
+                    foo           # in scope
+                    bar           # in scope
+                    baz           # in scope
+                ";
+            let document = Document::new(code, None);
+            let diagnostics = generate_diagnostics(document, state.clone());
+
+            let messages: Vec<_> = diagnostics.iter().map(|d| d.message.clone()).collect();
+            assert!(messages.iter().any(|m| m.contains("No symbol named 'foo'")));
+            assert!(messages.iter().any(|m| m.contains("No symbol named 'bar'")));
+            assert!(messages.iter().any(|m| m.contains("No symbol named 'baz'")));
+            assert!(messages.iter().any(|m| m.contains("No symbol named 'baz'")));
+            assert_eq!(messages.len(), 4);
+        });
+    }
 }

From b1800b52b255a9a04ff78d5cf8b5435d786fed9d Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Fri, 11 Jul 2025 15:38:42 +0200
Subject: [PATCH 09/14] Support `require()` too

---
 crates/ark/src/lsp/diagnostics.rs | 56 +++++++++++++++++++++++++++----
 1 file changed, 50 insertions(+), 6 deletions(-)

diff --git a/crates/ark/src/lsp/diagnostics.rs b/crates/ark/src/lsp/diagnostics.rs
index 9831d858e..ed5c064e6 100644
--- a/crates/ark/src/lsp/diagnostics.rs
+++ b/crates/ark/src/lsp/diagnostics.rs
@@ -806,9 +806,9 @@ fn recurse_call(
     let fun = fun.as_str();
 
     match fun {
-        "library" => {
-            // Track symbols exported by `library()` calls
-            handle_library_call(node, context)?;
+        "library" | "require" => {
+            // Track symbols exported by `library()` or `require()` calls
+            handle_package_attach_call(node, context)?;
         },
         _ => {},
     };
@@ -819,15 +819,15 @@ fn recurse_call(
     ().ok()
 }
 
-fn handle_library_call(node: Node, context: &mut DiagnosticContext) -> anyhow::Result<()> {
+fn handle_package_attach_call(node: Node, context: &mut DiagnosticContext) -> anyhow::Result<()> {
     // Find the first argument (package name). Positionally for now.
     let Some(value) = node.arguments_values().nth(0) else {
-        return Err(anyhow::anyhow!("Can't unpack `library()` argument"));
+        return Err(anyhow::anyhow!("Can't unpack attached package argument"));
     };
 
     let package_name = value.get_identifier_or_string_text(context.contents)?;
 
-    // Insert exports globablly for now
+    // Insert exports for the attached package
     if let Some(package) = context.library.get(&package_name) {
         for symbol in &package.namespace.exports {
             let pos = node.end_position();
@@ -1675,4 +1675,48 @@ foo
             assert_eq!(messages.len(), 4);
         });
     }
+
+    #[test]
+    fn test_library_static_exports_require() {
+        r_task(|| {
+            // `pkg` exports `foo` and `bar`
+            let namespace = Namespace {
+                exports: vec!["foo".to_string(), "bar".to_string()],
+                imports: vec![],
+                bulk_imports: vec![],
+            };
+            let description = Description {
+                name: "pkg".to_string(),
+                version: "1.0.0".to_string(),
+                depends: vec![],
+            };
+            let package = Package {
+                path: PathBuf::from("/mock/path"),
+                description,
+                namespace,
+            };
+
+            let library = Library::new(vec![]).insert("pkg", package);
+
+            let console_scopes = vec![vec!["require".to_string()]];
+            let state = WorldState {
+                library,
+                console_scopes,
+                ..Default::default()
+            };
+
+            let code = "
+                    foo()
+                    require(pkg)
+                    bar
+                    foo()
+                ";
+            let document = Document::new(code, None);
+            let diagnostics = generate_diagnostics(document, state.clone());
+            assert!(diagnostics
+                .iter()
+                .any(|d| d.message.contains("No symbol named 'foo'")));
+            assert_eq!(diagnostics.len(), 1);
+        });
+    }
 }

From ecd2463e2f32fe3fd7b408cfba17e3f043aa3a57 Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Fri, 11 Jul 2025 15:58:34 +0200
Subject: [PATCH 10/14] Parse `DESCRIPTION` files

---
 crates/ark/src/lsp/diagnostics.rs             | 100 +++++++-
 crates/ark/src/lsp/inputs/library.rs          |  45 +---
 crates/ark/src/lsp/inputs/mod.rs              |   2 +
 crates/ark/src/lsp/inputs/package.rs          | 180 +++----------
 .../ark/src/lsp/inputs/package_description.rs | 236 ++++++++++++++++++
 .../ark/src/lsp/inputs/package_namespace.rs   | 159 ++++++++++++
 6 files changed, 522 insertions(+), 200 deletions(-)
 create mode 100644 crates/ark/src/lsp/inputs/package_description.rs
 create mode 100644 crates/ark/src/lsp/inputs/package_namespace.rs

diff --git a/crates/ark/src/lsp/diagnostics.rs b/crates/ark/src/lsp/diagnostics.rs
index ed5c064e6..8a19e7e8f 100644
--- a/crates/ark/src/lsp/diagnostics.rs
+++ b/crates/ark/src/lsp/diagnostics.rs
@@ -8,6 +8,7 @@
 use std::collections::BTreeMap;
 use std::collections::HashMap;
 use std::collections::HashSet;
+use std::sync::Arc;
 
 use anyhow::bail;
 use anyhow::Result;
@@ -28,6 +29,7 @@ use crate::lsp::documents::Document;
 use crate::lsp::encoding::convert_tree_sitter_range_to_lsp_range;
 use crate::lsp::indexer;
 use crate::lsp::inputs::library::Library;
+use crate::lsp::inputs::package::Package;
 use crate::lsp::state::WorldState;
 use crate::lsp::traits::node::NodeExt;
 use crate::lsp::traits::rope::RopeExt;
@@ -826,24 +828,91 @@ fn handle_package_attach_call(node: Node, context: &mut DiagnosticContext) -> an
     };
 
     let package_name = value.get_identifier_or_string_text(context.contents)?;
+    let attach_pos = node.end_position();
 
-    // Insert exports for the attached package
-    if let Some(package) = context.library.get(&package_name) {
-        for symbol in &package.namespace.exports {
-            let pos = node.end_position();
-            context
-                .library_symbols
-                .entry(pos)
-                .or_insert_with(HashSet::new)
-                .insert(symbol.clone());
+    let package = match insert_package_exports(&package_name, attach_pos, context) {
+        Ok(package) => package,
+        Err(err) => {
+            lsp::log_warn!("{err:?}");
+            return Ok(());
+        },
+    };
+
+    // Also attach packages from `Depends` field
+    let mut attach_dependencies = package.description.depends.clone();
+
+    // Special handling for the tidyverse and tidymodels packages. Hard-coded
+    // for now but in the future, this should probably be expressed as a
+    // `DESCRIPTION` field like `Config/Needs/attach`.
+    let attach_field = match package.description.name.as_str() {
+        // https://github.com/tidyverse/tidyverse/blob/0231aafb/R/attach.R#L1
+        "tidyverse" => {
+            vec![
+                "dplyr",
+                "readr",
+                "forcats",
+                "stringr",
+                "ggplot2",
+                "tibble",
+                "lubridate",
+                "tidyr",
+                "purrr",
+            ]
+        },
+        // https://github.com/tidymodels/tidymodels/blob/aa3f82cf/R/attach.R#L1
+        "tidymodels" => {
+            vec![
+                "broom",
+                "dials",
+                "dplyr",
+                "ggplot2",
+                "infer",
+                "modeldata",
+                "parsnip",
+                "purrr",
+                "recipes",
+                "rsample",
+                "tibble",
+                "tidyr",
+                "tune",
+                "workflows",
+                "workflowsets",
+                "yardstick",
+            ]
+        },
+        _ => vec![],
+    };
+    attach_dependencies.extend(attach_field.into_iter().map(String::from));
+
+    for package_name in attach_dependencies {
+        if let Err(err) = insert_package_exports(&package_name, attach_pos, context) {
+            lsp::log_warn!("{err:?}");
         }
-    } else {
-        lsp::log_warn!("Can't get exports from package {package_name} because it is not installed.")
     }
 
     Ok(())
 }
 
+fn insert_package_exports(
+    package_name: &str,
+    attach_pos: Point,
+    context: &mut DiagnosticContext,
+) -> anyhow::Result<Arc<Package>> {
+    let Some(package) = context.library.get(package_name) else {
+        return Err(anyhow::anyhow!(
+            "Can't get exports from package {package_name} because it is not installed."
+        ));
+    };
+
+    context
+        .library_symbols
+        .entry(attach_pos)
+        .or_default()
+        .extend(package.namespace.exports.iter().cloned());
+
+    Ok(package)
+}
+
 fn recurse_subset_or_subset2(
     node: Node,
     context: &mut DiagnosticContext,
@@ -1030,9 +1099,10 @@ mod tests {
     use crate::lsp::diagnostics::generate_diagnostics;
     use crate::lsp::documents::Document;
     use crate::lsp::inputs::library::Library;
-    use crate::lsp::inputs::package::Description;
-    use crate::lsp::inputs::package::Namespace;
     use crate::lsp::inputs::package::Package;
+    use crate::lsp::inputs::package_description::Dcf;
+    use crate::lsp::inputs::package_description::Description;
+    use crate::lsp::inputs::package_namespace::Namespace;
     use crate::lsp::state::WorldState;
     use crate::r_task;
 
@@ -1532,6 +1602,7 @@ foo
                 name: "mockpkg".to_string(),
                 version: "1.0.0".to_string(),
                 depends: vec![],
+                fields: Dcf::new(),
             };
             let package = Package {
                 path: PathBuf::from("/mock/path"),
@@ -1613,6 +1684,7 @@ foo
                 name: "pkg1".to_string(),
                 version: "1.0.0".to_string(),
                 depends: vec![],
+                fields: Dcf::new(),
             };
             let package1 = Package {
                 path: PathBuf::from("/mock/path1"),
@@ -1630,6 +1702,7 @@ foo
                 name: "pkg2".to_string(),
                 version: "1.0.0".to_string(),
                 depends: vec![],
+                fields: Dcf::new(),
             };
             let package2 = Package {
                 path: PathBuf::from("/mock/path2"),
@@ -1689,6 +1762,7 @@ foo
                 name: "pkg".to_string(),
                 version: "1.0.0".to_string(),
                 depends: vec![],
+                fields: Dcf::new(),
             };
             let package = Package {
                 path: PathBuf::from("/mock/path"),
diff --git a/crates/ark/src/lsp/inputs/library.rs b/crates/ark/src/lsp/inputs/library.rs
index 32192d749..40d600477 100644
--- a/crates/ark/src/lsp/inputs/library.rs
+++ b/crates/ark/src/lsp/inputs/library.rs
@@ -5,15 +5,12 @@
 //
 
 use std::collections::HashMap;
-use std::fs;
 use std::path::PathBuf;
 use std::sync::Arc;
 use std::sync::RwLock;
 
 use super::package::Package;
 use crate::lsp;
-use crate::lsp::inputs::package::Description;
-use crate::lsp::inputs::package::Namespace;
 
 /// Lazily manages a list of known R packages by name
 #[derive(Default, Clone, Debug)]
@@ -71,33 +68,11 @@ impl Library {
 
     fn load_package(&self, name: &str) -> anyhow::Result<Option<Package>> {
         for lib_path in self.library_paths.iter() {
-            let package_path = lib_path.join(name);
-            let description_path = package_path.join("DESCRIPTION");
-            let namespace_path = package_path.join("NAMESPACE");
-
-            // Only consider libraries that have a folder named after the
-            // requested package and that contains a description file
-            if !description_path.is_file() {
-                continue;
+            match Package::load(&lib_path, name) {
+                Ok(Some(pkg)) => return Ok(Some(pkg)),
+                Ok(None) => (),
+                Err(err) => lsp::log_warn!("Can't load package: {err:?}"),
             }
-
-            // TODO
-            // let _desc_contents = fs::read_to_string(&description_path)?;
-
-            let description = Description {
-                name: name.to_string(),
-                version: "unknown".to_string(),
-                depends: vec![],
-            };
-
-            let namespace_contents = fs::read_to_string(&namespace_path)?;
-            let namespace = Namespace::parse(&namespace_contents)?;
-
-            return Ok(Some(Package {
-                path: package_path,
-                description,
-                namespace,
-            }));
         }
 
         Ok(None)
@@ -139,13 +114,13 @@ mod tests {
     fn test_load_and_cache_package() {
         let pkg_name = "mypkg";
         let description = r#"
-            Package: mypkg
-            Version: 1.0
+Package: mypkg
+Version: 1.0
         "#;
         let namespace = r#"
-            export(foo)
-            export(bar)
-            importFrom(pkg, baz)
+export(foo)
+export(bar)
+importFrom(pkg, baz)
         "#;
 
         let (temp_dir, _pkg_dir) = create_temp_package(pkg_name, description, namespace);
@@ -154,7 +129,7 @@ mod tests {
         let lib = Library::new(vec![temp_dir.path().to_path_buf()]);
 
         // First access loads from disk
-        let pkg = lib.get(pkg_name).expect("should load package");
+        let pkg = lib.get(pkg_name).unwrap();
         assert_eq!(pkg.description.name, "mypkg");
 
         // Second access uses cache (note that we aren't testing that we are
diff --git a/crates/ark/src/lsp/inputs/mod.rs b/crates/ark/src/lsp/inputs/mod.rs
index 3d4952b81..cfe7854fa 100644
--- a/crates/ark/src/lsp/inputs/mod.rs
+++ b/crates/ark/src/lsp/inputs/mod.rs
@@ -7,4 +7,6 @@
 
 pub mod library;
 pub mod package;
+pub mod package_description;
+pub mod package_namespace;
 pub mod source_root;
diff --git a/crates/ark/src/lsp/inputs/package.rs b/crates/ark/src/lsp/inputs/package.rs
index fe035e92c..5dd9c2d69 100644
--- a/crates/ark/src/lsp/inputs/package.rs
+++ b/crates/ark/src/lsp/inputs/package.rs
@@ -5,11 +5,11 @@
 //
 //
 
+use std::fs;
 use std::path::PathBuf;
 
-use tree_sitter::Parser;
-
-use crate::treesitter::TSQuery;
+use crate::lsp::inputs::package_description::Description;
+use crate::lsp::inputs::package_namespace::Namespace;
 
 /// Represents an R package and its metadata relevant for static analysis.
 #[derive(Clone, Debug)]
@@ -22,162 +22,38 @@ pub struct Package {
     pub namespace: Namespace,
 }
 
-/// Parsed DESCRIPTION file
-#[derive(Clone, Debug)]
-pub struct Description {
-    pub name: String,
-    pub version: String,
-
-    /// `Depends` field
-    pub depends: Vec<String>,
-}
+impl Package {
+    /// Attempts to load a package from the given path and name.
+    pub fn load(lib_path: &std::path::Path, name: &str) -> anyhow::Result<Option<Self>> {
+        let package_path = lib_path.join(name);
 
-/// Parsed NAMESPACE file
-#[derive(Clone, Debug)]
-pub struct Namespace {
-    /// Names of objects exported with `export()`
-    pub exports: Vec<String>,
-    /// Names of objects imported with `importFrom()`
-    pub imports: Vec<String>,
-    /// Names of packages bulk-imported with `import()`
-    pub bulk_imports: Vec<String>,
-}
+        let description_path = package_path.join("DESCRIPTION");
+        let namespace_path = package_path.join("NAMESPACE");
 
-impl Namespace {
-    /// Parse a NAMESPACE file using tree-sitter to extract exports and imports.
-    pub fn parse(contents: &str) -> anyhow::Result<Self> {
-        let mut parser = Parser::new();
-        parser
-            .set_language(&tree_sitter_r::LANGUAGE.into())
-            .map_err(|err| anyhow::anyhow!("Failed to set tree-sitter language: {err:?}"))?;
-
-        let tree = parser
-            .parse(contents, None)
-            .ok_or_else(|| anyhow::anyhow!("Failed to parse NAMESPACE file"))?;
-        let root_node = tree.root_node();
-
-        let query_str = r#"
-            (call
-                function: (identifier) @fn_name
-                arguments: (arguments (argument value: (identifier) @exported))
-                (#eq? @fn_name "export")
-            )
-            (call
-                function: (identifier) @fn_name
-                arguments: (arguments (argument value: (identifier) @pkg) (argument value: (identifier) @imported))
-                (#eq? @fn_name "importFrom")
-            )
-            (call
-                function: (identifier) @fn_name
-                arguments: (arguments (argument value: (identifier) @bulk_imported))
-                (#eq? @fn_name "import")
-            )
-        "#;
-        let mut ts_query = TSQuery::new(query_str)?;
-
-        let mut exports = Vec::new();
-        for capture in ts_query.captures_for(root_node, "exported", contents.as_bytes()) {
-            let symbol = capture
-                .utf8_text(contents.as_bytes())
-                .unwrap_or("")
-                .to_string();
-            exports.push(symbol);
+        // Only consider libraries that have a folder named after the
+        // requested package and that contains a description file
+        if !description_path.is_file() {
+            return Ok(None);
         }
 
-        let mut imports = Vec::new();
-        for capture in ts_query.captures_for(root_node, "imported", contents.as_bytes()) {
-            let symbol = capture
-                .utf8_text(contents.as_bytes())
-                .unwrap_or("")
-                .to_string();
-            imports.push(symbol);
-        }
+        // This fails if there is no `Package` field, so we're never loading
+        // folders like bookdown projects as package
+        let description_contents = fs::read_to_string(&description_path)?;
+        let description = Description::parse(&description_contents)?;
 
-        let mut bulk_imports = Vec::new();
-        for capture in ts_query.captures_for(root_node, "bulk_imported", contents.as_bytes()) {
-            let symbol = capture
-                .utf8_text(contents.as_bytes())
-                .unwrap_or("")
-                .to_string();
-            bulk_imports.push(symbol);
+        if description.name != name {
+            return Err(anyhow::anyhow!(
+                "`Package` field in `DESCRIPTION` doesn't match folder name '{name}'"
+            ));
         }
 
-        // Take unique values of imports and exports. In the future we'll lint
-        // this but for now just be defensive.
-        exports.sort();
-        exports.dedup();
-        imports.sort();
-        imports.dedup();
-        bulk_imports.sort();
-        bulk_imports.dedup();
-
-        Ok(Namespace {
-            imports,
-            exports,
-            bulk_imports,
-        })
-    }
-
-    /// TODO: Take a `Library` and incorporate bulk imports
-    pub(crate) fn _resolve_imports(&self) -> &Vec<String> {
-        &self.imports
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn parses_exports() {
-        let ns = r#"
-            export(foo)
-            export(bar)
-            exports(baz) # typo
-        "#;
-        let parsed = Namespace::parse(ns).unwrap();
-        assert_eq!(parsed.exports, vec!["bar", "foo"]);
-        assert!(parsed.imports.is_empty());
-    }
-
-    #[test]
-    fn parses_importfrom() {
-        let ns = r#"
-            importFrom(stats, median)
-            importFrom(utils, head)
-            importsFrom(utils, tail) # typo
-        "#;
-        let parsed = Namespace::parse(ns).unwrap();
-        assert_eq!(parsed.imports, vec!["head", "median"]);
-        assert!(parsed.exports.is_empty());
-    }
-
-    #[test]
-    fn parses_mixed_namespace_with_duplicates() {
-        let ns = r#"
-            export(foo)
-            importFrom(stats, median)
-            export(bar)
-            importFrom(utils, head)
-            importFrom(utils, median)
-        "#;
-        let parsed = Namespace::parse(ns).unwrap();
-        assert_eq!(parsed.exports, vec!["bar", "foo"]);
-        assert_eq!(parsed.imports, vec!["head", "median"]);
-    }
+        let namespace_contents = fs::read_to_string(&namespace_path)?;
+        let namespace = Namespace::parse(&namespace_contents)?;
 
-    #[test]
-    fn parses_bulk_imports() {
-        let ns = r#"
-                import(rlang)
-                import(utils)
-                export(foo)
-                import(utils)
-                importFrom(stats, median)
-            "#;
-        let parsed = Namespace::parse(ns).unwrap();
-        assert_eq!(parsed.bulk_imports, vec!["rlang", "utils"]);
-        assert_eq!(parsed.exports, vec!["foo"]);
-        assert_eq!(parsed.imports, vec!["median"]);
+        Ok(Some(Package {
+            path: package_path.to_path_buf(),
+            description,
+            namespace,
+        }))
     }
 }
diff --git a/crates/ark/src/lsp/inputs/package_description.rs b/crates/ark/src/lsp/inputs/package_description.rs
new file mode 100644
index 000000000..1d42f223f
--- /dev/null
+++ b/crates/ark/src/lsp/inputs/package_description.rs
@@ -0,0 +1,236 @@
+//
+// package_description.rs
+//
+// Copyright (C) 2025 by Posit Software, PBC
+//
+
+use std::collections::HashMap;
+
+use anyhow;
+
+/// Parsed DCF file (Debian Control File, e.g. DESCRIPTION). Simple wrapper
+/// around the map of fields whose `get()` method returns a `&str` that's easier
+/// to work with.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Dcf {
+    pub fields: HashMap<String, String>,
+}
+
+impl Dcf {
+    pub fn new() -> Self {
+        Dcf {
+            fields: HashMap::new(),
+        }
+    }
+
+    pub fn parse(input: &str) -> Self {
+        Dcf {
+            fields: parse_dcf(input),
+        }
+    }
+
+    /// Get a field value by key
+    pub fn get(&self, key: &str) -> Option<&str> {
+        self.fields.get(key).map(|s| s.as_str())
+    }
+}
+
+/// Parsed DESCRIPTION file
+#[derive(Clone, Debug)]
+pub struct Description {
+    pub name: String,
+    pub version: String,
+
+    /// `Depends` field. Currently doesn't contain versions.
+    pub depends: Vec<String>,
+
+    /// Raw DCF fields
+    pub fields: Dcf,
+}
+
+impl Description {
+    /// Parse a DESCRIPTION file in DCF format
+    pub fn parse(contents: &str) -> anyhow::Result<Self> {
+        let fields = Dcf::parse(contents);
+
+        let name = fields
+            .get("Package")
+            .ok_or_else(|| anyhow::anyhow!("Missing Package field in DESCRIPTION"))?
+            .to_string();
+
+        let version = fields
+            .get("Version")
+            .ok_or_else(|| anyhow::anyhow!("Missing Version field in DESCRIPTION"))?
+            .to_string();
+
+        let depends = fields
+            .get("Depends")
+            .and_then(|deps| {
+                let mut pkgs = parse_comma_separated(deps);
+
+                // Remove dependency on R. In the future we will record it to a field with
+                // the minimum version the package depends on.
+                pkgs.retain(|pkg| pkg != "R");
+
+                Some(pkgs)
+            })
+            .unwrap_or_default();
+
+        Ok(Description {
+            name,
+            version,
+            depends,
+            fields,
+        })
+    }
+}
+
+/// Parse a DCF (Debian Control File) format string into a key-value map.
+/// https://www.debian.org/doc/debian-policy/ch-controlfields.html
+fn parse_dcf(input: &str) -> std::collections::HashMap<String, String> {
+    use std::collections::HashMap;
+
+    let mut fields = HashMap::new();
+    let mut current_key: Option<String> = None;
+    let mut current_value = String::new();
+
+    for line in input.lines() {
+        // Indented line: This is a continuation, even if empty
+        if line.starts_with(char::is_whitespace) {
+            current_value.push_str(line);
+            current_value.push('\n');
+            continue;
+        }
+
+        // Non-whitespace at start and contains a colon: This is a new field
+        if !line.is_empty() && line.contains(':') {
+            // Save previous field
+            if let Some(key) = current_key.take() {
+                fields.insert(key, current_value.trim_end().to_string());
+            }
+
+            let idx = line.find(':').unwrap();
+            let key = line[..idx].trim().to_string();
+            let value = line[idx + 1..].trim_start();
+
+            current_key = Some(key);
+
+            current_value.clear();
+            current_value.push_str(value);
+            current_value.push('\n');
+
+            continue;
+        }
+    }
+
+    // Finish last field
+    if let Some(key) = current_key {
+        fields.insert(key, current_value.trim_end().to_string());
+    }
+
+    fields
+}
+
+/// Parse a comma-separated list of package dependencies
+fn parse_comma_separated(input: &str) -> Vec<String> {
+    input
+        .split(',')
+        .map(|s| s.trim())
+        .filter(|s| !s.is_empty())
+        .map(|s| {
+            // Remove version constraints like "R (>= 3.5.0)"
+            if let Some(idx) = s.find('(') {
+                s[..idx].trim().to_string()
+            } else {
+                s.to_string()
+            }
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_description_basic() {
+        let desc = r#"Package: mypackage
+Version: 1.0.0
+Title: My Package
+Description: A simple package for testing."#;
+        let parsed = Description::parse(desc).unwrap();
+        assert_eq!(parsed.name, "mypackage");
+        assert_eq!(parsed.version, "1.0.0");
+        assert!(parsed.depends.is_empty());
+    }
+
+    #[test]
+    fn parses_description_with_depends() {
+        let desc = r#"Package: mypackage
+Version: 1.0.0
+Depends: R (>= 3.5.0), utils, stats
+Title: My Package"#;
+        let parsed = Description::parse(desc).unwrap();
+        assert_eq!(parsed.name, "mypackage");
+        assert_eq!(parsed.version, "1.0.0");
+        assert_eq!(parsed.depends, vec!["utils", "stats"]);
+    }
+
+    #[test]
+    fn parses_description_with_multiline_field() {
+        let desc = r#"Package: mypackage
+Version: 1.0.0
+Description: This is a long description
+ that spans multiple lines
+ and should be preserved correctly."#;
+        let parsed = Description::parse(desc).unwrap();
+        assert_eq!(parsed.name, "mypackage");
+        assert_eq!(parsed.version, "1.0.0");
+    }
+
+    #[test]
+    fn parses_dcf_basic() {
+        let dcf = r#"Package: mypackage
+Version: 1.0.0
+Title: My Package
+Description: A simple package for testing."#;
+        let parsed = Dcf::parse(dcf);
+        assert_eq!(parsed.get("Package"), Some("mypackage"));
+        assert_eq!(parsed.get("Version"), Some("1.0.0"));
+        assert_eq!(parsed.get("Title"), Some("My Package"));
+        assert_eq!(
+            parsed.get("Description"),
+            Some("A simple package for testing.")
+        );
+    }
+
+    #[test]
+    fn parses_dcf_multiline_field() {
+        let dcf = r#"Package: mypackage
+Version: 1.0.0
+Description: This is a long description
+ that spans multiple lines
+ and should be preserved correctly."#;
+        let parsed = Dcf::parse(dcf);
+        assert_eq!(
+            parsed.get("Description"),
+            Some("This is a long description\n that spans multiple lines\n and should be preserved correctly.")
+        );
+    }
+
+    // Empty lines are ignored in DCF files. They are supported via a dot
+    // notation (` .` represents an empty line) bug we don't support that.
+    #[test]
+    fn parses_dcf_empty_continuation_line() {
+        let dcf = r#"Package: mypackage
+Description: First line
+ second line
+
+ third line"#;
+        let parsed = Dcf::parse(dcf);
+        assert_eq!(
+            parsed.get("Description"),
+            Some("First line\n second line\n third line")
+        );
+    }
+}
diff --git a/crates/ark/src/lsp/inputs/package_namespace.rs b/crates/ark/src/lsp/inputs/package_namespace.rs
new file mode 100644
index 000000000..64b7e8e5d
--- /dev/null
+++ b/crates/ark/src/lsp/inputs/package_namespace.rs
@@ -0,0 +1,159 @@
+//
+// package_namespace.rs
+//
+// Copyright (C) 2025 by Posit Software, PBC
+//
+
+use tree_sitter::Parser;
+
+use crate::treesitter::TSQuery;
+
+/// Parsed NAMESPACE file
+#[derive(Clone, Debug)]
+pub struct Namespace {
+    /// Names of objects exported with `export()`
+    pub exports: Vec<String>,
+    /// Names of objects imported with `importFrom()`
+    pub imports: Vec<String>,
+    /// Names of packages bulk-imported with `import()`
+    pub bulk_imports: Vec<String>,
+}
+
+impl Namespace {
+    /// Parse a NAMESPACE file using tree-sitter to extract exports and imports.
+    pub fn parse(contents: &str) -> anyhow::Result<Self> {
+        let mut parser = Parser::new();
+        parser
+            .set_language(&tree_sitter_r::LANGUAGE.into())
+            .map_err(|err| anyhow::anyhow!("Failed to set tree-sitter language: {err:?}"))?;
+
+        let tree = parser
+            .parse(contents, None)
+            .ok_or_else(|| anyhow::anyhow!("Failed to parse NAMESPACE file"))?;
+        let root_node = tree.root_node();
+
+        let query_str = r#"
+            (call
+                function: (identifier) @fn_name
+                arguments: (arguments (argument value: (identifier) @exported))
+                (#eq? @fn_name "export")
+            )
+            (call
+                function: (identifier) @fn_name
+                arguments: (arguments (argument value: (identifier) @pkg) (argument value: (identifier) @imported))
+                (#eq? @fn_name "importFrom")
+            )
+            (call
+                function: (identifier) @fn_name
+                arguments: (arguments (argument value: (identifier) @bulk_imported))
+                (#eq? @fn_name "import")
+            )
+        "#;
+        let mut ts_query = TSQuery::new(query_str)?;
+
+        let mut exports = Vec::new();
+        for capture in ts_query.captures_for(root_node, "exported", contents.as_bytes()) {
+            let symbol = capture
+                .utf8_text(contents.as_bytes())
+                .unwrap_or("")
+                .to_string();
+            exports.push(symbol);
+        }
+
+        let mut imports = Vec::new();
+        for capture in ts_query.captures_for(root_node, "imported", contents.as_bytes()) {
+            let symbol = capture
+                .utf8_text(contents.as_bytes())
+                .unwrap_or("")
+                .to_string();
+            imports.push(symbol);
+        }
+
+        let mut bulk_imports = Vec::new();
+        for capture in ts_query.captures_for(root_node, "bulk_imported", contents.as_bytes()) {
+            let symbol = capture
+                .utf8_text(contents.as_bytes())
+                .unwrap_or("")
+                .to_string();
+            bulk_imports.push(symbol);
+        }
+
+        // Take unique values of imports and exports. In the future we'll lint
+        // this but for now just be defensive.
+        exports.sort();
+        exports.dedup();
+        imports.sort();
+        imports.dedup();
+        bulk_imports.sort();
+        bulk_imports.dedup();
+
+        Ok(Namespace {
+            imports,
+            exports,
+            bulk_imports,
+        })
+    }
+
+    /// TODO: Take a `Library` and incorporate bulk imports
+    pub(crate) fn _resolve_imports(&self) -> &Vec<String> {
+        &self.imports
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_exports() {
+        let ns = r#"
+            export(foo)
+            export(bar)
+            exports(baz) # typo
+        "#;
+        let parsed = Namespace::parse(ns).unwrap();
+        assert_eq!(parsed.exports, vec!["bar", "foo"]);
+        assert!(parsed.imports.is_empty());
+    }
+
+    #[test]
+    fn parses_importfrom() {
+        let ns = r#"
+            importFrom(stats, median)
+            importFrom(utils, head)
+            importsFrom(utils, tail) # typo
+        "#;
+        let parsed = Namespace::parse(ns).unwrap();
+        assert_eq!(parsed.imports, vec!["head", "median"]);
+        assert!(parsed.exports.is_empty());
+    }
+
+    #[test]
+    fn parses_mixed_namespace_with_duplicates() {
+        let ns = r#"
+            export(foo)
+            importFrom(stats, median)
+            export(bar)
+            importFrom(utils, head)
+            importFrom(utils, median)
+        "#;
+        let parsed = Namespace::parse(ns).unwrap();
+        assert_eq!(parsed.exports, vec!["bar", "foo"]);
+        assert_eq!(parsed.imports, vec!["head", "median"]);
+    }
+
+    #[test]
+    fn parses_bulk_imports() {
+        let ns = r#"
+                import(rlang)
+                import(utils)
+                export(foo)
+                import(utils)
+                importFrom(stats, median)
+            "#;
+        let parsed = Namespace::parse(ns).unwrap();
+        assert_eq!(parsed.bulk_imports, vec!["rlang", "utils"]);
+        assert_eq!(parsed.exports, vec!["foo"]);
+        assert_eq!(parsed.imports, vec!["median"]);
+    }
+}

From 297a62cc28fa803fc447cb7b38e79fe521e672f5 Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Mon, 14 Jul 2025 09:43:32 +0200
Subject: [PATCH 11/14] Extract `arguments()` iterator from
 `arguments_values()`

---
 crates/ark/src/lsp/traits/node.rs | 32 ++++++++++++++++++++++++-------
 1 file changed, 25 insertions(+), 7 deletions(-)

diff --git a/crates/ark/src/lsp/traits/node.rs b/crates/ark/src/lsp/traits/node.rs
index 5cd1500a2..96a00779d 100644
--- a/crates/ark/src/lsp/traits/node.rs
+++ b/crates/ark/src/lsp/traits/node.rs
@@ -92,7 +92,9 @@ pub trait NodeExt: Sized {
     fn ancestors(&self) -> impl Iterator<Item = Self>;
     fn children_of(node: Self) -> impl Iterator<Item = Self>;
     fn next_siblings(&self) -> impl Iterator<Item = Self>;
+    fn arguments(&self) -> impl Iterator<Item = (Option<Self>, Option<Self>)>;
     fn arguments_values(&self) -> impl Iterator<Item = Self>;
+    fn arguments_names(&self) -> impl Iterator<Item = Self>;
 }
 
 impl<'tree> NodeExt for Node<'tree> {
@@ -249,21 +251,37 @@ impl<'tree> NodeExt for Node<'tree> {
         })
     }
 
-    /// Takes a call node and iterates over the values of its arguments
-    fn arguments_values(&self) -> impl Iterator<Item = Node<'tree>> {
+    /// Iterator over argument names and values. Either of `name` and `value`
+    /// may be absent, but not both.
+    fn arguments(&self) -> impl Iterator<Item = (Option<Node<'tree>>, Option<Node<'tree>>)> {
         self.child_by_field_name("arguments")
             // Create iterator that unpacks Option with `flat_map()`
             .into_iter()
             .flat_map(Self::children_of)
             .filter_map(|node| {
-                // This takes care of non-argument nodes like `(` and `)`
-                if node.kind() == "argument" {
-                    node.child_by_field_name("value")
-                } else {
-                    None
+                if node.kind() != "argument" {
+                    return None;
                 }
+
+                let name = node.child_by_field_name("name");
+                let value = node.child_by_field_name("value");
+
+                // Likely not possible but just in case
+                if value.is_none() && name.is_none() {
+                    return None;
+                }
+
+                Some((name, value))
             })
     }
+
+    fn arguments_names(&self) -> impl Iterator<Item = Node<'tree>> {
+        self.arguments().filter_map(|(name, _value)| name)
+    }
+
+    fn arguments_values(&self) -> impl Iterator<Item = Node<'tree>> {
+        self.arguments().filter_map(|(_name, value)| value)
+    }
 }
 
 /// First, recurse through children to find the smallest

From 8383aaae51e63b42e4f4b838d176ef0131105f1c Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Mon, 14 Jul 2025 09:57:13 +0200
Subject: [PATCH 12/14] Bail when `character.only` is supplied

---
 crates/ark/src/lsp/diagnostics.rs | 37 +++++++++++++++++++++++++++----
 crates/ark/src/lsp/traits/node.rs | 14 ++++++++++++
 2 files changed, 47 insertions(+), 4 deletions(-)

diff --git a/crates/ark/src/lsp/diagnostics.rs b/crates/ark/src/lsp/diagnostics.rs
index 8a19e7e8f..a7475cca6 100644
--- a/crates/ark/src/lsp/diagnostics.rs
+++ b/crates/ark/src/lsp/diagnostics.rs
@@ -822,12 +822,23 @@ fn recurse_call(
 }
 
 fn handle_package_attach_call(node: Node, context: &mut DiagnosticContext) -> anyhow::Result<()> {
-    // Find the first argument (package name). Positionally for now.
-    let Some(value) = node.arguments_values().nth(0) else {
+    // Find the first argument (package name). Positionally for now, no attempt
+    // at argument matching whatsoever.
+    let Some(package_node) = node.arguments_values().nth(0) else {
         return Err(anyhow::anyhow!("Can't unpack attached package argument"));
     };
 
-    let package_name = value.get_identifier_or_string_text(context.contents)?;
+    // Just bail if `character.only` is passed, even if it's actually `FALSE`.
+    // We'll do better when we have a more capable argument inspection
+    // infrastructure.
+    if let Some(_) = node
+        .arguments_names_as_string(context.contents)
+        .find(|n| n == "character.only")
+    {
+        return Ok(());
+    }
+
+    let package_name = package_node.get_identifier_or_string_text(context.contents)?;
     let attach_pos = node.end_position();
 
     let package = match insert_package_exports(&package_name, attach_pos, context) {
@@ -1666,8 +1677,26 @@ foo
                 bar
             ";
             let document = Document::new(code, None);
-            let diagnostics = generate_diagnostics(document, state);
+            let diagnostics = generate_diagnostics(document, state.clone());
             assert_eq!(diagnostics.len(), 0);
+
+            // If the library call includes the `character.only` argument, we bail
+            let code = r#"
+                library(mockpkg, character.only = TRUE)
+                foo()
+            "#;
+            let document = Document::new(code, None);
+            let diagnostics = generate_diagnostics(document, state.clone());
+            assert_eq!(diagnostics.len(), 1);
+
+            // Same if passed `FALSE`, we're not trying to be smart (yet)
+            let code = r#"
+                library(mockpkg, character.only = FALSE)
+                foo()
+            "#;
+            let document = Document::new(code, None);
+            let diagnostics = generate_diagnostics(document, state);
+            assert_eq!(diagnostics.len(), 1);
         });
     }
 
diff --git a/crates/ark/src/lsp/traits/node.rs b/crates/ark/src/lsp/traits/node.rs
index 96a00779d..50b34b279 100644
--- a/crates/ark/src/lsp/traits/node.rs
+++ b/crates/ark/src/lsp/traits/node.rs
@@ -11,6 +11,7 @@ use tree_sitter::Range;
 use tree_sitter::TreeCursor;
 
 use crate::lsp::traits::point::PointExt;
+use crate::lsp::traits::rope::RopeExt;
 
 fn _dump_impl(cursor: &mut TreeCursor, source: &str, indent: &str, output: &mut String) {
     let node = cursor.node();
@@ -95,6 +96,7 @@ pub trait NodeExt: Sized {
     fn arguments(&self) -> impl Iterator<Item = (Option<Self>, Option<Self>)>;
     fn arguments_values(&self) -> impl Iterator<Item = Self>;
     fn arguments_names(&self) -> impl Iterator<Item = Self>;
+    fn arguments_names_as_string(&self, contents: &ropey::Rope) -> impl Iterator<Item = String>;
 }
 
 impl<'tree> NodeExt for Node<'tree> {
@@ -279,6 +281,18 @@ impl<'tree> NodeExt for Node<'tree> {
         self.arguments().filter_map(|(name, _value)| name)
     }
 
+    fn arguments_names_as_string(&self, contents: &ropey::Rope) -> impl Iterator<Item = String> {
+        self.arguments_names().filter_map(|node| -> Option<String> {
+            match contents.node_slice(&node) {
+                Err(err) => {
+                    tracing::error!("Can't convert argument name to text: {err:?}");
+                    None
+                },
+                Ok(text) => Some(text.to_string()),
+            }
+        })
+    }
+
     fn arguments_values(&self) -> impl Iterator<Item = Node<'tree>> {
         self.arguments().filter_map(|(_name, value)| value)
     }

From 9092ac0a840850f9965be4438cce76fbb22910bb Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Mon, 14 Jul 2025 10:01:05 +0200
Subject: [PATCH 13/14] Warn outside of `handle_package_attach_call()`

---
 crates/ark/src/lsp/diagnostics.rs | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/crates/ark/src/lsp/diagnostics.rs b/crates/ark/src/lsp/diagnostics.rs
index a7475cca6..3d71093d2 100644
--- a/crates/ark/src/lsp/diagnostics.rs
+++ b/crates/ark/src/lsp/diagnostics.rs
@@ -810,7 +810,9 @@ fn recurse_call(
     match fun {
         "library" | "require" => {
             // Track symbols exported by `library()` or `require()` calls
-            handle_package_attach_call(node, context)?;
+            if let Err(err) = handle_package_attach_call(node, context) {
+                lsp::log_warn!("Can't handle attach call: {err:?}");
+            }
         },
         _ => {},
     };
@@ -841,13 +843,7 @@ fn handle_package_attach_call(node: Node, context: &mut DiagnosticContext) -> an
     let package_name = package_node.get_identifier_or_string_text(context.contents)?;
     let attach_pos = node.end_position();
 
-    let package = match insert_package_exports(&package_name, attach_pos, context) {
-        Ok(package) => package,
-        Err(err) => {
-            lsp::log_warn!("{err:?}");
-            return Ok(());
-        },
-    };
+    let package = insert_package_exports(&package_name, attach_pos, context)?;
 
     // Also attach packages from `Depends` field
     let mut attach_dependencies = package.description.depends.clone();
@@ -896,9 +892,7 @@ fn handle_package_attach_call(node: Node, context: &mut DiagnosticContext) -> an
     attach_dependencies.extend(attach_field.into_iter().map(String::from));
 
     for package_name in attach_dependencies {
-        if let Err(err) = insert_package_exports(&package_name, attach_pos, context) {
-            lsp::log_warn!("{err:?}");
-        }
+        insert_package_exports(&package_name, attach_pos, context)?;
     }
 
     Ok(())

From 915e4d1b23c01a92696e2f451912ab3cf8288960 Mon Sep 17 00:00:00 2001
From: Lionel Henry <lionel.hry@proton.me>
Date: Tue, 15 Jul 2025 15:57:08 +0200
Subject: [PATCH 14/14] Fix typos

---
 crates/ark/src/lsp/diagnostics.rs        | 11 +++++------
 crates/ark/src/lsp/diagnostics_syntax.rs |  3 ++-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/crates/ark/src/lsp/diagnostics.rs b/crates/ark/src/lsp/diagnostics.rs
index 3d71093d2..8dee0c2f1 100644
--- a/crates/ark/src/lsp/diagnostics.rs
+++ b/crates/ark/src/lsp/diagnostics.rs
@@ -84,7 +84,7 @@ impl Default for DiagnosticsConfig {
 }
 
 impl<'a> DiagnosticContext<'a> {
-    pub fn new(contents: &'a Rope, library: &'a crate::lsp::inputs::library::Library) -> Self {
+    pub fn new(contents: &'a Rope, library: &'a Library) -> Self {
         Self {
             contents,
             document_symbols: Vec::new(),
@@ -103,21 +103,20 @@ impl<'a> DiagnosticContext<'a> {
         symbols.insert(name.to_string(), location);
     }
 
-    // First, check document symbols.
     pub fn has_definition(&self, name: &str, start_position: Point) -> bool {
+        // Check document symbols
         for symbols in &self.document_symbols {
             if symbols.contains_key(name) {
                 return true;
             }
         }
 
-        // Then, check workspace symbols.
+        // Check workspace symbols
         if self.workspace_symbols.contains(name) {
             return true;
         }
 
-        // Finally, check package symbols from `library()` calls.
-        // Check all symbols exported by `library()` before the given position.
+        // Check all symbols exported by `library()` calls before the given position
         for (library_position, exports) in self.library_symbols.iter() {
             if *library_position > start_position {
                 break;
@@ -127,7 +126,7 @@ impl<'a> DiagnosticContext<'a> {
             }
         }
 
-        // Finally, check session symbols.
+        // Finally, check session symbols
         self.session_symbols.contains(name)
     }
 }
diff --git a/crates/ark/src/lsp/diagnostics_syntax.rs b/crates/ark/src/lsp/diagnostics_syntax.rs
index b2e8e9c7e..aa9bef605 100644
--- a/crates/ark/src/lsp/diagnostics_syntax.rs
+++ b/crates/ark/src/lsp/diagnostics_syntax.rs
@@ -309,10 +309,11 @@ mod tests {
     use crate::lsp::diagnostics::DiagnosticContext;
     use crate::lsp::diagnostics_syntax::syntax_diagnostics;
     use crate::lsp::documents::Document;
+    use crate::lsp::inputs::library::Library;
 
     fn text_diagnostics(text: &str) -> Vec<Diagnostic> {
         let document = Document::new(text, None);
-        let library = crate::lsp::inputs::library::Library::default();
+        let library = Library::default();
         let context = DiagnosticContext::new(&document.contents, &library);
         let diagnostics = syntax_diagnostics(document.ast.root_node(), &context).unwrap();
         diagnostics