MCP React Toolkit

Complete analysis for any React-based app (CRA, Vite, Next.js, Remix, Gatsby). Runs all 22 sub-tools and produces a unified health score (0-100) with prioritized migration hints.

Detect react-router usage, route structure (flat vs nested), lazy loading usage

Detect Redux, Context API, local state patterns, normalized state, derived state, Reselect usage

Detect CSS/SCSS/Tailwind/styled-components, inline styles, hardcoded colors, duplicate classes

Generate a typed CRUD data layer from a FieldSchema — an RTK Query api slice or TanStack Query hooks (list/get/create/update/delete) with cache invalidation.

Diff two API contract snapshots (JSON samples or OpenAPI schemas) and classify changes as breaking (removed field, type change) vs additive — a CI gate against contract breaks.

Apply approved diffs to improve MCP tools. Creates timestamped backups (.bak files) before modifying.

Execute the entire refactor pipeline end-to-end (validate -> backup -> create structure -> move -> update imports -> rename -> split -> barrels -> validate build) and automatically roll back to the backup if the build fails. Returns { success, steps, rolledBack, backupPath }. Set dryRun:true to preview. Example: { path: '/app', refactorPlan, dryRun: true, buildCommand: 'npm run build' }.

Full performance audit: heavy imports, memory leaks, unoptimized images, sync operations, console.logs, and deep nesting.

Audit keyboard navigation: tabindex usage, focus order, icon-only buttons without labels.

Run the tests and generate targeted fix code for each failure (import path corrections, act() wrappers, mocks, assertion updates).

Generate an index.ts barrel that re-exports every module in a folder (skips index/test/stories/.d.ts/css) — kills hand-maintained export lists that drift.

Analyze ALL MCP tools in the tools/ directory and return a comprehensive report. Shows worst/best performers, summary statistics, and all proposed diffs.

Evaluate gzipped built asset sizes against per-pattern budgets and return a pass/fail CI gate — the missing gate step for bundle analysis.

Run axe-core style rules against React components and HTML files to detect WCAG violations.

Evaluate the gzipped size of built .js/.css assets in a dist directory against per-pattern budgets. Returns { entries, violations, totalKB, passed } — passed=false is a CI-blockable regression.

Check if a component already exists at the specified path

Run a workspace health check: detect version mismatches, missing scripts, and circular dependencies

Check which components are wrapped with React.memo, use useMemo, or useCallback — and which are not.

Compare declared dependency versions against the latest npm versions.

Find React-specific performance issues: memory leaks, sync operations, unoptimized images, deep nesting.

Report which components already have Storybook stories and which are missing them.

Classify each file into feature-specific, shared, utility, or config type

AST-based JS/JSX → TypeScript conversion. Infers types from usage, generates interface definitions, converts PropTypes to TypeScript, and removes Flow annotations.

A generic rule-based codemod engine — apply a find/replace (regex with backrefs) or a named built-in migration (cra-env-to-vite, jest-fn-to-vi, react-render-to-createroot) across files. Dry-run by default.

Extract Core Web Vitals (LCP, FID/TBT, CLS, FCP, SI) from an existing Lighthouse JSON report or by running a new audit.

Compare two Lighthouse JSON reports to measure performance regressions or improvements.

Scaffold a new React component from a description using 41 shadcn/ui templates. Generates TSX, test file, Storybook story, and type definitions.

Auto-fix broken React components — resolves missing imports, replaces any types, extracts inline styles, and adds missing alt attributes.

Improve a React component directory with extended tests, Storybook stories, and variant coverage — rewrites the test and story files with comprehensive cases.

Comprehensive component audit across 7 categories — TypeScript errors, React patterns, accessibility (WCAG 2.1), code quality, security, and testing. Returns an A+ to F grade.

Wire the generated table/detail/form components into routes for a resource. router "rr7" emits a React Router route array with param wrappers; router "next" emits app/ segment page files. Returns one or more files referencing the components by their conventional names.

Convert an SVG (raw string or file path) into a typed React component that spreads SVGProps<SVGSVGElement> and optionally uses currentColor. Returns { code, filename, componentName }.

Rename .js/.jsx files to .ts/.tsx, add basic type annotations, convert propTypes to TypeScript interfaces

Generate a comprehensive test coverage report with gap analysis, grades (A-F), and actionable suggestions.

Orchestrate the whole CRA -> Vite migration in one call — analyze the project, plan deps + webpack, scaffold the Vite shell, summarize env/test migration, and return a ModernizationReport with a manual-review checklist and A-F grade. Composes the six CRA tools in-process.

CRA-specific deep inspection across the full config surface — react-scripts/ejection/CRACO, REACT_APP_ env vars + .env files, %PUBLIC_URL%/homepage, proxy, jest + setupTests, browserslist, eslint-config-react-app, SASS, service worker, SVG imports.

Generate barrel `index.ts` re-export files for the refactored directories so imports stay clean. Returns { indexFiles: string[] }. Example: { path: '/app', refactorPlan }.

Create the destination directory structure for a refactor plan (and an optional backup first). Returns { created: string[], backupPath }. Safe/idempotent — existing directories are left untouched. Example: { path: '/app', refactorPlan, backupPath: '/app/.backup' }.

Wire the generated table/detail/form components into routes — a React Router 7 route array with param wrappers, or Next App Router app/ segment page files.

Deep dependency analysis for monorepos — finds unused packages, duplicate dependencies across workspaces, outdated versions, and bundle size impact.

Build the full workspace dependency graph and detect circular dependencies

Map CRA dependencies to a Vite plan — what to remove (react-scripts, craco, node-sass…), what to add (vite, plugin-react, vitest, jsdom, sass, svgr…), and what has no known equivalent.

Generate scalable folder structure suggestion based on feature-based architecture

Generate a typed detail/view component from a FieldSchema — every field as a definition row plus a delete action, wired to the generated get and delete hooks.

Find heavy library imports (moment, lodash, rxjs, etc.) that bloat your bundle size.

Analyze existing tests and suggest missing edge cases: null inputs, empty inputs, boundary values, error handling, accessibility tests.

Analyze React component files for unnecessary re-render patterns: inline objects/arrays/functions, missing memo, context value issues.

Detect prop drilling, tight coupling, duplicated logic, large utility files, god components

Detect cross-feature imports, deep relative imports, and tight coupling issues

Detect duplicate components, duplicate utility functions, similar file structures

Identify logical features/domains in the app using file names, routing, folder grouping, and import clustering

Detect React version, language (JS/TS), framework (CRA/Vite/Next.js/Remix/Gatsby/React Native), and major dependencies

Identify files used across multiple features (shared modules)

Diff two API contract snapshots (JSON response samples or OpenAPI schema objects; each may be a JSON string or a file path) and classify changes as breaking (removed field / type change) vs additive. Returns { changes, breaking, additive, passed }. passed=false is a CI-blockable break.

Generate documentation from source — a README for an MCP tool (from its addTool registrations) or an API reference for a TS module (from its exported functions/types + JSDoc).

Generate a Playwright end-to-end CRUD flow spec (create -> list -> read -> edit -> delete + a11y) from a FieldSchema. Tests the feature the CRUD factory generates, closing the factory -> feature -> mock -> E2E loop.

Grade a path A–F on design-token compliance and group violations by file. A blocking gate for generated/changed UI code.

Scan React/TS/CSS for hardcoded design values (colors, spacing, font sizes, radii, shadows, z-index), suggest design-token replacements, and grade a path A–F on token compliance.

Generate a Zod-validated, typed env module (Vite or Next) from env var names or an .env.example — throws on boot with a readable error. Zod at the env boundary.

CRA -> Vite env migration: rewrite process.env.REACT_APP_X to import.meta.env.VITE_X in source, rename REACT_APP_ keys in .env files, and flag dynamic process.env[...] access. Dry-run by default.

Scan a file or directory of JSX/TSX for hardcoded user-facing strings and build an i18n message catalog with generated keys. Returns { hits, catalog, count }.

Find all packages that depend on a given package

Find dependencies declared with different versions across monorepo packages.

Find external dependencies used by multiple packages — candidates for extraction to a shared package

Find declared dependencies that are not imported anywhere in the package source files.

Comprehensive React component fixer - applies fixes from review JSON output for type-safety, accessibility, performance, security, code quality, and more

Apply safe, mechanical accessibility fixes to a JSX/TSX file (img alt="", target=_blank rel, label for->htmlFor, tabindex->tabIndex) and return the fixed code plus a list of what changed. Review before writing. Returns { code, fixes, count }.

Auto-fix common issues in a component: broken import paths, missing displayName, @/lib/utils → relative path

Fix component issues from a pre-computed review JSON. Pass the exact output from component-reviewer.

Run the suite (auto-detects Vitest/Jest), classify each failure by root cause (import, type, assertion, timeout, runtime), and generate targeted fix code.

Generate a React Hook Form + Zod form component (create or edit) from a FieldSchema, wired to the generated rtk or tanstack mutation hooks.

Generate a multi-step React Hook Form + Zod wizard (per-step validation, progress, back/next, merged submit) from a FieldSchema and step grouping — for onboarding/checkout flows.

Generate a typed CRUD data layer from a FieldSchema: an RTK Query api slice (dataLayer "rtk") or TanStack Query hooks (dataLayer "tanstack"), with list/get/create/update/delete and cache invalidation. Imports the resource type from the zod-schema-generator output.

Read a TypeScript module and generate a Markdown API reference from its exported functions, interfaces, and type aliases (with leading JSDoc). Returns { code, filename, symbols }.

Generate an index.ts barrel that re-exports every module in a folder (skips index/test/stories/.d.ts/css). Returns { code, filename, count }. Pass named:true to emit named exports for PascalCase modules.

Generate a React component using actual shadcn/ui source code with TypeScript types, tests, and Storybook stories

Generate multiple components at once using shadcn/ui templates

Generate a typed detail/view component from a FieldSchema — every field as a definition row plus a delete action, wired to the generated get and delete hooks. dataLayer "rtk" or "tanstack". Composes with api-client-generator and zod-schema-generator output.

Generate a Playwright end-to-end CRUD flow spec from a FieldSchema: create -> list -> read -> edit -> delete, plus an @axe-core/playwright accessibility check. Returns { code, filename, routeBase }. Tests the feature the CRUD factory generates. Requires @playwright/test and @axe-core/playwright in the target project.

Generate a Zod-validated, typed env module from env var names or an .env.example. target "vite" (import.meta.env, VITE_ prefix) or "next" (process.env, NEXT_PUBLIC_). Returns { code, filename, names }.

Generate a typed test-fixture factory from a FieldSchema: makeX(overrides), makeXs(count), and resetXSeq(). Deterministic, override-friendly data for unit tests, Storybook, and seeds. Returns { code, filename, factoryName }.

Generate a React Hook Form + Zod form component from a FieldSchema. mode "create" or "edit" (edit fetches the record and PUTs); dataLayer "rtk" or "tanstack" selects which generated mutation hooks it calls. Composes with zod-schema-generator and api-client-generator output.

Generate MSW handlers (GET list, GET :id, POST, PUT, DELETE) plus an in-memory seed array from a FieldSchema. Returns { code, filename, seedCount, handlerCount }.

Scaffold a Playwright test harness for a React/Vite app: playwright.config.ts, a POM fixture, a base Page Object, and (optionally) an auth storage-state setup. Returns { files: [{ path, code }], count }. Requires @playwright/test in the target project.

Generate loading/empty/error state components plus an <XStates> switch wrapper for a data view. Returns { code, filename, componentName }.

Generate a typed Zustand store from a state shape: the state, a setter per field, a reset, and optional persist/devtools middleware. Returns { code, filename, hookName }.

Analyze React component files and generate comprehensive Storybook story files: Default, Playground, all variants, sizes, disabled, loading, callbacks, accessibility, and interactive play functions.

Generate a TanStack Table data table from a FieldSchema — sortable headers, global filter, and pagination. paginationMode "client" or "server"; dataLayer "rtk" or "tanstack" selects the list hook. Columns come from table-visible fields. Composes with api-client-generator and zod-schema-generator output.

Analyze a TypeScript/React source file and generate a Vitest test file for all exported components, functions, hooks, and classes.

Scan a directory and generate test files for all source files that do not already have tests.

Read an MCP tool’s index.ts and generate a Markdown README: the server name, each registered action with its description, argument table, and a usage example. Returns { code, filename, toolName, actions }.

Generate plain TypeScript interfaces from a JSON sample. Nested objects become their own interfaces; arrays become T[]. Returns { code, filename, rootName }.

Generate a Playwright visual-regression spec (toHaveScreenshot) for a set of routes and/or Storybook story ids, with the recommended config snippet. Returns { code, filename, shots }. Requires @playwright/test in the target project.

Generate a multi-step RHF + Zod wizard from a FieldSchema: per-step validation (trigger), progress indicator, back/next, and a merged final submit. Pass `steps` to group fields, or it auto-splits into two. Returns { code, filename, componentName, steps }.

Generate a Zod schema and its inferred TypeScript type from a FieldSchema (produced by infer-fields). Returns TS code enforcing validation at the boundary — used by form-generator and api-client-generator.

Combine all analysis outputs into a single structured refactor plan

Analyse a TypeScript/React source file and auto-generate a Vitest test suite covering happy paths, edge cases, and error states based on the function signatures.

Scan JSX for hardcoded user-facing strings (text + translatable attributes) and produce i18n keys + a message catalog. Pure mechanical extraction.

Improve a React component directory with extended tests, Storybook stories, and variant coverage. Rewrites the test and story files with comprehensive cases.

Improve a component by expanding tests with edge cases, adding more Storybook story variants, and enhancing docs

Infer a typed FieldSchema (fields, types, relations, and table/form presentation defaults) from a JSON API sample response or an OpenAPI schema object. This is the data contract every CRUD/form/table/detail generator consumes.

Infer a typed FieldSchema (fields, types, foreign-key relations, and table/form presentation defaults) from a JSON API sample or an OpenAPI schema. The data contract every CRUD/form/table generator consumes.

Migrate Jest test files to Vitest — jest.* -> vi.* (with requireActual->importActual), add the vitest import, and flag vi.mock factories for manual review. Dry-run by default.

Generate an interactive, collapsible, searchable HTML JSON viewer from any payload. Supports dark/light mode and is useful for inspecting MCP responses and API payloads.

22-tool health audit for any React/Next.js/Remix app. Scores 0–100 across routing, state management, API layer, styling, and component architecture. Returns a prioritised migration roadmap.

Static HTML audit plus Lighthouse CLI integration — scores title, viewport, meta, OG/Twitter tags, canonical, JSON-LD, and Core Web Vitals. Supports diff between two runs.

List the built-in named codemods (e.g. cra-env-to-vite, jest-fn-to-vi, react-render-to-createroot).

List all packages in the monorepo workspace with their metadata

List all saved JSON responses with timestamps and metadata.

List all available TypeScript enforcement rules with descriptions and what they check for.

List all available shadcn/ui component templates

Map existing files to new target structure

Scaffold, wire, and verify new MCP tools inside this package — the executable form of the mcp-server-builder skill. Writes the McpServerBase shell + core stub + tests, edits root workspaces/scripts/bin, then builds and smoke-tests.

Analyze and improve MCP tools across 7 dimensions (description quality, schema completeness, error handling, edge cases, response structure, code quality, contextual depth). Proposes diffs, applies them, and supports rollback.

Orchestrate a CRA -> Vite migration: analyze the project, plan dependency + webpack changes, scaffold the Vite shell, and summarize env + test migration. Returns a ModernizationReport { profile, depRemap, webpackTranslation, scaffoldFiles, envMigration, testMigration, manualReview, journal, grade }. Writes the Vite shell into outDir when dryRun:false. The actual src env/test rewrites are run explicitly afterward via env-var-migrator and jest-to-vitest-migrator (dryRun:false).

Migrate CRA env usage to Vite across a project: rewrite process.env.REACT_APP_X -> import.meta.env.VITE_X in src, rename REACT_APP_ keys in .env* files, and flag dynamic process.env[...] access. Dry-run by default. Returns { dryRun, sourceFiles, envFiles, totalRewrites, dynamicAccess }.

Migrate Jest test files (**/*.test|spec.*, plus setupTests.ts/js) under a directory to Vitest: jest.* -> vi.*, @testing-library/jest-dom -> its /vitest subpath (required for custom matchers to register on Vitest's expect), add the vitest import, and flag vi.mock factories needing review. Dry-run by default. Returns { dryRun, files, totalRewrites, needsReview }.

Workspace introspection and dependency graph visualisation — lists all packages, maps inter-package relationships, finds shared dep mismatches, and reports monorepo health.

Move files to their planned destinations (backing up first). Returns { moved: Record<oldPath,newPath>, backupPath }. Pair with update-imports afterward so references stay valid; use rollback-on-failure if a later step fails. Example: { path: '/app', refactorPlan, backupPath }.

Generate MSW request handlers (list/get/create/update/delete) plus deterministic seed data from a FieldSchema, so the generated CRUD feature runs against a mock API in dev and tests.

Suggest better file and folder naming conventions

Runtime performance analysis — detects memory leaks, heavy imports, unoptimised images, excessive nesting, and console.log statements left in production code.

Map CRA dependencies to a Vite plan: { remove, add: [{name, version}], unmapped }. Pass a project path (reads package.json) or an explicit deps object. Options: svgr, sass.

Scaffold a Playwright test harness for a React/Vite app — config, POM fixture, base Page Object, and optional auth storage-state setup.

Five-stage automated quality pipeline: runs tests, type-checks, performance analysis, accessibility audit, and design token enforcement. Returns an A–F grade.

Flag redundant useMemo/useCallback/React.memo for the React 19 Compiler and rules-of-hooks blockers, with a best-effort strip of the simple single-expression cases.

Audit a Redux codebase for shortcomings, anti-patterns, and optimizations — re-render-causing selectors (whole-state/inline-object/unmemoized-derived), direct mutations, non-serializable state, connect->hooks, createStore->configureStore, switch-reducers->createSlice, manual thunks that should be RTK Query. Grades A-F.

Safely execute refactor plans on React/TS codebases — move/rename files, split modules, update all imports, create barrels, validate the build, and roll back on failure. 10 staged operations.

Aggregator: calls all refactoring suggestion tools and produces final structured plan

Rename files per the plan's `renames` (backing up first) and update their imports. Returns { renamed, backupPath }. Example: { path: '/app', refactorPlan: { renames: [{ from, to }] }, backupPath }.

Identify React render performance bottlenecks — unnecessary re-renders, missing memo, unstable inline object and function references, and missing useCallback/useMemo.

Comprehensive React component review - analyzes TypeScript, React patterns, accessibility, performance, security, code quality, and testing

Review a generated component for TypeScript errors and accessibility issues. Returns a quality score and suggestions.

Static A–F quality gate for generated or changed React/TS code: <img> missing alt and unfilled stubs (errors), any / console.log / hardcoded hex colors (warnings). Grades a file or directory.

Restore a file from its backup. Use this if an applied improvement caused issues.

Restore the project from a backup after a failed refactor — reverses moves/renames and falls back to a full re-copy from the backup. Returns { restored, backupPath }. Called automatically by apply-refactor on build failure, or manually. Example: { path: '/app', backupPath: '/app/.backup' }.

Apply a codemod across a file or directory — a named built-in `rule`, or an explicit `find`/`replace` (regex with $1 backrefs). Dry-run by default (reports per-file match counts without writing). Set dryRun:false to write. Returns { dryRun, totalMatches, files: [{ file, matches }] }.

Run the complete quality pipeline: tests, type safety, performance, accessibility, design tokens

Run a full Lighthouse audit against a live URL. Returns performance, accessibility, best-practices, and SEO scores with failing audits.

Run specific stages of the quality pipeline

Review a file or directory of generated code and return a grade A–F with the list of issues by severity.

Run the project test suite (auto-detects Vitest or Jest) and return a pass/fail summary with the list of failures.

Run a named routine (currently "schema_to_feature") over a JSON sample or FieldSchema. Returns { files: [{ filename, code }], journal: [{ step, ok, note }], grade (A–F), passed, resource, dataLayer, router, fileCount }. The files compose a full CRUD feature: Zod schema, api client (rtk|tanstack), table, detail, create+edit forms, and routes (rr7|next). Limitation: generated code assumes its peer deps (zod, @reduxjs/toolkit or @tanstack/react-query, react-hook-form, @tanstack/react-table, react-router-dom) are installed in the target project.

Scaffold a new MCP tool into the mcp-react-toolkit package: writes package.json, tsconfig.json, a McpServerBase index.ts shell wired to every action, a src/core.ts stub, and a test stub. Fill in src/core.ts afterwards. Kills the boilerplate; leaves only the logic.

Generate the Vite project shell for a CRA migration: vite.config.ts (react + optional svgr, envPrefix VITE_, @ alias, proxy, base), root index.html, src/main.tsx (createRoot), strict tsconfig + tsconfig.node, and vite-env.d.ts. Returns { files: [{ path, code }], count }.

Recursively scan a directory for TypeScript violations. Returns per-file results sorted by worst score first, plus summary statistics and breakdown by rule.

Analyze a single TypeScript/JavaScript file for type safety violations. Runs all rules by default. Returns violations with line numbers, severity, current code, suggested fix, and explanation.

Run a single specific rule across a file or directory. Useful for targeted fixes.

Scan a file or directory for hardcoded design values (colors, spacing, font sizes, radii, shadows, z-index) that should use design tokens. Returns a summary + violations, filterable by severity.

Split oversized modules into smaller files per the plan's `splits`, creating the new files and leaving TODO markers for content to move. Returns { splitFiles, created }. Review the output before committing. Example: { path: '/app', refactorPlan: { splits: [{ file, proposedFiles }] }, backupPath }.

Generate loading-skeleton, empty-state, and error-state components plus an <XStates> switch wrapper for a data view — kills the copy-pasted conditional-render boilerplate.

Analyze HTML files for SEO and performance issues without running a live server (title, meta tags, images, scripts, favicon, OG tags).

Auto-generate Storybook stories for any React component. Infers props from TypeScript interfaces and creates Default, variant, size, callback, and play-function stories.

Best-effort strip of the auto-fixable useMemo/useCallback wrappers in a file (single-expression cases). Returns { code } — review before writing. Complex cases and React.memo are reported by analyze, not auto-stripped.

Suggest a design-token replacement for each hardcoded value found in a file or directory.

Suggest splitting large or generic files into smaller modules

Convert raw SVG into a typed, tree-shakeable React component that spreads SVGProps and optionally uses currentColor — SVGR-grade, no build step.

Check if a config file is consistent across all packages and surface variants

Generate a TanStack Table data table (sortable headers, global filter, pagination) from a FieldSchema, wired to the generated list hook. Client or server pagination.

Generate a typed test-fixture factory (makeX/makeXs with overrides + seq reset) from a FieldSchema — deterministic mock data for unit tests, Storybook, and seeds.

Find untested code paths — maps every exported function and component to its test coverage, identifies uncovered branches, and reports a coverage gap score.

Best-effort translate a webpack/CRACO config into Vite equivalents — extract aliases, classify plugins and loaders (native / needs-plugin / unsupported), and return an explicit manual-review list. Pass the config as text or a file path. Returns { aliases, plugins, loaders, manualReview }.

Generate plain TypeScript interfaces from a JSON sample — nested objects become their own interfaces, arrays become T[]. The general-purpose sibling of infer-fields.

Scan a path for TypeScript violations — implicit any, unsafe casts, missing return types, non-null assertions. 7 rules scored 0–10 with fix suggestions.

Rewrite relative import paths across the project after files move, using an AST (not regex) so only real imports change. Returns { updatedFiles, importsUpdated }. Pass the movedFiles map from move-files. Example: { path: '/app', refactorPlan, movedFiles: { 'src/a.ts': 'src/x/a.ts' } }.

Check ARIA attributes for correctness: valid roles, proper aria-hidden usage.

Run the project's build command and detect errors — the safety gate after a refactor. Returns { success, errors: string[], output }. If it fails, call rollback-on-failure. Example: { path: '/app', buildCommand: 'npm run build' }.

Validate a refactor plan before executing it — checks that every source path exists, destinations are unique, and no moves conflict. Returns { valid, errors, warnings }. Run this first; a plan must pass here before create-target-structure/move-files. Example: { path: '/app', refactorPlan: { moves: [{ from, to }] } }.

Build the tool, run its tests, and JSON-RPC smoke-test its MCP server (tools/list). Returns pass/fail for each step.

Save JSON data and generate an interactive HTML viewer. Opens in browser for easy visualization of complex JSON responses.

Read a JSON file from disk and open an interactive HTML viewer — no need to paste raw JSON.

Re-open a previously saved JSON response by its ID.

Generate Playwright visual-regression specs (toHaveScreenshot) for routes or Storybook stories, plus the config snippet — catches unintended CSS/layout drift.

Generate the Vite project shell for a CRA migration — vite.config.ts (react/svgr/alias/proxy/base), root index.html, src/main.tsx (createRoot), strict tsconfig(.node).json, vite-env.d.ts.

Best-effort translation of a webpack/CRACO config into Vite equivalents — aliases, plugin/loader classification (native/needs-plugin/unsupported), and an explicit manual-review list.

Wire an already-scaffolded tool into the root package.json (workspaces + build/test scripts) and bin/cli.mjs TOOLS array, after `prev`. Idempotent.

Run the schema_to_feature routine end-to-end: infer-fields → zod → api-client → table/detail/form → crud-composer, gated by review-gate. Returns the full generated file set, a per-step journal, and an A–F grade.

Generate a Zod schema and its inferred TypeScript type from a FieldSchema — Zod at every boundary for forms and API clients.

Generate a typed Zustand store (state + per-field setters + reset, optional persist/devtools) from a state shape — the client-state complement to api-client-generator.