@codyswann/lisa 2.121.1 → 2.122.0

package/plugins/lisa-expo-copilot/skills/ops-db-ops/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: ops-db-ops
+description: Database migrations, reverts, schema generation, and GraphQL codegen for Expo + serverless backend projects. Operates on the backend (TypeORM) and frontend (GraphQL code generation).
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Database Operations
+
+Manage database migrations, schema generation, and GraphQL code generation.
+
+**Argument**: `$ARGUMENTS` — operation (`migrate`, `revert`, `generate`, `schema`, `codegen`) and optional environment (default: `dev`)
+
+## Path Convention
+
+- **Frontend**: Current project directory (`.`)
+- **Backend**: `${BACKEND_DIR:-../backend-v2}` — set `BACKEND_DIR` in `.claude/settings.local.json` if your backend is elsewhere
+
+## Safety
+
+**CRITICAL**: Never run migrations or reverts against production without explicit human confirmation.
+
+## Discovery
+
+Read the backend `package.json` to discover available migration and schema scripts:
+- `migration:run:*` — run pending migrations
+- `migration:revert:*` — revert last migration
+- `migration:generate:*` — generate new migration from entity changes
+- `migration:create` — create empty migration
+- `generate:sql-schema*` — regenerate SQL schema for MCP
+- `aws:signin:*` — AWS credential scripts
+
+Read the frontend `package.json` to discover codegen scripts:
+- `fetch:graphql:schema:*` — fetch GraphQL schema
+- `generate:types:*` — generate TypeScript types
+
+## AWS Prerequisite
+
+All database operations (except `codegen`) require AWS credentials. Run the backend's AWS signin script first:
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+bun run aws:signin:{env}
+```
+
+## Operations
+
+### migrate (run pending migrations)
+
+**Local database**:
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run migration:run:local
+```
+
+**Remote database**:
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run migration:run:remote:local
+```
+
+### revert (undo last migration)
+
+**Local database**:
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run migration:revert:local
+```
+
+**Remote database**:
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run migration:revert:remote:local
+```
+
+### generate (create new migration from entity changes)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+NAME={migration_name} bun run migration:generate:{env}
+```
+
+### create (create empty migration)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+NAME={migration_name} bun run migration:create
+```
+
+### schema (regenerate SQL schema for MCP)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+STAGE={env} bun run generate:sql-schema
+```
+
+### codegen (regenerate GraphQL types in frontend)
+
+1. **Fetch schema**:
+   ```bash
+   bun run fetch:graphql:schema:{env}
+   ```
+
+2. **Generate types**:
+   ```bash
+   bun run generate:types:{env}
+   ```
+
+**Note**: The backend must be running (locally or deployed) for schema fetching to work.
+
+## Output Format
+
+Report operation result:
+
+| Operation | Environment | Target | Status | Details |
+|-----------|-------------|--------|--------|---------|
+| migrate | dev | local DB | SUCCESS | 2 migrations applied |
+| codegen | dev | frontend | SUCCESS | Types regenerated |

package/plugins/lisa-expo-copilot/skills/ops-deploy/SKILL.md

@@ -0,0 +1,119 @@
+---
+name: ops-deploy
+description: Deploy Expo frontend (EAS Update/Build) or serverless backend (Serverless Framework) to dev, staging, or production environments.
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Deploy
+
+Deploy the application to remote environments.
+
+**Argument**: `$ARGUMENTS` — environment (`dev`, `staging`, `production`) and optional target (`frontend`, `backend`, `both`; default: `both`)
+
+## Path Convention
+
+- **Frontend**: Current project directory (`.`)
+- **Backend**: `${BACKEND_DIR:-../backend-v2}` — set `BACKEND_DIR` in `.claude/settings.local.json` if your backend is elsewhere
+
+## Safety
+
+**CRITICAL**: Production deployments require explicit human confirmation before proceeding. Always ask for confirmation when `$ARGUMENTS` contains `production`.
+
+## Discovery
+
+1. Read backend `package.json` to discover `deploy:*`, `aws:signin:*` scripts
+2. Read frontend `package.json` to discover available scripts
+3. Read `.env.{environment}` files to find GraphQL URLs for post-deploy verification
+
+## CI/CD Path (Preferred)
+
+The standard deployment path is via CI/CD — pushing to environment branches triggers auto-deploy. Manual deployment instructions below are for when CI/CD is not suitable.
+
+## Frontend Deployment
+
+### EAS Update (OTA — over-the-air JavaScript update)
+
+Use for JS-only changes (no native module changes).
+
+1. Verify EAS CLI:
+   ```bash
+   eas whoami
+   ```
+   If not authenticated: `eas login`
+
+2. Copy environment file:
+   ```bash
+   cp .env.{environment} .env
+   ```
+
+3. Deploy OTA update:
+   ```bash
+   STAGE={env} NODE_OPTIONS="--max-old-space-size=8192" eas update --auto --channel={env} --message="Manual update"
+   ```
+
+4. Verify deployment:
+   ```bash
+   eas update:list --branch {env} --limit 3
+   ```
+
+### EAS Build (Native binary — only when `app.config.ts` or native modules change)
+
+1. ```bash
+   eas build --platform all --non-interactive --no-wait --profile={profile}
+   ```
+
+2. Check build status:
+   ```bash
+   eas build:list --limit 5
+   ```
+
+## Backend Deployment
+
+### Full Deploy (Serverless Framework)
+
+1. AWS signin (discover script name from backend `package.json`):
+   ```bash
+   cd "${BACKEND_DIR:-../backend-v2}"
+   bun run aws:signin:{env}
+   ```
+
+2. Deploy all functions:
+   ```bash
+   cd "${BACKEND_DIR:-../backend-v2}"
+   bun run deploy:{env}
+   ```
+
+3. Verify (use the GraphQL URL from `.env.{environment}`):
+   ```bash
+   curl -sf {graphql-url} -X POST \
+     -H "Content-Type: application/json" \
+     -d '{"query":"{ __typename }"}' \
+     -w "\nHTTP %{http_code} in %{time_total}s\n"
+   ```
+
+### Single Function Deploy
+
+Discover available function names from backend `package.json` `deploy:function:*` scripts:
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+FUNCTION_NAME={fn} bun run deploy:function:{env}
+```
+
+## Post-Deploy Verification
+
+After any deployment:
+
+1. **Health check** the deployed environment (use `ops-verify-health` skill)
+2. **Check logs** for errors in the first 5 minutes (use `ops-check-logs` skill)
+3. **Monitor Sentry** for new issues (use `ops-monitor-errors` skill)
+4. **Run browser UAT smoke test** against the deployed environment (use `ops-browser-uat` skill)
+
+Report deployment result as a table:
+
+| Target | Environment | Method | Status | Verification |
+|--------|-------------|--------|--------|-------------|
+| Frontend | dev | EAS Update | SUCCESS/FAIL | URL responds |
+| Backend | dev | Serverless | SUCCESS/FAIL | GraphQL responds |

package/plugins/lisa-expo-copilot/skills/ops-monitor-errors/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: ops-monitor-errors
+description: Monitor Sentry for unresolved errors in frontend and backend projects. Supports filtering by project, environment, and time range.
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Monitor Errors
+
+Monitor Sentry for errors in the application.
+
+**Argument**: `$ARGUMENTS` — project (`frontend`, `backend`, `all`; default: `all`) and optional time range (default: `1h`)
+
+## Discovery
+
+Discover Sentry configuration from:
+1. `.sentryclirc` — org and project names
+2. `.env.*` files — `EXPO_PUBLIC_SENTRY_DSN` for DSN
+3. `package.json` — `@sentry/react-native` (frontend) or `@sentry/node` (backend) for project type
+
+## Sentry CLI
+
+### List Unresolved Issues
+
+```bash
+sentry-cli issues list \
+  --org {org} \
+  --project {project}
+```
+
+### Filter by Environment
+
+```bash
+sentry-cli issues list \
+  --org {org} \
+  --project {project} \
+  --query "is:unresolved environment:{env}"
+```
+
+### Post-Deploy Check (new issues since deploy)
+
+```bash
+sentry-cli issues list \
+  --org {org} \
+  --project {project} \
+  --query "is:unresolved firstSeen:-{time}"
+```
+
+Where `{time}` is a Sentry duration like `1h`, `30m`, `24h`.
+
+## Sentry API (Fallback)
+
+If `sentry-cli` is not installed or not authenticated, use the API directly:
+
+### List Unresolved Issues
+
+```bash
+curl -sf "https://sentry.io/api/0/projects/{org}/{project}/issues/?query=is:unresolved&sort=date" \
+  -H "Authorization: Bearer $SENTRY_AUTH_TOKEN" | \
+  jq '.[] | {id: .id, title: .title, count: .count, userCount: .userCount, firstSeen: .firstSeen, lastSeen: .lastSeen}'
+```
+
+### Filter by Environment
+
+```bash
+curl -sf "https://sentry.io/api/0/projects/{org}/{project}/issues/?query=is:unresolved+environment:{env}&sort=date" \
+  -H "Authorization: Bearer $SENTRY_AUTH_TOKEN" | \
+  jq '.[] | {id: .id, title: .title, count: .count, userCount: .userCount}'
+```
+
+## Post-Deploy Workflow
+
+After any deployment:
+
+1. Wait 5 minutes for errors to surface
+2. Check for new unresolved issues in the deployed environment
+3. Assess severity: are these new regressions or pre-existing?
+4. Report findings with severity assessment
+
+## Output Format
+
+Report errors as a table:
+
+| Issue ID | Title | Events | Users | First Seen | Severity |
+|----------|-------|--------|-------|------------|----------|
+| 12345 | TypeError: Cannot read property 'name' | 42 | 15 | 5m ago | HIGH |
+| 12346 | Network request failed | 3 | 2 | 2h ago | MEDIUM |
+
+### Severity Classification
+
+| Severity | Criteria |
+|----------|----------|
+| CRITICAL | > 100 events or > 50 users in last hour |
+| HIGH | > 10 events or > 5 users, appeared after deploy |
+| MEDIUM | Recurring issue, < 10 events |
+| LOW | < 3 events, no user impact |
+
+Include summary: total unresolved issues, new since last deploy, and recommendation (proceed / investigate / rollback).

package/plugins/lisa-expo-copilot/skills/ops-performance/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: ops-performance
+description: Performance analysis for Expo + serverless backend projects. Runs Lighthouse audits, bundle size analysis, and k6 load tests.
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Performance
+
+Analyze application performance.
+
+**Argument**: `$ARGUMENTS` — analysis type (`lighthouse`, `bundle`, `k6`, `all`; default: `all`) and optional target environment
+
+## Path Convention
+
+- **Frontend**: Current project directory (`.`)
+- **Backend**: `${BACKEND_DIR:-../backend-v2}` — set `BACKEND_DIR` in `.claude/settings.local.json` if your backend is elsewhere
+
+## Discovery
+
+1. Read frontend `package.json` for `lighthouse:check`, `export:web`, `analyze:bundle` scripts
+2. Read backend `package.json` for `k6:*` scripts
+3. Read `e2e/constants.ts` or `.env.*` files for environment URLs
+
+## Lighthouse Audit
+
+### Against Local
+
+```bash
+npx lighthouse http://localhost:8081 \
+  --output=json \
+  --output-path=./lighthouse-local.json \
+  --chrome-flags='--headless --no-sandbox'
+```
+
+### Against Deployed Environment
+
+Discover frontend URLs from `e2e/constants.ts` or `.env.*` files:
+
+```bash
+npx lighthouse https://{env_url} \
+  --output=json \
+  --output-path=./lighthouse-{env}.json \
+  --chrome-flags='--headless --no-sandbox'
+```
+
+### LHCI (Lighthouse CI — uses project config)
+
+```bash
+bun run lighthouse:check
+```
+
+### Parse Lighthouse Results
+
+```bash
+cat lighthouse-{env}.json | jq '{
+  performance: .categories.performance.score,
+  accessibility: .categories.accessibility.score,
+  bestPractices: .categories["best-practices"].score,
+  seo: .categories.seo.score,
+  fcp: .audits["first-contentful-paint"].displayValue,
+  lcp: .audits["largest-contentful-paint"].displayValue,
+  tbt: .audits["total-blocking-time"].displayValue,
+  cls: .audits["cumulative-layout-shift"].displayValue,
+  si: .audits["speed-index"].displayValue
+}'
+```
+
+## Bundle Analysis
+
+### Full Analysis (export + source-map-explorer)
+
+```bash
+bun run export:web && bun run analyze:bundle
+```
+
+### Quick Size Check
+
+```bash
+bun run export:web
+echo "=== Total Bundle Size ==="
+du -sh dist/
+echo ""
+echo "=== Largest JS Files ==="
+find dist -name "*.js" -exec ls -lhS {} + 2>/dev/null | head -20
+```
+
+## k6 Load Tests
+
+Discover available k6 scripts from the backend `package.json` (matching `k6:*`).
+
+### Smoke Test (minimal load, verify endpoints work)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+bun run k6:smoke
+```
+
+### Load Test (normal traffic simulation)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+bun run k6:load
+```
+
+### Stress Test (push beyond normal capacity)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+bun run k6:stress
+```
+
+### Spike Test (sudden traffic burst)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+bun run k6:spike
+```
+
+### Docker-based k6 (no local k6 install needed)
+
+```bash
+cd "${BACKEND_DIR:-../backend-v2}"
+bun run k6:docker:smoke
+bun run k6:docker:load
+```
+
+## Output Format
+
+### Lighthouse Scores
+
+| Metric | Score | Rating |
+|--------|-------|--------|
+| Performance | 0.85 | GOOD |
+| Accessibility | 0.92 | GOOD |
+| Best Practices | 0.88 | GOOD |
+| SEO | 0.95 | GOOD |
+
+### Core Web Vitals
+
+| Metric | Value | Threshold | Status |
+|--------|-------|-----------|--------|
+| FCP (First Contentful Paint) | 1.2s | < 1.8s | PASS |
+| LCP (Largest Contentful Paint) | 2.1s | < 2.5s | PASS |
+| TBT (Total Blocking Time) | 150ms | < 200ms | PASS |
+| CLS (Cumulative Layout Shift) | 0.05 | < 0.1 | PASS |
+
+### Bundle Size
+
+| Category | Size | Notes |
+|----------|------|-------|
+| Total dist/ | 4.2 MB | |
+| Largest chunk | 1.1 MB | vendor.js |
+
+### k6 Results
+
+| Metric | Value |
+|--------|-------|
+| Requests/sec | 450 |
+| Avg response time | 120ms |
+| p95 response time | 350ms |
+| Error rate | 0.1% |
+
+Include recommendations for any metrics that fall below thresholds.

package/plugins/lisa-expo-copilot/skills/ops-run-local/SKILL.md

@@ -0,0 +1,166 @@
+---
+name: ops-run-local
+description: Manage the local development environment for Expo + serverless backend projects. Supports start, stop, restart, and status for the full stack or individual services.
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# Ops: Run Local
+
+Manage the local development environment.
+
+**Argument**: `$ARGUMENTS` — `start`, `stop`, `restart`, `status`, `start-frontend`, `start-backend` (default: `start`)
+
+## Path Convention
+
+- **Frontend**: Current project directory (`.`)
+- **Backend**: `${BACKEND_DIR:-../backend-v2}` — set `BACKEND_DIR` in `.claude/settings.local.json` if your backend is elsewhere
+
+## Prerequisites (run before any operation)
+
+1. Verify backend directory exists:
+   ```bash
+   BACKEND_DIR="${BACKEND_DIR:-../backend-v2}"
+   test -d "$BACKEND_DIR" && echo "Backend dir OK: $BACKEND_DIR" || echo "ERROR: Backend dir not found at $BACKEND_DIR — set BACKEND_DIR"
+   ```
+2. Check port availability:
+   ```bash
+   lsof -i :8081 2>/dev/null | grep LISTEN
+   lsof -i :3000 2>/dev/null | grep LISTEN
+   ```
+3. Verify bun is installed:
+   ```bash
+   which bun && bun --version
+   ```
+
+## Discovery
+
+Read the frontend `package.json` to find available start scripts (e.g., `start:local`, `start:dev`, `start:staging`). Read the backend `package.json` to find backend start scripts (e.g., `start:local`, `start:dev`).
+
+## Operations
+
+### start (full stack)
+
+Start both backend and frontend for local development.
+
+1. **Start backend** (background):
+   ```bash
+   cd "${BACKEND_DIR:-../backend-v2}" && IS_OFFLINE=true bun run start:local
+   ```
+   Run this in the background using the Bash tool with `run_in_background: true`.
+
+2. **Wait for backend** (up to 30 seconds):
+   ```bash
+   for i in $(seq 1 30); do
+     curl -sf http://localhost:3000/graphql -X POST \
+       -H "Content-Type: application/json" \
+       -d '{"query":"{ __typename }"}' > /dev/null 2>&1 && echo "Backend ready" && break
+     sleep 1
+   done
+   ```
+
+3. **Start frontend** (background):
+   ```bash
+   bun run start:local
+   ```
+   Run this in the background using the Bash tool with `run_in_background: true`.
+
+4. **Verify frontend** (up to 60 seconds — Metro bundler can be slow):
+   ```bash
+   for i in $(seq 1 60); do
+     curl -sf http://localhost:8081 > /dev/null 2>&1 && echo "Frontend ready" && break
+     sleep 1
+   done
+   ```
+
+5. Report status table.
+
+### start-frontend (frontend only, pointing at remote backend)
+
+Use when the backend is already deployed and you only need the frontend.
+
+1. ```bash
+   bun run start:dev
+   ```
+   Run in background.
+
+2. Verify:
+   ```bash
+   for i in $(seq 1 60); do
+     curl -sf http://localhost:8081 > /dev/null 2>&1 && echo "Frontend ready" && break
+     sleep 1
+   done
+   ```
+
+### start-backend (backend only)
+
+1. Check AWS credentials (discover profile from backend `package.json` `aws:signin:*` scripts):
+   ```bash
+   aws sts get-caller-identity --profile {aws-profile} 2>/dev/null
+   ```
+   If expired, run the backend's `aws:signin:{env}` script.
+
+2. Start:
+   ```bash
+   cd "${BACKEND_DIR:-../backend-v2}" && IS_OFFLINE=true bun run start:local
+   ```
+   Run in background.
+
+3. Verify:
+   ```bash
+   for i in $(seq 1 30); do
+     curl -sf http://localhost:3000/graphql -X POST \
+       -H "Content-Type: application/json" \
+       -d '{"query":"{ __typename }"}' > /dev/null 2>&1 && echo "Backend ready" && break
+     sleep 1
+   done
+   ```
+
+### stop
+
+Kill all local services.
+
+```bash
+# Kill frontend (Metro bundler)
+lsof -ti :8081 | xargs kill -9 2>/dev/null || echo "No frontend process on :8081"
+
+# Kill backend (Serverless Offline)
+lsof -ti :3000 | xargs kill -9 2>/dev/null || echo "No backend process on :3000"
+
+# Stop Docker if running
+cd "${BACKEND_DIR:-../backend-v2}" && docker compose down 2>/dev/null || true
+```
+
+### restart
+
+1. Run **stop** (above).
+2. Wait 2 seconds: `sleep 2`
+3. Run **start** (above).
+4. Verify both services respond.
+
+### status
+
+Check what is currently running and responsive.
+
+```bash
+echo "=== Port Check ==="
+echo -n "Frontend :8081 — "; lsof -i :8081 2>/dev/null | grep LISTEN > /dev/null && echo "LISTENING" || echo "NOT LISTENING"
+echo -n "Backend  :3000 — "; lsof -i :3000 2>/dev/null | grep LISTEN > /dev/null && echo "LISTENING" || echo "NOT LISTENING"
+
+echo ""
+echo "=== Health Check ==="
+echo -n "Frontend :8081 — "; curl -sf -o /dev/null -w "%{http_code}" http://localhost:8081 2>/dev/null || echo "UNREACHABLE"
+echo -n "Backend  :3000 — "; curl -sf -o /dev/null -w "%{http_code}" http://localhost:3000/graphql -X POST -H "Content-Type: application/json" -d '{"query":"{ __typename }"}' 2>/dev/null || echo "UNREACHABLE"
+
+echo ""
+echo "=== Docker ==="
+docker compose -f "${BACKEND_DIR:-../backend-v2}/compose.yaml" ps 2>/dev/null || echo "No Docker services running"
+```
+
+Report results as a table:
+
+| Service | Port | Listening | Responsive |
+|---------|------|-----------|------------|
+| Frontend (Metro) | 8081 | YES/NO | YES/NO |
+| Backend (Serverless Offline) | 3000 | YES/NO | YES/NO |