@mragentix/cli 4.2.39 → 4.2.53

package/defaults/skills/firebase.md

@@ -0,0 +1,83 @@
+---
+name: firebase
+description: Firebase — hosting, Cloud Functions, Firestore, emulators, auth
+---
+
+You are now equipped with Firebase CLI expertise.
+
+## Prerequisites
+
+Ensure Firebase CLI is installed (`npm i -g firebase-tools`) and authenticated (`firebase login`). For CI: `firebase login:ci` or `firebase login --no-localhost`.
+
+## Project Setup
+
+- Initialize: `firebase init` (interactive wizard for Hosting, Firestore, Functions, Emulators, etc.)
+- Initialize specific feature: `firebase init hosting` / `firebase init functions` / `firebase init emulators`
+- Set active project: `firebase use <project-id>`
+- Add project alias: `firebase use --add` (e.g., dev, staging, prod — stored in `.firebaserc`)
+- List projects: `firebase projects:list`
+- Create project: `firebase projects:create <project-id> --display-name "My App"`
+
+## Deploying
+
+- Deploy everything: `firebase deploy`
+- Deploy only specific services (RECOMMENDED for safety):
+  - `firebase deploy --only hosting`
+  - `firebase deploy --only functions`
+  - `firebase deploy --only functions:myFunction` (single function)
+  - `firebase deploy --only firestore:rules`
+  - `firebase deploy --only firestore:indexes`
+  - `firebase deploy --only storage`
+- Deploy with message: `firebase deploy --only hosting -m "v1.2.0"`
+- Preview channel: `firebase hosting:channel:deploy staging` (creates temporary preview URL)
+- List preview channels: `firebase hosting:channel:list`
+
+Always use `--only` in production to avoid deploying unready changes to other services.
+
+## Local Development (Emulators)
+
+- Start all configured emulators: `firebase emulators:start`
+- Start specific ones: `firebase emulators:start --only auth,firestore,functions`
+- Run tests against emulators: `firebase emulators:exec "npm test"`
+- Persist data between sessions: `firebase emulators:start --import ./data --export-on-exit`
+- Export data: `firebase emulators:export ./emulator-data`
+
+Available emulators: auth, firestore, database, functions, hosting, pubsub, storage, eventarc.
+Use `firebase emulators:start` instead of the legacy `firebase serve`.
+
+## Cloud Functions
+
+- Deploy all: `firebase deploy --only functions`
+- Deploy one: `firebase deploy --only functions:functionName`
+- View logs: `firebase functions:log` or `firebase functions:log --only functionName`
+- Delete: `firebase functions:delete functionName`
+- Interactive shell: `firebase functions:shell`
+- Functions v2 (Cloud Run-based) uses `defineSecret()` and `defineString()` for config.
+
+## Firestore
+
+- Deploy rules: `firebase deploy --only firestore:rules`
+- Deploy indexes: `firebase deploy --only firestore:indexes`
+- Delete collection: `firebase firestore:delete <collection-path> --recursive`
+- Always test rules in emulator before deploying.
+
+## Hosting
+
+- Deploy: `firebase deploy --only hosting`
+- Preview channel: `firebase hosting:channel:deploy staging`
+- Disable: `firebase hosting:disable`
+- Multi-site: configure in `firebase.json` under `"hosting"` as array with `"site"` keys.
+
+## Auth
+
+- Export users: `firebase auth:export users.json`
+- Import users: `firebase auth:import users.json --hash-algo=BCRYPT`
+
+## Key Gotchas
+
+- Cloud Functions require the Blaze (pay-as-you-go) plan. Spark (free) doesn't support deploying functions.
+- Emulator ports are configured in `firebase.json`. Defaults: Auth(9099), Firestore(8080), Functions(5001), Hosting(5000), UI(4000).
+- Emulator data is ephemeral by default. Use `--import`/`--export-on-exit` for persistence.
+- Project aliases simplify multi-environment workflows. Use `firebase use staging` to switch.
+- For GitHub Actions CI: use `FirebaseExtended/action-hosting-deploy@v0`.
+- Functions v2 env vars: use `defineSecret('SECRET_NAME')` + Google Cloud Secret Manager.

package/defaults/skills/gh.md

@@ -0,0 +1,91 @@
+---
+name: gh
+description: GitHub CLI — repos, PRs, issues, actions, gists, API calls
+---
+
+You are now equipped with GitHub CLI (gh) expertise.
+
+## Prerequisites
+
+Ensure gh is installed (`sudo apt install gh`) and authenticated (`gh auth login`). Check with `gh auth status`. For CI: set `GITHUB_TOKEN` env var.
+
+## Repositories
+
+- Create (interactive): `gh repo create`
+- Create public from current dir: `gh repo create myapp --public --source . --push`
+- Create private: `gh repo create myapp --private`
+- Clone: `gh repo clone owner/repo`
+- Shallow clone: `gh repo clone owner/repo -- --depth 1`
+- Fork: `gh repo fork owner/repo --clone`
+- View in browser: `gh repo view --web`
+- List repos: `gh repo list --limit 50 --json name,url`
+- Delete: `gh repo delete owner/repo --yes`
+
+## Pull Requests
+
+- Create (interactive): `gh pr create`
+- Create with details: `gh pr create --title "Add login" --body "Implements #42"`
+- Create draft: `gh pr create --draft`
+- Create with reviewers: `gh pr create --title "Fix" --reviewer user1,user2`
+- List: `gh pr list` / `gh pr list --author @me` / `gh pr list --label bug`
+- View: `gh pr view 123` / `gh pr view 123 --web`
+- Checkout locally: `gh pr checkout 123`
+- Review: `gh pr review 123 --approve` / `--request-changes --body "msg"` / `--comment --body "msg"`
+- Merge: `gh pr merge 123 --squash --delete-branch`
+- Check CI status: `gh pr checks 123` / `gh pr checks 123 --watch`
+- View diff: `gh pr diff 123`
+
+## Issues
+
+- Create: `gh issue create --title "Bug" --body "Steps..." --label bug --assignee @me`
+- List: `gh issue list` / `gh issue list --label enhancement --assignee @me`
+- View: `gh issue view 42` / `gh issue view 42 --web`
+- Close: `gh issue close 42`
+- Comment: `gh issue comment 42 --body "Working on this"`
+
+## GitHub Actions
+
+- List runs: `gh run list --limit 10`
+- List for workflow: `gh run list --workflow ci.yml`
+- View run: `gh run view <id>` / `gh run view <id> --web`
+- Watch run: `gh run watch <id>`
+- Re-run failed: `gh run rerun <id> --failed`
+- Download artifacts: `gh run download <id>`
+- Manually trigger workflow: `gh workflow run deploy.yml --ref main -f environment=staging`
+- List workflows: `gh workflow list`
+
+## API Calls
+
+- REST GET: `gh api repos/owner/repo`
+- REST POST: `gh api repos/owner/repo/issues --method POST -f title="New" -f body="Details"`
+- GraphQL: `gh api graphql -f query='{ viewer { login } }'`
+- With jq filtering: `gh api repos/owner/repo --jq '.stargazers_count'`
+- Paginate: `gh api repos/owner/repo/issues --paginate`
+
+## Gists
+
+- Create from file: `gh gist create script.sh`
+- Create public: `gh gist create --public notes.md`
+- List: `gh gist list`
+
+## Extensions
+
+- Install: `gh extension install dlvhdr/gh-dash`
+- List installed: `gh extension list`
+- Upgrade all: `gh extension upgrade --all`
+
+## JSON Output
+
+Most commands support `--json` for machine-readable output:
+- `gh pr list --json number,title,author`
+- `gh issue list --json number,title,labels --jq '.[].title'`
+- `gh repo view --json name,description,stargazerCount`
+
+## Key Gotchas
+
+- Default auth scopes are minimal. Refresh for more: `gh auth refresh -s repo,read:org,workflow`
+- Inside a git repo, gh infers owner/repo from remotes. Override with `--repo owner/repo`.
+- Use `GH_PAGER=cat` to disable pager for scripting.
+- `gh api` handles auth automatically — use it for any REST/GraphQL endpoint.
+- Useful aliases: `gh alias set prc 'pr create --fill'`
+- Set secrets: `gh secret set KEY < value.txt` for GitHub Actions secrets.

package/defaults/skills/gws.md

@@ -0,0 +1,72 @@
+---
+name: gws
+description: Google Workspace CLI — Drive, Gmail, Sheets, Calendar, Chat operations
+---
+
+You are now equipped with Google Workspace CLI (gws) expertise.
+
+## Prerequisites
+
+Ensure gws is installed (`npm i -g @anthropic-ai/gws`), authenticated (`gws auth login`), and a Google Cloud project with OAuth credentials is configured. Check with `gws auth status`.
+
+## Auth
+
+- Login with specific scopes: `gws auth login -s drive,gmail,sheets,calendar`
+- Login with all scopes: `gws auth login -s drive,gmail,sheets,calendar,chat,admin,docs`
+- Check status: `gws auth status`
+- Logout: `gws auth logout`
+
+## Drive
+
+- List files: `gws drive list`
+- Search: `gws drive list --query "name contains 'report'"`
+- Download: `gws drive download <file-id>`
+- Upload: `gws drive upload ./file.pdf`
+- Create folder: `gws drive create-folder "Project Assets"`
+- Move file: `gws drive move <file-id> --to <folder-id>`
+- Delete: `gws drive delete <file-id>`
+
+## Sheets
+
+- Read sheet: `gws sheets get <spreadsheet-id>`
+- Read specific range: `gws sheets get <spreadsheet-id> --range "Sheet1!A1:D10"`
+- Write data: `gws sheets update <spreadsheet-id> --range "Sheet1!A1" --values '[["Name","Score"],["Alice",95]]'`
+- Append rows: `gws sheets append <spreadsheet-id> --range "Sheet1" --values '[["Bob",88]]'`
+- Create new spreadsheet: `gws sheets create "Budget 2025"`
+
+## Gmail
+
+- List recent messages: `gws gmail list`
+- Search: `gws gmail list --query "from:boss@company.com is:unread"`
+- Read message: `gws gmail get <message-id>`
+- Send email: `gws gmail send --to user@example.com --subject "Hello" --body "Message body"`
+- Search with filters: `gws gmail search "has:attachment after:2024/01/01"`
+
+## Calendar
+
+- List upcoming events: `gws calendar list`
+- List in date range: `gws calendar list --start 2025-01-01 --end 2025-01-31`
+- Create event: `gws calendar create --title "Team Standup" --start "2025-01-15T09:00:00" --end "2025-01-15T09:30:00"`
+- Delete event: `gws calendar delete <event-id>`
+
+## Chat
+
+- List spaces: `gws chat spaces`
+- Send message: `gws chat send --space <space-id> --text "Hello team"`
+- List messages: `gws chat messages --space <space-id>`
+
+## Utilities
+
+- Inspect API schemas: `gws schema`
+- Dry-run mode: `gws drive list --dry-run`
+- Auto-paginate: `gws drive list --page-all`
+- JSON output: `gws drive list --json`
+
+## Key Gotchas
+
+- Requires a Google Cloud project with appropriate APIs enabled and OAuth credentials.
+- Only request scopes you need. Google enforces 25-scope limit for unverified apps.
+- Tokens refresh automatically but revoked access requires re-login.
+- Use `--dry-run` before destructive operations.
+- Use `--page-all` carefully on large datasets — many API calls without automatic backoff.
+- Sheets can serve as a lightweight database for prototypes and dashboards.

package/defaults/skills/netlify.md

@@ -0,0 +1,69 @@
+---
+name: netlify
+description: Deploy to Netlify — functions, forms, edge, preview URLs
+---
+
+You are now equipped with Netlify CLI expertise. Use this knowledge to deploy and manage Netlify projects.
+
+## Prerequisites
+
+Ensure Netlify CLI is installed (`npm i -g netlify-cli`) and authenticated (`netlify login`). Check with `netlify status`.
+
+## Deploying
+
+- For a **draft/preview deployment**: `netlify deploy` — creates a unique preview URL.
+- For **production**: `netlify deploy --prod`
+- Deploy a specific directory (skip build): `netlify deploy --dir build --no-build`
+- Deploy with functions: `netlify deploy --functions my-functions`
+- Add a deploy message: `netlify deploy --message "Release v1.2.3"`
+- Deploy and open in browser: `netlify deploy --prod --open`
+- Trigger remote build without uploading: `netlify deploy --trigger`
+- For CI: `netlify deploy --prod --auth $NETLIFY_AUTH_TOKEN --site $NETLIFY_SITE_ID`
+
+## Project Setup
+
+- Initialize continuous deployment: `netlify init`
+- Link to existing project: `netlify link`
+- Unlink: `netlify unlink`
+- Start local dev server: `netlify dev` (auto-detects framework)
+- Dev with custom command: `netlify dev -c "hugo server -w" --target-port 1313`
+- Public live session with tunnel URL: `netlify dev --live`
+- Build locally like Netlify: `netlify build`
+
+## Functions
+
+- Create a function from template: `netlify functions:create --name my-function`
+- List functions: `netlify functions:list`
+- Test locally during dev: `netlify functions:invoke my-function --payload '{"key":"value"}'`
+- Build functions: `netlify functions:build`
+
+## Environment Variables
+
+- List all: `netlify env:list`
+- Get: `netlify env:get MY_VAR`
+- Set: `netlify env:set MY_VAR "value"`
+- Remove: `netlify env:unset MY_VAR`
+- Import from file: `netlify env:import .env`
+- Clone to another project: `netlify env:clone --to <target-id>`
+
+## Logs
+
+- Deploy build logs: `netlify logs:deploy`
+- Function logs: `netlify logs:function` or `netlify logs:function my-function`
+
+## Sites
+
+- Create: `netlify sites:create --name my-site`
+- List: `netlify sites:list`
+- Open dashboard: `netlify open` / `netlify open:admin`
+- Watch deploy finish: `netlify watch`
+
+## Key Gotchas
+
+- `netlify deploy` = draft. `netlify deploy --prod` = production. Drafts are great for QA.
+- Functions directory defaults to `netlify/functions/`. Override in `netlify.toml` or with `--functions`.
+- Edge Functions live in `netlify/edge-functions/` (Deno-based). Debug with `netlify dev --edge-inspect`.
+- `netlify.toml` is the primary config: build commands, redirects, headers, plugins.
+- Context-aware env vars: use `--context production|deploy-preview|branch-deploy|dev`.
+- `netlify serve` builds for production and serves locally (unlike `netlify dev`, no watch).
+- Monorepo: use `--filter <app>` on most commands.

package/defaults/skills/prisma.md

@@ -0,0 +1,62 @@
+---
+name: prisma
+description: Prisma — schema management, migrations, generate client, studio
+---
+
+You are now equipped with Prisma CLI expertise.
+
+## Prerequisites
+
+Ensure Prisma is installed (`npm i -D prisma @prisma/client`) and `DATABASE_URL` is set in `.env`. Use `npx prisma` to run commands.
+
+## Project Setup
+
+- Initialize: `npx prisma init` (creates `prisma/schema.prisma` + `.env`)
+- With specific DB: `npx prisma init --datasource-provider postgresql` (mysql|postgresql|sqlite|sqlserver|mongodb)
+- Validate schema: `npx prisma validate`
+- Format schema: `npx prisma format`
+
+## Local Development Workflow
+
+1. Edit `prisma/schema.prisma` to define/change models
+2. Create and apply migration: `npx prisma migrate dev --name <descriptive_name>`
+3. Generate client: `npx prisma generate` (happens automatically with migrate dev)
+4. Open data browser: `npx prisma studio` (port 5555)
+
+For rapid prototyping (no migration files): `npx prisma db push`
+
+## Migrations
+
+- Create + apply (dev only): `npx prisma migrate dev --name add_user_table`
+- Apply pending in production: `npx prisma migrate deploy` (NEVER use migrate dev in production)
+- Check status: `npx prisma migrate status`
+- Reset database (DESTRUCTIVE): `npx prisma migrate reset`
+- Resolve failed migration: `npx prisma migrate resolve --applied <migration_id>`
+- Diff two schemas: `npx prisma migrate diff --from-url "$DB_URL" --to-url "$SHADOW_URL" --script`
+- Execute raw SQL: `npx prisma db execute --stdin < migration.sql`
+
+## Database Operations
+
+- Push schema (no migration): `npx prisma db push`
+- Pull/introspect existing DB: `npx prisma db pull`
+- Seed: `npx prisma db seed`
+- Generate client: `npx prisma generate`
+- Watch mode: `npx prisma generate --watch`
+
+## Production Deploy
+
+Always use `npx prisma migrate deploy` in CI/production. This only applies existing migration files — never creates new ones. Add `prisma generate` to your build command or `postinstall` script:
+```json
+{ "scripts": { "postinstall": "prisma generate" } }
+```
+
+## Key Gotchas
+
+- `migrate dev` = local development (creates files + applies + generates). `migrate deploy` = CI/production (applies only).
+- Shadow database required for `migrate dev`. For cloud DBs (Supabase, PlanetScale), set `shadowDatabaseUrl` or use `db push`.
+- Always run `prisma generate` after schema changes or pulling repo.
+- Schema defaults to `prisma/schema.prisma`. Use `--schema` flag to override.
+- `db push` vs `migrate dev`: push = rapid prototyping (no history). migrate dev = migration history for production.
+- For Supabase: use direct connection (port 5432) for migrations, pooled (port 6543) for runtime.
+- For PlanetScale: add `relationMode = "prisma"` (no foreign keys) and use `db push`.
+- For serverless (Vercel): use Prisma Accelerate or connection pooler.

package/defaults/skills/railway.md

@@ -0,0 +1,69 @@
+---
+name: railway
+description: Railway — deploy apps, manage services, env vars, logs, databases
+---
+
+You are now equipped with Railway CLI expertise.
+
+## Prerequisites
+
+Ensure Railway CLI is installed (`npm i -g @railway/cli` or `brew install railway`) and authenticated (`railway login`). Check with `railway whoami`.
+
+## Project Setup
+
+- Create new project: `railway init`
+- Link to existing project: `railway link`
+- Link specific project/environment: `railway link --project <id> --environment <env-name>`
+- Check current context: `railway status`
+
+## Deploying
+
+- Deploy current directory: `railway up`
+- Deploy with Dockerfile: `railway up --dockerfile ./Dockerfile`
+- Deploy and detach: `railway up --detach`
+- Redeploy: `railway redeploy`
+- Redeploy with no cache: `railway redeploy --no-cache`
+
+Railway auto-detects the build system using Nixpacks (Node.js, Python, Go, Rust, Java, Ruby, PHP). If a Dockerfile exists, it takes priority over Nixpacks.
+
+## Environment Variables
+
+- List all: `railway variables`
+- Set: `railway variables set KEY=value`
+- Set multiple: `railway variables set KEY1=value1 KEY2=value2`
+- Delete: `railway variables delete KEY`
+- Open in browser: `railway open`
+
+## Logs
+
+- Stream live logs: `railway logs`
+- Follow in real time: `railway logs --follow`
+- Deployment logs: `railway logs --deployment`
+
+## Services & Commands
+
+- List services: `railway service`
+- Add service/database: `railway add`
+- Open shell with env vars: `railway shell`
+- Run command with Railway env vars injected: `railway run <command>`
+- Example — run migrations: `railway run npx prisma migrate deploy`
+- Example — open Prisma Studio: `railway run npx prisma studio`
+
+`railway run` is extremely useful — it injects all Railway env vars into your local command without copying connection strings.
+
+## Domains & Volumes
+
+- Generate railway.app domain: `railway domain`
+- Add persistent volume: `railway volume`
+- List volumes: `railway volume --list`
+- Custom domains are configured via the dashboard.
+
+## Key Gotchas
+
+- Every command operates against current linked project/environment. Check with `railway status`.
+- Dockerfile takes priority over Nixpacks. Remove Dockerfile to force Nixpacks.
+- Multiple environments supported (production, staging). Switch with `railway link --environment <name>`.
+- Services communicate internally via `<service>.railway.internal` DNS.
+- For CI: use `railway login --browserless` with `RAILWAY_TOKEN`.
+- Monorepo: set `RAILWAY_ROOT_DIRECTORY` for each service.
+- If start command isn't detected, set `RAILWAY_START_COMMAND` variable.

package/defaults/skills/stripe.md

@@ -0,0 +1,69 @@
+---
+name: stripe
+description: Stripe CLI — webhook forwarding, event triggers, API logs, resource management
+---
+
+You are now equipped with Stripe CLI expertise.
+
+## Prerequisites
+
+Ensure Stripe CLI is installed and authenticated (`stripe login`). Check with `stripe status`. CLI defaults to test mode (`sk_test_` keys).
+
+## Webhook Forwarding (Local Development)
+
+This is the most common use case:
+
+- Forward all events: `stripe listen --forward-to localhost:3000/api/webhooks`
+- Forward specific events only: `stripe listen --events payment_intent.succeeded,checkout.session.completed --forward-to localhost:3000/api/webhooks`
+- Forward Connect events: `stripe listen --forward-connect-to localhost:3000/api/connect-webhooks`
+
+**IMPORTANT:** `stripe listen` prints a webhook signing secret (`whsec_...`). Your app MUST use this secret (not the Dashboard secret) to verify signatures during local dev. Set it as: `STRIPE_WEBHOOK_SECRET=whsec_xxx`
+
+## Triggering Test Events
+
+- Trigger an event: `stripe trigger payment_intent.succeeded`
+- Common events to trigger:
+  - `stripe trigger checkout.session.completed`
+  - `stripe trigger customer.subscription.created`
+  - `stripe trigger invoice.payment_failed`
+- List all available events: `stripe trigger --list`
+
+Note: `stripe trigger` creates real test-mode objects. Running it multiple times creates duplicates. Use `stripe fixtures` for repeatable seeding.
+
+## API Log Streaming
+
+- Tail API logs: `stripe logs tail`
+- Filter by status: `stripe logs tail --filter-status-code 400`
+- Filter by method: `stripe logs tail --filter-http-method POST`
+- Filter by path: `stripe logs tail --filter-request-path /v1/charges`
+
+## Resource Management (CRUD)
+
+- Create customer: `stripe customers create --name "Jane Doe" --email jane@example.com`
+- List customers: `stripe customers list --limit 5`
+- Retrieve: `stripe customers retrieve cus_xxx`
+- Update: `stripe customers update cus_xxx --name "Jane Smith"`
+- Delete: `stripe customers delete cus_xxx`
+- Create payment intent: `stripe payment_intents create --amount 2000 --currency usd`
+- List all resource types: `stripe resources`
+
+## Fixtures & Samples
+
+- Run a fixture file: `stripe fixtures fixtures/seed.json`
+- List sample integrations: `stripe samples list`
+- Clone a sample: `stripe samples create accept-a-payment`
+
+## Auth
+
+- Interactive login: `stripe login`
+- Login with API key (CI): `stripe login --api-key sk_test_xxx`
+- Show config: `stripe config --list`
+
+## Key Gotchas
+
+- CLI defaults to test mode. Use `--live` for live mode. Never forward live webhooks to localhost.
+- Webhook signing secret changes every `stripe listen` session. Update your app's env var each time.
+- For CI/CD: create a restricted API key with minimal permissions, use `stripe login --api-key rk_test_xxx`.
+- Pairing code auth expires in 60 seconds.
+- Override API version: `--api-version 2023-10-16`
+- Use `stripe fixtures` instead of `stripe trigger` for repeatable, idempotent test data.

package/defaults/skills/supabase.md

@@ -0,0 +1,84 @@
+---
+name: supabase
+description: Supabase — local dev, migrations, auth, edge functions, storage, type generation
+---
+
+You are now equipped with Supabase CLI expertise.
+
+## Prerequisites
+
+Ensure Supabase CLI is installed (`npm i -g supabase` or `npx supabase`), authenticated (`supabase login`), and Docker is running (required for local dev).
+
+## Project Setup
+
+- Initialize: `supabase init` (creates `supabase/` directory with `config.toml` and `migrations/`)
+- Link to remote project: `supabase link --project-ref <project-id>` (project ref is in dashboard URL)
+- Unlink: `supabase unlink`
+
+## Local Development
+
+- Start all local services: `supabase start` (runs Postgres, Auth, Storage, PostgREST, Realtime, Edge Functions, Studio in Docker)
+- Check status and get local URLs/keys: `supabase status`
+- Stop: `supabase stop`
+- Stop and reset all data: `supabase stop --no-backup`
+- Reset database to current migrations: `supabase db reset` (DESTRUCTIVE — drops and recreates)
+
+## Migrations
+
+- Create new migration: `supabase migration new <name>`
+- Apply pending migrations locally: `supabase migration up`
+- Roll back last N: `supabase migration down --count <n>`
+- List migration status: `supabase migration list`
+- Squash migrations: `supabase migration squash`
+
+## Database Operations
+
+- Push migrations to remote: `supabase db push`
+- Pull remote schema into local migration: `supabase db pull`
+- Auto-generate migration from local changes: `supabase db diff --schema public -f <migration_name>`
+- Run SQL query: `supabase db query 'SELECT * FROM my_table LIMIT 10'`
+- Dump schema: `supabase db dump --schema public`
+- Lint database: `supabase db lint`
+
+**Key distinction:** `db push` = apply to REMOTE. `migration up` = apply LOCALLY.
+
+## Edge Functions
+
+- Create: `supabase functions new <name>` (creates `supabase/functions/<name>/index.ts`)
+- Serve locally (hot-reload): `supabase functions serve`
+- Deploy one: `supabase functions deploy <name>`
+- Deploy all: `supabase functions deploy`
+- List deployed: `supabase functions list`
+- Delete: `supabase functions delete <name>`
+
+## Type Generation
+
+- From local schema: `supabase gen types typescript --local > src/types/database.ts`
+- From remote: `supabase gen types typescript --linked > src/types/database.ts`
+- Specific schemas: `supabase gen types typescript --local --schema public,auth`
+
+Run this after every schema change to keep TypeScript types in sync.
+
+## Storage
+
+- List objects: `supabase storage ls ss:///bucket-name/path/`
+- Upload: `supabase storage cp ./file.png ss:///bucket/path/file.png`
+- Download: `supabase storage cp ss:///bucket/path/file.png ./file.png`
+- Delete: `supabase storage rm ss:///bucket/path/file.png`
+- Target local storage: add `--local` flag
+
+## Secrets (Edge Function env vars)
+
+- List: `supabase secrets list`
+- Set: `supabase secrets set MY_KEY=value ANOTHER=value2`
+- Unset: `supabase secrets unset MY_KEY`
+
+## Key Gotchas
+
+- Docker MUST be running before `supabase start`.
+- Always `supabase link` before any remote command (`db push`, `db pull`, `migration list`).
+- `supabase db diff -f <name>` is the easiest way to create migrations — make changes, then diff.
+- `supabase db reset` drops everything locally and replays migrations + seeds.
+- Secrets are for Edge Functions, not the database.
+- Use `--schema public,auth,storage` to target specific schemas on diff/dump/gen.
+- Most commands support `-o json` for scripting.

package/defaults/skills/turso.md

@@ -0,0 +1,78 @@
+---
+name: turso
+description: Turso — edge SQLite databases, replicas, groups, tokens
+---
+
+You are now equipped with Turso CLI expertise.
+
+## Prerequisites
+
+Ensure Turso CLI is installed (`curl -sSfL https://get.tur.so/install.sh | bash` or `brew install tursodatabase/tap/turso`) and authenticated (`turso auth login`).
+
+## Database Management
+
+- Create database: `turso db create mydb`
+- Create in specific group: `turso db create mydb --group us-east`
+- Create from SQLite file: `turso db create mydb --from-file ./local.db`
+- List databases: `turso db list`
+- Show details (URL, regions, size): `turso db show mydb`
+- Get connection URL only: `turso db show mydb --url`
+- Get HTTP URL: `turso db show mydb --http-url`
+- Delete: `turso db destroy mydb`
+
+## Interactive Shell
+
+- Open SQL shell: `turso db shell mydb`
+- Execute single statement: `turso db shell mydb "SELECT * FROM users;"`
+- Execute from file: `turso db shell mydb < schema.sql`
+
+## Database Tokens
+
+- Create auth token: `turso db tokens create mydb`
+- Read-only token: `turso db tokens create mydb --read-only`
+- Token with expiration: `turso db tokens create mydb --expiration 7d`
+- Long-lived token: `turso db tokens create mydb --expiration none`
+- Invalidate all tokens: `turso db tokens invalidate mydb`
+
+Store tokens as `TURSO_AUTH_TOKEN` in your environment.
+
+## Groups & Replicas
+
+- Create group: `turso group create us-group --location iad`
+- Add replica location: `turso group locations add us-group ord`
+- Remove replica: `turso group locations remove us-group ord`
+- Show group details: `turso group show us-group`
+- List groups: `turso group list`
+- List all available locations: `turso db locations`
+- Delete group: `turso group destroy us-group`
+
+## Production Setup Pattern
+
+```bash
+turso group create prod --location iad
+turso group locations add prod lhr    # London
+turso group locations add prod nrt    # Tokyo
+turso db create prod-db --group prod
+turso db tokens create prod-db --expiration none
+turso db show prod-db --url
+```
+
+## Auth
+
+- Login: `turso auth login`
+- Signup: `turso auth signup`
+- Check status: `turso auth whoami`
+- Get API token: `turso auth token`
+- Logout: `turso auth logout`
+
+## Key Gotchas
+
+- Connection URLs use `libsql://` protocol: `libsql://dbname-orgname.turso.io`
+- Writes go to primary; reads served from nearest replica.
+- Database tokens are separate from CLI login. Generate with `turso db tokens create`.
+- For local dev, use `file:local.db` URL with `@libsql/client` or run local libSQL server.
+- `--from-file` is great for seeding databases from SQLite files.
+- Embedded replicas give lowest latency — sync local SQLite with `syncUrl`.
+- For Drizzle: `dialect: "turso"` in drizzle.config.ts.
+- For Prisma: use `@prisma/adapter-libsql` with `driverAdapters` preview feature.
+- For Cloudflare Workers: use `@libsql/client/web` (HTTP transport).