quiver-cli 1.3.0 → 2.0.0

package/template/.agents/skills/find-skills/SKILL.md

@@ -1,141 +0,0 @@
----
-name: find-skills
-description: Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
----
-
-# Find Skills
-
-This skill helps you discover and install skills from the open agent skills ecosystem.
-
-## When to Use This Skill
-
-Use this skill when the user:
-
-- Asks "how do I do X" where X might be a common task with an existing skill
-- Says "find a skill for X" or "is there a skill for X"
-- Asks "can you do X" where X is a specialized capability
-- Expresses interest in extending agent capabilities
-- Wants to search for tools, templates, or workflows
-- Mentions they wish they had help with a specific domain (design, testing, deployment, etc.)
-
-## What is the Skills CLI?
-
-The Skills CLI (`npx skills`) is the package manager for the open agent skills ecosystem. Skills are modular packages that extend agent capabilities with specialized knowledge, workflows, and tools.
-
-**Key commands:**
-
-- `npx skills find [query] [--owner <owner>]` - Search for skills interactively or by keyword, optionally scoped to a GitHub owner
-- `npx skills add <package>` - Install a skill from GitHub or other sources
-- `npx skills update` - Update all installed skills
-
-**Browse skills at:** https://skills.sh/
-
-## How to Help Users Find Skills
-
-### Step 1: Understand What They Need
-
-When a user asks for help with something, identify:
-
-1. The domain (e.g., React, testing, design, deployment)
-2. The specific task (e.g., writing tests, creating animations, reviewing PRs)
-3. Whether this is a common enough task that a skill likely exists
-
-### Step 2: Check the Leaderboard First
-
-Before running a CLI search, check the [skills.sh leaderboard](https://skills.sh/) to see if a well-known skill already exists for the domain. The leaderboard ranks skills by total installs, surfacing the most popular and battle-tested options.
-
-For example, top skills for web development include:
-- `vercel-labs/agent-skills` — React, Next.js, web design (100K+ installs each)
-- `anthropics/skills` — Frontend design, document processing (100K+ installs)
-
-### Step 3: Search for Skills
-
-If the leaderboard doesn't cover the user's need, run the find command:
-
-```bash
-npx skills find [query] [--owner <owner>]
-```
-
-For example:
-
-- User asks "how do I make my React app faster?" → `npx skills find react performance`
-- User asks "can you help me with PR reviews?" → `npx skills find pr review`
-- User asks "I need to create a changelog" → `npx skills find changelog`
-
-### Step 4: Verify Quality Before Recommending
-
-**Do not recommend a skill based solely on search results.** Always verify:
-
-1. **Install count** — Prefer skills with 1K+ installs. Be cautious with anything under 100.
-2. **Source reputation** — Official sources (`vercel-labs`, `anthropics`, `microsoft`) are more trustworthy than unknown authors.
-3. **GitHub stars** — Check the source repository. A skill from a repo with <100 stars should be treated with skepticism.
-
-### Step 5: Present Options to the User
-
-When you find relevant skills, present them to the user with:
-
-1. The skill name and what it does
-2. The install count and source
-3. The install command they can run
-4. A link to learn more at skills.sh
-
-Example response:
-
-```
-I found a skill that might help! The "react-best-practices" skill provides
-React and Next.js performance optimization guidelines from Vercel Engineering.
-(185K installs)
-
-To install it:
-npx skills add vercel-labs/agent-skills@react-best-practices
-
-Learn more: https://skills.sh/vercel-labs/agent-skills/react-best-practices
-```
-
-### Step 6: Offer to Install
-
-If the user wants to proceed, you can install the skill for them:
-
-```bash
-npx skills add <owner/repo@skill> -g -y
-```
-
-The `-g` flag installs globally (user-level) and `-y` skips confirmation prompts.
-
-## Common Skill Categories
-
-When searching, consider these common categories:
-
-| Category        | Example Queries                          |
-| --------------- | ---------------------------------------- |
-| Web Development | react, nextjs, typescript, css, tailwind |
-| Testing         | testing, jest, playwright, e2e           |
-| DevOps          | deploy, docker, kubernetes, ci-cd        |
-| Documentation   | docs, readme, changelog, api-docs        |
-| Code Quality    | review, lint, refactor, best-practices   |
-| Design          | ui, ux, design-system, accessibility     |
-| Productivity    | workflow, automation, git                |
-
-## Tips for Effective Searches
-
-1. **Use specific keywords**: "react testing" is better than just "testing"
-2. **Try alternative terms**: If "deploy" doesn't work, try "deployment" or "ci-cd"
-3. **Check popular sources**: Many skills come from `vercel-labs/agent-skills` or `ComposioHQ/awesome-claude-skills`
-
-## When No Skills Are Found
-
-If no relevant skills exist:
-
-1. Acknowledge that no existing skill was found
-2. Offer to help with the task directly using your general capabilities
-3. Suggest the user could create their own skill with `npx skills init`
-
-Example:
-
-```
-I searched for skills related to "xyz" but didn't find any matches.
-I can still help you with this task directly! Would you like me to proceed?
-
-If this is something you do often, you could create your own skill:
-npx skills init my-xyz-skill
-```

package/template/.agents/skills/hono/SKILL.md

@@ -1,579 +0,0 @@
----
-name: hono
-description: Use when building Hono web applications or when the user asks about Hono APIs, routing, middleware, JSX, validation, testing, or streaming. TRIGGER when code imports from 'hono' or 'hono/*', or user mentions Hono. Use `npx hono request` to test endpoints.
----
-
-# Hono Skill
-
-Build Hono web applications. This skill provides inline API knowledge for AI. Use `npx hono request` to test endpoints. If the `hono-docs` MCP server is configured, prefer its tools for the latest documentation over the inline reference.
-
-## Hono CLI Usage
-
-### Request Testing
-
-Test endpoints without starting an HTTP server. Uses `app.request()` internally.
-
-```bash
-# GET request
-npx hono request [file] -P /path
-
-# POST request with JSON body
-npx hono request [file] -X POST -P /api/users -d '{"name": "test"}'
-```
-
-**Note:** Do not pass credentials directly in CLI arguments. Use environment variables for sensitive values. `hono request` does not support Cloudflare Workers bindings (KV, D1, R2, etc.). When bindings are required, use `workers-fetch` instead:
-
-```bash
-npx workers-fetch /path
-npx workers-fetch -X POST -H "Content-Type:application/json" -d '{"name":"test"}' /api/users
-```
-
----
-
-## Hono API Reference
-
-### App Constructor
-
-```ts
-import { Hono } from 'hono'
-
-const app = new Hono()
-
-// With TypeScript generics
-type Env = {
-  Bindings: { DATABASE: D1Database; KV: KVNamespace }
-  Variables: { user: User }
-}
-const app = new Hono<Env>()
-```
-
-### Routing Methods
-
-```ts
-app.get('/path', handler)
-app.post('/path', handler)
-app.put('/path', handler)
-app.delete('/path', handler)
-app.patch('/path', handler)
-app.options('/path', handler)
-app.all('/path', handler) // all HTTP methods
-app.on('PURGE', '/path', handler) // custom method
-app.on(['PUT', 'DELETE'], '/path', handler) // multiple methods
-```
-
-### Routing Patterns
-
-```ts
-// Path parameters
-app.get('/user/:name', (c) => {
-  const name = c.req.param('name')
-  return c.json({ name })
-})
-
-// Multiple params
-app.get('/posts/:id/comments/:commentId', (c) => {
-  const { id, commentId } = c.req.param()
-})
-
-// Optional parameters
-app.get('/api/animal/:type?', (c) => c.text('Animal!'))
-
-// Wildcards
-app.get('/wild/*/card', (c) => c.text('Wildcard'))
-
-// Regexp constraints
-app.get('/post/:date{[0-9]+}/:title{[a-z]+}', (c) => {
-  const { date, title } = c.req.param()
-})
-
-// Chained routes
-app
-  .get('/endpoint', (c) => c.text('GET'))
-  .post((c) => c.text('POST'))
-  .delete((c) => c.text('DELETE'))
-```
-
-### Route Grouping
-
-```ts
-// Using route()
-const api = new Hono()
-api.get('/users', (c) => c.json([]))
-
-const app = new Hono()
-app.route('/api', api) // mounts at /api/users
-
-// Using basePath()
-const app = new Hono().basePath('/api')
-app.get('/users', (c) => c.json([])) // GET /api/users
-```
-
-### Error Handling
-
-```ts
-app.notFound((c) => c.json({ message: 'Not Found' }, 404))
-
-app.onError((err, c) => {
-  console.error(err)
-  return c.json({ message: 'Internal Server Error' }, 500)
-})
-```
-
----
-
-## Context (c)
-
-### Response Methods
-
-```ts
-c.text('Hello') // text/plain
-c.json({ message: 'Hello' }) // application/json
-c.html('<h1>Hello</h1>') // text/html
-c.redirect('/new-path') // 302 redirect
-c.redirect('/new-path', 301) // 301 redirect
-c.body('raw body', 200, headers) // raw response
-c.notFound() // 404 response
-```
-
-### Headers & Status
-
-```ts
-c.status(201)
-c.header('X-Custom', 'value')
-c.header('Cache-Control', 'no-store')
-```
-
-### Variables (request-scoped data)
-
-```ts
-// In middleware
-c.set('user', { id: 1, name: 'Alice' })
-
-// In handler
-const user = c.get('user')
-// or
-const user = c.var.user
-```
-
-### Environment (Cloudflare Workers)
-
-```ts
-const value = await c.env.KV.get('key')
-const db = c.env.DATABASE
-c.executionCtx.waitUntil(promise)
-```
-
-### Renderer
-
-```ts
-app.use(async (c, next) => {
-  c.setRenderer((content) =>
-    c.html(
-      <html><body>{content}</body></html>
-    )
-  )
-  await next()
-})
-
-app.get('/', (c) => c.render(<h1>Hello</h1>))
-```
-
----
-
-## HonoRequest (c.req)
-
-```ts
-c.req.param('id') // path parameter
-c.req.param() // all path params as object
-c.req.query('page') // query string parameter
-c.req.query() // all query params as object
-c.req.queries('tags') // multiple values: ?tags=A&tags=B → ['A', 'B']
-c.req.header('Authorization') // request header
-c.req.header() // all headers (keys are lowercase)
-
-// Body parsing
-await c.req.json() // parse JSON body
-await c.req.text() // parse text body
-await c.req.formData() // parse as FormData
-await c.req.parseBody() // parse multipart/form-data or urlencoded
-await c.req.arrayBuffer() // parse as ArrayBuffer
-await c.req.blob() // parse as Blob
-
-// Validated data (used with validator middleware)
-c.req.valid('json')
-c.req.valid('query')
-c.req.valid('form')
-c.req.valid('param')
-
-// Properties
-c.req.url // full URL string
-c.req.path // pathname
-c.req.method // HTTP method
-c.req.raw // underlying Request object
-```
-
----
-
-## Middleware
-
-### Using Built-in Middleware
-
-```ts
-import { cors } from 'hono/cors'
-import { logger } from 'hono/logger'
-import { basicAuth } from 'hono/basic-auth'
-import { prettyJSON } from 'hono/pretty-json'
-import { secureHeaders } from 'hono/secure-headers'
-import { etag } from 'hono/etag'
-import { compress } from 'hono/compress'
-import { poweredBy } from 'hono/powered-by'
-import { timing } from 'hono/timing'
-import { cache } from 'hono/cache'
-import { bearerAuth } from 'hono/bearer-auth'
-import { jwt } from 'hono/jwt'
-import { csrf } from 'hono/csrf'
-import { ipRestriction } from 'hono/ip-restriction'
-import { bodyLimit } from 'hono/body-limit'
-import { requestId } from 'hono/request-id'
-import { methodOverride } from 'hono/method-override'
-import { trailingSlash, trimTrailingSlash } from 'hono/trailing-slash'
-
-// Registration
-app.use(logger()) // all routes
-app.use('/api/*', cors()) // specific path
-app.post('/api/*', basicAuth({ username: 'admin', password: 'secret' }))
-```
-
-### Custom Middleware
-
-```ts
-// Inline
-app.use(async (c, next) => {
-  const start = Date.now()
-  await next()
-  const elapsed = Date.now() - start
-  c.res.headers.set('X-Response-Time', `${elapsed}ms`)
-})
-
-// Reusable with createMiddleware
-import { createMiddleware } from 'hono/factory'
-
-const auth = createMiddleware(async (c, next) => {
-  const token = c.req.header('Authorization')
-  if (!token) return c.json({ error: 'Unauthorized' }, 401)
-  await next()
-})
-
-app.use('/api/*', auth)
-```
-
-### Middleware Execution Order
-
-Middleware executes in registration order. `await next()` calls the next middleware/handler, and code after `next()` runs on the way back:
-
-```
-Request → mw1 before → mw2 before → handler → mw2 after → mw1 after → Response
-```
-
-```ts
-app.use(async (c, next) => {
-  // before handler
-  await next()
-  // after handler
-})
-```
-
----
-
-## Validation
-
-Validation targets: `json`, `form`, `query`, `header`, `param`, `cookie`.
-
-### Zod Validator
-
-```ts
-import { zValidator } from '@hono/zod-validator'
-import { z } from 'zod'
-
-const schema = z.object({
-  title: z.string().min(1),
-  body: z.string()
-})
-
-app.post('/posts', zValidator('json', schema), (c) => {
-  const data = c.req.valid('json') // fully typed
-  return c.json(data, 201)
-})
-```
-
-### Valibot / Standard Schema Validator
-
-```ts
-import { sValidator } from '@hono/standard-validator'
-import * as v from 'valibot'
-
-const schema = v.object({ name: v.string(), age: v.number() })
-
-app.post('/users', sValidator('json', schema), (c) => {
-  const data = c.req.valid('json')
-  return c.json(data, 201)
-})
-```
-
----
-
-## JSX
-
-### Setup
-
-In `tsconfig.json`:
-
-```json
-{
-  "compilerOptions": {
-    "jsx": "react-jsx",
-    "jsxImportSource": "hono/jsx"
-  }
-}
-```
-
-Or use pragma: `/** @jsxImportSource hono/jsx */`
-
-**Important:** Files using JSX must have a `.tsx` extension. Rename `.ts` to `.tsx` or the compiler will fail.
-
-### Components
-
-```tsx
-import type { PropsWithChildren } from 'hono/jsx'
-
-const Layout = (props: PropsWithChildren) => (
-  <html>
-    <head>
-      <title>My App</title>
-    </head>
-    <body>{props.children}</body>
-  </html>
-)
-
-const UserCard = ({ name }: { name: string }) => (
-  <div class="card">
-    <h2>{name}</h2>
-  </div>
-)
-
-app.get('/', (c) => {
-  return c.html(
-    <Layout>
-      <UserCard name="Alice" />
-    </Layout>
-  )
-})
-```
-
-### jsxRenderer Middleware
-
-Use `jsxRenderer` middleware for layouts. See `npx hono docs /docs/middleware/builtin/jsx-renderer` for details.
-
-### Async Components
-
-```tsx
-const UserList = async () => {
-  const users = await fetchUsers()
-  return (
-    <ul>
-      {users.map((u) => (
-        <li>{u.name}</li>
-      ))}
-    </ul>
-  )
-}
-```
-
-### Fragments
-
-```tsx
-const Items = () => (
-  <>
-    <li>Item 1</li>
-    <li>Item 2</li>
-  </>
-)
-```
-
----
-
-## Streaming
-
-```ts
-import { stream, streamText, streamSSE } from 'hono/streaming'
-
-// Basic stream
-app.get('/stream', (c) => {
-  return stream(c, async (stream) => {
-    stream.onAbort(() => console.log('Aborted'))
-    await stream.write(new Uint8Array([0x48, 0x65]))
-    await stream.pipe(readableStream)
-  })
-})
-
-// Text stream
-app.get('/stream-text', (c) => {
-  return streamText(c, async (stream) => {
-    await stream.writeln('Hello')
-    await stream.sleep(1000)
-    await stream.write('World')
-  })
-})
-
-// Server-Sent Events
-app.get('/sse', (c) => {
-  return streamSSE(c, async (stream) => {
-    let id = 0
-    while (true) {
-      await stream.writeSSE({
-        data: JSON.stringify({ time: new Date().toISOString() }),
-        event: 'time-update',
-        id: String(id++)
-      })
-      await stream.sleep(1000)
-    }
-  })
-})
-```
-
----
-
-## Testing with app.request()
-
-Test endpoints without starting an HTTP server:
-
-```ts
-// GET
-const res = await app.request('/posts')
-expect(res.status).toBe(200)
-expect(await res.json()).toEqual({ posts: [] })
-
-// POST with JSON
-const res = await app.request('/posts', {
-  method: 'POST',
-  body: JSON.stringify({ title: 'Hello' }),
-  headers: { 'Content-Type': 'application/json' }
-})
-
-// POST with FormData
-const formData = new FormData()
-formData.append('name', 'Alice')
-const res = await app.request('/users', { method: 'POST', body: formData })
-
-// With mock env (Cloudflare Workers bindings)
-const res = await app.request('/api/data', {}, { KV: mockKV, DATABASE: mockDB })
-
-// Using Request object
-const req = new Request('http://localhost/api', { method: 'DELETE' })
-const res = await app.request(req)
-```
-
----
-
-## Hono Client (RPC)
-
-Type-safe API client using shared types between server and client.
-
-**IMPORTANT: Routes MUST be chained for type inference to work. Without chaining, the client cannot infer route types.**
-
-```ts
-// Server: routes MUST be chained to preserve types
-const route = app
-  .post('/posts', zValidator('json', schema), (c) => {
-    return c.json({ ok: true }, 201)
-  })
-  .get('/posts', (c) => {
-    return c.json({ posts: [] })
-  })
-export type AppType = typeof route
-
-// Client: use hc() with the exported type
-import { hc } from 'hono/client'
-import type { AppType } from './server'
-
-const client = hc<AppType>('http://localhost:8787/')
-const res = await client.posts.$post({ json: { title: 'Hello' } })
-const data = await res.json() // fully typed
-```
-
-Type utilities:
-
-```ts
-import type { InferRequestType, InferResponseType } from 'hono/client'
-
-type ReqType = InferRequestType<typeof client.posts.$post>
-type ResType = InferResponseType<typeof client.posts.$post, 200>
-```
-
----
-
-## Helpers
-
-Helpers are utility functions imported from `hono/<helper-name>`:
-
-```ts
-import { getConnInfo } from 'hono/conninfo'
-import { getCookie, setCookie, deleteCookie } from 'hono/cookie'
-import { css, Style } from 'hono/css'
-import { createFactory } from 'hono/factory'
-import { html, raw } from 'hono/html'
-import { stream, streamText, streamSSE } from 'hono/streaming'
-import { testClient } from 'hono/testing'
-import { upgradeWebSocket } from 'hono/cloudflare-workers' // or other adapter
-```
-
-Available helpers: Accepts, Adapter, ConnInfo, Cookie, css, Dev, Factory, html, JWT, Proxy, Route, SSG, Streaming, Testing, WebSocket.
-
-For details, use `npx hono docs /docs/helpers/<helper-name>`.
-
-### Factory
-
-Use `createFactory` to define `Env` once and share it across app, middleware, and handlers:
-
-```ts
-import { createFactory } from 'hono/factory'
-
-const factory = createFactory<Env>()
-
-// Create app (Env type is inherited)
-const app = factory.createApp()
-
-// Create middleware (Env type is inherited, no need to pass generics)
-const mw = factory.createMiddleware(async (c, next) => {
-  await next()
-})
-
-// Create handlers separately (preserves type inference)
-const handlers = factory.createHandlers(logger(), (c) => c.json({ message: 'Hello' }))
-app.get('/api', ...handlers)
-```
-
----
-
-## Best Practices
-
-- Write handlers inline in route definitions for proper type inference of path params.
-- Use `app.route()` to organize large apps by feature, not Rails-style controllers.
-- Use `createFactory()` to share Env type across app, middleware, and handlers.
-- Use `c.set()`/`c.get()` to pass data between middleware and handlers.
-- Chain validators for multiple request parts (param + query + json).
-- Export app type for RPC: `export type AppType = typeof routes`
-- Use `app.request()` for testing — no server startup needed.
-
-## Adapters
-
-Hono runs on multiple runtimes. The default export works for Cloudflare Workers, Deno, and Bun. For Node.js, use the Node adapter:
-
-```ts
-// Cloudflare Workers / Deno / Bun
-export default app
-
-// Node.js
-import { serve } from '@hono/node-server'
-serve(app)
-```