constella 0.1.0

package/skills/stacks/baas/firebase/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: firebase
+description: Firebase is Google's Backend-as-a-Service platform (Auth, Firestore, Realtime Database, Cloud Functions, Hosting, Cloud Storage, FCM). Consult when building serverless app backends, adding Google/email auth, syncing NoSQL data in real time, deploying static/SSR hosting, writing Cloud Functions, or using the Firebase CLI/emulator suite.
+domain: stack
+category: baas
+tags: [firebase, baas, google, firestore, auth, serverless, cloud-functions]
+official_sources:
+  - https://firebase.google.com/docs
+  - https://github.com/firebase/firebase-tools
+  - https://www.npmjs.com/package/firebase-tools
+verified: 2026-06-17
+---
+
+# Firebase
+
+## Overview
+Firebase is Google's Backend-as-a-Service platform that bundles authentication, NoSQL databases (Cloud Firestore and the older Realtime Database), serverless Cloud Functions, static/SSR Hosting, Cloud Storage, and messaging behind client SDKs and a single CLI. It removes the need to run your own backend for most app features. Read this when adding auth, real-time data sync, file storage, push notifications, or deploying functions/hosting from the Firebase CLI.
+
+## Official sources
+- Docs: https://firebase.google.com/docs
+- Repo: https://github.com/firebase/firebase-tools
+- Install: https://www.npmjs.com/package/firebase-tools
+
+## Install / setup
+```bash
+npm install -g firebase-tools
+firebase login
+firebase init
+```
+Source: https://firebase.google.com/docs/cli
+
+## Core concepts
+- **Project** — top-level container; one project holds all Firebase products and maps to a Google Cloud project.
+- **Cloud Firestore** — scalable document/collection NoSQL DB with real-time listeners and offline cache; preferred over Realtime Database for new apps.
+- **Authentication** — managed identity (email/password, Google, Apple, phone, anonymous, OIDC/SAML) issuing ID tokens verified by Security Rules.
+- **Security Rules** — declarative server-side access control evaluated per request for Firestore, Storage, and Realtime Database.
+- **Cloud Functions** — serverless Node/Python handlers triggered by HTTPS, Firestore/Auth events, schedules, or Pub/Sub.
+- **Hosting** — global CDN for static assets and SSR frameworks (Next.js/Angular), wired to functions via rewrites.
+- **Emulator Suite** — local emulators for Auth, Firestore, Functions, Hosting for offline development and CI.
+
+## Best practices
+- Write and test Security Rules first; never rely on client-side checks alone (https://firebase.google.com/docs/rules).
+- Develop against the Emulator Suite before touching production data (https://firebase.google.com/docs/emulator-suite).
+- Model Firestore data for your queries — denormalize and avoid unbounded collection scans (https://firebase.google.com/docs/firestore/data-model).
+- Keep API keys/config public but lock data with Rules and App Check (https://firebase.google.com/docs/app-check).
+
+## Common pitfalls
+- Default-open or test-mode Security Rules left in production → leaked/writable data; deploy least-privilege rules before launch.
+- Missing composite indexes for compound queries → query fails at runtime; create the suggested index from the error link.
+- Per-document write contention on hot Firestore documents → throttling; shard counters or distribute writes.
+
+## Examples
+```javascript
+import { initializeApp } from "firebase/app";
+import { getFirestore, collection, addDoc } from "firebase/firestore";
+
+const app = initializeApp({ projectId: "demo", apiKey: "..." });
+const db = getFirestore(app);
+
+await addDoc(collection(db, "messages"), {
+  text: "hello",
+  createdAt: Date.now(),
+});
+```
+
+## Further reading
+- https://firebase.google.com/docs/firestore — Cloud Firestore guide
+- https://firebase.google.com/docs/functions — Cloud Functions reference
+- https://firebase.google.com/docs/cli — Firebase CLI reference
+
+## Related skills
+- ../appwrite — open-source self-hosted BaaS alternative
+- ../amplify — AWS fullstack BaaS with similar auth/data/functions

package/skills/stacks/baas/heroku/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: heroku
+description: Heroku is a Git-push Platform-as-a-Service for deploying and running apps (Node, Python, Ruby, Java, Go, PHP) with managed add-ons like Postgres and Redis. Consult when deploying an app via git push, configuring buildpacks/Procfile/dynos, setting config vars, scaling processes, provisioning Postgres/Redis add-ons, or using the Heroku CLI.
+domain: stack
+category: baas
+tags: [heroku, paas, deployment, dynos, buildpacks, postgres, git]
+official_sources:
+  - https://devcenter.heroku.com/
+  - https://github.com/heroku/cli
+  - https://devcenter.heroku.com/articles/heroku-cli
+verified: 2026-06-17
+---
+
+# Heroku
+
+## Overview
+Heroku is a managed Platform-as-a-Service that runs your application code on isolated containers called dynos, deployed by pushing to a Git remote. It detects your language via buildpacks, runs processes declared in a `Procfile`, and offers a marketplace of add-ons (Heroku Postgres, Redis, etc.) so you avoid managing servers. Read this when deploying via `git push heroku`, defining dynos/process types, managing config vars and add-ons, or scaling with the Heroku CLI.
+
+## Official sources
+- Docs: https://devcenter.heroku.com/
+- Repo: https://github.com/heroku/cli
+- Install: https://devcenter.heroku.com/articles/heroku-cli
+
+## Install / setup
+```bash
+heroku login
+heroku create
+git push heroku main
+```
+Source: https://devcenter.heroku.com/articles/getting-started-with-nodejs (install CLI via https://devcenter.heroku.com/articles/heroku-cli)
+
+## Core concepts
+- **Dyno** — lightweight isolated container running one process type; scaled horizontally/vertically by dyno type.
+- **Buildpack** — language-specific scripts that detect and compile your app into a runnable slug.
+- **Procfile** — root-level file declaring process types (`web:`, `worker:`) and their start commands.
+- **Config vars** — environment variables set with `heroku config:set`, the standard place for secrets/settings.
+- **Add-ons** — managed services (Heroku Postgres, Heroku Redis, etc.) attached and exposed via config vars.
+- **Release** — immutable deploy unit (slug + config); rolled back with `heroku rollback`.
+- **Stack** — the base OS/runtime image (e.g. `heroku-24`) your dynos run on.
+
+## Best practices
+- Store all configuration and secrets in config vars, never in the repo (https://devcenter.heroku.com/articles/config-vars).
+- Build stateless processes following the Twelve-Factor App methodology (https://12factor.net).
+- Run DB migrations in a `release` Procfile phase, not at boot (https://devcenter.heroku.com/articles/release-phase).
+- Provision Heroku Postgres as an add-on instead of an ephemeral local DB (https://devcenter.heroku.com/articles/heroku-postgresql).
+
+## Common pitfalls
+- Writing to the dyno's local filesystem → data lost on restart/deploy (ephemeral); use Postgres/S3 add-ons instead.
+- Web process not binding to `$PORT` → boot timeout / R10 error; bind your server to `process.env.PORT`.
+- Free/Eco dynos sleeping or missing a `web` process type → app returns errors; ensure a valid `Procfile`.
+
+## Examples
+```procfile
+web: node index.js
+worker: node worker.js
+release: node ./scripts/migrate.js
+```
+```bash
+heroku config:set NODE_ENV=production
+heroku addons:create heroku-postgresql:essential-0
+heroku ps:scale web=2
+```
+
+## Further reading
+- https://devcenter.heroku.com/categories/deployment — deployment methods and Git workflow
+- https://devcenter.heroku.com/articles/dynos — dyno types, scaling, and lifecycle
+- https://devcenter.heroku.com/articles/procfile — Procfile and process types reference
+
+## Related skills
+- ../firebase — BaaS with managed hosting and functions
+- ../amplify — AWS fullstack hosting + backend platform

package/skills/stacks/backend/actix/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: actix
+description: Powerful, fast Rust web framework (actix-web) on Tokio with HTTP/1 and HTTP/2, routing, and middleware; consult when building Rust HTTP services.
+domain: stack
+category: backend
+tags: [rust, actix-web, tokio, http, web-framework]
+official_sources:
+  - https://actix.rs/docs/
+  - https://github.com/actix/actix-web
+verified: 2026-06-16
+---
+
+# Actix Web
+
+## Overview
+actix-web is a powerful, pragmatic, and extremely fast web framework for Rust. It supports HTTP/1.x and HTTP/2, streaming and pipelining, powerful request routing with optional macros, and comprehensive middleware. Built on Tokio and running on stable Rust, it ranks among the fastest web frameworks in TechEmpower benchmarks. Read this when building Rust HTTP APIs and services.
+
+## Official sources
+- Docs: https://actix.rs/docs/
+- Repo: https://github.com/actix/actix-web
+- Install / download: https://actix.rs/docs/getting-started/
+
+## Install / setup
+```bash
+cargo new hello-world
+cd hello-world
+```
+```toml
+# Cargo.toml — add the dependency (requires a recent stable Rust)
+[dependencies]
+actix-web = "4"
+```
+
+## Core concepts
+- App & HttpServer: an `App` registers routes and shared state; `HttpServer` binds an address and runs the app, often across multiple worker threads.
+- Handlers (extractors): async functions whose typed arguments (path, query, JSON, state) are extracted from the request automatically.
+- Routing: route macros (`#[get("/path")]`) or builder methods (`.route(...)`, `.service(...)`) map paths and methods to handlers.
+- Application state: shared data wrapped in `web::Data<T>` injected into handlers; it must be thread-safe.
+- Middleware: wraps handlers for cross-cutting concerns (logging, auth, compression) via the `wrap` API.
+- Responders: handler return types implementing `Responder` are converted into HTTP responses.
+
+## Best practices
+- Pin `actix-web = "4"` and use a recent stable Rust toolchain as the docs require (https://actix.rs/docs/getting-started/).
+- Share state with `web::Data` instead of globals so it is cleanly injected and thread-safe.
+- Use typed extractors (Json, Path, Query) so deserialization and validation happen at the boundary.
+- Add the Logger middleware and structured error handling rather than panicking in handlers.
+
+## Common pitfalls
+- Doing blocking work directly in an async handler → blocks the worker; offload with `web::block` or an async client.
+- Expecting non-Send state to be shared across workers → `App` state must be thread-safe; wrap shared data in `web::Data`.
+- Confusing the actor framework `actix` with the web framework `actix-web` → for web servers depend on `actix-web`.
+
+## Examples
+```rust
+use actix_web::{get, App, HttpServer, Responder};
+
+#[get("/")]
+async fn hello() -> impl Responder {
+    "Hello, World!"
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    HttpServer::new(|| App::new().service(hello))
+        .bind(("127.0.0.1", 8080))?
+        .run()
+        .await
+}
+```
+
+## Further reading
+- https://actix.rs/docs/getting-started/ — Getting started
+- https://actix.rs/docs/extractors/ — Type-safe extractors
+
+## Related skills
+- ../gin — comparable high-performance framework in Go
+- ../aspnet-core — cross-platform compiled-language web framework (.NET)

package/skills/stacks/backend/adonisjs/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: adonisjs
+description: TypeScript-first full-stack Node MVC framework with testing, ORM, and official packages; consult when building AdonisJS web apps or API servers.
+domain: stack
+category: backend
+tags: [nodejs, typescript, adonisjs, mvc, web-framework]
+official_sources:
+  - https://docs.adonisjs.com/
+  - https://github.com/adonisjs/core
+verified: 2026-06-16
+---
+
+# AdonisJS
+
+## Overview
+AdonisJS is a TypeScript-first web framework for building web apps and API servers on Node.js. It ships a full-stack MVC structure with testing support, modern tooling, and an ecosystem of official packages, emphasizing ergonomics and speed. Read this when building or maintaining an AdonisJS backend.
+
+## Official sources
+- Docs: https://docs.adonisjs.com/
+- Repo: https://github.com/adonisjs/core
+- Install / download: https://docs.adonisjs.com/guides/getting-started/installation
+
+## Install / setup
+```bash
+# Requires Node.js >= 24.x and npm >= 11.x
+npm init adonisjs@latest [project-name]
+```
+
+## Core concepts
+- IoC container & providers: services are registered via providers and resolved from a dependency-injection container.
+- Routing & controllers: routes in `start/routes.ts` map URLs to controller methods; route groups apply shared prefixes and middleware.
+- Middleware: composable request handlers run before route handlers for cross-cutting concerns (auth, body parsing).
+- Lucid ORM: the official Active Record-style ORM with models, migrations, and query building.
+- HttpContext: the per-request object (`ctx`) exposing request, response, and session passed to controllers.
+- Config & environment: typed configuration and validated environment variables via the framework's config system.
+
+## Best practices
+- Use the official starter and ecosystem packages (auth, Lucid, validation) rather than ad-hoc libraries, since they integrate with the IoC container (https://docs.adonisjs.com/guides/getting-started/installation).
+- Keep controllers thin and move logic into services resolved from the container.
+- Use Lucid migrations for schema changes so databases stay reproducible.
+- Validate request input with the built-in validator before using it.
+
+## Common pitfalls
+- Running on an unsupported Node version → the installer requires Node.js >= 24.x and npm >= 11.x; upgrade before installing.
+- Bypassing the IoC container by instantiating services manually → register and resolve them so dependencies and lifecycles are managed.
+- Skipping input validation → validate with the framework's validator instead of trusting raw request data.
+
+## Examples
+```ts
+// start/routes.ts
+import router from '@adonisjs/core/services/router'
+
+router.get('/users/:id', async ({ params }) => {
+  return { id: params.id }
+})
+```
+
+## Further reading
+- https://docs.adonisjs.com/guides/getting-started/installation — Installation
+- https://docs.adonisjs.com/guides/basics/routing — Routing
+- https://lucid.adonisjs.com/ — Lucid ORM
+
+## Related skills
+- ../laravel — the PHP framework AdonisJS's conventions are often compared to
+- ../fiber — Express-lineage framework in Go

package/skills/stacks/backend/aspnet-core/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: aspnet-core
+description: Cross-platform, open-source .NET web framework for cloud apps, web APIs, and Blazor; consult when building or maintaining ASP.NET Core backends.
+domain: stack
+category: backend
+tags: [dotnet, csharp, aspnet-core, web-api, web-framework]
+official_sources:
+  - https://learn.microsoft.com/aspnet/core/
+  - https://github.com/dotnet/aspnetcore
+verified: 2026-06-16
+---
+
+# ASP.NET Core
+
+## Overview
+ASP.NET Core is a cross-platform, open-source .NET framework for building modern cloud-based web applications on Windows, macOS, or Linux. It supports web apps, REST/Minimal APIs, gRPC, real-time apps with SignalR, and the Blazor frontend model. Read this when building .NET HTTP services or web apps. Requires the .NET SDK.
+
+## Official sources
+- Docs: https://learn.microsoft.com/aspnet/core/
+- Repo: https://github.com/dotnet/aspnetcore
+- Install / download: https://learn.microsoft.com/aspnet/core/getting-started (SDK: https://dotnet.microsoft.com/download/dotnet)
+
+## Install / setup
+```bash
+# Install the latest .NET SDK first (https://dotnet.microsoft.com/download/dotnet)
+
+# Create a Blazor Web App
+dotnet new blazor -o BlazorSample
+cd BlazorSample
+
+# Run with hot reload
+dotnet watch
+```
+```bash
+# Or create a Razor Pages web app
+dotnet new webapp -o RazorPagesSample
+```
+
+## Core concepts
+- Host & startup: `WebApplication.CreateBuilder` configures services and the request pipeline; `app.Run()` starts the server.
+- Middleware pipeline: ordered components process each request/response (routing, auth, static files); order matters.
+- Dependency injection: a built-in DI container registers services with lifetimes (singleton, scoped, transient) consumed via constructor injection.
+- Routing & endpoints: Minimal APIs, controllers, and Razor Pages map URLs to handlers via endpoint routing.
+- Configuration & options: layered configuration (appsettings.json, env vars, user secrets) bound to strongly typed options.
+- Blazor & Razor: component-based UI (Blazor) and the Razor syntax mixing HTML with C# for server-rendered pages.
+
+## Best practices
+- Use `dotnet watch` during development for hot reload of markup and code (https://learn.microsoft.com/aspnet/core/getting-started).
+- Register dependencies in the DI container and inject them rather than constructing them manually.
+- Order middleware deliberately; place routing, authentication, and authorization in the documented sequence.
+- Use the configuration/options system and user secrets for settings instead of hardcoding values.
+
+## Common pitfalls
+- Misordering middleware (e.g. authorization before routing) → requests bypass or mishandle auth; follow the documented pipeline order.
+- Choosing the wrong project template → `dotnet new blazor` scaffolds Blazor, `dotnet new webapp` scaffolds Razor Pages; pick what matches your app.
+- Storing secrets in appsettings.json committed to source control → use user secrets in development and a secret store in production.
+
+## Examples
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+var app = builder.Build();
+
+app.MapGet("/ping", () => "pong");
+
+app.Run();
+```
+
+## Further reading
+- https://learn.microsoft.com/aspnet/core/getting-started — Get started
+- https://learn.microsoft.com/aspnet/core/tutorials/min-web-api — Minimal API tutorial
+- https://learn.microsoft.com/aspnet/core/fundamentals/ — Fundamentals (DI, middleware, configuration)
+
+## Related skills
+- ../actix — high-performance compiled-language web framework (Rust)
+- ../laravel — full-stack web framework alternative (PHP)

package/skills/stacks/backend/codeigniter/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: codeigniter
+description: CodeIgniter 4 — a small, fast PHP MVC framework for building web apps and APIs with minimal configuration. Consult when scaffolding a CodeIgniter 4 app starter, defining routes and controllers, using the Query Builder or models, building RESTful resources, or running the spark CLI and server.
+domain: stack
+category: backend
+tags: [codeigniter, php, mvc, composer, rest, query-builder, backend]
+official_sources:
+  - https://codeigniter.com/user_guide/
+  - https://github.com/codeigniter4/CodeIgniter4
+  - https://codeigniter.com/user_guide/installation/installing_composer.html
+verified: 2026-06-17
+---
+
+# CodeIgniter
+
+## Overview
+CodeIgniter 4 is a lightweight PHP MVC framework prized for a small footprint, fast performance, and near-zero configuration. It provides routing, controllers, models with a fluent Query Builder, validation, and the `spark` CLI without imposing heavy conventions. Read this when building a small-to-mid PHP app or API where you want explicit control and minimal boilerplate.
+
+## Official sources
+- Docs: https://codeigniter.com/user_guide/
+- Repo: https://github.com/codeigniter4/CodeIgniter4
+- Install: https://codeigniter.com/user_guide/installation/installing_composer.html
+
+## Install / setup
+```bash
+composer create-project codeigniter4/appstarter project-root
+cd project-root && php spark serve
+```
+Source: https://codeigniter.com/user_guide/installation/installing_composer.html (creates `project-root` with the latest framework as a dependency; `spark serve` starts the dev server on :8080).
+
+## Core concepts
+- **MVC structure** — `app/Controllers`, `app/Models`, `app/Views` hold the application code.
+- **Routing** — `app/Config/Routes.php` maps URLs to controller methods; auto-routing is opt-in.
+- **Controllers** — extend `BaseController`; return strings, views, or responses.
+- **Models & Entities** — extend `CodeIgniter\Model` for CRUD, validation, and result hydration.
+- **Query Builder** — chainable, DB-agnostic query API via `$this->db->table(...)`.
+- **spark CLI** — `php spark` runs migrations, generators, the dev server, and custom commands.
+- **Filters** — request/response middleware (auth, CSRF, CORS) configured in `Config\Filters`.
+- **Environment config** — `.env` plus `app/Config/*` classes; set `CI_ENVIRONMENT`.
+
+## Best practices
+- Disable auto-routing and define explicit routes for security (https://codeigniter.com/user_guide/incoming/routing.html).
+- Use `ResourceController`/`ResourcePresenter` for RESTful endpoints (https://codeigniter.com/user_guide/incoming/restful.html).
+- Configure the database and base URL via `.env`, keep it out of version control (https://codeigniter.com/user_guide/general/configuration.html).
+- Use the Model layer and validation rather than raw queries for user input (https://codeigniter.com/user_guide/models/model.html).
+
+## Common pitfalls
+- Leaving auto-routing (legacy) enabled exposes unintended methods → set routing to defined routes only.
+- Wrong `baseURL` in `app/Config/App.php`/`.env` breaks asset and redirect URLs → set it correctly per environment.
+- Forgetting `CI_ENVIRONMENT=production` leaves verbose error output on → set it for prod.
+
+## Examples
+```php
+namespace App\Controllers;
+
+use CodeIgniter\RESTful\ResourceController;
+
+class Users extends ResourceController
+{
+    protected $modelName = \App\Models\UserModel::class;
+    protected $format = 'json';
+
+    public function show($id = null)
+    {
+        return $this->respond($this->model->find($id));
+    }
+}
+```
+
+## Further reading
+- https://codeigniter.com/user_guide/intro/index.html — framework overview and welcome
+- https://codeigniter.com/user_guide/database/query_builder.html — Query Builder reference
+
+## Related skills
+- ../symfony — heavier, component-based PHP framework
+- ../nginx — front CodeIgniter with Nginx + PHP-FPM

package/skills/stacks/backend/django/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: django
+description: Full-featured, batteries-included Python web framework with ORM, admin, and auth; consult for rapid, secure server-rendered apps and APIs.
+domain: stack
+category: backend
+tags: [django, python, orm, mvc, web-framework, backend]
+official_sources:
+  - https://docs.djangoproject.com/en/stable/
+  - https://github.com/django/django
+verified: 2026-06-16
+---
+
+# Django
+
+## Overview
+Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design — "the web framework for perfectionists with deadlines." It ships batteries-included: an ORM, automatic admin site, authentication, forms, templating, and security defaults. Read this when building data-driven Python web apps or APIs where you want strong conventions and built-in tooling.
+
+## Official sources
+- Docs: https://docs.djangoproject.com/en/stable/
+- Repo: https://github.com/django/django
+- Install: https://docs.djangoproject.com/en/stable/topics/install/
+
+## Install / setup
+```bash
+python -m pip install Django
+```
+On Windows the docs show `py -m pip install Django`. (Source: https://docs.djangoproject.com/en/stable/topics/install/)
+
+## Core concepts
+- **Projects vs apps** — a project is the deployable site; apps are reusable, focused components registered in `INSTALLED_APPS`.
+- **MTV pattern** — Django's take on MVC: Models (data), Templates (presentation), Views (request handling).
+- **ORM & migrations** — models map to DB tables; `makemigrations` / `migrate` evolve the schema.
+- **URLconf & views** — `urls.py` routes paths to view functions/classes that return `HttpResponse`.
+- **Admin site** — an auto-generated CRUD interface for registered models.
+- **Settings & middleware** — central `settings.py` config plus a middleware stack for cross-cutting request/response processing.
+
+## Best practices
+- Run `makemigrations` and `migrate` to manage schema changes; never edit the database schema out of band (https://docs.djangoproject.com/en/stable/topics/migrations/).
+- Keep secrets and environment-specific values out of source; review the deployment checklist before going live (https://docs.djangoproject.com/en/stable/howto/deployment/checklist/).
+- Use the ORM's `select_related` / `prefetch_related` to avoid N+1 queries (https://docs.djangoproject.com/en/stable/topics/db/optimization/).
+- Rely on built-in protections (CSRF, XSS escaping, SQL parameterization) rather than rolling your own (https://docs.djangoproject.com/en/stable/topics/security/).
+
+## Common pitfalls
+- Running with `DEBUG = True` in production → leaks tracebacks and settings; set `DEBUG = False` and configure `ALLOWED_HOSTS` (https://docs.djangoproject.com/en/stable/ref/settings/#debug).
+- Triggering N+1 queries by iterating querysets that lazily hit related objects → use `select_related`/`prefetch_related` to batch the joins.
+
+## Examples
+```python
+# views.py
+from django.http import HttpResponse
+
+def index(request):
+    return HttpResponse("Hello, world.")
+```
+
+## Further reading
+- https://docs.djangoproject.com/en/stable/intro/tutorial01/ — official tutorial
+- https://docs.djangoproject.com/en/stable/howto/deployment/checklist/ — deployment checklist
+
+## Related skills
+- ../flask — lighter-weight Python alternative
+- ../fastapi — async, typed Python API framework

package/skills/stacks/backend/express/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: express
+description: Minimal, unopinionated, ubiquitous Node.js web framework with middleware and routing; consult for lightweight HTTP servers and APIs.
+domain: stack
+category: backend
+tags: [express, nodejs, http, middleware, routing, backend]
+official_sources:
+  - https://expressjs.com/
+  - https://github.com/expressjs/express
+verified: 2026-06-16
+---
+
+# Express
+
+## Overview
+Express is a fast, unopinionated, minimalist web framework for Node.js. It provides a thin layer of routing and middleware over Node's HTTP server, leaving structure and architecture to the developer. Read this when you want a small, well-understood foundation for an HTTP server or API, or when working under a framework (like NestJS) that uses Express underneath.
+
+## Official sources
+- Docs: https://expressjs.com/
+- Repo: https://github.com/expressjs/express
+- Install: https://expressjs.com/en/starter/installing.html
+
+## Install / setup
+```bash
+npm install express
+```
+The starter guide first creates a project with `mkdir myapp`, `cd myapp`, then `npm init`. (Source: https://expressjs.com/en/starter/installing.html)
+
+## Core concepts
+- **Application** — `express()` creates an app you configure with routes, middleware, and settings.
+- **Middleware** — functions with the `(req, res, next)` signature that run in order; the backbone of Express (parsing, auth, logging).
+- **Routing** — `app.get()`, `app.post()`, and `express.Router()` map HTTP methods + paths to handlers.
+- **Request / Response** — `req` and `res` objects expose params, query, body, and response helpers (`res.json`, `res.status`, `res.send`).
+- **Error-handling middleware** — special middleware with four args `(err, req, res, next)` catches errors.
+
+## Best practices
+- Order middleware deliberately; body parsers and auth must run before the routes that depend on them (https://expressjs.com/en/guide/using-middleware.html).
+- Split routes into `express.Router()` modules for maintainability (https://expressjs.com/en/guide/routing.html).
+- Define a single error-handling middleware last to centralize failures (https://expressjs.com/en/guide/error-handling.html).
+- Follow the production best-practices guide (use a reverse proxy, set `NODE_ENV=production`, handle exceptions) (https://expressjs.com/en/advanced/best-practice-performance.html).
+
+## Common pitfalls
+- In Express 4, async handler rejections were not caught automatically; Express 5 now forwards rejected promises to the error handler, so verify which major version you target (https://expressjs.com/en/guide/migrating-5.html).
+- Express 5 changed path matching: bare `*` wildcards must be named (e.g. `/*splat`) and several legacy methods/signatures were removed (`app.del`, `res.send(body, status)`); review the migration guide before upgrading (https://expressjs.com/en/guide/migrating-5.html).
+
+## Examples
+```javascript
+const express = require('express');
+const app = express();
+
+app.get('/', (req, res) => {
+  res.send('Hello World');
+});
+
+app.listen(3000);
+```
+
+## Further reading
+- https://expressjs.com/en/guide/migrating-5.html — Express 4 → 5 migration
+- https://expressjs.com/en/advanced/best-practice-security.html — security best practices
+
+## Related skills
+- ../fastify — higher-performance alternative
+- ../koa — successor framework from the original Express team
+- ../nestjs — opinionated framework built on Express by default

package/skills/stacks/backend/fastapi/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: fastapi
+description: Modern async, type-hint-driven Python API framework with automatic validation and OpenAPI docs; consult for high-performance typed APIs.
+domain: stack
+category: backend
+tags: [fastapi, python, async, pydantic, openapi, backend]
+official_sources:
+  - https://fastapi.tiangolo.com/
+  - https://github.com/fastapi/fastapi
+verified: 2026-06-16
+---
+
+# FastAPI
+
+## Overview
+FastAPI is a modern, high-performance Python web framework for building APIs using standard Python type hints. Type annotations drive request parsing, validation (via Pydantic), and automatic interactive documentation (Swagger UI and ReDoc) generated from OpenAPI. Read this when building typed, async-capable APIs where automatic validation and docs save significant boilerplate.
+
+## Official sources
+- Docs: https://fastapi.tiangolo.com/
+- Repo: https://github.com/fastapi/fastapi
+- Install: https://fastapi.tiangolo.com/#installation
+
+## Install / setup
+```bash
+pip install "fastapi[standard]"
+```
+The docs note the quotes around `"fastapi[standard]"` are needed so the command works in all terminals. (Source: https://fastapi.tiangolo.com/#installation)
+
+## Core concepts
+- **Path operations** — decorators like `@app.get("/")` declare routes on a `FastAPI()` app.
+- **Type hints → validation** — function parameter and Pydantic model types define and validate request bodies, query/path params automatically.
+- **Pydantic models** — declare request/response schemas as Python classes; FastAPI validates and serializes against them.
+- **Dependency injection** — `Depends()` injects reusable dependencies (auth, DB sessions, params) into path operations.
+- **Async support** — define handlers as `async def` to use `await` for non-blocking I/O.
+- **Automatic docs** — OpenAPI schema plus Swagger UI (`/docs`) and ReDoc (`/redoc`) are generated from your types.
+
+## Best practices
+- Model request and response bodies with Pydantic so validation and serialization are declarative (https://fastapi.tiangolo.com/tutorial/body/).
+- Use `Depends()` for shared concerns (DB sessions, auth) instead of repeating logic in each endpoint (https://fastapi.tiangolo.com/tutorial/dependencies/).
+- Use `async def` for I/O-bound handlers, but keep blocking calls out of the event loop (run them in a threadpool) (https://fastapi.tiangolo.com/async/).
+- Set explicit `response_model` types to control and document output shapes (https://fastapi.tiangolo.com/tutorial/response-model/).
+
+## Common pitfalls
+- Running blocking/synchronous I/O directly inside an `async def` endpoint → blocks the event loop and kills concurrency; use `def` handlers (run in a threadpool) or async-native libraries (https://fastapi.tiangolo.com/async/).
+- Returning ORM/raw objects without a `response_model` → may leak fields or fail serialization; declare a Pydantic response model.
+
+## Examples
+```python
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/")
+async def read_root():
+    return {"Hello": "World"}
+```
+
+## Further reading
+- https://fastapi.tiangolo.com/tutorial/ — full tutorial
+- https://fastapi.tiangolo.com/deployment/ — deployment guide
+
+## Related skills
+- ../flask — lighter Python microframework
+- ../django — batteries-included Python framework