Jest plugins

Develop full-stack JavaScript and TypeScript projects with ES6+, Node.js APIs (Express/Fastify), and modern frontend frameworks. Includes testing with Jest/Vitest, advanced TypeScript types, and project scaffolding for Next.js, React, or Node services.

Enforce strict red-green-refactor TDD cycles: generate failing tests, implement minimal passing code, then refactor while keeping tests green. Includes AI-powered code review for security and quality.

Automatically generate production-ready unit tests from source code files or snippets in JavaScript/TypeScript (using Jest, Vitest, or Mocha), Python (pytest), Java (JUnit 5), and Go. Auto-detects frameworks, covers happy paths, edge cases, boundaries, errors, and provides mocks for robust testing.

Automate overnight software development by configuring Git hooks for TDD enforcement with tests and lints, then run Claude autonomously for 6-8 hours to build features that pass all checks by morning.

Generate fast (<5min) smoke test suites in Jest-style JavaScript for critical paths like system health, authentication, and core features, then run them post-deployment via Playwright, curl, Bash scripts, or CI/CD to verify UI, APIs, and functionality.

Track regression tests across code releases by mapping git commits to pytest or Jest tests, tagging markers for suites, flagging coverage gaps, generating pass/fail reports with flaky detection, viewing history, and enforcing runs in CI/CD pipelines.

Audit web pages and components for WCAG 2.1/2.2 accessibility compliance using axe-core, Playwright, Pa11y, Lighthouse, and more. Detect ARIA errors, keyboard navigation issues, color contrast violations, and screen reader incompatibilities, then generate markdown reports with prioritized fixes and code examples.

Analyze test coverage reports from Jest/nyc, pytest, Go test, and JaCoCo across JavaScript, Python, Go, and Java projects to identify untested code paths, branch gaps, low-coverage files, enforce thresholds, and generate detailed reports with targeted test recommendations.

Generate test reports by parsing JUnit XML, Jest JSON, pytest results, and coverage data into Markdown/HTML formats with metrics, failures, slowest tests, trends, and CI annotations. Aggregate results across frameworks for summaries and exports in HTML, PDF, or JSON.

Orchestrate multi-agent coding workflows with context-aware task decomposition, parallel subtask execution, automated code review, and TDD test generation.

Provision and manage isolated test environments using Docker Compose and Testcontainers for databases, caches, queues like PostgreSQL, MySQL, Redis, DynamoDB. Generate docker-compose files, env vars, seed data scripts, startup scripts, and cleanup code to enable reliable, reproducible testing without local setup conflicts.

Equip Windsurf AI IDE with 30 Cascade skills to automate code generation, debugging, testing, multi-file refactoring, CI/CD workflows, Docker setups, Git integrations, security configurations, and enterprise onboarding, streamlining full dev lifecycles.

Integrate production-grade Exa neural search into Node.js/TypeScript apps across the full lifecycle: install SDK with auth, configure multi-env setups and caching, secure with guardrails and RBAC, optimize performance/costs/reliability, add monitoring/observability, deploy to Vercel/Docker/Cloud Run, set up CI/CD tests, and troubleshoot incidents via 30 targeted skills.

Test load balancing strategies by validating traffic distribution, health checks, failover, session persistence, and SSL on live NGINX, HAProxy, AWS ALB/NLB, GCP, and Kubernetes Ingress setups. Generate Jest test suites to verify these behaviors across backends.

Generate test doubles—mocks, stubs, spies, fakes—for unit testing by analyzing code dependencies. Produces implementations, fixtures, example tests, and rationale. Works across JavaScript (Jest, Vitest, Sinon), Python (pytest, unittest.mock), Go (gomock), and more frameworks.

Automate database testing workflows by generating test suites with data factories, transaction wrappers for automatic rollback, schema validation, assertions, cleanup, fixtures, migrations, integrity checks, and performance monitoring across PostgreSQL, MySQL, MongoDB, SQLite, Redis using Prisma, Drizzle, Jest, Pytest.

Create and manage snapshot tests for UI components and data using Jest, Vitest, or pytest to catch regressions. Analyze test failures with intelligent diff reviews, selectively update snapshots for intentional changes, validate and organize snapshot files, then generate detailed analysis reports.

Generate and execute comprehensive test suites for REST and GraphQL APIs directly from OpenAPI specs, automating request generation, schema/response validation, CRUD coverage, auth handling, error/performance checks, idempotency tests, with reporting in Jest, pytest, Supertest, or REST-assured.

Orchestrate complex test workflows across Jest, Vitest, pytest, Playwright, and Cypress with parallel execution, test sharding, dependency management, flakey retries, affected test selection, and result aggregation in GitHub Actions or GitLab CI. Generate optimized configs for CI/CD pipelines.

Generate realistic test data for users, products, orders, technical fields, and custom schemas to populate fixtures, factories, seeds, edge cases, and databases in JS/TS/Python/Ruby apps using Faker.js, Fishery, pytest fixtures, and factory patterns.

Enforce strict TDD workflow: write minimal failing tests first for complex logic or public APIs, verify red phase failure, implement green-passing code without internal mocks, then refactor safely. Supports unit and integration tests with Jest.

Enforces Test-Driven Development by detecting the test framework, installing a reporter, and outputting test results. Blocks file writes with forbidden terms and enforces semantic rules via bash guards and LLM prompt checks.

Enforce TDD and SDD workflows with AI-driven agents that scaffold projects, generate tests, debug failures, reverse-engineer docs, and orchestrate batch task execution from design plans.

Delegate specialized AI agents to automate code reviews on git diffs, security audits for APIs and auth per OWASP, debugging of errors and incidents, test generation with Jest/pytest, performance profiling, and quality assurance across dev workflows.

Automate code analysis, test setup, and quality enhancement across JavaScript, TypeScript, Python, Java, Go, Rust, and Ruby by running slash commands that generate unit/integration/E2E/mutation/property/load/visual tests, fix linting/formatting issues, analyze coverage/performance/security, reproduce bugs with failing tests, optimize code, and integrate CI/CD workflows.

Generate unit tests for functions, classes, or modules using your project's Jest or Pytest framework. Automatically mocks dependencies, follows conventions, runs tests, and reports count plus coverage to accelerate testing workflows.

Generate and run unit tests for functions and classes across Jest, Vitest, or Pytest, mocking dependencies, covering happy paths, edge cases, errors, and providing coverage summaries. Create integration tests using Docker to simulate real database, API, and queue interactions with full verification.

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 structured development workflows from idea to PR merge: clarifies ideas, brainstorms and documents designs, creates git branches/worktrees, plans and executes tasks via subagents with TDD, systematic debugging, automated code reviews, verifications, and git integration.

Orchestrate a fleet of 11 AI-powered QE agents to automate comprehensive quality engineering: generate unit/integration/E2E tests for Jest/Vitest/Playwright/Pytest, perform sublinear coverage analysis and gap prioritization, run chaos/resilience experiments on Docker/K8s, guide TDD workflows, benchmark performance, enforce git/CI quality gates, detect flakiness/security issues, and produce reports.

Execute structured, evidence-driven engineering workflows in Claude Code across 5 phases (Investigate, Design, Implement, Verify, Ship) using 15 skills and 8 specialist agents that enforce TDD, root-cause analysis, architecture/UX/security reviews, dependency audits, PR preparation, and incremental shipping with pasted test outputs, logs, and diffs as proof before advancing.

Implement mobile app testing strategies for React Native, iOS, and Android: configure unit tests with Jest/XCTest/JUnit, automate UI interactions using Detox/Espresso/Appium, design E2E workflows, set up device farms, and debug flaky tests or platform-specific errors.

Generate complete Jest unit tests for JavaScript/TypeScript modules and React components, automatically including mocking, spies, snapshots, and coverage. Quickly create tests, address missing coverage gaps, or fix improper mocking setups in your codebase.

Automates the end-to-end development workflow: specify requirements via structured interview, generate a plan with contract-first design, execute with parallel research agents and hook-based guards, and manage PR states from draft to review. Includes autonomous bug diagnosis, multi-source technical research, knowledge extraction from PRs, and verification with static checks, CLI tests, and browser QA.

Enforce Ed's house style for writing, refactoring, and reviewing TypeScript/React code, PostgreSQL queries, tests with AAA structure and property-based approaches, plus clear technical documentation to maintain team consistency and quality.

Structure software projects into context-driven tracks: scaffold setups, generate specs and plans from project docs, implement tasks via AI agents with git snapshots, review code for quality/security/test coverage, track progress, manage skills/snippets/patterns, and revert via git history.

Enforce a specification-first development workflow: decompose requirements into atomic specs, run automated gates, evolve specs via agent cycles, and use pair programming (Navigator-Driver) with independent test generation.

Enforce validation and best practices in React Native Web projects to build cross-platform web and native apps, covering core platform abstraction, React Navigation routing with deep linking, performance optimizations like code splitting and memoization, responsive StyleSheet theming, and Jest-based testing workflows.

Automate end-to-end React Native/Expo app development with multi-agent AI harness: orchestrate planning, feature coding, TDD cycles, visual/video debugging, performance profiling, security audits, native module scaffolding, SDK upgrades, and autonomous ticket-to-PR workflows via 22 commands and 13 agents.

Run, generate, debug, and harden software tests using pytest, Playwright, Jest, Cypress, and more; scan OpenAPI specs for OWASP API Top 10 vulnerabilities and solve CAPTCHAs via an AI visual solver

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

Execute unit/integration/E2E tests across Python (pytest), JS/TS (Vitest/Jest), Rust (cargo), Go projects with quick/fail-fast/full runs, coverage, reports, and Playwright browser automation. Analyze test quality for smells/gaps, run property/mutation testing, and consult TDD strategies for effective suites.

Develop NestJS applications with advanced patterns for dependency injection, guards, interceptors, and unit testing, including JWT authentication and modular modular design.

Orchestrate multi-agent AI teams through structured PACT phases (Prepare, Architect, Code, Test) to delegate and complete development tasks like feature implementation, n8n workflow building, git worktree isolation, PR creation with peer review, security audits, and persistent memory management.

Automate documentation, test generation, and prompt optimization within Claude Code sessions — maintain CLAUDE.md files from git changes, generate tests with Jest/Vitest/Pytest/Cypress/Playwright, and refine prompts for AI models using chain-of-thought and few-shot techniques.

Automates a spec-driven development loop that transforms rough ideas into structured specifications, implements tasks with TDD and behavioral guardrails, traces bugs back to spec gaps, and enables multiplayer collaboration with knowledge graph integration.

Execute Spec-Driven Development (SDD) workflows to build features: generate EARS requirements docs, technical designs, hierarchical TDD tasks, implement with Red-Green-Refactor cycles and SOLID principles, run code reviews, OWASP security audits, and Conventional Commits.

Scan JavaScript and TypeScript codebases via command line to detect unused functions, variables, exports, unreachable code, and low-coverage areas, enabling targeted dead code elimination and Jest coverage integration for codebase cleanup.

Design comprehensive testing strategies, automation frameworks, and quality metrics for web/mobile apps using Jest, Cypress, Playwright, Vitest, Firebase, and CI/CD pipelines to boost reliability, coverage, and efficiency.

Paste GitHub Actions CI failure logs from Shopware workflows to get noise-filtered interpretations that pinpoint root causes across PHPUnit tests, PHPStan analysis, ECS, ESLint, TypeScript checks, Stylelint, Prettier formatting, Jest, Playwright e2e tests, ludtwig, and Lighthouse audits.

Generate modern React components, custom hooks, and Tailwind styles with TypeScript; implement patterns like composition and state management with Zustand; design app architectures; write Vitest and Jest tests; review code for best practices, performance, accessibility, and quality using specialized agents.

Accelerate React Native and Expo development with TDD workflows, automated UI testing on-device testing, performance profiling, CI/CD setup, and structured code review — all orchestrated through Claude Code skills and agents.

Scaffold, customize, theme, and optimize Material UI (MUI) apps in React/Next.js with specialized commands for DataGrids, charts, TreeViews, forms, SSR, performance tuning, accessibility audits, testing, multi-tenant design systems, and v4-v6 migrations using 27 skills, 14 commands, and 7 agents.

Automate end-to-end product development: write specs, generate tasks, implement code with subagents, run tests, review changes, and summarize diffs—or execute individual steps like code review or change summarization.

Generate TypeScript React 19 components, custom hooks, and Vitest/RTL tests via commands; implement Server/Client Components, state management with Zustand/Context, forms using React Hook Form/Zod, performance optimizations; consult expert agent for patterns, hooks, and architecture.

Enforce code quality across your projects by automatically cleaning redundant comments and dead code from git changes or entire repos, adding engaging emojis to docs and comments, fixing Java code generator formatting issues with @formatter guards, upgrading test assertions to strict deep equality in Jest/Vitest, and guiding optimal Bash/Git CLI usage.

Manage full development lifecycle with task planning, git worktree-based branch workflows, test-driven implementation, automated PR creation and review, and multi-environment verification (web E2E with Playwright, backend API tests, mobile Maestro E2E) backed by structured evidence reports.

Software development workflow augmentation: debug with root-cause analysis, audit code and architecture, generate structured specs from requirements, manage Obsidian vaults with PARA methodology, write tests, review PRs, and produce documentation, blog posts, or conference talks.

Provides a collection of reusable skills for TypeScript/NestJS projects: creating MCP servers, writing E2E and unit tests with Jest and Docker, converting EPUB books to Markdown, generating interactive presentations, and managing git workflows across multi-repo projects

Guides AI-assisted development through a spec-driven TDD workflow: triage, spec writing, architecture evaluation, TDD planning, ping-pong test-code cycles, browser verification, and code review. Includes codebase analysis, dependency analysis, git hotspot detection, and design discovery.

Orchestrate an AI agent mesh to auto-detect tech stacks and test frameworks across JavaScript, Python, Ruby, and C# projects; bootstrap dev infrastructure with constitutions, docs, and gitignores; log sessions; optimize context files; scaffold templates; and proactively monitor changes to prevent context drift.

Orchestrate multi-agent AI workflows that decompose high-level development plans into sequential tasks, dispatch researcher, coder, and reviewer agents to explore codebases, implement features, perform code reviews for security and quality, and verify spec alignment using supervisor loops and composable skills.

Develop modern JavaScript/TypeScript apps and Node.js backends by scaffolding projects with pnpm/Vitest/ESLint, applying ES6+ patterns for refactoring/optimization, implementing Express/Fastify APIs with auth/DB/WebSockets, mastering advanced types/generics, and running Jest/Vitest tests via skills, commands, and expert agents.

Automated code quality and security auditing for Drupal (PHP) and Next.js (JavaScript/TypeScript) projects. Runs comprehensive linting, static analysis, security scans, SOLID/DRY checks, test coverage, and TDD workflow with multi-agent debates for balanced improvements.

Generate Draw.io diagrams for architectures, flowcharts, ERDs, and AWS cloud setups; create unit, integration, and E2E tests for Jest (JS/TS), Pytest (Python), and Go; design REST/GraphQL APIs with schemas; perform code reviews assessing security, performance, and maintainability; optimize cost-effective ML training on SageMaker Spot instances.

Orchestrate AI-powered dev workflows to audit code completeness across accessibility/testing/docs/security/observability, create/optimize CI/CD pipelines, design/review DB schemas with ERDs/migrations, generate tests/docs/API integrations/SDKs, perform research/spikes, and refine tasks via codebase exploration with tracking, skill routing, and execution hooks.

Generates unit tests for Python, JS/TS, Java, and Go with mocking and edge-case coverage, debugs test failures and unexpected behavior through root-cause analysis, and builds self-healing test suites with Playwright, Cypress, Jest, and pytest integrated into CI/CD pipelines.

Develop, test, and troubleshoot Temporal.io workflows and activities across Python, Go, and TypeScript SDKs using specialized agents for SDK patterns, async handling, determinism, pytest/Jest tests, and error diagnosis including performance issues.

Orchestrate complete test suites by scanning projects for unit, integration, and E2E testing gaps, then delegate specialist agents to generate, run, update tests, report coverage, and apply fixes. Handles Jest/Vitest/Pytest for units, Playwright for E2E, API/GraphQL/SQL for integrations.

Manage context-driven development workflows with structured tracks (features/bugs/chores), specs, plans, and TDD cycles. Automates project initialization, style guide enforcement, git worktree management, and phased implementation with quality gates and rollback.

Manage multi-tenant MERN platforms on Keycloak: administer realms, users, clients, and themes; orchestrate Docker Compose microservices with health checks and env validation; generate Jest tests from Express routes with auth mocking.

Audit code, APIs, and tests for quality issues across dimensions — type safety, error handling, test robustness, API compliance, and accessibility — using specialized agents that review diffs, verify OpenAPI specs, mutate tests, and enforce coding standards.

Draw UML and architecture diagrams from real code with a 3-tier gated pipeline that audits business correctness, diagram-code alignment, and notation quality before rendering, plus an adversarial auditor that cross-module verifies diagrams against actual code with file:line evidence.

Generate and edit AI images for project assets like UI mockups, logos, and covers using OpenAI API via Python CLI. Automatically add comprehensive tests to JavaScript, TypeScript, Python, or Go files or functions, detecting frameworks and running them. Debug errors, crashes, and test failures with a systematic agent that reproduces issues, hypothesizes fixes, tests, and verifies across bash, git, JS/TS/Python.

Automate the full Jira development lifecycle within Claude Code: create and discover issues, design approaches, implement code, run tests, review changes, create pull requests, merge branches, and generate status reports, all synced with Jira project management.

Build and maintain production-ready web applications with React, Tailwind CSS, and TypeScript, using test-driven development, automated UI feedback loops via Playwright, and structured code review for quality and accessibility.

Enforce rule-proof spec-driven development by creating specs that define constraints, running tests to generate proofs, tracking coverage via sync_status, and detecting drift when code diverges from specs.

Configure ESLint to analyze code issues and apply fixes in JavaScript/TypeScript projects supporting React and Node.js. Author high-quality Jest unit tests using AAA patterns, mocks, async handling, and TDD to avoid flakiness. Migrate Jest setups to Vitest through codemods, config changes, and troubleshooting. Run Vitest tasks via dedicated command.

Automates spec-driven development (SDD) workflows: from spec generation and test creation (unit/integration/e2e) to task decomposition, auto-loop sprint execution, adversarial code reviews, baseline capture with Playwright, and code cleanup — enabling AI teams to iterate from specification to verified delivery.

Orchestrates an AI crew that takes any React Native or TypeScript backend task from idea to pull request with a single human checkpoint — a team-lead agent dispatches specialist developers, QA engineers, security auditors, and web researchers to handle specification, planning, implementation, testing, review, and deployment readiness.

Automate pull request quality gates with an ensemble of agents that perform security scans for SQLi/XSS vulnerabilities, enforce code maintainability and DoD criteria, execute Jest/Vitest/Pytest/RSPEC tests, analyze coverage and flakiness, triage bugs from GitHub/Jira, and orchestrate debugging/fixes for merge approval.

Orchestrate autonomous development workflows in Claude Code using coordinated agents and skills: design APIs/architectures, generate/review/refactor/debug/test code, audit security/performance/production readiness, optimize bottlenecks, manage git commits/branches/sprints across repos.

Orchestrate 10 agents to transform OpenAPI/GraphQL specs into production-ready TypeScript API clients with type-safe methods, Zod schemas, OAuth/JWT auth flows, rate limiting strategies, retry/error handling, mock servers, interactive explorers, and complete test suites using Vitest/Jest/Playwright.

Build, test, and deploy Salesforce Apex, LWC, and Flows with autonomous agents that handle code generation, security scanning, deployment validation, and org configuration. Includes MCP servers for Salesforce CLI and DX operations.

Orchestrate coordinated AI agent teams that ship verified software through spec-driven TDD, trust-but-verify orchestration, environment-aware deployment, and cross-project learning — enabling autonomous development cycles with human oversight.

Enforce code quality standards across full-stack JavaScript and Python projects with automated code review, testing, git workflow management, and structured project scaffolding from concept to documentation.

Audit your repository for compliance with 7 development standards like avoiding TypeScript any/as, setting up CI with GitHub Actions, local test environments via Docker Compose, conventional commits, pinned dependencies, comprehensive tests with Jest, and pre-commit hooks with ESLint/Prettier; generate reports via /dev-standards and auto-fix issues with --fix.

Run ESLint, Prettier, and Jest/Vitest in one step to enforce JavaScript quality checks with zero errors and 90%+ coverage targets.

Enforce TypeScript code quality and test coverage with strict thresholds by running tsc, ESLint, Prettier, and Jest/Vitest in one command.

Enforce Ed's house style for TypeScript, React, PostgreSQL code by guiding writing, refactoring, and reviews with type rules, immutability, FCIS patterns, transaction safety, validation defenses, modern hooks, property-based and AAA testing, plus clear technical docs.

Guides development from ambiguous ideas through structured design clarification, TDD implementation, code review, and git-based integration—enforcing phased workflows for planning, execution, debugging, and quality validation.

Configure and write robust Jest unit tests for JavaScript/TypeScript projects using structured patterns like AAA and describe blocks, advanced mocking via factories and modules, async handling with promises and fake timers, plus coverage setup with thresholds and reporters to ensure high test quality.

Build scalable React apps using proven patterns: share state with Context API and hooks including useReducer, architect components via single responsibility and compound designs, manage server state with TanStack Query queries/mutations/caching, and test with React Testing Library user interactions and role-based queries.

Automate full testing lifecycle: auto-detect frameworks like Jest/Vitest/Playwright/Cypress, generate unit/API/E2E tests and strategies, analyze coverage gaps, write missing tests for files/functions, run suites with failure fixes, and validate web/API security/accessibility.

Orchestrates a complete feature development lifecycle from codebase analysis and TDD test strategy through implementation, multi-agent code review (quality, security, performance, bugs, conventions), UI verification, and PR creation with resume capability for interrupted workflows.