@riligar/agents-kit 1.11.0 → 1.13.0

package/.agent/skills/riligar-dev-backend/SKILL.md

@@ -1,15 +1,12 @@
 ---
 name: riligar-dev-backend
 type: development
-description: API design principles and decision-making. REST vs GraphQL vs tRPC selection, response formats, versioning, pagination. Use when designing APIs or backend services.
+description: Elysia backend development patterns for Bun. Use when building APIs, routes, plugins, validation, middleware, and error handling with Elysia framework.
 ---
 
-# API Patterns
+# Elysia Backend Development
 
-> API design principles and decision-making for 2025.
-> **Learn to THINK, not copy fixed patterns.**
-
----
+> Build fast, type-safe APIs with Elysia + Bun.
 
 ## Mandatory Guidelines
 
@@ -17,84 +14,122 @@ description: API design principles and decision-making. REST vs GraphQL vs tRPC
 > All work in this skill MUST adhere to:
 >
 > - @[.agent/skills/riligar-dev-clean-code] (Clean Code Standards)
-
----
-
-## 🎯 Selective Reading Rule
-
-**Read ONLY files relevant to the request!** Check the content map, find what you need.
-
----
-
-## 📑 Content Map
-
-| File                  | Description                                 | When to Read           |
-| --------------------- | ------------------------------------------- | ---------------------- |
-| `api-style.md`        | REST vs GraphQL vs tRPC decision tree       | Choosing API type      |
-| `rest.md`             | Resource naming, HTTP methods, status codes | Designing REST API     |
-| `response.md`         | Envelope pattern, error format, pagination  | Response structure     |
-| `graphql.md`          | Schema design, when to use, security        | Considering GraphQL    |
-| `trpc.md`             | TypeScript monorepo, type safety            | TS fullstack projects  |
-| `versioning.md`       | URI/Header/Query versioning                 | API evolution planning |
-| `auth.md`             | JWT, OAuth, Passkey, API Keys               | Auth pattern selection |
-| `rate-limiting.md`    | Token bucket, sliding window                | API protection         |
-| `documentation.md`    | OpenAPI/Swagger best practices              | Documentation          |
-| `security-testing.md` | OWASP API Top 10, auth/authz testing        | Security audits        |
-
----
-
-## 🔗 Related Skills
-
-| Need                | Skill                                             |
-| ------------------- | ------------------------------------------------- |
-| **Core Standards**  | @[.agent/skills/riligar-dev-clean-code]           |
-| **Architecture**    | @[.agent/skills/riligar-dev-architecture]         |
-| **Database**        | @[.agent/skills/riligar-dev-database]             |
-| **Infrastructure**  | @[.agent/skills/riligar-infrastructure]           |
-| **Tech Stack**      | @[.agent/skills/riligar-tech-stack]               |
-| **Business Case**   | @[.agent/skills/riligar-business-startup-analyst] |
-| **Market Analysis** | @[.agent/skills/riligar-business-startup-market]  |
-| **Code Review**     | @[.agent/skills/riligar-dev-code-review]          |
-| **Task Planning**   | @[.agent/skills/riligar-plan-writing]             |
-| **SEO Tech**        | @[.agent/skills/riligar-dev-seo]                  |
-
----
-
-## ✅ Decision Checklist
-
-Before designing an API:
-
-- [ ] **Asked user about API consumers?**
-- [ ] **Chosen API style for THIS context?** (REST/GraphQL/tRPC)
-- [ ] **Defined consistent response format?**
-- [ ] **Planned versioning strategy?**
-- [ ] **Considered authentication needs?**
-- [ ] **Planned rate limiting?**
-- [ ] **Documentation approach defined?**
-
----
-
-## ❌ Anti-Patterns
-
-**DON'T:**
-
-- Default to REST for everything
-- Use verbs in REST endpoints (/getUsers)
-- Return inconsistent response formats
-- Expose internal errors to clients
-- Skip rate limiting
-
-**DO:**
-
-- Choose API style based on context
-- Ask about client requirements
-- Document thoroughly
-- Use appropriate status codes
-
----
-
-## Script
-
-| Script                     | Purpose                 | Command                                          |
-| -------------------------- | ----------------------- | ------------------------------------------------ |
-| `scripts/api_validator.py` | API endpoint validation | `python scripts/api_validator.py <project_path>` |
+> - @[.agent/skills/riligar-tech-stack] (Tech Stack - Bun, Elysia, SQLite, Drizzle)
+
+## Quick Reference
+
+```javascript
+import { Elysia, t } from 'elysia'
+
+const app = new Elysia()
+    .get('/', () => 'Hello Elysia')
+    .post('/users', ({ body }) => createUser(body), {
+        body: t.Object({
+            name: t.String(),
+            email: t.String({ format: 'email' })
+        })
+    })
+    .listen(3000)
+```
+
+## Content Map
+
+| File | Description | When to Read |
+| --- | --- | --- |
+| [elysia-basics.md](references/elysia-basics.md) | Setup, routes, handlers, context | Starting new project |
+| [elysia-plugins.md](references/elysia-plugins.md) | Plugins, guards, modular design | Organizing code |
+| [elysia-validation.md](references/elysia-validation.md) | TypeBox validation (body, query, params) | Input validation |
+| [elysia-lifecycle.md](references/elysia-lifecycle.md) | Hooks (onBeforeHandle, onError, etc.) | Middleware, auth checks |
+| [elysia-patterns.md](references/elysia-patterns.md) | REST patterns, responses, pagination | API design |
+
+## Project Structure
+
+```
+src/
+├── index.js           # Entry point
+├── routes/
+│   ├── index.js       # Route aggregator
+│   ├── users.js       # User routes plugin
+│   └── posts.js       # Post routes plugin
+├── services/
+│   ├── user.js        # Business logic
+│   └── post.js
+├── database/
+│   ├── db.js          # Drizzle connection
+│   ├── schema.js      # Drizzle schema
+│   └── migrations/
+└── middleware/
+    ├── auth.js        # Auth middleware
+    └── logger.js      # Request logging
+```
+
+## Core Patterns
+
+### Route Plugin
+
+```javascript
+// routes/users.js
+import { Elysia, t } from 'elysia'
+import { getUserById, createUser } from '../services/user'
+
+export const userRoutes = new Elysia({ prefix: '/users' })
+    .get('/', () => getAllUsers())
+    .get('/:id', ({ params }) => getUserById(params.id))
+    .post('/', ({ body }) => createUser(body), {
+        body: t.Object({
+            name: t.String({ minLength: 1 }),
+            email: t.String({ format: 'email' })
+        })
+    })
+```
+
+### Main App
+
+```javascript
+// index.js
+import { Elysia } from 'elysia'
+import { userRoutes } from './routes/users'
+import { postRoutes } from './routes/posts'
+
+const app = new Elysia()
+    .onError(({ error, set }) => {
+        console.error(error)
+        set.status = 500
+        return { error: 'Internal Server Error' }
+    })
+    .use(userRoutes)
+    .use(postRoutes)
+    .listen(3000)
+
+console.log(`Server running at ${app.server?.url}`)
+```
+
+## Related Skills
+
+| Need | Skill |
+| --- | --- |
+| **Authentication** | @[.agent/skills/riligar-dev-auth-elysia] |
+| **Database** | @[.agent/skills/riligar-dev-database] |
+| **Tech Stack** | @[.agent/skills/riligar-tech-stack] |
+| **Clean Code** | @[.agent/skills/riligar-dev-clean-code] |
+| **Infrastructure** | @[.agent/skills/riligar-infrastructure] |
+
+## Decision Checklist
+
+Before building an API:
+
+- [ ] Defined route structure and prefixes?
+- [ ] Planned validation for all inputs?
+- [ ] Error handling configured?
+- [ ] Auth middleware needed? → Use `riligar-dev-auth-elysia`
+- [ ] Database connection setup? → Use `riligar-dev-database`
+
+## Anti-Patterns
+
+| Don't | Do |
+| --- | --- |
+| Put business logic in handlers | Extract to `services/` |
+| Skip input validation | Use TypeBox (`t.Object`) |
+| Ignore error handling | Use `onError` lifecycle |
+| Create monolithic files | Split into plugins |
+| Use verbs in routes (`/getUser`) | Use nouns (`/users/:id`) |

package/.agent/skills/riligar-dev-backend/references/elysia-basics.md

@@ -0,0 +1,224 @@
+# Elysia Basics
+
+## Installation
+
+```bash
+bun add elysia
+```
+
+## Minimal Server
+
+```javascript
+import { Elysia } from 'elysia'
+
+const app = new Elysia()
+    .get('/', () => 'Hello World')
+    .listen(3000)
+
+console.log(`Server running at ${app.server?.url}`)
+```
+
+## HTTP Methods
+
+```javascript
+const app = new Elysia()
+    .get('/users', () => getUsers())           // Read
+    .post('/users', ({ body }) => create(body)) // Create
+    .put('/users/:id', ({ params, body }) => replace(params.id, body))   // Replace
+    .patch('/users/:id', ({ params, body }) => update(params.id, body))  // Update
+    .delete('/users/:id', ({ params }) => remove(params.id))             // Delete
+```
+
+## Context Object
+
+Every handler receives a context object with request data:
+
+```javascript
+app.post('/example', (ctx) => {
+    // Request data
+    ctx.body      // Parsed request body
+    ctx.query     // Query string (?key=value)
+    ctx.params    // Path parameters (/:id)
+    ctx.headers   // Request headers
+    ctx.cookie    // Cookies
+    ctx.request   // Raw Request object
+    ctx.path      // Request pathname
+
+    // Response helpers
+    ctx.set.status = 201           // Set status code
+    ctx.set.headers['X-Custom'] = 'value'  // Set header
+    ctx.redirect('/other')         // Redirect
+
+    return { success: true }
+})
+```
+
+## Destructuring Context
+
+```javascript
+// Clean handler with destructuring
+app.post('/users', ({ body, set }) => {
+    const user = createUser(body)
+    set.status = 201
+    return user
+})
+
+app.get('/users/:id', ({ params }) => {
+    return getUserById(params.id)
+})
+
+app.get('/search', ({ query }) => {
+    return search(query.q, query.limit)
+})
+```
+
+## Response Types
+
+### JSON (default)
+
+```javascript
+app.get('/json', () => {
+    return { message: 'Hello' }  // Automatically JSON
+})
+```
+
+### String
+
+```javascript
+app.get('/text', () => {
+    return 'Plain text response'
+})
+```
+
+### Status Codes
+
+```javascript
+app.post('/users', ({ body, set }) => {
+    const user = createUser(body)
+    set.status = 201  // Created
+    return user
+})
+
+app.get('/users/:id', ({ params, set }) => {
+    const user = findUser(params.id)
+    if (!user) {
+        set.status = 404
+        return { error: 'User not found' }
+    }
+    return user
+})
+```
+
+### Redirect
+
+```javascript
+app.get('/old-path', ({ redirect }) => {
+    return redirect('/new-path')
+})
+```
+
+## Route Parameters
+
+### Path Parameters
+
+```javascript
+// Single parameter
+app.get('/users/:id', ({ params }) => {
+    return getUserById(params.id)
+})
+
+// Multiple parameters
+app.get('/users/:userId/posts/:postId', ({ params }) => {
+    return getPost(params.userId, params.postId)
+})
+```
+
+### Query Parameters
+
+```javascript
+// GET /search?q=hello&limit=10
+app.get('/search', ({ query }) => {
+    const { q, limit = '10' } = query
+    return search(q, parseInt(limit))
+})
+```
+
+## Headers
+
+### Reading Headers
+
+```javascript
+app.get('/protected', ({ headers, set }) => {
+    const token = headers.authorization
+    if (!token) {
+        set.status = 401
+        return { error: 'Unauthorized' }
+    }
+    return { message: 'Welcome' }
+})
+```
+
+### Setting Headers
+
+```javascript
+app.get('/api/data', ({ set }) => {
+    set.headers['X-Custom-Header'] = 'value'
+    set.headers['Cache-Control'] = 'max-age=3600'
+    return { data: 'example' }
+})
+```
+
+## Cookies
+
+```javascript
+app.get('/set-cookie', ({ cookie }) => {
+    cookie.session.set({
+        value: 'abc123',
+        httpOnly: true,
+        maxAge: 60 * 60 * 24  // 1 day
+    })
+    return { message: 'Cookie set' }
+})
+
+app.get('/read-cookie', ({ cookie }) => {
+    return { session: cookie.session.value }
+})
+```
+
+## Static Files
+
+```javascript
+import { Elysia } from 'elysia'
+import { staticPlugin } from '@elysiajs/static'
+
+const app = new Elysia()
+    .use(staticPlugin({
+        prefix: '/public',
+        assets: 'public'
+    }))
+```
+
+## Environment Variables
+
+```javascript
+// Use Bun's built-in env
+const port = process.env.PORT || 3000
+const dbUrl = process.env.DATABASE_URL
+
+const app = new Elysia()
+    .listen(port)
+```
+
+## Graceful Shutdown
+
+```javascript
+const app = new Elysia()
+    .get('/', () => 'Hello')
+    .listen(3000)
+
+process.on('SIGINT', () => {
+    console.log('Shutting down...')
+    app.stop()
+    process.exit(0)
+})
+```