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

Build and manage Cloudflare applications: create serverless Workers, stateful Durable Objects, AI agents with React hooks, enforce Zero Trust policies, and audit web performance using CLI tools and MCP integrations.

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.

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

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.

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.

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.

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.

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.

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.

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.

Enforces Test-Driven Development by detecting your test framework (Vitest, Jest, Storybook, pytest, Go), installing the matching reporter, and blocking direct file edits to redirect reads through a custom pipeline that runs on session start and each user prompt.

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.

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.

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

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.

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.

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.

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.

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 for Vite-based TypeScript and JavaScript projects with workspace setups, test environments, coverage, and performance tuning. Provides testing patterns for unit tests, mocks, and spies, along with a hook to track tool usage during development.

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.

Orchestrate the full software development lifecycle from idea to shipped code — planning, TDD implementation, code quality audits, architectural refactoring, testing, deployment readiness checks, and structured git workflows with conventional commits and npm publishing.

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.

Orchestrate multi-agent AI coding workflows with autonomous planning, implementation, review, and testing across Next.js and React Router projects, including automated code generation, refactoring, performance auditing, and CI/CD integration.

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.

Generates unit, integration, and e2e tests using Jest, Vitest, Pytest, Cypress, or Playwright; researches documentation and best practices via web search; creates formatted reports (PDF, DOCX, HTML); and manages CLAUDE.md files by scanning workspaces and analyzing staged git changes. Also optimizes 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.

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.

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.

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.

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.

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.

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.

Automate review-driven development workflows: requirement interviews, git worktree branching, test-first implementation, automated verification (Playwright, vitest, pytest, Maestro), evidence collection, and structured report generation for PR sign-off.

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.

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.

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.

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.

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.

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.

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.

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.

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 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 web applications with AI-guided workflows for React/Next.js architecture, accessible CSS/Tailwind design systems, TDD testing cycles, and visual UI debugging via Playwright screenshots. Includes automated code review for git diffs and framework-agnostic test execution.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Design and build full-stack multiplayer games with server-authoritative architecture, economy balancing, narrative systems, and CI/CD deployment using Elysia, Bun, PostgreSQL, and Redis.

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.

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.

Perform institutional-grade corporate finance analysis and document generation entirely offline, including DCF/LBO/M&A modeling, credit analysis, fixed-income pricing, portfolio optimization, fund administration, KYC/AML workflows, and equity research report production via 57 slash commands and 9 specialist agents.

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

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

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.

Orchestrate a complete feature development lifecycle from codebase analysis and TDD test design through multi-agent code review, UI verification, and PR creation, with state persistence to resume interrupted workflows