peachsim 0.1.527

package/src/skills/builtin/a11y-review.ts

@@ -0,0 +1,132 @@
+// built-in skill: accessibility audit
+
+import { launchReapedChrome } from '../../../../../scripts/lib/reap-browser'
+import type { RNXSkill } from '../types'
+
+export const skill: RNXSkill = {
+  name: 'a11y-review',
+  description: 'Check the app for accessibility issues',
+  type: 'review',
+  version: '1.0.0',
+  triggers: ['accessibility', 'a11y', 'check accessibility', 'audit accessibility'],
+  tools: [
+    {
+      name: 'audit_accessibility',
+      description: 'Run an accessibility audit on the current screen',
+      parameters: {
+        screen: { type: 'string', description: 'Screen name or URL to audit' },
+      },
+      async execute(params, context) {
+        const { chromium } = await import('playwright')
+        const path = await import('path')
+        const fs = await import('fs')
+
+        // sootsim renders CanvasKit — require GPU-backed Chrome (Metal). the
+        // bundled swiftshader shell software-renders the canvas and pegs every
+        // core; never use it for sootsim.
+        const browser = await launchReapedChrome((options) => chromium.launch(options), {
+          headless: true,
+        })
+        const page = await browser.newPage({ viewport: { width: 500, height: 900 } })
+
+        try {
+          await page.goto(context.url, { waitUntil: 'networkidle' })
+          await page.waitForFunction('window.__sootsimTest', { timeout: 10000 })
+          await page.waitForTimeout(2000)
+
+          // get accessibility tree
+          const tree = await page.evaluate(
+            'window.__sootsimTest.dumpAccessibilityTree(10)',
+          )
+          const allNodes = await page.evaluate('window.__sootsimTest.queryAll({})')
+
+          // analyze for common issues
+          const issues: {
+            severity: 'error' | 'warning' | 'info'
+            message: string
+            node?: string
+          }[] = []
+
+          if (Array.isArray(allNodes)) {
+            for (const node of allNodes) {
+              // check for missing accessibility labels on interactive elements
+              if (
+                (node.accessibilityRole === 'button' ||
+                  node.accessibilityRole === 'link' ||
+                  node.type === 'TouchableOpacity' ||
+                  node.type === 'Pressable') &&
+                !node.accessibilityLabel &&
+                !node.text
+              ) {
+                issues.push({
+                  severity: 'error',
+                  message: `Interactive element missing accessibility label`,
+                  node: node.testID || node.id || node.type,
+                })
+              }
+
+              // check for missing roles
+              if (
+                (node.type === 'TouchableOpacity' || node.type === 'Pressable') &&
+                !node.accessibilityRole
+              ) {
+                issues.push({
+                  severity: 'warning',
+                  message: `Touchable element missing accessibility role`,
+                  node: node.testID || node.id || node.type,
+                })
+              }
+
+              // check for images without alt text
+              if (node.type === 'Image' && !node.accessibilityLabel && !node.accessible) {
+                issues.push({
+                  severity: 'warning',
+                  message: `Image missing accessibility label`,
+                  node: node.testID || node.id || 'Image',
+                })
+              }
+
+              // check for small touch targets
+              if (
+                node.layout &&
+                (node.accessibilityRole === 'button' ||
+                  node.type === 'TouchableOpacity') &&
+                (node.layout.width < 44 || node.layout.height < 44)
+              ) {
+                issues.push({
+                  severity: 'warning',
+                  message: `Touch target too small (${Math.round(node.layout.width)}x${Math.round(node.layout.height)}pt, minimum 44x44pt)`,
+                  node: node.testID || node.text || node.type,
+                })
+              }
+            }
+          }
+
+          // write report
+          const report = {
+            timestamp: new Date().toISOString(),
+            screen: params.screen || 'current',
+            nodeCount: Array.isArray(allNodes) ? allNodes.length : 0,
+            issues,
+            errors: issues.filter((i) => i.severity === 'error').length,
+            warnings: issues.filter((i) => i.severity === 'warning').length,
+            tree: typeof tree === 'string' ? tree : JSON.stringify(tree),
+          }
+
+          const reportPath = path.join(context.outputDir, 'a11y-report.json')
+          fs.mkdirSync(path.dirname(reportPath), { recursive: true })
+          fs.writeFileSync(reportPath, JSON.stringify(report, null, 2))
+
+          return {
+            success: issues.filter((i) => i.severity === 'error').length === 0,
+            message: `${report.errors} errors, ${report.warnings} warnings across ${report.nodeCount} nodes`,
+            artifacts: [{ type: 'report', name: 'a11y-report', path: reportPath }],
+            data: report,
+          }
+        } finally {
+          await browser.close()
+        }
+      },
+    },
+  ],
+}

package/src/skills/builtin/compat-check.ts

@@ -0,0 +1,71 @@
+// built-in skill: package compatibility check
+
+import type { RNXSkill } from '../types'
+
+export const skill: RNXSkill = {
+  name: 'compat-check',
+  description: 'Check package compatibility with rnx',
+  type: 'review',
+  version: '1.0.0',
+  triggers: ['compatibility', 'compat', 'check package', 'supported packages'],
+  tools: [
+    {
+      name: 'check_compatibility',
+      description: 'Scan project dependencies for rnx compatibility',
+      parameters: {
+        packageName: {
+          type: 'string',
+          description: 'Specific package to check (optional)',
+        },
+      },
+      async execute(params, context) {
+        const fs = await import('node:fs')
+        const path = await import('node:path')
+        const { COMPAT_RESULT_CAVEAT, formatPackageStatus, formatScanCounts, scanDeps } =
+          await import('../../../../compat/src/web.ts')
+
+        const packagePath = path.join(context.projectDir, 'package.json')
+        if (!fs.existsSync(packagePath)) {
+          return { success: false, message: 'No package.json found' }
+        }
+        const parsed: unknown = JSON.parse(fs.readFileSync(packagePath, 'utf8'))
+        if (!parsed || typeof parsed !== 'object') {
+          return { success: false, message: 'package.json is not an object' }
+        }
+
+        const dependencies = readDependencies(parsed)
+        const scan = params.packageName
+          ? scanDeps({
+              dependencies: {
+                [params.packageName]: dependencies[params.packageName] ?? '*',
+              },
+            })
+          : scanDeps(parsed)
+        const packageResult = params.packageName ? scan.packages[0] : undefined
+        const message = packageResult
+          ? `${params.packageName}: ${formatPackageStatus(packageResult)}. ${COMPAT_RESULT_CAVEAT}`
+          : `${formatScanCounts(scan)}. ${COMPAT_RESULT_CAVEAT}`
+
+        const reportPath = path.join(context.outputDir, 'compat-report.json')
+        fs.mkdirSync(path.dirname(reportPath), { recursive: true })
+        fs.writeFileSync(reportPath, `${JSON.stringify(scan, null, 2)}\n`)
+
+        return {
+          success: true,
+          message,
+          artifacts: [{ type: 'report', name: 'compat-report', path: reportPath }],
+          data: scan,
+        }
+      },
+    },
+  ],
+}
+
+function readDependencies(value: object): Record<string, string> {
+  const dependencies = Reflect.get(value, 'dependencies')
+  const devDependencies = Reflect.get(value, 'devDependencies')
+  return {
+    ...(dependencies && typeof dependencies === 'object' ? dependencies : {}),
+    ...(devDependencies && typeof devDependencies === 'object' ? devDependencies : {}),
+  }
+}

package/src/skills/builtin/maestro-test.ts

@@ -0,0 +1,121 @@
+// built-in skill: run Maestro tests against the app
+
+import type { RNXSkill } from '../types'
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export const skill: RNXSkill = {
+  name: 'maestro-test',
+  description: 'Run Maestro YAML tests against the app',
+  type: 'testing',
+  version: '1.0.0',
+  triggers: ['run test', 'test flow', 'run maestro', 'test the app'],
+  tools: [
+    {
+      name: 'run_maestro',
+      description: 'Run a Maestro YAML test against the app',
+      parameters: {
+        flowPath: {
+          type: 'string',
+          description: 'Path to the YAML flow file',
+          required: true,
+        },
+        record: { type: 'boolean', description: 'Record video of the flow' },
+      },
+      async execute(params, context) {
+        const fs = await import('fs')
+        const path = await import('path')
+        const yaml = await import('yaml')
+        const { DEFAULT_SOOTSIM_BRIDGE_PORT } = await import('../../bridge-constants')
+        const { SootSimBridgeHost } = await import('../../host/bridge-host')
+        const { createBridge } = await import('../../../cli/ws-bridge')
+        const { runOpenCommand } = await import('../../../cli/commands/control')
+        const { SootSimBridgeFlowRunner } =
+          await import('../../../cli/bridge-flow-runner')
+
+        const host = new SootSimBridgeHost({ port: DEFAULT_SOOTSIM_BRIDGE_PORT })
+        host.start({ silent: true })
+
+        try {
+          const flowContent = fs.readFileSync(params.flowPath, 'utf8')
+          const fmMatch = flowContent.match(/^---\n([\s\S]*?)\n---\n?/)
+          const stepsBody = fmMatch ? flowContent.slice(fmMatch[0].length) : flowContent
+          const steps = yaml.parse(stepsBody)
+          const beforeIds = new Set(host.listSims().map((sim) => sim.id))
+
+          await runOpenCommand([context.url, '--new', '--headless', '--no-describe'], {
+            port: DEFAULT_SOOTSIM_BRIDGE_PORT,
+          })
+
+          let simId: string | null = null
+          for (let i = 0; i < 60; i++) {
+            const sims = host.listSims()
+            const opened =
+              sims.find((sim) => !beforeIds.has(sim.id) && sim.readyState === 'open') ||
+              sims.find((sim) => sim.readyState === 'open')
+            if (opened) {
+              simId = opened.id
+              break
+            }
+            await sleep(500)
+          }
+
+          if (!simId) {
+            throw new Error('no sim connected to the bridge host')
+          }
+
+          const bridge = createBridge(DEFAULT_SOOTSIM_BRIDGE_PORT, {
+            simId,
+            commandTimeoutMs: 15000,
+          })
+          const driver = new SootSimBridgeFlowRunner(bridge, {
+            screenshotDir: context.outputDir,
+            flowDir: path.dirname(path.resolve(params.flowPath)),
+            simId,
+            recordingOutputDir: params.record ? context.outputDir : undefined,
+          })
+
+          let videoPath: string | null = null
+
+          try {
+            await driver.waitForTree(120000)
+            if (params.record) {
+              await driver.startRecording()
+            }
+            await driver.runFlow(steps)
+            if (params.record) {
+              videoPath = await driver.stopRecording()
+            }
+
+            return {
+              success: true,
+              message: `Flow completed: ${steps.length} steps passed`,
+              data: {
+                steps: steps.length,
+                simId,
+                videoPath: videoPath || undefined,
+              },
+              artifacts: videoPath
+                ? [{ type: 'video', name: path.basename(videoPath), path: videoPath }]
+                : undefined,
+            }
+          } finally {
+            try {
+              await bridge.closeSim(simId)
+            } catch {}
+            bridge.close()
+          }
+        } catch (err: any) {
+          return {
+            success: false,
+            message: `Flow failed: ${err.message}`,
+          }
+        } finally {
+          await host.close().catch(() => {})
+        }
+      },
+    },
+  ],
+}

package/src/skills/builtin/perf-profile.ts

@@ -0,0 +1,90 @@
+// built-in skill: performance profiling
+
+import { launchReapedChrome } from '../../../../../scripts/lib/reap-browser'
+import type { RNXSkill } from '../types'
+
+interface OverlayProfile {
+  syncCount?: number
+  avgSyncMs?: number
+  [key: string]: unknown
+}
+
+export const skill: RNXSkill = {
+  name: 'perf-profile',
+  description: 'Profile render performance of the app',
+  type: 'performance',
+  version: '1.0.0',
+  triggers: ['performance', 'profile', 'render time', 'benchmark', 'perf'],
+  tools: [
+    {
+      name: 'profile_render',
+      description: 'Profile render performance of the current screen',
+      parameters: {
+        duration: {
+          type: 'number',
+          description: 'Profile duration in seconds (default: 5)',
+        },
+        interactions: {
+          type: 'boolean',
+          description: 'Include user interactions in profiling',
+        },
+      },
+      async execute(params, context) {
+        const { chromium } = await import('playwright')
+        const path = await import('path')
+        const fs = await import('fs')
+
+        // sootsim renders CanvasKit — require GPU-backed Chrome (Metal). the
+        // bundled swiftshader shell software-renders the canvas and pegs every
+        // core; never use it for sootsim.
+        const browser = await launchReapedChrome((options) => chromium.launch(options), {
+          headless: true,
+        })
+        const page = await browser.newPage({ viewport: { width: 500, height: 900 } })
+
+        try {
+          await page.goto(context.url, { waitUntil: 'networkidle' })
+          await page.waitForFunction('window.__sootsimTest && window.__sootsimA11y', {
+            timeout: 10000,
+          })
+          await page.waitForTimeout(1000)
+
+          // reset profiler
+          await page.evaluate('window.__sootsimA11y.resetProfile()')
+
+          // wait for profile duration
+          const duration = (params.duration || 5) * 1000
+          await page.waitForTimeout(duration)
+
+          // collect results
+          const profile = (await page.evaluate(
+            'window.__sootsimA11y.profile()',
+          )) as OverlayProfile
+          const nodeCount = await page.evaluate('window.__sootsimTest.getNodeCount()')
+          const syncCount = profile.syncCount ?? 0
+
+          const report = {
+            timestamp: new Date().toISOString(),
+            duration: params.duration || 5,
+            nodeCount,
+            ...profile,
+            fps: syncCount > 0 ? (syncCount / (duration / 1000)).toFixed(1) : '0',
+          }
+
+          const reportPath = path.join(context.outputDir, 'perf-report.json')
+          fs.mkdirSync(path.dirname(reportPath), { recursive: true })
+          fs.writeFileSync(reportPath, JSON.stringify(report, null, 2))
+
+          return {
+            success: true,
+            message: `${report.fps} fps, ${profile.avgSyncMs?.toFixed(1)}ms avg sync, ${nodeCount} nodes`,
+            artifacts: [{ type: 'report', name: 'perf-report', path: reportPath }],
+            data: report,
+          }
+        } finally {
+          await browser.close()
+        }
+      },
+    },
+  ],
+}

package/src/skills/builtin/screenshot-all.ts

@@ -0,0 +1,52 @@
+// built-in skill: capture all screens in light/dark mode
+
+import { launchReapedChrome } from '../../../../../scripts/lib/reap-browser'
+import type { RNXSkill } from '../types'
+
+export const skill: RNXSkill = {
+  name: 'screenshot-all',
+  description: 'Capture screenshots of all screens in the app',
+  type: 'screenshot',
+  version: '1.0.0',
+  triggers: ['screenshot', 'capture screens', 'capture all', 'take screenshots'],
+  tools: [
+    {
+      name: 'capture_screenshot',
+      description: 'Capture a screenshot of the current screen',
+      parameters: {
+        name: { type: 'string', description: 'Screenshot name', required: true },
+        theme: { type: 'string', description: 'Color scheme: light or dark' },
+      },
+      async execute(params, context) {
+        const { chromium } = await import('playwright')
+        const path = await import('path')
+        const fs = await import('fs')
+
+        // sootsim renders CanvasKit — require GPU-backed Chrome (Metal). the
+        // bundled swiftshader shell software-renders the canvas and pegs every
+        // core; never use it for sootsim.
+        const browser = await launchReapedChrome((options) => chromium.launch(options), {
+          headless: true,
+        })
+        const page = await browser.newPage({ viewport: { width: 500, height: 900 } })
+
+        try {
+          await page.goto(context.url, { waitUntil: 'networkidle' })
+          await page.waitForTimeout(2000)
+
+          const outputPath = path.join(context.outputDir, `${params.name}.png`)
+          fs.mkdirSync(path.dirname(outputPath), { recursive: true })
+          await page.screenshot({ path: outputPath })
+
+          return {
+            success: true,
+            message: `Screenshot saved: ${params.name}`,
+            artifacts: [{ type: 'screenshot', name: params.name, path: outputPath }],
+          }
+        } finally {
+          await browser.close()
+        }
+      },
+    },
+  ],
+}

package/src/skills/builtin/visual-diff.ts

@@ -0,0 +1,100 @@
+// built-in skill: visual diff against baselines
+
+import { launchReapedChrome } from '../../../../../scripts/lib/reap-browser'
+import type { RNXSkill } from '../types'
+
+export const skill: RNXSkill = {
+  name: 'visual-diff',
+  description: 'Compare current rendering against baseline screenshots',
+  type: 'review',
+  version: '1.0.0',
+  triggers: ['visual diff', 'compare', 'visual regression', 'diff screenshots'],
+  tools: [
+    {
+      name: 'visual_diff',
+      description: 'Compare current screen against a baseline screenshot',
+      parameters: {
+        baseline: {
+          type: 'string',
+          description: 'Path to baseline screenshot',
+          required: true,
+        },
+        name: { type: 'string', description: 'Name for the diff output', required: true },
+        threshold: {
+          type: 'number',
+          description: 'Pixel match threshold (0-1, default 0.1)',
+        },
+      },
+      async execute(params, context) {
+        const { chromium } = await import('playwright')
+        const path = await import('path')
+        const fs = await import('fs')
+
+        // sootsim renders CanvasKit — require GPU-backed Chrome (Metal). the
+        // bundled swiftshader shell software-renders the canvas and pegs every
+        // core; never use it for sootsim.
+        const browser = await launchReapedChrome((options) => chromium.launch(options), {
+          headless: true,
+        })
+        const page = await browser.newPage({ viewport: { width: 500, height: 900 } })
+
+        try {
+          await page.goto(context.url, { waitUntil: 'networkidle' })
+          await page.waitForTimeout(2000)
+
+          // capture current
+          const currentPath = path.join(context.outputDir, `${params.name}-current.png`)
+          fs.mkdirSync(path.dirname(currentPath), { recursive: true })
+          await page.screenshot({ path: currentPath })
+
+          // compare using pixelmatch if available
+          try {
+            const { PNG } = await import('pngjs')
+            const pixelmatch = (await import('pixelmatch')).default
+
+            const baseline = PNG.sync.read(fs.readFileSync(params.baseline))
+            const current = PNG.sync.read(fs.readFileSync(currentPath))
+
+            const { width, height } = baseline
+            const diff = new PNG({ width, height })
+
+            const numDiffPixels = pixelmatch(
+              baseline.data,
+              current.data,
+              diff.data,
+              width,
+              height,
+              { threshold: params.threshold || 0.1 },
+            )
+
+            const diffPath = path.join(context.outputDir, `${params.name}-diff.png`)
+            fs.writeFileSync(diffPath, PNG.sync.write(diff))
+
+            const totalPixels = width * height
+            const diffPercent = ((numDiffPixels / totalPixels) * 100).toFixed(2)
+
+            return {
+              success: numDiffPixels === 0,
+              message: `${diffPercent}% difference (${numDiffPixels} pixels)`,
+              artifacts: [
+                { type: 'screenshot', name: `${params.name}-current`, path: currentPath },
+                { type: 'screenshot', name: `${params.name}-diff`, path: diffPath },
+              ],
+              data: { diffPixels: numDiffPixels, totalPixels, diffPercent },
+            }
+          } catch {
+            return {
+              success: true,
+              message: 'Screenshot captured (pixelmatch not available for comparison)',
+              artifacts: [
+                { type: 'screenshot', name: `${params.name}-current`, path: currentPath },
+              ],
+            }
+          }
+        } finally {
+          await browser.close()
+        }
+      },
+    },
+  ],
+}

package/src/skills/registry.ts

@@ -0,0 +1,107 @@
+// skill registry — load, discover, and match skills
+
+import * as fs from 'fs'
+import * as path from 'path'
+import { skill as a11yReviewSkill } from './builtin/a11y-review'
+import { skill as compatCheckSkill } from './builtin/compat-check'
+import { skill as maestroTestSkill } from './builtin/maestro-test'
+import { skill as perfProfileSkill } from './builtin/perf-profile'
+import { skill as screenshotAllSkill } from './builtin/screenshot-all'
+import { skill as visualDiffSkill } from './builtin/visual-diff'
+import type { RNXSkill, SkillContext } from './types'
+
+const _skills: Map<string, RNXSkill> = new Map()
+const BUILTIN_SKILLS = [
+  a11yReviewSkill,
+  compatCheckSkill,
+  perfProfileSkill,
+  screenshotAllSkill,
+  maestroTestSkill,
+  visualDiffSkill,
+]
+
+export const skillRegistry = {
+  register(skill: RNXSkill) {
+    _skills.set(skill.name, skill)
+  },
+
+  get(name: string): RNXSkill | undefined {
+    return _skills.get(name)
+  },
+
+  listAll(): RNXSkill[] {
+    return Array.from(_skills.values())
+  },
+
+  // match skills by natural language query against triggers
+  match(query: string): RNXSkill[] {
+    const q = query.toLowerCase()
+    return this.listAll().filter((skill) =>
+      skill.triggers.some((trigger) => q.includes(trigger.toLowerCase())),
+    )
+  },
+
+  // load built-in skills
+  async loadBuiltins() {
+    for (const skill of BUILTIN_SKILLS) {
+      this.register(skill)
+    }
+  },
+
+  // load skills from a project manifest (rnx-skills.json)
+  async loadFromManifest(projectDir: string) {
+    const manifestPath = path.join(projectDir, 'rnx-skills.json')
+    if (!fs.existsSync(manifestPath)) return
+
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'))
+      if (Array.isArray(manifest.skills)) {
+        for (const entry of manifest.skills) {
+          if (typeof entry === 'string') {
+            // npm package name
+            try {
+              const mod = await import(entry)
+              if (mod.skill) this.register(mod.skill)
+            } catch {}
+          } else if (entry.file) {
+            // local file
+            try {
+              const mod = await import(path.resolve(projectDir, entry.file))
+              if (mod.skill) this.register(mod.skill)
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  },
+
+  // auto-discover skills based on project dependencies
+  suggestSkills(projectDir: string): string[] {
+    const suggestions: string[] = []
+    const pkgPath = path.join(projectDir, 'package.json')
+    if (!fs.existsSync(pkgPath)) return suggestions
+
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+
+      // suggest testing skill if detox or maestro is in deps
+      if (deps['detox'] || deps['maestro']) {
+        suggestions.push('maestro-test')
+      }
+
+      // suggest a11y review if no a11y testing library
+      if (!deps['jest-axe'] && !deps['@testing-library/jest-dom']) {
+        suggestions.push('a11y-review')
+      }
+
+      // always suggest visual-diff and screenshot
+      suggestions.push('visual-diff', 'screenshot-all')
+
+      // suggest perf if app has many screens
+      suggestions.push('perf-profile')
+    } catch {}
+
+    return suggestions
+  },
+}