@modootoday/pmcp 0.13.0 → 0.14.0

package/plugins/zod-validation-error-5/NOTICE

@@ -0,0 +1,51 @@
+pmcp
+
+Copyright (c) 2026 modootoday. All rights reserved.
+
+Licensor: modootoday
+Licensed under the Elastic License 2.0; see LICENSE.
+
+The licensor is modootoday, the company, not any individual contributor. This
+file names the licensor because the Elastic License 2.0 defines that term rather
+than carrying a copyright line of its own; LICENSE is kept unmodified.
+
+What the licence permits, in short, without replacing the terms in LICENSE:
+
+  - Using this software inside your own company, on any scale.
+  - Embedding it in a product you sell, and modifying or forking it.
+  - Redistributing it, with these notices intact.
+  - Running it locally as an MCP server, which is what it is for. A host
+    process spawning it on your own machine is use, not a hosted service.
+
+What it does not permit:
+
+  - Offering this software to third parties as a hosted or managed service.
+    A remotely hosted MCP endpoint serving other people is the case this
+    forbids.
+  - Circumventing licence key functionality.
+  - Removing or obscuring these notices.
+
+The Elastic License 2.0 is source-available, not an OSI-approved open source
+licence. It grants a patent licence and ends that licence if you assert a patent
+claim against the software; see the Patents section of LICENSE.
+
+LICENSE governs. Where this summary and LICENSE differ, LICENSE is what applies.
+
+---
+
+This software depends on the following packages, which are distributed under
+their own terms and are not covered by the licence above.
+
+  @modelcontextprotocol/server   MIT   Copyright (c) Anthropic, PBC
+  @modelcontextprotocol/core     MIT   Copyright (c) Anthropic, PBC
+  zod                            MIT   Copyright (c) Colin McDonnell
+  semver                         ISC   See the dependency's LICENSE file.
+  smol-toml              BSD-3-Clause   Copyright (c) Squirrel Chat et al.
+  yaml                           ISC   Copyright Eemeli Aro
+
+Full licence texts and copyright notices ship with those packages. Their
+respective licence terms govern distribution of those dependencies.
+
+@huggingface/transformers is an optional peer dependency. It is never
+distributed with this package; a user who wants semantic ranking installs it
+themselves, under its own Apache-2.0 terms.

package/plugins/zod-validation-error-5/gemini-extension.json

@@ -0,0 +1 @@
+{ "name": "zod-validation-error-5", "version": "5.0.0" }

package/plugins/zod-validation-error-5/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "zod-validation-error-5",
+  "version": "5.0.0",
+  "description": "Use zod-validation-error ^5.0.0 with Zod 4 by default, including direct ValidationError construction, Zod error conversion, type guards, message builders, and the separate Zod 3 entrypoint.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/zod-validation-error-5/skills/zod-validation-error/SKILL.md

@@ -0,0 +1,212 @@
+---
+name: zod-validation-error
+description: Use zod-validation-error ^5.0.0 with Zod 4 by default, including direct ValidationError construction, Zod error conversion, type guards, message builders, and the separate Zod 3 entrypoint.
+---
+
+Verified against zod-validation-error@5.0.0 on 2026-09-08. 7 of 7 examples executed.
+
+# zod-validation-error v5
+
+Use this skill for `zod-validation-error` version `^5.0.0`. It requires Node.js 18 or newer and TypeScript 4.5 or newer. The default package entrypoint is the Zod 4 build. Zod is a peer dependency and must be installed by the application.
+
+## Important version distinction
+
+Version 5 supports both Zod 4 and Zod 3, but they are separate package entrypoints:
+
+- Import the default package for the Zod 4 surface: `zod-validation-error`.
+- Import `zod-validation-error/v3` when using the Zod 3 surface.
+
+Do not copy the older singleton error-map setup into the v5 default surface. The older form is:
+
+```ts
+import { z as zod } from 'zod';
+import { errorMap } from 'zod-validation-error';
+
+zod.setErrorMap(errorMap);
+```
+
+For v5 with Zod 4, create the map and configure Zod:
+
+```ts
+import { z as zod } from 'zod';
+import { createErrorMap } from 'zod-validation-error';
+
+zod.config({
+  customError: createErrorMap(),
+});
+```
+
+Zod 4 schemas also use the newer constructors shown by the package documentation, such as `zod.int()` and `zod.email()`. The older Zod 3 shape uses `zod.number().int()` and `zod.string().email()`.
+
+## Direct `ValidationError`
+
+`ValidationError` is an `Error` and can be used without Zod, for example when validating an argument in code that does not need a schema.
+
+```ts pmcp-example
+import assert from 'node:assert/strict';
+import { ValidationError } from 'zod-validation-error';
+
+const error = new ValidationError('Invalid argument; expected buffer');
+
+assert.equal(error instanceof Error, true);
+assert.equal(error.message, 'Invalid argument; expected buffer');
+```
+
+## Convert a Zod error
+
+Use `fromError` when the caught value is not known to be a Zod error. Use a Zod 4 schema with the default package entrypoint.
+
+```ts pmcp-example
+import assert from 'node:assert/strict';
+import { z as zod } from 'zod';
+import { fromError, isValidationError } from 'zod-validation-error';
+
+const schema = zod.object({
+  id: zod.int().positive(),
+  email: zod.email(),
+});
+
+let converted: unknown;
+try {
+  schema.parse({ id: -1, email: 'not-an-email' });
+} catch (error) {
+  converted = fromError(error);
+}
+
+assert.equal(isValidationError(converted), true);
+assert.equal(converted instanceof Error, true);
+```
+
+`fromZodError` is the explicit conversion function when the value is already a Zod error.
+
+```ts pmcp-example
+import assert from 'node:assert/strict';
+import { z as zod } from 'zod';
+import { fromZodError, isValidationError } from 'zod-validation-error';
+
+const schema = zod.object({ count: zod.int().positive() });
+const result = schema.safeParse({ count: 0 });
+
+assert.equal(result.success, false);
+if (result.success) process.exit(1);
+
+const error = fromZodError(result.error);
+assert.equal(isValidationError(error), true);
+assert.equal(error instanceof Error, true);
+```
+
+## Convert one issue
+
+`fromZodIssue` converts a Zod issue directly into a `ValidationError`.
+
+```ts pmcp-example
+import assert from 'node:assert/strict';
+import { fromZodIssue, isValidationError } from 'zod-validation-error';
+
+const error = fromZodIssue({
+  origin: 'number',
+  code: 'too_small',
+  minimum: 0,
+  inclusive: false,
+  path: ['id'],
+  message: 'Number must be greater than 0 at "id"',
+  input: -1,
+});
+
+assert.equal(isValidationError(error), true);
+assert.equal(error instanceof Error, true);
+```
+
+## Convert with `toValidationError`
+
+`toValidationError(options)` produces a function that accepts a Zod error and returns a `ValidationError`.
+
+```ts pmcp-example
+import assert from 'node:assert/strict';
+import { z as zod } from 'zod';
+import { isValidationError, toValidationError } from 'zod-validation-error';
+
+const schema = zod.object({ name: zod.string().min(1) });
+const result = schema.safeParse({ name: '' });
+
+assert.equal(result.success, false);
+if (result.success) process.exit(1);
+
+const convert = toValidationError({});
+const error = convert(result.error);
+
+assert.equal(isValidationError(error), true);
+```
+
+## Message builders and error maps
+
+`createMessageBuilder` accepts options including `maxIssuesInMessage` and `includePath`. `createErrorMap` creates the map used with Zod 4 configuration. The package documentation shows configuring both through the package API rather than relying on the older v3 singleton `errorMap`.
+
+```ts pmcp-example
+import assert from 'node:assert/strict';
+import { z as zod } from 'zod';
+import {
+  createErrorMap,
+  createMessageBuilder,
+} from 'zod-validation-error';
+
+const messageBuilder = createMessageBuilder({
+  maxIssuesInMessage: 3,
+  includePath: false,
+});
+const errorMap = createErrorMap();
+
+assert.equal(typeof messageBuilder, 'function');
+assert.equal(typeof errorMap, 'function');
+
+zod.config({ customError: errorMap });
+```
+
+## Type guards
+
+The documented guards are useful when handling unknown caught values:
+
+- `isValidationError` checks for the package's `ValidationError`.
+- `isValidationErrorLike` checks whether an unknown value has the validation-error shape expected by the package.
+- `isZodErrorLike` checks whether an unknown value has a Zod-error-like shape.
+
+A plain object containing only `name` and `message` is not necessarily validation-error-like. Use an actual package error or an actual Zod error when testing these guards.
+
+```ts pmcp-example
+import assert from 'node:assert/strict';
+import { z as zod } from 'zod';
+import {
+  ValidationError,
+  isValidationError,
+  isValidationErrorLike,
+  isZodErrorLike,
+} from 'zod-validation-error';
+
+const validationError = new ValidationError('invalid input');
+const result = zod.string().parse;
+
+let zodError: unknown;
+try {
+  zod.string().parse(123);
+} catch (error) {
+  zodError = error;
+}
+
+assert.equal(isValidationError(validationError), true);
+assert.equal(isValidationErrorLike(validationError), true);
+assert.equal(isValidationError(new Error('ordinary error')), false);
+assert.equal(isZodErrorLike(zodError), true);
+```
+
+## Common mistakes
+
+- **Using v3 imports or setup with the default v5 entrypoint.** The default export is the v4 build. Use `createErrorMap()` with `zod.config({ customError: ... })`.
+- **Using the Zod 3 schema examples with Zod 4.** In the documented v5 surface, use `zod.int()` and `zod.email()` rather than assuming the older `zod.number().int()` and `zod.string().email()` examples apply.
+- **Assuming a plain object is validation-error-like.** `isValidationErrorLike` checks the package's expected shape; `{ name, message }` alone does not satisfy it. Use a `ValidationError` or another value with the documented validation-error shape.
+- **Assuming the package is a runner.** It has no documented CLI or test-runner integration requirement. Its conversion, error-map, builder, and guard APIs are callable from ordinary scripts.
+- **Passing arbitrary caught values to APIs intended for Zod errors.** Use `fromError` for an unknown caught value; use `fromZodError` or `toValidationError` when the value is known to be a Zod error.
+- **Forgetting the peer dependency.** The conversion and error-map APIs are built around Zod issue/error types, and the package declares Zod as a peer dependency.
+
+## Not covered
+
+This skill does not cover the detailed formatting of every generated message, all `createMessageBuilder` or `toValidationError` options beyond those documented above, custom issue construction beyond the shown issue, Zod schema design, package installation commands, or the full Zod 3 API. Those details were not established by the available research.

package/plugins/zustand-5/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "zustand-5",
+  "version": "5.0.0",
+  "description": "Use Zustand ^5.0.0 for vanilla stores, React-bound stores, persistence, and Redux-style reducers. Covers documented v5 APIs, standalone examples, and migration traps such as stable selectors, replacement updates, and changed persistence behavior.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/zustand-5/LICENSE

@@ -0,0 +1,93 @@
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/plugins/zustand-5/NOTICE

@@ -0,0 +1,51 @@
+pmcp
+
+Copyright (c) 2026 modootoday. All rights reserved.
+
+Licensor: modootoday
+Licensed under the Elastic License 2.0; see LICENSE.
+
+The licensor is modootoday, the company, not any individual contributor. This
+file names the licensor because the Elastic License 2.0 defines that term rather
+than carrying a copyright line of its own; LICENSE is kept unmodified.
+
+What the licence permits, in short, without replacing the terms in LICENSE:
+
+  - Using this software inside your own company, on any scale.
+  - Embedding it in a product you sell, and modifying or forking it.
+  - Redistributing it, with these notices intact.
+  - Running it locally as an MCP server, which is what it is for. A host
+    process spawning it on your own machine is use, not a hosted service.
+
+What it does not permit:
+
+  - Offering this software to third parties as a hosted or managed service.
+    A remotely hosted MCP endpoint serving other people is the case this
+    forbids.
+  - Circumventing licence key functionality.
+  - Removing or obscuring these notices.
+
+The Elastic License 2.0 is source-available, not an OSI-approved open source
+licence. It grants a patent licence and ends that licence if you assert a patent
+claim against the software; see the Patents section of LICENSE.
+
+LICENSE governs. Where this summary and LICENSE differ, LICENSE is what applies.
+
+---
+
+This software depends on the following packages, which are distributed under
+their own terms and are not covered by the licence above.
+
+  @modelcontextprotocol/server   MIT   Copyright (c) Anthropic, PBC
+  @modelcontextprotocol/core     MIT   Copyright (c) Anthropic, PBC
+  zod                            MIT   Copyright (c) Colin McDonnell
+  semver                         ISC   See the dependency's LICENSE file.
+  smol-toml              BSD-3-Clause   Copyright (c) Squirrel Chat et al.
+  yaml                           ISC   Copyright Eemeli Aro
+
+Full licence texts and copyright notices ship with those packages. Their
+respective licence terms govern distribution of those dependencies.
+
+@huggingface/transformers is an optional peer dependency. It is never
+distributed with this package; a user who wants semantic ranking installs it
+themselves, under its own Apache-2.0 terms.

package/plugins/zustand-5/gemini-extension.json

@@ -0,0 +1 @@
+{ "name": "zustand-5", "version": "5.0.0" }

package/plugins/zustand-5/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "zustand-5",
+  "version": "5.0.0",
+  "description": "Use Zustand ^5.0.0 for vanilla stores, React-bound stores, persistence, and Redux-style reducers. Covers documented v5 APIs, standalone examples, and migration traps such as stable selectors, replacement updates, and changed persistence behavior.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/zustand-5/skills/zustand/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: zustand
+description: Use Zustand ^5.0.0 for vanilla stores, React-bound stores, persistence, and Redux-style reducers. Covers documented v5 APIs, standalone examples, and migration traps such as stable selectors, replacement updates, and changed persistence behavior.
+---
+
+Verified against zustand@5.0.15 on 2026-09-08. 3 of 3 examples executed.
+
+# zustand ^5.0.0
+
+## Core API
+
+Use named exports. Zustand v5 drops default exports.
+
+- `zustand`: `create`, `useStore`
+- `zustand/vanilla`: `createStore`
+- `zustand/middleware`: `persist`, `createJSONStorage`, `redux`, and other documented middleware such as `devtools`, `immer`, `combine`, and `subscribeWithSelector`
+
+`create<T>()(stateCreator)` returns a React-bound store hook. The hook has attached `setState`, `getState`, `getInitialState`, and `subscribe` APIs. The state creator receives `set` and `get`; ordinary `set` calls merge partial updates.
+
+A React runtime is required to import and use the `zustand` entry point. A plain standalone script without React cannot execute a `create` example. Use `createStore` from `zustand/vanilla` for code that does not run inside React.
+
+`createStore<T>()(stateCreator)` returns a vanilla `StoreApi<T>` with `getState`, `setState`, `getInitialState`, and `subscribe`.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { createStore } from 'zustand/vanilla'
+
+const store = createStore<{ bears: number; add: () => void }>()((set) => ({
+  bears: 0,
+  add: () => set((state) => ({ bears: state.bears + 1 })),
+}))
+
+store.getState().add()
+assert.equal(store.getState().bears, 1)
+assert.equal(store.getInitialState().bears, 0)
+
+let observed = -1
+const unsubscribe = store.subscribe((state) => {
+  observed = state.bears
+})
+store.setState({ bears: 3 })
+assert.equal(observed, 3)
+unsubscribe()
+```
+
+A vanilla store can be bound to React with `useStore`, but that binding requires a React application/runtime and is not demonstrated in a plain script.
+
+## Persistence
+
+Wrap a state creator with `persist`. The `name` option is required. The default storage is JSON-wrapped `localStorage`; in non-browser or standalone code, provide a storage explicitly with `createJSONStorage`.
+
+In v5, persist does not store the initial state during store creation. If the initial state must be persisted immediately, explicitly call `setState` after creating the store.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { createStore } from 'zustand/vanilla'
+import { createJSONStorage, persist } from 'zustand/middleware'
+
+const values = new Map<string, string>()
+const storage = createJSONStorage(() => ({
+  getItem: (key) => values.get(key) ?? null,
+  setItem: (key, value) => { values.set(key, value) },
+  removeItem: (key) => { values.delete(key) },
+}))
+
+const store = createStore(
+  persist(
+    (set) => ({ count: 0, increment: () => set((state) => ({ count: state.count + 1 })) }),
+    { name: 'counter', storage },
+  ),
+)
+
+assert.equal(values.has('counter'), false)
+store.getState().increment()
+assert.equal(store.getState().count, 1)
+assert.equal(values.has('counter'), true)
+```
+
+`persist` modifies the state creator's wrapped `set` and `get`. Do not assume that middleware changes every separately exposed vanilla `getState` or `setState` behavior in the same way.
+
+## Redux middleware
+
+`redux(reducer, initialState)` adds `dispatch` to the state. Actions must have a string `type`. The reducer returns the next state value.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { createStore } from 'zustand/vanilla'
+import { redux } from 'zustand/middleware'
+
+const store = createStore(
+  redux(
+    (state: { count: number }, action: { type: string }) =>
+      action.type === 'inc' ? { count: state.count + 1 } : state,
+    { count: 0 },
+  ),
+)
+
+store.getState().dispatch({ type: 'inc' })
+assert.equal(store.getState().count, 1)
+```
+
+## v5 migration traps
+
+### Do not use the v4 equality-function shape with `create`
+
+In v5, `create` does not accept a custom equality function as a second hook argument. For equality-function usage, use `createWithEqualityFn` from `zustand/traditional` and install the `use-sync-external-store` peer dependency. Alternatively use `useShallow` from `zustand/shallow`.
+
+### Keep selector results stable
+
+Selectors that create a new array or object on every call can cause infinite loops in v5. Use `useShallow` for shallowly compared compound selections, or return stable values. Avoid a fresh fallback such as `state.action ?? (() => {})`; define a stable fallback instead.
+
+### Replacement updates require complete state
+
+`setState(value, true)` replaces the entire state rather than merging it. The replacement must contain every required state field. For partial updates, omit the second argument or use the default merge behavior.
+
+### Other v5 compatibility changes
+
+- React 18 is the minimum React version documented for v5.
+- TypeScript 4.5 is the minimum documented version.
+- `use-sync-external-store` is a peer dependency for `zustand/traditional`.
+- UMD/SystemJS and ES5 support were dropped.
+- `createContext` was removed from `zustand/context`.
+- Persist behavior changed: initial state is not automatically stored during store creation.
+- Default exports and deprecated features were dropped.
+
+## What this skill does not cover
+
+This skill does not cover React component rendering, because the React-bound `zustand` entry point cannot run in the standalone example environment without React. It also does not cover framework integration, hydration, a runnable `traditional` example, detailed options for every middleware, Redux DevTools setup, or browser-specific storage behavior. `devtools` additionally requires the Redux DevTools Chrome extension. Those areas require runtime or configuration context not covered by the supplied research.