@punks/cli 0.1.16 → 1.0.1

package/dist/skills/frameworks/elysia/elysiajs/examples/file.ts

@@ -0,0 +1,10 @@
+import { Elysia, file } from 'elysia'
+
+/**
+ * Example of handle single static file
+ *
+ * @see https://github.com/elysiajs/elysia-static
+ */
+new Elysia()
+	.get('/tako', file('./example/takodachi.png'))
+	.listen(3000)

package/dist/skills/frameworks/elysia/elysiajs/examples/guard.ts

@@ -0,0 +1,34 @@
+import { Elysia, t } from 'elysia'
+
+new Elysia()
+	.state('name', 'salt')
+	.get('/', ({ store: { name } }) => `Hi ${name}`, {
+		query: t.Object({
+			name: t.String()
+		})
+	})
+	// If query 'name' is not preset, skip the whole handler
+	.guard(
+		{
+			query: t.Object({
+				name: t.String()
+			})
+		},
+		(app) =>
+			app
+				// Query type is inherited from guard
+				.get('/profile', ({ query }) => `Hi`)
+				// Store is inherited
+				.post('/name', ({ store: { name }, body, query }) => name, {
+					body: t.Object({
+						id: t.Number({
+							minimum: 5
+						}),
+						username: t.String(),
+						profile: t.Object({
+							name: t.String()
+						})
+					})
+				})
+	)
+	.listen(3000)

package/dist/skills/frameworks/elysia/elysiajs/examples/map-response.ts

@@ -0,0 +1,15 @@
+import { Elysia } from 'elysia'
+
+const prettyJson = new Elysia()
+	.mapResponse(({ response }) => {
+		if (response instanceof Object)
+			return new Response(JSON.stringify(response, null, 4))
+	})
+	.as('scoped')
+
+new Elysia()
+	.use(prettyJson)
+	.get('/', () => ({
+		hello: 'world'
+	}))
+	.listen(3000)

package/dist/skills/frameworks/elysia/elysiajs/examples/redirect.ts

@@ -0,0 +1,6 @@
+import { Elysia } from 'elysia'
+
+new Elysia()
+	.get('/', () => 'Hi')
+	.get('/redirect', ({ redirect }) => redirect('/'))
+	.listen(3000)

package/dist/skills/frameworks/elysia/elysiajs/examples/rename.ts

@@ -0,0 +1,32 @@
+import { Elysia, t } from 'elysia'
+
+// ? Elysia#83 | Proposal: Standardized way of renaming third party plugin-scoped stuff
+// this would be a plugin provided by a third party
+const myPlugin = new Elysia()
+	.decorate('myProperty', 42)
+	.model('salt', t.String())
+
+new Elysia()
+	.use(
+		myPlugin
+			// map decorator, rename "myProperty" to "renamedProperty"
+			.decorate(({ myProperty, ...decorators }) => ({
+				renamedProperty: myProperty,
+				...decorators
+			}))
+			// map model, rename "salt" to "pepper"
+			.model(({ salt, ...models }) => ({
+				...models,
+				pepper: t.String()
+			}))
+			// Add prefix
+			.prefix('decorator', 'unstable')
+	)
+	.get(
+		'/mapped',
+		({ unstableRenamedProperty }) => unstableRenamedProperty
+	)
+	.post('/pepper', ({ body }) => body, {
+		body: 'pepper',
+		// response: t.String()
+	})

package/dist/skills/frameworks/elysia/elysiajs/examples/schema.ts

@@ -0,0 +1,61 @@
+import { Elysia, t } from 'elysia'
+
+const app = new Elysia()
+	.model({
+		name: t.Object({
+			name: t.String()
+		}),
+		b: t.Object({
+			response: t.Number()
+		}),
+		authorization: t.Object({
+			authorization: t.String()
+		})
+	})
+	// Strictly validate response
+	.get('/', () => 'hi')
+	// Strictly validate body and response
+	.post('/', ({ body, query }) => body.id, {
+		body: t.Object({
+			id: t.Number(),
+			username: t.String(),
+			profile: t.Object({
+				name: t.String()
+			})
+		})
+	})
+	// Strictly validate query, params, and body
+	.get('/query/:id', ({ query: { name }, params }) => name, {
+		query: t.Object({
+			name: t.String()
+		}),
+		params: t.Object({
+			id: t.String()
+		}),
+		response: {
+			200: t.String(),
+			300: t.Object({
+				error: t.String()
+			})
+		}
+	})
+	.guard(
+		{
+			headers: 'authorization'
+		},
+		(app) =>
+			app
+				.derive(({ headers }) => ({
+					userId: headers.authorization
+				}))
+				.get('/', ({ userId }) => 'A')
+				.post('/id/:id', ({ query, body, params, userId }) => body, {
+					params: t.Object({
+						id: t.Number()
+					}),
+					transform({ params }) {
+						params.id = +params.id
+					}
+				})
+	)
+	.listen(3000)

package/dist/skills/frameworks/elysia/elysiajs/examples/state.ts

@@ -0,0 +1,6 @@
+import { Elysia } from 'elysia'
+
+new Elysia()
+	.state('counter', 0)
+	.get('/', ({ store }) => store.counter++)
+	.listen(3000)

package/dist/skills/frameworks/elysia/elysiajs/examples/upload-file.ts

@@ -0,0 +1,20 @@
+import { Elysia, t } from 'elysia'
+
+const app = new Elysia()
+	.post('/single', ({ body: { file } }) => file, {
+		body: t.Object({
+			file: t.File({
+				maxSize: '1m'
+			})
+		})
+	})
+	.post(
+		'/multiple',
+		({ body: { files } }) => files.reduce((a, b) => a + b.size, 0),
+		{
+			body: t.Object({
+				files: t.Files()
+			})
+		}
+	)
+	.listen(3000)

package/dist/skills/frameworks/elysia/elysiajs/examples/websocket.ts

@@ -0,0 +1,25 @@
+import { Elysia } from 'elysia'
+
+const app = new Elysia()
+	.state('start', 'here')
+	.ws('/ws', {
+		open(ws) {
+			ws.subscribe('asdf')
+			console.log('Open Connection:', ws.id)
+		},
+		close(ws) {
+			console.log('Closed Connection:', ws.id)
+		},
+		message(ws, message) {
+			ws.publish('asdf', message)
+			ws.send(message)
+		}
+	})
+	.get('/publish/:publish', ({ params: { publish: text } }) => {
+		app.server!.publish('asdf', text)
+
+		return text
+	})
+	.listen(3000, (server) => {
+		console.log(`http://${server.hostname}:${server.port}`)
+	})

package/dist/skills/frameworks/elysia/elysiajs/integrations/ai-sdk.md

@@ -0,0 +1,92 @@
+# AI SDK Integration
+
+## What It Is
+Seamless integration with Vercel AI SDK via response streaming.
+
+## Response Streaming
+Return `ReadableStream` or `Response` directly:
+```typescript
+import { streamText } from 'ai'
+import { openai } from '@ai-sdk/openai'
+
+new Elysia().get('/', () => {
+  const stream = streamText({
+    model: openai('gpt-5'),
+    system: 'You are Yae Miko from Genshin Impact',
+    prompt: 'Hi! How are you doing?'
+  })
+  
+  return stream.textStream  // ReadableStream
+  // or
+  return stream.toUIMessageStream()  // UI Message Stream
+})
+```
+
+Elysia auto-handles stream.
+
+## Server-Sent Events
+Wrap `ReadableStream` with `sse`:
+```typescript
+import { sse } from 'elysia'
+
+.get('/', () => {
+  const stream = streamText({ /* ... */ })
+  
+  return sse(stream.textStream)
+  // or
+  return sse(stream.toUIMessageStream())
+})
+```
+
+Each chunk → SSE.
+
+## As Response
+Return stream directly (no Eden type safety):
+```typescript
+.get('/', () => {
+  const stream = streamText({ /* ... */ })
+  
+  return stream.toTextStreamResponse()
+  // or
+  return stream.toUIMessageStreamResponse()  // Uses SSE
+})
+```
+
+## Manual Streaming
+Generator function for control:
+```typescript
+import { sse } from 'elysia'
+
+.get('/', async function* () {
+  const stream = streamText({ /* ... */ })
+  
+  for await (const data of stream.textStream)
+    yield sse({ data, event: 'message' })
+  
+  yield sse({ event: 'done' })
+})
+```
+
+## Fetch for Unsupported Models
+Direct fetch with streaming proxy:
+```typescript
+.get('/', () => {
+  return fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`
+    },
+    body: JSON.stringify({
+      model: 'gpt-5',
+      stream: true,
+      messages: [
+        { role: 'system', content: 'You are Yae Miko' },
+        { role: 'user', content: 'Hi! How are you doing?' }
+      ]
+    })
+  })
+})
+```
+
+Elysia auto-proxies fetch response with streaming.

package/dist/skills/frameworks/elysia/elysiajs/integrations/astro.md

@@ -0,0 +1,59 @@
+# Astro Integration - SKILLS.md
+
+## What It Is
+Run Elysia on Astro via Astro Endpoint.
+
+## Setup
+1. Set output to server:
+```javascript
+// astro.config.mjs
+export default defineConfig({
+  output: 'server'
+})
+```
+
+2. Create `pages/[...slugs].ts`
+3. Define Elysia server + export handlers:
+```typescript
+// pages/[...slugs].ts
+import { Elysia, t } from 'elysia'
+
+const app = new Elysia()
+  .get('/api', () => 'hi')
+  .post('/api', ({ body }) => body, {
+    body: t.Object({ name: t.String() })
+  })
+
+const handle = ({ request }: { request: Request }) => app.handle(request)
+
+export const GET = handle
+export const POST = handle
+```
+
+WinterCG compliance - works normally.
+
+Recommended: Run Astro on Bun (Elysia designed for Bun).
+
+## Prefix for Non-Root
+If placed in `pages/api/[...slugs].ts`, set prefix:
+```typescript
+// pages/api/[...slugs].ts
+const app = new Elysia({ prefix: '/api' })
+  .get('/', () => 'hi')
+
+const handle = ({ request }: { request: Request }) => app.handle(request)
+
+export const GET = handle
+export const POST = handle
+```
+
+Ensures routing works in any location.
+
+## Benefits
+Co-location of frontend + backend. End-to-end type safety with Eden.
+
+## pnpm
+Manual install:
+```bash
+pnpm add @sinclair/typebox openapi-types
+```

package/dist/skills/frameworks/elysia/elysiajs/integrations/better-auth.md

@@ -0,0 +1,117 @@
+# Better Auth Integration
+Elysia + Better Auth integration guide
+
+## What It Is
+Framework-agnostic TypeScript auth/authz. Comprehensive features + plugin ecosystem.
+
+## Setup
+```typescript
+import { betterAuth } from 'better-auth'
+import { Pool } from 'pg'
+
+export const auth = betterAuth({
+  database: new Pool()
+})
+```
+
+## Handler Mounting
+```typescript
+import { auth } from './auth'
+
+new Elysia()
+  .mount(auth.handler)  // http://localhost:3000/api/auth
+  .listen(3000)
+```
+
+### Custom Endpoint
+```typescript
+// Mount with prefix
+.mount('/auth', auth.handler)  // http://localhost:3000/auth/api/auth
+
+// Customize basePath
+export const auth = betterAuth({
+  basePath: '/api'  // http://localhost:3000/auth/api
+})
+```
+
+Cannot set `basePath` to empty or `/`.
+
+## OpenAPI Integration
+Extract docs from Better Auth:
+```typescript
+import { openAPI } from 'better-auth/plugins'
+
+let _schema: ReturnType<typeof auth.api.generateOpenAPISchema>
+const getSchema = async () => (_schema ??= auth.api.generateOpenAPISchema())
+
+export const OpenAPI = {
+  getPaths: (prefix = '/auth/api') =>
+    getSchema().then(({ paths }) => {
+      const reference: typeof paths = Object.create(null)
+      
+      for (const path of Object.keys(paths)) {
+        const key = prefix + path
+        reference[key] = paths[path]
+        
+        for (const method of Object.keys(paths[path])) {
+          const operation = (reference[key] as any)[method]
+          operation.tags = ['Better Auth']
+        }
+      }
+      
+      return reference
+    }) as Promise<any>,
+  components: getSchema().then(({ components }) => components) as Promise<any>
+} as const
+```
+
+Apply to Elysia:
+```typescript
+new Elysia().use(openapi({
+  documentation: {
+    components: await OpenAPI.components,
+    paths: await OpenAPI.getPaths()
+  }
+}))
+```
+
+## CORS
+```typescript
+import { cors } from '@elysiajs/cors'
+
+new Elysia()
+  .use(cors({
+    origin: 'http://localhost:3001',
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+    credentials: true,
+    allowedHeaders: ['Content-Type', 'Authorization']
+  }))
+  .mount(auth.handler)
+```
+
+## Macro for Auth
+Use macro + resolve for session/user:
+```typescript
+const betterAuth = new Elysia({ name: 'better-auth' })
+  .mount(auth.handler)
+  .macro({
+    auth: {
+      async resolve({ status, request: { headers } }) {
+        const session = await auth.api.getSession({ headers })
+        
+        if (!session) return status(401)
+        
+        return {
+          user: session.user,
+          session: session.session
+        }
+      }
+    }
+  })
+
+new Elysia()
+  .use(betterAuth)
+  .get('/user', ({ user }) => user, { auth: true })
+```
+
+Access `user` and `session` in all routes.

package/dist/skills/frameworks/elysia/elysiajs/integrations/cloudflare-worker.md

@@ -0,0 +1,95 @@
+
+# Cloudflare Worker Integration
+
+## What It Is
+**Experimental** Cloudflare Worker adapter for Elysia.
+
+## Setup
+1. Install Wrangler:
+```bash
+wrangler init elysia-on-cloudflare
+```
+
+2. Apply adapter + compile:
+```typescript
+import { Elysia } from 'elysia'
+import { CloudflareAdapter } from 'elysia/adapter/cloudflare-worker'
+
+export default new Elysia({
+  adapter: CloudflareAdapter
+})
+  .get('/', () => 'Hello Cloudflare Worker!')
+  .compile()  // Required
+```
+
+3. Set compatibility date (min `2025-06-01`):
+```json
+// wrangler.json
+{
+  "name": "elysia-on-cloudflare",
+  "main": "src/index.ts",
+  "compatibility_date": "2025-06-01"
+}
+```
+
+4. Dev server:
+```bash
+wrangler dev
+# http://localhost:8787
+```
+
+No `nodejs_compat` flag needed.
+
+## Limitations
+1. `Elysia.file` + Static Plugin don't work (no `fs` module)
+2. OpenAPI Type Gen doesn't work (no `fs` module)
+3. Cannot define Response before server start
+4. Cannot inline values:
+```typescript
+// ❌ Throws error
+.get('/', 'Hello Elysia')
+
+// ✅ Works
+.get('/', () => 'Hello Elysia')
+```
+
+## Static Files
+Use Cloudflare's built-in static serving:
+```json
+// wrangler.json
+{
+  "assets": { "directory": "public" }
+}
+```
+
+Structure:
+```
+├─ public
+│  ├─ kyuukurarin.mp4
+│  └─ static/mika.webp
+```
+
+Access:
+- `http://localhost:8787/kyuukurarin.mp4`
+- `http://localhost:8787/static/mika.webp`
+
+## Binding
+Import env from `cloudflare:workers`:
+```typescript
+import { env } from 'cloudflare:workers'
+
+export default new Elysia({ adapter: CloudflareAdapter })
+  .get('/', () => `Hello ${await env.KV.get('my-key')}`)
+  .compile()
+```
+
+## AoT Compilation
+As of Elysia 1.4.7, AoT works with Cloudflare Worker. Drop `aot: false` flag.
+
+Cloudflare now supports Function compilation during startup.
+
+## pnpm
+Manual install:
+```bash
+pnpm add @sinclair/typebox openapi-types
+```

package/dist/skills/frameworks/elysia/elysiajs/integrations/deno.md

@@ -0,0 +1,34 @@
+# Deno Integration
+Run Elysia on Deno
+
+## What It Is
+Run Elysia on Deno via Web Standard Request/Response.
+
+## Setup
+Wrap `Elysia.fetch` in `Deno.serve`:
+```typescript
+import { Elysia } from 'elysia'
+
+const app = new Elysia()
+  .get('/', () => 'Hello Elysia')
+  .listen(3000)
+
+Deno.serve(app.fetch)
+```
+
+Run:
+```bash
+deno serve --watch src/index.ts
+```
+
+## Port Config
+```typescript
+Deno.serve(app.fetch)                  // Default
+Deno.serve({ port: 8787 }, app.fetch)  // Custom port
+```
+
+## pnpm
+[Inference] pnpm doesn't auto-install peer deps. Manual install required:
+```bash
+pnpm add @sinclair/typebox openapi-types
+```