constellai 0.3.0

package/skills/stacks/mobile/ionic/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: ionic
+description: Ionic is an open-source UI toolkit for building cross-platform mobile, desktop, and web apps from one web codebase (Angular, React, or Vue) running natively via Capacitor; consult when scaffolding with ionic start, using Ionic UI components, or wiring native device features.
+domain: stack
+category: mobile
+tags: [ionic, capacitor, angular, react, vue, mobile, web]
+official_sources:
+  - https://ionicframework.com/docs
+  - https://github.com/ionic-team/ionic-framework
+  - https://ionicframework.com/docs/intro/cli
+verified: 2026-06-17
+---
+
+# Ionic
+
+## Overview
+Ionic is an open-source UI toolkit for building cross-platform apps for mobile, desktop, and web from a single web-technology codebase, integrating with Angular, React, or Vue. UI is composed of framework-agnostic web components; native packaging and device APIs come from Capacitor. Read this when scaffolding an Ionic app, using its component library, theming, or bridging to native features.
+
+## Official sources
+- Docs: https://ionicframework.com/docs
+- Repo: https://github.com/ionic-team/ionic-framework
+- Install: https://ionicframework.com/docs/intro/cli
+
+## Install / setup
+```bash
+npm install -g @ionic/cli
+ionic start myApp tabs --type=angular --capacitor
+cd myApp
+ionic serve
+```
+Install command from https://ionicframework.com/docs/intro/cli; `ionic start` usage from https://ionicframework.com/docs/cli/commands/start (swap `--type=react` or `--type=vue` as needed).
+
+## Core concepts
+- **Web components** — `<ion-button>`, `<ion-list>`, etc., are framework-agnostic components usable from Angular/React/Vue.
+- **Capacitor** — the native runtime that packages the web app as iOS/Android and exposes device plugins (Camera, Filesystem, etc.).
+- **Adaptive (mode) styling** — components adapt to `ios` or `md` (Material) mode for platform-appropriate look and feel.
+- **Routing & navigation** — uses the host framework's router (Angular Router, React Router, Vue Router) plus `ion-router-outlet`.
+- **CSS variables / theming** — customize via CSS custom properties and the global theme.
+- **ionic CLI** — `start`, `serve`, `build`, `generate`, and `capacitor` subcommands.
+
+## Best practices
+- Use Capacitor (default for new apps) over legacy Cordova for native builds (https://ionicframework.com/docs/developing/starting).
+- Choose the framework integration matching your team (Angular/React/Vue) at `ionic start` time (https://ionicframework.com/docs/cli/commands/start).
+- Theme with CSS variables rather than overriding component internals (https://ionicframework.com/docs/theming/basics).
+- Lazy-load routes/pages to keep startup fast on devices (https://ionicframework.com/docs/angular/navigation).
+
+## Common pitfalls
+- Forgetting `npx cap sync` after installing native plugins → native projects miss the changes.
+- Heavy DOM/animation work on low-end devices → it's still a WebView; profile and virtualize long lists with your framework's virtual-scroll solution (Angular CDK, react-window, vue-virtual-scroller).
+- Mixing Cordova and Capacitor plugin assumptions → prefer Capacitor-native plugins.
+
+## Examples
+```html
+<ion-header>
+  <ion-toolbar>
+    <ion-title>Home</ion-title>
+  </ion-toolbar>
+</ion-header>
+<ion-content class="ion-padding">
+  <ion-button expand="block">Tap me</ion-button>
+</ion-content>
+```
+
+## Further reading
+- https://ionicframework.com/docs/components — UI component reference
+- https://capacitorjs.com/docs — Capacitor native runtime and plugins
+- https://ionicframework.com/docs/theming/basics — theming with CSS variables
+
+## Related skills
+- ../react-native — alternative cross-platform mobile framework
+- ../nativescript — JS-to-native UI without a WebView
+- ../flutter — native-rendered cross-platform UI toolkit

package/skills/stacks/mobile/nativescript/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: nativescript
+description: NativeScript is an open-source framework for building truly native iOS and Android apps from JavaScript/TypeScript with direct access to native APIs (no WebView), usable plain or with Angular, Vue, React, Svelte, or SolidJS; consult when scaffolding with ns create or calling native platform APIs.
+domain: stack
+category: mobile
+tags: [nativescript, typescript, javascript, mobile, ios, android, native]
+official_sources:
+  - https://docs.nativescript.org/
+  - https://github.com/NativeScript/NativeScript
+  - https://docs.nativescript.org/setup/
+verified: 2026-06-17
+---
+
+# NativeScript
+
+## Overview
+NativeScript is an open-source framework for building truly native iOS and Android apps using JavaScript or TypeScript, rendering native UI components (not a WebView) and giving direct, synchronous access to native platform APIs. It works standalone or with Angular, Vue, React, Svelte, or SolidJS flavors. Read this when scaffolding a NativeScript app, calling iOS/Android APIs directly from JS, or wiring native UI.
+
+## Official sources
+- Docs: https://docs.nativescript.org/
+- Repo: https://github.com/NativeScript/NativeScript
+- Install: https://docs.nativescript.org/setup/
+
+## Install / setup
+```bash
+npm install -g nativescript
+ns create myCoolApp --template @nativescript/template-blank
+cd myCoolApp
+ns run android   # or: ns run ios
+```
+Install command from https://docs.nativescript.org/setup/windows; `ns create` template usage from https://docs.nativescript.org/guide/creating-a-project.
+
+## Core concepts
+- **Direct native API access** — call iOS (Objective-C/Swift) and Android (Java/Kotlin) APIs straight from JS via generated bindings.
+- **Native UI elements** — XML/markup maps to real native views (`<Label>`, `<Button>`, `<ListView>`), no DOM/WebView.
+- **Flavors** — author in plain JS/TS or with Angular, Vue, React, Svelte, or SolidJS bindings.
+- **ns CLI** — `create`, `run`, `build`, `debug`, `preview`, and `plugin` subcommands.
+- **Plugins** — npm packages wrapping native SDKs; installed with `ns plugin add`.
+- **Webpack & HMR** — bundled with webpack; hot module replacement during `ns run`.
+
+## Best practices
+- Pick a flavor that matches your team and scaffold with the right template (`--ng`, `--vue`, `--react`, etc.) (https://docs.nativescript.org/guide/creating-a-project).
+- Verify your toolchain with `ns doctor` before building (https://docs.nativescript.org/setup/).
+- Prefer maintained `@nativescript/*` plugins for native features (https://docs.nativescript.org/guide/development-workflow/using-packages).
+- Use TypeScript for type-safe access to native API typings; generate them with `ns typings ios`/`ns typings android` (https://docs.nativescript.org/guide/native-code/generate-typings).
+
+## Common pitfalls
+- Missing native SDKs/emulators → run `ns doctor` and follow the per-OS setup guide.
+- Treating it like web → there is no DOM or CSS cascade; layout uses NativeScript layout containers and a CSS subset.
+- Stale build artifacts after native changes → `ns clean`, then rebuild.
+
+## Examples
+```xml
+<!-- main-page.xml -->
+<Page xmlns="http://schemas.nativescript.org/tns.xsd">
+  <StackLayout>
+    <Label text="Hello from NativeScript" />
+    <Button text="Tap" tap="{{ onTap }}" />
+  </StackLayout>
+</Page>
+```
+
+## Further reading
+- https://docs.nativescript.org/guide/marshalling/ — marshalling and calling native APIs
+- https://market.nativescript.org/ — plugins marketplace
+- https://docs.nativescript.org/setup/ — environment setup and `ns doctor`
+
+## Related skills
+- ../react-native — also renders native UI from JavaScript
+- ../ionic — web-tech cross-platform mobile alternative (Capacitor)
+- ../android — native Android APIs surfaced by NativeScript

package/skills/stacks/mobile/react-native/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: react-native
+description: React Native cross-platform mobile framework that builds native iOS and Android apps from React/JavaScript; consult when scaffolding, navigating, styling, debugging Metro/native modules, or shipping RN apps with Expo or the community CLI.
+domain: stack
+category: mobile
+tags: [react-native, react, mobile, ios, android, expo, javascript]
+official_sources:
+  - https://reactnative.dev/docs/getting-started
+  - https://github.com/facebook/react-native
+  - https://reactnative.dev/docs/environment-setup
+verified: 2026-06-17
+---
+
+# React Native
+
+## Overview
+React Native is an open-source framework from Meta for building native iOS and Android apps using React and JavaScript/TypeScript. UI is declared with React components that render to real native views (not a WebView). Read this when starting an RN project, wiring navigation, building native modules, or troubleshooting the Metro bundler and platform builds.
+
+## Official sources
+- Docs: https://reactnative.dev/docs/getting-started
+- Repo: https://github.com/facebook/react-native
+- Install: https://reactnative.dev/docs/environment-setup
+
+## Install / setup
+```bash
+npx @react-native-community/cli@latest init AwesomeProject
+```
+From the official "without a framework" guide at https://reactnative.dev/docs/getting-started-without-a-framework. The docs recommend a framework (Expo) for new apps via `npx create-expo-app@latest`.
+
+## Core concepts
+- **Components & JSX** — UI built from `View`, `Text`, `Image`, `ScrollView`, etc., instead of HTML elements.
+- **Metro bundler** — JS bundler that serves and hot-reloads your code; started with `npx react-native start`.
+- **Native modules / New Architecture** — TurboModules and Fabric (the New Architecture, default in RN 0.76+) bridge JS to native APIs via JSI.
+- **StyleSheet & Flexbox** — styling uses JS objects and Flexbox; no CSS cascade; values are unitless density-independent pixels.
+- **Platform code** — `Platform.OS`, `.ios.js`/`.android.js` file extensions, and `Platform.select` for per-OS branches.
+- **Hermes** — default JS engine optimized for RN startup and memory.
+- **Frameworks (Expo)** — recommended toolbox providing routing, builds (EAS), and OTA updates on top of RN.
+
+## Best practices
+- Prefer a framework like Expo for new apps unless you have unusual native constraints (https://reactnative.dev/docs/getting-started).
+- Use the New Architecture and keep RN/native deps aligned via the Upgrade Helper (https://reactnative.dev/docs/upgrading).
+- Use `FlatList`/`SectionList` for long lists instead of mapping inside `ScrollView` (https://reactnative.dev/docs/optimizing-flatlist-configuration).
+- Type your app with TypeScript; the default template ships TS (https://reactnative.dev/docs/typescript).
+
+## Common pitfalls
+- Stale Metro cache after dependency changes → restart with `npx react-native start --reset-cache`.
+- Mixing incompatible native lib versions → use the Upgrade Helper and run `cd ios && pod install` after native changes.
+- Assuming CSS units/cascade → RN styles are per-component JS objects with Flexbox defaults (`flexDirection: 'column'`).
+
+## Examples
+```tsx
+import { View, Text, StyleSheet } from 'react-native';
+
+export default function App() {
+  return (
+    <View style={styles.center}>
+      <Text>Hello from React Native</Text>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  center: { flex: 1, alignItems: 'center', justifyContent: 'center' },
+});
+```
+
+## Further reading
+- https://reactnative.dev/docs/components-and-apis — built-in core components and APIs
+- https://reactnavigation.org/ — React Navigation, the standard routing library
+- https://docs.expo.dev/ — Expo framework, EAS builds, and OTA updates
+
+## Related skills
+- ../ionic — another web-tech cross-platform mobile stack (Capacitor)
+- ../flutter — alternative cross-platform native UI toolkit
+- ../nativescript — native UI from JS without a WebView

package/skills/stacks/mobile/xamarin/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: xamarin
+description: .NET MAUI is Microsoft's cross-platform framework (Xamarin's successor) for building native Android, iOS, macOS, and Windows apps from one C# and XAML codebase; consult when scaffolding with dotnet new maui, writing XAML/MVVM UI, or migrating from Xamarin.Forms.
+domain: stack
+category: mobile
+tags: [maui, xamarin, dotnet, csharp, xaml, mobile, cross-platform]
+official_sources:
+  - https://learn.microsoft.com/en-us/dotnet/maui/
+  - https://github.com/dotnet/maui
+  - https://dotnet.microsoft.com/en-us/apps/maui
+verified: 2026-06-17
+---
+
+# Xamarin / .NET MAUI
+
+## Overview
+.NET MAUI (Multi-platform App UI) is Microsoft's open-source framework for building native apps for Android, iOS, macOS, and Windows from a single C#/XAML codebase. It is the evolution and successor of Xamarin.Forms (Xamarin support ended May 1, 2024). Read this when starting a MAUI app, building XAML UI with MVVM/data binding, sharing code across platforms, or migrating a Xamarin.Forms project.
+
+## Official sources
+- Docs: https://learn.microsoft.com/en-us/dotnet/maui/
+- Repo: https://github.com/dotnet/maui
+- Install: https://dotnet.microsoft.com/en-us/apps/maui
+
+## Install / setup
+```bash
+dotnet workload install maui
+dotnet new maui -n MyMauiApp
+cd MyMauiApp
+dotnet build -t:Run -f net9.0-android
+```
+CLI creation from https://learn.microsoft.com/en-us/dotnet/maui/get-started/first-app (install the `.NET MAUI` workload / Visual Studio MAUI workload per https://learn.microsoft.com/en-us/dotnet/maui/get-started/installation).
+
+## Core concepts
+- **Single project, multi-target** — one project targets `net*-android`, `net*-ios`, `net*-maccatalyst`, `net*-windows`.
+- **XAML + code-behind** — declarative UI in XAML paired with C# code-behind/handlers.
+- **MVVM & data binding** — `BindingContext`, `INotifyPropertyChanged`, and commands separate UI from logic.
+- **Handlers** — lightweight mapping from cross-platform controls to native views (replacing Xamarin renderers).
+- **Layouts & controls** — `Grid`, `StackLayout`, `CollectionView`, `Shell` for app structure and navigation.
+- **Dependency injection** — built-in DI registered in `MauiProgram.CreateMauiApp()`.
+- **Platform code** — conditional `#if ANDROID`/`IOS` and `Platforms/` folders for native specifics.
+
+## Best practices
+- Use MVVM with the .NET MAUI Community Toolkit's source generators for clean view models (https://learn.microsoft.com/en-us/dotnet/communitytoolkit/maui/).
+- Prefer `CollectionView`/`Shell` over legacy `ListView`/manual navigation (https://learn.microsoft.com/en-us/dotnet/maui/user-interface/controls/collectionview/).
+- Register services and pages via DI in `MauiProgram` (https://learn.microsoft.com/en-us/dotnet/maui/fundamentals/dependency-injection).
+- Migrate Xamarin.Forms apps with the official upgrade guidance (https://learn.microsoft.com/en-us/dotnet/maui/migration/).
+
+## Common pitfalls
+- Blocking the UI thread → use `async`/`await` and `MainThread.BeginInvokeOnMainThread` for UI updates.
+- Forgetting the MAUI workload → builds fail; run `dotnet workload install maui`.
+- Assuming Xamarin custom renderers carry over → port them to MAUI handlers.
+
+## Examples
+```xml
+<!-- MainPage.xaml -->
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml">
+  <VerticalStackLayout Padding="20" Spacing="10">
+    <Label Text="Hello, .NET MAUI!" FontSize="24" />
+    <Button Text="Click" Clicked="OnClicked" />
+  </VerticalStackLayout>
+</ContentPage>
+```
+
+## Further reading
+- https://learn.microsoft.com/en-us/dotnet/maui/fundamentals/data-binding/ — fundamentals: data binding (see also app-lifecycle, shell)
+- https://learn.microsoft.com/en-us/dotnet/maui/migration/ — migrating from Xamarin.Forms
+- https://learn.microsoft.com/en-us/dotnet/communitytoolkit/maui/ — .NET MAUI Community Toolkit
+
+## Related skills
+- ../flutter — alternative single-codebase native cross-platform UI
+- ../react-native — JS/React cross-platform mobile framework
+- ../android — native Android target underneath MAUI

package/skills/stacks/orm/diesel/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: diesel
+description: Safe, extensible compile-time-checked ORM and query builder for Rust; consult for type-safe SQL against PostgreSQL, MySQL, or SQLite in Rust.
+domain: stack
+category: orm
+tags: [orm, rust, query-builder, postgresql, sqlite, mysql]
+official_sources:
+  - https://diesel.rs/guides/
+  - https://github.com/diesel-rs/diesel
+verified: 2026-06-16
+---
+
+# Diesel
+
+## Overview
+Diesel is a safe, extensible ORM and query builder for Rust that uses Rust's type system to catch query errors at compile time and eliminate boilerplate. It supports PostgreSQL, MySQL, and SQLite with a zero-cost, Rust-like query DSL. Read this when building Rust applications that need type-safe, performant database access.
+
+## Official sources
+- Docs / guides: https://diesel.rs/guides/
+- Repo: https://github.com/diesel-rs/diesel
+- Install / getting started: https://diesel.rs/guides/getting-started
+
+## Install / setup
+```bash
+cargo install diesel_cli --no-default-features --features postgres
+```
+Add to `Cargo.toml`:
+```toml
+diesel = { version = "2.2.0", features = ["postgres"] }
+dotenvy = "0.15"
+```
+
+## Core concepts
+- **diesel_cli**: command-line tool that creates the database, manages migrations, and generates schema (`diesel setup`, `diesel migration`).
+- **schema.rs**: generated `table!` definitions describing tables and columns, used for compile-time query checking.
+- **Migrations**: pairs of `up.sql`/`down.sql` files applied and reverted by the CLI.
+- **Connection**: a typed connection (e.g. `PgConnection`) established with a database URL.
+- **Query DSL**: methods like `filter`, `select`, `load`, `insert_into` compile to checked SQL.
+- **Derive macros**: `Queryable`, `Insertable`, `Selectable` map Rust structs to rows.
+
+## Best practices
+- Install `diesel_cli` with only the features you need (e.g. `--no-default-features --features postgres`) to avoid pulling in unused client libraries (per the getting-started guide).
+- Keep `schema.rs` generated from migrations rather than hand-editing it, so it matches the database.
+- Store the connection URL in a `.env` file (used with `dotenvy`) as shown in the guide.
+- Write reversible migrations (`up.sql` + `down.sql`) and run them through the CLI.
+
+## Common pitfalls
+- Installing `diesel_cli` without the right backend feature → build errors or a CLI that cannot talk to your database; specify the backend feature.
+- Editing `schema.rs` by hand → drift from the real schema; regenerate it from migrations instead.
+
+## Examples
+```rust
+use diesel::prelude::*;
+
+#[derive(Queryable, Selectable)]
+#[diesel(table_name = crate::schema::users)]
+struct User { id: i32, name: String }
+
+let conn = &mut PgConnection::establish(&database_url)?;
+let results = users::table
+    .filter(users::name.eq("Ada"))
+    .select(User::as_select())
+    .load(conn)?;
+```
+
+## Further reading
+- https://diesel.rs/guides/getting-started — getting started
+- https://diesel.rs/guides/all-about-inserts — inserts guide
+
+## Related skills
+- ../gorm — Go's standard ORM (contrast: another typed-language ORM)
+- ../prisma — type-safe ORM in the TS ecosystem

package/skills/stacks/orm/django-orm/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: django-orm
+description: Django's built-in ORM — models, QuerySets, migrations, and the admin; consult for relational data access inside a Django project.
+domain: stack
+category: orm
+tags: [orm, python, django, models, queryset, migrations]
+official_sources:
+  - https://docs.djangoproject.com/en/stable/topics/db/
+  - https://github.com/django/django
+verified: 2026-06-16
+---
+
+# Django ORM
+
+## Overview
+The Django ORM ships with the Django web framework and is the single, definitive source of truth for your data: each model maps to a database table, and you query through lazy QuerySets. It includes a migration system and integrates with the Django admin. Read this when building data access inside a Django project rather than as a standalone library (the ORM is not distributed separately).
+
+## Official sources
+- Docs: https://docs.djangoproject.com/en/stable/topics/db/
+- Repo: https://github.com/django/django
+
+## Core concepts
+- **Models**: subclasses of `django.db.models.Model`; each field maps to a column and each model to a table.
+- **QuerySets**: lazy, chainable query objects (`Model.objects.filter(...)`) that hit the database only when evaluated.
+- **Managers**: the `objects` manager is the query entry point; custom managers add reusable query logic.
+- **Migrations**: schema changes are captured by `makemigrations` and applied with `migrate`.
+- **Relationships**: `ForeignKey`, `ManyToManyField`, `OneToOneField` model associations with related-object access.
+- **Aggregation & raw SQL**: `annotate`/`aggregate` for grouped queries, plus escape hatches for raw SQL when needed.
+
+## Best practices
+- Use `select_related` (joins) and `prefetch_related` (separate queries) to avoid N+1 when traversing relations (per docs).
+- Always create and review migrations with `makemigrations`/`migrate`; keep them in version control.
+- Defer or restrict columns with `only()`/`defer()` and `values()` when you do not need full model instances.
+- Wrap multi-step writes in `transaction.atomic()` for atomicity.
+
+## Common pitfalls
+- Iterating related objects in a loop without `select_related`/`prefetch_related` → N+1 query storms.
+- Assuming QuerySets execute immediately → they are lazy and re-evaluating one repeatedly re-runs the query; cache with `list()` when reused.
+
+## Examples
+```python
+from django.db import models
+
+class User(models.Model):
+    name = models.CharField(max_length=50)
+
+# querying
+ada = User.objects.create(name="Ada")
+adults = User.objects.filter(name="Ada").select_related()
+```
+
+## Further reading
+- https://docs.djangoproject.com/en/stable/topics/db/queries/ — making queries
+- https://docs.djangoproject.com/en/stable/topics/db/optimization/ — query optimization
+
+## Related skills
+- ../sqlalchemy — standalone Python ORM/toolkit alternative
+- ../prisma — type-safe ORM in the TS ecosystem

package/skills/stacks/orm/drizzle/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: drizzle
+description: Lightweight, headless TypeScript-first SQL ORM with zero dependencies and SQL-like queries; consult for type-safe SQL in Node/edge runtimes.
+domain: stack
+category: orm
+tags: [orm, typescript, nodejs, sql, serverless, postgresql]
+official_sources:
+  - https://orm.drizzle.team/docs/overview
+  - https://github.com/drizzle-team/drizzle-orm
+verified: 2026-06-16
+---
+
+# Drizzle ORM
+
+## Overview
+Drizzle is a headless, TypeScript-first ORM that stays close to SQL: you describe tables in TypeScript and write queries with a SQL-like fluent API. It is lightweight (~7.4kb minified+gzipped), tree-shakeable, and ships with zero dependencies, making it well suited to serverless and edge runtimes (Bun, Deno, Cloudflare Workers). Read this when you want type safety without a heavy abstraction layer over SQL.
+
+## Official sources
+- Docs: https://orm.drizzle.team/docs/overview
+- Repo: https://github.com/drizzle-team/drizzle-orm
+- Install / get started: https://orm.drizzle.team/docs/get-started
+
+## Install / setup
+```bash
+npm i drizzle-orm pg
+npm i -D drizzle-kit @types/pg
+```
+
+## Core concepts
+- **Schema in TypeScript**: tables/columns are declared with helpers like `pgTable`, giving full inference for queries.
+- **Two query styles**: a SQL-like query builder (`select().from()...`) and a relational queries API for ergonomic nested reads.
+- **drizzle-kit**: the companion CLI for generating and applying migrations from your TS schema.
+- **Driver-agnostic**: connect via the appropriate driver (node-postgres, postgres.js, MySQL, SQLite/libSQL, etc.).
+- **Headless / no codegen runtime**: types come from your schema declarations, not a generated client.
+
+## Best practices
+- Define schema in dedicated files and import them where queries run so types stay inferred end to end.
+- Use `drizzle-kit generate` to produce migration SQL and apply it with `drizzle-kit migrate` (per Drizzle docs) rather than hand-editing tables.
+- Pick the query API to match the task: the query builder for explicit SQL, relational queries for nested fetches.
+- Pin and review generated migrations in version control before applying to production.
+
+## Common pitfalls
+- Expecting Prisma-style automatic client generation → Drizzle is headless; types derive from your schema declarations, so keep schema imports accurate.
+- Mixing incompatible driver and dialect (e.g. a `pg` driver with a MySQL schema) → choose the driver/dialect pair the docs specify for your database.
+
+## Examples
+```ts
+import { drizzle } from 'drizzle-orm/node-postgres'
+import { pgTable, serial, text } from 'drizzle-orm/pg-core'
+import { eq } from 'drizzle-orm'
+
+export const users = pgTable('users', {
+  id: serial('id').primaryKey(),
+  name: text('name'),
+})
+
+const db = drizzle(process.env.DATABASE_URL!)
+const ada = await db.select().from(users).where(eq(users.name, 'Ada'))
+```
+
+## Further reading
+- https://orm.drizzle.team/docs/migrations — migrations with drizzle-kit
+- https://orm.drizzle.team/docs/rqb — relational queries API
+
+## Related skills
+- ../prisma — schema-DSL ORM with codegen alternative
+- ../knex — lower-level SQL query builder

package/skills/stacks/orm/gorm/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: gorm
+description: The fantastic, developer-friendly ORM for Go with associations, hooks, transactions, and auto-migration; consult for relational data access in Go.
+domain: stack
+category: orm
+tags: [orm, go, golang, database, migrations, associations]
+official_sources:
+  - https://gorm.io/docs/
+  - https://github.com/go-gorm/gorm
+verified: 2026-06-16
+---
+
+# GORM
+
+## Overview
+GORM is the de-facto ORM library for Go, aiming to be developer-friendly. It maps Go structs to tables and provides associations, hooks, transactions, eager loading, and auto-migration, with driver support for PostgreSQL, MySQL, SQLite, SQL Server, and others. Read this when building Go services that need a full-featured ORM rather than hand-written SQL.
+
+## Official sources
+- Docs: https://gorm.io/docs/
+- Repo: https://github.com/go-gorm/gorm
+- Install / index: https://gorm.io/docs/index.html
+
+## Install / setup
+```bash
+go get -u gorm.io/gorm
+go get -u gorm.io/driver/sqlite
+```
+
+## Core concepts
+- **Models**: plain Go structs whose fields map to columns; embed `gorm.Model` for ID/timestamps/soft-delete.
+- **`*gorm.DB`**: the database handle opened with `gorm.Open(driver, &gorm.Config{})`; carries chainable method calls.
+- **CRUD chain methods**: `Create`, `First`/`Find`, `Where`, `Update`, `Delete` build and run queries.
+- **Associations**: `Has One`, `Has Many`, `Belongs To`, `Many To Many` with `Preload` for eager loading.
+- **AutoMigrate**: creates/updates tables to match struct definitions.
+- **Hooks & transactions**: lifecycle callbacks (`BeforeCreate` etc.) and `db.Transaction(func...)` for atomic work.
+
+## Best practices
+- Open the database once and reuse the shared `*gorm.DB`; it manages an underlying connection pool.
+- Use `Preload` (or joins) to load associations and avoid N+1 queries (per docs).
+- Treat `AutoMigrate` as convenient for development; review schema changes carefully before relying on it in production (it only adds, it will not delete columns).
+- Always check the returned `error` (and `RowsAffected`) on query chains.
+
+## Common pitfalls
+- Ignoring the `.Error` field on a chained call → silent failures; inspect `result.Error` after each operation.
+- Expecting `AutoMigrate` to drop or rename columns → it does not remove columns; use explicit migrations for destructive changes.
+
+## Examples
+```go
+import (
+  "gorm.io/gorm"
+  "gorm.io/driver/sqlite"
+)
+
+type User struct {
+  gorm.Model
+  Name string
+}
+
+db, _ := gorm.Open(sqlite.Open("app.db"), &gorm.Config{})
+db.AutoMigrate(&User{})
+db.Create(&User{Name: "Ada"})
+
+var u User
+db.Where("name = ?", "Ada").First(&u)
+```
+
+## Further reading
+- https://gorm.io/docs/models.html — declaring models
+- https://gorm.io/docs/preload.html — preloading associations
+
+## Related skills
+- ../diesel — Rust's type-safe ORM (contrast: another typed-language ORM)
+- ../prisma — type-safe ORM in the TS ecosystem

package/skills/stacks/orm/knex/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: knex
+description: Flexible multi-dialect SQL query builder for Node.js with transactions, pooling, and migrations; consult when you want SQL control without a full ORM.
+domain: stack
+category: orm
+tags: [query-builder, nodejs, sql, migrations, transactions, postgresql]
+official_sources:
+  - https://knexjs.org/
+  - https://github.com/knex/knex
+verified: 2026-06-16
+---
+
+# Knex.js
+
+## Overview
+Knex is a batteries-included, multi-dialect SQL query builder for Node.js supporting PostgreSQL, MySQL/MariaDB, SQLite3, MSSQL, CockroachDB, and Oracle. It builds SQL with a fluent, chainable API and adds transactions, connection pooling, streaming, and a migration/seed system. Read this when you want fine SQL control and portability without the abstraction of a full ORM.
+
+## Official sources
+- Docs: https://knexjs.org/
+- Repo: https://github.com/knex/knex
+- Install / guide: https://knexjs.org/guide/#node-js
+
+## Install / setup
+```bash
+npm install knex --save
+npm install pg
+```
+
+## Core concepts
+- **Knex instance**: configured with a `client` (dialect) and `connection`; created once and reused.
+- **Query builder**: chainable methods (`select`, `where`, `join`, `insert`, `update`, `del`) that compile to SQL.
+- **Schema builder**: `knex.schema.createTable(...)` for DDL.
+- **Migrations & seeds**: versioned schema changes and seed data run via the Knex CLI.
+- **Transactions**: `knex.transaction(async trx => …)` for atomic multi-statement work.
+- **Connection pooling**: built-in pool managed per Knex instance.
+
+## Best practices
+- Install only the driver for your database (e.g. `pg`, `mysql2`, `sqlite3`) as the install guide instructs.
+- Create a single Knex instance and share it; each instance owns a connection pool.
+- Use migrations for all schema changes and commit them to version control.
+- Use parameterized builder methods (not string concatenation) to avoid SQL injection; use `knex.raw` with bindings when raw SQL is needed.
+
+## Common pitfalls
+- Creating multiple Knex instances → multiple pools that can exhaust database connections; reuse one instance.
+- Interpolating user input into `knex.raw` strings → SQL injection; pass values as bindings (`?`) instead.
+
+## Examples
+```js
+const knex = require('knex')({
+  client: 'pg',
+  connection: process.env.DATABASE_URL,
+})
+
+await knex('users').insert({ name: 'Ada' })
+const users = await knex('users').where({ name: 'Ada' }).select('*')
+```
+
+## Further reading
+- https://knexjs.org/guide/migrations.html — migrations
+- https://knexjs.org/guide/query-builder.html — query builder reference
+
+## Related skills
+- ../drizzle — TS-first SQL ORM that also stays close to SQL
+- ../sequelize — full ORM built atop query-builder concepts