@enjoys/context-engine 1.1.1 → 1.1.2

package/data/completion/r.json

@@ -0,0 +1,1985 @@
+{
+  "language": "r",
+  "completions": [
+    {
+      "label": "if",
+      "kind": 14,
+      "detail": "Conditional execution (keyword)",
+      "documentation": { "value": "Conditional branching.\n\n```r\nif (condition) {\n  # true branch\n} else {\n  # false branch\n}\n```" },
+      "insertText": "if (${1:condition}) {\n  ${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_if"
+    },
+    {
+      "label": "else",
+      "kind": 14,
+      "detail": "Alternative branch (keyword)",
+      "documentation": { "value": "Alternative branch in `if` statement.\n\n```r\nif (x > 0) {\n  print(\"positive\")\n} else {\n  print(\"non-positive\")\n}\n```" },
+      "insertText": "else {\n  ${1}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_else"
+    },
+    {
+      "label": "for",
+      "kind": 14,
+      "detail": "For loop (keyword)",
+      "documentation": { "value": "Iterate over elements of a vector.\n\n```r\nfor (i in 1:10) {\n  print(i)\n}\n\nfor (item in my_list) {\n  cat(item, \"\\n\")\n}\n```" },
+      "insertText": "for (${1:i} in ${2:seq}) {\n  ${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_for"
+    },
+    {
+      "label": "while",
+      "kind": 14,
+      "detail": "While loop (keyword)",
+      "documentation": { "value": "Execute a block while a condition is TRUE.\n\n```r\nwhile (x > 0) {\n  x <- x - 1\n}\n```" },
+      "insertText": "while (${1:condition}) {\n  ${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_while"
+    },
+    {
+      "label": "repeat",
+      "kind": 14,
+      "detail": "Infinite loop (keyword)",
+      "documentation": { "value": "Execute a block indefinitely until `break` is called.\n\n```r\nrepeat {\n  x <- x + 1\n  if (x > 10) break\n}\n```" },
+      "insertText": "repeat {\n  ${1}\n  if (${2:condition}) break\n}",
+      "insertTextRules": 4,
+      "sortText": "00_repeat"
+    },
+    {
+      "label": "in",
+      "kind": 14,
+      "detail": "Membership operator (keyword)",
+      "documentation": { "value": "Used in `for` loops to iterate over sequences.\n\n```r\nfor (x in 1:10) print(x)\n```" },
+      "insertText": "in",
+      "sortText": "00_in"
+    },
+    {
+      "label": "next",
+      "kind": 14,
+      "detail": "Skip to next iteration (keyword)",
+      "documentation": { "value": "Skip the rest of the current iteration and proceed to the next.\n\n```r\nfor (i in 1:10) {\n  if (i %% 2 == 0) next\n  print(i)\n}\n```" },
+      "insertText": "next",
+      "sortText": "00_next"
+    },
+    {
+      "label": "break",
+      "kind": 14,
+      "detail": "Exit loop (keyword)",
+      "documentation": { "value": "Exit the current `for`, `while`, or `repeat` loop.\n\n```r\nfor (i in 1:100) {\n  if (i > 10) break\n}\n```" },
+      "insertText": "break",
+      "sortText": "00_break"
+    },
+    {
+      "label": "function",
+      "kind": 14,
+      "detail": "Define a function (keyword)",
+      "documentation": { "value": "Create a function object.\n\n```r\nmy_func <- function(x, y = 1) {\n  x + y\n}\n\n# Anonymous function\nsapply(1:5, function(x) x^2)\n```" },
+      "insertText": "function(${1:args}) {\n  ${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_function"
+    },
+    {
+      "label": "return",
+      "kind": 14,
+      "detail": "Return value from function (keyword)",
+      "documentation": { "value": "Explicitly return a value from a function.\n\n```r\nmy_func <- function(x) {\n  if (x < 0) return(NULL)\n  sqrt(x)\n}\n```" },
+      "insertText": "return(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "00_return"
+    },
+    {
+      "label": "TRUE",
+      "kind": 14,
+      "detail": "Logical constant TRUE",
+      "documentation": { "value": "Logical truth value.\n\n```r\nx <- TRUE\nis.logical(TRUE)  # TRUE\n```" },
+      "insertText": "TRUE",
+      "sortText": "00_TRUE"
+    },
+    {
+      "label": "FALSE",
+      "kind": 14,
+      "detail": "Logical constant FALSE",
+      "documentation": { "value": "Logical false value.\n\n```r\nx <- FALSE\n!FALSE  # TRUE\n```" },
+      "insertText": "FALSE",
+      "sortText": "00_FALSE"
+    },
+    {
+      "label": "NULL",
+      "kind": 14,
+      "detail": "Null object",
+      "documentation": { "value": "The NULL object represents the absence of a value.\n\n```r\nx <- NULL\nis.null(x)  # TRUE\nlength(NULL)  # 0\n```" },
+      "insertText": "NULL",
+      "sortText": "00_NULL"
+    },
+    {
+      "label": "NA",
+      "kind": 14,
+      "detail": "Missing value indicator",
+      "documentation": { "value": "Logical constant representing a missing value.\n\n```r\nx <- c(1, NA, 3)\nis.na(x)       # FALSE TRUE FALSE\nna.rm = TRUE   # common argument to ignore NAs\n```" },
+      "insertText": "NA",
+      "sortText": "00_NA"
+    },
+    {
+      "label": "NA_integer_",
+      "kind": 14,
+      "detail": "Integer NA",
+      "documentation": { "value": "Missing value of integer type.\n\n```r\nx <- NA_integer_\nis.na(x)  # TRUE\ntypeof(x)  # \"integer\"\n```" },
+      "insertText": "NA_integer_",
+      "sortText": "00_NA_integer_"
+    },
+    {
+      "label": "NA_real_",
+      "kind": 14,
+      "detail": "Double/real NA",
+      "documentation": { "value": "Missing value of double type.\n\n```r\nx <- NA_real_\ntypeof(x)  # \"double\"\n```" },
+      "insertText": "NA_real_",
+      "sortText": "00_NA_real_"
+    },
+    {
+      "label": "NA_complex_",
+      "kind": 14,
+      "detail": "Complex NA",
+      "documentation": { "value": "Missing value of complex type.\n\n```r\nx <- NA_complex_\ntypeof(x)  # \"complex\"\n```" },
+      "insertText": "NA_complex_",
+      "sortText": "00_NA_complex_"
+    },
+    {
+      "label": "NA_character_",
+      "kind": 14,
+      "detail": "Character NA",
+      "documentation": { "value": "Missing value of character type.\n\n```r\nx <- NA_character_\ntypeof(x)  # \"character\"\n```" },
+      "insertText": "NA_character_",
+      "sortText": "00_NA_character_"
+    },
+    {
+      "label": "Inf",
+      "kind": 14,
+      "detail": "Positive infinity",
+      "documentation": { "value": "Positive infinity.\n\n```r\n1 / 0     # Inf\nis.infinite(Inf)  # TRUE\n```" },
+      "insertText": "Inf",
+      "sortText": "00_Inf"
+    },
+    {
+      "label": "NaN",
+      "kind": 14,
+      "detail": "Not a Number",
+      "documentation": { "value": "Not a Number — result of undefined numeric operations.\n\n```r\n0 / 0      # NaN\nis.nan(NaN)  # TRUE\n```" },
+      "insertText": "NaN",
+      "sortText": "00_NaN"
+    },
+    {
+      "label": "library",
+      "kind": 1,
+      "detail": "Load and attach a package",
+      "documentation": { "value": "Load and attach a package namespace.\n\n```r\nlibrary(dplyr)\nlibrary(ggplot2)\nlibrary(tidyr, warn.conflicts = FALSE)\n```" },
+      "insertText": "library(${1:package})",
+      "insertTextRules": 4,
+      "sortText": "00_library"
+    },
+    {
+      "label": "require",
+      "kind": 1,
+      "detail": "Load a package (returns logical)",
+      "documentation": { "value": "Try to load a package. Returns TRUE/FALSE instead of erroring.\n\n```r\nif (!require(dplyr)) install.packages(\"dplyr\")\n```" },
+      "insertText": "require(${1:package})",
+      "insertTextRules": 4,
+      "sortText": "00_require"
+    },
+    {
+      "label": "source",
+      "kind": 1,
+      "detail": "Read and evaluate R code from a file",
+      "documentation": { "value": "Parse and evaluate R expressions from a file.\n\n```r\nsource(\"helper_functions.R\")\nsource(\"config.R\", local = TRUE)\n```" },
+      "insertText": "source(\"${1:file.R}\")",
+      "insertTextRules": 4,
+      "sortText": "00_source"
+    },
+    {
+      "label": "local",
+      "kind": 1,
+      "detail": "Evaluate in a local environment",
+      "documentation": { "value": "Evaluate expression in a local environment.\n\n```r\nresult <- local({\n  tmp <- 42\n  tmp * 2\n})\n```" },
+      "insertText": "local({\n  ${1}\n})",
+      "insertTextRules": 4,
+      "sortText": "00_local"
+    },
+    {
+      "label": "switch",
+      "kind": 1,
+      "detail": "Multi-way conditional",
+      "documentation": { "value": "Select one of several alternatives based on a value.\n\n```r\nresult <- switch(x,\n  \"a\" = 1,\n  \"b\" = 2,\n  \"c\" = 3,\n  -1  # default\n)\n```" },
+      "insertText": "switch(${1:expr},\n  ${2:case1} = ${3:value1},\n  ${4:default}\n)",
+      "insertTextRules": 4,
+      "sortText": "00_switch"
+    },
+    {
+      "label": "print",
+      "kind": 1,
+      "detail": "Print values",
+      "documentation": { "value": "Generic print function for displaying objects.\n\n```r\nprint(x)\nprint(df, n = 20)\nprint(\"hello\")\n```" },
+      "insertText": "print(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_print"
+    },
+    {
+      "label": "cat",
+      "kind": 1,
+      "detail": "Concatenate and print",
+      "documentation": { "value": "Concatenate and print to stdout or a file.\n\n```r\ncat(\"Hello\", \"world\\n\")\ncat(\"x =\", x, \"\\n\")\ncat(\"line\\n\", file = \"out.txt\", append = TRUE)\n```" },
+      "insertText": "cat(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_cat"
+    },
+    {
+      "label": "paste",
+      "kind": 1,
+      "detail": "Concatenate strings with separator",
+      "documentation": { "value": "Concatenate strings with a separator (default space).\n\n```r\npaste(\"Hello\", \"world\")        # \"Hello world\"\npaste(\"a\", \"b\", sep = \"-\")     # \"a-b\"\npaste0(\"x\", 1:3)               # \"x1\" \"x2\" \"x3\"\n```" },
+      "insertText": "paste(${1:...}, sep = \"${2: }\")",
+      "insertTextRules": 4,
+      "sortText": "01_paste"
+    },
+    {
+      "label": "paste0",
+      "kind": 1,
+      "detail": "Concatenate strings without separator",
+      "documentation": { "value": "Concatenate strings with no separator (equivalent to `paste(..., sep = \"\")`.\n\n```r\npaste0(\"file\", 1:3, \".csv\")  # \"file1.csv\" \"file2.csv\" \"file3.csv\"\npaste0(\"prefix_\", name)\n```" },
+      "insertText": "paste0(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_paste0"
+    },
+    {
+      "label": "sprintf",
+      "kind": 1,
+      "detail": "Formatted string output",
+      "documentation": { "value": "C-style string formatting.\n\n```r\nsprintf(\"%s is %d years old\", name, age)\nsprintf(\"%.2f%%\", pct * 100)\nsprintf(\"%05d\", id)\n```" },
+      "insertText": "sprintf(\"${1:%s}\", ${2:...})",
+      "insertTextRules": 4,
+      "sortText": "01_sprintf"
+    },
+    {
+      "label": "c",
+      "kind": 1,
+      "detail": "Combine values into a vector",
+      "documentation": { "value": "Combine values into a vector or list.\n\n```r\nx <- c(1, 2, 3)\nnames <- c(\"Alice\", \"Bob\")\nmixed <- c(a = 1, b = 2)\n```" },
+      "insertText": "c(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_c"
+    },
+    {
+      "label": "length",
+      "kind": 1,
+      "detail": "Length of an object",
+      "documentation": { "value": "Get or set the length of a vector or list.\n\n```r\nlength(1:10)         # 10\nlength(list(a=1))    # 1\nlength(NULL)         # 0\n```" },
+      "insertText": "length(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_length"
+    },
+    {
+      "label": "nchar",
+      "kind": 1,
+      "detail": "Number of characters in a string",
+      "documentation": { "value": "Count the number of characters in a string.\n\n```r\nnchar(\"hello\")     # 5\nnchar(c(\"a\", \"bb\"))  # 1 2\n```" },
+      "insertText": "nchar(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_nchar"
+    },
+    {
+      "label": "seq",
+      "kind": 1,
+      "detail": "Generate a sequence",
+      "documentation": { "value": "Generate regular sequences.\n\n```r\nseq(1, 10)             # 1 2 ... 10\nseq(0, 1, by = 0.1)   # 0.0 0.1 ... 1.0\nseq_len(5)             # 1 2 3 4 5\nseq_along(x)           # 1:length(x)\n```" },
+      "insertText": "seq(${1:from}, ${2:to}, by = ${3:1})",
+      "insertTextRules": 4,
+      "sortText": "01_seq"
+    },
+    {
+      "label": "seq_along",
+      "kind": 1,
+      "detail": "Sequence along an object",
+      "documentation": { "value": "Generate a sequence `1, 2, ..., length(x)`.\n\n```r\nfor (i in seq_along(x)) {\n  cat(i, x[i], \"\\n\")\n}\n```" },
+      "insertText": "seq_along(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_seq_along"
+    },
+    {
+      "label": "seq_len",
+      "kind": 1,
+      "detail": "Sequence of given length",
+      "documentation": { "value": "Generate sequence `1:length.out`.\n\n```r\nseq_len(5)  # 1 2 3 4 5\n```" },
+      "insertText": "seq_len(${1:n})",
+      "insertTextRules": 4,
+      "sortText": "01_seq_len"
+    },
+    {
+      "label": "rep",
+      "kind": 1,
+      "detail": "Replicate elements",
+      "documentation": { "value": "Replicate elements of a vector.\n\n```r\nrep(0, 5)              # 0 0 0 0 0\nrep(1:3, times = 2)    # 1 2 3 1 2 3\nrep(1:3, each = 2)     # 1 1 2 2 3 3\n```" },
+      "insertText": "rep(${1:x}, ${2:times})",
+      "insertTextRules": 4,
+      "sortText": "01_rep"
+    },
+    {
+      "label": "rev",
+      "kind": 1,
+      "detail": "Reverse a vector",
+      "documentation": { "value": "Reverse the elements of a vector.\n\n```r\nrev(1:5)           # 5 4 3 2 1\nrev(c(\"a\", \"b\"))   # \"b\" \"a\"\n```" },
+      "insertText": "rev(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_rev"
+    },
+    {
+      "label": "sort",
+      "kind": 1,
+      "detail": "Sort a vector",
+      "documentation": { "value": "Sort a vector in ascending or descending order.\n\n```r\nsort(c(3, 1, 2))                 # 1 2 3\nsort(c(3, 1, 2), decreasing = TRUE)  # 3 2 1\n```" },
+      "insertText": "sort(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_sort"
+    },
+    {
+      "label": "order",
+      "kind": 1,
+      "detail": "Ordering permutation",
+      "documentation": { "value": "Return a permutation which rearranges its argument into ascending or descending order.\n\n```r\nx <- c(3, 1, 2)\norder(x)        # 2 3 1\nx[order(x)]     # 1 2 3\ndf[order(df$age), ]\n```" },
+      "insertText": "order(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_order"
+    },
+    {
+      "label": "which",
+      "kind": 1,
+      "detail": "Which indices are TRUE",
+      "documentation": { "value": "Return indices where a logical vector is TRUE.\n\n```r\nwhich(c(FALSE, TRUE, TRUE))  # 2 3\nwhich(x > 5)\nwhich.min(x)\nwhich.max(x)\n```" },
+      "insertText": "which(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_which"
+    },
+    {
+      "label": "match",
+      "kind": 1,
+      "detail": "Value matching",
+      "documentation": { "value": "Return positions of first matches of first argument in second.\n\n```r\nmatch(c(\"b\", \"d\"), c(\"a\", \"b\", \"c\"))  # 2 NA\nx %in% table  # logical vector\n```" },
+      "insertText": "match(${1:x}, ${2:table})",
+      "insertTextRules": 4,
+      "sortText": "01_match"
+    },
+    {
+      "label": "unique",
+      "kind": 1,
+      "detail": "Unique values",
+      "documentation": { "value": "Return unique elements of a vector.\n\n```r\nunique(c(1, 2, 2, 3, 3, 3))  # 1 2 3\n```" },
+      "insertText": "unique(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_unique"
+    },
+    {
+      "label": "duplicated",
+      "kind": 1,
+      "detail": "Determine duplicate elements",
+      "documentation": { "value": "Return a logical vector indicating which elements are duplicates.\n\n```r\nduplicated(c(1, 2, 2, 3))  # FALSE FALSE TRUE FALSE\nx[!duplicated(x)]  # remove duplicates\n```" },
+      "insertText": "duplicated(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_duplicated"
+    },
+    {
+      "label": "table",
+      "kind": 1,
+      "detail": "Contingency table",
+      "documentation": { "value": "Build a frequency table of factor levels.\n\n```r\ntable(c(\"a\", \"b\", \"a\", \"c\", \"a\"))  # a:3 b:1 c:1\ntable(df$gender, df$group)\n```" },
+      "insertText": "table(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_table"
+    },
+    {
+      "label": "sum",
+      "kind": 1,
+      "detail": "Sum of values",
+      "documentation": { "value": "Compute the sum of all values.\n\n```r\nsum(1:10)             # 55\nsum(x, na.rm = TRUE)\n```" },
+      "insertText": "sum(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_sum"
+    },
+    {
+      "label": "mean",
+      "kind": 1,
+      "detail": "Arithmetic mean",
+      "documentation": { "value": "Compute the arithmetic mean.\n\n```r\nmean(1:10)             # 5.5\nmean(x, na.rm = TRUE)\nmean(x, trim = 0.1)\n```" },
+      "insertText": "mean(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_mean"
+    },
+    {
+      "label": "median",
+      "kind": 1,
+      "detail": "Median value",
+      "documentation": { "value": "Compute the median value.\n\n```r\nmedian(c(1, 3, 5, 7, 9))  # 5\nmedian(x, na.rm = TRUE)\n```" },
+      "insertText": "median(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_median"
+    },
+    {
+      "label": "sd",
+      "kind": 1,
+      "detail": "Standard deviation",
+      "documentation": { "value": "Compute the standard deviation.\n\n```r\nsd(c(1, 2, 3, 4, 5))  # 1.581139\nsd(x, na.rm = TRUE)\n```" },
+      "insertText": "sd(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_sd"
+    },
+    {
+      "label": "var",
+      "kind": 1,
+      "detail": "Variance",
+      "documentation": { "value": "Compute variance (or covariance matrix).\n\n```r\nvar(1:10)\nvar(x, y)     # covariance\nvar(df)       # covariance matrix\n```" },
+      "insertText": "var(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_var"
+    },
+    {
+      "label": "min",
+      "kind": 1,
+      "detail": "Minimum value",
+      "documentation": { "value": "Return the minimum of all values.\n\n```r\nmin(5, 3, 8)         # 3\nmin(x, na.rm = TRUE)\n```" },
+      "insertText": "min(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_min"
+    },
+    {
+      "label": "max",
+      "kind": 1,
+      "detail": "Maximum value",
+      "documentation": { "value": "Return the maximum of all values.\n\n```r\nmax(5, 3, 8)         # 8\nmax(x, na.rm = TRUE)\n```" },
+      "insertText": "max(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_max"
+    },
+    {
+      "label": "range",
+      "kind": 1,
+      "detail": "Range of values (min and max)",
+      "documentation": { "value": "Return the minimum and maximum of a vector.\n\n```r\nrange(c(3, 1, 5))  # 1 5\n```" },
+      "insertText": "range(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_range"
+    },
+    {
+      "label": "abs",
+      "kind": 1,
+      "detail": "Absolute value",
+      "documentation": { "value": "Compute the absolute value.\n\n```r\nabs(-5)    # 5\nabs(c(-1, 2, -3))  # 1 2 3\n```" },
+      "insertText": "abs(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_abs"
+    },
+    {
+      "label": "sqrt",
+      "kind": 1,
+      "detail": "Square root",
+      "documentation": { "value": "Compute the square root.\n\n```r\nsqrt(16)   # 4\nsqrt(1:5)\n```" },
+      "insertText": "sqrt(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_sqrt"
+    },
+    {
+      "label": "log",
+      "kind": 1,
+      "detail": "Natural logarithm",
+      "documentation": { "value": "Compute the natural logarithm (or with specified base).\n\n```r\nlog(exp(1))       # 1\nlog(100, base = 10)  # 2\n```" },
+      "insertText": "log(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_log"
+    },
+    {
+      "label": "log2",
+      "kind": 1,
+      "detail": "Base-2 logarithm",
+      "documentation": { "value": "Compute the base-2 logarithm.\n\n```r\nlog2(8)   # 3\nlog2(1024)  # 10\n```" },
+      "insertText": "log2(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_log2"
+    },
+    {
+      "label": "log10",
+      "kind": 1,
+      "detail": "Base-10 logarithm",
+      "documentation": { "value": "Compute the base-10 logarithm.\n\n```r\nlog10(1000)  # 3\n```" },
+      "insertText": "log10(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_log10"
+    },
+    {
+      "label": "exp",
+      "kind": 1,
+      "detail": "Exponential function",
+      "documentation": { "value": "Compute the exponential function e^x.\n\n```r\nexp(1)    # 2.718282\nexp(0)    # 1\n```" },
+      "insertText": "exp(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_exp"
+    },
+    {
+      "label": "ceiling",
+      "kind": 1,
+      "detail": "Round up",
+      "documentation": { "value": "Round up to the nearest integer.\n\n```r\nceiling(2.3)  # 3\nceiling(-2.3) # -2\n```" },
+      "insertText": "ceiling(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_ceiling"
+    },
+    {
+      "label": "floor",
+      "kind": 1,
+      "detail": "Round down",
+      "documentation": { "value": "Round down to the nearest integer.\n\n```r\nfloor(2.7)  # 2\nfloor(-2.3) # -3\n```" },
+      "insertText": "floor(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_floor"
+    },
+    {
+      "label": "round",
+      "kind": 1,
+      "detail": "Round to n decimal places",
+      "documentation": { "value": "Round a number to n digits.\n\n```r\nround(3.14159, 2)  # 3.14\nround(2.5)          # 2 (banker's rounding)\n```" },
+      "insertText": "round(${1:x}, digits = ${2:0})",
+      "insertTextRules": 4,
+      "sortText": "01_round"
+    },
+    {
+      "label": "trunc",
+      "kind": 1,
+      "detail": "Truncate to integer",
+      "documentation": { "value": "Truncate towards zero.\n\n```r\ntrunc(2.9)   # 2\ntrunc(-2.9)  # -2\n```" },
+      "insertText": "trunc(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_trunc"
+    },
+    {
+      "label": "sign",
+      "kind": 1,
+      "detail": "Sign of values",
+      "documentation": { "value": "Return the sign: -1, 0, or 1.\n\n```r\nsign(-5)  # -1\nsign(0)   # 0\nsign(3)   # 1\n```" },
+      "insertText": "sign(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_sign"
+    },
+    {
+      "label": "cumsum",
+      "kind": 1,
+      "detail": "Cumulative sum",
+      "documentation": { "value": "Compute the cumulative sum.\n\n```r\ncumsum(1:5)  # 1 3 6 10 15\n```" },
+      "insertText": "cumsum(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_cumsum"
+    },
+    {
+      "label": "cumprod",
+      "kind": 1,
+      "detail": "Cumulative product",
+      "documentation": { "value": "Compute the cumulative product.\n\n```r\ncumprod(1:5)  # 1 2 6 24 120\n```" },
+      "insertText": "cumprod(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_cumprod"
+    },
+    {
+      "label": "cummax",
+      "kind": 1,
+      "detail": "Cumulative maximum",
+      "documentation": { "value": "Compute the cumulative maxima.\n\n```r\ncummax(c(3, 1, 4, 1, 5))  # 3 3 4 4 5\n```" },
+      "insertText": "cummax(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_cummax"
+    },
+    {
+      "label": "cummin",
+      "kind": 1,
+      "detail": "Cumulative minimum",
+      "documentation": { "value": "Compute the cumulative minima.\n\n```r\ncummin(c(3, 1, 4, 1, 5))  # 3 1 1 1 1\n```" },
+      "insertText": "cummin(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_cummin"
+    },
+    {
+      "label": "diff",
+      "kind": 1,
+      "detail": "Lagged differences",
+      "documentation": { "value": "Compute lagged differences.\n\n```r\ndiff(c(1, 3, 6, 10))  # 2 3 4\ndiff(x, lag = 2)\n```" },
+      "insertText": "diff(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_diff"
+    },
+    {
+      "label": "head",
+      "kind": 1,
+      "detail": "First n elements",
+      "documentation": { "value": "Return the first n elements.\n\n```r\nhead(1:100)        # 1 2 3 4 5 6\nhead(df, 10)\n```" },
+      "insertText": "head(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_head"
+    },
+    {
+      "label": "tail",
+      "kind": 1,
+      "detail": "Last n elements",
+      "documentation": { "value": "Return the last n elements.\n\n```r\ntail(1:100)        # 95 96 97 98 99 100\ntail(df, 5)\n```" },
+      "insertText": "tail(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_tail"
+    },
+    {
+      "label": "nrow",
+      "kind": 1,
+      "detail": "Number of rows",
+      "documentation": { "value": "Return the number of rows of a matrix or data frame.\n\n```r\nnrow(mtcars)  # 32\n```" },
+      "insertText": "nrow(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_nrow"
+    },
+    {
+      "label": "ncol",
+      "kind": 1,
+      "detail": "Number of columns",
+      "documentation": { "value": "Return the number of columns of a matrix or data frame.\n\n```r\nncol(mtcars)  # 11\n```" },
+      "insertText": "ncol(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_ncol"
+    },
+    {
+      "label": "dim",
+      "kind": 1,
+      "detail": "Dimensions of an object",
+      "documentation": { "value": "Get or set the dimensions of an object.\n\n```r\ndim(mtcars)       # 32 11\ndim(matrix(1:6, nrow = 2))  # 2 3\n```" },
+      "insertText": "dim(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_dim"
+    },
+    {
+      "label": "names",
+      "kind": 1,
+      "detail": "Get or set names",
+      "documentation": { "value": "Get or set the names of an object.\n\n```r\nnames(x)\nnames(x) <- c(\"a\", \"b\", \"c\")\n```" },
+      "insertText": "names(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_names"
+    },
+    {
+      "label": "colnames",
+      "kind": 1,
+      "detail": "Column names",
+      "documentation": { "value": "Get or set column names.\n\n```r\ncolnames(df)\ncolnames(df) <- c(\"x\", \"y\", \"z\")\n```" },
+      "insertText": "colnames(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_colnames"
+    },
+    {
+      "label": "rownames",
+      "kind": 1,
+      "detail": "Row names",
+      "documentation": { "value": "Get or set row names.\n\n```r\nrownames(df)\nrownames(df) <- paste0(\"row\", 1:nrow(df))\n```" },
+      "insertText": "rownames(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_rownames"
+    },
+    {
+      "label": "str",
+      "kind": 1,
+      "detail": "Display structure of an object",
+      "documentation": { "value": "Compactly display the internal structure.\n\n```r\nstr(mtcars)\nstr(my_list)\n```" },
+      "insertText": "str(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "01_str"
+    },
+    {
+      "label": "summary",
+      "kind": 1,
+      "detail": "Summary of an object",
+      "documentation": { "value": "Produce result summaries (dispatched by class).\n\n```r\nsummary(mtcars)\nsummary(lm_fit)\nsummary(factor_var)\n```" },
+      "insertText": "summary(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "01_summary"
+    },
+    {
+      "label": "class",
+      "kind": 1,
+      "detail": "Object class",
+      "documentation": { "value": "Get or set the class attribute.\n\n```r\nclass(mtcars)    # \"data.frame\"\nclass(1:5)       # \"integer\"\n```" },
+      "insertText": "class(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_class"
+    },
+    {
+      "label": "typeof",
+      "kind": 1,
+      "detail": "Internal type of an object",
+      "documentation": { "value": "Return the internal storage type.\n\n```r\ntypeof(1L)       # \"integer\"\ntypeof(1.0)      # \"double\"\ntypeof(\"a\")      # \"character\"\n```" },
+      "insertText": "typeof(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_typeof"
+    },
+    {
+      "label": "is.numeric",
+      "kind": 1,
+      "detail": "Test if numeric",
+      "documentation": { "value": "Test whether an object is numeric (integer or double).\n\n```r\nis.numeric(1.5)    # TRUE\nis.numeric(\"a\")    # FALSE\n```" },
+      "insertText": "is.numeric(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_is.numeric"
+    },
+    {
+      "label": "is.character",
+      "kind": 1,
+      "detail": "Test if character",
+      "documentation": { "value": "Test whether an object is of type character.\n\n```r\nis.character(\"hello\")  # TRUE\nis.character(42)       # FALSE\n```" },
+      "insertText": "is.character(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_is.character"
+    },
+    {
+      "label": "is.logical",
+      "kind": 1,
+      "detail": "Test if logical",
+      "documentation": { "value": "Test whether an object is of type logical.\n\n```r\nis.logical(TRUE)   # TRUE\nis.logical(1)      # FALSE\n```" },
+      "insertText": "is.logical(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_is.logical"
+    },
+    {
+      "label": "is.na",
+      "kind": 1,
+      "detail": "Test for NA values",
+      "documentation": { "value": "Test each element for NA.\n\n```r\nis.na(c(1, NA, 3))  # FALSE TRUE FALSE\nsum(is.na(x))       # count NAs\n```" },
+      "insertText": "is.na(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_is.na"
+    },
+    {
+      "label": "is.null",
+      "kind": 1,
+      "detail": "Test for NULL",
+      "documentation": { "value": "Test if an object is NULL.\n\n```r\nis.null(NULL)  # TRUE\nis.null(NA)    # FALSE\n```" },
+      "insertText": "is.null(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_is.null"
+    },
+    {
+      "label": "as.numeric",
+      "kind": 1,
+      "detail": "Coerce to numeric",
+      "documentation": { "value": "Coerce an object to numeric (double).\n\n```r\nas.numeric(\"3.14\")  # 3.14\nas.numeric(TRUE)    # 1\n```" },
+      "insertText": "as.numeric(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_as.numeric"
+    },
+    {
+      "label": "as.character",
+      "kind": 1,
+      "detail": "Coerce to character",
+      "documentation": { "value": "Coerce an object to character string.\n\n```r\nas.character(42)     # \"42\"\nas.character(TRUE)   # \"TRUE\"\n```" },
+      "insertText": "as.character(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_as.character"
+    },
+    {
+      "label": "as.logical",
+      "kind": 1,
+      "detail": "Coerce to logical",
+      "documentation": { "value": "Coerce to logical.\n\n```r\nas.logical(0)       # FALSE\nas.logical(1)       # TRUE\nas.logical(\"TRUE\")  # TRUE\n```" },
+      "insertText": "as.logical(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_as.logical"
+    },
+    {
+      "label": "as.integer",
+      "kind": 1,
+      "detail": "Coerce to integer",
+      "documentation": { "value": "Coerce to integer.\n\n```r\nas.integer(3.7)    # 3\nas.integer(\"42\")   # 42\n```" },
+      "insertText": "as.integer(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_as.integer"
+    },
+    {
+      "label": "as.double",
+      "kind": 1,
+      "detail": "Coerce to double",
+      "documentation": { "value": "Coerce to double-precision floating point.\n\n```r\nas.double(1L)      # 1\nas.double(\"3.14\")  # 3.14\n```" },
+      "insertText": "as.double(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_as.double"
+    },
+    {
+      "label": "as.data.frame",
+      "kind": 1,
+      "detail": "Coerce to data frame",
+      "documentation": { "value": "Coerce to a data.frame.\n\n```r\nas.data.frame(matrix(1:6, nrow = 2))\nas.data.frame(my_list)\n```" },
+      "insertText": "as.data.frame(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_as.data.frame"
+    },
+    {
+      "label": "data.frame",
+      "kind": 1,
+      "detail": "Create a data frame",
+      "documentation": { "value": "Create a data frame from column vectors.\n\n```r\ndf <- data.frame(\n  name = c(\"Alice\", \"Bob\"),\n  age = c(25, 30),\n  stringsAsFactors = FALSE\n)\n```" },
+      "insertText": "data.frame(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_data.frame"
+    },
+    {
+      "label": "matrix",
+      "kind": 1,
+      "detail": "Create a matrix",
+      "documentation": { "value": "Create a matrix from the given values.\n\n```r\nmatrix(1:6, nrow = 2, ncol = 3)\nmatrix(0, nrow = 3, ncol = 3)\n```" },
+      "insertText": "matrix(${1:data}, nrow = ${2:nrow})",
+      "insertTextRules": 4,
+      "sortText": "01_matrix"
+    },
+    {
+      "label": "array",
+      "kind": 1,
+      "detail": "Create a multi-dimensional array",
+      "documentation": { "value": "Create a multi-dimensional array.\n\n```r\narray(1:24, dim = c(2, 3, 4))\n```" },
+      "insertText": "array(${1:data}, dim = c(${2:dims}))",
+      "insertTextRules": 4,
+      "sortText": "01_array"
+    },
+    {
+      "label": "list",
+      "kind": 1,
+      "detail": "Create a list",
+      "documentation": { "value": "Create a list (generic container).\n\n```r\nx <- list(a = 1, b = \"text\", c = TRUE)\nx[[1]]\nx$a\n```" },
+      "insertText": "list(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_list"
+    },
+    {
+      "label": "vector",
+      "kind": 1,
+      "detail": "Create a vector",
+      "documentation": { "value": "Create a vector of given mode and length.\n\n```r\nvector(\"numeric\", 5)     # 0 0 0 0 0\nvector(\"character\", 3)   # \"\" \"\" \"\"\n```" },
+      "insertText": "vector(\"${1:mode}\", ${2:length})",
+      "insertTextRules": 4,
+      "sortText": "01_vector"
+    },
+    {
+      "label": "factor",
+      "kind": 1,
+      "detail": "Create a factor",
+      "documentation": { "value": "Encode a vector as a factor (categorical variable).\n\n```r\nfactor(c(\"low\", \"med\", \"high\"), levels = c(\"low\", \"med\", \"high\"), ordered = TRUE)\n```" },
+      "insertText": "factor(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_factor"
+    },
+    {
+      "label": "read.csv",
+      "kind": 1,
+      "detail": "Read CSV file",
+      "documentation": { "value": "Read a CSV file into a data frame.\n\n```r\ndf <- read.csv(\"data.csv\")\ndf <- read.csv(\"data.csv\", stringsAsFactors = FALSE, na.strings = c(\"\", \"NA\"))\n```" },
+      "insertText": "read.csv(\"${1:file.csv}\")",
+      "insertTextRules": 4,
+      "sortText": "01_read.csv"
+    },
+    {
+      "label": "read.table",
+      "kind": 1,
+      "detail": "Read tabular data",
+      "documentation": { "value": "Read a table formatted file into a data frame.\n\n```r\ndf <- read.table(\"data.txt\", header = TRUE, sep = \"\\t\")\n```" },
+      "insertText": "read.table(\"${1:file}\", header = ${2:TRUE}, sep = \"${3:\\t}\")",
+      "insertTextRules": 4,
+      "sortText": "01_read.table"
+    },
+    {
+      "label": "write.csv",
+      "kind": 1,
+      "detail": "Write CSV file",
+      "documentation": { "value": "Write a data frame to a CSV file.\n\n```r\nwrite.csv(df, \"output.csv\", row.names = FALSE)\n```" },
+      "insertText": "write.csv(${1:x}, \"${2:file.csv}\", row.names = FALSE)",
+      "insertTextRules": 4,
+      "sortText": "01_write.csv"
+    },
+    {
+      "label": "write.table",
+      "kind": 1,
+      "detail": "Write tabular data",
+      "documentation": { "value": "Write a data frame to a file.\n\n```r\nwrite.table(df, \"output.txt\", sep = \"\\t\", row.names = FALSE)\n```" },
+      "insertText": "write.table(${1:x}, \"${2:file}\", sep = \"${3:\\t}\")",
+      "insertTextRules": 4,
+      "sortText": "01_write.table"
+    },
+    {
+      "label": "readRDS",
+      "kind": 1,
+      "detail": "Read RDS file",
+      "documentation": { "value": "Read a single R object from file.\n\n```r\nobj <- readRDS(\"data.rds\")\n```" },
+      "insertText": "readRDS(\"${1:file.rds}\")",
+      "insertTextRules": 4,
+      "sortText": "01_readRDS"
+    },
+    {
+      "label": "saveRDS",
+      "kind": 1,
+      "detail": "Save RDS file",
+      "documentation": { "value": "Serialize an R object to file.\n\n```r\nsaveRDS(obj, \"data.rds\")\n```" },
+      "insertText": "saveRDS(${1:object}, \"${2:file.rds}\")",
+      "insertTextRules": 4,
+      "sortText": "01_saveRDS"
+    },
+    {
+      "label": "file.path",
+      "kind": 1,
+      "detail": "Construct file paths",
+      "documentation": { "value": "Construct platform-independent file paths.\n\n```r\nfile.path(\"data\", \"input\", \"file.csv\")\n```" },
+      "insertText": "file.path(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "01_file.path"
+    },
+    {
+      "label": "file.exists",
+      "kind": 1,
+      "detail": "Check if file exists",
+      "documentation": { "value": "Test whether files exist.\n\n```r\nfile.exists(\"data.csv\")  # TRUE/FALSE\n```" },
+      "insertText": "file.exists(\"${1:path}\")",
+      "insertTextRules": 4,
+      "sortText": "01_file.exists"
+    },
+    {
+      "label": "dir.create",
+      "kind": 1,
+      "detail": "Create a directory",
+      "documentation": { "value": "Create a directory.\n\n```r\ndir.create(\"output\", recursive = TRUE, showWarnings = FALSE)\n```" },
+      "insertText": "dir.create(\"${1:path}\", recursive = TRUE)",
+      "insertTextRules": 4,
+      "sortText": "01_dir.create"
+    },
+    {
+      "label": "getwd",
+      "kind": 1,
+      "detail": "Get working directory",
+      "documentation": { "value": "Return the current working directory.\n\n```r\ngetwd()  # \"/home/user/project\"\n```" },
+      "insertText": "getwd()",
+      "sortText": "01_getwd"
+    },
+    {
+      "label": "setwd",
+      "kind": 1,
+      "detail": "Set working directory",
+      "documentation": { "value": "Change the working directory.\n\n```r\nsetwd(\"/path/to/project\")\n```" },
+      "insertText": "setwd(\"${1:dir}\")",
+      "insertTextRules": 4,
+      "sortText": "01_setwd"
+    },
+    {
+      "label": "Sys.time",
+      "kind": 1,
+      "detail": "Current date/time",
+      "documentation": { "value": "Return the current date and time.\n\n```r\nSys.time()  # \"2024-01-15 14:30:00 UTC\"\n```" },
+      "insertText": "Sys.time()",
+      "sortText": "01_Sys.time"
+    },
+    {
+      "label": "Sys.sleep",
+      "kind": 1,
+      "detail": "Pause execution",
+      "documentation": { "value": "Suspend execution for a given number of seconds.\n\n```r\nSys.sleep(2)  # pause 2 seconds\n```" },
+      "insertText": "Sys.sleep(${1:seconds})",
+      "insertTextRules": 4,
+      "sortText": "01_Sys.sleep"
+    },
+    {
+      "label": "system",
+      "kind": 1,
+      "detail": "Run system command",
+      "documentation": { "value": "Invoke an OS command.\n\n```r\nsystem(\"ls -la\")\noutput <- system(\"whoami\", intern = TRUE)\n```" },
+      "insertText": "system(\"${1:command}\", intern = ${2:TRUE})",
+      "insertTextRules": 4,
+      "sortText": "01_system"
+    },
+    {
+      "label": "system2",
+      "kind": 1,
+      "detail": "Run system command (modern)",
+      "documentation": { "value": "Invoke an OS command (safer interface).\n\n```r\nsystem2(\"git\", c(\"status\", \"--short\"), stdout = TRUE)\n```" },
+      "insertText": "system2(\"${1:command}\", args = c(${2:}))",
+      "insertTextRules": 4,
+      "sortText": "01_system2"
+    },
+    {
+      "label": "tryCatch",
+      "kind": 1,
+      "detail": "Error handling",
+      "documentation": { "value": "Handle errors and conditions.\n\n```r\nresult <- tryCatch({\n  log(-1)\n}, warning = function(w) {\n  message(\"Warning: \", w$message)\n}, error = function(e) {\n  message(\"Error: \", e$message)\n  NA\n}, finally = {\n  cat(\"Done\\n\")\n})\n```" },
+      "insertText": "tryCatch({\n  ${1}\n}, error = function(e) {\n  ${2:message(e$message)}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_tryCatch"
+    },
+    {
+      "label": "withCallingHandlers",
+      "kind": 1,
+      "detail": "Condition handler (non-exiting)",
+      "documentation": { "value": "Establish calling handlers for conditions.\n\n```r\nwithCallingHandlers(\n  expr,\n  warning = function(w) invokeRestart(\"muffleWarning\")\n)\n```" },
+      "insertText": "withCallingHandlers({\n  ${1}\n}, warning = function(w) {\n  ${2}\n})",
+      "insertTextRules": 4,
+      "sortText": "01_withCallingHandlers"
+    },
+    {
+      "label": "stop",
+      "kind": 1,
+      "detail": "Signal an error",
+      "documentation": { "value": "Stop execution and signal an error condition.\n\n```r\nstop(\"invalid argument\")\nstop(\"x must be > 0, got: \", x)\n```" },
+      "insertText": "stop(\"${1:message}\")",
+      "insertTextRules": 4,
+      "sortText": "01_stop"
+    },
+    {
+      "label": "warning",
+      "kind": 1,
+      "detail": "Signal a warning",
+      "documentation": { "value": "Generate a warning message.\n\n```r\nwarning(\"deprecated function\")\nwarning(\"NAs introduced by coercion\", call. = FALSE)\n```" },
+      "insertText": "warning(\"${1:message}\")",
+      "insertTextRules": 4,
+      "sortText": "01_warning"
+    },
+    {
+      "label": "message",
+      "kind": 1,
+      "detail": "Diagnostic message",
+      "documentation": { "value": "Generate a diagnostic message (to stderr).\n\n```r\nmessage(\"Processing file: \", filename)\nmessage(\"Step \", i, \" of \", n)\n```" },
+      "insertText": "message(\"${1:...}\")",
+      "insertTextRules": 4,
+      "sortText": "01_message"
+    },
+    {
+      "label": "format",
+      "kind": 1,
+      "detail": "Format values",
+      "documentation": { "value": "Format an R object for pretty printing.\n\n```r\nformat(3.14159, digits = 3)  # \"3.14\"\nformat(Sys.Date(), \"%Y-%m-%d\")\n```" },
+      "insertText": "format(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_format"
+    },
+    {
+      "label": "substr",
+      "kind": 1,
+      "detail": "Extract/replace substring",
+      "documentation": { "value": "Extract or replace substrings.\n\n```r\nsubstr(\"Hello\", 1, 3)  # \"Hel\"\n```" },
+      "insertText": "substr(${1:x}, ${2:start}, ${3:stop})",
+      "insertTextRules": 4,
+      "sortText": "01_substr"
+    },
+    {
+      "label": "substring",
+      "kind": 1,
+      "detail": "Extract substring (vectorized)",
+      "documentation": { "value": "Extract substrings (compatible with replacement).\n\n```r\nsubstring(\"Hello world\", 7)  # \"world\"\n```" },
+      "insertText": "substring(${1:text}, ${2:first})",
+      "insertTextRules": 4,
+      "sortText": "01_substring"
+    },
+    {
+      "label": "gsub",
+      "kind": 1,
+      "detail": "Global pattern replacement",
+      "documentation": { "value": "Replace all occurrences of a pattern.\n\n```r\ngsub(\"o\", \"0\", \"foo bar boo\")  # \"f00 bar b00\"\ngsub(\"[[:space:]]+\", \"_\", text)\n```" },
+      "insertText": "gsub(\"${1:pattern}\", \"${2:replacement}\", ${3:x})",
+      "insertTextRules": 4,
+      "sortText": "01_gsub"
+    },
+    {
+      "label": "sub",
+      "kind": 1,
+      "detail": "First pattern replacement",
+      "documentation": { "value": "Replace the first occurrence of a pattern.\n\n```r\nsub(\"o\", \"0\", \"foo\")  # \"f0o\"\n```" },
+      "insertText": "sub(\"${1:pattern}\", \"${2:replacement}\", ${3:x})",
+      "insertTextRules": 4,
+      "sortText": "01_sub"
+    },
+    {
+      "label": "grep",
+      "kind": 1,
+      "detail": "Pattern matching (indices)",
+      "documentation": { "value": "Search for pattern matches and return indices.\n\n```r\ngrep(\"^a\", c(\"apple\", \"banana\", \"avocado\"))  # 1 3\ngrep(\"error\", log_lines, value = TRUE)\n```" },
+      "insertText": "grep(\"${1:pattern}\", ${2:x})",
+      "insertTextRules": 4,
+      "sortText": "01_grep"
+    },
+    {
+      "label": "grepl",
+      "kind": 1,
+      "detail": "Pattern matching (logical)",
+      "documentation": { "value": "Test for pattern matches, return logical vector.\n\n```r\ngrepl(\"^a\", c(\"apple\", \"banana\"))  # TRUE FALSE\n```" },
+      "insertText": "grepl(\"${1:pattern}\", ${2:x})",
+      "insertTextRules": 4,
+      "sortText": "01_grepl"
+    },
+    {
+      "label": "regexpr",
+      "kind": 1,
+      "detail": "First regex match position",
+      "documentation": { "value": "Find the first match of a pattern.\n\n```r\nm <- regexpr(\"[0-9]+\", \"abc123def\")\nregmatches(\"abc123def\", m)  # \"123\"\n```" },
+      "insertText": "regexpr(\"${1:pattern}\", ${2:text})",
+      "insertTextRules": 4,
+      "sortText": "01_regexpr"
+    },
+    {
+      "label": "gregexpr",
+      "kind": 1,
+      "detail": "All regex match positions",
+      "documentation": { "value": "Find all matches of a pattern.\n\n```r\nm <- gregexpr(\"[0-9]+\", \"a1b2c3\")\nregmatches(\"a1b2c3\", m)  # list(c(\"1\", \"2\", \"3\"))\n```" },
+      "insertText": "gregexpr(\"${1:pattern}\", ${2:text})",
+      "insertTextRules": 4,
+      "sortText": "01_gregexpr"
+    },
+    {
+      "label": "strsplit",
+      "kind": 1,
+      "detail": "Split strings",
+      "documentation": { "value": "Split character strings by a pattern.\n\n```r\nstrsplit(\"a,b,c\", \",\")  # list(c(\"a\", \"b\", \"c\"))\nstrsplit(\"hello\", \"\")    # list(c(\"h\",\"e\",\"l\",\"l\",\"o\"))\n```" },
+      "insertText": "strsplit(${1:x}, \"${2:split}\")",
+      "insertTextRules": 4,
+      "sortText": "01_strsplit"
+    },
+    {
+      "label": "trimws",
+      "kind": 1,
+      "detail": "Trim whitespace",
+      "documentation": { "value": "Remove leading and/or trailing whitespace.\n\n```r\ntrimws(\"  hello  \")        # \"hello\"\ntrimws(\"  hello  \", \"left\")  # \"hello  \"\n```" },
+      "insertText": "trimws(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_trimws"
+    },
+    {
+      "label": "toupper",
+      "kind": 1,
+      "detail": "Convert to uppercase",
+      "documentation": { "value": "Convert strings to uppercase.\n\n```r\ntoupper(\"hello\")  # \"HELLO\"\n```" },
+      "insertText": "toupper(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_toupper"
+    },
+    {
+      "label": "tolower",
+      "kind": 1,
+      "detail": "Convert to lowercase",
+      "documentation": { "value": "Convert strings to lowercase.\n\n```r\ntolower(\"HELLO\")  # \"hello\"\n```" },
+      "insertText": "tolower(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "01_tolower"
+    },
+    {
+      "label": "startsWith",
+      "kind": 1,
+      "detail": "Test if string starts with prefix",
+      "documentation": { "value": "Test if strings start with a prefix.\n\n```r\nstartsWith(\"Hello\", \"He\")  # TRUE\n```" },
+      "insertText": "startsWith(${1:x}, \"${2:prefix}\")",
+      "insertTextRules": 4,
+      "sortText": "01_startsWith"
+    },
+    {
+      "label": "endsWith",
+      "kind": 1,
+      "detail": "Test if string ends with suffix",
+      "documentation": { "value": "Test if strings end with a suffix.\n\n```r\nendsWith(\"file.csv\", \".csv\")  # TRUE\n```" },
+      "insertText": "endsWith(${1:x}, \"${2:suffix}\")",
+      "insertTextRules": 4,
+      "sortText": "01_endsWith"
+    },
+    {
+      "label": "apply",
+      "kind": 1,
+      "detail": "Apply function over margins",
+      "documentation": { "value": "Apply a function over rows or columns of a matrix.\n\n```r\napply(mat, 1, sum)  # row sums\napply(mat, 2, mean) # column means\n```" },
+      "insertText": "apply(${1:X}, ${2:MARGIN}, ${3:FUN})",
+      "insertTextRules": 4,
+      "sortText": "01_apply"
+    },
+    {
+      "label": "sapply",
+      "kind": 1,
+      "detail": "Apply and simplify",
+      "documentation": { "value": "Apply a function and simplify the result.\n\n```r\nsapply(1:5, function(x) x^2)  # 1 4 9 16 25\nsapply(df, class)\n```" },
+      "insertText": "sapply(${1:X}, ${2:FUN})",
+      "insertTextRules": 4,
+      "sortText": "01_sapply"
+    },
+    {
+      "label": "lapply",
+      "kind": 1,
+      "detail": "Apply and return list",
+      "documentation": { "value": "Apply a function over a list and return a list.\n\n```r\nlapply(1:3, function(x) x^2)  # list(1, 4, 9)\nlapply(files, read.csv)\n```" },
+      "insertText": "lapply(${1:X}, ${2:FUN})",
+      "insertTextRules": 4,
+      "sortText": "01_lapply"
+    },
+    {
+      "label": "vapply",
+      "kind": 1,
+      "detail": "Apply with type-safe return",
+      "documentation": { "value": "Apply with specified return type (safer than sapply).\n\n```r\nvapply(1:5, sqrt, numeric(1))\n```" },
+      "insertText": "vapply(${1:X}, ${2:FUN}, ${3:FUN.VALUE})",
+      "insertTextRules": 4,
+      "sortText": "01_vapply"
+    },
+    {
+      "label": "tapply",
+      "kind": 1,
+      "detail": "Apply by groups",
+      "documentation": { "value": "Apply a function to groups defined by an index.\n\n```r\ntapply(mtcars$mpg, mtcars$cyl, mean)\n```" },
+      "insertText": "tapply(${1:X}, ${2:INDEX}, ${3:FUN})",
+      "insertTextRules": 4,
+      "sortText": "01_tapply"
+    },
+    {
+      "label": "mapply",
+      "kind": 1,
+      "detail": "Multivariate apply",
+      "documentation": { "value": "Apply a function to multiple lists/vectors element-wise.\n\n```r\nmapply(rep, 1:4, 4:1)  # rep(1,4), rep(2,3), etc.\n```" },
+      "insertText": "mapply(${1:FUN}, ${2:...})",
+      "insertTextRules": 4,
+      "sortText": "01_mapply"
+    },
+    {
+      "label": "Map",
+      "kind": 1,
+      "detail": "Wrapper for mapply (no simplify)",
+      "documentation": { "value": "Apply a function to corresponding elements (returns list).\n\n```r\nMap(`+`, 1:3, 4:6)  # list(5, 7, 9)\n```" },
+      "insertText": "Map(${1:f}, ${2:...})",
+      "insertTextRules": 4,
+      "sortText": "01_Map"
+    },
+    {
+      "label": "Reduce",
+      "kind": 1,
+      "detail": "Reduce a list to a single value",
+      "documentation": { "value": "Apply a binary function cumulatively.\n\n```r\nReduce(`+`, 1:5)  # 15\nReduce(merge, list_of_dfs)\n```" },
+      "insertText": "Reduce(${1:f}, ${2:x})",
+      "insertTextRules": 4,
+      "sortText": "01_Reduce"
+    },
+    {
+      "label": "Filter",
+      "kind": 1,
+      "detail": "Filter elements by predicate",
+      "documentation": { "value": "Select elements for which a function returns TRUE.\n\n```r\nFilter(is.numeric, my_list)\nFilter(function(x) x > 0, vec)\n```" },
+      "insertText": "Filter(${1:f}, ${2:x})",
+      "insertTextRules": 4,
+      "sortText": "01_Filter"
+    },
+    {
+      "label": "do.call",
+      "kind": 1,
+      "detail": "Call a function with args list",
+      "documentation": { "value": "Execute a function call with arguments from a list.\n\n```r\ndo.call(rbind, list_of_dfs)\ndo.call(paste, c(words, sep = \"-\"))\n```" },
+      "insertText": "do.call(${1:what}, ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "01_do.call"
+    },
+    {
+      "label": "Vectorize",
+      "kind": 1,
+      "detail": "Vectorize a scalar function",
+      "documentation": { "value": "Create a vectorized version of a function.\n\n```r\nvfunc <- Vectorize(my_scalar_func)\nvfunc(1:5)\n```" },
+      "insertText": "Vectorize(${1:FUN})",
+      "insertTextRules": 4,
+      "sortText": "01_Vectorize"
+    },
+    {
+      "label": "ifelse",
+      "kind": 1,
+      "detail": "Vectorized conditional",
+      "documentation": { "value": "Vectorized conditional: returns values depending on test.\n\n```r\nifelse(x > 0, \"pos\", \"non-pos\")\nifelse(is.na(x), 0, x)\n```" },
+      "insertText": "ifelse(${1:test}, ${2:yes}, ${3:no})",
+      "insertTextRules": 4,
+      "sortText": "01_ifelse"
+    },
+    {
+      "label": "plot",
+      "kind": 1,
+      "detail": "Generic X-Y plotting",
+      "documentation": { "value": "Generic function for plotting R objects.\n\n```r\nplot(x, y)\nplot(1:10, main = \"Title\", xlab = \"X\", ylab = \"Y\", type = \"l\")\n```" },
+      "insertText": "plot(${1:x}, ${2:y})",
+      "insertTextRules": 4,
+      "sortText": "02_plot"
+    },
+    {
+      "label": "hist",
+      "kind": 1,
+      "detail": "Histogram",
+      "documentation": { "value": "Draw a histogram.\n\n```r\nhist(rnorm(1000))\nhist(x, breaks = 30, col = \"steelblue\", main = \"Distribution\")\n```" },
+      "insertText": "hist(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "02_hist"
+    },
+    {
+      "label": "barplot",
+      "kind": 1,
+      "detail": "Bar plot",
+      "documentation": { "value": "Draw a bar plot.\n\n```r\nbarplot(table(x), col = \"steelblue\")\nbarplot(height, names.arg = labels)\n```" },
+      "insertText": "barplot(${1:height})",
+      "insertTextRules": 4,
+      "sortText": "02_barplot"
+    },
+    {
+      "label": "boxplot",
+      "kind": 1,
+      "detail": "Box-and-whisker plot",
+      "documentation": { "value": "Produce box-and-whisker plots.\n\n```r\nboxplot(mpg ~ cyl, data = mtcars)\n```" },
+      "insertText": "boxplot(${1:formula}, data = ${2:df})",
+      "insertTextRules": 4,
+      "sortText": "02_boxplot"
+    },
+    {
+      "label": "lines",
+      "kind": 1,
+      "detail": "Add lines to a plot",
+      "documentation": { "value": "Add connected line segments to an existing plot.\n\n```r\nlines(x, y, col = \"red\", lty = 2)\n```" },
+      "insertText": "lines(${1:x}, ${2:y})",
+      "insertTextRules": 4,
+      "sortText": "02_lines"
+    },
+    {
+      "label": "points",
+      "kind": 1,
+      "detail": "Add points to a plot",
+      "documentation": { "value": "Add points to an existing plot.\n\n```r\npoints(x, y, col = \"red\", pch = 19)\n```" },
+      "insertText": "points(${1:x}, ${2:y})",
+      "insertTextRules": 4,
+      "sortText": "02_points"
+    },
+    {
+      "label": "abline",
+      "kind": 1,
+      "detail": "Add straight line to a plot",
+      "documentation": { "value": "Add straight lines to a plot.\n\n```r\nabline(h = 0, col = \"gray\")\nabline(v = mean(x), lty = 2)\nabline(lm_fit, col = \"red\")\n```" },
+      "insertText": "abline(${1:a}, ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "02_abline"
+    },
+    {
+      "label": "legend",
+      "kind": 1,
+      "detail": "Add legend to a plot",
+      "documentation": { "value": "Add a legend to a plot.\n\n```r\nlegend(\"topright\", legend = c(\"A\", \"B\"), col = c(\"red\", \"blue\"), lty = 1)\n```" },
+      "insertText": "legend(\"${1:topright}\", legend = c(${2:...}))",
+      "insertTextRules": 4,
+      "sortText": "02_legend"
+    },
+    {
+      "label": "title",
+      "kind": 1,
+      "detail": "Add title to a plot",
+      "documentation": { "value": "Add annotations to a plot.\n\n```r\ntitle(main = \"Main Title\", sub = \"Subtitle\", xlab = \"X\", ylab = \"Y\")\n```" },
+      "insertText": "title(main = \"${1:Title}\")",
+      "insertTextRules": 4,
+      "sortText": "02_title"
+    },
+    {
+      "label": "par",
+      "kind": 1,
+      "detail": "Set graphical parameters",
+      "documentation": { "value": "Set or query graphical parameters.\n\n```r\npar(mfrow = c(2, 2))  # 2x2 plot layout\npar(mar = c(5, 4, 4, 2) + 0.1)\n```" },
+      "insertText": "par(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "02_par"
+    },
+    {
+      "label": "ggplot",
+      "kind": 1,
+      "detail": "Create a ggplot2 plot",
+      "documentation": { "value": "Initialize a ggplot2 plot.\n\n```r\nlibrary(ggplot2)\nggplot(df, aes(x = x, y = y)) +\n  geom_point() +\n  theme_minimal()\n```" },
+      "insertText": "ggplot(${1:data}, aes(x = ${2:x}, y = ${3:y})) +\n  ${4:geom_point()}",
+      "insertTextRules": 4,
+      "sortText": "02_ggplot"
+    },
+    {
+      "label": "aes",
+      "kind": 1,
+      "detail": "Aesthetic mapping (ggplot2)",
+      "documentation": { "value": "Define aesthetic mappings for ggplot2.\n\n```r\naes(x = var1, y = var2, color = group)\naes(fill = category, size = value)\n```" },
+      "insertText": "aes(x = ${1:x}, y = ${2:y})",
+      "insertTextRules": 4,
+      "sortText": "02_aes"
+    },
+    {
+      "label": "geom_point",
+      "kind": 1,
+      "detail": "Scatter plot layer (ggplot2)",
+      "documentation": { "value": "Add a scatter plot layer.\n\n```r\nggplot(df, aes(x, y)) + geom_point(size = 3, alpha = 0.7)\n```" },
+      "insertText": "geom_point(${1:})",
+      "insertTextRules": 4,
+      "sortText": "02_geom_point"
+    },
+    {
+      "label": "geom_line",
+      "kind": 1,
+      "detail": "Line plot layer (ggplot2)",
+      "documentation": { "value": "Add a line plot layer.\n\n```r\nggplot(df, aes(x, y)) + geom_line(color = \"blue\")\n```" },
+      "insertText": "geom_line(${1:})",
+      "insertTextRules": 4,
+      "sortText": "02_geom_line"
+    },
+    {
+      "label": "geom_bar",
+      "kind": 1,
+      "detail": "Bar chart layer (ggplot2)",
+      "documentation": { "value": "Add a bar chart layer.\n\n```r\nggplot(df, aes(x = category)) + geom_bar()\nggplot(df, aes(x = cat, y = val)) + geom_bar(stat = \"identity\")\n```" },
+      "insertText": "geom_bar(${1:})",
+      "insertTextRules": 4,
+      "sortText": "02_geom_bar"
+    },
+    {
+      "label": "facet_wrap",
+      "kind": 1,
+      "detail": "Facet by variable (ggplot2)",
+      "documentation": { "value": "Facet a plot by a single variable.\n\n```r\nggplot(df, aes(x, y)) + geom_point() + facet_wrap(~group)\n```" },
+      "insertText": "facet_wrap(~${1:variable})",
+      "insertTextRules": 4,
+      "sortText": "02_facet_wrap"
+    },
+    {
+      "label": "theme",
+      "kind": 1,
+      "detail": "Customize plot theme (ggplot2)",
+      "documentation": { "value": "Modify the non-data components of a plot.\n\n```r\ntheme_minimal()\ntheme(axis.text.x = element_text(angle = 45, hjust = 1))\n```" },
+      "insertText": "theme(${1:})",
+      "insertTextRules": 4,
+      "sortText": "02_theme"
+    },
+    {
+      "label": "install.packages",
+      "kind": 1,
+      "detail": "Install CRAN packages",
+      "documentation": { "value": "Download and install packages from CRAN.\n\n```r\ninstall.packages(\"dplyr\")\ninstall.packages(c(\"ggplot2\", \"tidyr\"))\n```" },
+      "insertText": "install.packages(\"${1:package}\")",
+      "insertTextRules": 4,
+      "sortText": "03_install.packages"
+    },
+    {
+      "label": "remove.packages",
+      "kind": 1,
+      "detail": "Remove installed packages",
+      "documentation": { "value": "Remove installed packages.\n\n```r\nremove.packages(\"old_pkg\")\n```" },
+      "insertText": "remove.packages(\"${1:package}\")",
+      "insertTextRules": 4,
+      "sortText": "03_remove.packages"
+    },
+    {
+      "label": "loadNamespace",
+      "kind": 1,
+      "detail": "Load a namespace without attaching",
+      "documentation": { "value": "Load the namespace of a package without attaching it.\n\n```r\nns <- loadNamespace(\"dplyr\")\n```" },
+      "insertText": "loadNamespace(\"${1:package}\")",
+      "insertTextRules": 4,
+      "sortText": "03_loadNamespace"
+    },
+    {
+      "label": "packageVersion",
+      "kind": 1,
+      "detail": "Get package version",
+      "documentation": { "value": "Return the version of an installed package.\n\n```r\npackageVersion(\"ggplot2\")  # '3.4.4'\n```" },
+      "insertText": "packageVersion(\"${1:package}\")",
+      "insertTextRules": 4,
+      "sortText": "03_packageVersion"
+    },
+    {
+      "label": "update.packages",
+      "kind": 1,
+      "detail": "Update installed packages",
+      "documentation": { "value": "Update outdated packages.\n\n```r\nupdate.packages(ask = FALSE)\n```" },
+      "insertText": "update.packages(ask = FALSE)",
+      "sortText": "03_update.packages"
+    },
+    {
+      "label": "available.packages",
+      "kind": 1,
+      "detail": "List available packages on CRAN",
+      "documentation": { "value": "Return a matrix of available packages on CRAN.\n\n```r\npkgs <- available.packages()\n```" },
+      "insertText": "available.packages()",
+      "sortText": "03_available.packages"
+    },
+    {
+      "label": "lm",
+      "kind": 1,
+      "detail": "Fit a linear model",
+      "documentation": { "value": "Fit a linear model using ordinary least squares.\n\n```r\nfit <- lm(y ~ x1 + x2, data = df)\nsummary(fit)\ncoef(fit)\n```" },
+      "insertText": "lm(${1:formula}, data = ${2:df})",
+      "insertTextRules": 4,
+      "sortText": "03_lm"
+    },
+    {
+      "label": "glm",
+      "kind": 1,
+      "detail": "Fit a generalized linear model",
+      "documentation": { "value": "Fit a generalized linear model.\n\n```r\nfit <- glm(y ~ x, data = df, family = binomial)\nsummary(fit)\n```" },
+      "insertText": "glm(${1:formula}, data = ${2:df}, family = ${3:binomial})",
+      "insertTextRules": 4,
+      "sortText": "03_glm"
+    },
+    {
+      "label": "t.test",
+      "kind": 1,
+      "detail": "Student's t-test",
+      "documentation": { "value": "Perform a t-test.\n\n```r\nt.test(x, mu = 0)\nt.test(x, y, paired = TRUE)\n```" },
+      "insertText": "t.test(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_t.test"
+    },
+    {
+      "label": "cor",
+      "kind": 1,
+      "detail": "Correlation",
+      "documentation": { "value": "Compute correlation between vectors or columns.\n\n```r\ncor(x, y)\ncor(df, use = \"complete.obs\")\n```" },
+      "insertText": "cor(${1:x}, ${2:y})",
+      "insertTextRules": 4,
+      "sortText": "03_cor"
+    },
+    {
+      "label": "cor.test",
+      "kind": 1,
+      "detail": "Test for correlation",
+      "documentation": { "value": "Test for association between paired samples.\n\n```r\ncor.test(x, y, method = \"pearson\")\n```" },
+      "insertText": "cor.test(${1:x}, ${2:y})",
+      "insertTextRules": 4,
+      "sortText": "03_cor.test"
+    },
+    {
+      "label": "chisq.test",
+      "kind": 1,
+      "detail": "Chi-squared test",
+      "documentation": { "value": "Perform a chi-squared test.\n\n```r\nchisq.test(table(x, y))\n```" },
+      "insertText": "chisq.test(${1:x})",
+      "insertTextRules": 4,
+      "sortText": "03_chisq.test"
+    },
+    {
+      "label": "aov",
+      "kind": 1,
+      "detail": "Analysis of variance",
+      "documentation": { "value": "Fit an analysis of variance model.\n\n```r\nfit <- aov(y ~ group, data = df)\nsummary(fit)\n```" },
+      "insertText": "aov(${1:formula}, data = ${2:df})",
+      "insertTextRules": 4,
+      "sortText": "03_aov"
+    },
+    {
+      "label": "anova",
+      "kind": 1,
+      "detail": "ANOVA table",
+      "documentation": { "value": "Compute analysis of variance tables for fitted model objects.\n\n```r\nanova(fit1)\nanova(fit1, fit2)\n```" },
+      "insertText": "anova(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "03_anova"
+    },
+    {
+      "label": "predict",
+      "kind": 1,
+      "detail": "Model predictions",
+      "documentation": { "value": "Obtain predictions from a fitted model.\n\n```r\npredict(fit, newdata = test_df)\npredict(fit, interval = \"confidence\")\n```" },
+      "insertText": "predict(${1:object}, newdata = ${2:newdata})",
+      "insertTextRules": 4,
+      "sortText": "03_predict"
+    },
+    {
+      "label": "residuals",
+      "kind": 1,
+      "detail": "Model residuals",
+      "documentation": { "value": "Extract model residuals.\n\n```r\nresiduals(fit)\nresid(fit)  # alias\n```" },
+      "insertText": "residuals(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "03_residuals"
+    },
+    {
+      "label": "fitted",
+      "kind": 1,
+      "detail": "Fitted values",
+      "documentation": { "value": "Extract fitted values from a model.\n\n```r\nfitted(fit)\n```" },
+      "insertText": "fitted(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "03_fitted"
+    },
+    {
+      "label": "confint",
+      "kind": 1,
+      "detail": "Confidence intervals",
+      "documentation": { "value": "Compute confidence intervals for model parameters.\n\n```r\nconfint(fit)\nconfint(fit, level = 0.99)\n```" },
+      "insertText": "confint(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "03_confint"
+    },
+    {
+      "label": "coef",
+      "kind": 1,
+      "detail": "Model coefficients",
+      "documentation": { "value": "Extract model coefficients.\n\n```r\ncoef(fit)\n```" },
+      "insertText": "coef(${1:object})",
+      "insertTextRules": 4,
+      "sortText": "03_coef"
+    },
+    {
+      "label": "setClass",
+      "kind": 1,
+      "detail": "Define S4 class",
+      "documentation": { "value": "Create an S4 class definition.\n\n```r\nsetClass(\"Person\", representation(\n  name = \"character\",\n  age = \"numeric\"\n))\n```" },
+      "insertText": "setClass(\"${1:Class}\", representation(\n  ${2:slot} = \"${3:type}\"\n))",
+      "insertTextRules": 4,
+      "sortText": "04_setClass"
+    },
+    {
+      "label": "setGeneric",
+      "kind": 1,
+      "detail": "Define S4 generic",
+      "documentation": { "value": "Create an S4 generic function.\n\n```r\nsetGeneric(\"greet\", function(object) standardGeneric(\"greet\"))\n```" },
+      "insertText": "setGeneric(\"${1:name}\", function(${2:object}) standardGeneric(\"${1:name}\"))",
+      "insertTextRules": 4,
+      "sortText": "04_setGeneric"
+    },
+    {
+      "label": "setMethod",
+      "kind": 1,
+      "detail": "Define S4 method",
+      "documentation": { "value": "Define an S4 method for a generic.\n\n```r\nsetMethod(\"greet\", \"Person\", function(object) {\n  cat(\"Hello,\", object@name, \"\\n\")\n})\n```" },
+      "insertText": "setMethod(\"${1:generic}\", \"${2:Class}\", function(${3:object}) {\n  ${4}\n})",
+      "insertTextRules": 4,
+      "sortText": "04_setMethod"
+    },
+    {
+      "label": "setRefClass",
+      "kind": 1,
+      "detail": "Define reference class (R5)",
+      "documentation": { "value": "Create a mutable reference class.\n\n```r\nPerson <- setRefClass(\"Person\",\n  fields = list(name = \"character\", age = \"numeric\"),\n  methods = list(\n    greet = function() cat(\"Hello,\", name, \"\\n\")\n  )\n)\n```" },
+      "insertText": "setRefClass(\"${1:Class}\",\n  fields = list(${2:}),\n  methods = list(${3:})\n)",
+      "insertTextRules": 4,
+      "sortText": "04_setRefClass"
+    },
+    {
+      "label": "R6Class",
+      "kind": 1,
+      "detail": "Define R6 class",
+      "documentation": { "value": "Create an R6 class (requires R6 package).\n\n```r\nlibrary(R6)\nPerson <- R6Class(\"Person\",\n  public = list(\n    name = NULL,\n    initialize = function(name) self$name <- name,\n    greet = function() cat(\"Hello,\", self$name, \"\\n\")\n  )\n)\np <- Person$new(\"Alice\")\n```" },
+      "insertText": "R6Class(\"${1:Class}\",\n  public = list(\n    initialize = function(${2:}) {\n      ${3}\n    }\n  )\n)",
+      "insertTextRules": 4,
+      "sortText": "04_R6Class"
+    },
+    {
+      "label": "new.env",
+      "kind": 1,
+      "detail": "Create a new environment",
+      "documentation": { "value": "Create a new environment.\n\n```r\ne <- new.env(parent = emptyenv())\nassign(\"x\", 42, envir = e)\n```" },
+      "insertText": "new.env(parent = ${1:emptyenv()})",
+      "insertTextRules": 4,
+      "sortText": "04_new.env"
+    },
+    {
+      "label": "environment",
+      "kind": 1,
+      "detail": "Get/set function environment",
+      "documentation": { "value": "Get or set the environment of a function.\n\n```r\nenvironment(my_func)\nenvironment()  # current environment\n```" },
+      "insertText": "environment(${1:fun})",
+      "insertTextRules": 4,
+      "sortText": "04_environment"
+    },
+    {
+      "label": "globalenv",
+      "kind": 1,
+      "detail": "Global environment",
+      "documentation": { "value": "Return the global environment.\n\n```r\nglobalenv()\nls(envir = globalenv())\n```" },
+      "insertText": "globalenv()",
+      "sortText": "04_globalenv"
+    },
+    {
+      "label": "baseenv",
+      "kind": 1,
+      "detail": "Base environment",
+      "documentation": { "value": "Return the base environment.\n\n```r\nbaseenv()\n```" },
+      "insertText": "baseenv()",
+      "sortText": "04_baseenv"
+    },
+    {
+      "label": "emptyenv",
+      "kind": 1,
+      "detail": "Empty environment",
+      "documentation": { "value": "Return the empty environment (has no parent).\n\n```r\nemptyenv()\n```" },
+      "insertText": "emptyenv()",
+      "sortText": "04_emptyenv"
+    },
+    {
+      "label": "parent.env",
+      "kind": 1,
+      "detail": "Parent environment",
+      "documentation": { "value": "Return or set the parent (enclosing) environment.\n\n```r\nparent.env(e)\n```" },
+      "insertText": "parent.env(${1:env})",
+      "insertTextRules": 4,
+      "sortText": "04_parent.env"
+    },
+    {
+      "label": "exists",
+      "kind": 1,
+      "detail": "Check if variable exists",
+      "documentation": { "value": "Check if a variable exists in an environment.\n\n```r\nexists(\"x\")                    # TRUE/FALSE\nexists(\"x\", envir = my_env)\n```" },
+      "insertText": "exists(\"${1:name}\")",
+      "insertTextRules": 4,
+      "sortText": "04_exists"
+    },
+    {
+      "label": "get",
+      "kind": 1,
+      "detail": "Get value of variable",
+      "documentation": { "value": "Retrieve a variable by name.\n\n```r\nget(\"x\")\nget(\"func\", envir = ns)\n```" },
+      "insertText": "get(\"${1:name}\")",
+      "insertTextRules": 4,
+      "sortText": "04_get"
+    },
+    {
+      "label": "assign",
+      "kind": 1,
+      "detail": "Assign value to variable",
+      "documentation": { "value": "Assign a value to a name in an environment.\n\n```r\nassign(\"x\", 42)\nassign(\"y\", 100, envir = my_env)\n```" },
+      "insertText": "assign(\"${1:name}\", ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "04_assign"
+    },
+    {
+      "label": "rm",
+      "kind": 1,
+      "detail": "Remove objects",
+      "documentation": { "value": "Remove objects from an environment.\n\n```r\nrm(x, y)\nrm(list = ls())  # clear all\n```" },
+      "insertText": "rm(${1:...})",
+      "insertTextRules": 4,
+      "sortText": "04_rm"
+    },
+    {
+      "label": "ls",
+      "kind": 1,
+      "detail": "List objects",
+      "documentation": { "value": "List objects in an environment.\n\n```r\nls()\nls(envir = my_env)\nls(pattern = \"^data\")\n```" },
+      "insertText": "ls()",
+      "sortText": "04_ls"
+    },
+    {
+      "label": "attach",
+      "kind": 1,
+      "detail": "Attach data to search path",
+      "documentation": { "value": "Attach a data frame or list to the search path.\n\n```r\nattach(mtcars)\nmpg  # directly accessible\ndetach(mtcars)\n```" },
+      "insertText": "attach(${1:what})",
+      "insertTextRules": 4,
+      "sortText": "04_attach"
+    },
+    {
+      "label": "detach",
+      "kind": 1,
+      "detail": "Detach from search path",
+      "documentation": { "value": "Detach a previously attached object.\n\n```r\ndetach(mtcars)\ndetach(\"package:dplyr\")\n```" },
+      "insertText": "detach(${1:name})",
+      "insertTextRules": 4,
+      "sortText": "04_detach"
+    },
+    {
+      "label": "search",
+      "kind": 1,
+      "detail": "Show search path",
+      "documentation": { "value": "Return the current search path.\n\n```r\nsearch()\n# \".GlobalEnv\" \"package:stats\" ...\n```" },
+      "insertText": "search()",
+      "sortText": "04_search"
+    },
+    {
+      "label": "for_loop",
+      "kind": 27,
+      "detail": "Snippet: for loop",
+      "documentation": { "value": "Standard for loop iterating over a sequence.\n\n```r\nfor (i in 1:n) {\n  # body\n}\n```" },
+      "insertText": "for (${1:i} in ${2:1:n}) {\n  ${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "05_for_loop"
+    },
+    {
+      "label": "while_loop",
+      "kind": 27,
+      "detail": "Snippet: while loop",
+      "documentation": { "value": "While loop.\n\n```r\nwhile (condition) {\n  # body\n}\n```" },
+      "insertText": "while (${1:condition}) {\n  ${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "05_while_loop"
+    },
+    {
+      "label": "func_def",
+      "kind": 27,
+      "detail": "Snippet: function definition",
+      "documentation": { "value": "Define a named function.\n\n```r\nmy_func <- function(x, y = 1) {\n  x + y\n}\n```" },
+      "insertText": "${1:name} <- function(${2:args}) {\n  ${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "05_func_def"
+    },
+    {
+      "label": "if_else_block",
+      "kind": 27,
+      "detail": "Snippet: if-else block",
+      "documentation": { "value": "Full if/else if/else block.\n\n```r\nif (cond1) {\n  # ...\n} else if (cond2) {\n  # ...\n} else {\n  # ...\n}\n```" },
+      "insertText": "if (${1:condition}) {\n  ${2}\n} else {\n  ${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "05_if_else_block"
+    },
+    {
+      "label": "trycatch_block",
+      "kind": 27,
+      "detail": "Snippet: tryCatch block",
+      "documentation": { "value": "Error handling block.\n\n```r\ntryCatch({\n  # risky code\n}, error = function(e) {\n  message(e$message)\n})\n```" },
+      "insertText": "tryCatch({\n  ${1}\n}, warning = function(w) {\n  message(\"Warning: \", w$message)\n}, error = function(e) {\n  message(\"Error: \", e$message)\n  ${2:NULL}\n})",
+      "insertTextRules": 4,
+      "sortText": "05_trycatch_block"
+    },
+    {
+      "label": "read_csv_snippet",
+      "kind": 27,
+      "detail": "Snippet: read CSV file",
+      "documentation": { "value": "Read a CSV file into a data frame.\n\n```r\ndf <- read.csv(\"data.csv\", stringsAsFactors = FALSE)\nstr(df)\nhead(df)\n```" },
+      "insertText": "${1:df} <- read.csv(\"${2:data.csv}\", stringsAsFactors = FALSE)\nstr(${1:df})\nhead(${1:df})",
+      "insertTextRules": 4,
+      "sortText": "05_read_csv_snippet"
+    },
+    {
+      "label": "ggplot_snippet",
+      "kind": 27,
+      "detail": "Snippet: ggplot scatter plot",
+      "documentation": { "value": "A quick ggplot2 scatter plot.\n\n```r\nlibrary(ggplot2)\nggplot(df, aes(x = x, y = y)) +\n  geom_point() +\n  labs(title = \"Title\") +\n  theme_minimal()\n```" },
+      "insertText": "library(ggplot2)\nggplot(${1:df}, aes(x = ${2:x}, y = ${3:y})) +\n  geom_point() +\n  labs(title = \"${4:Title}\") +\n  theme_minimal()",
+      "insertTextRules": 4,
+      "sortText": "05_ggplot_snippet"
+    },
+    {
+      "label": "pipe_data",
+      "kind": 27,
+      "detail": "Snippet: data pipeline (pipes)",
+      "documentation": { "value": "Data transformation pipeline using the native pipe.\n\n```r\nlibrary(dplyr)\nresult <- df |>\n  filter(x > 0) |>\n  mutate(y = x * 2) |>\n  summarise(mean_y = mean(y))\n```" },
+      "insertText": "${1:result} <- ${2:df} |>\n  filter(${3:condition}) |>\n  mutate(${4:new_col} = ${5:expr}) |>\n  summarise(${6:agg} = ${7:mean}(${8:col}))",
+      "insertTextRules": 4,
+      "sortText": "05_pipe_data"
+    },
+    {
+      "label": "shiny_app",
+      "kind": 27,
+      "detail": "Snippet: Shiny app skeleton",
+      "documentation": { "value": "Basic Shiny application template.\n\n```r\nlibrary(shiny)\nui <- fluidPage(\n  titlePanel(\"My App\"),\n  sidebarLayout(\n    sidebarPanel(sliderInput(\"n\", \"N:\", 1, 100, 50)),\n    mainPanel(plotOutput(\"plot\"))\n  )\n)\nserver <- function(input, output) {\n  output$plot <- renderPlot({ hist(rnorm(input$n)) })\n}\nshinyApp(ui, server)\n```" },
+      "insertText": "library(shiny)\n\nui <- fluidPage(\n  titlePanel(\"${1:My App}\"),\n  sidebarLayout(\n    sidebarPanel(\n      ${2:sliderInput(\"n\", \"N:\", 1, 100, 50)}\n    ),\n    mainPanel(\n      ${3:plotOutput(\"plot\")}\n    )\n  )\n)\n\nserver <- function(input, output) {\n  output\\$${4:plot} <- renderPlot({\n    ${5:hist(rnorm(input\\$n))}\n  })\n}\n\nshinyApp(ui, server)",
+      "insertTextRules": 4,
+      "sortText": "05_shiny_app"
+    },
+    {
+      "label": "r6_class_snippet",
+      "kind": 27,
+      "detail": "Snippet: R6 class definition",
+      "documentation": { "value": "R6 class template.\n\n```r\nlibrary(R6)\nMyClass <- R6Class(\"MyClass\",\n  public = list(\n    initialize = function(...) { },\n    method = function() { }\n  )\n)\n```" },
+      "insertText": "library(R6)\n${1:MyClass} <- R6Class(\"${1:MyClass}\",\n  public = list(\n    ${2:field} = NULL,\n    initialize = function(${3:}) {\n      self\\$${2:field} <- ${3:}\n    },\n    ${4:method} = function() {\n      ${5}\n    }\n  )\n)",
+      "insertTextRules": 4,
+      "sortText": "05_r6_class_snippet"
+    },
+    {
+      "label": "integer",
+      "kind": 7,
+      "detail": "Type: integer",
+      "documentation": { "value": "Integer type. Created with `L` suffix or `as.integer()`.\n\n```r\nx <- 42L\ntypeof(x)  # \"integer\"\n```" },
+      "insertText": "integer",
+      "sortText": "06_integer"
+    },
+    {
+      "label": "double",
+      "kind": 7,
+      "detail": "Type: double",
+      "documentation": { "value": "Double-precision floating point number.\n\n```r\nx <- 3.14\ntypeof(x)  # \"double\"\n```" },
+      "insertText": "double",
+      "sortText": "06_double"
+    },
+    {
+      "label": "character",
+      "kind": 7,
+      "detail": "Type: character",
+      "documentation": { "value": "Character (string) type.\n\n```r\nx <- \"hello\"\ntypeof(x)  # \"character\"\n```" },
+      "insertText": "character",
+      "sortText": "06_character"
+    },
+    {
+      "label": "logical",
+      "kind": 7,
+      "detail": "Type: logical",
+      "documentation": { "value": "Logical type (TRUE/FALSE/NA).\n\n```r\nx <- TRUE\ntypeof(x)  # \"logical\"\n```" },
+      "insertText": "logical",
+      "sortText": "06_logical"
+    },
+    {
+      "label": "complex",
+      "kind": 7,
+      "detail": "Type: complex",
+      "documentation": { "value": "Complex number type.\n\n```r\nx <- 1 + 2i\ntypeof(x)  # \"complex\"\n```" },
+      "insertText": "complex",
+      "sortText": "06_complex"
+    },
+    {
+      "label": "raw",
+      "kind": 7,
+      "detail": "Type: raw",
+      "documentation": { "value": "Raw byte type.\n\n```r\nx <- charToRaw(\"A\")\ntypeof(x)  # \"raw\"\n```" },
+      "insertText": "raw",
+      "sortText": "06_raw"
+    },
+    {
+      "label": "data.frame_type",
+      "kind": 7,
+      "detail": "Type: data.frame",
+      "documentation": { "value": "Data frame — tabular data structure with named columns.\n\n```r\ndf <- data.frame(x = 1:3, y = c(\"a\", \"b\", \"c\"))\nclass(df)  # \"data.frame\"\n```" },
+      "insertText": "data.frame",
+      "sortText": "06_data.frame"
+    },
+    {
+      "label": "matrix_type",
+      "kind": 7,
+      "detail": "Type: matrix",
+      "documentation": { "value": "Matrix — 2D array of same-type elements.\n\n```r\nm <- matrix(1:6, nrow = 2)\nclass(m)  # \"matrix\" \"array\"\n```" },
+      "insertText": "matrix",
+      "sortText": "06_matrix"
+    },
+    {
+      "label": "factor_type",
+      "kind": 7,
+      "detail": "Type: factor",
+      "documentation": { "value": "Factor — categorical variable with fixed levels.\n\n```r\nf <- factor(c(\"low\", \"med\", \"high\"))\nclass(f)  # \"factor\"\n```" },
+      "insertText": "factor",
+      "sortText": "06_factor"
+    },
+    {
+      "label": "environment_type",
+      "kind": 7,
+      "detail": "Type: environment",
+      "documentation": { "value": "Environment — frame for variable bindings.\n\n```r\ne <- new.env()\nis.environment(e)  # TRUE\n```" },
+      "insertText": "environment",
+      "sortText": "06_environment"
+    },
+    {
+      "label": "formula",
+      "kind": 7,
+      "detail": "Type: formula",
+      "documentation": { "value": "Formula — symbolic model specification.\n\n```r\nf <- y ~ x1 + x2\nclass(f)  # \"formula\"\n```" },
+      "insertText": "formula",
+      "sortText": "06_formula"
+    },
+    {
+      "label": "expression",
+      "kind": 7,
+      "detail": "Type: expression",
+      "documentation": { "value": "Expression — unevaluated R expressions.\n\n```r\ne <- expression(1 + 2)\neval(e)  # 3\n```" },
+      "insertText": "expression",
+      "sortText": "06_expression"
+    },
+    {
+      "label": "call_type",
+      "kind": 7,
+      "detail": "Type: call",
+      "documentation": { "value": "Call — an unevaluated function call.\n\n```r\ncl <- quote(mean(x))\nclass(cl)  # \"call\"\n```" },
+      "insertText": "call",
+      "sortText": "06_call"
+    },
+    {
+      "label": "symbol_type",
+      "kind": 7,
+      "detail": "Type: symbol/name",
+      "documentation": { "value": "Symbol — a variable name.\n\n```r\ns <- as.name(\"x\")\nclass(s)  # \"name\"\n```" },
+      "insertText": "symbol",
+      "sortText": "06_symbol"
+    }
+  ]
+}