cue-ai 0.9.0 → 0.9.2

package/resources/skills/skills/strapi/strapi-cli/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: strapi-cli
+description: 'Use when user says "Strapi CLI", "create a Strapi app", "strapi develop", "build/start Strapi", or "export/import Strapi data". Scaffold and run a Strapi v5 project.'
+tags: [strapi, cli, cms, scaffolding, headless-cms]
+---
+
+# Strapi CLI
+
+Scaffold, run, and manage a Strapi v5 project from the command line.
+
+## Use This Skill For
+
+- Creating a new Strapi project
+- Running the dev server, building, and starting in production
+- Exporting / importing / transferring content between environments
+- Generating APIs, types, and listing routes/services
+- Managing admin users from the terminal
+
+## Prerequisites
+
+- Node.js LTS and a package manager (`yarn` recommended; `npm` works but
+  hides prompts for interactive commands like `admin:create-user`)
+- Scaffolder: `create-strapi` (run via `npx`, no global install)
+- In-project CLI: `@strapi/strapi`, invoked as `npm run strapi`,
+  `yarn strapi`, or `npx strapi`
+
+## Create a Project
+
+```bash
+npx create-strapi@latest my-strapi-project
+cd my-strapi-project
+npm run develop        # admin panel → http://localhost:1337/admin
+```
+
+`strapi new`, `strapi install`, and `strapi watch-admin` from v4 were
+removed in v5. Use `create-strapi` to scaffold and `develop` for watch mode.
+
+## Command Reference
+
+The local `strapi` binary takes a category of subcommands. Prefix with your
+package manager (`npm run strapi <cmd>` / `yarn strapi <cmd>`).
+
+### Development
+
+| Command | What it does |
+|---|---|
+| `strapi develop` | Dev server with file watcher + auto-restart. Content-Type Builder is available here. Add `--no-watch-admin` to disable admin hot reload. |
+| `strapi start` | Production-style run. Content-Type Builder is disabled (no restarts). |
+| `strapi build` | Build the admin panel for production. |
+| `strapi console` | Open a REPL with the `strapi` instance loaded. |
+
+### Data management
+
+| Command | What it does |
+|---|---|
+| `strapi export` | Export content + config to `.tar` (optionally `.gz`, `.enc`). |
+| `strapi import` | Import an export archive or unpacked directory (`-f <file>`). |
+| `strapi transfer` | Stream data directly between two Strapi instances. |
+
+### Code generation
+
+| Command | What it does |
+|---|---|
+| `strapi generate` | Interactive generator: API, controller, service, content-type, plugin, policy, middleware. |
+| `strapi ts:generate-types` | Regenerate TypeScript types from the schema. |
+| `strapi openapi generate` | Emit an OpenAPI spec for your content API. |
+
+### Cloud
+
+| Command | What it does |
+|---|---|
+| `strapi login` / `logout` | Authenticate with Strapi Cloud. |
+| `strapi deploy` | Deploy the project to Strapi Cloud. |
+
+### Listing & admin
+
+- `strapi routes:list`, `policies:list`, `middlewares:list`,
+  `content-types:list`, `controllers:list`, `services:list`
+- `strapi admin:create-user`, `admin:reset-user-password`,
+  `admin:list-users` (use `yarn`, not `npm`, so prompts render)
+
+## Rules
+
+- Use `develop` while modeling content; `start` for production runs only.
+- Run interactive admin commands with `yarn`, never `npm` (npm swallows the
+  prompts).
+- Treat exports as backups before a risky migration or upgrade.
+- Never commit the generated `.env`, `APP_KEYS`, or admin tokens.
+
+## Next Step
+
+After the server is up, model content with `building-with-strapi`, or wire
+an AI client with `strapi-mcp-setup`.

package/resources/skills/skills/strapi/strapi-content-api/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: strapi-content-api
+description: 'Use when consuming a Strapi v5 backend over HTTP: REST endpoints, the populate/filters/sort/pagination params, GraphQL setup, API tokens, and permissions.'
+tags: [strapi, rest-api, graphql, content-api, headless-cms]
+---
+
+# Strapi Content API
+
+Query a Strapi v5 backend from a storefront, app, or script over REST or
+GraphQL.
+
+## Use This Skill For
+
+- Calling the auto-generated REST endpoints
+- Shaping responses with `populate`, `fields`, `filters`, `sort`, pagination
+- Setting up and querying GraphQL
+- Authenticating with API tokens and granting the right permissions
+
+## Prerequisites
+
+- A running Strapi instance (default `http://localhost:1337`)
+- For protected data: an API token from admin → Settings → API Tokens
+- For GraphQL: the `@strapi/plugin-graphql` package installed
+
+## REST Endpoints
+
+Strapi generates REST routes per content-type. Use the `pluralApiId` for
+collection types and `singularApiId` for single types.
+
+| Method | Collection route | Action |
+|---|---|---|
+| GET | `/api/:pluralApiId` | List documents |
+| POST | `/api/:pluralApiId` | Create a document |
+| GET | `/api/:pluralApiId/:documentId` | Get one document |
+| PUT | `/api/:pluralApiId/:documentId` | Update a document |
+| DELETE | `/api/:pluralApiId/:documentId` | Delete a document |
+
+Single types drop the `documentId` segment (e.g. `GET /api/homepage`).
+Entries are addressed by their 24-char `documentId`, not numeric `id`.
+
+```bash
+# list, then fetch one
+curl http://localhost:1337/api/restaurants
+curl http://localhost:1337/api/restaurants/abc123documentid
+```
+
+A list response wraps results in `{ data, meta }`, where `meta.pagination`
+carries page info.
+
+## Query Parameters
+
+Nothing populates by default; relations, media, components, and dynamic
+zones come back only when you ask, and only if the role has find permission
+on them.
+
+```bash
+# populate relations + pick fields
+curl "http://localhost:1337/api/restaurants?populate=*"
+curl "http://localhost:1337/api/restaurants?populate[chef][fields][0]=name&fields[0]=title"
+
+# filter, sort, paginate
+curl "http://localhost:1337/api/restaurants?filters[city][\$eq]=Paris"
+curl "http://localhost:1337/api/restaurants?sort=title:asc&pagination[page]=1&pagination[pageSize]=10"
+
+# draft & publish
+curl "http://localhost:1337/api/restaurants?status=published"
+```
+
+Common filter operators: `$eq`, `$ne`, `$lt`, `$gt`, `$contains`,
+`$containsi`, `$in`, `$null`. Combine with `$and` / `$or`.
+
+## GraphQL
+
+```bash
+yarn add @strapi/plugin-graphql      # or: npm install @strapi/plugin-graphql
+```
+
+One endpoint serves everything: `/graphql` (default). The playground is at
+the same URL in dev. Dynamic zones are union types, so query their fields
+with inline fragments (`... on ComponentCategoryName`).
+
+```graphql
+query {
+  restaurants(filters: { city: { eq: "Paris" } }, sort: "title:asc") {
+    documentId
+    title
+    chef { name }
+  }
+}
+```
+
+## Authentication & Permissions
+
+- **Public role**: grant find/findOne per content-type in admin → Settings
+  → Users & Permissions → Roles for unauthenticated reads.
+- **API tokens**: send `Authorization: Bearer <token>` for read-only,
+  full-access, or custom-scoped server-to-server calls.
+
+```bash
+curl -H "Authorization: Bearer $STRAPI_TOKEN" http://localhost:1337/api/orders
+```
+
+## Rules
+
+- Address entries by `documentId`.
+- Add `populate`/`fields` explicitly and grant matching permissions, or
+  relations return empty.
+- Never ship a full-access token to a browser client; use the public role or
+  a narrowly scoped read-only token.
+- URL-encode filter operators (`$eq`) in shells.
+
+## Next Step
+
+For AI clients that manage content directly instead of raw HTTP, set up
+`strapi-mcp-setup`.

package/resources/skills/skills/strapi/strapi-deploy/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: strapi-deploy
+description: 'Use when deploying a Strapi v5 backend: Strapi Cloud via the CLI, or self-hosting with NODE_ENV=production build/start, pm2, env vars, and a production database.'
+tags: [strapi, deployment, strapi-cloud, self-host, pm2]
+---
+
+# Strapi Deploy
+
+Deploy a Strapi v5 project to Strapi Cloud or your own server.
+
+## Use This Skill For
+
+- Deploying to Strapi Cloud from the CLI
+- Self-hosting: production build, start, process management, env config
+- Moving content between environments
+
+## Prerequisites
+
+- A built project (`npm run build`) that runs locally
+- For Cloud: a Strapi Cloud account and the project-local `strapi` CLI
+- For self-host: Node.js LTS on the server, a production database, and a
+  process manager (`pm2` recommended)
+
+## Option A: Strapi Cloud
+
+```bash
+npm run strapi login     # or: yarn strapi login
+npm run strapi deploy
+```
+
+Cloud handles the build, database, and hosting. Use this when you want the
+fastest path and do not need to manage infrastructure.
+
+## Option B: Self-Host
+
+### 1. Configure for production
+
+Set production env vars (never commit them): `NODE_ENV=production`,
+`APP_KEYS`, `API_TOKEN_SALT`, `ADMIN_JWT_SECRET`, `JWT_SECRET`, and the
+database connection (`DATABASE_*`). Point `config/database.ts` at a real
+database (PostgreSQL/MySQL), not SQLite, for production.
+
+### 2. Build
+
+```bash
+NODE_ENV=production npm run build      # or: yarn build
+```
+
+On Windows, wrap with cross-env: `cross-env NODE_ENV=production npm run build`.
+
+### 3. Start
+
+```bash
+NODE_ENV=production npm run start      # or: yarn start
+```
+
+### 4. Keep it running with pm2
+
+```bash
+npm install -g pm2
+pm2 start npm --name strapi -- run start
+pm2 save
+pm2 startup            # generate the boot script
+```
+
+Put a reverse proxy (nginx/Traefik) in front for TLS. If you self-host on
+Coolify, the `coolify` skill covers the container + proxy + env workflow.
+
+## Moving Content Between Environments
+
+```bash
+# back up before deploy
+npm run strapi export -- --file backup.tar.gz
+
+# or stream straight to another instance
+npm run strapi transfer -- --to https://prod.example.com/admin
+```
+
+## Rules
+
+- Production runs with `NODE_ENV=production`; SQLite is for local dev only.
+- All secrets come from env on the server, never the repo.
+- Build before start; a stale or missing admin build serves a broken panel.
+- Export (or transfer) as a backup before every production deploy.
+
+## Next Step
+
+After deploy, verify the live API with `strapi-content-api`, or wire the
+production MCP endpoint with `strapi-mcp-setup`.

package/resources/skills/skills/strapi/strapi-mcp-setup/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: strapi-mcp-setup
+description: 'Use when connecting an AI client to Strapi over MCP: the built-in content-management MCP server and the Kapa-powered Strapi Docs MCP server. Covers enabling, tokens, wiring.'
+tags: [strapi, mcp, ai, content-management, claude-code]
+---
+
+# Strapi MCP Setup
+
+Wire an AI client (Claude Code, Cursor, Claude Desktop) to Strapi's two MCP
+servers.
+
+## The Two Servers
+
+| Server | Purpose | Auth | Endpoint |
+|---|---|---|---|
+| **strapi-mcp** | Create/read/update/delete/publish content in *your* Strapi | Admin API token | `<your-strapi>/mcp` |
+| **strapi-docs** | Query the Strapi documentation for accurate, current answers | None | `https://strapi-docs.mcp.kapa.ai` |
+
+The `strapi` cue profile wires both already (`mcps: [strapi-docs, strapi-mcp]`).
+This skill covers turning them on and authenticating.
+
+## Prerequisites
+
+- For **strapi-mcp**: a running Strapi **v5.47.0+** instance and an Admin API
+  token. The content tools available depend on that token's permissions.
+- For **strapi-docs**: nothing, it is hosted and unauthenticated.
+- Optional manual wiring uses `npx mcp-remote`.
+
+## strapi-mcp (content management)
+
+### 1. Enable the server
+
+Add the `mcp` block to your Strapi server config and restart:
+
+```ts title="config/server.ts"
+export default ({ env }) => ({
+  host: env('HOST', '0.0.0.0'),
+  port: env.int('PORT', 1337),
+  app: { keys: env.array('APP_KEYS') },
+  mcp: { enabled: true },
+});
+```
+
+The endpoint becomes available at `/mcp` (e.g. `http://localhost:1337/mcp`).
+It uses Streamable HTTP, is stateless, and only accepts POST (GET/DELETE
+return 405).
+
+### 2. Create an Admin token
+
+Admin panel → **Settings → API Tokens → Create new token**. Scope it to the
+content actions you want the AI to perform. Copy the value once.
+
+### 3. Connect Claude Code
+
+```bash
+claude mcp add strapi-mcp --transport http http://localhost:1337/mcp \
+  -H "Authorization: Bearer YOUR_ADMIN_TOKEN"
+```
+
+Restart Claude Code, then run `/mcp` to confirm `strapi-mcp` is connected.
+
+### Via the cue profile
+
+The profile's registry entry reads two env vars. Set them (profile `env:` or
+your shell) before materializing:
+
+```bash
+export STRAPI_URL="http://localhost:1337"
+export STRAPI_ADMIN_TOKEN="paste-admin-token-here"
+```
+
+The entry expands to an HTTP server at `${STRAPI_URL}/mcp` with the bearer
+header. Permission changes (revoking/editing the token) take effect on the
+next request, there is no session to restart.
+
+## strapi-docs (documentation)
+
+Zero-config. The cue profile wires it as an HTTP MCP at
+`https://strapi-docs.mcp.kapa.ai`. To add it elsewhere manually:
+
+```json title=".cursor/mcp.json or .vscode/mcp.json (servers→type http)"
+{ "mcpServers": { "strapi-docs": { "url": "https://strapi-docs.mcp.kapa.ai" } } }
+```
+
+Tip: prefix doc questions with `Use the strapi-docs MCP server to answer:` so
+the model queries live docs instead of stale training data.
+
+## Rules
+
+- Scope the Admin token to the minimum actions the AI needs; it gates every
+  content tool.
+- Never commit the Admin token; pass it through env (`STRAPI_ADMIN_TOKEN`).
+- strapi-mcp needs the server running and v5.47+; until then it errors, 
+  strapi-docs still works standalone.
+- The content MCP is Beta; verify destructive actions (delete/unpublish)
+  before letting an agent run them unattended.
+
+## Next Step
+
+Once connected, use `building-with-strapi` for the data model the MCP tools
+operate on, or `strapi-content-api` to consume the same content over HTTP.

package/resources/skills/skills/strapi/strapi-plugins/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: strapi-plugins
+description: 'Use when developing a Strapi v5 plugin: scaffolding with @strapi/sdk-plugin, the server + admin panel structure, registering it, and building/publishing.'
+tags: [strapi, plugins, sdk-plugin, backend, admin-panel]
+---
+
+# Strapi Plugins
+
+Build a Strapi v5 plugin to extend the server, the admin panel, or both.
+
+## Use This Skill For
+
+- Scaffolding a new plugin with the Plugin SDK
+- Understanding the server-side vs admin-side structure
+- Registering a local plugin and building it for publish
+
+## Prerequisites
+
+- A Strapi v5 project to host the plugin during development
+- The Plugin SDK: `@strapi/sdk-plugin` (run via `npx` / `yarn dlx`)
+- For installing community plugins instead of writing one, use the
+  Marketplace npx command shown on each plugin's page
+
+## Scaffold
+
+```bash
+npx @strapi/sdk-plugin@latest init my-strapi-plugin
+# or: yarn dlx @strapi/sdk-plugin init my-strapi-plugin
+```
+
+This generates a plugin package with separate server and admin entry points.
+Keep each concern in its own folder (the generated layout) rather than one
+entry file.
+
+```
+my-strapi-plugin/
+├── admin/src/         admin panel UI (React) — index.ts register()/bootstrap()
+├── server/src/        controllers, services, routes, content-types, register/bootstrap
+├── strapi-server.ts   server entry
+├── strapi-admin.ts    admin entry
+└── package.json
+```
+
+## Plugin SDK Commands
+
+| Command | What it does |
+|---|---|
+| `@strapi/sdk-plugin init <name>` | Scaffold a new plugin package |
+| `strapi-plugin build` | Build the plugin for publishing |
+| `strapi-plugin watch` | Rebuild on change during development |
+| `strapi-plugin verify` | Check the package is publish-ready |
+
+You can also scaffold individual pieces inside a host project with
+`strapi generate plugin`.
+
+## Register a Local Plugin
+
+Enable the plugin in the host project's plugins config:
+
+```ts title="config/plugins.ts"
+export default {
+  'my-plugin': {
+    enabled: true,
+    resolve: './src/plugins/my-strapi-plugin', // local path
+  },
+};
+```
+
+Server code reaches Strapi through `strapi` (e.g.
+`strapi.documents(...)`, `strapi.plugin('my-plugin').service('x')`). Admin
+code registers menu links, settings pages, and injection zones in
+`admin/src/index.ts`.
+
+## Build & Publish
+
+```bash
+cd my-strapi-plugin
+npm run build          # strapi-plugin build
+npm publish            # to NPM, then optionally submit to the Marketplace
+```
+
+Upgrading the SDK across majors (e.g. v5 → v6) can change config; check the
+plugin's create-a-plugin guide before bumping.
+
+## Rules
+
+- Split server and admin concerns into their folders; do not cram everything
+  into one entry file.
+- Use the Document Service from server code, not raw DB access, unless you
+  need the lower level.
+- `enabled: true` plus a `resolve` path is required for local plugins to load.
+- Run `verify` before publishing to catch a malformed package.
+
+## Next Step
+
+Model the content your plugin operates on with `building-with-strapi`, or ship
+the project with `strapi-deploy`.

package/resources/skills/skills/tools/context7/SKILL.md

@@ -0,0 +1,101 @@
+---
+name: context7
+description: Fetch up-to-date, version-specific library/API docs to avoid outdated or hallucinated APIs. Use when the user says "use context7", "latest docs for X", or codes against a fast-moving library.
+allowed-tools: Bash(ctx7:*), Bash(npx:*)
+category: tools
+tags: [tools, documentation, context7, mcp, libraries]
+metadata:
+  version: 1.0.0
+  homepage: https://context7.com
+---
+
+# Up-to-date library docs with Context7
+
+Context7 pulls version-specific documentation and real code examples from a
+library's source and drops them into context. It kills the two failure modes of
+training-data answers: outdated APIs, and hallucinated methods that don't exist.
+
+Two surfaces, same data. Use whichever is wired:
+
+- **MCP** (`context7` server, ships in `core`): call `resolve-library-id`, then
+  `query-docs`. No shell needed.
+- **CLI** (`ctx7`): same lookups from the terminal.
+
+## Prerequisites
+
+The `context7` MCP ships in cue's `core` profile (no API key needed). For the
+standalone CLI:
+
+```bash
+npm install -g ctx7    # or run on demand with: npx ctx7 <cmd>
+```
+
+For higher rate limits, get a free key at https://context7.com/dashboard and set
+`CONTEXT7_API_KEY` in your environment.
+
+## When to reach for it
+
+Pull docs before writing code against any library whose API may have moved since
+your training cutoff: frameworks (Next.js, Remix), SDKs (Supabase, Stripe,
+OpenAI), infra (Cloudflare Workers, Vercel), CSS (Tailwind). If the user names a
+version like "Next.js 15 middleware", Context7 matches that version.
+
+## Step 1: Resolve the library id
+
+A Context7 id looks like `/vercel/next.js` or `/supabase/supabase`. If the user
+already gave one, skip to Step 2.
+
+Via MCP: call `resolve-library-id` with the library name plus the question.
+
+Via CLI:
+
+```bash
+ctx7 library "next.js" "app router middleware"
+```
+
+## Step 2: Fetch the docs
+
+Via MCP: call `query-docs` with the resolved `libraryId` plus the question.
+
+Via CLI:
+
+```bash
+ctx7 docs /vercel/next.js "add middleware that checks a JWT cookie"
+```
+
+Read the returned snippets, then write the implementation against them, not
+against memory.
+
+## Example
+
+User: "Show me the Supabase email/password sign-up API. use context7"
+
+```bash
+# Step 1 — resolve (skip if the id is known)
+ctx7 library "supabase" "email password sign-up"
+# → /supabase/supabase
+
+# Step 2 — fetch version-specific docs
+ctx7 docs /supabase/supabase "email and password sign-up"
+```
+
+Then write the `supabase.auth.signUp(...)` call straight from the returned
+snippet.
+
+## Rules
+
+- **Resolve before querying.** A bare library name needs `resolve-library-id`
+  first; `query-docs` takes a Context7 id, not a name.
+- **Pass the version when the user gives one.** "Next.js 14" and "Next.js 15"
+  return different docs; include it in the query.
+- **Prefer the MCP when it is loaded** (it is in `core`); fall back to the
+  `ctx7` CLI only when the MCP tools are not available.
+- **Quote, do not paraphrase from memory.** The point of Context7 is the fetched
+  snippet; write code against what it returns, not what you recall.
+- **No key is fine.** It works unauthenticated at lower rate limits; only add
+  `CONTEXT7_API_KEY` if you hit limits.
+
+## Next step
+
+Name the library plus task ("Supabase email/password sign-up", "Cloudflare
+Worker caching JSON for 5 min") and run Step 1 to resolve its id.

package/resources/skills/skills/tools/opensrc/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: opensrc
-description: Fetch dependency source code to give AI agents deeper implementation context. Use when the agent needs to understand how a library works internally, read source code for a package, fetch implementation details for a dependency, or explore how an npm/PyPI/crates.io package is built. Triggers include "fetch source for", "read the source of", "how does X work internally", "get the implementation of", "opensrc path", or any task requiring access to dependency source code beyond types and docs.
+description: Fetch dependency source code so agents read real implementations, not just types and docs — clones npm/PyPI/crates.io/GitHub packages at the right version and caches them locally. Use when the user says "fetch source for", "read the source of", "get the implementation of", "how does X work internally", or "opensrc path", or whenever a task needs to inspect a dependency's actual code beyond its public types.
 allowed-tools: Bash(opensrc:*)
 category: tools
 tags: [tools, source-fetching, dependencies, npm, pypi, crates]