@ngxtm/devkit 3.0.2 → 3.1.0

package/skills/unreal-engine-cpp-pro/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: unreal-engine-cpp-pro
+description: Expert guide for Unreal Engine 5.x C++ development, covering UObject hygiene, performance patterns, and best practices.
+risk: safe
+source: self
+---
+
+# Unreal Engine C++ Pro
+
+This skill provides expert-level guidelines for developing with Unreal Engine 5 using C++. It focuses on writing robust, performant, and standard-compliant code.
+
+## When to Use
+
+Use this skill when:
+- Developing C++ code for Unreal Engine 5.x projects
+- Writing Actors, Components, or UObject-derived classes
+- Optimizing performance-critical code in Unreal Engine
+- Debugging memory leaks or garbage collection issues
+- Implementing Blueprint-exposed functionality
+- Following Epic Games' coding standards and conventions
+- Working with Unreal's reflection system (UCLASS, USTRUCT, UFUNCTION)
+- Managing asset loading and soft references
+
+Do not use this skill when:
+- Working with Blueprint-only projects (no C++ code)
+- Developing for Unreal Engine versions prior to 5.x
+- Working on non-Unreal game engines
+- The task is unrelated to Unreal Engine development
+
+## Core Principles
+
+1.  **UObject & Garbage Collection**:
+    *   Always use `UPROPERTY()` for `UObject*` member variables to ensure they are tracked by the Garbage Collector (GC).
+    *   Use `TStrongObjectPtr<>` if you need to keep a root reference outside of a UObject graph, but prefer `addToRoot()` generally.
+    *   Understand the `IsValid()` check vs `nullptr`. `IsValid()` handles pending kill state safely.
+
+2.  **Unreal Reflection System**:
+    *   Use `UCLASS()`, `USTRUCT()`, `UENUM()`, `UFUNCTION()` to expose types to the reflection system and Blueprints.
+    *   Minimize `BlueprintReadWrite` when possible; prefer `BlueprintReadOnly` for state that shouldn't be trampled by logic in UI/Level BPs.
+
+3.  **Performance First**:
+    *   **Tick**: Disable Ticking (`bCanEverTick = false`) by default. Only enable it if absolutely necessary. Prefer timers (`GetWorldTimerManager()`) or event-driven logic.
+    *   **Casting**: Avoid `Cast<T>()` in hot loops. Cache references in `BeginPlay`.
+    *   **Structs vs Classes**: Use `F` structs for data-heavy, non-UObject types to reduce overhead.
+
+## Naming Conventions (Strict)
+
+Follow Epic Games' coding standard:
+
+*   **Templates**: Prefix with `T` (e.g., `TArray`, `TMap`).
+*   **UObject**: Prefix with `U` (e.g., `UCharacterMovementComponent`).
+*   **AActor**: Prefix with `A` (e.g., `AMyGameMode`).
+*   **SWidget**: Prefix with `S` (Slate widgets).
+*   **Structs**: Prefix with `F` (e.g., `FVector`).
+*   **Enums**: Prefix with `E` (e.g., `EWeaponState`).
+*   **Interfaces**: Prefix with `I` (e.g., `IInteractable`).
+*   **Booleans**: Prefix with `b` (e.g., `bIsDead`).
+
+## Common Patterns
+
+### 1. Robust Component Lookup
+Avoid `GetComponentByClass` in `Tick`. Do it in `PostInitializeComponents` or `BeginPlay`.
+
+```cpp
+void AMyCharacter::PostInitializeComponents() {
+    Super::PostInitializeComponents();
+    HealthComp = FindComponentByClass<UHealthComponent>();
+    check(HealthComp); // Fail hard in dev if missing
+}
+```
+
+### 2. Interface Implementation
+Use interfaces to decouple systems (e.g., Interaction system).
+
+```cpp
+// Interface call check
+if (TargetActor->Implements<UInteractable>()) {
+    IInteractable::Execute_OnInteract(TargetActor, this);
+}
+```
+
+### 3. Async Loading (Soft References)
+Avoid hard references (`UPROPERTY(EditDefaultsOnly) TSubclassOf<AActor>`) for massive assets which force load orders. Use `TSoftClassPtr` or `TSoftObjectPtr`.
+
+```cpp
+UPROPERTY(EditAnywhere, BlueprintReadWrite)
+TSoftClassPtr<AWeapon> WeaponClassToLoad;
+
+void AMyCharacter::Equip() {
+    if (WeaponClassToLoad.IsPending()) {
+        WeaponClassToLoad.LoadSynchronous(); // Or use StreamableManager for async
+    }
+}
+```
+
+## Debugging
+
+*   **Logging**: Use `UE_LOG` with custom categories.
+    ```cpp
+    DEFINE_LOG_CATEGORY_STATIC(LogMyGame, Log, All);
+    UE_LOG(LogMyGame, Warning, TEXT("Health is low: %f"), CurrentHealth);
+    ```
+*   **Screen Messages**:
+    ```cpp
+    if (GEngine) GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, TEXT("Died!"));
+    ```
+*   **Visual Logger**: extremely useful for AI debugging. Implement `IVisualLoggerDebugSnapshotInterface`.
+
+## Checklist before PR
+
+- [ ] Does this Actor need to Tick? Can it be a Timer?
+- [ ] Are all `UObject*` members wrapped in `UPROPERTY`?
+- [ ] Are hard references (TSubclassOf) causing load chains? Can they be Soft Ptrs?
+- [ ] Did you clean up verified delegates in `EndPlay`?

package/skills/unreal-engine-cpp-pro/examples/ExampleActor.cpp

@@ -0,0 +1,43 @@
+#include "ExampleActor.h"
+#include "Components/BoxComponent.h"
+#include "Kismet/GameplayStatics.h"
+
+// Define a static log category for this specific file/module
+DEFINE_LOG_CATEGORY_STATIC(LogExampleActor, Log, All);
+
+AExampleActor::AExampleActor()
+{
+    // Default to strict settings
+    PrimaryActorTick.bCanEverTick = false; 
+    PrimaryActorTick.bStartWithTickEnabled = false;
+
+    RootCollision = CreateDefaultSubobject<UBoxComponent>(TEXT("RootCollision"));
+    RootComponent = RootCollision;
+    
+    bIsActive = true;
+}
+
+void AExampleActor::BeginPlay()
+{
+    Super::BeginPlay();
+    
+    // Cache references here, not in Tick
+    CachedPC = UGameplayStatics::GetPlayerController(this, 0);
+
+    if (bIsActive)
+    {
+        UE_LOG(LogExampleActor, Log, TEXT("ExampleActor %s started!"), *GetName());
+    }
+}
+
+void AExampleActor::EndPlay(const EEndPlayReason::Type EndPlayReason)
+{
+    // Clean up any strict delegates or handles here
+    Super::EndPlay(EndPlayReason);
+}
+
+void AExampleActor::Tick(float DeltaTime)
+{
+    Super::Tick(DeltaTime);
+    // Ticking is disabled by default in constructor, so this won't run unless enabled explicitly.
+}

package/skills/unreal-engine-cpp-pro/examples/ExampleActor.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "GameFramework/Actor.h"
+#include "ExampleActor.generated.h"
+
+// Forward overrides to reduce compile times
+class UBoxComponent;
+
+/**
+ * AExampleActor
+ * 
+ * Demonstrates:
+ * 1. Correct class prefix (A)
+ * 2. UPROPERTY usage
+ * 3. Soft references for assets
+ */
+UCLASS()
+class MYGAME_API AExampleActor : public AActor
+{
+    GENERATED_BODY()
+    
+public:    
+    // Sets default values for this actor's properties
+    AExampleActor();
+
+protected:
+    // Called when the game starts or when spawned
+    virtual void BeginPlay() override;
+    
+    // Called when the game ends
+    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
+
+public:    
+    // Called every frame
+    virtual void Tick(float DeltaTime) override;
+
+    /** Component exposed to Blueprint, but immutable logic in C++ */
+    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
+    UBoxComponent* RootCollision;
+
+    /** 
+     * Soft reference to an actor class to lazy load.
+     * Prevents hard reference chains.
+     */
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Config")
+    TSoftClassPtr<AActor> ActorTypeToSpawn;
+
+    /** Proper boolean naming convention 'b' */
+    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "State")
+    uint8 bIsActive:1;
+
+private:
+    /** Cached reference, not exposed to Blueprints */
+    UPROPERTY(Transient)
+    APlayerController* CachedPC;
+};

package/skills/upgrading-expo/SKILL.md

@@ -1,22 +1,118 @@
 ---
 name: upgrading-expo
-description: Guidelines for upgrading Expo SDK versions and fixing dependency issues.
-author: expo
-category: development
-tags: [expo, react, typescript]
+description: "Upgrade Expo SDK versions"
+source: "https://github.com/expo/skills/tree/main/plugins/upgrading-expo"
+risk: safe
 ---
 
 # Upgrading Expo
 
-Guidelines for upgrading Expo SDK versions and fixing dependency issues.
+## Overview
 
-## When to Use
+Upgrade Expo SDK versions safely, handling breaking changes, dependencies, and configuration updates.
 
-- Upgrading Expo SDK versions
-- Fixing dependency conflicts
-- Migration patterns
-- Breaking change handling
+## When to Use This Skill
 
-## Source
+Use this skill when you need to upgrade Expo SDK versions.
 
-This skill references patterns from [Expo's skills](https://github.com/expo/skills).
+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/skills/using-neon/SKILL.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/skills/uv-package-manager/SKILL.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.