@modootoday/pmcp 0.13.0 → 0.14.0

package/plugins/zod-schema-validation-3/skills/zod-schema-validation/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: zod-schema-validation
+description: Use Zod 3 schemas for runtime validation, coercion, object/tuple/record composition, and safe parsing in TypeScript or plain scripts.
+---
+
+Verified against zod@3.25.76 on 2026-09-07. 7 of 7 examples executed.
+
+# Zod 3
+
+Use this skill for the `zod` package with version range `^3.0.0`. The documented API is the Zod 3 API. The documentation requires TypeScript 4.5+ with `strict` mode enabled.
+
+## Import and version boundary
+
+The documented default import is:
+
+```ts
+import { z } from "zod";
+```
+
+When supporting both Zod major versions, the maintainer documentation identifies `zod/v3` as the stable Zod 3 subpath. Do not assume examples written for another major have the same exports or signatures. In particular, use the exported `z` variable rather than older import shapes.
+
+## Primitive schemas and parsing
+
+Create primitive schemas with constructors such as:
+
+- `z.string()`
+- `z.number()`
+- `z.bigint()`
+- `z.boolean()`
+- `z.date()`
+- `z.symbol()`
+- `z.undefined()`
+- `z.null()`
+- `z.void()`
+- `z.any()`
+- `z.unknown()`
+- `z.never()`
+
+`.parse(value)` returns the parsed value when valid and throws a `ZodError` when invalid. `.safeParse(value)` does not throw for validation failure; it returns an object with either `{ success: true, data }` or `{ success: false, error }`.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const schema = z.string();
+
+assert.equal(schema.parse("tuna"), "tuna");
+assert.throws(() => schema.parse(12));
+
+const valid = schema.safeParse("tuna");
+assert.equal(valid.success, true);
+if (valid.success) assert.equal(valid.data, "tuna");
+
+const invalid = schema.safeParse(12);
+assert.equal(invalid.success, false);
+```
+
+## Object schemas and inferred types
+
+Use `z.object({...})` to validate object shapes. `z.infer<typeof Schema>` is a TypeScript-only utility that extracts the schema's inferred type; it does not perform runtime work.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const User = z.object({
+  username: z.string(),
+});
+
+type User = z.infer<typeof User>;
+const user: User = { username: "Ludwig" };
+
+assert.deepEqual(User.parse(user), { username: "Ludwig" });
+assert.equal(User.safeParse({ username: 42 }).success, false);
+```
+
+## Coercion
+
+The `z.coerce` constructors convert input before applying the schema:
+
+- `z.coerce.string()` uses string coercion.
+- `z.coerce.number()` uses number coercion.
+- `z.coerce.boolean()` uses boolean coercion.
+- `z.coerce.bigint()` uses bigint coercion.
+- `z.coerce.date()` constructs a date.
+
+A coerced string schema is a normal `ZodString`, so string methods such as `.email()` and `.min()` can be chained.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+assert.equal(z.coerce.string().parse(12), "12");
+assert.equal(z.coerce.string().parse("tuna"), "tuna");
+assert.equal(z.coerce.number().parse("12"), 12);
+assert.equal(z.coerce.boolean().parse(1), true);
+
+const email = z.coerce.string().email().min(5);
+assert.equal(email.parse("a@b.co"), "a@b.co");
+assert.equal(email.safeParse("not-an-email").success, false);
+```
+
+## Custom messages
+
+Primitive schemas accept `invalid_type_error` and `required_error` options for custom validation messages.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const name = z.string({
+  invalid_type_error: "Name must be string",
+  required_error: "Name is required",
+});
+
+const result = name.safeParse(123);
+assert.equal(result.success, false);
+if (!result.success) {
+  assert.equal(result.error.issues[0]?.message, "Name must be string");
+}
+```
+
+## Tuples and rest elements
+
+`z.tuple([...])` defines positional elements. Add trailing elements with `.rest(schema)`. `z.output<typeof schema>` is a TypeScript utility for the parsed output type.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const myTuple = z.tuple([z.string(), z.number()]).rest(z.boolean());
+type TupleOutput = z.output<typeof myTuple>;
+
+const value: TupleOutput = ["count", 2, true, false];
+assert.deepEqual(myTuple.parse(value), ["count", 2, true, false]);
+assert.equal(myTuple.safeParse(["count", 2, "not boolean"]).success, false);
+```
+
+## Selective partial objects
+
+For an object schema, `.partial({ name: true })` makes only the selected property optional. It does not make every property optional.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const user = z.object({
+  name: z.string(),
+  age: z.number(),
+});
+
+const optionalNameUser = user.partial({ name: true });
+
+assert.deepEqual(optionalNameUser.parse({ age: 30 }), { age: 30 });
+assert.equal(optionalNameUser.safeParse({ name: "Ada" }).success, false);
+```
+
+## Records
+
+Use `z.record(keySchema, valueSchema)` to validate record keys and values. The inferred type can be extracted with `z.infer`.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const schema = z.record(z.number(), z.boolean());
+type Schema = z.infer<typeof schema>;
+
+const empty: Schema = {};
+assert.deepEqual(schema.parse(empty), {});
+```
+
+## Async parsing
+
+Schemas that use asynchronous refinements or transforms must use `.parseAsync()` or `.safeParseAsync()` rather than their synchronous counterparts. The reviewed material identifies these method names but does not provide a complete Zod 3 async signature or example; keep async schema details within the package's documented API rather than inventing a synchronous equivalent.
+
+## Common version and shape mistakes
+
+- Do not substitute a newer-major API for the Zod 3 API when the dependency is `^3.0.0`.
+- Do not rely on older examples that omit the exported `z` variable; Zod 3 documents `import { z } from "zod"`.
+- Do not treat `.safeParse()` as throwing on invalid input. Inspect its `success` field and read `data` or `error` conditionally.
+- Do not treat `z.infer` or `z.output` as runtime functions. They are TypeScript type utilities.
+- Do not use `.parse()` for schemas with asynchronous refinements or transforms; use `.parseAsync()` or `.safeParseAsync()`.
+- Within Zod 3, `.or()` and `.transform()` changed in 3.2 to return new wrapper instances rather than the earlier flattening/avoiding-nesting shape. Code that depends on the internal schema nesting should not assume the pre-3.2 shape.
+
+## Not covered
+
+This skill does not cover the complete exported-symbol list, exhaustive method signatures, every Zod 3 schema combinator, detailed asynchronous refinement/transform construction, custom error maps, custom `ZodType` subclasses, CLI or build commands, or the complete differences between Zod 1, Zod 2, Zod 3, and later majors.

package/plugins/zod-schema-validation-4/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "zod-schema-validation-4",
+  "version": "4.0.1",
+  "description": "Validate boundaries with explicit failure handling, transformed types and async parsing.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/zod-schema-validation-4/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/zod-schema-validation-4/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-schema-validation-4/gemini-extension.json

@@ -0,0 +1 @@
+{ "name": "zod-schema-validation-4", "version": "4.0.1" }

package/plugins/zod-schema-validation-4/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "zod-schema-validation-4",
+  "version": "4.0.1",
+  "description": "Validate boundaries with explicit failure handling, transformed types and async parsing.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/zod-schema-validation-4/skills/zod-schema-validation/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: zod-schema-validation
+description: A boundary needs validating and the code either trusts a cast, throws where it should have branched, or hand-rolls an error shape; or a parse failure reaches a person as a stack trace instead of a message naming the field that was wrong.
+---
+
+The original seven standalone examples were verified against zod@4.5.4 on 2026-09-07. Additional development fixtures cover transform input/output types and async parsing; see the catalog for their latest executed verification.
+
+# zod
+
+Parse at the boundary, then trust the value. The point of a schema is that
+everything past it is typed because it was checked, not because it was cast.
+
+## When to reach for it
+
+Reach for this when data arrives from outside the program and its shape is a
+claim rather than a fact: a request body, a config file, an environment
+variable, a third-party response. Do not reach for it to re-check a value your
+own code just produced.
+
+## Parse or branch, not both
+
+`parse` throws and `safeParse` returns a result. Pick by whether the caller has
+something to do about a failure. A route that must answer 400 branches; a boot
+path that cannot continue throws.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const Config = z.object({ port: z.number(), host: z.string() });
+
+// safeParse when the caller answers for the failure.
+const result = Config.safeParse({ port: "8080", host: "localhost" });
+assert.equal(result.success, false);
+
+// parse when there is no answer but to stop.
+assert.deepEqual(Config.parse({ port: 8080, host: "localhost" }), {
+  port: 8080,
+  host: "localhost",
+});
+```
+
+## Unknown keys are dropped, not rejected
+
+An object schema ignores keys it does not declare and returns only what it
+declared. This is the behaviour most often assumed wrong in both directions:
+it does not fail, and it does not pass the extra key through.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const User = z.object({ id: z.string() });
+const parsed = User.parse({ id: "u1", role: "admin" });
+
+// The undeclared key is gone. Reading parsed.role would be undefined, so an
+// authorization check written against it silently never fires.
+assert.deepEqual(parsed, { id: "u1" });
+assert.equal("role" in parsed, false);
+```
+
+If the extra key should be an error, say so with `.strict()`; if it should
+survive, say so with `.passthrough()`. Both are explicit, and the default is
+neither.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const Strict = z.object({ id: z.string() }).strict();
+assert.equal(Strict.safeParse({ id: "u1", extra: 1 }).success, false);
+
+const Open = z.object({ id: z.string() }).passthrough();
+assert.deepEqual(Open.parse({ id: "u1", extra: 1 }), { id: "u1", extra: 1 });
+```
+
+## Read the failure, do not stringify it
+
+A `ZodError` carries `issues`, and each issue names the path that failed. That
+path is what a person needs; the stack trace is not.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const Order = z.object({ item: z.object({ qty: z.number() }) });
+const outcome = Order.safeParse({ item: { qty: "two" } });
+
+assert.equal(outcome.success, false);
+if (!outcome.success) {
+  const [issue] = outcome.error.issues;
+  assert.deepEqual(issue.path, ["item", "qty"]);
+  assert.equal(issue.code, "invalid_type");
+  // `expected` is what the schema wanted, which is what the message should say.
+  assert.equal(issue.expected, "number");
+}
+```
+
+For a whole-form answer, `z.treeifyError` groups messages by field, which maps
+onto a form without any reshaping of your own.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const Signup = z.object({ email: z.string(), age: z.number() });
+const outcome = Signup.safeParse({ email: 1, age: "old" });
+
+assert.equal(outcome.success, false);
+if (!outcome.success) {
+  const tree = z.treeifyError(outcome.error);
+  assert.ok(tree.properties?.email?.errors.length);
+  assert.ok(tree.properties?.age?.errors.length);
+}
+```
+
+## Let the schema be the type
+
+Infer the type from the schema instead of declaring both. Two declarations
+drift, and the one that drifts is the one the compiler is not checking.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const Session = z.object({ userId: z.string(), expiresAt: z.number() });
+type Session = z.infer<typeof Session>;
+
+const session: Session = Session.parse({ userId: "u1", expiresAt: 1 });
+assert.equal(session.userId, "u1");
+```
+
+## Coerce only where the wire is untyped
+
+`z.coerce` converts before checking, which is right for query strings and
+environment variables and wrong for a JSON body that already has types. Coercing
+a JSON number field hides a producer sending strings.
+
+```ts pmcp-example
+import { z } from "zod";
+import assert from "node:assert/strict";
+
+const Query = z.object({ page: z.coerce.number() });
+assert.deepEqual(Query.parse({ page: "2" }), { page: 2 });
+
+const Body = z.object({ page: z.number() });
+assert.equal(Body.safeParse({ page: "2" }).success, false);
+```
+
+## Transform input and output deliberately
+
+A transform can change the output type. Use `z.input<typeof schema>` for callers and `z.output<typeof schema>` for validated results; `z.infer` describes the output. Keep transport coercion at the boundary and validate before transforming.
+
+```ts pmcp-example
+import assert from "node:assert/strict";
+import { z } from "zod";
+
+const Count = z.string().regex(/^\d+$/).transform(Number);
+type CountInput = z.input<typeof Count>;
+type CountOutput = z.output<typeof Count>;
+
+const input: CountInput = "12";
+const output: CountOutput = Count.parse(input);
+assert.equal(output, 12);
+assert.equal(Count.safeParse("twelve").success, false);
+```
+
+An async refinement or transform requires `parseAsync` or `safeParseAsync`. A synchronous parse is not an equivalent replacement. Check the success branch before reading data; map issues into the caller's existing error contract.
+
+## Development checks and sources
+
+Run the project's existing typecheck and test runner after changing a boundary. Verify accepted data, rejected data, unknown-key handling and transformed output. Preserve the existing error response format.
+
+Consult [Zod schemas and transforms](https://zod.dev/api) for the pinned major. Features added after the catalog's exact verified version need their own verification.
+
+## Advanced boundaries
+
+Custom error maps and codec composition each have enough
+surface to be their own skill. Discriminated unions are worth reading about
+before modelling a tagged payload as a plain union, because the error a plain
+union produces names every branch it tried.

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

@@ -0,0 +1,9 @@
+{
+  "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/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.