Agent-almanac scaffold-shiny-app

install

source · Clone the upstream repo

git clone https://github.com/pjt222/agent-almanac

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/pjt222/agent-almanac "$T" && mkdir -p ~/.claude/skills && cp -r "$T/i18n/de/skills/scaffold-shiny-app" ~/.claude/skills/pjt222-agent-almanac-scaffold-shiny-app-75cb6f && rm -rf "$T"

manifest: i18n/de/skills/scaffold-shiny-app/SKILL.md

source content

Shiny-App scaffolden

Eine neue Shiny-Anwendung mit dem geeigneten Framework für den Produktionsfall scaffolden.

Wann verwenden

Start einer neuen Shiny-App
Wahl zwischen Scaffolding-Frameworks (golem, rhino, Vanilla)
Einrichten einer standardisierten Projektstruktur für ein Team
Schnelles Prototypen einer datengesteuerten Web-App in R

Eingaben

Erforderlich: App-Name (gültiger R-Paketname)
Erforderlich: Framework-Wahl:
```
golem
```
,
```
rhino
```
oder
```
vanilla
```
Optional: Autor-Informationen für DESCRIPTION (bei golem/rhino)
Optional: Ziel-Verzeichnis (Standard: aktuelles Verzeichnis)

Vorgehensweise

Schritt 1: Framework auswählen

Das richtige Scaffolding-Framework basierend auf Projektanforderungen auswählen.

Framework	Wann verwenden
`golem`	Produktions-Apps, R-Paket-Struktur, CRAN-Deployment
`rhino`	Modulare Apps, box-Module, JavaScript-Assets
`vanilla`	Schnelle Prototypen, einfache Apps, kein Framework-Overhead

Erwartet: Framework-Auswahl stimmt mit Projektkomplexität und Team-Expertise überein.

Bei Fehler: Wenn unsicher, mit

vanilla

beginnen und später auf golem/rhino migrieren, wenn die App wächst.

Schritt 2: Projekt scaffolden

Das gewählte Framework installieren und das Projekt initialisieren.

Für golem:

install.packages("golem")
golem::create_golem("myapp")

Für rhino:

install.packages("rhino")
rhino::init("myapp")

Für Vanilla Shiny:

install.packages("shiny")

# Projektstruktur manuell erstellen
dir.create("myapp")
dir.create("myapp/R")
dir.create("myapp/www")

# App-Dateien erstellen
file.create("myapp/app.R")
file.create("myapp/R/ui.R")
file.create("myapp/R/server.R")

Erwartet: Projektverzeichnis mit Framework-spezifischer Struktur erstellt.

Bei Fehler: Wenn Package-Installation fehlschlägt, prüfen ob CRAN erreichbar ist:

options(repos = c(CRAN = "https://cran.rstudio.com/"))

. Für golem auf GitHub:

remotes::install_github("Thinkr-open/golem")

Schritt 3: Basis-UI und Server einrichten

Grundlegende UI- und Server-Komponenten implementieren.

Für golem (

R/app_ui.R

und
R/app_server.R
):

# R/app_ui.R
app_ui <- function(request) {
  tagList(
    golem_add_external_resources(),
    fluidPage(
      titlePanel("My App"),
      sidebarLayout(
        sidebarPanel(
          selectInput("dataset", "Choose a dataset:",
            choices = c("iris", "mtcars"))
        ),
        mainPanel(
          tableOutput("table")
        )
      )
    )
  )
}

# R/app_server.R
app_server <- function(input, output, session) {
  output$table <- renderTable({
    get(input$dataset)
  })
}

Für Vanilla Shiny (

app.R

library(shiny)

ui <- fluidPage(
  titlePanel("My App"),
  sidebarLayout(
    sidebarPanel(
      selectInput("dataset", "Choose a dataset:",
        choices = c("iris", "mtcars"))
    ),
    mainPanel(
      tableOutput("table")
    )
  )
)

server <- function(input, output, session) {
  output$table <- renderTable({
    get(input$dataset)
  })
}

shinyApp(ui, server)

Erwartet: UI und Server ohne Syntaxfehler definiert. App startet ohne Laufzeitfehler.

Bei Fehler: Wenn

get(input$dataset)

Fehler erzeugt, sicherstellen, dass Datensatznamen mit R-Basisumgebung zugänglichen Datensätzen übereinstimmen (iris, mtcars, etc.).

Schritt 4: Lokal verifizieren

Die App lokal ausführen und grundlegende Funktionalität prüfen.

Für golem:

golem::run_dev()

Für Vanilla:

# Im Projektverzeichnis
shiny::runApp("myapp")

# Oder wenn bereits in myapp/
shiny::runApp()

App öffnet sich im Standard-Browser oder zeigt die URL an:

Listening on http://127.0.0.1:PORT

Erwartet: App startet ohne Fehler. Basis-UI rendert korrekt. Dropdown-Auswahl ändert Tabelleninhalt.

Bei Fehler: Wenn Port belegt ist, anderen Port angeben:

shiny::runApp(port = 3838)

. Wenn App mit Fehler abbricht, Konsolen-Fehlerausgabe für Paket-fehlende oder Syntaxfehler prüfen.

Schritt 5: Projektstruktur dokumentieren

README.md

und grundlegende Konfiguration hinzufügen.

# README.md erstellen
writeLines(c(
  "# My App",
  "",
  "## Overview",
  "Brief description of the app.",
  "",
  "## Setup",
  "```r",
  "install.packages('shiny')",
  "shiny::runApp()",
  "```",
  "",
  "## Structure",
  "- `R/` — App-Logik (UI, Server, Module)",
  "- `www/` — Statische Assets (CSS, JS, Bilder)",
  "- `tests/` — App-Tests"
), "myapp/README.md")

Erwartet: README erklärt App-Zweck und Setup-Schritte.

Bei Fehler: Wenn README-Erstellung fehlschlägt, manuell im Texteditor erstellen.

Validierung

Projektverzeichnis mit korrekter Framework-Struktur erstellt
Basis-UI und Server ohne Syntaxfehler definiert
App startet lokal ohne Fehler
UI rendert korrekt im Browser
Basis-Interaktivität (Input → Output) funktioniert
README mit Setup-Anweisungen vorhanden

Haeufige Stolperfallen

Golem vs Plain Shiny: golem erzwingt R-Paket-Struktur (DESCRIPTION, NAMESPACE).
```
devtools::check()
```
laufen lassen, um Paket-Konformität sicherzustellen.
Namespace-Kollisionen: Wenn mehrere Pakete Funktion
```
select()
```
exportieren, stets
```
pkg::function()
```
verwenden (z. B.
```
dplyr::select()
```
).
Reaktive Kontexte:
```
input$*
```
-Werte nur innerhalb reaktiver Kontexte (
```
reactive()
```
,
```
observe()
```
,
```
render*()
```
). Außerhalb schlägt dies fehl.
Shiny-App vs Funktion: In golem ist
```
run_app()
```
die Entry-Point-Funktion. In Vanilla ist
```
shinyApp(ui, server)
```
der Entry-Point.
Port-Konflikte: Wenn mehrere Apps gleichzeitig laufen, für jede explizite Ports setzen.
www/
-Verzeichnis: Statische Dateien müssen in
```
www/
```
liegen. Auf sie wird mit relativem Pfad ohne
```
www/
```
-Präfix zugegriffen.