@modootoday/pmcp 0.13.0 → 0.14.0

package/plugins/expect-type-1/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/expect-type-1/gemini-extension.json

@@ -0,0 +1 @@
+{ "name": "expect-type-1", "version": "1.0.0" }

package/plugins/expect-type-1/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "expect-type-1",
+  "version": "1.0.0",
+  "description": "Use expect-type ^1.0.0 for compile-time TypeScript assertions about values, types, functions, properties, and type transformations. It has no meaningful runtime assertion behavior; run TypeScript checking separately from any direct script execution.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/expect-type-1/skills/expect-type/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: expect-type
+description: Use expect-type ^1.0.0 for compile-time TypeScript assertions about values, types, functions, properties, and type transformations. It has no meaningful runtime assertion behavior; run TypeScript checking separately from any direct script execution.
+---
+
+Verified against expect-type@1.4.0 on 2026-09-08. 7 of 7 examples executed.
+
+# expect-type v1.0.0
+
+## What this package is
+
+`expect-type` is a compile-time TypeScript assertion library. Import its main entry point with:
+
+```ts
+import {expectTypeOf} from 'expect-type'
+```
+
+Assertions are checked by TypeScript and reported by the IDE or `tsc`; they are not runtime tests. The package needs no special CLI, build step, runner, IDE extension, or lint plugin. Install it as a development dependency:
+
+```sh
+npm install expect-type --save-dev
+```
+
+When a plain script invokes the API, the chained methods have no meaningful runtime behavior. The examples below therefore include `node:assert/strict` checks only to verify that the exported function is available and that the calls can be made. The type assertions themselves must be checked with TypeScript.
+
+## Exact equality versus assignability
+
+Use `.toEqualTypeOf` when the types must be identical. Use `.toMatchTypeOf` when the actual type may contain additional properties.
+
+```ts pmcp-example
+import {strict as assert} from 'node:assert'
+import {expectTypeOf} from 'expect-type'
+
+assert.equal(typeof expectTypeOf, 'function')
+
+expectTypeOf({a: 1}).toEqualTypeOf<{a: number}>()
+expectTypeOf({a: 1, b: 1}).toMatchTypeOf<{a: number}>()
+
+// This is intentionally a compile-time failure when the directive is checked.
+// @ts-expect-error extra properties are not allowed by exact equality
+expectTypeOf({a: 1, b: 1}).toEqualTypeOf<{a: number}>()
+```
+
+Older examples commonly use `.toMatchTypeOf` for this distinction. In v1, use `.toEqualTypeOf` for exact equality and reserve `.toMatchTypeOf` for the extra-property/assignability case.
+
+## Primitive and structural assertions
+
+The documented primitive and structural checks are available directly on an inspected value:
+
+```ts pmcp-example
+import {strict as assert} from 'node:assert'
+import {expectTypeOf} from 'expect-type'
+
+assert.equal(typeof expectTypeOf, 'function')
+
+expectTypeOf(() => 1).toBeFunction()
+expectTypeOf({}).toBeObject()
+expectTypeOf([]).toBeArray()
+expectTypeOf('').toBeString()
+expectTypeOf(1).toBeNumber()
+expectTypeOf(true).toBeBoolean()
+expectTypeOf(Symbol(1)).toBeSymbol()
+expectTypeOf({a: 1}).toHaveProperty('a').toBeNumber()
+```
+
+You can also provide the type argument without a runtime value:
+
+```ts pmcp-example
+import {strict as assert} from 'node:assert'
+import {expectTypeOf} from 'expect-type'
+
+assert.equal(typeof expectTypeOf, 'function')
+
+expectTypeOf<{a: number}>().toHaveProperty('a').toBeNumber()
+expectTypeOf<string>().toBeString()
+expectTypeOf<number>().toBeNumber()
+```
+
+## Function parameters, returns, overloads, and `this`
+
+For a function value, inspect an individual parameter with `.parameter(index)`, all parameters with `.parameters`, and the return type with `.returns`:
+
+```ts pmcp-example
+import {strict as assert} from 'node:assert'
+import {expectTypeOf} from 'expect-type'
+
+assert.equal(typeof expectTypeOf, 'function')
+
+const f = (a: number) => [a, a]
+
+expectTypeOf(f).toBeCallableWith(1)
+expectTypeOf(f).parameter(0).toBeNumber()
+expectTypeOf(f).parameters.toEqualTypeOf<[number]>()
+expectTypeOf(f).returns.toEqualTypeOf([1, 2])
+```
+
+Function overloads are represented differently from TypeScript's built-in utility types. For an overloaded function, the documented shape is a union of parameter tuples and a union of return types:
+
+```ts pmcp-example
+import {strict as assert} from 'node:assert'
+import {expectTypeOf} from 'expect-type'
+
+type Factorize = {
+  (input: number): number[]
+  (input: bigint): bigint[]
+}
+
+assert.equal(typeof expectTypeOf, 'function')
+expectTypeOf<Factorize>().parameters.toEqualTypeOf<[number] | [bigint]>()
+expectTypeOf<Factorize>().returns.toEqualTypeOf<number[] | bigint[]>()
+expectTypeOf<Factorize>().parameter(0).toEqualTypeOf<number | bigint>()
+```
+
+The API also exposes function `this`-parameter support through `.thisParameter`.
+
+## Type transformations and modifiers
+
+The documented chain includes `.not`, `.branded`, `.extract`, `.exclude`, `.pick`, `.omit`, `.resolves`, `.items`, `.guards`, `.asserts`, `.instance`, `.constructorParameters`, `.thisParameter`, and `.toBeConstructibleWith`. These are type-level chains; use them in a type-checked file rather than expecting runtime test results.
+
+```ts pmcp-example
+import {strict as assert} from 'node:assert'
+import {expectTypeOf} from 'expect-type'
+
+assert.equal(typeof expectTypeOf, 'function')
+
+type Value = {id: string; count: number}
+type Branded = string & {readonly __brand: 'id'}
+type AsyncValue = Promise<number>
+type ItemList = number[]
+type Constructor = new (value: string) => {value: string}
+
+expectTypeOf<Value>().not.toBeString()
+expectTypeOf<Branded>().branded.toEqualTypeOf<Branded>()
+expectTypeOf<Value | null>().extract<Value>().toEqualTypeOf<Value>()
+expectTypeOf<Value | null>().exclude<null>().toEqualTypeOf<Value>()
+expectTypeOf<Value>().pick<'id'>().toEqualTypeOf<{id: string}>()
+expectTypeOf<Value>().omit<'count'>().toEqualTypeOf<{id: string}>()
+expectTypeOf<AsyncValue>().resolves.toBeNumber()
+expectTypeOf<ItemList>().items.toBeNumber()
+expectTypeOf<Constructor>().constructorParameters.toEqualTypeOf<[string]>()
+expectTypeOf<Constructor>().toBeConstructibleWith('value')
+```
+
+The package also provides `.guards`, `.asserts`, `.instance`, and `.thisParameter` for the corresponding function, instance, and `this`-type checks. Their assertions are likewise compile-time-only.
+
+## Intersections and deep types
+
+A documented limitation is that exact equality can reject a structurally equivalent intersection:
+
+```ts pmcp-example
+import {strict as assert} from 'node:assert'
+import {expectTypeOf} from 'expect-type'
+
+assert.equal(typeof expectTypeOf, 'function')
+
+// This is documented as a limitation; the directive should be checked by tsc.
+// @ts-expect-error intersections may not be recognized as identical object types
+expectTypeOf<{a: 1} & {b: 2}>().toEqualTypeOf<{a: 1; b: 2}>()
+```
+
+For simple intersections, use a mapped `Simplify` type before asserting equality. `.branded` is the deeper workaround, but it has a compiler performance cost and can make TypeScript give up on excessively deep types.
+
+## Does not cover
+
+This skill does not cover runtime validation, runtime behavior of the values being inspected, a test-runner integration, CLI usage, configuration files, or the complete signatures of every re-exported internal type and helper. The research only establishes the public `expectTypeOf` entry point and the documented chains listed above. Type assertions must be checked by TypeScript; running an example directly with Bun does not replace `tsc`.

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

@@ -0,0 +1,9 @@
+{
+  "name": "express-5",
+  "version": "5.0.0",
+  "description": "Use Express 5.x programmatically on Node.js 18+; covers the Express app, routers, body middleware, Express 5 routing, and migration differences.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/express-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/express-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/express-5/gemini-extension.json

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

package/plugins/express-5/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "express-5",
+  "version": "5.0.0",
+  "description": "Use Express 5.x programmatically on Node.js 18+; covers the Express app, routers, body middleware, Express 5 routing, and migration differences.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

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

@@ -0,0 +1,179 @@
+---
+name: express
+description: Use Express 5.x programmatically on Node.js 18+; covers the Express app, routers, body middleware, Express 5 routing, and migration differences.
+---
+
+Verified against express@5.2.1 on 2026-09-08. 6 of 6 examples executed.
+
+# Express 5
+
+Express `^5.0.0` requires Node.js 18 or newer. Import the package and call the exported function to create an application:
+
+```ts pmcp-example
+import express from 'express'
+import assert from 'node:assert/strict'
+
+const app = express()
+
+assert.equal(typeof express, 'function')
+assert.equal(typeof app, 'function')
+assert.equal(typeof app.get, 'function')
+assert.equal(typeof app.post, 'function')
+assert.equal(typeof app.put, 'function')
+assert.equal(typeof app.delete, 'function')
+assert.equal(typeof app.patch, 'function')
+assert.equal(typeof app.options, 'function')
+assert.equal(typeof app.head, 'function')
+assert.equal(typeof app.all, 'function')
+assert.equal(typeof app.use, 'function')
+assert.equal(typeof app.listen, 'function')
+```
+
+The application is itself a request handler and can be passed to Node's HTTP server APIs. `app.listen(...)` returns an `http.Server`. A plain script does not need an Express-specific runner or build step. These examples do not start a server because they must run without network access.
+
+## Middleware factories
+
+The documented top-level middleware factories return middleware functions:
+
+- `express.json(options)` parses JSON bodies.
+- `express.raw(options)` parses request payloads into a `Buffer`.
+- `express.text(options)` parses text bodies.
+- `express.urlencoded(options)` parses URL-encoded bodies.
+- `express.static(root, options)` serves static files.
+
+```ts pmcp-example
+import express from 'express'
+import assert from 'node:assert/strict'
+
+assert.equal(typeof express.json(), 'function')
+assert.equal(typeof express.json({}), 'function')
+assert.equal(typeof express.raw(), 'function')
+assert.equal(typeof express.text(), 'function')
+assert.equal(typeof express.urlencoded({ extended: true }), 'function')
+assert.equal(typeof express.static('public'), 'function')
+```
+
+In Express 5, `express.urlencoded()` defaults `extended` to `false`; specify `{ extended: true }` when that is required. If no body parser handles the request, `req.body` is `undefined`. `express.raw()` produces a `Buffer`.
+
+```ts pmcp-example
+import express from 'express'
+import assert from 'node:assert/strict'
+import { PassThrough } from 'node:stream'
+
+const request = new PassThrough()
+request.headers = {
+  'content-type': 'application/json',
+  'content-length': '11'
+}
+request.method = 'POST'
+request.url = '/profile'
+
+const response = {
+  setHeader() {},
+  getHeader() { return undefined },
+  removeHeader() {},
+  end() {}
+}
+
+let parsed: unknown
+express.json()(request, response, (error?: unknown) => {
+  assert.equal(error, undefined)
+  parsed = request.body
+})
+request.end('{"ok":true}')
+
+await new Promise((resolve) => setImmediate(resolve))
+assert.deepEqual(parsed, { ok: true })
+```
+
+## Routers
+
+`express.Router(options)` returns a router. The documented options are `caseSensitive`, `mergeParams`, and `strict`. Mount it with `app.use()`:
+
+```ts pmcp-example
+import express from 'express'
+import assert from 'node:assert/strict'
+
+const app = express()
+const router = express.Router({
+  caseSensitive: true,
+  mergeParams: true,
+  strict: true
+})
+
+router.get('/', (_req, res) => res.send('hello world'))
+app.use('/api', router)
+
+assert.equal(typeof router, 'function')
+assert.equal(typeof router.get, 'function')
+assert.equal(typeof router.use, 'function')
+assert.equal(typeof app.use, 'function')
+```
+
+## Express 5 route syntax
+
+Express 5 uses the newer `path-to-regexp` route syntax. Do not retain the common Express 4 string-path forms:
+
+- Use `/*splat` instead of `/*`.
+- Use `/{*splat}` when the wildcard should also match the root path.
+- Use `/:file{.:ext}` instead of `/:file.:ext?`.
+- Parameter names must be valid JavaScript identifiers or quoted names.
+- `?`, regexp characters, and several reserved characters are not accepted in string paths as they were in older forms.
+
+```ts pmcp-example
+import express from 'express'
+import assert from 'node:assert/strict'
+
+const app = express()
+
+app.get('/*splat', (_req, res) => res.send('wildcard'))
+app.get('/{*splat}', (_req, res) => res.send('root-or-wildcard'))
+app.get('/:file{.:ext}', (_req, res) => res.send('file'))
+
+assert.equal(typeof app.get, 'function')
+```
+
+## Async handlers and errors
+
+Rejected promises from middleware and route handlers are forwarded to error middleware in Express 5. An `async` handler can therefore stand alone; the Express 4 `.catch(next)` pattern is not required.
+
+```ts pmcp-example
+import express from 'express'
+import assert from 'node:assert/strict'
+
+const app = express()
+
+app.get('/user/:id', async (_req, _res) => {
+  throw new Error('lookup failed')
+})
+
+app.use((error, _req, res, _next) => {
+  assert.equal(error.message, 'lookup failed')
+  res.status(500).send('handled')
+})
+
+assert.equal(typeof app, 'function')
+```
+
+This example registers the behavior but does not issue a network request. The complete request lifecycle is exercised through the HTTP server in the surrounding application or tool.
+
+## Express 5 migration pitfalls
+
+- Use `app.delete()`, not the removed `app.del()`.
+- Use `res.status(200).send(body)`, not `res.send(body, status)`.
+- `res.redirect('back')` and `res.location('back')` are removed; use `req.get('Referrer') || '/'` explicitly, for example `res.redirect(req.get('Referrer') || '/')`.
+- `app.param(fn)` and `router.param(fn)` are removed forms.
+- Singular method aliases are removed.
+- `app.router` is available again as a reference to the base router.
+- `app.listen(..., callback)` passes server errors to the callback rather than throwing them.
+- Brotli request-body decompression is supported.
+
+## Static files
+
+`express.static(root, options)` uses `root` and `dotfiles`, not the old `from` and `hidden` options. `dotfiles` defaults to `"ignore"`; explicitly opt in with `{ dotfiles: 'allow' }` when serving hidden paths such as `/.well-known`.
+
+`express.static.mime` is gone; use `mime-types` instead. Static-file behavior requires an application filesystem and is not exercised by the standalone examples here.
+
+## Not covered
+
+This skill does not cover Node HTTP server lifecycle details, network-based integration tests, filesystem fixtures for static files, the complete request and response object API, every middleware option, deployment configuration, or optional migration codemods. Those require the surrounding application/tool or information not present in the supplied research.

package/plugins/fake-indexeddb-6/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "fake-indexeddb-6",
+  "version": "6.0.0",
+  "description": "Use fake-indexeddb ^6.0.0 as a pure-JavaScript, in-memory IndexedDB implementation in Node.js scripts and test environments.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}