feat(extraction): R language support (#828) (#839)

R has no declaration syntax — everything is an expression — so the
extractor works through the visitNode hook: functions in every
assignment form (incl. nested, attributed to their enclosing scope),
top-level variables/constants, library()/require() imports and
source() file references (claimed, Lua-style), S4/RefClass/R6/ggproto
classes with their methods and extends edges, setGeneric/setMethod.
Grammar vendored from r-lib/tree-sitter-r v1.2.0 (ABI 14; npm package
is a security placeholder, tree-sitter-wasms has no R).

Benchmarked on AnomalyDetection (8/8 named defs), dplyr (1027 fns),
ggplot2 (150 ggproto classes / 597 methods / 128 extends edges —
adding ggproto mid-bench flipped the large-repo A/B from a regression
to 2.4x faster than the no-codegraph arm).

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

.claude/skills/agent-eval/corpus.json

@@ -1,98 +1,427 @@
 {
   "_comment": "Test corpus for /agent-eval. Add entries freely. size: Small (<~150 files), Medium (~150-1500), Large (>~1500). 'question' is a representative architectural question that exercises cross-file understanding.",
   "TypeScript": [
-    { "name": "ky", "repo": "https://github.com/sindresorhus/ky", "size": "Small", "files": "~25", "question": "How does ky implement request retries and timeouts?" },
-    { "name": "excalidraw", "repo": "https://github.com/excalidraw/excalidraw", "size": "Medium", "files": "~600", "question": "How does Excalidraw render and update canvas elements?" },
-    { "name": "vscode", "repo": "https://github.com/microsoft/vscode", "size": "Large", "files": "~10000", "question": "How does the extension host communicate with the main process?" }
+    {
+      "name": "ky",
+      "repo": "https://github.com/sindresorhus/ky",
+      "size": "Small",
+      "files": "~25",
+      "question": "How does ky implement request retries and timeouts?"
+    },
+    {
+      "name": "excalidraw",
+      "repo": "https://github.com/excalidraw/excalidraw",
+      "size": "Medium",
+      "files": "~600",
+      "question": "How does Excalidraw render and update canvas elements?"
+    },
+    {
+      "name": "vscode",
+      "repo": "https://github.com/microsoft/vscode",
+      "size": "Large",
+      "files": "~10000",
+      "question": "How does the extension host communicate with the main process?"
+    }
   ],
   "JavaScript": [
-    { "name": "express", "repo": "https://github.com/expressjs/express", "size": "Small", "files": "~50", "question": "How does Express route a request through its middleware stack?" }
+    {
+      "name": "express",
+      "repo": "https://github.com/expressjs/express",
+      "size": "Small",
+      "files": "~50",
+      "question": "How does Express route a request through its middleware stack?"
+    }
   ],
   "Go": [
-    { "name": "cobra", "repo": "https://github.com/spf13/cobra", "size": "Small", "files": "~50", "question": "How does cobra parse commands and flags?" },
-    { "name": "gin", "repo": "https://github.com/gin-gonic/gin", "size": "Medium", "files": "~150", "question": "How does gin route requests through its middleware chain?" },
-    { "name": "terraform", "repo": "https://github.com/hashicorp/terraform", "size": "Large", "files": "~4000", "question": "How does Terraform build and walk the resource dependency graph?" },
-    { "name": "cosmos-sdk", "repo": "https://github.com/cosmos/cosmos-sdk", "size": "Large", "files": "~5000", "question": "How does a bank module MsgSend message reach the account balance update? Trace the cross-module call path from the bank keeper's Send handler through to the account/balance store update." }
+    {
+      "name": "cobra",
+      "repo": "https://github.com/spf13/cobra",
+      "size": "Small",
+      "files": "~50",
+      "question": "How does cobra parse commands and flags?"
+    },
+    {
+      "name": "gin",
+      "repo": "https://github.com/gin-gonic/gin",
+      "size": "Medium",
+      "files": "~150",
+      "question": "How does gin route requests through its middleware chain?"
+    },
+    {
+      "name": "terraform",
+      "repo": "https://github.com/hashicorp/terraform",
+      "size": "Large",
+      "files": "~4000",
+      "question": "How does Terraform build and walk the resource dependency graph?"
+    },
+    {
+      "name": "cosmos-sdk",
+      "repo": "https://github.com/cosmos/cosmos-sdk",
+      "size": "Large",
+      "files": "~5000",
+      "question": "How does a bank module MsgSend message reach the account balance update? Trace the cross-module call path from the bank keeper's Send handler through to the account/balance store update."
+    }
   ],
   "Python": [
-    { "name": "click", "repo": "https://github.com/pallets/click", "size": "Small", "files": "~60", "question": "How does click parse command-line arguments into commands?" },
-    { "name": "flask", "repo": "https://github.com/pallets/flask", "size": "Medium", "files": "~90", "question": "How does Flask dispatch a request to a view function?" },
-    { "name": "django", "repo": "https://github.com/django/django", "size": "Large", "files": "~2700", "question": "How does Django's ORM build and execute a query from a QuerySet?" }
+    {
+      "name": "click",
+      "repo": "https://github.com/pallets/click",
+      "size": "Small",
+      "files": "~60",
+      "question": "How does click parse command-line arguments into commands?"
+    },
+    {
+      "name": "flask",
+      "repo": "https://github.com/pallets/flask",
+      "size": "Medium",
+      "files": "~90",
+      "question": "How does Flask dispatch a request to a view function?"
+    },
+    {
+      "name": "django",
+      "repo": "https://github.com/django/django",
+      "size": "Large",
+      "files": "~2700",
+      "question": "How does Django's ORM build and execute a query from a QuerySet?"
+    }
   ],
   "Rust": [
-    { "name": "clap", "repo": "https://github.com/clap-rs/clap", "size": "Medium", "files": "~200", "question": "How does clap parse arguments against a derived command definition?" },
-    { "name": "tokio", "repo": "https://github.com/tokio-rs/tokio", "size": "Large", "files": "~700", "question": "How does tokio schedule and run async tasks on its runtime?" },
-    { "name": "deno", "repo": "https://github.com/denoland/deno", "size": "Large", "files": "~1500", "question": "How does Deno load and execute a TypeScript module?" }
+    {
+      "name": "clap",
+      "repo": "https://github.com/clap-rs/clap",
+      "size": "Medium",
+      "files": "~200",
+      "question": "How does clap parse arguments against a derived command definition?"
+    },
+    {
+      "name": "tokio",
+      "repo": "https://github.com/tokio-rs/tokio",
+      "size": "Large",
+      "files": "~700",
+      "question": "How does tokio schedule and run async tasks on its runtime?"
+    },
+    {
+      "name": "deno",
+      "repo": "https://github.com/denoland/deno",
+      "size": "Large",
+      "files": "~1500",
+      "question": "How does Deno load and execute a TypeScript module?"
+    }
   ],
   "Java": [
-    { "name": "gson", "repo": "https://github.com/google/gson", "size": "Medium", "files": "~200", "question": "How does Gson serialize an object to JSON?" },
-    { "name": "okhttp", "repo": "https://github.com/square/okhttp", "size": "Medium", "files": "~640", "question": "How does OkHttp process a request through its interceptor chain?" },
-    { "name": "guava", "repo": "https://github.com/google/guava", "size": "Large", "files": "~3000", "question": "How does Guava's CacheBuilder build and configure a cache?" }
+    {
+      "name": "gson",
+      "repo": "https://github.com/google/gson",
+      "size": "Medium",
+      "files": "~200",
+      "question": "How does Gson serialize an object to JSON?"
+    },
+    {
+      "name": "okhttp",
+      "repo": "https://github.com/square/okhttp",
+      "size": "Medium",
+      "files": "~640",
+      "question": "How does OkHttp process a request through its interceptor chain?"
+    },
+    {
+      "name": "guava",
+      "repo": "https://github.com/google/guava",
+      "size": "Large",
+      "files": "~3000",
+      "question": "How does Guava's CacheBuilder build and configure a cache?"
+    }
   ],
   "Kotlin": [
-    { "name": "koin", "repo": "https://github.com/InsertKoinIO/koin", "size": "Medium", "files": "~300", "question": "How does Koin resolve and inject dependencies?" },
-    { "name": "leakcanary", "repo": "https://github.com/square/leakcanary", "size": "Medium", "files": "~250", "question": "How does LeakCanary detect and analyze a memory leak?" }
+    {
+      "name": "koin",
+      "repo": "https://github.com/InsertKoinIO/koin",
+      "size": "Medium",
+      "files": "~300",
+      "question": "How does Koin resolve and inject dependencies?"
+    },
+    {
+      "name": "leakcanary",
+      "repo": "https://github.com/square/leakcanary",
+      "size": "Medium",
+      "files": "~250",
+      "question": "How does LeakCanary detect and analyze a memory leak?"
+    }
   ],
   "Swift": [
-    { "name": "alamofire", "repo": "https://github.com/Alamofire/Alamofire", "size": "Small", "files": "~100", "question": "How does Alamofire build, send, and validate a request?" }
+    {
+      "name": "alamofire",
+      "repo": "https://github.com/Alamofire/Alamofire",
+      "size": "Small",
+      "files": "~100",
+      "question": "How does Alamofire build, send, and validate a request?"
+    }
   ],
   "C#": [
-    { "name": "serilog", "repo": "https://github.com/serilog/serilog", "size": "Medium", "files": "~250", "question": "How does Serilog route a log event to its sinks?" },
-    { "name": "jellyfin", "repo": "https://github.com/jellyfin/jellyfin", "size": "Large", "files": "~2500", "question": "How does Jellyfin scan and identify items in a media library?" }
+    {
+      "name": "serilog",
+      "repo": "https://github.com/serilog/serilog",
+      "size": "Medium",
+      "files": "~250",
+      "question": "How does Serilog route a log event to its sinks?"
+    },
+    {
+      "name": "jellyfin",
+      "repo": "https://github.com/jellyfin/jellyfin",
+      "size": "Large",
+      "files": "~2500",
+      "question": "How does Jellyfin scan and identify items in a media library?"
+    }
   ],
   "Ruby": [
-    { "name": "sinatra", "repo": "https://github.com/sinatra/sinatra", "size": "Small", "files": "~60", "question": "How does Sinatra match a request to a route handler?" },
-    { "name": "discourse", "repo": "https://github.com/discourse/discourse", "size": "Large", "files": "~3000", "question": "How does Discourse create and render a new post?" }
+    {
+      "name": "sinatra",
+      "repo": "https://github.com/sinatra/sinatra",
+      "size": "Small",
+      "files": "~60",
+      "question": "How does Sinatra match a request to a route handler?"
+    },
+    {
+      "name": "discourse",
+      "repo": "https://github.com/discourse/discourse",
+      "size": "Large",
+      "files": "~3000",
+      "question": "How does Discourse create and render a new post?"
+    }
   ],
   "PHP": [
-    { "name": "slim", "repo": "https://github.com/slimphp/Slim", "size": "Small", "files": "~80", "question": "How does Slim handle a request through its middleware?" },
-    { "name": "laravel", "repo": "https://github.com/laravel/framework", "size": "Large", "files": "~3000", "question": "How does Laravel resolve and dispatch a route to a controller?" }
+    {
+      "name": "slim",
+      "repo": "https://github.com/slimphp/Slim",
+      "size": "Small",
+      "files": "~80",
+      "question": "How does Slim handle a request through its middleware?"
+    },
+    {
+      "name": "laravel",
+      "repo": "https://github.com/laravel/framework",
+      "size": "Large",
+      "files": "~3000",
+      "question": "How does Laravel resolve and dispatch a route to a controller?"
+    }
   ],
   "C": [
-    { "name": "redis", "repo": "https://github.com/redis/redis", "size": "Large", "files": "~600", "question": "How does Redis parse and dispatch a client command?" }
+    {
+      "name": "redis",
+      "repo": "https://github.com/redis/redis",
+      "size": "Large",
+      "files": "~600",
+      "question": "How does Redis parse and dispatch a client command?"
+    }
   ],
   "C++": [
-    { "name": "json", "repo": "https://github.com/nlohmann/json", "size": "Small", "files": "~100", "question": "How does nlohmann::json parse a JSON string into a value?" },
-    { "name": "grpc", "repo": "https://github.com/grpc/grpc", "size": "Large", "files": "~3000", "question": "How does gRPC dispatch an incoming RPC to its handler?" }
+    {
+      "name": "json",
+      "repo": "https://github.com/nlohmann/json",
+      "size": "Small",
+      "files": "~100",
+      "question": "How does nlohmann::json parse a JSON string into a value?"
+    },
+    {
+      "name": "grpc",
+      "repo": "https://github.com/grpc/grpc",
+      "size": "Large",
+      "files": "~3000",
+      "question": "How does gRPC dispatch an incoming RPC to its handler?"
+    }
   ],
   "Dart": [
-    { "name": "flutter", "repo": "https://github.com/flutter/flutter", "size": "Large", "files": "~6000", "question": "How does Flutter build and lay out a widget tree?" }
+    {
+      "name": "flutter",
+      "repo": "https://github.com/flutter/flutter",
+      "size": "Large",
+      "files": "~6000",
+      "question": "How does Flutter build and lay out a widget tree?"
+    }
   ],
   "Svelte": [
-    { "name": "shadcn-svelte", "repo": "https://github.com/huntabyte/shadcn-svelte", "size": "Medium", "files": "~600", "question": "How do shadcn-svelte components compose and apply their styling?" }
+    {
+      "name": "shadcn-svelte",
+      "repo": "https://github.com/huntabyte/shadcn-svelte",
+      "size": "Medium",
+      "files": "~600",
+      "question": "How do shadcn-svelte components compose and apply their styling?"
+    }
   ],
   "Lua": [
-    { "name": "lualine.nvim", "repo": "https://github.com/nvim-lualine/lualine.nvim", "size": "Small", "files": "~120", "question": "How does lualine assemble and render its statusline sections and components?" },
-    { "name": "telescope.nvim", "repo": "https://github.com/nvim-telescope/telescope.nvim", "size": "Medium", "files": "~80", "question": "How does Telescope wire a picker to its finder, sorter, and previewer?" },
-    { "name": "kong", "repo": "https://github.com/Kong/kong", "size": "Large", "files": "~1330", "question": "How does Kong execute plugins across a request's lifecycle phases?" }
+    {
+      "name": "lualine.nvim",
+      "repo": "https://github.com/nvim-lualine/lualine.nvim",
+      "size": "Small",
+      "files": "~120",
+      "question": "How does lualine assemble and render its statusline sections and components?"
+    },
+    {
+      "name": "telescope.nvim",
+      "repo": "https://github.com/nvim-telescope/telescope.nvim",
+      "size": "Medium",
+      "files": "~80",
+      "question": "How does Telescope wire a picker to its finder, sorter, and previewer?"
+    },
+    {
+      "name": "kong",
+      "repo": "https://github.com/Kong/kong",
+      "size": "Large",
+      "files": "~1330",
+      "question": "How does Kong execute plugins across a request's lifecycle phases?"
+    }
   ],
   "Luau": [
-    { "name": "Knit", "repo": "https://github.com/Sleitnick/Knit", "size": "Small", "files": "~10", "question": "How does Knit register services and expose them to clients?" },
-    { "name": "vide", "repo": "https://github.com/centau/vide", "size": "Small", "files": "~40", "question": "How does vide track reactive sources and re-run effects when state changes?" },
-    { "name": "Fusion", "repo": "https://github.com/dphfox/Fusion", "size": "Medium", "files": "~115", "question": "How does Fusion build and update its reactive UI graph from state objects?" }
+    {
+      "name": "Knit",
+      "repo": "https://github.com/Sleitnick/Knit",
+      "size": "Small",
+      "files": "~10",
+      "question": "How does Knit register services and expose them to clients?"
+    },
+    {
+      "name": "vide",
+      "repo": "https://github.com/centau/vide",
+      "size": "Small",
+      "files": "~40",
+      "question": "How does vide track reactive sources and re-run effects when state changes?"
+    },
+    {
+      "name": "Fusion",
+      "repo": "https://github.com/dphfox/Fusion",
+      "size": "Medium",
+      "files": "~115",
+      "question": "How does Fusion build and update its reactive UI graph from state objects?"
+    }
   ],
   "Objective-C": [
-    { "name": "Masonry", "repo": "https://github.com/SnapKit/Masonry", "size": "Small", "files": "~50", "question": "How does Masonry build and activate Auto Layout constraints from its block DSL?" },
-    { "name": "FMDB", "repo": "https://github.com/ccgus/fmdb", "size": "Medium", "files": "~80", "question": "How does FMDB execute a prepared SQL statement and bind parameters?" },
-    { "name": "SDWebImage", "repo": "https://github.com/SDWebImage/SDWebImage", "size": "Large", "files": "~400", "question": "How does SDWebImage download, cache, and decode an image for a UIImageView?" }
+    {
+      "name": "Masonry",
+      "repo": "https://github.com/SnapKit/Masonry",
+      "size": "Small",
+      "files": "~50",
+      "question": "How does Masonry build and activate Auto Layout constraints from its block DSL?"
+    },
+    {
+      "name": "FMDB",
+      "repo": "https://github.com/ccgus/fmdb",
+      "size": "Medium",
+      "files": "~80",
+      "question": "How does FMDB execute a prepared SQL statement and bind parameters?"
+    },
+    {
+      "name": "SDWebImage",
+      "repo": "https://github.com/SDWebImage/SDWebImage",
+      "size": "Large",
+      "files": "~400",
+      "question": "How does SDWebImage download, cache, and decode an image for a UIImageView?"
+    }
   ],
   "Mixed iOS (Swift+ObjC)": [
-    { "name": "Charts", "repo": "https://github.com/danielgindi/Charts", "size": "Small", "files": "~270", "question": "How does the ChartsDemo ObjC demo controller drive the Swift Charts library to animate and notify a data update?" },
-    { "name": "realm-swift", "repo": "https://github.com/realm/realm-swift", "size": "Medium", "files": "~370", "question": "How does a Swift `Realm.write { realm.add(obj) }` reach the Objective-C persistence layer?" },
-    { "name": "wikipedia-ios", "repo": "https://github.com/wikimedia/wikipedia-ios", "size": "Large", "files": "~1700", "question": "How does tapping a search result reach the article-fetch network call across the Swift / ObjC boundary?" }
+    {
+      "name": "Charts",
+      "repo": "https://github.com/danielgindi/Charts",
+      "size": "Small",
+      "files": "~270",
+      "question": "How does the ChartsDemo ObjC demo controller drive the Swift Charts library to animate and notify a data update?"
+    },
+    {
+      "name": "realm-swift",
+      "repo": "https://github.com/realm/realm-swift",
+      "size": "Medium",
+      "files": "~370",
+      "question": "How does a Swift `Realm.write { realm.add(obj) }` reach the Objective-C persistence layer?"
+    },
+    {
+      "name": "wikipedia-ios",
+      "repo": "https://github.com/wikimedia/wikipedia-ios",
+      "size": "Large",
+      "files": "~1700",
+      "question": "How does tapping a search result reach the article-fetch network call across the Swift / ObjC boundary?"
+    }
   ],
   "React Native (legacy bridge + TurboModule)": [
-    { "name": "@react-native-async-storage", "repo": "https://github.com/react-native-async-storage/async-storage", "size": "Small", "files": "~60", "question": "How does `setItem` in JS reach the native `legacy_multiSet` implementation?" },
-    { "name": "react-native-svg", "repo": "https://github.com/software-mansion/react-native-svg", "size": "Medium", "files": "~700", "question": "How does a JS `Svg.getTotalLength(...)` reach the iOS / Android native implementation via TurboModule?" },
-    { "name": "react-native-firebase", "repo": "https://github.com/invertase/react-native-firebase", "size": "Large", "files": "~1100", "question": "How does a native iOS push notification reach the JS `messaging().onMessage(...)` listener?" }
+    {
+      "name": "@react-native-async-storage",
+      "repo": "https://github.com/react-native-async-storage/async-storage",
+      "size": "Small",
+      "files": "~60",
+      "question": "How does `setItem` in JS reach the native `legacy_multiSet` implementation?"
+    },
+    {
+      "name": "react-native-svg",
+      "repo": "https://github.com/software-mansion/react-native-svg",
+      "size": "Medium",
+      "files": "~700",
+      "question": "How does a JS `Svg.getTotalLength(...)` reach the iOS / Android native implementation via TurboModule?"
+    },
+    {
+      "name": "react-native-firebase",
+      "repo": "https://github.com/invertase/react-native-firebase",
+      "size": "Large",
+      "files": "~1100",
+      "question": "How does a native iOS push notification reach the JS `messaging().onMessage(...)` listener?"
+    }
   ],
   "Expo Modules": [
-    { "name": "expo-haptics", "repo": "https://github.com/expo/expo/tree/main/packages/expo-haptics", "size": "Small", "files": "~15", "question": "How does `Haptics.notificationAsync(...)` in JS reach `UINotificationFeedbackGenerator` in the Swift Module?" },
-    { "name": "expo-camera", "repo": "https://github.com/expo/expo/tree/main/packages/expo-camera", "size": "Medium", "files": "~70", "question": "How does a JS `CameraView.takePictureAsync(options)` reach the native AVCaptureSession / CameraDevice call?" }
+    {
+      "name": "expo-haptics",
+      "repo": "https://github.com/expo/expo/tree/main/packages/expo-haptics",
+      "size": "Small",
+      "files": "~15",
+      "question": "How does `Haptics.notificationAsync(...)` in JS reach `UINotificationFeedbackGenerator` in the Swift Module?"
+    },
+    {
+      "name": "expo-camera",
+      "repo": "https://github.com/expo/expo/tree/main/packages/expo-camera",
+      "size": "Medium",
+      "files": "~70",
+      "question": "How does a JS `CameraView.takePictureAsync(options)` reach the native AVCaptureSession / CameraDevice call?"
+    }
   ],
   "React Native Fabric (view components)": [
-    { "name": "react-native-segmented-control", "repo": "https://github.com/react-native-segmented-control/segmented-control", "size": "Small", "files": "~25", "question": "How does JSX `<SegmentedControl onChange={cb}/>` reach the native onChange handler on iOS/Android?" },
-    { "name": "react-native-screens", "repo": "https://github.com/software-mansion/react-native-screens", "size": "Medium", "files": "~1200", "question": "How does JSX `<ScreenStack>` reach the native RNSScreenStackView component?" },
-    { "name": "react-native-skia", "repo": "https://github.com/Shopify/react-native-skia", "size": "Large", "files": "~1000", "question": "How does a `<SkiaPictureView/>` JSX usage reach the iOS / Android native renderer?" }
+    {
+      "name": "react-native-segmented-control",
+      "repo": "https://github.com/react-native-segmented-control/segmented-control",
+      "size": "Small",
+      "files": "~25",
+      "question": "How does JSX `<SegmentedControl onChange={cb}/>` reach the native onChange handler on iOS/Android?"
+    },
+    {
+      "name": "react-native-screens",
+      "repo": "https://github.com/software-mansion/react-native-screens",
+      "size": "Medium",
+      "files": "~1200",
+      "question": "How does JSX `<ScreenStack>` reach the native RNSScreenStackView component?"
+    },
+    {
+      "name": "react-native-skia",
+      "repo": "https://github.com/Shopify/react-native-skia",
+      "size": "Large",
+      "files": "~1000",
+      "question": "How does a `<SkiaPictureView/>` JSX usage reach the iOS / Android native renderer?"
+    }
+  ],
+  "R": [
+    {
+      "name": "AnomalyDetection",
+      "repo": "https://github.com/twitter/AnomalyDetection",
+      "size": "Small",
+      "files": "~24",
+      "question": "How does AnomalyDetectionTs go from the exported entry function to the underlying S-H-ESD statistical test? Name the functions on the path in order."
+    },
+    {
+      "name": "dplyr",
+      "repo": "https://github.com/tidyverse/dplyr",
+      "size": "Medium",
+      "files": "~450",
+      "question": "When mutate() is called on a grouped data frame, which functions handle the grouping and expression evaluation, in order, from mutate() down?"
+    },
+    {
+      "name": "ggplot2",
+      "repo": "https://github.com/tidyverse/ggplot2",
+      "size": "Large",
+      "files": "~1150",
+      "question": "When a ggplot object is printed, how does the plot actually get built and drawn \u2014 trace the path from print/plot to where geoms render. Name the key functions in order."
+    }
   ]
-}
+}

CHANGELOG.md

@@ -16,6 +16,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### New Features
 
+- **CodeGraph now indexes R** (`.R` / `.r`) — functions in every assignment form (`name <- function(...)`, `name = function(...)`, nested definitions), S4 / Reference / R6 classes with their methods, `setGeneric`/`setMethod` generics, top-level variables and constants, `library()` / `require()` imports, `source()` file references, and call edges — including calls inside tidyverse pipe chains. Statistical and research codebases get the full explore / impact / callers surface. (#828) (R)
 - **Workspaces holding multiple git repositories now index as a whole.** Running `codegraph init` at the root of a directory that contains several independent git repos — including the common "super-repo" layout where the parent repo's `.gitignore` hides the child repos to keep `git status` quiet — now indexes every nested project into one graph, with each child repo's own `.gitignore` respected. `codegraph sync` and live file watching pick up changes inside the nested repos too (previously change detection only consulted the parent repo, so edits in child repos were invisible until a full re-index). Git repositories inside `node_modules` (npm git-dependencies) remain excluded. (#514)
 
 - **`codegraph_explore` now explains where a flow ends instead of going silent.** When the symbols you ask about don't connect statically — because the code dispatches through a runtime mechanism like a computed call (`handlers[action.type](...)`), Python's `getattr`, a command/mediator bus (`sender.Send(new DeleteCommand(...))`), reflection, or `new Proxy` — explore now announces the exact dispatch site (file and line) where the static path stops, and when the dispatch key is visible in the source it shortlists the likely runtime targets (for example pointing a MediatR command straight at its `Handler.Handle` method). Detection is deterministic and runs only when a flow fails to connect; fully connected flows are unchanged, and nothing about indexing or the graph itself changes. Relatedly, a custom event bus whose emit and handler connect through a single synthesized hop now shows that hop explicitly (with the registration site) — it previously rendered nothing because the connection was "too short" for the flow section. (#687)

README.md

@@ -225,7 +225,7 @@ CodeGraph cuts **tokens, tool calls, and wall-clock time on every repo** — acr
 | **Full-Text Search** | Find code by name instantly across your entire codebase, powered by FTS5 |
 | **Impact Analysis** | Trace callers, callees, and the full impact radius of any symbol before making changes |
 | **Always Fresh** | File watcher uses native OS events (FSEvents/inotify/ReadDirectoryChangesW) with debounced auto-sync — the graph stays current as you code, zero config |
-| **20+ Languages** | TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Objective-C, Swift, Kotlin, Scala, Dart, Lua, Luau, Svelte, Vue, Astro, Liquid, Pascal/Delphi |
+| **20+ Languages** | TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Objective-C, Swift, Kotlin, Scala, Dart, Lua, Luau, R, Svelte, Vue, Astro, Liquid, Pascal/Delphi |
 | **Framework-aware Routes** | Recognizes web-framework routing files and links URL patterns to their handlers across 17 frameworks |
 | **Mixed iOS / React Native / Expo** | Closes cross-language flows that static parsing misses: Swift ↔ ObjC bridging, React Native legacy bridge + TurboModules + Fabric view components, native → JS event emitters, Expo Modules |
 | **100% Local** | No data leaves your machine. No API keys. No external services. SQLite database only |
@@ -660,6 +660,7 @@ is written):
 | Liquid | `.liquid` | Full support |
 | Pascal / Delphi | `.pas`, `.dpr`, `.dpk`, `.lpr` | Full support (classes, records, interfaces, enums, DFM/FMX form files) |
 | Lua | `.lua` | Full support (functions, methods with receivers, local variables, `require` imports, call edges) |
+| R | `.R` `.r` | Full support (functions in every assignment form, S4/R5/R6 classes with methods, `library`/`require` imports, `source()` file references, call edges) |
 | Luau | `.luau` | Full support (everything in Lua, plus `type`/`export type` aliases, typed signatures, and Roblox instance-path `require`) |
 
 ## Measured cross-file coverage

__tests__/extraction.test.ts

@@ -7010,3 +7010,154 @@ describe('Swift property wrappers / attributes (blast-radius recall)', () => {
     } finally { cleanupTempDir(dir); }
   });
 });
+
+describe('R Extraction', () => {
+  describe('Language detection', () => {
+    it('should detect R files (both extension cases)', () => {
+      expect(detectLanguage('analysis.R')).toBe('r');
+      expect(detectLanguage('scripts/clean.r')).toBe('r');
+    });
+
+    it('should report R as supported', () => {
+      expect(isLanguageSupported('r')).toBe(true);
+      expect(getSupportedLanguages()).toContain('r');
+    });
+  });
+
+  describe('Function extraction', () => {
+    it('extracts every assignment form, lambdas, and nested functions', () => {
+      const code = `
+clean_data <- function(df, threshold = 0.5) {
+  helper <- function(d) scale(d)
+  helper(df)
+}
+normalize = function(v) (v - mean(v)) / sd(v)
+double_it <- \\(x) x * 2
+`;
+      const result = extractFromSource('analysis.R', code);
+      const funcs = result.nodes.filter((n) => n.kind === 'function').map((n) => n.name);
+      expect(funcs).toContain('clean_data');
+      expect(funcs).toContain('normalize');
+      expect(funcs).toContain('double_it');
+      expect(funcs).toContain('helper'); // nested, inside clean_data's scope
+      const cleanData = result.nodes.find((n) => n.name === 'clean_data');
+      expect(cleanData?.language).toBe('r');
+      expect(cleanData?.signature).toBe('(df, threshold = 0.5)');
+    });
+
+    it('attributes body calls to the enclosing function', () => {
+      const code = `
+prep <- function(d) scale(d)
+fit_model <- function(data) {
+  lm(y ~ x, data = prep(data))
+}
+`;
+      const result = extractFromSource('models.R', code);
+      const prepCall = result.unresolvedReferences.find(
+        (r) => r.referenceName === 'prep' && r.referenceKind === 'calls'
+      );
+      expect(prepCall).toBeDefined();
+      const fitModel = result.nodes.find((n) => n.name === 'fit_model');
+      expect(prepCall?.fromNodeId).toBe(fitModel?.id);
+    });
+  });
+
+  describe('Imports', () => {
+    it('extracts library/require/source as imports, not calls', () => {
+      const code = `
+library(dplyr)
+require(stats)
+requireNamespace("jsonlite")
+source("helpers.R")
+`;
+      const result = extractFromSource('main.R', code);
+      const imports = result.nodes.filter((n) => n.kind === 'import').map((n) => n.name);
+      expect(imports).toContain('dplyr');
+      expect(imports).toContain('stats');
+      expect(imports).toContain('jsonlite');
+      expect(imports).toContain('helpers.R');
+      // Claimed by the hook — no call references to the import machinery.
+      const libCalls = result.unresolvedReferences.filter(
+        (r) => r.referenceKind === 'calls' && (r.referenceName === 'library' || r.referenceName === 'source')
+      );
+      expect(libCalls).toHaveLength(0);
+    });
+  });
+
+  describe('Variables and constants', () => {
+    it('extracts top-level assignments; ALL_CAPS as constants; right-assign too', () => {
+      const code = `
+ALPHA <- 0.05
+max_iter = 100
+compute_stats(df) -> stats_result
+inner <- function() {
+  local_var <- 1
+}
+`;
+      const result = extractFromSource('config.R', code);
+      const constant = result.nodes.find((n) => n.name === 'ALPHA');
+      expect(constant?.kind).toBe('constant');
+      const variable = result.nodes.find((n) => n.name === 'max_iter');
+      expect(variable?.kind).toBe('variable');
+      const rightAssigned = result.nodes.find((n) => n.name === 'stats_result');
+      expect(rightAssigned?.kind).toBe('variable');
+      // Locals inside functions are deliberately NOT extracted.
+      expect(result.nodes.find((n) => n.name === 'local_var')).toBeUndefined();
+    });
+  });
+
+  describe('Classes', () => {
+    it('extracts S4/R5/R6 class calls as classes with their list methods', () => {
+      const code = `
+setClass("Patient", representation(id = "character"))
+Account <- setRefClass("Account",
+  fields = list(balance = "numeric"),
+  methods = list(deposit = function(x) { balance <<- balance + x })
+)
+Stack <- R6Class("Stack",
+  public = list(push = function(v) invisible(v))
+)
+setGeneric("describe", function(obj) standardGeneric("describe"))
+setMethod("describe", "Patient", function(obj) paste(obj@id))
+`;
+      const result = extractFromSource('classes.R', code);
+      const classes = result.nodes.filter((n) => n.kind === 'class').map((n) => n.name);
+      expect(classes).toContain('Patient');
+      expect(classes).toContain('Account');
+      expect(classes).toContain('Stack');
+      const methods = result.nodes.filter((n) => n.kind === 'method').map((n) => n.name);
+      expect(methods).toContain('deposit');
+      expect(methods).toContain('push');
+      // setGeneric/setMethod produce functions named by their string argument.
+      const describes = result.nodes.filter((n) => n.name === 'describe' && n.kind === 'function');
+      expect(describes.length).toBeGreaterThanOrEqual(2);
+      // The class-assignment idiom must not ALSO produce a variable node.
+      expect(result.nodes.find((n) => n.name === 'Account' && n.kind === 'variable')).toBeUndefined();
+    });
+
+    it('extracts ggproto classes with direct-arg methods and the parent as extends', () => {
+      // ggplot2's OO system — every Geom/Stat/Scale in the ecosystem uses it.
+      const code = `
+GeomPoint <- ggproto("GeomPoint", Geom,
+  required_aes = c("x", "y"),
+  draw_panel = function(data, panel_params, coord) {
+    coords <- coord$transform(data, panel_params)
+    grid::pointsGrob(coords$x, coords$y)
+  },
+  draw_key = draw_key_point
+)
+`;
+      const result = extractFromSource('geom-point.R', code);
+      const cls = result.nodes.find((n) => n.name === 'GeomPoint' && n.kind === 'class');
+      expect(cls).toBeDefined();
+      const method = result.nodes.find((n) => n.name === 'draw_panel' && n.kind === 'method');
+      expect(method).toBeDefined();
+      const ext = result.unresolvedReferences.find(
+        (r) => r.referenceKind === 'extends' && r.referenceName === 'Geom'
+      );
+      expect(ext?.fromNodeId).toBe(cls?.id);
+      // No twin variable for the assignment.
+      expect(result.nodes.find((n) => n.name === 'GeomPoint' && n.kind === 'variable')).toBeUndefined();
+    });
+  });
+});

src/extraction/grammars.ts

@@ -36,6 +36,7 @@ const WASM_GRAMMAR_FILES: Record<GrammarLanguage, string> = {
   pascal: 'tree-sitter-pascal.wasm',
   scala: 'tree-sitter-scala.wasm',
   lua: 'tree-sitter-lua.wasm',
+  r: 'tree-sitter-r.wasm',
   luau: 'tree-sitter-luau.wasm',
   objc: 'tree-sitter-objc.wasm',
 };
@@ -94,6 +95,7 @@ export const EXTENSION_MAP: Record<string, Language> = {
   '.svelte': 'svelte',
   '.vue': 'vue',
   '.astro': 'astro',
+  '.r': 'r',
   '.pas': 'pascal',
   '.dpr': 'pascal',
   '.dpk': 'pascal',
@@ -214,7 +216,7 @@ export async function loadGrammarsForLanguages(languages: Language[]): Promise<v
       // `class Foo(...)` as an ERROR that swallows the whole class (#237); we
       // vendor the upstream ABI-15 tree-sitter-c-sharp 0.23.5 wasm, which parses
       // primary constructors natively.
-      const wasmPath = (lang === 'pascal' || lang === 'scala' || lang === 'lua' || lang === 'luau' || lang === 'csharp')
+      const wasmPath = (lang === 'pascal' || lang === 'scala' || lang === 'lua' || lang === 'luau' || lang === 'csharp' || lang === 'r')
         ? path.join(__dirname, 'wasm', wasmFile)
         : require.resolve(`tree-sitter-wasms/out/${wasmFile}`);
       const language = await WasmLanguage.load(wasmPath);
@@ -401,6 +403,7 @@ export function getLanguageDisplayName(language: Language): string {
     python: 'Python',
     go: 'Go',
     rust: 'Rust',
+    r: 'R',
     java: 'Java',
     c: 'C',
     cpp: 'C++',

src/extraction/languages/index.ts

@@ -24,6 +24,7 @@ import { dartExtractor } from './dart';
 import { pascalExtractor } from './pascal';
 import { scalaExtractor } from './scala';
 import { luaExtractor } from './lua';
+import { rExtractor } from './r';
 import { luauExtractor } from './luau';
 import { objcExtractor } from './objc';
 
@@ -47,6 +48,7 @@ export const EXTRACTORS: Partial<Record<Language, LanguageExtractor>> = {
   pascal: pascalExtractor,
   scala: scalaExtractor,
   lua: luaExtractor,
+  r: rExtractor,
   luau: luauExtractor,
   objc: objcExtractor,
 };

src/extraction/languages/r.ts

@@ -0,0 +1,310 @@
+import type { Node as SyntaxNode } from 'web-tree-sitter';
+import { getNodeText, getChildByField } from '../tree-sitter-helpers';
+import type { LanguageExtractor, ExtractorContext } from '../tree-sitter-types';
+
+/**
+ * R language extractor (#828).
+ *
+ * R has no declaration syntax — everything is an expression, so every symbol
+ * the graph needs arrives through the visitNode hook rather than node-type
+ * lists:
+ *
+ *   - functions:   `name <- function(x) …` / `name = function(x) …` parse as
+ *                  binary_operator(lhs: identifier, rhs: function_definition).
+ *                  (`function(x) … -> name` right-assign of a function does
+ *                  not survive the grammar's precedence — the `->` binds inside
+ *                  the body — and the style is rare; deliberate gap.)
+ *   - variables:   top-level assignments only (locals would bloat the graph);
+ *                  ALL_CAPS / dotted-caps names extract as constants.
+ *   - imports:     `library(x)` / `require(x)` / `requireNamespace("x")` are
+ *                  ordinary calls; `source("file.R")` references another file.
+ *                  All are claimed so no noise call-edge to `library` remains
+ *                  (same pattern as Lua's `require`).
+ *   - classes:     S4 `setClass("Name", …)`, R5 `setRefClass("Name", …)`, and
+ *                  R6 `R6Class("Name", public = list(m = function() …))` are
+ *                  calls too; the class node is named by the first string
+ *                  argument and `name = function` entries in its list() args
+ *                  extract as methods inside the class scope.
+ *   - S4 generics: `setGeneric("name", …)` / `setMethod("name", "Class", fn)`
+ *                  extract as functions named by the first string argument.
+ *
+ * Calls themselves go through the generic call extraction (`call` nodes with a
+ * `function` field). Namespaced `pkg::fn(…)` keeps its qualified text;
+ * `obj$method(…)` extracts under its full text (resolution of `$`-dispatch is
+ * a known gap — R's S3 dispatch is runtime by design).
+ */
+
+const ASSIGN_LEFT = new Set(['<-', '<<-', '=']);
+const ASSIGN_RIGHT = new Set(['->', '->>']);
+const IMPORT_FNS = new Set(['library', 'require', 'requireNamespace', 'loadNamespace']);
+const CLASS_FNS = new Set(['setClass', 'setRefClass', 'R6Class', 'ggproto']);
+const GENERIC_FNS = new Set(['setGeneric', 'setMethod']);
+/** ALL_CAPS or DOTTED.CAPS top-level assignment → constant. */
+const CONSTANT_NAME = /^[A-Z][A-Z0-9._]*$/;
+
+/** The call's callee name when it is a bare identifier or `pkg::fn` (→ `fn`). */
+function calleeName(call: SyntaxNode, source: string): string | null {
+  const fn = getChildByField(call, 'function');
+  if (!fn) return null;
+  if (fn.type === 'identifier') return getNodeText(fn, source);
+  if (fn.type === 'namespace_operator') {
+    const rhs = getChildByField(fn, 'rhs');
+    if (rhs) return getNodeText(rhs, source);
+  }
+  return null;
+}
+
+/** First positional argument's value node of a call. */
+function firstArgValue(call: SyntaxNode): SyntaxNode | null {
+  const args = getChildByField(call, 'arguments');
+  if (!args) return null;
+  for (let i = 0; i < args.namedChildCount; i++) {
+    const arg = args.namedChild(i);
+    if (arg?.type !== 'argument') continue;
+    return getChildByField(arg, 'value');
+  }
+  return null;
+}
+
+/** Text of a string node's content, or an identifier's text. */
+function literalOrIdentifier(node: SyntaxNode | null, source: string): string | null {
+  if (!node) return null;
+  if (node.type === 'identifier') return getNodeText(node, source);
+  if (node.type === 'string') {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c?.type === 'string_content') return getNodeText(c, source);
+    }
+    return ''; // empty string literal
+  }
+  return null;
+}
+
+/** Emit one `name = function(…)` argument entry as a method in the current scope. */
+function emitMethodArg(entry: SyntaxNode, ctx: ExtractorContext): void {
+  const entryName = getChildByField(entry, 'name');
+  const entryValue = getChildByField(entry, 'value');
+  if (!entryName || entryValue?.type !== 'function_definition') return;
+  const params = getChildByField(entryValue, 'parameters');
+  const method = ctx.createNode('method', getNodeText(entryName, ctx.source), entry, {
+    signature: params ? getNodeText(params, ctx.source) : undefined,
+  });
+  const body = getChildByField(entryValue, 'body');
+  if (method && body) {
+    ctx.pushScope(method.id);
+    ctx.visitNode(body); // hook-aware walk — see the function-assignment note below
+    ctx.popScope();
+  }
+}
+
+/**
+ * Extract a class call's methods. Two shapes:
+ *  - inside list() arguments — R5 `methods = list(deposit = function(x) …)`,
+ *    R6 `public = list(…)` / `private = list(…)`;
+ *  - DIRECT named function arguments — ggproto's style:
+ *    `ggproto("GeomPoint", Geom, draw_panel = function(…) …)`.
+ * Also records the parent class as an `extends` reference: ggproto's second
+ * positional identifier argument, R6's `inherit = Parent`, S4's
+ * `contains = "Parent"`.
+ */
+function extractClassMembers(classCall: SyntaxNode, classId: string, ctx: ExtractorContext): void {
+  const args = getChildByField(classCall, 'arguments');
+  if (!args) return;
+  let positional = 0;
+  for (let i = 0; i < args.namedChildCount; i++) {
+    const arg = args.namedChild(i);
+    if (arg?.type !== 'argument') continue;
+    const argName = getChildByField(arg, 'name');
+    const value = getChildByField(arg, 'value');
+    if (!argName) {
+      positional++;
+      // ggproto("Name", Parent, …) — the 2nd positional identifier is the parent.
+      if (positional === 2 && value?.type === 'identifier') {
+        ctx.addUnresolvedReference({
+          fromNodeId: classId,
+          referenceName: getNodeText(value, ctx.source),
+          referenceKind: 'extends',
+          line: value.startPosition.row + 1,
+          column: value.startPosition.column,
+        });
+      }
+      continue;
+    }
+    const argNameText = getNodeText(argName, ctx.source);
+    // R6 `inherit = Parent` / S4 `contains = "Parent"`.
+    if ((argNameText === 'inherit' || argNameText === 'contains') && value) {
+      const parent = literalOrIdentifier(value, ctx.source);
+      if (parent) {
+        ctx.addUnresolvedReference({
+          fromNodeId: classId,
+          referenceName: parent,
+          referenceKind: 'extends',
+          line: value.startPosition.row + 1,
+          column: value.startPosition.column,
+        });
+      }
+      continue;
+    }
+    // Direct named function argument (ggproto methods).
+    if (value?.type === 'function_definition') {
+      emitMethodArg(arg, ctx);
+      continue;
+    }
+    // list(…) of named function arguments (R5/R6 methods).
+    if (value?.type === 'call' && calleeName(value, ctx.source) === 'list') {
+      const listArgs = getChildByField(value, 'arguments');
+      if (!listArgs) continue;
+      for (let j = 0; j < listArgs.namedChildCount; j++) {
+        const entry = listArgs.namedChild(j);
+        if (entry?.type === 'argument') emitMethodArg(entry, ctx);
+      }
+    }
+  }
+}
+
+export const rExtractor: LanguageExtractor = {
+  functionTypes: [], // named functions are assignments — handled in visitNode
+  classTypes: [],
+  methodTypes: [],
+  interfaceTypes: [],
+  structTypes: [],
+  enumTypes: [],
+  typeAliasTypes: [],
+  importTypes: [], // library()/require()/source() are calls — handled in visitNode
+  callTypes: ['call'],
+  variableTypes: [], // top-level assignments — handled in visitNode
+  nameField: 'name',
+  bodyField: 'body',
+  paramsField: 'parameters',
+
+  visitNode: (node, ctx) => {
+    const source = ctx.source;
+
+    if (node.type === 'call') {
+      const fname = calleeName(node, source);
+      if (!fname) return false;
+
+      // library(dplyr) / require(stats) / requireNamespace("jsonlite") —
+      // and source("helpers.R"), which references another file in the project.
+      if (IMPORT_FNS.has(fname) || fname === 'source') {
+        const mod = literalOrIdentifier(firstArgValue(node), source);
+        if (!mod) return true; // dynamic argument — nothing to record, still not a call edge
+        const imp = ctx.createNode('import', mod, node, {
+          signature: getNodeText(node, source).trim().slice(0, 100),
+        });
+        if (imp && ctx.nodeStack.length > 0) {
+          const parentId = ctx.nodeStack[ctx.nodeStack.length - 1];
+          if (parentId) {
+            ctx.addUnresolvedReference({
+              fromNodeId: parentId,
+              referenceName: mod,
+              referenceKind: 'imports',
+              line: node.startPosition.row + 1,
+              column: node.startPosition.column,
+            });
+          }
+        }
+        return true;
+      }
+
+      // setClass("Patient", …) / setRefClass("Account", …) / R6Class("Stack", …)
+      if (CLASS_FNS.has(fname)) {
+        const name = literalOrIdentifier(firstArgValue(node), source);
+        if (!name) return false;
+        const cls = ctx.createNode('class', name, node, {});
+        if (cls) {
+          ctx.pushScope(cls.id);
+          extractClassMembers(node, cls.id, ctx);
+          ctx.popScope();
+        }
+        return true;
+      }
+
+      // setGeneric("describe", …) / setMethod("describe", "Patient", function(obj) …)
+      if (GENERIC_FNS.has(fname)) {
+        const name = literalOrIdentifier(firstArgValue(node), source);
+        if (!name) return false;
+        // The implementing function_definition, when present (setMethod always,
+        // setGeneric usually via the def= argument).
+        const args = getChildByField(node, 'arguments');
+        let impl: SyntaxNode | null = null;
+        if (args) {
+          for (let i = 0; i < args.namedChildCount; i++) {
+            const v = args.namedChild(i)?.type === 'argument'
+              ? getChildByField(args.namedChild(i)!, 'value') : null;
+            if (v?.type === 'function_definition') { impl = v; break; }
+          }
+        }
+        const params = impl ? getChildByField(impl, 'parameters') : null;
+        const fn = ctx.createNode('function', name, node, {
+          signature: params ? getNodeText(params, source) : undefined,
+        });
+        const body = impl ? getChildByField(impl, 'body') : null;
+        if (fn && body) {
+          ctx.pushScope(fn.id);
+          ctx.visitNode(body); // hook-aware walk — see the function-assignment note below
+          ctx.popScope();
+        }
+        return true;
+      }
+
+      return false; // ordinary call — generic extraction records the edge
+    }
+
+    if (node.type === 'binary_operator') {
+      const op = node.childForFieldName('operator')?.text;
+      if (!op) return false;
+      const lhs = getChildByField(node, 'lhs');
+      const rhs = getChildByField(node, 'rhs');
+
+      // name <- function(…) / name = function(…)   (any scope — nested
+      // functions extract inside their enclosing function's scope). The body
+      // is walked through ctx.visitNode, NOT ctx.visitFunctionBody: the body
+      // walker doesn't consult this hook, and in R every nested definition is
+      // an assignment expression that only this hook can recognize. visitNode
+      // dispatches calls and the hook alike, with the function on the scope
+      // stack so attribution is right.
+      if (ASSIGN_LEFT.has(op) && lhs?.type === 'identifier' && rhs?.type === 'function_definition') {
+        const params = getChildByField(rhs, 'parameters');
+        const fn = ctx.createNode('function', getNodeText(lhs, source), node, {
+          signature: params ? getNodeText(params, source) : undefined,
+        });
+        const body = getChildByField(rhs, 'body');
+        if (fn && body) {
+          ctx.pushScope(fn.id);
+          ctx.visitNode(body);
+          ctx.popScope();
+        }
+        return true;
+      }
+
+      // Top-level value assignments → variable/constant. Locals are skipped
+      // deliberately (graph bloat); the initializer is still visited so its
+      // calls and nested definitions extract.
+      const topLevel = node.parent?.type === 'program';
+      if (topLevel && ASSIGN_LEFT.has(op) && lhs?.type === 'identifier' && rhs) {
+        // `Account <- setRefClass("Account", …)` is the CLASS definition idiom
+        // (same for R6Class / setClass / setGeneric) — the call hook makes the
+        // class/function node; a twin variable node would just be noise.
+        const rhsCallee = rhs.type === 'call' ? calleeName(rhs, source) : null;
+        if (!rhsCallee || (!CLASS_FNS.has(rhsCallee) && !GENERIC_FNS.has(rhsCallee))) {
+          const name = getNodeText(lhs, source);
+          ctx.createNode(CONSTANT_NAME.test(name) ? 'constant' : 'variable', name, node, {});
+        }
+        ctx.visitNode(rhs);
+        return true;
+      }
+      // value -> name / value ->> name (right assign)
+      if (topLevel && ASSIGN_RIGHT.has(op) && rhs?.type === 'identifier' && lhs) {
+        const name = getNodeText(rhs, source);
+        ctx.createNode(CONSTANT_NAME.test(name) ? 'constant' : 'variable', name, node, {});
+        ctx.visitNode(lhs);
+        return true;
+      }
+
+      return false;
+    }
+
+    return false;
+  },
+};

src/types.ts

@@ -90,6 +90,7 @@ export const LANGUAGES = [
   'lua',
   'luau',
   'objc',
+  'r',
   'yaml',
   'twig',
   'xml',