claude-all-config 2.1.5 → 2.1.7

package/README.md

@@ -11,19 +11,40 @@ Auto-detects installed CLIs and configures them with agents, skills, commands, M
 
 ## ⚡ Quick Install
 
-### Option 1: curl (Recommended)
+### 🐧 Linux / Ubuntu / Mac
+
 ```bash
+# Option 1: curl (Recommended)
 curl -fsSL https://raw.githubusercontent.com/zesbe/ClaudeAll/main/install.sh | bash
+
+# Option 2: npm
+npm install -g claude-all-config
 ```
 
-### Option 2: npm
+### 📱 Termux Android
+
 ```bash
+# Install prerequisites
+pkg install nodejs-lts git
+
+# Install Claude Code / Gemini CLI
+npm install -g @anthropic-ai/claude-code
+npm install -g @google/gemini-cli
+
+# Install superpowers
 npm install -g claude-all-config
 ```
 
+**Termux Paths:** `/data/data/com.termux/files/home/.claude/`
+
+> 📖 See [TERMUX.md](./TERMUX.md) for detailed Termux documentation.
+
+---
+
 **Auto-detects and installs to:**
 - ✅ Claude Code → `~/.claude/`
 - ✅ Gemini CLI → `~/.gemini/superpowers/`
+- ✅ Termux → `/data/data/com.termux/files/home/.claude/`
 
 ---
 

package/commands/clean.md

@@ -0,0 +1,69 @@
+---
+description: Clean the codebase or current working task in focus via Prettier, Import Sorter, ESLint, and TypeScript Compiler
+---
+
+# Code Quality Cleanup
+
+You are a code quality specialist. When provided with $ARGUMENTS (file paths or directories), systematically clean and optimize the code for production readiness. If no arguments provided, focus on currently open or recently modified files.
+
+## Your Cleanup Process:
+
+**Step 1: Analyze Target Scope**
+- If $ARGUMENTS provided: Focus on specified files/directories
+- If no arguments: Check git status for modified files and currently open files
+- Identify file types and applicable cleanup tools
+
+**Step 2: Execute Cleanup Pipeline**
+Perform these actions in order:
+
+1. **Remove Debug Code**
+   - Strip console.log, debugger statements, and temporary debugging code
+   - Remove commented-out code blocks
+   - Clean up development-only imports
+
+2. **Format Code Structure**
+   - Run Prettier (if available) or apply consistent formatting
+   - Ensure proper indentation and spacing
+   - Standardize quote usage and trailing commas
+
+3. **Optimize Imports**
+   - Sort imports alphabetically
+   - Remove unused imports
+   - Group imports by type (libraries, local files)
+   - Use absolute imports where configured
+
+4. **Fix Linting Issues**
+   - Resolve ESLint/TSLint errors and warnings
+   - Apply auto-fixable rules
+   - Report manual fixes needed
+
+5. **Type Safety Validation**
+   - Run TypeScript compiler checks
+   - Fix obvious type issues
+   - Add missing type annotations where beneficial
+
+6. **Comment Optimization**
+   - Remove redundant or obvious comments
+   - Improve unclear comments
+   - Ensure JSDoc/docstring completeness for public APIs
+
+**Step 3: Present Cleanup Report**
+
+## Cleanup Results
+
+### Files Processed
+- [List of files that were cleaned]
+
+### Actions Taken
+- **Debug Code Removed**: [Number of console.logs, debuggers removed]
+- **Formatting Applied**: [Files formatted]
+- **Imports Optimized**: [Unused imports removed, sorting applied]
+- **Linting Issues Fixed**: [Auto-fixed issues count]
+- **Type Issues Resolved**: [TypeScript errors fixed]
+- **Comments Improved**: [Redundant comments removed, unclear ones improved]
+
+### Manual Actions Needed
+- [List any issues that require manual intervention]
+
+### Quality Improvements
+- [Summary of overall code quality improvements made]

package/commands/commit-openagents.md

@@ -0,0 +1,131 @@
+---
+description: Smart commit command with automatic validation and conventional commits
+---
+
+# Smart Commit Command
+
+You are an AI agent that helps create well-formatted git commits. This command handles the complete commit workflow including validation, testing, and pushing changes.
+
+## Instructions for Agent
+
+When the user runs this command, execute the following workflow:
+
+### 1. **Smart Repo Analysis (Automatic)**
+
+**Before doing anything, analyze the repo state:**
+
+```bash
+# Check current branch and status
+git status
+git branch --show-current
+
+# Check recent commits for style
+git log --oneline -5
+```
+
+### 2. **Analyze Changes**
+- Run `git status` to see all untracked files
+- Run `git diff` to see both staged and unstaged changes
+- Run `git log --oneline -5` to see recent commit style
+- Identify the scope of changes
+
+### 3. **Stage Files Intelligently**
+**Auto-stage based on change type:**
+- If modifying agents → stage `agents/`
+- If modifying skills → stage `skills/`
+- If modifying commands → stage `commands/`
+- If modifying context → stage `context/`
+- If modifying hooks → stage `hooks/`
+- If modifying docs → stage `docs/`
+- If modifying CI/CD → stage `.github/workflows/`
+- If user provides specific files → stage only those
+
+**Never auto-stage:**
+- `node_modules/`
+- `.env` files
+- Temporary directories
+
+### 4. **Generate Commit Message**
+
+**Follow Conventional Commits (NO EMOJIS):**
+```
+<type>(<scope>): <description>
+
+[optional body]
+```
+
+**Types:**
+- `feat` - New features
+- `fix` - Bug fixes
+- `refactor` - Code restructuring
+- `test` - Test additions
+- `docs` - Documentation updates
+- `chore` - Maintenance tasks
+- `ci` - CI/CD changes
+- `perf` - Performance improvements
+
+**Scopes:**
+- `agents` - Agent changes
+- `skills` - Skill changes
+- `commands` - Command changes
+- `context` - Context file changes
+- `hooks` - Hook changes
+- `mcp` - MCP server changes
+- `docs` - Documentation changes
+
+**Examples:**
+```
+feat(agents): add new code-generator agent
+fix(skills): correct brainstorming skill logic
+refactor(commands): split commit command into modules
+docs(readme): update installation instructions
+chore(deps): upgrade dependencies
+```
+
+### 5. **Execute Commit**
+```bash
+git add <relevant-files>
+git commit -m "<type>(<scope>): <description>"
+git status  # Verify commit succeeded
+```
+
+### 6. **Post-Commit Actions**
+
+**Ask user:**
+```
+✅ Commit created: <commit-hash>
+📝 Message: <commit-message>
+
+Would you like to:
+1. Push to remote (git push origin <branch>)
+2. Create another commit
+3. Done
+```
+
+## Error Handling
+
+### If No Changes Detected
+```
+ℹ️ No changes to commit. Working tree is clean.
+
+Recent commits:
+<git log --oneline -3>
+```
+
+### If Merge Conflicts
+```
+⚠️ Merge conflicts detected. Please resolve conflicts first.
+
+Conflicted files:
+<list-files>
+```
+
+## Success Criteria
+
+A successful commit should:
+- ✅ Follow conventional commit format (NO EMOJIS)
+- ✅ Have appropriate scope
+- ✅ Be atomic (single purpose)
+- ✅ Have clear, concise message
+- ✅ Not include sensitive information
+- ✅ Not include generated files

package/commands/indexes.md

@@ -0,0 +1,32 @@
+---
+description: Analyze database queries and recommend missing indexes
+argument-hint: Optional - specific tables or queries to analyze
+---
+
+# Database Index Analysis
+
+**Scope:** `$ARGUMENTS` (or entire codebase if not specified)
+
+Scan whole codebase and tell me what indexes are missing.
+
+## 📚 **DOCUMENTATION REQUIREMENTS**
+
+**Create comprehensive database analysis documentation at:**
+- `docs/tasks/backend/DD-MM-YYYY/<semantic-db-id>/`
+
+**Documentation Structure:**
+- `README.md` - Database analysis overview and objectives
+- `query-analysis.md` - Detailed query performance analysis
+- `index-recommendations.md` - Missing indexes and impact analysis
+- `performance-metrics.md` - Before/after performance comparisons
+- `implementation-plan.md` - Index creation strategy and migration plan
+- `monitoring-setup.md` - Performance monitoring and alerting
+
+**Semantic Database Task ID Examples:**
+- `user-query-optimization`
+- `order-performance-indexes`
+- `search-query-acceleration`
+- `relationship-index-analysis`
+- `slow-query-investigation`
+
+Please analyze all database queries, identify missing indexes, and document recommendations according to the standards above.

package/commands/worktrees.md

@@ -0,0 +1,87 @@
+---
+description: Manage git worktrees for parallel development workflows
+---
+
+# Git Worktree Management
+
+You are a git workflow specialist. When provided with $ARGUMENTS, manage git worktrees to enable parallel development on multiple branches. Common arguments: "create", "list", "cleanup", or specific branch names.
+
+## Your Worktree Management Process:
+
+**Step 1: Assess Current State**
+- Check if git worktrees are already in use with `git worktree list`
+- Verify GitHub CLI is available and authenticated for PR operations
+- Identify the main repository directory structure
+- Check for existing `./tree` directory or similar worktree organization
+
+**Step 2: Execute Worktree Operations**
+
+### Create Worktrees for All Open PRs
+When $ARGUMENTS includes "prs" or "all":
+1. Run `gh pr list --json headRefName,title,number` to get open PRs
+2. For each PR branch:
+   - Create directory structure: `./tree/[branch-name]`
+   - Execute `git worktree add ./tree/[branch-name] [branch-name]`
+   - Handle branch names with slashes by creating nested directories
+3. Report successful worktree creation
+
+### Create Worktree for Specific Branch
+When $ARGUMENTS specifies a branch name:
+1. Check if branch exists locally or remotely
+2. Create worktree at `./tree/[branch-name]`
+3. If branch doesn't exist, offer to create it with `git worktree add -b [branch-name] ./tree/[branch-name]`
+
+### Create New Branch with Worktree
+When $ARGUMENTS includes "new" and a branch name:
+1. Prompt for base branch (default: main/master)
+2. Create new branch and worktree simultaneously
+3. Set up proper tracking if needed
+
+### List and Status Check
+When $ARGUMENTS includes "list" or "status":
+1. Show all current worktrees with `git worktree list`
+2. Check status of each worktree
+3. Identify any stale or problematic worktrees
+
+### Cleanup Operations
+When $ARGUMENTS includes "cleanup":
+1. Identify branches that no longer exist remotely
+2. Remove corresponding worktrees safely
+3. Clean up empty directories in `./tree`
+
+**Step 3: Present Worktree Report**
+
+## Worktree Management Results
+
+### Operation Summary
+- **Command**: [What operation was performed]
+- **Target**: [Specific branches or "all open PRs"]
+- **Location**: [Worktree directory structure used]
+
+### Active Worktrees
+```
+[List of active worktrees with format:]
+/path/to/main/repo          [main branch] (main repository)
+/path/to/tree/feature-123   [feature-123] (worktree)
+/path/to/tree/bugfix-456    [bugfix-456]  (worktree)
+```
+
+### Actions Completed
+- **Created**: [Number of new worktrees created]
+- **Removed**: [Number of stale worktrees cleaned up]
+- **Skipped**: [Worktrees that already existed]
+
+### Directory Structure
+```
+project/
+├── main repository files
+└── tree/
+    ├── feature-branch-1/
+    ├── feature-branch-2/
+    └── bugfix-branch/
+```
+
+### Next Steps
+- **To work on a branch**: `cd tree/[branch-name]`
+- **To switch branches**: Use different worktree directories
+- **To clean up later**: Use `/worktrees cleanup` command

package/commands/writing-plans.md

@@ -0,0 +1,13 @@
+---
+description: Create a detailed implementation plan
+argument-hint: [design-doc-path]
+---
+
+# Write Implementation Plan
+
+**User Input:** $ARGUMENTS
+
+**Instructions:**
+1.  **Target:** I want to create a detailed implementation plan.
+2.  **Action:** Please **invoke/use the `writing-plans` skill** immediately.
+3.  Refer to the design document or requirements in "$ARGUMENTS" (if provided).

package/context/README.md

@@ -0,0 +1,27 @@
+# Context Files
+
+Context files provide domain knowledge, process documentation, and templates that agents can reference.
+
+## Structure
+
+```
+context/
+├── core/           # Core system knowledge
+├── development/    # Development practices and patterns
+├── data/           # Data handling and processing
+├── content/        # Content creation guidelines
+├── project/        # Project management context
+├── ui/             # UI/UX design patterns
+└── templates/      # Reusable templates
+```
+
+## Usage
+
+Agents automatically load relevant context based on the task type. You can also explicitly reference context files in prompts.
+
+## Adding Context
+
+1. Create a new .md file in the appropriate subdirectory
+2. Follow the standard format with frontmatter
+3. Keep files focused (50-200 lines)
+4. Include examples where helpful

package/install.sh

@@ -79,6 +79,7 @@ install_claude() {
     mkdir -p "$HOME/.claude/commands"
     mkdir -p "$HOME/.claude/hooks"
     mkdir -p "$HOME/.claude/plugins"
+    mkdir -p "$HOME/.claude/context"
 
     cp -r "$REPO_DIR/agents/"* "$HOME/.claude/agents/" 2>/dev/null || true
     AGENT_COUNT=$(ls -1 "$HOME/.claude/agents/"*.md 2>/dev/null | wc -l)
@@ -98,9 +99,12 @@ install_claude() {
     cp "$REPO_DIR/plugins/installed_plugins.json" "$HOME/.claude/plugins/" 2>/dev/null || true
     echo -e "   ${GREEN}✅ plugins${NC}"
 
+    cp -r "$REPO_DIR/context/"* "$HOME/.claude/context/" 2>/dev/null || true
+    echo -e "   ${GREEN}✅ context files${NC}"
+
     cp "$REPO_DIR/mcp.json" "$HOME/.mcp.json" 2>/dev/null || true
     chmod 600 "$HOME/.mcp.json" 2>/dev/null || true
-    echo -e "   ${GREEN}✅ MCP config (6 servers)${NC}"
+    echo -e "   ${GREEN}✅ MCP config (7 servers)${NC}"
 
     cat > "$HOME/.claude/settings.local.json" << 'EOF'
 {
@@ -154,7 +158,7 @@ install_gemini() {
 
     cp "$REPO_DIR/mcp.json" "$HOME/.gemini/mcp.json" 2>/dev/null || true
     chmod 600 "$HOME/.gemini/mcp.json" 2>/dev/null || true
-    echo -e "   ${GREEN}✅ MCP config (6 servers)${NC}"
+    echo -e "   ${GREEN}✅ MCP config (7 servers)${NC}"
 
     cat > "$HOME/.gemini/GEMINI.md" << 'EOF'
 # Gemini Superpowers
@@ -175,8 +179,8 @@ executing-plans, and more...
 ## Commands
 /brainstorm, /write-plan, /execute-plan
 
-## MCP Servers (6)
-context7, exa, sequential-thinking, memory, filesystem, fetch
+## MCP Servers (7)
+context7, exa, sequential-thinking, memory, filesystem, fetch, web-reader
 
 ## Usage
 Run with YOLO mode: gemini -y
@@ -225,7 +229,7 @@ fi
 
 # Install MCP packages (shared)
 echo "📦 Installing MCP packages..."
-npm install -g @upstash/context7-mcp @modelcontextprotocol/server-sequential-thinking exa-mcp-server @modelcontextprotocol/server-memory @modelcontextprotocol/server-filesystem @kazuph/mcp-fetch 2>/dev/null || {
+npm install -g @upstash/context7-mcp @modelcontextprotocol/server-sequential-thinking exa-mcp-server @modelcontextprotocol/server-memory @modelcontextprotocol/server-filesystem @kazuph/mcp-fetch @modelcontextprotocol/server-web-reader 2>/dev/null || {
     echo -e "${YELLOW}⚠️  Some MCP packages may need manual install${NC}"
 }
 echo -e "${GREEN}✅ MCP packages installed${NC}"

package/mcp.json

@@ -29,6 +29,11 @@
     "fetch": {
       "command": "npx",
       "args": ["-y", "@wordbricks/fetch-mcp@latest"]
+    },
+    "web-reader": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-web-reader"],
+      "description": "Read and convert web content to LLM-friendly format"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-all-config",
-  "version": "2.1.5",
+  "version": "2.1.7",
   "description": "🤖 Universal AI CLI Config - Claude Code + Gemini CLI with Agents, Skills, MCP Servers, 17+ Providers (MiniMax, OpenAI, xAI, Groq, DeepSeek, Letta & More)",
   "main": "index.js",
   "bin": {
@@ -53,6 +53,7 @@
     "agents/",
     "skills/",
     "commands/",
+    "context/",
     "hooks/",
     "plugins/",
     "bin/",

package/postinstall.js

@@ -68,7 +68,7 @@ function installClaude() {
   console.log('📦 Installing to Claude (~/.claude/)...');
 
   // Create directories
-  const dirs = ['agents', 'skills', 'commands', 'hooks', 'plugins'];
+  const dirs = ['agents', 'skills', 'commands', 'hooks', 'plugins', 'context'];
   dirs.forEach(dir => {
     const targetDir = path.join(CLAUDE_DIR, dir);
     if (!fs.existsSync(targetDir)) {
@@ -94,13 +94,18 @@ function installClaude() {
     console.log(`   🔌 plugins`);
   }
 
+  if (fs.existsSync(path.join(PKG_DIR, 'context'))) {
+    const contextCount = copyDir(path.join(PKG_DIR, 'context'), path.join(CLAUDE_DIR, 'context'));
+    console.log(`   📂 ${contextCount} context files`);
+  }
+
   // MCP config
   const mcpSrc = path.join(PKG_DIR, 'mcp.json');
   const mcpDest = path.join(HOME, '.mcp.json');
   if (fs.existsSync(mcpSrc)) {
     fs.copyFileSync(mcpSrc, mcpDest);
     fs.chmodSync(mcpDest, 0o600);
-    console.log(`   🔧 MCP config (6 servers)`);
+    console.log(`   🔧 MCP config (7 servers)`);
   }
 
   // Settings
@@ -166,7 +171,7 @@ function installGemini() {
   if (fs.existsSync(mcpSrc)) {
     fs.copyFileSync(mcpSrc, mcpDest);
     fs.chmodSync(mcpDest, 0o600);
-    console.log(`   🔧 MCP config (6 servers)`);
+    console.log(`   🔧 MCP config (7 servers)`);
   }
 
   // GEMINI.md
@@ -188,8 +193,8 @@ executing-plans, and more...
 ## Commands
 /brainstorm, /write-plan, /execute-plan
 
-## MCP Servers (6)
-context7, exa, sequential-thinking, memory, filesystem, fetch
+## MCP Servers (7)
+context7, exa, sequential-thinking, memory, filesystem, fetch, web-reader
 
 ## Usage
 Run with YOLO mode: gemini -y

package/skills/agents-md-generator/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: agents-md-generator
+description: Generate hierarchical AGENTS.md structures for codebases. Use when user asks to create AGENTS.md files, analyze codebase for AI agent documentation, set up AI-friendly project documentation, or generate context files for AI coding assistants. Triggers on "create AGENTS.md", "generate agents", "analyze codebase for AI", "AI documentation setup", "hierarchical agents".
+---
+
+# AGENTS.md Generator
+
+Generate hierarchical AGENTS.md structures optimized for AI coding agents with minimal token usage.
+
+## Core Principles
+
+1. **Root AGENTS.md is LIGHTWEIGHT** - Only universal guidance, links to sub-files (~100-200 lines max)
+2. **Nearest-wins hierarchy** - Agents read closest AGENTS.md to file being edited
+3. **JIT indexing** - Provide paths/globs/commands, NOT full content
+4. **Token efficiency** - Small, actionable guidance over encyclopedic docs
+5. **Sub-folder files have MORE detail** - Specific patterns, examples, commands
+
+## Workflow
+
+### Phase 1: Repository Analysis
+
+Analyze and report:
+1. **Repository type**: Monorepo, multi-package, or simple?
+2. **Tech stack**: Languages, frameworks, key tools
+3. **Major directories** needing own AGENTS.md
+4. **Build system**: pnpm/npm/yarn workspaces? Turborepo?
+5. **Testing setup**: Jest, Vitest, Playwright, pytest?
+6. **Key patterns**: Organization, conventions, examples
+
+### Phase 2: Root AGENTS.md
+
+Create lightweight root (~100-200 lines):
+
+```markdown
+# Project Name
+
+## Project Snapshot
+[3-5 lines: repo type, tech stack, note about sub-AGENTS.md files]
+
+## Root Setup Commands
+[5-10 lines: install, build all, typecheck all, test all]
+
+## Universal Conventions
+[5-10 lines: code style, commit format, branch strategy]
+
+## JIT Index
+- Web UI: `apps/web/` -> [see apps/web/AGENTS.md](apps/web/AGENTS.md)
+- API: `apps/api/` -> [see apps/api/AGENTS.md](apps/api/AGENTS.md)
+
+## Definition of Done
+[3-5 lines: what must pass before PR]
+```
+
+### Phase 3: Sub-Folder AGENTS.md
+
+For each major package, create detailed AGENTS.md with:
+- Package Identity
+- Setup & Run commands
+- Patterns & Conventions (with real file examples)
+- Key Files
+- JIT Index Hints
+- Common Gotchas
+- Pre-PR Checks
+
+## Quality Checklist
+
+- [ ] Root AGENTS.md under 200 lines
+- [ ] Root links to all sub-AGENTS.md files
+- [ ] Each sub-file has concrete examples (actual paths)
+- [ ] Commands are copy-paste ready
+- [ ] No duplication between root and sub-files

package/skills/artifacts-builder/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: artifacts-builder
+description: Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.
+license: Complete terms in LICENSE.txt
+---
+
+# Artifacts Builder
+
+To build powerful frontend claude.ai artifacts, follow these steps:
+1. Initialize the frontend repo using `scripts/init-artifact.sh`
+2. Develop your artifact by editing the generated code
+3. Bundle all code into a single HTML file using `scripts/bundle-artifact.sh`
+4. Display artifact to user
+5. (Optional) Test the artifact
+
+**Stack**: React 18 + TypeScript + Vite + Parcel (bundling) + Tailwind CSS + shadcn/ui
+
+## Design & Style Guidelines
+
+VERY IMPORTANT: To avoid what is often referred to as "AI slop", avoid using excessive centered layouts, purple gradients, uniform rounded corners, and Inter font.
+
+## Quick Start
+
+### Step 1: Initialize Project
+
+Run the initialization script to create a new React project:
+```bash
+bash scripts/init-artifact.sh <project-name>
+cd <project-name>
+```
+
+This creates a fully configured project with:
+- React + TypeScript (via Vite)
+- Tailwind CSS 3.4.1 with shadcn/ui theming system
+- Path aliases (`@/`) configured
+- 40+ shadcn/ui components pre-installed
+- All Radix UI dependencies included
+- Parcel configured for bundling (via .parcelrc)
+- Node 18+ compatibility (auto-detects and pins Vite version)
+
+### Step 2: Develop Your Artifact
+
+To build the artifact, edit the generated files. See **Common Development Tasks** below for guidance.
+
+### Step 3: Bundle to Single HTML File
+
+To bundle the React app into a single HTML artifact:
+```bash
+bash scripts/bundle-artifact.sh
+```
+
+This creates `bundle.html` - a self-contained artifact with all JavaScript, CSS, and dependencies inlined. This file can be directly shared in Claude conversations as an artifact.
+
+**Requirements**: Your project must have an `index.html` in the root directory.
+
+**What the script does**:
+- Installs bundling dependencies (parcel, @parcel/config-default, parcel-resolver-tspaths, html-inline)
+- Creates `.parcelrc` config with path alias support
+- Builds with Parcel (no source maps)
+- Inlines all assets into single HTML using html-inline
+
+### Step 4: Share Artifact with User
+
+Finally, share the bundled HTML file in conversation with the user so they can view it as an artifact.
+
+### Step 5: Testing/Visualizing the Artifact (Optional)
+
+Note: This is a completely optional step. Only perform if necessary or requested.
+
+To test/visualize the artifact, use available tools (including other Skills or built-in tools like Playwright or Puppeteer). In general, avoid testing the artifact upfront as it adds latency between the request and when the finished artifact can be seen. Test later, after presenting the artifact, if requested or if issues arise.
+
+## Reference
+
+- **shadcn/ui components**: https://ui.shadcn.com/docs/components