constellai 0.3.0

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

@@ -0,0 +1,70 @@
+---
+name: graphql
+description: GraphQL — a query language and server-side runtime for APIs where clients request exactly the fields they need from a strongly-typed schema. Consult when designing a schema (SDL), writing queries/mutations/subscriptions, building a resolver-based server (graphql-js, Apollo), avoiding over/under-fetching, or referencing the GraphQL specification.
+domain: stack
+category: backend
+tags: [graphql, api, schema, resolvers, query-language, graphql-js, backend]
+official_sources:
+  - https://graphql.org/learn/
+  - https://github.com/graphql/graphql-spec
+  - https://www.graphql-js.org/docs/getting-started/
+verified: 2026-06-17
+---
+
+# GraphQL
+
+## Overview
+GraphQL is an open-source query language for APIs plus a runtime that fulfills those queries against a typed schema. Clients ask for exactly the fields they need in one request, eliminating over- and under-fetching common to REST. It is transport- and database-agnostic — resolvers fetch data from any backend. Read this when designing a schema, writing resolvers, or choosing a GraphQL server.
+
+## Official sources
+- Docs: https://graphql.org/learn/
+- Repo: https://github.com/graphql/graphql-spec
+- Install: https://www.graphql-js.org/docs/getting-started/
+
+## Install / setup
+```bash
+# Reference JavaScript implementation:
+npm install graphql --save
+```
+Source: https://www.graphql-js.org/docs/getting-started/ (graphql-js is the official JS implementation: parser, type system, validator, executor).
+
+## Core concepts
+- **Schema (SDL)** — the typed contract; `type`, `Query`, `Mutation`, `Subscription` define the API surface.
+- **Types** — scalars, objects, enums, interfaces, unions, input types, and non-null/list modifiers.
+- **Operations** — queries (read), mutations (write), subscriptions (real-time streams).
+- **Resolvers** — functions that return the data for each field; the heart of execution.
+- **Fields & arguments** — clients select fields and pass typed arguments per field.
+- **Introspection** — the schema is self-describing; tools like GraphiQL query it.
+- **Single endpoint** — typically one POST endpoint (e.g. `/graphql`) for all operations.
+- **Fragments & variables** — reusable field sets and parameterized, cacheable queries.
+
+## Best practices
+- Design the schema around client/product needs, not your database tables (https://graphql.org/learn/schema/).
+- Solve N+1 resolver fan-out with batching/caching (DataLoader) (https://graphql.org/learn/best-practices/).
+- Use cursor-based (connections) pagination for lists (https://graphql.org/learn/pagination/).
+- Return structured `errors` and prefer nullable fields for partial failures (https://graphql.org/learn/best-practices/).
+
+## Common pitfalls
+- N+1 queries when a list resolver hits the DB per item → batch with DataLoader.
+- Unbounded query depth/complexity enables DoS → add depth/complexity limits and timeouts.
+- Exposing a single `/graphql` makes per-resource HTTP caching hard → use persisted queries / response caching.
+
+## Examples
+```javascript
+import { graphql, buildSchema } from 'graphql';
+
+const schema = buildSchema(`type Query { hello: String }`);
+const rootValue = { hello: () => 'Hello world!' };
+
+graphql({ schema, source: '{ hello }', rootValue })
+  .then((res) => console.log(res));
+// { data: { hello: 'Hello world!' } }
+```
+
+## Further reading
+- https://spec.graphql.org/ — the formal GraphQL specification versions
+- https://graphql.org/community/tools-and-libraries/ — servers and clients per language
+
+## Related skills
+- ../spring — expose a GraphQL API from a Spring backend (Spring for GraphQL)
+- ../nginx — reverse-proxy a GraphQL server behind Nginx

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

@@ -0,0 +1,64 @@
+---
+name: hono
+description: Tiny, ultrafast Web-Standards web framework that runs on Cloudflare Workers, Deno, Bun, Node.js and edge; consult for edge/multi-runtime APIs.
+domain: stack
+category: backend
+tags: [hono, edge, web-standards, cloudflare-workers, bun, deno, backend]
+official_sources:
+  - https://hono.dev/docs/
+  - https://github.com/honojs/hono
+verified: 2026-06-16
+---
+
+# Hono
+
+## Overview
+Hono is a small, simple, and ultrafast web framework built on Web Standards. The same code runs on any JavaScript runtime — Cloudflare Workers, Fastly Compute, Deno, Bun, Vercel, AWS Lambda, Lambda@Edge, and Node.js. Read this when targeting edge/serverless platforms or when you want one routing/middleware codebase portable across runtimes.
+
+## Official sources
+- Docs: https://hono.dev/docs/
+- Repo: https://github.com/honojs/hono
+- Getting started: https://hono.dev/docs/getting-started/basic
+
+## Install / setup
+```bash
+npm create hono@latest my-app
+```
+(Source: https://hono.dev/docs/getting-started/basic)
+
+## Core concepts
+- **App instance** — `new Hono()` creates the router/app; `.get()`, `.post()`, etc. register routes.
+- **Web Standards core** — built on the standard `Request`/`Response` and Fetch APIs, which is why it is runtime-portable.
+- **Context (`c`)** — handlers receive a `Context` exposing `c.req`, `c.json()`, `c.text()`, env bindings, and helpers.
+- **Middleware** — composable `async (c, next) => {}` functions; Hono ships built-in middleware (CORS, logger, JWT, etc.).
+- **Presets / adapters** — import paths/presets (`hono`, `hono/tiny`, `hono/quick`) and runtime adapters tailor the router and serving for each platform.
+- **RPC & typing** — routes can be typed end-to-end and shared with clients via the RPC feature.
+
+## Best practices
+- Pick the import preset that matches your workload (e.g. `hono/quick` for many cold starts) per the docs (https://hono.dev/docs/api/presets).
+- Use the official middleware (CORS, logger, secure headers) instead of hand-rolling cross-cutting concerns (https://hono.dev/docs/middleware/builtin/cors).
+- Use the runtime-specific starter template so the entrypoint and serving adapter match your target (https://hono.dev/docs/getting-started/basic).
+- Return `Response`-compatible values from handlers via `c.json` / `c.text` rather than mutating shared state.
+
+## Common pitfalls
+- Assuming Node-only APIs (e.g. `fs`, raw `http`) work everywhere → on Workers/Deno/edge only Web Standard APIs are available; keep handlers runtime-agnostic.
+- Forgetting a platform-specific entrypoint/adapter → each runtime has its own bootstrap (e.g. `@hono/node-server` for Node); follow the matching getting-started page (https://hono.dev/docs/getting-started/nodejs).
+
+## Examples
+```typescript
+import { Hono } from 'hono';
+
+const app = new Hono();
+
+app.get('/', (c) => c.text('Hello Hono!'));
+
+export default app;
+```
+
+## Further reading
+- https://hono.dev/docs/api/presets — choosing presets per runtime
+- https://hono.dev/docs/guides/rpc — typed RPC between server and client
+
+## Related skills
+- ../fastify — Node-focused performance framework
+- ../express — minimal Node framework with a similar middleware model

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

@@ -0,0 +1,63 @@
+---
+name: koa
+description: Expressive, minimal middleware framework for Node.js from the Express team, built on async/await; consult for lean, composable HTTP servers.
+domain: stack
+category: backend
+tags: [koa, nodejs, middleware, async-await, http, backend]
+official_sources:
+  - https://koajs.com/
+  - https://github.com/koajs/koa
+verified: 2026-06-16
+---
+
+# Koa
+
+## Overview
+Koa is an expressive HTTP middleware framework for Node.js, created by the team behind Express, designed to make web applications and APIs more enjoyable to write. It has a small core (no bundled middleware) and uses `async`/`await` with a cascading middleware model and a unified `ctx` object. Read this when you want a minimal, modern foundation and prefer composing middleware explicitly.
+
+## Official sources
+- Docs: https://koajs.com/
+- Repo: https://github.com/koajs/koa
+
+## Install / setup
+```bash
+npm i koa
+```
+Koa requires node v18.0.0 or higher for ES2015 and async function support. (Source: https://koajs.com/)
+
+## Core concepts
+- **Application** — `new Koa()` creates an app; `app.use()` adds middleware; `app.listen()` starts the server.
+- **Cascading middleware** — middleware are `async (ctx, next) => {}`; calling `await next()` runs downstream middleware, then control flows back upstream ("cascade").
+- **Context (`ctx`)** — a single object per request that wraps and delegates to `ctx.request` and `ctx.response` (e.g. `ctx.body`, `ctx.status`).
+- **Request / Response abstractions** — Koa's own objects sit on top of Node's, adding helpful accessors.
+- **No bundled middleware** — routing, body parsing, etc. come from separate packages (e.g. `@koa/router`, `koa-bodyparser`).
+
+## Best practices
+- Set the response with `ctx.body` / `ctx.status` rather than calling Node's `res` directly, so Koa handles serialization correctly (https://koajs.com/#response).
+- Use `try/catch` around `await next()` in an upstream middleware to centralize error handling (https://koajs.com/#error-handling).
+- Keep middleware focused and order them deliberately, since the cascade depends on registration order.
+- Add only the middleware packages you need (router, body parser, CORS) to keep the core minimal.
+
+## Common pitfalls
+- Forgetting to `await next()` (or returning before it) → downstream middleware never runs and the cascade breaks; always await the chain.
+- Treating Koa like Express (e.g. expecting built-in routing/body parsing or the `(req, res, next)` signature) → Koa uses `ctx` and bundles no middleware; install the equivalents explicitly.
+
+## Examples
+```javascript
+const Koa = require('koa');
+const app = new Koa();
+
+app.use(async (ctx) => {
+  ctx.body = 'Hello World';
+});
+
+app.listen(3000);
+```
+
+## Further reading
+- https://koajs.com/#error-handling — error handling patterns
+- https://github.com/koajs/koa/blob/master/docs/guide.md — official guide
+
+## Related skills
+- ../express — predecessor framework from the same team
+- ../fastify — higher-performance Node alternative

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

@@ -0,0 +1,73 @@
+---
+name: laravel
+description: Full-featured PHP web framework with Eloquent ORM, Blade, queues, and Artisan; consult when building or maintaining a Laravel backend.
+domain: stack
+category: backend
+tags: [php, laravel, mvc, eloquent, web-framework]
+official_sources:
+  - https://laravel.com/docs
+  - https://github.com/laravel/laravel
+verified: 2026-06-16
+---
+
+# Laravel
+
+## Overview
+Laravel is a PHP web application framework with expressive syntax that provides structure for full-stack apps and API backends. It bundles routing, dependency injection, the Eloquent ORM, queues, scheduled jobs, real-time broadcasting, and testing out of the box. Read this when scaffolding, routing, persisting data, or organizing a Laravel codebase.
+
+## Official sources
+- Docs: https://laravel.com/docs
+- Repo: https://github.com/laravel/laravel (application skeleton); framework at https://github.com/laravel/framework
+- Install / download: https://laravel.com/docs/installation
+
+## Install / setup
+```bash
+# Install the Laravel installer via Composer (requires PHP + Composer)
+composer global require laravel/installer
+
+# Create a new application
+laravel new example-app
+
+# Start dev server, queue worker, and Vite together
+cd example-app
+npm install && npm run build
+composer run dev
+```
+
+## Core concepts
+- Request lifecycle: requests enter through `public/index.php`, pass through middleware, are dispatched by the router, and return a response — understanding this order is key to debugging.
+- Routing & controllers: routes in `routes/web.php` and `routes/api.php` map URIs to closures or controllers; conventions make controller/file placement predictable.
+- Eloquent ORM: each model maps to a database table; relationships, migrations, and seeders manage schema and data.
+- Service container & facades: the container resolves dependencies via injection; facades provide a static-style interface to container-bound services.
+- Blade templates: Laravel's templating engine for full-stack rendering, with components and layouts.
+- Configuration via `.env`: environment-specific values live in `.env` (not committed); the `config/` directory holds documented options.
+
+## Best practices
+- Keep `.env` out of source control; each environment supplies its own credentials (https://laravel.com/docs/installation#environment-based-configuration).
+- Serve the app from the web root (the `public/` directory), never from a subdirectory, to avoid exposing sensitive files (https://laravel.com/docs/installation#directory-configuration).
+- Use migrations and seeders for schema/data so environments stay reproducible.
+- Use starter kits for authentication scaffolding rather than rolling your own (https://laravel.com/docs/starter-kits).
+
+## Common pitfalls
+- Committing `.env` or serving from a subdirectory → exposes credentials and source; keep `.env` ignored and serve from the public root.
+- Treating Laravel only as full-stack → it also works as an API backend with Sanctum auth; choose the path that matches your frontend.
+- Forgetting to run `php artisan migrate` after switching from the default SQLite to MySQL/PostgreSQL → create the database and run migrations.
+
+## Examples
+```php
+// routes/web.php
+use Illuminate\Support\Facades\Route;
+
+Route::get('/users/{id}', function (string $id) {
+    return \App\Models\User::findOrFail($id);
+});
+```
+
+## Further reading
+- https://laravel.com/docs/lifecycle — Request lifecycle
+- https://laravel.com/docs/eloquent — Eloquent ORM
+- https://laravel.com/docs/sanctum — API authentication
+
+## Related skills
+- ../rails — another convention-driven full-stack web framework
+- ../adonisjs — TypeScript framework with comparable full-stack ergonomics

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

@@ -0,0 +1,70 @@
+---
+name: nestjs
+description: Opinionated TypeScript backend framework with DI, modules, and decorators; consult when building structured Node server-side apps.
+domain: stack
+category: backend
+tags: [nestjs, nodejs, typescript, dependency-injection, backend]
+official_sources:
+  - https://docs.nestjs.com/
+  - https://github.com/nestjs/nest
+verified: 2026-06-16
+---
+
+# NestJS
+
+## Overview
+NestJS is a progressive Node.js framework for building efficient, scalable, enterprise-grade server-side applications with TypeScript. It layers an opinionated architecture (modules, providers, dependency injection, decorators) on top of an HTTP platform (Express by default, optionally Fastify). Read this when you need a structured, testable backend with first-class DI rather than wiring middleware by hand.
+
+## Official sources
+- Docs: https://docs.nestjs.com/
+- Repo: https://github.com/nestjs/nest
+- Install / first steps: https://docs.nestjs.com/first-steps
+
+## Install / setup
+```bash
+npm i -g @nestjs/cli
+nest new project-name
+```
+The CLI can also be run without a global install via `npx @nestjs/cli@latest`. Add `--strict` to `nest new` for TypeScript's stricter feature set. (Source: https://docs.nestjs.com/first-steps)
+
+## Core concepts
+- **Modules** — each app has a root module; modules group related providers and controllers and define the dependency boundary via `@Module({})`.
+- **Controllers** — handle incoming requests and return responses; routing is declared with decorators like `@Controller()` and `@Get()`.
+- **Providers / services** — injectable classes (`@Injectable()`) holding business logic, resolved by Nest's DI container.
+- **Dependency injection** — constructor-based injection wires providers together; the container manages instantiation and scope.
+- **Pipes, guards, interceptors, filters** — cross-cutting building blocks for validation/transformation, authorization, request/response wrapping, and exception handling.
+- **Platform-agnostic core** — the same code runs on `@nestjs/platform-express` or `@nestjs/platform-fastify`.
+
+## Best practices
+- Keep one feature per module and export only what other modules need, so the DI graph stays explicit (https://docs.nestjs.com/modules).
+- Use Pipes (e.g. the built-in `ValidationPipe` with class-validator) to validate and transform incoming payloads at the boundary (https://docs.nestjs.com/techniques/validation).
+- Centralize error handling with exception filters rather than try/catch in every controller (https://docs.nestjs.com/exception-filters).
+- Lean on the CLI (`nest generate`) to scaffold modules/controllers/services consistently.
+
+## Common pitfalls
+- Forgetting to register a provider in a module's `providers` (or import its module) → "Nest can't resolve dependencies" error; declare and export providers explicitly.
+- Treating default request-scoped vs singleton lifetimes interchangeably → request-scoped providers add per-request overhead; default to singleton scope unless you truly need per-request state (https://docs.nestjs.com/fundamentals/injection-scopes).
+
+## Examples
+```typescript
+import { Module, Controller, Get } from '@nestjs/common';
+
+@Controller('cats')
+export class CatsController {
+  @Get()
+  findAll(): string {
+    return 'This action returns all cats';
+  }
+}
+
+@Module({ controllers: [CatsController] })
+export class AppModule {}
+```
+
+## Further reading
+- https://docs.nestjs.com/fundamentals/custom-providers — advanced DI patterns
+- https://docs.nestjs.com/cli/overview — CLI reference
+
+## Related skills
+- ../express — the default underlying HTTP platform
+- ../fastify — alternative high-performance platform adapter

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

@@ -0,0 +1,77 @@
+---
+name: nginx
+description: Nginx — a high-performance HTTP server, reverse proxy, and load balancer for serving static files, terminating TLS, and proxying to app backends. Consult when writing nginx.conf, configuring server/location blocks, setting up reverse proxy (proxy_pass) or load balancing (upstream), serving static assets, enabling gzip/TLS, or installing from the official nginx.org repo.
+domain: stack
+category: backend
+tags: [nginx, web-server, reverse-proxy, load-balancer, http, tls, backend]
+official_sources:
+  - https://nginx.org/en/docs/
+  - https://github.com/nginx/nginx
+  - https://nginx.org/en/linux_packages.html
+verified: 2026-06-17
+---
+
+# Nginx
+
+## Overview
+Nginx is an event-driven HTTP server and reverse proxy known for high concurrency and low memory use. It serves static content, terminates TLS, load-balances across upstream app servers, and proxies dynamic requests (e.g. to PHP-FPM, Node, or a Spring app). Read this when authoring `nginx.conf`, defining server/location blocks, configuring reverse proxy or load balancing, or installing Nginx from the official repository.
+
+## Official sources
+- Docs: https://nginx.org/en/docs/
+- Repo: https://github.com/nginx/nginx
+- Install: https://nginx.org/en/linux_packages.html
+
+## Install / setup
+```bash
+# Ubuntu/Debian, from the official nginx.org repository (after adding the repo + key):
+sudo apt update && sudo apt install nginx
+```
+Source: https://nginx.org/en/linux_packages.html (add the nginx signing key and `deb ... nginx.org/packages/ubuntu` repo first, then install).
+
+## Core concepts
+- **Master/worker processes** — a master manages config; workers handle connections via an event loop.
+- **Contexts** — directives nest in `main`, `events`, `http`, `server`, and `location` blocks.
+- **server blocks** — virtual hosts matched by `listen` + `server_name`.
+- **location blocks** — match request URIs (prefix, `=`, `~` regex) to behavior.
+- **Reverse proxy** — `proxy_pass` forwards requests to a backend; set `proxy_set_header` for Host/X-Forwarded-*.
+- **upstream / load balancing** — group backends; round-robin, `least_conn`, `ip_hash`.
+- **Static serving** — `root`/`alias` + `try_files` resolve files on disk.
+- **TLS** — `ssl_certificate`/`ssl_certificate_key` on `listen 443 ssl`.
+
+## Best practices
+- Use `try_files $uri $uri/ =404;` (or to a front controller) instead of `if` for routing (https://nginx.org/en/docs/http/ngx_http_core_module.html#try_files).
+- Forward client info on proxies: set `Host`, `X-Forwarded-For`, `X-Forwarded-Proto` (https://nginx.org/en/docs/http/ngx_http_proxy_module.html).
+- Test config before reload: `nginx -t` then `nginx -s reload` (https://nginx.org/en/docs/beginners_guide.html).
+- Enable gzip and sensible `keepalive_timeout`/buffer tuning for throughput (https://nginx.org/en/docs/http/ngx_http_gzip_module.html).
+
+## Common pitfalls
+- Overusing `if` inside `location` causes surprising behavior → prefer `try_files`/`map` ("if is evil").
+- `proxy_pass` with a trailing slash vs none changes the rewritten URI → know the path-rewrite rule.
+- Editing config without `nginx -t` can take down the server on reload → always test first.
+
+## Examples
+```nginx
+upstream app { server 127.0.0.1:3000; }
+
+server {
+    listen 80;
+    server_name example.com;
+
+    location /static/ { root /var/www; }
+
+    location / {
+        proxy_pass http://app;
+        proxy_set_header Host $host;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+    }
+}
+```
+
+## Further reading
+- https://nginx.org/en/docs/beginners_guide.html — beginner's guide to running and configuring nginx
+- https://nginx.org/en/docs/dirindex.html — alphabetical directive index
+
+## Related skills
+- ../spring — proxy a Spring Boot app behind Nginx
+- ../symfony — serve Symfony's front controller via Nginx + PHP-FPM

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

@@ -0,0 +1,68 @@
+---
+name: phoenix
+description: Elixir web framework with realtime channels, LiveView, and an MVC structure on the BEAM; consult when building Phoenix apps or realtime features.
+domain: stack
+category: backend
+tags: [elixir, phoenix, liveview, realtime, web-framework]
+official_sources:
+  - https://hexdocs.pm/phoenix/
+  - https://github.com/phoenixframework/phoenix
+verified: 2026-06-16
+---
+
+# Phoenix
+
+## Overview
+Phoenix is a web framework written in Elixir that aims for "peace of mind from prototype to production." Running on the Erlang VM (BEAM), it provides an MVC structure, realtime communication via Channels, and server-rendered interactive UIs via LiveView. Read this when building Phoenix web apps, APIs, or realtime features.
+
+## Official sources
+- Docs: https://hexdocs.pm/phoenix/ (canonical: https://phoenix.hexdocs.pm/)
+- Repo: https://github.com/phoenixframework/phoenix
+- Install / download: https://hexdocs.pm/phoenix/installation.html
+
+## Install / setup
+```bash
+# Install the Phoenix application generator
+mix archive.install hex phx_new
+
+# Create a new application (replace "hello" with your app name)
+mix phx.new hello
+```
+
+## Core concepts
+- Endpoint & Router: the Endpoint is the entry point handling all requests; the Router maps paths to controllers and pipelines.
+- Plugs & pipelines: composable request-processing functions; pipelines group plugs (e.g. `:browser`, `:api`) applied to route scopes.
+- Controllers, views, templates: controllers handle requests and render templates via view modules, following an MVC structure.
+- Contexts: modules that group related domain logic and data access, keeping the web layer thin.
+- Channels: bidirectional realtime messaging over WebSockets for features like chat and live updates.
+- LiveView: server-rendered, stateful interactive UIs without writing custom client-side JavaScript.
+- Ecto: the data-mapping/query library typically used with Phoenix for schemas and migrations.
+
+## Best practices
+- Organize domain logic into Contexts so the web layer (controllers/LiveViews) stays thin (https://hexdocs.pm/phoenix/contexts.html).
+- Use router pipelines (`:browser`, `:api`) to apply the right plugs per route group.
+- Use Channels/LiveView for realtime rather than polling, leveraging the BEAM's concurrency.
+- Use Ecto migrations and changesets for schema changes and validation.
+
+## Common pitfalls
+- Putting business logic in controllers or LiveViews → move it into Contexts for testability and reuse.
+- Applying the wrong pipeline to a route (e.g. CSRF-protected `:browser` plugs on an API) → scope routes under the matching pipeline.
+- Confusing the package on Hex (`phx_new` generator) with the runtime dependency (`phoenix`) → install the generator archive first, then generate the app.
+
+## Examples
+```elixir
+# lib/hello_web/router.ex
+scope "/", HelloWeb do
+  pipe_through :browser
+  get "/", PageController, :home
+end
+```
+
+## Further reading
+- https://hexdocs.pm/phoenix/up_and_running.html — Up and running
+- https://hexdocs.pm/phoenix/contexts.html — Contexts
+- https://hexdocs.pm/phoenix/channels.html — Channels (realtime)
+
+## Related skills
+- ../rails — another MVC, convention-driven web framework
+- ../laravel — full-stack framework with realtime broadcasting

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

@@ -0,0 +1,67 @@
+---
+name: rails
+description: Convention-driven full-stack Ruby MVC framework with Active Record; consult when building or maintaining a Ruby on Rails backend.
+domain: stack
+category: backend
+tags: [ruby, rails, mvc, active-record, web-framework]
+official_sources:
+  - https://guides.rubyonrails.org/
+  - https://github.com/rails/rails
+verified: 2026-06-16
+---
+
+# Ruby on Rails
+
+## Overview
+Ruby on Rails is a web application framework that includes everything needed to build database-backed apps using the Model-View-Controller pattern. It favors convention over configuration, with Active Record for persistence plus libraries for mail, jobs, WebSockets, file storage, and rich text. Read this when scaffolding, routing, modeling data, or organizing a Rails app.
+
+## Official sources
+- Docs: https://guides.rubyonrails.org/
+- Repo: https://github.com/rails/rails
+- Install / download: https://guides.rubyonrails.org/getting_started.html (install Ruby/Rails: https://guides.rubyonrails.org/install_ruby_on_rails.html)
+
+## Install / setup
+```bash
+# Install the Rails gem (Ruby must already be installed)
+gem install rails
+
+# Create a new application
+rails new store
+```
+
+## Core concepts
+- Convention over configuration: predictable file locations and naming reduce boilerplate; following conventions is what makes Rails productive.
+- MVC layers: Models (domain/data, usually Active Record), Views (templates, typically HTML with embedded Ruby), Controllers (handle HTTP requests and coordinate responses).
+- Active Record: maps classes to tables and provides associations, validations, and query methods; migrations evolve the schema.
+- Routing: `config/routes.rb` maps URLs to controller actions, with RESTful resource routing as the default idiom.
+- Generators: `rails generate` scaffolds models, controllers, and migrations following conventions.
+- Asset and frontend pipeline: Rails integrates view templates and bundled JS/CSS for full-stack rendering.
+
+## Best practices
+- Lean on RESTful resource routes and conventional naming so generators and helpers work as intended (https://guides.rubyonrails.org/getting_started.html).
+- Use migrations for every schema change so databases stay reproducible across environments.
+- Keep business logic in models/service objects rather than controllers (fat-model/skinny-controller idiom).
+- Use the built-in test framework (Minitest) and fixtures to cover models and controllers.
+
+## Common pitfalls
+- Fighting conventions (custom paths, non-standard names) → generators, autoloading, and helpers break; follow Rails naming.
+- Putting heavy logic in controllers or views → move it into models or plain Ruby objects for testability.
+- Editing the schema by hand instead of via migrations → environments drift; always generate and run migrations.
+
+## Examples
+```ruby
+# config/routes.rb
+Rails.application.routes.draw do
+  resources :articles
+  root "articles#index"
+end
+```
+
+## Further reading
+- https://guides.rubyonrails.org/getting_started.html — Getting started
+- https://guides.rubyonrails.org/active_record_basics.html — Active Record basics
+- https://guides.rubyonrails.org/routing.html — Rails routing
+
+## Related skills
+- ../laravel — analogous convention-driven full-stack framework in PHP
+- ../phoenix — MVC-style framework with realtime, in Elixir

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

@@ -0,0 +1,70 @@
+---
+name: spring
+description: Spring Framework and Spring Boot — the Java/Kotlin application framework for dependency injection, web/REST APIs, data access, and security. Consult when building Java backends, wiring beans, writing @RestController endpoints, configuring Spring Boot auto-configuration, JPA/JDBC data access, or bootstrapping a project from Spring Initializr (start.spring.io).
+domain: stack
+category: backend
+tags: [spring, spring-boot, java, kotlin, jvm, dependency-injection, rest]
+official_sources:
+  - https://docs.spring.io/spring-framework/reference/
+  - https://github.com/spring-projects/spring-framework
+  - https://start.spring.io/
+verified: 2026-06-17
+---
+
+# Spring Framework
+
+## Overview
+Spring is the dominant application framework for the JVM, providing an inversion-of-control (IoC) container, declarative transactions, web MVC, data access, and security. Spring Boot layers opinionated auto-configuration and an embedded server on top so apps run with `java -jar`. Read this when building Java/Kotlin backends, defining beans, writing REST controllers, or wiring Spring Data/Security.
+
+## Official sources
+- Docs: https://docs.spring.io/spring-framework/reference/
+- Repo: https://github.com/spring-projects/spring-framework
+- Install: https://start.spring.io/
+
+## Install / setup
+```bash
+# Generate a Spring Boot project from Spring Initializr (web dependency)
+curl https://start.spring.io/starter.zip -d dependencies=web -d type=gradle-project -o demo.zip
+unzip demo.zip && ./gradlew bootRun
+```
+Source: https://spring.io/quickstart/ (start.spring.io generates the project; `./gradlew bootRun` runs it on :8080).
+
+## Core concepts
+- **IoC container / ApplicationContext** — manages bean lifecycle and dependency injection.
+- **Beans & stereotypes** — `@Component`, `@Service`, `@Repository`, `@Controller` register beans; `@Autowired`/constructor injection wires them.
+- **Auto-configuration (Boot)** — `@SpringBootApplication` enables component scan + conditional config based on the classpath.
+- **Spring MVC** — `@RestController` + `@GetMapping`/`@PostMapping` map HTTP to handler methods.
+- **Spring Data** — repository interfaces (`JpaRepository`) generate queries from method names.
+- **Declarative transactions** — `@Transactional` manages commit/rollback boundaries.
+- **Profiles & config** — `application.yml`/`application.properties`, `@Profile`, externalized `@ConfigurationProperties`.
+- **Spring Security** — filter-chain based authn/authz via `SecurityFilterChain` beans.
+
+## Best practices
+- Prefer constructor injection over field injection for testability and immutability (https://docs.spring.io/spring-framework/reference/core/beans/dependencies/factory-collaborators.html).
+- Let Spring Boot starters manage versions; do not pin transitive deps manually (https://docs.spring.io/spring-boot/reference/using/build-systems.html).
+- Externalize config and use profiles instead of hardcoding env values (https://docs.spring.io/spring-boot/reference/features/external-config.html).
+- Keep `@Transactional` on the service layer, not controllers (https://docs.spring.io/spring-framework/reference/data-access/transaction.html).
+
+## Common pitfalls
+- Calling a `@Transactional`/`@Cacheable` method from within the same bean bypasses the proxy → split into a separate bean or use self-injection.
+- Field injection hides missing deps and breaks unit tests → use constructor injection.
+- `@SpringBootApplication` in the wrong package skips component scanning → place it at the root package.
+
+## Examples
+```java
+@RestController
+class HelloController {
+  @GetMapping("/hello")
+  String hello(@RequestParam(defaultValue = "World") String name) {
+    return "Hello " + name;
+  }
+}
+```
+
+## Further reading
+- https://docs.spring.io/spring-boot/index.html — Spring Boot reference docs
+- https://spring.io/guides — official task-focused getting-started guides
+
+## Related skills
+- ../graphql — expose a Spring backend via GraphQL (Spring for GraphQL)
+- ../nginx — reverse-proxy a Spring Boot app behind Nginx