@modootoday/pmcp 0.13.0 → 0.14.0

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

@@ -0,0 +1 @@
+{ "name": "jackspeak-4", "version": "4.0.0" }

package/plugins/jackspeak-4/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "jackspeak-4",
+  "version": "4.0.0",
+  "description": "Use jackspeak v4 to declare command-line fields, parse an explicit argument array, validate parsed values, and render usage documentation.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/jackspeak-4/skills/jackspeak/SKILL.md

@@ -0,0 +1,162 @@
+---
+name: jackspeak
+description: Use jackspeak v4 to declare command-line fields, parse an explicit argument array, validate parsed values, and render usage documentation.
+---
+
+Verified against jackspeak@4.2.3 on 2026-09-08. 3 of 3 examples executed.
+
+# jackspeak v4
+
+## Use this skill when
+
+Use the named `jack` export to build a declarative command-line parser. The basic shape is:
+
+```ts
+import { jack } from 'jackspeak'
+
+const result = jack(options)
+  .flag(fieldDefinitions)
+  .opt(fieldDefinitions)
+  .parse(args)
+```
+
+`parse()` returns `{ positionals, values }`. Pass an explicit `string[]` in library code and tests; its default is `process.argv`.
+
+Version 4 requires Node `20` or `>=22`. The package has ESM/CommonJS conditional exports, and the documented public entry point is `jackspeak` (with `jackspeak/min` also published). The documented API does not require a separate jackspeak CLI or test runner.
+
+## Core parsing shape
+
+`jack(options = {})` returns a chainable `Jack`. The documented field-definition methods are:
+
+- `heading(text, level?)`
+- `description(text, { pre? } = {})`
+- `flag(definitions)`
+- `flagList(definitions)`
+- `num(definitions)`
+- `numList(definitions)`
+- `opt(definitions)`
+- `optList(definitions)`
+- `addFields(...)`
+
+Definitions are object literals. This is important for TypeScript inference and avoids the older assumption that the parser is configured with a separate schema format.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { jack } from 'jackspeak'
+
+const parser = jack({ envPrefix: 'FOO' })
+  .flag({
+    foo: { description: 'another boolean', short: 'f' },
+  })
+  .optList({
+    'ip-addrs': {
+      description: 'addresses to ip things',
+      delim: ',',
+      default: ['127.0.0.1'],
+    },
+  })
+
+const { positionals, values } = parser.parse([
+  'some',
+  'positional',
+  '--ip-addrs',
+  '192.168.0.1',
+  '--ip-addrs',
+  '1.1.1.1',
+  '--foo',
+])
+
+assert.deepEqual(positionals, ['some', 'positional'])
+assert.equal(values.foo, true)
+assert.deepEqual(values['ip-addrs'], ['192.168.0.1', '1.1.1.1'])
+```
+
+Use `short` for a short flag or option name. A field can have a `description`, and list options can specify a delimiter and a default list.
+
+## Field kinds
+
+The available field kinds communicate the intended value shape:
+
+- `flag`: boolean option
+- `flagList`: repeated/list boolean option
+- `opt`: scalar option
+- `optList`: repeated/list option; `delim` controls delimiter splitting
+- `num`: numeric option
+- `numList`: repeated/list numeric option
+
+The research documents the methods and the object-definition style, but does not document every individual field configuration or the exact result shape for every kind. Do not infer unsupported configuration names from examples for another major version.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { jack } from 'jackspeak'
+
+const parser = jack()
+  .flag({ verbose: { short: 'v' } })
+  .opt({ reporter: { short: 'R', description: 'report style' } })
+  .num({ jobs: { short: 'j', default: 1 } })
+
+const parsed = parser.parse(['-v', '--reporter', 'compact', '--jobs', '4', 'file.ts'])
+
+assert.equal(parsed.values.verbose, true)
+assert.equal(parsed.values.reporter, 'compact')
+assert.equal(parsed.values.jobs, 4)
+assert.deepEqual(parsed.positionals, ['file.ts'])
+```
+
+## Validation and generated documentation
+
+The parser exposes these actions:
+
+- `parse(args?: string[])`: parse arguments and return `{ positionals, values }`.
+- `validate(o)`: assert that an unknown value is a valid `OptionsResults` value. Invalid values throw.
+- `usage()`: return usage text.
+- `usageMarkdown()`: return usage documentation in Markdown.
+- `setConfigValues(options, src?)`: set configuration values on the parser; `src` is optional.
+
+Unrecognized configurations and invalid values throw. Keep validation at the boundary when values come from configuration rather than directly from `parse()`.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert'
+import { jack } from 'jackspeak'
+
+const parser = jack({ usage: 'foo [options] <files>' })
+  .heading('The best Foo that ever Fooed')
+  .description('Executes all the files.')
+  .opt({ reporter: { short: 'R', description: 'report style' } })
+  .num({ jobs: { short: 'j', default: 1 } })
+
+const { values, positionals } = parser.parse(['--reporter', 'tap', 'a.ts'])
+parser.validate(values)
+
+assert.equal(values.reporter, 'tap')
+assert.equal(values.jobs, 1)
+assert.deepEqual(positionals, ['a.ts'])
+assert.equal(typeof parser.usage(), 'string')
+assert.equal(typeof parser.usageMarkdown(), 'string')
+assert.match(parser.usage(), /foo/)
+assert.match(parser.usageMarkdown(), /Foo|foo/)
+```
+
+## Headings, descriptions, and fields
+
+`heading` accepts a text string and an optional heading level from 1 through 6. `description` accepts text and an optional `{ pre: boolean }` setting. Both participate in generated usage output. Field methods are chainable.
+
+`addFields(...)` is also available for adding fields, but the opened research does not specify its argument shape; use the package's v4 type definitions or documentation when that method is required rather than copying a v3-era shape.
+
+## Environment integration
+
+Environment integration is conditional on `envPrefix`. The environment source defaults to `process.env`. Boolean values are represented as `'1'` and `'0'`; repeated values use a delimiter whose default is `\n`. The research does not establish a safe standalone example that changes the process environment, so rely on the v4 documentation and types for the exact field-to-environment naming rules.
+
+## Common mistakes
+
+- **Using the older runner-oriented mental model.** jackspeak is used programmatically here: import `jack`, define fields, and call `.parse()`. There is no documented separate jackspeak CLI for these examples.
+- **Expecting `parse()` to return values directly.** It returns `{ positionals, values }`; read options from `result.values` and positional arguments from `result.positionals`.
+- **Calling `.parse()` without accounting for `process.argv`.** The default is `process.argv`. Pass an explicit array when parsing supplied arguments or writing tests.
+- **Assuming v3's runtime requirements.** v4 requires Node `20` or `>=22`; v3 had no `engines` field.
+- **Assuming the optional parser dependency is required.** v4 lists `@pkgjs/parseargs` as an optional dependency; it is not required by the documented API.
+- **Using undocumented configuration shapes.** Invalid or unrecognized configurations throw. In particular, do not invent the `addFields` argument shape or copy an older major's examples without checking v4's definitions.
+- **Treating list options as scalar options.** Use `optList`/`numList`/`flagList` for list-shaped fields and configure `delim` where delimiter behavior matters.
+
+## Not covered
+
+This skill does not cover the complete v4 field-definition type signatures, every option supported by each field kind, exact long/short-option syntax beyond the documented examples, the exact environment-variable naming rules, the full behavior or argument shape of `addFields`, the `jackspeak/min` subpath API, CommonJS import examples, or the internal optional `@pkgjs/parseargs` integration. Those details were not established by the opened research.

package/plugins/jake-12/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "jake-12",
+  "version": "12.0.0",
+  "description": "Use Jake 12.x task-definition APIs safely from JavaScript or TypeScript, while distinguishing import-time definitions from behavior supplied by Jake’s CLI runner.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/jake-12/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/jake-12/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/jake-12/gemini-extension.json

@@ -0,0 +1 @@
+{ "name": "jake-12", "version": "12.0.0" }

package/plugins/jake-12/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "jake-12",
+  "version": "12.0.0",
+  "description": "Use Jake 12.x task-definition APIs safely from JavaScript or TypeScript, while distinguishing import-time definitions from behavior supplied by Jake’s CLI runner.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/jake-12/skills/jake/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: jake
+description: Use Jake 12.x task-definition APIs safely from JavaScript or TypeScript, while distinguishing import-time definitions from behavior supplied by Jake’s CLI runner.
+---
+
+Verified against jake@12.10.1 on 2026-09-08. 7 of 7 examples executed.
+
+# jake
+
+## Version and import
+
+This skill targets `jake` `^12.0.0`, including the documented `12.10.1` release. The package’s main entry point is `lib/jake.js`, and importing it returns the Jake object. The package requires Node `>=10`.
+
+Use the package directly in a script:
+
+```ts pmcp-example
+import assert from "node:assert/strict";
+import jake from "jake";
+
+assert.equal(typeof jake.task, "function");
+assert.equal(typeof jake.file, "function");
+assert.equal(typeof jake.namespace, "function");
+assert.equal(typeof jake.series, "function");
+```
+
+The documented task-definition functions include `task`, `rule`, `directory`, `file`, `desc`, `namespace`, `complete`, `fail`, `packageTask`, `publishTask`, `npmPublishTask`, `testTask`, `setTaskTimeout`, `setSeriesAutoPrefix`, and `series`.
+
+## Define ordinary tasks
+
+The established API is `task(name, [prerequisites], [action])`. The action can be an ordinary function, an async function, or a function returning a Promise. Define prerequisites by name when they must run before the action.
+
+```ts pmcp-example
+import assert from "node:assert/strict";
+import { desc, task } from "jake";
+
+let ran = false;
+
+desc("A task defined by an embedded Jake program.");
+task("prepare", () => {
+  ran = true;
+});
+task("build", ["prepare"], async () => {
+  assert.equal(ran, false);
+  await Promise.resolve();
+});
+
+assert.equal(typeof task, "function");
+assert.equal(typeof desc, "function");
+```
+
+Defining a task does not, by itself, demonstrate CLI execution or prerequisite execution. Those behaviors require Jake’s runner.
+
+## File and directory tasks
+
+Use `file` for a file-oriented task and `directory` for a directory-oriented task. A file task accepts a name, optional prerequisites, and an action. A directory task can be declared with its directory name.
+
+```ts pmcp-example
+import assert from "node:assert/strict";
+import { desc, file } from "jake";
+
+let actionDefined = false;
+
+desc("Build a production file.");
+file("foo-production.js", ["bar", "foo-bar.js", "foo-baz.js"], () => {
+  actionDefined = true;
+});
+
+assert.equal(actionDefined, false);
+assert.equal(typeof file, "function");
+```
+
+The file action is associated with the task definition; it is not run merely because the definition is imported.
+
+```ts pmcp-example
+import assert from "node:assert/strict";
+import { desc, directory } from "jake";
+
+desc('Declare the directory task "bar".');
+directory("bar");
+
+assert.equal(typeof directory, "function");
+assert.equal(typeof desc, "function");
+```
+
+## Namespaces
+
+Use `namespace(name, callback)` to group task definitions. Tasks declared inside the callback are namespace-scoped, such as `foo:bar` in the documented shape.
+
+```ts pmcp-example
+import assert from "node:assert/strict";
+import { desc, namespace, task } from "jake";
+
+let defined = false;
+
+namespace("foo", () => {
+  desc("The foo:bar task.");
+  task("bar", () => {
+    defined = true;
+  });
+});
+
+assert.equal(defined, false);
+assert.equal(typeof namespace, "function");
+```
+
+The callback defines the task; it does not execute the task action.
+
+## Compose functions with `series`
+
+`series` composes functions for sequential execution. The documentation labels this API experimental.
+
+```ts pmcp-example
+import assert from "node:assert/strict";
+import { series } from "jake";
+
+const events: string[] = [];
+const clean = () => {
+  events.push("clean");
+};
+const lint = async () => {
+  events.push("lint");
+};
+const build = () => {
+  events.push("build");
+};
+
+const composed = series(clean, lint, build);
+assert.equal(typeof composed, "function");
+
+await composed();
+assert.deepEqual(events, ["clean", "lint", "build"]);
+```
+
+Because this API is experimental, prefer the established `task` form when task-definition compatibility is the priority.
+
+## Exported-function task shape
+
+Jake also documents an alternative, experimental form in which exported functions implicitly become tasks:
+
+```ts pmcp-example
+import assert from "node:assert/strict";
+import { series } from "jake";
+
+function clean() {}
+async function lint() {}
+function internalBuild() {}
+
+const exportedTasks = {
+  clean,
+  lint,
+  build: series(clean, lint, internalBuild),
+};
+
+assert.equal(typeof exportedTasks.clean, "function");
+assert.equal(typeof exportedTasks.lint, "function");
+assert.equal(typeof exportedTasks.build, "function");
+```
+
+The exported-function task API and `series` are documented as experimental. Do not confuse this newer shape with the older and still explicitly documented `task(name, prerequisites, action)` API.
+
+## Runner-only behavior
+
+Jake is primarily a CLI tool, but its task APIs can be embedded in another program. Importing the package and defining tasks is usable in a plain script; task discovery, task listing, prerequisite execution, and normal CLI invocation require Jake’s runner.
+
+The CLI shape is:
+
+```text
+jake [options ...] [env variables ...] target
+```
+
+When invoked as a runner, Jake searches for `Jakefile`, `Jakefile.js`, `jakefile`, or `jakefile.js`. If it does not find one, it searches parent directories up to the filesystem root and errors if none is found. It automatically loads `.js` files from `jakelib` after the main Jakefile; `-J`/`--jakelibdir` overrides that directory.
+
+Do not put `describe`, `it`, or `expect` in a directly executed example: they are not provided by Jake’s package import. Likewise, do not assume that merely importing a Jakefile executes its tasks.
+
+## What this skill does not cover
+
+- The exact signatures or behavior of the exposed classes and helpers beyond the documented task-definition surface.
+- The signatures of `run`, `parseAllTasks`, `attemptRule`, `createTask`, or other internal/programmatic runner functions.
+- Jake CLI options beyond the invocation shape and `-J`/`--jakelibdir` behavior described above.
+- Filesystem effects and the actual execution order of runner-discovered tasks.
+- A v12-specific migration guide: the supplied changelog has no v11 or v12 migration/change section.
+- Undocumented behavior of `rule`, publishing helpers, test helpers, timeout configuration, or completion/failure signaling.

package/plugins/jasmine-core-7/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "jasmine-core-7",
+  "version": "7.0.1",
+  "description": "Use jasmine-core ^7.0.0 directly from Node: install its globals into a chosen object, inspect the core version, reset shared state, and define Jasmine specs, expectations, spies, and not-applicable specs. It is not the Jasmine CLI or test runner.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}