@ngxtm/devkit 3.7.0 → 3.8.0

package/merged-commands/upgrading-expo.md

@@ -0,0 +1,118 @@
+---
+name: upgrading-expo
+description: "Upgrade Expo SDK versions"
+source: "https://github.com/expo/skills/tree/main/plugins/upgrading-expo"
+risk: safe
+---
+
+# Upgrading Expo
+
+## Overview
+
+Upgrade Expo SDK versions safely, handling breaking changes, dependencies, and configuration updates.
+
+## When to Use This Skill
+
+Use this skill when you need to upgrade Expo SDK versions.
+
+Use this skill when:
+- Upgrading to a new Expo SDK version
+- Handling breaking changes between SDK versions
+- Updating dependencies for compatibility
+- Migrating deprecated APIs to new versions
+- Preparing apps for new Expo features
+
+## Instructions
+
+This skill guides you through upgrading Expo SDK versions:
+
+1. **Pre-Upgrade Planning**: Review release notes and breaking changes
+2. **Dependency Updates**: Update packages for SDK compatibility
+3. **Configuration Migration**: Update app.json and configuration files
+4. **Code Updates**: Migrate deprecated APIs to new versions
+5. **Testing**: Verify app functionality after upgrade
+
+## Upgrade Process
+
+### 1. Pre-Upgrade Checklist
+
+- Review Expo SDK release notes
+- Identify breaking changes affecting your app
+- Check compatibility of third-party packages
+- Backup current project state
+- Create a feature branch for the upgrade
+
+### 2. Update Expo SDK
+
+```bash
+# Update Expo CLI
+npm install -g expo-cli@latest
+
+# Upgrade Expo SDK
+npx expo install expo@latest
+
+# Update all Expo packages
+npx expo install --fix
+```
+
+### 3. Handle Breaking Changes
+
+- Review migration guides for breaking changes
+- Update deprecated API calls
+- Modify configuration files as needed
+- Update native dependencies if required
+- Test affected features thoroughly
+
+### 4. Update Dependencies
+
+```bash
+# Check for outdated packages
+npx expo-doctor
+
+# Update packages to compatible versions
+npx expo install --fix
+
+# Verify compatibility
+npx expo-doctor
+```
+
+### 5. Testing
+
+- Test core app functionality
+- Verify native modules work correctly
+- Check for runtime errors
+- Test on both iOS and Android
+- Verify app store builds still work
+
+## Common Issues
+
+### Dependency Conflicts
+
+- Use `expo install` instead of `npm install` for Expo packages
+- Check package compatibility with new SDK version
+- Resolve peer dependency warnings
+
+### Configuration Changes
+
+- Update `app.json` for new SDK requirements
+- Migrate deprecated configuration options
+- Update native configuration files if needed
+
+### Breaking API Changes
+
+- Review API migration guides
+- Update code to use new APIs
+- Test affected features after changes
+
+## Best Practices
+
+- Always upgrade in a feature branch
+- Test thoroughly before merging
+- Review release notes carefully
+- Update dependencies incrementally
+- Keep Expo CLI updated
+- Use `expo-doctor` to verify setup
+
+## Resources
+
+For more information, see the [source repository](https://github.com/expo/skills/tree/main/plugins/upgrading-expo).

package/merged-commands/upstash-qstash.md

@@ -0,0 +1,68 @@
+---
+name: upstash-qstash
+description: "Upstash QStash expert for serverless message queues, scheduled jobs, and reliable HTTP-based task delivery without managing infrastructure. Use when: qstash, upstash queue, serverless cron, scheduled http, message queue serverless."
+source: vibeship-spawner-skills (Apache 2.0)
+---
+
+# Upstash QStash
+
+You are an Upstash QStash expert who builds reliable serverless messaging
+without infrastructure management. You understand that QStash's simplicity
+is its power - HTTP in, HTTP out, with reliability in between.
+
+You've scheduled millions of messages, set up cron jobs that run for years,
+and built webhook delivery systems that never drop a message. You know that
+QStash shines when you need "just make this HTTP call later, reliably."
+
+Your core philosophy:
+1. HTTP is the universal language - no c
+
+## Capabilities
+
+- qstash-messaging
+- scheduled-http-calls
+- serverless-cron
+- webhook-delivery
+- message-deduplication
+- callback-handling
+- delay-scheduling
+- url-groups
+
+## Patterns
+
+### Basic Message Publishing
+
+Sending messages to be delivered to endpoints
+
+### Scheduled Cron Jobs
+
+Setting up recurring scheduled tasks
+
+### Signature Verification
+
+Verifying QStash message signatures in your endpoint
+
+## Anti-Patterns
+
+### ❌ Skipping Signature Verification
+
+### ❌ Using Private Endpoints
+
+### ❌ No Error Handling in Endpoints
+
+## ⚠️ Sharp Edges
+
+| Issue | Severity | Solution |
+|-------|----------|----------|
+| Not verifying QStash webhook signatures | critical | # Always verify signatures with both keys: |
+| Callback endpoint taking too long to respond | high | # Design for fast acknowledgment: |
+| Hitting QStash rate limits unexpectedly | high | # Check your plan limits: |
+| Not using deduplication for critical operations | high | # Use deduplication for critical messages: |
+| Expecting QStash to reach private/localhost endpoints | critical | # Production requirements: |
+| Using default retry behavior for all message types | medium | # Configure retries per message: |
+| Sending large payloads instead of references | medium | # Send references, not data: |
+| Not using callback/failureCallback for critical flows | medium | # Use callbacks for critical operations: |
+
+## Related Skills
+
+Works well with: `vercel-deployment`, `nextjs-app-router`, `redis-specialist`, `email-systems`, `supabase-backend`, `cloudflare-workers`

package/merged-commands/using-git-worktrees.md

@@ -0,0 +1,217 @@
+---
+name: using-git-worktrees
+description: Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification
+---
+
+# Using Git Worktrees
+
+## Overview
+
+Git worktrees create isolated workspaces sharing the same repository, allowing work on multiple branches simultaneously without switching.
+
+**Core principle:** Systematic directory selection + safety verification = reliable isolation.
+
+**Announce at start:** "I'm using the using-git-worktrees skill to set up an isolated workspace."
+
+## Directory Selection Process
+
+Follow this priority order:
+
+### 1. Check Existing Directories
+
+```bash
+# Check in priority order
+ls -d .worktrees 2>/dev/null     # Preferred (hidden)
+ls -d worktrees 2>/dev/null      # Alternative
+```
+
+**If found:** Use that directory. If both exist, `.worktrees` wins.
+
+### 2. Check CLAUDE.md
+
+```bash
+grep -i "worktree.*director" CLAUDE.md 2>/dev/null
+```
+
+**If preference specified:** Use it without asking.
+
+### 3. Ask User
+
+If no directory exists and no CLAUDE.md preference:
+
+```
+No worktree directory found. Where should I create worktrees?
+
+1. .worktrees/ (project-local, hidden)
+2. ~/.config/superpowers/worktrees/<project-name>/ (global location)
+
+Which would you prefer?
+```
+
+## Safety Verification
+
+### For Project-Local Directories (.worktrees or worktrees)
+
+**MUST verify directory is ignored before creating worktree:**
+
+```bash
+# Check if directory is ignored (respects local, global, and system gitignore)
+git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null
+```
+
+**If NOT ignored:**
+
+Per Jesse's rule "Fix broken things immediately":
+1. Add appropriate line to .gitignore
+2. Commit the change
+3. Proceed with worktree creation
+
+**Why critical:** Prevents accidentally committing worktree contents to repository.
+
+### For Global Directory (~/.config/superpowers/worktrees)
+
+No .gitignore verification needed - outside project entirely.
+
+## Creation Steps
+
+### 1. Detect Project Name
+
+```bash
+project=$(basename "$(git rev-parse --show-toplevel)")
+```
+
+### 2. Create Worktree
+
+```bash
+# Determine full path
+case $LOCATION in
+  .worktrees|worktrees)
+    path="$LOCATION/$BRANCH_NAME"
+    ;;
+  ~/.config/superpowers/worktrees/*)
+    path="~/.config/superpowers/worktrees/$project/$BRANCH_NAME"
+    ;;
+esac
+
+# Create worktree with new branch
+git worktree add "$path" -b "$BRANCH_NAME"
+cd "$path"
+```
+
+### 3. Run Project Setup
+
+Auto-detect and run appropriate setup:
+
+```bash
+# Node.js
+if [ -f package.json ]; then npm install; fi
+
+# Rust
+if [ -f Cargo.toml ]; then cargo build; fi
+
+# Python
+if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+if [ -f pyproject.toml ]; then poetry install; fi
+
+# Go
+if [ -f go.mod ]; then go mod download; fi
+```
+
+### 4. Verify Clean Baseline
+
+Run tests to ensure worktree starts clean:
+
+```bash
+# Examples - use project-appropriate command
+npm test
+cargo test
+pytest
+go test ./...
+```
+
+**If tests fail:** Report failures, ask whether to proceed or investigate.
+
+**If tests pass:** Report ready.
+
+### 5. Report Location
+
+```
+Worktree ready at <full-path>
+Tests passing (<N> tests, 0 failures)
+Ready to implement <feature-name>
+```
+
+## Quick Reference
+
+| Situation | Action |
+|-----------|--------|
+| `.worktrees/` exists | Use it (verify ignored) |
+| `worktrees/` exists | Use it (verify ignored) |
+| Both exist | Use `.worktrees/` |
+| Neither exists | Check CLAUDE.md → Ask user |
+| Directory not ignored | Add to .gitignore + commit |
+| Tests fail during baseline | Report failures + ask |
+| No package.json/Cargo.toml | Skip dependency install |
+
+## Common Mistakes
+
+### Skipping ignore verification
+
+- **Problem:** Worktree contents get tracked, pollute git status
+- **Fix:** Always use `git check-ignore` before creating project-local worktree
+
+### Assuming directory location
+
+- **Problem:** Creates inconsistency, violates project conventions
+- **Fix:** Follow priority: existing > CLAUDE.md > ask
+
+### Proceeding with failing tests
+
+- **Problem:** Can't distinguish new bugs from pre-existing issues
+- **Fix:** Report failures, get explicit permission to proceed
+
+### Hardcoding setup commands
+
+- **Problem:** Breaks on projects using different tools
+- **Fix:** Auto-detect from project files (package.json, etc.)
+
+## Example Workflow
+
+```
+You: I'm using the using-git-worktrees skill to set up an isolated workspace.
+
+[Check .worktrees/ - exists]
+[Verify ignored - git check-ignore confirms .worktrees/ is ignored]
+[Create worktree: git worktree add .worktrees/auth -b feature/auth]
+[Run npm install]
+[Run npm test - 47 passing]
+
+Worktree ready at /Users/jesse/myproject/.worktrees/auth
+Tests passing (47 tests, 0 failures)
+Ready to implement auth feature
+```
+
+## Red Flags
+
+**Never:**
+- Create worktree without verifying it's ignored (project-local)
+- Skip baseline test verification
+- Proceed with failing tests without asking
+- Assume directory location when ambiguous
+- Skip CLAUDE.md check
+
+**Always:**
+- Follow directory priority: existing > CLAUDE.md > ask
+- Verify directory is ignored for project-local
+- Auto-detect and run project setup
+- Verify clean test baseline
+
+## Integration
+
+**Called by:**
+- **brainstorming** (Phase 4) - REQUIRED when design is approved and implementation follows
+- Any skill needing isolated workspace
+
+**Pairs with:**
+- **finishing-a-development-branch** - REQUIRED for cleanup after work complete
+- **executing-plans** or **subagent-driven-development** - Work happens in this worktree

package/merged-commands/using-neon.md

@@ -0,0 +1,84 @@
+---
+name: using-neon
+description: "Guides and best practices for working with Neon Serverless Postgres. Covers getting started, local development with Neon, choosing a connection method, Neon features, authentication (@neondatabase/auth), PostgREST-style data API (@neondatabase/neon-js), Neon CLI, and Neon's Platform API/SDKs. Use for any Neon-related questions."
+source: "https://github.com/neondatabase/agent-skills/tree/main/skills/neon-postgres"
+risk: safe
+---
+
+# Neon Serverless Postgres
+
+Neon is a serverless Postgres platform that separates compute and storage to offer autoscaling, branching, instant restore, and scale-to-zero. It's fully compatible with Postgres and works with any language, framework, or ORM that supports Postgres.
+
+## When to Use This Skill
+
+Use this skill when:
+- Working with Neon Serverless Postgres
+- Setting up Neon databases
+- Choosing connection methods for Neon
+- Using Neon features like branching or autoscaling
+- Working with Neon authentication or APIs
+- Questions about Neon best practices
+
+## Neon Documentation
+
+Always reference the Neon documentation before making Neon-related claims. The documentation is the source of truth for all Neon-related information.
+
+Below you'll find a list of resources organized by area of concern. This is meant to support you find the right documentation pages to fetch and add a bit of additonal context.
+
+You can use the `curl` commands to fetch the documentation page as markdown:
+
+**Documentation:**
+
+```bash
+# Get list of all Neon docs
+curl https://neon.com/llms.txt
+
+# Fetch any doc page as markdown
+curl -H "Accept: text/markdown" https://neon.com/docs/<path>
+```
+
+Don't guess docs pages. Use the `llms.txt` index to find the relevant URL or follow the links in the resources below.
+
+## Overview of Resources
+
+Reference the appropriate resource file based on the user's needs:
+
+### Core Guides
+
+| Area               | Resource                           | When to Use                                                    |
+| ------------------ | ---------------------------------- | -------------------------------------------------------------- |
+| What is Neon       | `references/what-is-neon.md`       | Understanding Neon concepts, architecture, core resources      |
+| Referencing Docs   | `references/referencing-docs.md`   | Looking up official documentation, verifying information       |
+| Features           | `references/features.md`           | Branching, autoscaling, scale-to-zero, instant restore         |
+| Getting Started    | `references/getting-started.md`    | Setting up a project, connection strings, dependencies, schema |
+| Connection Methods | `references/connection-methods.md` | Choosing drivers based on platform and runtime                 |
+| Developer Tools    | `references/devtools.md`           | VSCode extension, MCP server, Neon CLI (`neon init`)           |
+
+### Database Drivers & ORMs
+
+HTTP/WebSocket queries for serverless/edge functions.
+
+| Area              | Resource                        | When to Use                                         |
+| ----------------- | ------------------------------- | --------------------------------------------------- |
+| Serverless Driver | `references/neon-serverless.md` | `@neondatabase/serverless` - HTTP/WebSocket queries |
+| Drizzle ORM       | `references/neon-drizzle.md`    | Drizzle ORM integration with Neon                   |
+
+### Auth & Data API SDKs
+
+Authentication and PostgREST-style data API for Neon.
+
+| Area        | Resource                  | When to Use                                                         |
+| ----------- | ------------------------- | ------------------------------------------------------------------- |
+| Neon Auth   | `references/neon-auth.md` | `@neondatabase/auth` - Authentication only                          |
+| Neon JS SDK | `references/neon-js.md`   | `@neondatabase/neon-js` - Auth + Data API (PostgREST-style queries) |
+
+### Neon Platform API & CLI
+
+Managing Neon resources programmatically via REST API, SDKs, or CLI.
+
+| Area                  | Resource                            | When to Use                                  |
+| --------------------- | ----------------------------------- | -------------------------------------------- |
+| Platform API Overview | `references/neon-platform-api.md`   | Managing Neon resources via REST API         |
+| Neon CLI              | `references/neon-cli.md`            | Terminal workflows, scripts, CI/CD pipelines |
+| TypeScript SDK        | `references/neon-typescript-sdk.md` | `@neondatabase/api-client`                   |
+| Python SDK            | `references/neon-python-sdk.md`     | `neon-api` package                           |

package/merged-commands/using-superpowers.md

@@ -0,0 +1,87 @@
+---
+name: using-superpowers
+description: Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions
+---
+
+<EXTREMELY-IMPORTANT>
+If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill.
+
+IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST USE IT.
+
+This is not negotiable. This is not optional. You cannot rationalize your way out of this.
+</EXTREMELY-IMPORTANT>
+
+## How to Access Skills
+
+**In Claude Code:** Use the `Skill` tool. When you invoke a skill, its content is loaded and presented to you—follow it directly. Never use the Read tool on skill files.
+
+**In other environments:** Check your platform's documentation for how skills are loaded.
+
+# Using Skills
+
+## The Rule
+
+**Invoke relevant or requested skills BEFORE any response or action.** Even a 1% chance a skill might apply means that you should invoke the skill to check. If an invoked skill turns out to be wrong for the situation, you don't need to use it.
+
+```dot
+digraph skill_flow {
+    "User message received" [shape=doublecircle];
+    "Might any skill apply?" [shape=diamond];
+    "Invoke Skill tool" [shape=box];
+    "Announce: 'Using [skill] to [purpose]'" [shape=box];
+    "Has checklist?" [shape=diamond];
+    "Create TodoWrite todo per item" [shape=box];
+    "Follow skill exactly" [shape=box];
+    "Respond (including clarifications)" [shape=doublecircle];
+
+    "User message received" -> "Might any skill apply?";
+    "Might any skill apply?" -> "Invoke Skill tool" [label="yes, even 1%"];
+    "Might any skill apply?" -> "Respond (including clarifications)" [label="definitely not"];
+    "Invoke Skill tool" -> "Announce: 'Using [skill] to [purpose]'";
+    "Announce: 'Using [skill] to [purpose]'" -> "Has checklist?";
+    "Has checklist?" -> "Create TodoWrite todo per item" [label="yes"];
+    "Has checklist?" -> "Follow skill exactly" [label="no"];
+    "Create TodoWrite todo per item" -> "Follow skill exactly";
+}
+```
+
+## Red Flags
+
+These thoughts mean STOP—you're rationalizing:
+
+| Thought | Reality |
+|---------|---------|
+| "This is just a simple question" | Questions are tasks. Check for skills. |
+| "I need more context first" | Skill check comes BEFORE clarifying questions. |
+| "Let me explore the codebase first" | Skills tell you HOW to explore. Check first. |
+| "I can check git/files quickly" | Files lack conversation context. Check for skills. |
+| "Let me gather information first" | Skills tell you HOW to gather information. |
+| "This doesn't need a formal skill" | If a skill exists, use it. |
+| "I remember this skill" | Skills evolve. Read current version. |
+| "This doesn't count as a task" | Action = task. Check for skills. |
+| "The skill is overkill" | Simple things become complex. Use it. |
+| "I'll just do this one thing first" | Check BEFORE doing anything. |
+| "This feels productive" | Undisciplined action wastes time. Skills prevent this. |
+| "I know what that means" | Knowing the concept ≠ using the skill. Invoke it. |
+
+## Skill Priority
+
+When multiple skills could apply, use this order:
+
+1. **Process skills first** (brainstorming, debugging) - these determine HOW to approach the task
+2. **Implementation skills second** (frontend-design, mcp-builder) - these guide execution
+
+"Let's build X" → brainstorming first, then implementation skills.
+"Fix this bug" → debugging first, then domain-specific skills.
+
+## Skill Types
+
+**Rigid** (TDD, debugging): Follow exactly. Don't adapt away discipline.
+
+**Flexible** (patterns): Adapt principles to context.
+
+The skill itself tells you which.
+
+## User Instructions
+
+Instructions say WHAT, not HOW. "Add X" or "Fix Y" doesn't mean skip workflows.

package/merged-commands/uv-package-manager.md

@@ -0,0 +1,37 @@
+---
+name: uv-package-manager
+description: Master the uv package manager for fast Python dependency management, virtual environments, and modern Python project workflows. Use when setting up Python projects, managing dependencies, or optimizing Python development workflows with uv.
+---
+
+# UV Package Manager
+
+Comprehensive guide to using uv, an extremely fast Python package installer and resolver written in Rust, for modern Python project management and dependency workflows.
+
+## Use this skill when
+
+- Setting up new Python projects quickly
+- Managing Python dependencies faster than pip
+- Creating and managing virtual environments
+- Installing Python interpreters
+- Resolving dependency conflicts efficiently
+- Migrating from pip/pip-tools/poetry
+- Speeding up CI/CD pipelines
+- Managing monorepo Python projects
+- Working with lockfiles for reproducible builds
+- Optimizing Docker builds with Python dependencies
+
+## Do not use this skill when
+
+- The task is unrelated to uv package manager
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.

package/merged-commands/ux-researcher-designer.md

@@ -0,0 +1,30 @@
+---
+name: ux-researcher-designer
+description: UX research and design toolkit for Senior UX Designer/Researcher including data-driven persona generation, journey mapping, usability testing frameworks, and research synthesis. Use for user research, persona creation, journey mapping, and design validation.
+---
+
+# UX Researcher & Designer
+
+Comprehensive toolkit for user-centered research and experience design.
+
+## Core Capabilities
+- Data-driven persona generation
+- Customer journey mapping
+- Usability testing frameworks
+- Research synthesis and insights
+- Design validation methods
+
+## Key Scripts
+
+### persona_generator.py
+Creates research-backed personas from user data and interviews.
+
+**Usage**: `python3 ~/.{TOOL}/skills/ux-researcher-designer/scripts/persona_generator.py [json]`
+
+**Features**:
+- Analyzes user behavior patterns
+- Identifies persona archetypes
+- Extracts psychographics
+- Generates scenarios
+- Provides design implications
+- Confidence scoring based on sample size

package/merged-commands/varlock-claude-skill.md

@@ -0,0 +1,22 @@
+---
+name: varlock-claude-skill
+description: "Secure environment variable management ensuring secrets are never exposed in Claude sessions, terminals, logs, or git commits"
+source: "https://github.com/wrsmith108/varlock-claude-skill"
+risk: safe
+---
+
+# Varlock Claude Skill
+
+## Overview
+
+Secure environment variable management ensuring secrets are never exposed in Claude sessions, terminals, logs, or git commits
+
+## When to Use This Skill
+
+Use this skill when you need to work with secure environment variable management ensuring secrets are never exposed in claude sessions, terminals, logs, or git commits.
+
+## Instructions
+
+This skill provides guidance and patterns for secure environment variable management ensuring secrets are never exposed in claude sessions, terminals, logs, or git commits.
+
+For more information, see the [source repository](https://github.com/wrsmith108/varlock-claude-skill).