@omnimod/plugin-react-class-to-hooks 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 salnika
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,27 @@
+# @omnimod/plugin-react-class-to-hooks
+
+[![npm](https://img.shields.io/npm/v/%40omnimod%2Fplugin-react-class-to-hooks?label=npm)](https://www.npmjs.com/package/@omnimod/plugin-react-class-to-hooks)
+[![CI](https://img.shields.io/github/actions/workflow/status/Salnika/omnimod/ci.yml?branch=master&label=ci)](https://github.com/Salnika/omnimod/actions/workflows/ci.yml)
+[![License](https://img.shields.io/github/license/Salnika/omnimod)](../../LICENSE)
+
+omnimod plugin that migrates simple React class components to function
+components with hooks.
+
+## Use With The CLI
+
+```bash
+omnimod run react-class-to-hooks "src/**/*.{tsx,jsx}"
+omnimod run react-class-to-hooks "src/**/*.{tsx,jsx}" --write
+```
+
+## Use As A Library
+
+```ts
+import { reactClassToHooks } from "@omnimod/plugin-react-class-to-hooks";
+```
+
+## Notes
+
+The plugin targets straightforward class components with state, props, and common
+lifecycle methods. Complex patterns such as HOCs, refs, and derived state are
+reported as diagnostics.

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+//#region src/plugin.d.ts
+type ReactClassToHooksOptions = Record<string, unknown>;
+/**
+ * Migrate SIMPLE React class components to function components + hooks. This is
+ * intentionally conservative: only classes with a `render()`, optional
+ * `state = { ... }`, optional mount/unmount/update lifecycles, and plain methods
+ * are converted. Anything with a constructor body, refs, context, unsupported
+ * lifecycle, or a multi-key/functional `setState` is left untouched with a warn.
+ */
+declare const reactClassToHooks: import("@omnimod/core").Plugin<ReactClassToHooksOptions, unknown>;
+//#endregion
+export { type ReactClassToHooksOptions, reactClassToHooks as default, reactClassToHooks };

package/dist/index.mjs

@@ -0,0 +1,590 @@
+import { definePlugin, walk } from "@omnimod/core";
+import { cast } from "@omnimod/plugin-utils";
+//#region src/detect.ts
+/** The React class-component base classes we recognise as a superclass. */
+const REACT_BASES = /* @__PURE__ */ new Set(["Component", "PureComponent"]);
+/**
+* True when `superClass` is one of `React.Component`, `Component`,
+* `React.PureComponent`, `PureComponent`.
+*/
+function isReactComponentSuper(superClass) {
+	if (!superClass) return false;
+	if (superClass.type === "Identifier") return REACT_BASES.has(cast(superClass).name);
+	if (superClass.type === "MemberExpression") {
+		const member = cast(superClass);
+		if (member.computed || member.property.type !== "Identifier") return false;
+		if (member.object.type !== "Identifier") return false;
+		return cast(member.object).name === "React" && REACT_BASES.has(cast(member.property).name);
+	}
+	return false;
+}
+const UNSUPPORTED_LIFECYCLE = /* @__PURE__ */ new Set([
+	"getDerivedStateFromProps",
+	"getSnapshotBeforeUpdate",
+	"shouldComponentUpdate",
+	"componentDidCatch",
+	"getDerivedStateFromError",
+	"componentWillMount",
+	"UNSAFE_componentWillMount",
+	"componentWillReceiveProps",
+	"UNSAFE_componentWillReceiveProps",
+	"componentWillUpdate",
+	"UNSAFE_componentWillUpdate"
+]);
+/** Property key as a plain string, or null if it is computed / non-identifier. */
+function memberName(key, computed) {
+	if (computed) return null;
+	if (key.type === "Identifier") return cast(key).name;
+	if (key.type === "Literal") {
+		const value = key.value;
+		return typeof value === "string" ? value : null;
+	}
+	return null;
+}
+/**
+* Inspect a React class component and decide whether it is "simple" enough to
+* migrate. Returns a `bail` reason (non-null) when it must be left untouched.
+*/
+function analyzeClass(node) {
+	const name = node.id ? cast(node.id).name : null;
+	const members = [];
+	let bail = null;
+	let hasRender = false;
+	for (const raw of node.body.body) {
+		if (bail) break;
+		if (raw.type === "MethodDefinition") {
+			const method = cast(raw);
+			const key = memberName(method.key, method.computed);
+			if (method.kind === "constructor") {
+				bail = "constructor contains logic beyond super()/this.state";
+				continue;
+			}
+			if (method.static) {
+				bail = `unsupported static method \`${key ?? "?"}\``;
+				continue;
+			}
+			if (key === null) {
+				bail = "computed method name";
+				continue;
+			}
+			if (key === "render") {
+				hasRender = true;
+				members.push({
+					node: raw,
+					kind: "render",
+					name: key
+				});
+			} else if (key === "componentDidMount") members.push({
+				node: raw,
+				kind: "lifecycle-mount",
+				name: key
+			});
+			else if (key === "componentWillUnmount") members.push({
+				node: raw,
+				kind: "lifecycle-unmount",
+				name: key
+			});
+			else if (key === "componentDidUpdate") members.push({
+				node: raw,
+				kind: "lifecycle-update",
+				name: key
+			});
+			else if (UNSUPPORTED_LIFECYCLE.has(key)) bail = `unsupported lifecycle method \`${key}\``;
+			else if (method.kind === "get" || method.kind === "set") bail = `unsupported accessor \`${key}\``;
+			else members.push({
+				node: raw,
+				kind: "method",
+				name: key
+			});
+			continue;
+		}
+		if (raw.type === "PropertyDefinition") {
+			const prop = cast(raw);
+			const key = memberName(prop.key, prop.computed);
+			if (key === null) {
+				bail = "computed class field";
+				continue;
+			}
+			if (prop.static) {
+				if (key === "defaultProps") members.push({
+					node: raw,
+					kind: "default-props",
+					name: key
+				});
+				else bail = `unsupported static field \`${key}\``;
+				continue;
+			}
+			if (key === "state") {
+				members.push({
+					node: raw,
+					kind: "state-field",
+					name: key
+				});
+				continue;
+			}
+			if (prop.value && prop.value.type === "ArrowFunctionExpression") {
+				members.push({
+					node: raw,
+					kind: "method",
+					name: key
+				});
+				continue;
+			}
+			bail = `unsupported instance field \`${key}\` (only \`state\` and bound methods are handled)`;
+			continue;
+		}
+		if (raw.type === "StaticBlock") {
+			bail = "static initialization block";
+			continue;
+		}
+		bail = `unsupported class member \`${raw.type}\``;
+	}
+	if (!bail && !hasRender) bail = "no render() method";
+	return {
+		node,
+		name,
+		members,
+		bail
+	};
+}
+function findClassComponents(program) {
+	const found = [];
+	for (const stmt of program.body) {
+		let classNode = null;
+		let isDeclaration = false;
+		if (stmt.type === "ClassDeclaration") {
+			classNode = cast(stmt);
+			isDeclaration = true;
+		} else if (stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration") {
+			const decl = stmt.declaration;
+			if (decl && decl.type === "ClassDeclaration") {
+				classNode = cast(decl);
+				isDeclaration = true;
+			}
+		}
+		if (!classNode) continue;
+		if (!isReactComponentSuper(classNode.superClass)) continue;
+		found.push({
+			info: analyzeClass(classNode),
+			statement: stmt,
+			isDeclaration
+		});
+	}
+	return found;
+}
+//#endregion
+//#region src/rewrite.ts
+/** `count` → `setCount`. */
+function setterName(key) {
+	return `set${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+}
+/**
+* Rewrite the `this.*` references inside a region of source into their function
+* equivalents. Returns the transformed text and a flag noting whether a
+* multi-key / functional `setState` was encountered (which forces a bail).
+*
+* Handled forms:
+*  - `this.state.k`            → `k`
+*  - `this.props.x` / `this.props` → `props.x` / `props`
+*  - `this.setState({ k: v })` → `setK(v)` (single-key object updates only)
+*  - `this.foo`                → `foo` (methods / bound fields)
+*/
+function rewriteThis(source, region, state) {
+	const edits = [];
+	let unsupportedSetState = false;
+	walk(region, (node) => {
+		if (node.type !== "MemberExpression") return;
+		const member = cast(node);
+		if (member.object.type !== "ThisExpression") return;
+		if (member.computed || member.property.type !== "Identifier") return;
+		const prop = cast(member.property).name;
+		if (prop === "state") return;
+		if (prop === "props") {
+			edits.push({
+				start: member.object.start,
+				end: member.property.start,
+				text: ""
+			});
+			return;
+		}
+		edits.push({
+			start: member.object.start,
+			end: member.property.start,
+			text: ""
+		});
+	});
+	walk(region, (node) => {
+		if (node.type === "MemberExpression") {
+			const outer = cast(node);
+			if (outer.object.type === "MemberExpression" && !outer.computed && outer.property.type === "Identifier") {
+				const inner = cast(outer.object);
+				if (inner.object.type === "ThisExpression" && inner.property.type === "Identifier" && cast(inner.property).name === "state") {
+					const key = cast(outer.property).name;
+					if (state.keys.includes(key)) edits.push({
+						start: outer.start,
+						end: outer.property.end,
+						text: key
+					});
+				}
+			}
+		}
+		if (node.type === "CallExpression") {
+			const call = cast(node);
+			if (call.callee.type === "MemberExpression" && !cast(call.callee).computed) {
+				const callee = cast(call.callee);
+				if (callee.object.type === "ThisExpression" && callee.property.type === "Identifier" && cast(callee.property).name === "setState") {
+					const arg = call.arguments[0];
+					if (!arg || arg.type !== "ObjectExpression") {
+						unsupportedSetState = true;
+						return;
+					}
+					const obj = cast(arg);
+					if (obj.properties.length !== 1) {
+						unsupportedSetState = true;
+						return;
+					}
+					const only = obj.properties[0];
+					if (!only || only.type !== "Property") {
+						unsupportedSetState = true;
+						return;
+					}
+					const property = cast(only);
+					if (property.computed || property.key.type !== "Identifier") {
+						unsupportedSetState = true;
+						return;
+					}
+					const key = cast(property.key).name;
+					const setter = state.setters.get(key);
+					if (!setter) {
+						unsupportedSetState = true;
+						return;
+					}
+					const valueText = rewriteThis(source, property.value, state).text;
+					edits.push({
+						start: call.start,
+						end: call.end,
+						text: `${setter}(${valueText})`
+					});
+				}
+			}
+		}
+	});
+	return {
+		text: applyEdits(source, region, edits),
+		unsupportedSetState
+	};
+}
+/**
+* Apply non-overlapping edits within [region.start, region.end) to the source
+* and return the rewritten substring. Inner `this.state.k` / `setState` edits
+* subsume the prefix-strip edits, so drop any prefix-strip that overlaps a
+* span-replacing edit.
+*/
+function applyEdits(source, region, edits) {
+	const sorted = [...edits].sort((a, b) => a.start - b.start || b.end - a.end);
+	const kept = [];
+	let lastEnd = -1;
+	for (const edit of sorted) {
+		if (edit.start < lastEnd) continue;
+		kept.push(edit);
+		lastEnd = edit.end;
+	}
+	let out = "";
+	let cursor = region.start;
+	for (const edit of kept) {
+		out += source.slice(cursor, edit.start);
+		out += edit.text;
+		cursor = edit.end;
+	}
+	out += source.slice(cursor, region.end);
+	return out;
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* Migrate SIMPLE React class components to function components + hooks. This is
+* intentionally conservative: only classes with a `render()`, optional
+* `state = { ... }`, optional mount/unmount/update lifecycles, and plain methods
+* are converted. Anything with a constructor body, refs, context, unsupported
+* lifecycle, or a multi-key/functional `setState` is left untouched with a warn.
+*/
+const reactClassToHooks = definePlugin({
+	name: "react-class-to-hooks",
+	description: "Migrate simple React class components to function components + hooks.",
+	include: ["**/*.{tsx,jsx}"],
+	transform(file) {
+		const classes = findClassComponents(file.program);
+		if (classes.length === 0) return;
+		const hooksUsed = /* @__PURE__ */ new Set();
+		let anyConverted = false;
+		for (const found of classes) {
+			const info = found.info;
+			if (info.bail) {
+				file.report({
+					message: `Left \`${info.name ?? "class component"}\` as a class: ${info.bail}.`,
+					severity: "warn"
+				});
+				continue;
+			}
+			if (!info.name) {
+				file.report({
+					message: "Left an anonymous class component untouched (no name to convert to).",
+					severity: "warn"
+				});
+				continue;
+			}
+			const converted = convertClass(file, info, info.name);
+			if (!converted) continue;
+			for (const hook of converted.hooks) hooksUsed.add(hook);
+			anyConverted = true;
+		}
+		if (anyConverted && hooksUsed.size > 0) ensureReactHookImports(file, hooksUsed);
+	}
+});
+/** Build the function-component text and replace the class in place. */
+function convertClass(file, info, name) {
+	const hooks = /* @__PURE__ */ new Set();
+	let stateField = null;
+	let render = null;
+	let mount = null;
+	let unmount = null;
+	let update = null;
+	const methods = [];
+	for (const member of info.members) switch (member.kind) {
+		case "state-field":
+			stateField = member;
+			break;
+		case "render":
+			render = member;
+			break;
+		case "lifecycle-mount":
+			mount = member;
+			break;
+		case "lifecycle-unmount":
+			unmount = member;
+			break;
+		case "lifecycle-update":
+			update = member;
+			break;
+		case "method":
+			methods.push(member);
+			break;
+		case "default-props": break;
+		case "constructor": break;
+	}
+	if (!render) {
+		file.report({
+			message: `Left \`${name}\`: no render() found.`,
+			severity: "warn"
+		});
+		return null;
+	}
+	const state = parseState(file, stateField);
+	if (state === "bail") {
+		file.report({
+			message: `Left \`${name}\`: \`state\` is not a simple object literal.`,
+			severity: "warn"
+		});
+		return null;
+	}
+	if (state.keys.length > 0) hooks.add("useState");
+	const lines = [];
+	for (const key of state.keys) {
+		const initText = state.inits.get(key) ?? "undefined";
+		lines.push(`  const [${key}, ${state.setters.get(key)}] = useState(${initText});`);
+	}
+	for (const method of methods) {
+		const rendered = renderMethod(file, method, state);
+		if (rendered === null) {
+			file.report({
+				message: `Left \`${name}\`: method \`${method.name}\` uses an unsupported \`setState\` (multi-key or updater fn).`,
+				severity: "warn"
+			});
+			return null;
+		}
+		lines.push(rendered);
+	}
+	if (mount || unmount) {
+		hooks.add("useEffect");
+		const effect = renderMountEffect(file, mount, unmount, state);
+		if (effect === null) {
+			file.report({
+				message: `Left \`${name}\`: a lifecycle method uses an unsupported \`setState\`.`,
+				severity: "warn"
+			});
+			return null;
+		}
+		lines.push(effect);
+	}
+	if (update) {
+		hooks.add("useEffect");
+		const body = methodBodyText(file, update, state);
+		if (body === null) {
+			file.report({
+				message: `Left \`${name}\`: componentDidUpdate uses an unsupported \`setState\`.`,
+				severity: "warn"
+			});
+			return null;
+		}
+		lines.push(`  // TODO(omnimod): review this effect's dependency array.`);
+		lines.push(`  useEffect(() => {${body}});`);
+		file.report({
+			message: `Converted \`${name}\`.componentDidUpdate to a useEffect — review its dependency array.`,
+			severity: "info"
+		});
+	}
+	const renderReturn = renderRenderBody(file, render, state);
+	if (renderReturn === null) {
+		file.report({
+			message: `Left \`${name}\`: render() uses an unsupported \`setState\`.`,
+			severity: "warn"
+		});
+		return null;
+	}
+	lines.push(renderReturn);
+	const fnText = `function ${name}(props) {\n${lines.join("\n")}\n}`;
+	const classNode = info.node;
+	file.magic.update(classNode.start, classNode.end, fnText);
+	return { hooks };
+}
+/** Parse `state = { k: v }` into keys, setters and init-expression text. */
+function parseState(file, field) {
+	const keys = [];
+	const setters = /* @__PURE__ */ new Map();
+	const inits = /* @__PURE__ */ new Map();
+	if (!field) return {
+		keys,
+		setters,
+		inits
+	};
+	const prop = cast(field.node);
+	if (!prop.value || prop.value.type !== "ObjectExpression") return "bail";
+	const obj = cast(prop.value);
+	for (const raw of obj.properties) {
+		if (raw.type !== "Property") return "bail";
+		const property = cast(raw);
+		if (property.computed || property.kind !== "init") return "bail";
+		if (property.key.type !== "Identifier") return "bail";
+		const key = cast(property.key).name;
+		keys.push(key);
+		setters.set(key, setterName(key));
+		inits.set(key, file.source.slice(property.value.start, property.value.end));
+	}
+	return {
+		keys,
+		setters,
+		inits
+	};
+}
+/** The `StateInfo` view expected by the `this.*` rewriter. */
+function stateInfo(state) {
+	return {
+		keys: state.keys,
+		setters: state.setters
+	};
+}
+/** Render a plain method as `const foo = (params) => { body };`. */
+function renderMethod(file, member, state) {
+	const node = member.node;
+	let fn;
+	if (node.type === "MethodDefinition") fn = cast(node).value;
+	else fn = cast(cast(node).value);
+	const params = file.source.slice(paramsStart(file, fn), paramsEnd(file, fn));
+	const rewritten = rewriteThis(file.source, fn.body, stateInfo(state));
+	if (rewritten.unsupportedSetState) return null;
+	return `  const ${member.name} = (${params}) => ${rewritten.text};`;
+}
+/** Get the source span text of a function/method body ({...} → inner text). */
+function methodBodyText(file, member, state) {
+	const node = member.node;
+	const fn = cast(node).value;
+	const block = cast(fn.body);
+	const rewritten = rewriteThis(file.source, block, stateInfo(state));
+	if (rewritten.unsupportedSetState) return null;
+	return rewritten.text.slice(1, -1);
+}
+/** componentDidMount → useEffect(() => { B; [return cleanup;] }, []). */
+function renderMountEffect(file, mount, unmount, state) {
+	let mountBody = "";
+	if (mount) {
+		const body = methodBodyText(file, mount, state);
+		if (body === null) return null;
+		mountBody = body;
+	}
+	let cleanup = "";
+	if (unmount) {
+		const body = methodBodyText(file, unmount, state);
+		if (body === null) return null;
+		cleanup = `\n    return () => {${body}};`;
+	}
+	return `  useEffect(() => {${mountBody}${cleanup}\n  }, []);`;
+}
+/** render() { return X; } → `  return X;` (with `this.*` rewritten). */
+function renderRenderBody(file, render, state) {
+	const fn = cast(render.node).value;
+	const block = cast(fn.body);
+	const rewritten = rewriteThis(file.source, block, stateInfo(state));
+	if (rewritten.unsupportedSetState) return null;
+	const reindented = reindent(rewritten.text.slice(1, -1), "  ");
+	return reindented.length > 0 ? reindented : "  return null;";
+}
+/**
+* Remove the shared leading indentation from a multi-line block and re-apply
+* `prefix` to each non-blank line. Leading/trailing blank lines are trimmed.
+*/
+function reindent(block, prefix) {
+	const lines = block.replace(/^\n+/, "").replace(/\s+$/, "").split("\n");
+	let common = Infinity;
+	for (const line of lines) {
+		if (line.trim().length === 0) continue;
+		const indent = line.length - line.trimStart().length;
+		if (indent < common) common = indent;
+	}
+	if (!Number.isFinite(common)) common = 0;
+	return lines.map((line) => line.trim().length === 0 ? "" : `${prefix}${line.slice(common)}`).join("\n");
+}
+/** Start offset of a function's parameter list (just after the `(`). */
+function paramsStart(file, fn) {
+	const params = fn.params;
+	if (params.length > 0) return params[0].start;
+	return file.source.indexOf("(", fn.start) + 1;
+}
+/** End offset of a function's parameter list (just before the `)`). */
+function paramsEnd(file, fn) {
+	const params = fn.params;
+	if (params.length > 0) return params[params.length - 1].end;
+	return file.source.indexOf("(", fn.start) + 1;
+}
+/**
+* Merge the required hooks into an existing `import ... from "react"` (adding a
+* named clause when needed) or prepend a fresh named import.
+*/
+function ensureReactHookImports(file, hooks) {
+	const wanted = [...hooks].sort();
+	for (const stmt of file.program.body) {
+		if (stmt.type !== "ImportDeclaration") continue;
+		const imp = cast(stmt);
+		if (imp.source.value !== "react") continue;
+		const existing = /* @__PURE__ */ new Set();
+		let lastNamed = null;
+		let hasNamedBlock = false;
+		for (const spec of imp.specifiers) if (spec.type === "ImportSpecifier") {
+			const s = cast(spec);
+			if (s.imported.type === "Identifier") existing.add(cast(s.imported).name);
+			lastNamed = spec;
+			hasNamedBlock = true;
+		}
+		const missing = wanted.filter((hook) => !existing.has(hook));
+		if (missing.length === 0) return;
+		if (hasNamedBlock && lastNamed) file.magic.appendLeft(lastNamed.end, `, ${missing.join(", ")}`);
+		else {
+			const def = imp.specifiers[0];
+			if (def) file.magic.appendLeft(def.end, `, { ${missing.join(", ")} }`);
+			else file.magic.appendLeft(imp.source.start - 6, `{ ${missing.join(", ")} } `);
+		}
+		return;
+	}
+	file.magic.prepend(`import { ${wanted.join(", ")} } from "react";\n`);
+}
+//#endregion
+export { reactClassToHooks as default, reactClassToHooks };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@omnimod/plugin-react-class-to-hooks",
+  "version": "0.1.0",
+  "description": "omnimod plugin: migrate simple React class components to function components + hooks.",
+  "keywords": [
+    "codemod",
+    "hooks",
+    "migration",
+    "omnimod-plugin",
+    "react"
+  ],
+  "homepage": "https://salnika.github.io/omnimod/",
+  "bugs": "https://github.com/salnika/omnimod/issues",
+  "license": "MIT",
+  "author": "salnika",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/salnika/omnimod.git",
+    "directory": "packages/plugin-react-class-to-hooks"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@omnimod/core": "0.1.0",
+    "@omnimod/plugin-utils": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "@typescript/native-preview": "7.0.0-dev.20260509.2",
+    "typescript": "^6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.2",
+    "vite-plus": "0.2.2"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}