Jest plugins

Write modern JavaScript/TypeScript applications using ES6+ patterns and advanced type safety, build Node.js backends with Express/Fastify, implement testing with Jest/Vitest, and scaffold projects for Next.js, React, and CLIs.

Generate unit and integration tests for Python and JavaScript with mocking, edge cases, and framework-specific patterns. Includes debugging and test automation with self-healing tests and CI/CD integration.

Write and run JavaScript/TypeScript tests with Jest, Vitest, and Testing Library, covering unit, integration, and e2e tests with mocking, fixtures, and TDD/BDD workflows.

Generate comprehensive unit tests from source code with automatic framework detection, covering happy paths, edge cases, error handling, and mocking for multiple languages.

Manage and run regression test suites across releases, mapping tests to bug tickets, detecting flaky tests, and analyzing change impact to prevent breaking existing functionality.

Generate structured test reports from JUnit XML, Jest JSON, and pytest results, producing Markdown summaries, HTML dashboards, and CI annotations with coverage metrics, pass/fail analysis, and trend comparisons.

Set up and manage comprehensive testing infrastructure across unit, integration, E2E, visual, load, mutation, and property-based testing. Analyze code quality, generate tests, enforce quality gates, and automate TDD workflows with CI/CD integration.

Generate realistic test data with locale awareness, producing factory functions, database seed scripts, and fixture files ready for immediate use in tests.

Validate load balancer configurations by generating Jest test suites that verify traffic distribution, failover handling, sticky sessions, and health checks across backends for NGINX, HAProxy, AWS ALB/NLB, GCP, and Kubernetes Ingress.

Manage and update snapshot tests across Jest, Vitest, Playwright, and Storybook with intelligent diff analysis for selective updates and regression testing.

Run integration tests with automated Docker environment setup, database seeding, and cleanup, validating API calls, database queries, and message queue interactions across services.

Orchestrate complex test workflows with parallel execution across multiple frameworks, intelligent sharding, retry logic, and CI pipeline generation. Manage test dependencies and run only affected tests based on file changes.

Generate ready-to-use test doubles (mocks, stubs, spies, fakes) by analyzing your code's dependencies, with support for Jest, Sinon, Python unittest.mock, Go interfaces, and testdouble.js.

Guides test-first (TDD/SDD) development from planning through implementation, verification, and debugging. Analyzes codebases to reverse-engineer specs, generates requirements and test cases, runs Playwright E2E tests, detects security vulnerabilities, and produces architecture diagrams and design documents.

Orchestrates AI agent workflows with structured planning, sub-agent task delegation, and quality verification loops. Enforces code quality, testing, security, and documentation standards across projects. Automates Git workflows, commit messages, and project knowledge base management.

Orchestrates multi-agent AI swarms across Claude Code, Gemini CLI, and Codex CLI to autonomously manage GitHub issues from creation through merged PR, with TDD enforcement, design review gates, adversarial code review, and PR shepherding.

Deploy a fleet of specialized AI agents for quality engineering: automated test generation, sublinear coverage analysis, chaos/resilience testing, mutation testing, flaky test remediation, and quality gate enforcement across CI/CD pipelines.

Guides mobile app testing strategies including unit tests, UI automation, and E2E flows, with support for setup, device farms, and flaky tests across iOS and Android.

Turn Claude Code into a QA engineer capable of writing and executing end-to-end tests with Playwright and Cypress, API tests, unit tests with Jest and pytest, performance tests with k6, and running an autonomous QA agent that explores apps, generates tests, and self-heals.

Run multi-layer code quality and security audits for Drupal and Next.js projects, with cross-tool synthesis, rubric-scored reviews, 3-agent security/architecture debates, and CI-ready JSON output.

Enforces a consistent code and writing style across TypeScript, React, PostgreSQL, and testing, with property-driven design, defense-in-depth validation, and Functional Core/Imperative Shell patterns.

Enforce AI-first code conventions, audit staged diffs for OWASP security issues, generate architecture docs and session summaries, and check tool-stack freshness — all via skills, hooks, and agents that complement other plugins.

Provides a dedicated QA engineer that creates test strategies, builds E2E suites with Playwright or Cypress, performs API testing (REST, GraphQL, gRPC), audits test health for flaky tests and coverage gaps, and runs visual design reviews.

Perform a comprehensive test reconnaissance: inventory test frameworks, test files, code coverage, and CI integration, and assess testing maturity for project takeover or audit.

Generate a test strategy for a project or feature including risk map, test type decisions (unit/integration/E2E), coverage targets, and CI configuration. Handles queries like 'create test strategy', 'testing plan', or 'improve test coverage'.

Build cross-platform web and native apps with React Native Web, providing core abstractions, navigation, performance optimization, styling patterns, and testing setup

Configure and run Jest test suites for JavaScript and TypeScript projects with custom matchers, parameterized tests, coverage thresholds, and performance optimization patterns.

Generate and run tests across pytest, Playwright, Jest, Cypress, and more; debug failures; and scan APIs for OWASP Top 10 vulnerabilities — all from Claude Code.

Guides NestJS dependency injection, guards, interceptors, and testing patterns for building modular, secure, and well-tested Node.js applications.

Orchestrates a multi-agent AI harness for React Native and Expo development, enabling autonomous feature implementation, code review, performance profiling, visual debugging, and version migration through coordinated agents and commands.

Provides a diverse collection of skills for media processing, MCP server development, code testing (E2E/unit), project management, documentation, presentation generation, and incident analysis, supporting multiple technologies and automation workflows.

Accelerate Drupal and WordPress development with AI agents that convert Figma designs to code, validate implementations in real browsers, generate tests and documentation, manage drupal.org contribution workflows, and enforce PR best practices with conventional commits and release checklists.

Autonomous spec-driven development loop: turn rough ideas into structured requirements, decompose them into dependency-ordered task plans, then implement, test, review, and commit each task with behavioral guardrails and knowledge-graph context.

Automates testing across web and mobile apps — unit, integration, e2e, performance, accessibility, and visual — to reduce bugs and improve reliability.

Automated test execution, analysis, and quality improvement across Python, JavaScript/TypeScript, Go, and Rust projects. Provides property-based testing, mutation testing, test smell detection, multi-tier test runner (unit/integration/E2E) with fail-fast execution, and CI setup. Supports pytest, Vitest, Jest, Playwright, Cypress.

Guides AI-assisted development through a spec-driven TDD workflow: triage, discovery, spec writing, architecture evaluation, TDD planning for various patterns (outside-in, ping-pong, CQRS, MVC), code generation, test writing, browser verification, code quality and hotspot analysis, and structured review loops with ship recommendations.

Develop React applications with generated components, architecture patterns, testing, and automated code review, all using TypeScript and modern best practices.

Autonomously develop features end-to-end: write specs, break into tasks, implement with subagents, review for bugs and architecture, then summarize changes for pull requests.

Scaffolds and configures React Native projects for both Expo (managed/dev-client) and bare workflows: sets up navigation with React Navigation v7 and Expo Router, handles platform-specific code for iOS/Android, recommends state management and secure storage options (AsyncStorage, MMKV, SecureStore, Keychain), and configures testing with Jest, React Testing Library Native, and optional Detox/Maestro e2e.

Develop full-stack Next.js applications with App Router, Server Components, Server Actions, and Route Handlers. Covers project structure, data fetching (SSG/ISR/SSR/streaming), routing primitives, testing strategies, and RSC vs Client Component decisions. Includes an agent for implementation and hooks for data governance.

Build Angular 18-21 SPAs with standalone components, signals, NgRx state management, typed reactive forms, functional route guards, and component testing via TestBed, harnesses, and Angular Testing Library.

Guides React SPA development with best practices for component structure, hooks, state management, routing, forms, and testing. Includes an agent for end-to-end feature building and hooks for data governance to track data asset lineage.

Build NestJS backend applications with opinionated patterns for REST APIs, GraphQL, WebSockets, microservices, and ORM integration (TypeORM/Prisma/Mongoose), including testing with Jest and supertest.

Provides React 19 expertise for building apps with Server/Client Components, hooks, state management, forms, and testing. Includes commands to generate components, hooks, and tests, plus performance analysis.

Remove redundant comments from code and tests, enforce strict test assertions with deep equality, and add emojis to documentation for readability.

Generates tests across Jest, Vitest, Pytest, Cypress, and Playwright; optimizes prompts for AI models; researches external documentation and best practices; creates and updates CLAUDE.md files from staged git changes; and produces formatted documents (PDF, DOCX, HTML) from markdown.

Interpret GitHub Actions CI failure logs from Shopware workflows by filtering noise and identifying root causes across PHPUnit, PHPStan, ESLint, TypeScript, Jest, Playwright, and other tools.

Orchestrates multi-agent development workflows by decomposing plans into tasks, dispatching autonomous agents for implementation, code review, and research, and enforcing code quality and documentation conventions.

Accelerate React Native and Expo development with a comprehensive skills library covering TDD, debugging, performance optimization, UI automation, code review, and git workflows. Includes parallel agent dispatch, implementation plan execution, and CI/CD setup for iOS and Android.

Run a full QA pipeline with agents that audit WCAG accessibility, test APIs (REST, GraphQL), benchmark performance, automate Playwright UI tests, analyze test failures, and optimize workflows — all with evidence-based validation and release readiness assessment.

Enforces disciplined software engineering workflows including test-driven development, structured code reviews, atomic git commits, plan-driven implementation, and systematic debugging with multi-agent verification and quality gates.

Scan TypeScript and Python test suites for assertions that can never fail — type-checker redundancies, tautologies, mock echoes, dead assertions, and duplicates — then delete them automatically.

Generate unit tests with mocking and edge cases, debug test failures with root cause analysis, and build automated testing ecosystems with self-healing tests and CI/CD integration

Enforce a structured context-driven development workflow with TDD, track management, and project initialization. Automates style guide application, spec/plan generation, and git-aware rollback across multiple languages.

Automates the full code review lifecycle: task planning, implementation, multi-platform testing (web/backend/mobile), evidence collection, PR automation, and structured reports covering code quality, security, accessibility, and E2E integrity.

A developer toolkit that automates code review, testing, security audits, accessibility checks, API validation, and documentation maintenance, with agents for PR analysis, Jira management, and design pattern mining.

Plan, implement, review, test, and document code across the full development lifecycle with structured workflows for feature planning, code review, debugging, security scanning, commit messages, release notes, and test generation.

Generate unit tests from source code with automatic detection of Jest, pytest, or JUnit frameworks, covering happy paths, edge cases, error handling, and mock dependencies.

Analyze snapshot test failures, perform selective updates, and validate snapshot quality across Jest, Vitest, Playwright, and Storybook with intelligent diff analysis.

Generate mocks, stubs, spies, and fakes for unit testing by analyzing code dependencies, producing ready-to-use implementations with usage examples for Jest and other frameworks.

Run Claude autonomously for 6-8 hours overnight using Git hooks that enforce test-driven development — wake up to fully tested features, refactored code, or fixed bugs with pre-commit test validation and coverage enforcement.

Develop Salesforce Commerce Cloud storefronts and backends across B2C (SFCC/Demandware) and B2B/D2C (Lightning) platforms, including SFRA cartridges, ISML templates, SCAPI/OCAPI APIs, PWA Kit headless React storefronts, Apex hooks, LWC components, Einstein AI recommendations, and Salesforce Payments integration.

Generate UML diagrams from real code with a multi-stage audit pipeline that verifies business correctness, diagram-code consistency, and notation readability, backed by an adversarial diagram auditor. Also strengthens mutation test suites by writing outcome-asserting tests.

Develop JavaScript and TypeScript applications with modern patterns, advanced type systems, Node.js backends, and testing workflows. Includes project scaffolding and expert guidance for complex type architecture and full-stack development.

Automates the full Jira development lifecycle: discover requirements, create issues, start tasks with git worktrees, generate approach docs, implement code, run tests, review changes, create PRs, merge locally, and post completion reports with status dashboards.

Accelerate development workflows with code reviews, API design (REST/GraphQL), test generation (Jest/Pytest/Go), Draw.io architecture diagrams, and cost-optimized ML training on AWS SageMaker.

Enforce a shift-left development pipeline by deriving merge readiness from git/gh artifacts, govern writes to external systems (Notion, Slack, GitHub, Linear) with explicit-instruction-only rules, and restrict test execution to files changed in recent commits using runner-specific filters for Gradle, pytest, Jest, Go, and Cargo.

Accelerate React Native mobile development with specialized agents for navigation, state management, native modules, animations, testing, and deployment. Includes skill assessment and learning path guidance for React Native developers.

Analyze test coverage from Jest, Vitest, pytest, and Go projects, generate test fixtures and mock data, execute tests with auto-detected frameworks, and get prioritized recommendations for improving coverage gaps.

Enforce spec-driven development with structured specs, automated proof auditing, drift detection, and test-coverage verification across features.

Lint JavaScript/TypeScript projects with ESLint, write high-quality Jest unit tests using patterns like AAA/USE, and migrate from Jest to Vitest with automated codemods and best practices.

Automates frontend development workflows with AI agents for testing, code review, and implementation. Integrates multi-agent collaboration (OpenAI Codex, Agent Teams), converts Figma designs to React components, generates Playwright E2E tests, and manages git lifecycle. Includes voice input, research, startup validation, and Jira/Confluence MCP connectors.

Develop, test, and troubleshoot Temporal.io workflows across Python, Go, TypeScript, Java, .NET, and PHP SDKs with expert guidance on determinism, patterns, and production incidents.

Orchestrate full multi-layer test suites — unit, integration, and E2E — by delegating to specialist agents that scan projects, generate tests with coverage targets, and validate across APIs, databases, and UI workflows.

Run 35+ research-derived code review lenses on diffs or PRs to catch correctness, security, performance, accessibility, and architecture issues, then merge findings into a ranked verdict.

Manage multi-tenant MERN platforms on Keycloak: administer realms/users/clients, orchestrate Docker microservices, validate env configs, generate Jest tests, and enforce ADR guardrails.

Enforce Definition of Done and quality gates across the PR lifecycle with automated code review, security vulnerability scanning, test coverage validation, and TDD-based bug resolution orchestrated by specialized agents.

Run a unified pipeline of 5 code quality gates — linting, test coverage, security scanning, complexity analysis, and dependency health — across JavaScript, TypeScript, Python, Go, Rust, and more. Automatically fix issues, enforce thresholds, and generate detailed reports in console, JSON, Markdown, HTML, or integrate with Jira and GitHub PRs.

Orchestrates 10 agents to produce production-grade API integrations from OpenAPI/GraphQL specs: typed clients, auth flows, error handling with retries/circuit breakers, rate limiting, mock servers, and generated test suites.

Orchestrates a complete TypeScript development workflow: architecture design with Mermaid diagrams, implementation following project conventions, Jest/Vitest testing patterns, and specialized code review for type safety and async patterns.

Enforce development standards across TypeScript/JS projects: type safety, CI configuration, conventional commits, dependency pinning, test setups, and pre-commit hooks. Get compliance reports via /dev-standards or auto-fix with --fix.

Enforces a consistent house style for writing code and English across TypeScript, React, PostgreSQL, and testing, covering property-driven design, defense-in-depth validation, FCIS patterns, and clear technical documentation.

Enforce JavaScript code quality with ESLint linting, Prettier formatting, and Jest/Vitest testing, targeting zero errors and 90%+ coverage on demand.

Runs TypeScript quality checks in a single pass: type checking (tsc --noEmit), linting (ESLint), formatting (Prettier), and testing (Jest/Vitest) with strict enforcement of 0 errors and 90%+ coverage.

Production-ready Salesforce development with expert subagents for Apex, LWC, SOQL, org configuration, CI/CD, security audits, and quality gates. Automates planning, coding, testing, deployment, and documentation across the Salesforce platform.

Automates technical debt reduction by scanning dependencies for vulnerabilities, analyzing code for smells and SOLID violations, and generating prioritized refactoring plans, while also providing autonomous code review and AI-powered test generation with self-healing capabilities.

Automatically generate unit and integration tests for Python and JavaScript projects with mocking and edge case coverage, and debug test failures through root cause analysis and self-healing tests.

Orchestrate end-to-end full-stack feature development from architecture design to deployment, integrating automated CI/CD pipelines, security audits, performance tuning, and AI-driven test generation across backend, frontend, database, and infrastructure layers.

Run multi-layered code reviews combining static analysis tools with AI reasoning, and delegate performance engineering and test automation to specialized agents for load testing, observability, caching, and self-healing test generation.

Auto-detect testing frameworks (Jest, Vitest, Mocha, Playwright, Cypress) and generate unit, API, and E2E tests with coverage analysis, test strategy planning, and failure diagnostics across your project.

Build React applications with patterns for component architecture, hooks, context-based state management, server state handling via TanStack Query, and component testing with React Testing Library.

Write structured Jest unit tests with patterns for test organization, mocking, async code, and coverage configuration.

Orchestrates a complete feature development lifecycle from codebase mapping and TDD test design through implementation, multi-agent code review (bugs, security, performance, style, conventions), UI verification, and PR creation with state persistence for resumable workflows.

Enforces quality and best practices for React Native Web projects, offering validated patterns for cross-platform navigation, responsive styling, performance optimization, and component testing.

Configure and execute Jest test suites with custom matchers (sync, async, TypeScript), parameterized tests, coverage thresholds, and mocking/spying patterns for JavaScript and TypeScript projects.