Vitest plugins

Modern JS/TS development across full stack: write type-safe code with ES6+/TypeScript patterns, scaffold projects for Next.js/React/Node/CLI, test with Jest/Vitest/Testing Library, and build backend APIs with Express/Fastify

Develop, deploy, and manage applications on Cloudflare’s platform including Workers, Durable Objects, AI agents, and MCP servers. Scaffold projects, configure resources, audit web performance, and integrate with Cloudflare services via API and CLI.

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.

Streamline end-to-end Obsidian plugin development and vault management: scaffold projects with TypeScript setups, implement UI views/events/data handling, optimize performance/security, establish local dev loops/CI/CD/release pipelines, migrate content, and troubleshoot errors using 24 specialized skills.

Generate production Mistral AI code and configs in Claude Code for SDK setup/auth, chat completions/embeddings/RAG pipelines, error debugging/rate limits, security hardening/compliance, CI/CD testing with Vitest/GitHub Actions, Vercel/Docker/K8s deployment, cost/performance optimization, observability, and OpenAI migrations in TypeScript/Node/Python.

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

Integrate Groq's fast AI inference into Node.js/TypeScript projects via 24 skills: build chat completions, tool calling, vision/audio processing; migrate from OpenAI/Anthropic; optimize costs, performance, rate limits; secure APIs with RBAC/PII redaction; deploy to Vercel/Docker; set up CI tests, monitoring, observability.

Integrate Fireflies.ai GraphQL API for meeting transcripts, AI summaries, action items, and Q&A: fetch/process data, handle webhooks with signature verification, automate auth/secrets/CI testing with GitHub Actions/Vitest, deploy to Vercel/Docker, monitor performance/costs, ensure security/compliance/GDPR.

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.

Automate full-lifecycle MaintainX CMMS integrations: manage work orders/assets/locations via TypeScript API clients, configure auth/RBAC/webhooks, implement CI/CD with GitHub Actions/Vitest, deploy to Docker/GCP/K8s, tune performance/costs/rate-limits, add monitoring/security/data syncs/ETL for production maintenance ops.

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.

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 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.

Accelerate Intercom API integrations in Node.js/TypeScript apps by generating code for contacts/conversations management, webhook/event handling, auth setup, CI/CD pipelines, local testing, production checklists, security hardening, rate limit retries, performance caching, observability instrumentation, cost optimization, data migrations, and incident response runbooks.

Build full-stack Nuxt 4+ applications with authentication, SEO, CMS content management, UI components, database access, and deployment to Cloudflare or Vercel, while also providing Vue 3 patterns, 3D scenes, game development, TypeScript library authoring, and testing workflows.

Integrate Grammarly API into TypeScript/Node.js apps, GitHub Actions CI/CD, and deployments to score text for clarity, engagement, correctness, tone; detect AI content and plagiarism; with auth setup, rate limiting, chunking, caching, monitoring, cost optimization, and migration guides.

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.

Automate comprehensive project management: audit health and permissions, generate architecture/user docs and roadmaps, handle git workflows/PRs/releases, test UX/onboarding/responsiveness via browser, consult multi-AI models, and post team updates with feedback triage.

Build production SalesLoft API v2 integrations in TypeScript: authenticate via OAuth, manage prospects and cadences, track emails/calls/engagements, handle rate limits/errors/webhooks, test locally and in CI with Vitest/GitHub Actions, deploy to Vercel/GCP/AWS, and optimize performance/security using 18 ready skills.

Build, optimize, deploy, and troubleshoot AssemblyAI-powered audio transcription apps in Node.js/TypeScript projects. Generate SDK integrations for speech-to-text, streaming, LeMUR analysis with diarization/sentiment/PII; CI/CD pipelines, Vercel/GCP deploys, cost/performance tuning, webhooks, security hardening, and error handling workflows.

Build production Attio CRM integrations with Claude Code: handle authentication, full CRUD/search on records/companies/deals/custom objects, manage lists/notes/tasks, implement webhooks, debug errors/rate limits, optimize performance/costs, set up local dev/CI-CD/deployments to Vercel/Fly.io.

Build production ElevenLabs voice AI apps with Claude Code skills: integrate TTS/voice cloning/STT, debug API errors, optimize costs/latency/rate limits, secure keys/webhooks, deploy to Vercel/Fly/Cloud Run, set up CI/CD with mocked tests, and generate reference architectures.

Execute 16 specialized slash commands to scaffold SvelteKit projects with TypeScript/Tailwind/auth/DB, generate components/tests/Storybook stories, debug errors/migrate versions, optimize performance, audit accessibility, fix tests, and troubleshoot Storybook setups.

Profile API endpoints to measure latencies and detect bottlenecks like N+1 queries or missing indexes, then run benchmarks on functions and modules with vitest or pytest for ops/sec, memory usage, comparisons, and prioritized optimization suggestions with impact estimates.

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.

Run autonomous full-stack dev workflows in Claude Code: generate PRDs/specs via interviews, execute Ralph/autodev loops for overnight PRD implementation with git branching/testing/committing, parallelize tasks across 12 agents (architect, frontend-dev, code-reviewer), build React/Tailwind/shadcn UIs and FastAPI backends, TDD/E2E test/verify/review code, automate git commits/PRs, and audit harness health.

Orchestrate a multi-agent AI swarm to automate the full development lifecycle — from brainstorming and design review through TDD implementation, PR management, and deployment — with enforced quality gates and cross-model adversarial reviews.

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.

Set up Vitest testing workflows for TypeScript/JavaScript projects, including installation, configuration, running tests in watch mode with UI and coverage, writing assertions, and implementing mocks for units and integrations.

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.

Scaffold Nuxt 4 projects via interactive wizard selecting UI, DB, auth, and deployment prefs; develop core setup/routing/SEO, data fetching/state, server APIs/DB/WebSockets, and production optimizations using guided skills; autonomously diagnose hydration/SSR/routing/build issues, migrate from Nuxt 3, and analyze performance bottlenecks with agents.

Develop full-stack Nuxt 5 applications by interactively setting up projects with wizards, following guided skills for core setup, data fetching, server routes, and production optimization, delegating debugging, Nuxt 4 migrations, and performance audits to autonomous agents, and accessing official documentation via remote MCP server.

Run mutation testing with Stryker on TypeScript/JavaScript projects using Vitest or bun test, and mutmut on Python projects to identify weak unit tests that pass despite code mutations, improving test suite quality and effectiveness.

Build stateful real-time apps like chat rooms and multiplayer games using Cloudflare Durable Objects: scaffold projects with wrangler configs, TypeScript boilerplate, and tests; generate patterns for WebSockets, alarms, and SQLite; interactively debug issues, optimize performance bottlenecks, and manage class migrations with validation.

Test REST and GraphQL HTTP APIs in TypeScript/JavaScript projects using Supertest and Vitest or in Python projects using httpx and pytest. Validate requests and responses, implement authentication flows, and verify error handling directly in your code.

Accelerate Cloudflare Workers full lifecycle: develop locally with Wrangler/Miniflare, test with Vitest and binding mocks, deploy via GitHub Actions CI/CD to prod/staging, migrate from AWS/Vercel/Node, optimize performance/memory/caching, secure APIs with auth/CORS/rate-limiting, monitor with logs/metrics, using interactive commands, guided skills, and autonomous agents for audits/test gen.

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.

Review React, React Flow, React Router, shadcn/ui, Tailwind v4, Vitest, and Zustand code with specialized sub-skills that auto-detect technologies and enforce a multi-step verification protocol to reduce false positives.

Configure Vitest testing for Vite-powered JavaScript/TypeScript projects with workspace setups, performance optimizations, and unit testing patterns, while logging file writes, web fetches, and session stops.

Streamline TypeScript development workflows using Bun for dependency management, building executables/bundles, running tests, debugging via inspector, and publishing to npm. Lint/format with Biome, eliminate dead code using Knip, and add Sentry monitoring for errors and performance.

Write and manage Effect TypeScript applications with type-safe error handling, dependency injection, concurrency via fibers, data validation using @effect/schema, resource lifecycle management, and test patterns with Vitest.

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.

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.

Guides Python application development with FastAPI, SQLAlchemy, and Temporal patterns, plus TypeScript support for Drizzle, Fastify, and Vitest. Includes architecture guidance, stub-driven TDD, automated code review, commit conventions, and documentation generation.

Audit and improve Capacitor mobile app quality using targeted skills for WCAG accessibility checks, performance profiling with DevTools and native tools, Capsec security scans for 63+ vulnerabilities, Vitest/Playwright testing setups, WebView/Xcode debugging workflows, and iOS/Android device log streaming.

Orchestrate end-to-end AI-driven feature development from research and planning through implementation, testing, and review. Automate code quality audits, PR pipelines, checkpoint rollbacks, and multi-agent parallel workstreams. Generate React components, design tokens, and hooks for Next.js or React Router stacks while syncing progress with GitHub Issues.

Generates tests, optimizes prompts, researches documentation, and creates formatted documents (PDF, DOCX, HTML) from markdown. Manages CLAUDE.md files by scanning workspace structure and updating from git changes.

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.

Enforce rigorous quality gates across React/TypeScript and Go projects with a harness of lifecycle hooks that block violations on every edit. Automate TDD workflows, code review, CI warning audits, dependency vulnerability scanning (Snyk), and accessibility checks, all integrated into a single developer workflow.

Test REST and GraphQL APIs in TypeScript/JavaScript with Supertest/Vitest or Python with httpx/Pytest, handling auth, validation, and errors. Enforce contracts via Pact for consumer-provider agreements and OpenAPI spec validation to detect breaking changes in CI pipelines.

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.

Add modular AI skills to your LLM-assisted development environment for automated testing, code review, PR creation, commit rewriting, design-to-code, accessibility audits, and API security testing. Use skills individually or orchestrate them for complex workflows.

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.

Transforms project ideas into production-ready applications through a multi-agent pipeline. Specifies requirements, plans architecture, generates tasks, then autonomously builds code using specialized agents for frontend, backend, database, DevOps, testing, and security with quality gates and git integration.

Build, test, and release MCP servers built on @cyanheads/mcp-ts-core with scaffolding, design, testing, security auditing, and automated publishing workflows

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.

Run a rigorous planning-to-verification pipeline for coding tasks: auto-analyze codebase health, generate TDD-embedded implementation plans, execute with independent verification agents, and audit plans for correctness, simplicity, and completeness. Preserves session memory across Claude Code sessions.

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.

Auto-detects JS/TS/Python/Go/Rust/PHP/Java projects, installs linting/typechecking/testing tools, and generates custom /fix, /test, /commit, /update slash commands using parallel Claude agents to audit dead code, security risks, deprecations, generate tests, commit safely, and update dependencies.

Set up production-ready Vitest 4.0, Playwright 1.56, and MSW 2.x testing stacks for unit, integration, E2E, and visual regression tests with browser mode support. Leverage AI agents to generate tests, debug traces, optimize coverage, run mutation testing, manage mocks, and configure CI/CD across Windows/Git Bash, macOS, and Linux.

Manage full development lifecycle from requirements gathering to PR submission with built-in review agents for code quality, security, E2E tests, and UI/UX. Automates commit workflows, generates structured reports with evidence, and enforces verification for web, backend, and mobile 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.

Guides an entire software development lifecycle from PRD to deployment: plan features, implement incrementally, enforce TDD, review code, audit accessibility/security/performance, manage git commits and PRs, and ship with automated CI/CD gates — all within an AI coding agent.

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.

Deploy a team of 5 specialist agents to parallel-review git diff changes across backend, frontend, testing, security, and UX aspects, generating an integrated Markdown report in docs/reviews/ for automated code quality checks and team reviews.

Standardize AI-generated projects with Ralph autonomous loop, persistent memory, and quality gates. Enforce Git workflow standards, code quality gates via pre-commit/pre-push hooks, and spec-driven task management with OpenSpec format. Manage skills and tasks through CLI commands and an MCP server for Cursor or Claude Code integration.

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.

Delegate expert Vue 3 and Nuxt.js development: design scalable components and composables with Composition API, refactor app architectures, implement SSR/SSG features, and integrate modern tooling with best practices.

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.

Delegate fullstack TypeScript tasks to 15 specialized agents for building Next.js UIs, Fastify APIs, Drizzle/Postgres schemas and queries, Redis queues with BullMQ/ioredis, Docker containers, Playwright/Vitest tests, performance optimization, security audits, accessibility fixes, debugging, and git workflows, powered by 22 skills enforcing best practices.

Manage context-driven development workflows in Claude Code with automated project context loading, Red-Green-Refactor TDD cycles, track management, git-aware rollbacks, and verification agents enforcing code quality.

Audit APIs against OpenAPI specs, review code quality across diffs and types, enforce frontend SDK boundaries, generate diagrams and documentation, manage Jira tickets, and test keyboard accessibility and layout stability.

Scaffold, test, secure, and deploy TypeScript MCP servers using @cyanheads/mcp-ts-core — from generating tool/resource definitions and integrating authentication/telemetry to publishing releases with GitHub Actions and Cloudflare Workers.

Query the PubChem database for chemical compounds, properties, safety data, bioactivity, and cross-references via MCP. Runs locally with no credentials.

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.

Enforce best practices and patterns for React, Next.js, Effect-TS services, TanStack Query, performance optimization, testing, PRDs, SDK docs, and AI development pipelines in TypeScript projects using guided skills.

Bootstrap JavaScript/TypeScript projects with Anthony Fu's opinionated conventions, instantly configuring code organization, Vitest testing, @antfu/ni tooling, ESLint rules, git hooks, and pnpm workspaces for seamless new project setup, monorepo management, and library publishing.

Set up and run fast unit tests for Vite apps using Vitest's Jest-compatible API. Configure projects, use CLI for execution, write tests with APIs for mocking, snapshots, fixtures, coverage generation, test filtering, and concurrency control.

Develop Vue 3 SPAs with Composition API using script setup, TypeScript reactivity, and SFC structure. Implement Vue Router 4 navigation guards, params, and lifecycle patterns avoiding infinite loops and stale data. Test components, composables, Pinia stores, and E2E flows with Vitest, Vue Test Utils, and Playwright.

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-driven development lifecycle from task assignment to code review, pull request, merge, and completion reporting — with an optional dashboard for session monitoring.

Develop Effect-TS applications using guided skills for effects, schemas, streams, layers, concurrency, error handling, and testing; run automated compliance checks with fixes; migrate code from Promises, async/await, or fp-ts; perform strict reviews and parallel git tasks with specialized agents.

Automate writing, running, debugging, and configuring Vitest tests in Vite-based projects via natural language prompts. Generate tests, mock dependencies with vi, set up coverage and thresholds in vitest.config.ts or vite.config.ts, and diagnose failures using Vitest API.

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.

Generate Bulloak tree specifications and Foundry-based tests (integration, fuzz, fork, invariant) for Solidity smart contracts with full scenario coverage, gas benchmarks, and cheatcodes. Write, run, debug, mock, and measure coverage for Vitest v4 tests in TypeScript React/Next.js projects.

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.

Auto-generate comprehensive tests—unit, integration, edge cases, and bug-catching—by analyzing code behavior with specialized AI agents. Boosts quality assurance for Jest, Pytest, Vitest, and more beyond mere coverage.

Develop Slack agents and bots in JavaScript projects using Bolt or Chat SDK. Follow guided wizards to set up projects, write and run Vitest tests, expose local apps via ngrok tunneling, and deploy to Vercel.

Enforce pixel-perfect frontend discipline in Svelte projects by auto-applying CSS nesting and semantic code styles, validating edits with browser measurements and Playwright screenshots, running post-edit linting and tests, and performing zero-regression migrations via git baselines and research.

Automate Svelte 5 workflows by enforcing code style rules on edits, generating structured JSDoc component docs, wiring Storybook stories as Vitest browser tests with MSW support, previewing stories via Playwright, and creating or fixing unit, SSR, and E2E tests.

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.