moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-lang-r/SKILL.md

@@ -1,20 +1,32 @@
 ---
-name: moai-lang-r
-description: R 4.4+ development specialist covering tidyverse, ggplot2, Shiny, and data science patterns. Use when developing data analysis pipelines, visualizations, or Shiny applications.
-version: 1.0.0
-updated: 2025-12-07
-status: active
-allowed-tools: Read, Grep, Glob, Bash, mcp__context7__resolve-library-id, mcp__context7__get-library-docs
+name: "moai-lang-r"
+description: "R 4.4+ development specialist covering tidyverse, ggplot2, Shiny, and data science patterns. Use when developing data analysis pipelines, visualizations, or Shiny applications."
+version: 1.1.0
+category: "language"
+modularized: true
+user-invocable: false
+tags:
+  ["language", "r", "tidyverse", "ggplot2", "shiny", "dplyr", "data-science"]
+updated: 2026-01-11
+status: "active"
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+  - Bash
+  - mcp__context7__resolve-library-id
+  - mcp__context7__get-library-docs
 ---
 
 ## Quick Reference (30 seconds)
 
 R 4.4+ Development Specialist - tidyverse, ggplot2, Shiny, renv, and modern R patterns.
 
-Auto-Triggers: `.R` files, `.Rmd`, `.qmd`, `DESCRIPTION`, `renv.lock`, Shiny/ggplot2 discussions
+Auto-Triggers: Files with .R extension, .Rmd, .qmd, DESCRIPTION, renv.lock, Shiny or ggplot2 discussions
 
 Core Capabilities:
-- R 4.4 Features: Native pipe |>, lambda syntax \(x), improved error messages
+
+- R 4.4 Features: Native pipe operator, lambda syntax with backslash, improved error messages
 - Data Manipulation: dplyr, tidyr, purrr, stringr, forcats
 - Visualization: ggplot2, plotly, scales, patchwork
 - Web Applications: Shiny, reactivity, modules, bslib
@@ -25,58 +37,17 @@ Core Capabilities:
 
 ### Quick Patterns
 
-dplyr Data Pipeline:
-```r
-library(tidyverse)
-
-result <- data |>
-  filter(year >= 2020) |>
-  mutate(
-    revenue_k = revenue / 1000,
-    growth = (revenue - lag(revenue)) / lag(revenue)
-  ) |>
-  group_by(category) |>
-  summarise(
-    total_revenue = sum(revenue_k, na.rm = TRUE),
-    avg_growth = mean(growth, na.rm = TRUE),
-    .groups = "drop"
-  )
-```
-
-ggplot2 Visualization:
-```r
-library(ggplot2)
-
-ggplot(data, aes(x = date, y = value, color = category)) +
-  geom_line(linewidth = 1) +
-  geom_point(size = 2) +
-  scale_color_viridis_d() +
-  labs(
-    title = "Trend Analysis",
-    x = "Date", y = "Value",
-    color = "Category"
-  ) +
-  theme_minimal()
-```
-
-Shiny Basic App:
-```r
-library(shiny)
-
-ui <- fluidPage(
-  selectInput("var", "Variable:", choices = names(mtcars)),
-  plotOutput("plot")
-)
-
-server <- function(input, output, session) {
-  output$plot <- renderPlot({
-    ggplot(mtcars, aes(.data[[input$var]])) +
-      geom_histogram()
-  })
-}
-
-shinyApp(ui, server)
-```
+dplyr Data Pipeline Pattern:
+
+Load tidyverse library. Create result by piping data through filter for year 2020 or later, mutate adding revenue_k as revenue divided by 1000 and growth as current minus lagged revenue divided by lagged revenue, group_by category, then summarise with total_revenue as sum, avg_growth as mean with na.rm TRUE, and groups set to drop.
+
+ggplot2 Visualization Pattern:
+
+Load ggplot2 library. Create ggplot with data and aes mapping x to date, y to value, and color to category. Add geom_line with linewidth 1 and geom_point with size 2. Apply scale_color_viridis_d for color scale. Add labs for title, axis labels, and color legend. Apply theme_minimal for clean appearance.
+
+Shiny Basic App Pattern:
+
+Load shiny library. Create ui using fluidPage with selectInput for variable selection from mtcars column names and plotOutput for plot. Create server function with input, output, and session parameters. In server, assign renderPlot to output plot using ggplot with mtcars and aes using .data pronoun with input variable for histogram. Create app with shinyApp passing ui and server.
 
 ---
 
@@ -84,450 +55,98 @@ shinyApp(ui, server)
 
 ### R 4.4 Modern Features
 
-Native Pipe Operator |>:
-```r
-# R 4.4+ native pipe (preferred over magrittr %>%)
-result <- data |>
-  filter(!is.na(value)) |>
-  mutate(log_value = log(value)) |>
-  summarise(mean_log = mean(log_value))
+Native Pipe Operator:
 
-# Placeholder _ for non-first argument
-data |>
-  lm(formula = y ~ x, data = _)
-
-# Chain with function calls
-data |>
-  (\(d) split(d, d$group))() |>
-  lapply(\(x) mean(x$value))
-```
+Create result by piping data through filter removing NA values, mutate adding log_value as log of value, and summarise computing mean_log. For non-first argument position, use underscore placeholder in lm formula call with data parameter.
 
 Lambda Syntax with Backslash:
-```r
-# R 4.1+ shorthand lambda (replaces function(x))
-map(data, \(x) x^2)
-map2(list1, list2, \(x, y) x + y)
-pmap(list(a = 1:3, b = 4:6), \(a, b) a * b)
-
-# In dplyr contexts
-data |>
-  mutate(across(where(is.numeric), \(x) scale(x)[,1]))
-```
-
-Improved Error Messages:
-```r
-# R 4.4 provides clearer error traces
-# Enable for debugging
-options(error = rlang::entrace)
-rlang::global_entrace()
-
-# Informative conditions
-rlang::abort(
-
-  message = "Data validation failed",
-  class = "validation_error",
-  body = c(
-    i = "Column 'value' contains negative numbers",
-    x = "Expected all positive values"
-  )
-)
-```
+
+Use map with data and backslash x syntax for x squared. Use map2 with two lists and backslash x y for x plus y. In dplyr contexts, use mutate with across on numeric columns applying backslash x for scale function extracting first column.
 
 ### tidyverse Data Manipulation
 
 dplyr Core Verbs:
-```r
-library(dplyr)
-
-# filter, select, mutate, summarise, arrange
-processed <- raw_data |>
-  filter(status == "active", amount > 0) |>
-  select(id, date, amount, category) |>
-  mutate(
-    month = floor_date(date, "month"),
-    amount_scaled = amount / max(amount)
-  ) |>
-  arrange(desc(date))
-
-# group_by with summarise
-summary <- processed |>
-  group_by(category, month) |>
-  summarise(
-    n = n(),
-    total = sum(amount),
-    avg = mean(amount),
-    .groups = "drop"
-  )
-
-# across for multiple columns
-data |>
-  mutate(across(starts_with("price"), \(x) round(x, 2))) |>
-  summarise(across(where(is.numeric), list(
-    mean = \(x) mean(x, na.rm = TRUE),
-    sd = \(x) sd(x, na.rm = TRUE)
-  )))
-```
-
-tidyr Reshaping:
-```r
-library(tidyr)
-
-# pivot_longer (wide to long)
-wide_data |>
-  pivot_longer(
-    cols = starts_with("year_"),
-    names_to = "year",
-    names_prefix = "year_",
-    values_to = "value"
-  )
-
-# pivot_wider (long to wide)
-long_data |>
-  pivot_wider(
-    names_from = category,
-    values_from = value,
-    values_fill = 0
-  )
-
-# nest/unnest for list columns
-data |>
-  group_by(id) |>
-  nest() |>
-  mutate(model = map(data, \(d) lm(y ~ x, data = d))) |>
-  mutate(summary = map(model, broom::tidy)) |>
-  unnest(summary)
-```
+
+Load dplyr library. Create processed by piping raw_data through filter for active status and positive amount, select for specific columns, mutate adding month using floor_date and amount_scaled dividing by max, then arrange descending by date. For grouped summaries, pipe through group_by, summarise with n for count, sum and mean for aggregations, and groups drop.
+
+tidyr Reshaping Pattern:
+
+Load tidyr library. For wide to long transformation, use pivot_longer with cols starting with year prefix, names_to for column name, names_prefix to strip, and values_to for values. For long to wide transformation, use pivot_wider with names_from and values_from, adding values_fill for missing value handling.
 
 purrr Functional Programming:
-```r
-library(purrr)
-
-# map variants
-files |> map(\(f) read_csv(f))
-files |> map_dfr(\(f) read_csv(f), .id = "source")
-values |> map_dbl(\(x) mean(x, na.rm = TRUE))
-values |> map_chr(\(x) paste(x, collapse = ", "))
-
-# safely for error handling
-safe_read <- safely(read_csv)
-results <- files |> map(safe_read)
-successes <- results |> map("result") |> compact()
-errors <- results |> map("error") |> compact()
-
-# possibly with default value
-safe_log <- possibly(log, otherwise = NA_real_)
-values |> map_dbl(safe_log)
-
-# walk for side effects
-plots |> walk(\(p) ggsave(paste0(p$name, ".png"), p$plot))
-```
-
-stringr Text Processing:
-```r
-library(stringr)
-
-# Common operations
-str_detect(text, "pattern")
-str_extract(text, "\\d+")
-str_replace_all(text, "old", "new")
-str_split(text, ",")
-
-# Complex patterns with regex
-data |>
-  mutate(
-    email_domain = str_extract(email, "(?<=@)[^@]+$"),
-    first_word = str_extract(name, "^\\w+"),
-    cleaned = str_squish(str_to_lower(text))
-  )
-```
+
+Load purrr library. Use map with files and lambda to read_csv each file. Use map_dfr for row-binding with id parameter for source column. Use map_dbl for extracting numeric results with mean and na.rm TRUE. For error handling, create safe_read using safely wrapper on read_csv. Map files through safe_read, extract results, and use compact to filter successes.
 
 ### ggplot2 Visualization Patterns
 
 Complete Plot Structure:
-```r
-library(ggplot2)
-library(scales)
-
-p <- ggplot(data, aes(x = x, y = y, color = group)) +
-  # Geometries
-  geom_point(alpha = 0.7, size = 3) +
-  geom_smooth(method = "lm", se = TRUE) +
-  # Scales
-  scale_x_continuous(labels = comma) +
-  scale_y_log10(labels = dollar) +
-  scale_color_brewer(palette = "Set2") +
-  # Facets
-  facet_wrap(~ category, scales = "free_y") +
-  # Labels
-  labs(
-    title = "Analysis Title",
-    subtitle = "Descriptive subtitle",
-    caption = "Source: Dataset",
-    x = "X Axis Label",
-    y = "Y Axis Label"
-  ) +
-  # Theme
-  theme_minimal(base_size = 12) +
-  theme(
-    legend.position = "bottom",
-    plot.title = element_text(face = "bold"),
-    axis.text.x = element_text(angle = 45, hjust = 1)
-  )
-
-# Save with proper dimensions
-ggsave("output.png", p, width = 10, height = 6, dpi = 300)
-```
+
+Load ggplot2 and scales libraries. Create p using ggplot with data and aesthetics for x, y, and color by group. Add geom_point with alpha and size, geom_smooth with lm method and standard error. Apply scale_x_continuous with comma labels, scale_y_log10 with dollar labels, and scale_color_brewer with Set2 palette. Add facet_wrap by category with free_y scales. Add labs for title, subtitle, and axis labels. Apply theme_minimal with base_size and theme for legend position. Save with ggsave specifying filename, plot, dimensions, and dpi.
 
 Multiple Plots with patchwork:
-```r
-library(patchwork)
-
-p1 <- ggplot(data, aes(x)) + geom_histogram()
-p2 <- ggplot(data, aes(x, y)) + geom_point()
-p3 <- ggplot(data, aes(group, y)) + geom_boxplot()
-
-# Combine plots
-combined <- (p1 | p2) / p3 +
-  plot_annotation(
-    title = "Combined Analysis",
-    tag_levels = "A"
-  ) +
-  plot_layout(heights = c(1, 2))
-```
+
+Load patchwork library. Create p1 with histogram, p2 with scatter plot, and p3 with boxplot. Combine using pipe and parentheses for layout with p1 beside p2 over p3. Add plot_annotation for title and tag_levels.
 
 ### Shiny Application Patterns
 
 Modular Shiny App:
-```r
-# Module: data_filter_module.R
-dataFilterUI <- function(id) {
-  ns <- NS(id)
-  tagList(
-    selectInput(ns("category"), "Category:", choices = NULL),
-    sliderInput(ns("range"), "Range:", min = 0, max = 100, value = c(0, 100))
-  )
-}
-
-dataFilterServer <- function(id, data) {
-  moduleServer(id, function(input, output, session) {
-    observe({
-      categories <- unique(data()$category)
-      updateSelectInput(session, "category", choices = categories)
-    })
-
-    filtered_data <- reactive({
-      req(input$category)
-      data() |>
-        filter(
-          category == input$category,
-          value >= input$range[1],
-          value <= input$range[2]
-        )
-    })
-
-    return(filtered_data)
-  })
-}
-```
+
+Create dataFilterUI function taking id parameter. Use NS function for namespace. Return tagList with selectInput for category with NULL initial choices and sliderInput for range. Create dataFilterServer function taking id and data reactive. Use moduleServer with inner function. In observe block, extract unique categories and updateSelectInput. Return reactive filtering data by category and range inputs using req for input validation.
 
 Reactive Patterns:
-```r
-server <- function(input, output, session) {
-  # reactive: Cached computation
-  processed_data <- reactive({
-    raw_data() |>
-      filter(year == input$year) |>
-      mutate(calc = value * input$multiplier)
-  })
-
-  # reactiveVal: Mutable state
-  counter <- reactiveVal(0)
-  observeEvent(input$increment, {
-    counter(counter() + 1)
-  })
-
-  # reactiveValues: Multiple mutable values
-  rv <- reactiveValues(
-    data = NULL,
-    selected = NULL,
-    history = list()
-  )
-
-  # eventReactive: Trigger on specific event
-  analysis <- eventReactive(input$run_analysis, {
-    req(processed_data())
-    expensive_computation(processed_data())
-  })
-
-  # observe: Side effects
-  observe({
-    req(input$selection)
-    rv$selected <- input$selection
-  })
-
-  # debounce for rapid inputs
-  search_term <- reactive(input$search) |> debounce(300)
-}
-```
-
-Shiny with bslib Modern UI:
-```r
-library(shiny)
-library(bslib)
-
-ui <- page_sidebar(
-  title = "Data Dashboard",
-  theme = bs_theme(
-    bootswatch = "flatly",
-    primary = "#0066CC"
-  ),
-  sidebar = sidebar(
-    title = "Controls",
-    selectInput("dataset", "Dataset:", choices = c("mtcars", "iris")),
-    numericInput("n", "Rows:", value = 10, min = 1)
-  ),
-  navset_card_tab(
-    nav_panel("Table", tableOutput("table")),
-    nav_panel("Plot", plotOutput("plot")),
-    nav_panel("Summary", verbatimTextOutput("summary"))
-  )
-)
-```
+
+In server function, create processed_data as reactive caching filtered data by input year. Create counter as reactiveVal initialized to 0. Use observeEvent on input increment to update counter. Create analysis as eventReactive on input run_analysis for expensive computation. Apply debounce with 300 milliseconds on search input reactive for rapid input handling.
 
 ### testthat Testing Framework
 
-Test Structure:
-```r
-# tests/testthat/test-calculations.R
-library(testthat)
-
-test_that("calculate_growth returns correct values", {
-  # Arrange
-  data <- tibble(year = 2020:2022, value = c(100, 110, 121))
-
-  # Act
-  result <- calculate_growth(data)
-
-  # Assert
-  expect_equal(nrow(result), 3)
-  expect_equal(result$growth[2], 0.1, tolerance = 0.001)
-  expect_true(is.na(result$growth[1]))
-})
-
-test_that("calculate_growth handles edge cases", {
-  expect_error(calculate_growth(NULL), "data cannot be NULL")
-  expect_warning(calculate_growth(tibble()), "empty data")
-})
-```
-
-Snapshot Testing:
-```r
-test_that("plot output is consistent", {
-  p <- create_summary_plot(test_data)
-  expect_snapshot_output(print(p))
-})
-
-test_that("table output matches snapshot", {
-  result <- generate_report(test_data)
-  expect_snapshot(result)
-})
-```
-
-Mocking External Dependencies:
-```r
-test_that("fetch_data uses API correctly", {
-  local_mocked_bindings(
-    httr2_request = function(url) {
-      list(status_code = 200, body = '{"data": [1,2,3]}')
-    }
-  )
-
-  result <- fetch_data("https://api.example.com/data")
-  expect_equal(result, c(1, 2, 3))
-})
-```
+Test Structure Pattern:
+
+Load testthat library. Create test_that block for calculate_growth with tibble of years and values. Call function and store result. Use expect_equal for row count, expect_equal for growth value with tolerance, and expect_true for NA check.
 
 ### renv Dependency Management
 
 Project Setup:
-```r
-# Initialize renv in project
-renv::init()
-
-# Install packages
-renv::install("tidyverse")
-renv::install("shiny")
-renv::install("user/package")  # GitHub
-
-# Snapshot current state
-renv::snapshot()
-
-# Restore from lockfile
-renv::restore()
-
-# Update packages
-renv::update()
-```
-
-renv.lock Structure:
-```json
-{
-  "R": {
-    "Version": "4.4.0",
-    "Repositories": [
-      {"Name": "CRAN", "URL": "https://cloud.r-project.org"}
-    ]
-  },
-  "Packages": {
-    "dplyr": {
-      "Package": "dplyr",
-      "Version": "1.1.4",
-      "Source": "Repository"
-    }
-  }
-}
-```
+
+Call renv::init for initialization. Call renv::install for tidyverse and shiny packages. Call renv::snapshot to record state. Call renv::restore to restore from lockfile.
 
 ---
 
 ## Advanced Implementation (10+ minutes)
 
 For comprehensive coverage including:
-- Advanced Shiny patterns (async, caching, deployment)
+
+- Advanced Shiny patterns for async, caching, and deployment
 - Complex ggplot2 extensions and custom themes
 - Database integration with dbplyr and pool
 - R package development patterns
 - Performance optimization techniques
-- Production deployment (Docker, Posit Connect)
+- Production deployment with Docker and Posit Connect
 
 See:
-- [reference.md](reference.md) - Complete reference documentation
-- [examples.md](examples.md) - Production-ready code examples
+
+- modules/advanced-patterns.md for complete advanced patterns guide
 
 ---
 
 ## Context7 Library Mappings
 
-```
-/tidyverse/dplyr - Data manipulation verbs
-/tidyverse/ggplot2 - Grammar of graphics visualization
-/tidyverse/purrr - Functional programming toolkit
-/tidyverse/tidyr - Data tidying functions
-/tidyverse/stringr - String manipulation
-/rstudio/shiny - Web application framework
-/r-lib/testthat - Unit testing framework
-/rstudio/renv - Dependency management
-```
+- tidyverse/dplyr for data manipulation verbs
+- tidyverse/ggplot2 for grammar of graphics visualization
+- tidyverse/purrr for functional programming toolkit
+- tidyverse/tidyr for data tidying functions
+- rstudio/shiny for web application framework
+- r-lib/testthat for unit testing framework
+- rstudio/renv for dependency management
 
 ---
 
 ## Works Well With
 
-- `moai-lang-python` - Python/R interoperability with reticulate
-- `moai-domain-database` - SQL patterns and database optimization
-- `moai-quality-testing` - TDD and testing strategies
-- `moai-essentials-debug` - AI-powered debugging
-- `moai-foundation-trust` - TRUST 5 quality principles
+- moai-lang-python for Python and R interoperability with reticulate
+- moai-domain-database for SQL patterns and database optimization
+- moai-workflow-testing for TDD and testing strategies
+- moai-essentials-debug for AI-powered debugging
+- moai-foundation-quality for TRUST 5 quality principles
 
 ---
 
@@ -536,44 +155,27 @@ See:
 Common Issues:
 
 R Version Check:
-```r
-R.version.string  # Should be 4.4+
-packageVersion("dplyr")
-```
+
+Call R.version.string in R console for version 4.4 or later. Call packageVersion with package name to check installed package versions.
 
 Native Pipe Not Working:
-- Ensure R version is 4.1+ for |>
-- Check RStudio settings: Tools > Global Options > Code > Use native pipe
+
+- Ensure R version is 4.1 or later for native pipe operator
+- Check RStudio settings under Tools, Global Options, Code for Use native pipe option
 
 renv Issues:
-```r
-# Clear cache and reinitialize
-renv::clean()
-renv::rebuild()
 
-# Force snapshot
-renv::snapshot(force = TRUE)
-```
+Call renv::clean to remove unused packages. Call renv::rebuild to rebuild package library. Call renv::snapshot with force TRUE to force snapshot update.
 
 Shiny Reactivity Debug:
-```r
-# Enable reactive log
-options(shiny.reactlog = TRUE)
-reactlog::reactlog_enable()
 
-# View reactive dependencies
-shiny::reactlogShow()
-```
+Set options shiny.reactlog to TRUE. Call reactlog::reactlog_enable to enable logging. Call shiny::reactlogShow to display reactive log visualization.
 
 ggplot2 Font Issues:
-```r
-# Install and configure fonts
-library(showtext)
-font_add_google("Roboto", "roboto")
-showtext_auto()
-```
+
+Load showtext library. Call font_add_google with font name and family. Call showtext_auto to enable for all graphics devices.
 
 ---
 
-Last Updated: 2025-12-07
-Status: Active (v1.0.0)
+Last Updated: 2026-01-11
+Status: Active (v1.1.0)