opencastle 0.33.9 → 0.34.0

package/src/orchestrator/plugins/expo/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: expo-development
+description: "Scaffolds Expo/React Native apps, configures EAS Build profiles, manages native modules via CNG, sets up Expo Router navigation, and uses EAS Update for OTA deployments. Use when creating React Native apps with Expo, configuring EAS builds, setting up Expo Router, managing native modules, or deploying OTA updates."
+---
+
+# Expo Development
+
+## Topic Routing
+
+Read the matching reference before writing code for any of these topics:
+
+| Topic | Reference |
+|-------|-----------|
+| EAS Build & deployment | `references/eas-build.md` |
+| Expo Router & navigation | `references/routing.md` |
+| Native modules & CNG | `references/native-modules.md` |
+
+## Critical Rules
+
+**Project Setup**
+- Use `npx create-expo-app@latest` for new projects — always target the latest SDK
+- Use Continuous Native Generation (CNG) — never eject; prefer `npx expo prebuild` when native config is needed
+- Configure `app.json` / `app.config.ts` for all project metadata — never modify native projects directly when using CNG
+
+**Expo Router**
+- File-based routing in `app/` — define `_layout.tsx` in each directory for `<Stack>`, `<Tabs>`, or `<Drawer>`
+- Use `Link` for declarative navigation, `useRouter()` for imperative — configure `scheme` in app.json for deep links
+
+**EAS Build**
+- Define `development` / `preview` / `production` profiles in `eas.json`
+- Preview: `"distribution": "internal"` + `"channel": "preview"` — Development: add `"developmentClient": true`
+- Production: `"channel": "production"` + `"autoIncrement": true`
+
+**EAS Update (OTA)**
+- `eas update --channel production` for JS-only changes — no app store review
+- Set `"runtimeVersion": { "policy": "fingerprint" }` — mismatched runtimeVersion forces a new binary build
+
+**Native Modules**
+- Prefer Expo SDK packages over community alternatives — install with `npx expo install` for version resolution
+- Config plugins (`app.plugin.js`) modify native projects at prebuild time — never edit `ios/` or `android/` directly
+- Custom native code: `npx create-expo-module` scaffolds Swift + Kotlin module
+
+**Security**
+- Store API keys and secrets in EAS Secrets — never hardcode in `app.json` or source code
+- Use `expo-secure-store` for device-side secret storage
+
+## Workflow: New Project → Build → Deploy
+
+1. **Scaffold** — `npx create-expo-app@latest my-app --template default@sdk-55`
+2. **Verify local** — `cd my-app && npx expo start` → confirm app loads in simulator
+3. **Init EAS** — `eas init && eas build:configure` → creates `eas.json` with profiles
+4. **Build preview** — `eas build --profile preview --platform ios`
+5. **Check status** — `eas build:list` → wait for `finished` status; if `errored` → `eas build:view <id>` → fix config → rebuild
+6. **Test** — install preview build on device via QR code or TestFlight
+7. **Build production** — `eas build --profile production --platform all`
+8. **Submit** — `eas submit --platform ios && eas submit --platform android`
+
+## Workflow: OTA Update
+
+1. **Make JS-only changes** — modify components, styles, or logic (no native module changes)
+2. **Deploy** — `eas update --channel production --message "Fix: button alignment"`
+3. **Verify** — `eas update:list` → confirm update published with correct `runtimeVersion`
+4. **Rollback if needed** — `eas update:republish --group <previous-group-id>`
+
+> If `runtimeVersion` mismatch: a new binary build is required — OTA cannot bridge native changes.
+
+## Build Failure Recovery
+
+```
+Build failed → check logs
+├── "Provisioning profile" error → eas credentials → fix iOS signing
+├── "SDK version mismatch" → npx expo install --fix → rebuild
+├── "Metro bundler" error → check JS syntax → npx expo start to reproduce
+├── "Native module" error → npx expo prebuild --clean → verify config plugins
+└── "EAS secret" missing → eas secret:create → rebuild
+```
+
+## Screen with Expo Router
+
+```tsx
+// app/user/[id].tsx
+import { useLocalSearchParams } from 'expo-router';
+import { View, Text } from 'react-native';
+
+export default function UserScreen() {
+  const { id } = useLocalSearchParams<{ id: string }>();
+  return (
+    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
+      <Text>User {id}</Text>
+    </View>
+  );
+}
+```
+
+## EAS Build Profile
+
+```json
+{
+  "build": {
+    "development": {
+      "developmentClient": true,
+      "distribution": "internal"
+    },
+    "preview": {
+      "distribution": "internal",
+      "channel": "preview"
+    },
+    "production": {
+      "channel": "production",
+      "autoIncrement": true
+    }
+  }
+}
+```

package/src/orchestrator/plugins/expo/config.ts

@@ -0,0 +1,24 @@
+import type { PluginConfig } from '../types.js';
+
+export const config: PluginConfig = {
+  id: 'expo',
+  name: 'Expo',
+  category: 'tech',
+  subCategory: 'framework',
+  label: 'Expo',
+  hint: 'React Native framework with EAS builds and OTA updates',
+  skillName: 'expo-development',
+  mcpServerKey: 'Expo',
+  mcpConfig: {
+    type: 'http',
+    url: 'https://mcp.expo.dev/mcp',
+  },
+  authType: 'oauth',
+  envVars: [],
+  agentToolMap: {
+    'developer': ['search_documentation', 'read_documentation', 'add_library'],
+    'testing-expert': ['automation_take_screenshot', 'automation_tap', 'automation_find_view'],
+  },
+  docsUrl: null,
+  officialDocs: 'https://docs.expo.dev/',
+};

package/src/orchestrator/plugins/expo/references/eas-build.md

@@ -0,0 +1,73 @@
+# EAS Build & Deployment
+
+## Build Profiles
+
+Define in `eas.json` at project root:
+
+- **development** — installs `expo-dev-client`, `distribution: internal`
+- **preview** — for TestFlight/internal testing, `distribution: internal`
+- **production** — for app store submission, `autoIncrement: true`
+
+## Commands
+
+```bash
+# Build for iOS
+eas build --platform ios --profile preview
+
+# Build for Android
+eas build --platform android --profile preview
+
+# Submit to App Store
+eas submit --platform ios
+
+# Submit to Google Play
+eas submit --platform android
+```
+
+## EAS Update (OTA)
+
+```bash
+# Deploy JS-only update
+eas update --channel production --message "Fix button alignment"
+
+# Check update status
+eas update:list
+```
+
+## Runtime Version Policy
+
+Use fingerprint policy in `app.json`:
+
+```json
+{
+  "expo": {
+    "runtimeVersion": {
+      "policy": "fingerprint"
+    }
+  }
+}
+```
+
+This auto-detects binary-incompatible changes and forces a new build.
+
+## EAS Workflows
+
+Define CI/CD in `.eas/workflows/`:
+
+```yaml
+name: build-and-deploy
+on:
+  push:
+    branches: [main]
+jobs:
+  build:
+    type: build
+    params:
+      platform: ios
+      profile: production
+  submit:
+    type: submit
+    needs: [build]
+    params:
+      platform: ios
+```

package/src/orchestrator/plugins/expo/references/native-modules.md

@@ -0,0 +1,71 @@
+# Native Modules & CNG
+
+## Continuous Native Generation (CNG)
+
+CNG regenerates native projects from `app.json` config:
+
+```bash
+# Generate native projects (don't commit these)
+npx expo prebuild
+
+# Clean and regenerate
+npx expo prebuild --clean
+```
+
+Add `ios/` and `android/` to `.gitignore` when using CNG.
+
+## Installing Expo SDK Packages
+
+Always use `npx expo install` — it resolves compatible versions:
+
+```bash
+npx expo install expo-camera expo-location expo-notifications
+```
+
+## Config Plugins
+
+Modify native projects at prebuild time without manual edits:
+
+```js
+// app.plugin.js
+const { withInfoPlist } = require('@expo/config-plugins');
+
+module.exports = function myPlugin(config) {
+  return withInfoPlist(config, (config) => {
+    config.modResults.NSCameraUsageDescription = 'App needs camera access';
+    return config;
+  });
+};
+```
+
+Register in `app.json`:
+
+```json
+{
+  "expo": {
+    "plugins": ["./app.plugin.js"]
+  }
+}
+```
+
+## Creating Custom Modules
+
+```bash
+npx create-expo-module my-native-module
+```
+
+This scaffolds a module with iOS (Swift) and Android (Kotlin) native code.
+
+## Expo SDK Package Selection
+
+| Need | Package |
+|------|---------|
+| Camera | `expo-camera` |
+| Location | `expo-location` |
+| Push notifications | `expo-notifications` |
+| File system | `expo-file-system` |
+| Secure storage | `expo-secure-store` |
+| Auth | `expo-auth-session` |
+| SQLite | `expo-sqlite` |
+| Haptics | `expo-haptics` |
+| Image picker | `expo-image-picker` |

package/src/orchestrator/plugins/expo/references/routing.md

@@ -0,0 +1,83 @@
+# Expo Router & Navigation
+
+## File-Based Routing
+
+Routes map to files in the `app/` directory:
+
+| File | Route |
+|------|-------|
+| `app/index.tsx` | `/` |
+| `app/about.tsx` | `/about` |
+| `app/user/[id].tsx` | `/user/:id` |
+| `app/(tabs)/_layout.tsx` | Tab navigator |
+| `app/(auth)/login.tsx` | `/login` (grouped) |
+
+## Layout Files
+
+Every directory can have a `_layout.tsx` that wraps its children:
+
+```tsx
+import { Stack } from 'expo-router';
+
+export default function RootLayout() {
+  return (
+    <Stack>
+      <Stack.Screen name="index" options={{ title: 'Home' }} />
+      <Stack.Screen name="(tabs)" options={{ headerShown: false }} />
+    </Stack>
+  );
+}
+```
+
+## Navigation
+
+```tsx
+import { Link, useRouter } from 'expo-router';
+
+// Declarative
+<Link href="/user/123">View Profile</Link>
+
+// Imperative
+const router = useRouter();
+router.push('/user/123');
+router.replace('/home');
+router.back();
+```
+
+## Deep Linking
+
+Configure in `app.json`:
+
+```json
+{
+  "expo": {
+    "scheme": "myapp",
+    "web": {
+      "bundler": "metro"
+    }
+  }
+}
+```
+
+URLs like `myapp://user/123` automatically resolve to `app/user/[id].tsx`.
+
+## Tab Navigation
+
+```tsx
+import { Tabs } from 'expo-router';
+import { Ionicons } from '@expo/vector-icons';
+
+export default function TabLayout() {
+  return (
+    <Tabs>
+      <Tabs.Screen
+        name="index"
+        options={{
+          title: 'Home',
+          tabBarIcon: ({ color }) => <Ionicons name="home" color={color} size={24} />,
+        }}
+      />
+    </Tabs>
+  );
+}
+```

package/src/orchestrator/plugins/index.ts

@@ -21,8 +21,14 @@ import { config as playwright } from './playwright/config.js';
 import { config as vitest } from './vitest/config.js';
 import { config as figma } from './figma/config.js';
 import { config as resend } from './resend/config.js';
+import { config as stripe } from './stripe/config.js';
 import { config as nextjs } from './nextjs/config.js';
 import { config as astro } from './astro/config.js';
+import { config as sentry } from './sentry/config.js';
+import { config as drizzle } from './drizzle/config.js';
+import { config as cloudflare } from './cloudflare/config.js';
+import { config as coolify } from './coolify/config.js';
+import { config as expo } from './expo/config.js';
 
 export type { PluginConfig, McpServerConfig, McpInput, EnvVarRequirement } from './types.js';
 
@@ -44,8 +50,14 @@ export const PLUGINS: Record<string, PluginConfig> = {
   vitest,
   figma,
   resend,
+  stripe,
   nextjs,
   astro,
+  sentry,
+  drizzle,
+  cloudflare,
+  coolify,
+  expo,
   linear,
   jira,
   trello,

package/src/orchestrator/plugins/linear/SKILL.md

@@ -7,7 +7,7 @@ description: "Creates and names Linear issues, assigns labels and priorities, ma
 
 # Task Management with Linear
 
-For project-specific team ID, workflow state UUIDs, and label UUIDs, see [tracker-config.md](../../.opencastle/project/tracker-config.md).
+For project-specific team ID, workflow state UUIDs, and label UUIDs, see [tracker-config.md](../../.opencastle/project/tracker-config.md). For status transitions, follow the **Status Update Procedure** section below.
 
 ## MCP Tool Examples
 
@@ -16,8 +16,8 @@ For project-specific team ID, workflow state UUIDs, and label UUIDs, see [tracke
 { "teamId": "TEAM_UUID", "title": "[UI] Build PriceRangeFilter", "description": "Objective: ...\nFiles: ...\nAC: ...", "labelIds": ["LABEL_UUID"], "priority": 2 }
 // → { "id": "TAS-42", "url": "https://linear.app/team/TAS-42" }
 
-// Update issue status
-{ "issueId": "TAS-42", "stateId": "IN_PROGRESS_UUID" }
+// Update issue status (see Status Update Procedure)
+{ "issueId": "TAS-42", "stateId": "<UUID from tracker-config.md>" }
 
 // Search issues
 { "query": "is:open assignee:me", "teamId": "TEAM_UUID" }
@@ -76,3 +76,21 @@ Group related issues under a Linear project; issues track individual subtasks.
 6. On completion: verify all issues Done/Cancelled, run build/lint/test.
 
 If creation fails: check team ID and state UUIDs in [tracker-config.md](../../.opencastle/project/tracker-config.md); retry once. If board state is inconsistent on resume: re-read all issue statuses before proceeding.
+
+## Status Update Procedure
+
+> ⚠️ `update_issue` requires a workflow state **UUID** — passing a name like `"In Progress"` always fails with `stateId must be a UUID`.
+
+1. **Read UUIDs from [tracker-config.md](../../.opencastle/project/tracker-config.md)** before any status transition. Names returned by `list_issues`/`get_issue` are display-only, not valid `stateId` values.
+2. **If `tracker-config.md` has no state UUIDs**, skip status updates and log a warning.
+
+```json
+// ✅ UUID from tracker-config.md
+{ "issueId": "TAS-42", "stateId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890" }
+// ❌ FAILS — name, not UUID
+{ "issueId": "TAS-42", "status": "In Progress" }
+```
+
+## One-Time Setup: Discover Workflow State UUIDs
+
+If `tracker-config.md` lacks state UUIDs, ask the user to populate them from Linear Settings → Teams → Workflow (UUID in browser URL per state) or via the GraphQL `workflowStates { nodes { id name } }` query.

package/src/orchestrator/plugins/sentry/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: sentry-monitoring
+description: "Sentry error monitoring, SDK initialization, performance tracing, source maps, session replay, and release tracking. Use when adding Sentry to a project, capturing errors with context, setting up distributed tracing, configuring source maps, or debugging production issues."
+---
+
+# Sentry Monitoring
+
+## Topic Routing
+
+Read the matching reference before writing code for any of these topics:
+
+| Topic | Reference |
+|-------|-----------|
+| SDK setup & initialization | `references/sdk-setup.md` |
+| Error capture & context enrichment | `references/error-patterns.md` |
+| Performance tracing & spans | `references/performance.md` |
+
+## Critical Rules
+
+**SDK Initialization**
+- Next.js requires separate init files: `instrumentation-client.ts` (browser), `sentry.server.config.ts` (Node), `sentry.edge.config.ts` (edge runtime)
+- Call `Sentry.init()` as early as possible — before any other imports that might throw
+- Set `sendDefaultPii: true` to capture authenticated user context automatically
+- Use `npx @sentry/wizard@latest -i nextjs` for guided setup; it creates all init files and patches `next.config.ts`
+
+**Error Capture**
+- Use `Sentry.captureException(err)` for caught errors; uncaught errors are captured automatically
+- Enrich errors with `Sentry.setContext()`, `Sentry.setTag()`, `Sentry.setUser()` before or inside the capture call
+- Add breadcrumbs with `Sentry.addBreadcrumb()` to build a debugging trail leading to the error
+- Override fingerprinting via `event.fingerprint` in `beforeSend` to control issue grouping
+
+**Performance**
+- Set `tracesSampleRate: 1.0` in development, `0.1` (or lower) in production to control costs
+- Use `Sentry.startSpan()` for custom instrumentation around expensive operations
+- Core Web Vitals are captured automatically by the browser SDK — no extra config needed
+
+**Source Maps**
+- Wrap `next.config.ts` with `withSentryConfig()` to auto-upload source maps at build time
+- Set `SENTRY_AUTH_TOKEN` in CI environment; generate at Organization Settings → Auth Tokens
+- Enable `tunnelRoute: '/monitoring'` to proxy Sentry requests through your server and avoid ad-blockers
+
+**Releases & Replay**
+- Associate commits by setting `SENTRY_RELEASE` or letting the wizard configure it automatically
+- Enable Session Replay with `replaysSessionSampleRate` and `replaysOnErrorSampleRate` for visual debugging
+- Never expose the DSN in server-side code that handles secrets — DSN is safe for client-side use only
+
+## Next.js Init Pattern
+
+```typescript
+// instrumentation-client.ts (browser) — mirrors sentry.server.config.ts / sentry.edge.config.ts
+import * as Sentry from '@sentry/nextjs';
+
+Sentry.init({
+  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
+  tracesSampleRate: process.env.NODE_ENV === 'production' ? 0.1 : 1.0,
+  sendDefaultPii: true,
+  // Browser-only options:
+  replaysSessionSampleRate: 0.1,
+  replaysOnErrorSampleRate: 1.0,
+  integrations: [Sentry.replayIntegration()],
+});
+```
+
+## Capture with Context
+
+```typescript
+import * as Sentry from '@sentry/nextjs';
+
+try {
+  await processOrder(orderId);
+} catch (err) {
+  Sentry.withScope((scope) => {
+    scope.setTag('action', 'process-order');
+    scope.setContext('order', { orderId, userId });
+    Sentry.captureException(err);
+  });
+  throw err; // re-throw after capturing
+}
+```
+
+## Reference Files
+
+- `references/sdk-setup.md` — Init patterns for Next.js, React, Node.js; wizard usage; config options
+- `references/error-patterns.md` — captureException, context enrichment, breadcrumbs, fingerprinting, error boundaries
+- `references/performance.md` — tracesSampleRate, startSpan, distributed tracing, custom instrumentation
+
+## Quick Workflow: Add Sentry to a Next.js app
+1. Run `npx @sentry/wizard@latest -i nextjs` — select your Sentry org and project when prompted
+2. Wizard creates `instrumentation-client.ts`, `sentry.server.config.ts`, `sentry.edge.config.ts`, and patches `next.config.ts`
+3. Set `NEXT_PUBLIC_SENTRY_DSN` in `.env.local` and `SENTRY_AUTH_TOKEN` in `.env.local` (and CI secrets)
+4. Adjust `tracesSampleRate` in each init file — verify Sentry receives a test event before merging
+5. Add `global-error.tsx` and call `Sentry.captureException` inside it for App Router error boundaries
+   - **If events not appearing:** check DSN matches the project → verify `tunnelRoute` is configured → confirm `SENTRY_AUTH_TOKEN` is set for source map uploads
+   - **If source maps missing:** confirm `withSentryConfig` wraps the Next.js config → check build logs for upload errors

package/src/orchestrator/plugins/sentry/config.ts

@@ -0,0 +1,29 @@
+import type { PluginConfig } from '../types.js';
+
+export const config: PluginConfig = {
+  id: 'sentry',
+  name: 'Sentry',
+  category: 'tech',
+  subCategory: 'observability',
+  label: 'Sentry',
+  hint: 'Error monitoring, performance tracing, and observability',
+  skillName: 'sentry-monitoring',
+  mcpServerKey: 'Sentry',
+  mcpConfig: {
+    type: 'stdio',
+    command: 'npx',
+    args: ['@sentry/mcp-server@latest'],
+  },
+  authType: 'env-token',
+  envVars: [
+    { name: 'SENTRY_ACCESS_TOKEN', hint: 'Create at Settings \u2192 Auth Tokens in sentry.io' },
+  ],
+  agentToolMap: {
+    'developer': ['search_errors', 'get_issue_details', 'search_issues', 'create_sentry_issue'],
+    'devops-expert': ['list_projects', 'get_project_stats', 'search_errors'],
+    'security-expert': ['search_errors', 'get_issue_details', 'list_projects'],
+  },
+  docsUrl: null,
+  officialDocs: 'https://docs.sentry.io/',
+  mcpPackage: '@sentry/mcp-server',
+};

package/src/orchestrator/plugins/sentry/references/error-patterns.md

@@ -0,0 +1,112 @@
+# Sentry Error Patterns
+
+## Basic Capture
+
+```typescript
+import * as Sentry from '@sentry/nextjs';
+
+// Caught error
+try {
+  await riskyOperation();
+} catch (err) {
+  Sentry.captureException(err);
+}
+
+// Custom message
+Sentry.captureMessage('Payment declined', 'warning');
+```
+
+## Context Enrichment
+
+```typescript
+// Set user (persists for subsequent events in the session)
+Sentry.setUser({ id: user.id, email: user.email });
+
+// Structured context object
+Sentry.setContext('order', { orderId, amount, currency });
+
+// Searchable tag
+Sentry.setTag('tenant', organizationSlug);
+
+// Scoped enrichment (one-off, does not persist)
+Sentry.withScope((scope) => {
+  scope.setTag('action', 'checkout');
+  scope.setContext('cart', { itemCount, total });
+  scope.setLevel('fatal');
+  Sentry.captureException(err);
+});
+```
+
+## Breadcrumbs
+
+```typescript
+Sentry.addBreadcrumb({
+  category: 'payment',
+  message: 'User clicked pay button',
+  level: 'info',
+  data: { amount: 99.99 },
+});
+```
+
+## Custom Fingerprinting
+
+```typescript
+// sentry.client.config.ts
+Sentry.init({
+  dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
+  beforeSend(event) {
+    // Group all DB timeout errors together regardless of query
+    if (event.exception?.values?.[0]?.value?.includes('timeout')) {
+      event.fingerprint = ['database-timeout'];
+    }
+    return event;
+  },
+});
+```
+
+## Error Boundaries (React / Next.js App Router)
+
+```typescript
+// app/global-error.tsx
+'use client';
+import * as Sentry from '@sentry/nextjs';
+import { useEffect } from 'react';
+
+export default function GlobalError({ error, reset }: { error: Error; reset: () => void }) {
+  useEffect(() => {
+    Sentry.captureException(error);
+  }, [error]);
+
+  return (
+    <html>
+      <body>
+        <h2>Something went wrong</h2>
+        <button onClick={reset}>Try again</button>
+      </body>
+    </html>
+  );
+}
+```
+
+### Wrapping components
+
+```typescript
+import * as Sentry from '@sentry/react';
+
+export const SafeWidget = Sentry.withErrorBoundary(MyWidget, {
+  fallback: <p>This widget failed to load</p>,
+});
+```
+
+## Server Action Instrumentation
+
+```typescript
+'use server';
+import * as Sentry from '@sentry/nextjs';
+
+export async function submitForm(data: FormData) {
+  return await Sentry.withServerActionInstrumentation('submitForm', async () => {
+    // Your server action logic here
+  });
+}
+```