@modootoday/pmcp 0.13.0 → 0.14.0

package/plugins/ioredis-6/skills/ioredis/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: ioredis
+description: Use ioredis ^6.0.0 from Node.js 20+ for Redis commands, pipelines, Pub/Sub, Lua commands, streams, and RESP3-aware clients.
+---
+
+Verified against ioredis@6.0.0 on 2026-09-07. 5 of 5 examples executed.
+
+# ioredis ^6.0.0
+
+## Runtime and compatibility
+
+- ioredis 6 requires Node.js `>=20`.
+- The documented Redis range is Redis `6.2` through the latest release.
+- The package exports TypeScript declarations.
+- In CommonJS, use `require("ioredis")`. In TypeScript, prefer the named import `{ Redis }`.
+- The default import is still supported, but is scheduled for deprecation in the next major version.
+- `new Redis()` connects to `localhost:6379`.
+- Redis URLs may use `redis://` or `rediss://`, including username, password, port, and database components.
+
+## The v6 protocol and reply-shape trap
+
+ioredis v6 opens connections with RESP3 by default and sends `HELLO 3`. If credentials are configured, authentication is included in that handshake. It falls back to RESP2 only for `NOPROTO` or unknown-command errors; other handshake errors fail the connection.
+
+Code copied from v5 commonly assumes the old protocol or reply shapes. To preserve the v5 wire protocol, configure:
+
+```ts
+new Redis({ protocol: 2 })
+```
+
+The default `replyMapping: "legacy"` keeps v5/RESP2-compatible result shapes. With `protocol: 3` and `replyMapping: "resp3"`, replies use RESP3-oriented shapes:
+
+- RESP3 maps become plain objects instead of flat arrays.
+- RESP3 doubles become numbers instead of strings.
+- RESP3 booleans become booleans instead of `0`/`1`.
+- Sets remain arrays.
+- Big numbers and verbatim strings remain strings.
+- Command-specific transformers still apply.
+
+For example, with `protocol: 3` and `replyMapping: "resp3"`, `CONFIG GET maxmemory` returns `{ maxmemory: "0" }` rather than `["maxmemory", "0"]`, and `ZSCORE` returns `1.5` rather than `"1.5"`.
+
+## Basic commands
+
+Commands return promises when the last argument is not a callback. They also support callbacks. The normal standalone shape is:
+
+```ts
+const redis = new Redis()
+await redis.set("mykey", "value")
+const value = await redis.get("mykey")
+```
+
+The callback form is also supported:
+
+```ts
+redis.get("mykey", (err, result) => {
+  if (err) {
+    console.error(err)
+  } else {
+    console.log(result)
+  }
+})
+```
+
+A Redis server is required for command execution. Close clients when the script is finished.
+
+```ts pmcp-example
+import { strict as assert } from "node:assert"
+import { Redis } from "ioredis"
+
+assert.equal(typeof Redis, "function")
+assert.equal(typeof Redis.prototype.get, "function")
+assert.equal(typeof Redis.prototype.set, "function")
+
+const redis = new Redis("redis://127.0.0.1:6379")
+assert.equal(typeof redis.get, "function")
+assert.equal(typeof redis.set, "function")
+redis.disconnect()
+```
+
+## Pipelining
+
+`redis.pipeline()` returns a pipeline. Queue commands on it and call `exec()` to flush them. `exec()` also returns a promise.
+
+```ts
+const results = await redis
+  .pipeline()
+  .set("foo", "bar")
+  .get("foo")
+  .exec()
+```
+
+The callback form receives an array of responses corresponding to the queued commands. Each response has the form `[err, result]`; the pipeline-level `err` is documented as always `null`.
+
+```ts pmcp-example
+import { strict as assert } from "node:assert"
+import { Redis } from "ioredis"
+
+assert.equal(typeof Redis.prototype.pipeline, "function")
+
+const redis = new Redis("redis://127.0.0.1:6379")
+const pipeline = redis.pipeline()
+assert.equal(typeof pipeline.set, "function")
+assert.equal(typeof pipeline.get, "function")
+assert.equal(typeof pipeline.exec, "function")
+redis.disconnect()
+```
+
+## Pub/Sub
+
+Use separate connections for subscriber and publisher roles. Once a connection subscribes, it enters subscriber mode.
+
+```ts
+const sub = new Redis()
+const pub = new Redis()
+
+sub.subscribe("my-channel-1", "my-channel-2")
+sub.on("message", (channel, message) => {
+  console.log(channel, message)
+})
+await pub.publish("my-channel-1", JSON.stringify({ foo: "bar" }))
+```
+
+Use `messageBuffer` when messages must be received as Buffers. Pattern subscriptions use `psubscribe()` and the `pmessage`/`pmessageBuffer` events.
+
+```ts pmcp-example
+import { strict as assert } from "node:assert"
+import { Redis } from "ioredis"
+
+assert.equal(typeof Redis.prototype.subscribe, "function")
+assert.equal(typeof Redis.prototype.psubscribe, "function")
+assert.equal(typeof Redis.prototype.publish, "function")
+
+const subscriber = new Redis("redis://127.0.0.1:6379")
+const publisher = new Redis("redis://127.0.0.1:6379")
+assert.equal(typeof subscriber.on, "function")
+assert.equal(typeof publisher.publish, "function")
+subscriber.disconnect()
+publisher.disconnect()
+```
+
+## Lua custom commands
+
+`defineCommand()` adds a command to the client. ioredis uses `EVALSHA` when possible. A `myecho` command can declare its key count and Lua body:
+
+```ts
+redis.defineCommand("myecho", {
+  numberOfKeys: 2,
+  lua: "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}"
+})
+```
+
+The generated command accepts the keys and arguments. ioredis also creates a Buffer-returning variant named by adding `Buffer`, such as `myechoBuffer`.
+
+```ts pmcp-example
+import { strict as assert } from "node:assert"
+import { Redis } from "ioredis"
+
+assert.equal(typeof Redis.prototype.defineCommand, "function")
+
+const redis = new Redis("redis://127.0.0.1:6379")
+redis.defineCommand("myecho", {
+  numberOfKeys: 2,
+  lua: "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}"
+})
+assert.equal(typeof redis.myecho, "function")
+assert.equal(typeof redis.myechoBuffer, "function")
+redis.disconnect()
+```
+
+## Streams
+
+Use `XADD` to produce stream messages. The documented consumption pattern uses `XREAD` in an async consumer, with each message represented by an ID and field/value data.
+
+```ts
+await redis.xadd("mystream", "*", "randomValue", Math.random())
+```
+
+`XREAD` is used to consume messages, commonly from the last-seen ID. Stream reads also support the documented `MAXCOUNT` and `MAXSIZE` additions in v6.
+
+```ts pmcp-example
+import { strict as assert } from "node:assert"
+import { Redis } from "ioredis"
+
+assert.equal(typeof Redis.prototype.xadd, "function")
+assert.equal(typeof Redis.prototype.xread, "function")
+
+const redis = new Redis("redis://127.0.0.1:6379")
+assert.equal(typeof redis.xadd, "function")
+assert.equal(typeof redis.xread, "function")
+redis.disconnect()
+```
+
+## Common mistakes
+
+- Do not assume v5's RESP2 wire protocol is still the default. v6 defaults to RESP3; use `{ protocol: 2 }` when preserving v5 protocol behavior.
+- Do not assume every reply has its v5 shape. The default legacy mapping preserves compatibility, while `{ protocol: 3, replyMapping: "resp3" }` changes maps, doubles, and booleans.
+- Do not use one connection for both subscription and ordinary publishing. Create separate subscriber and publisher clients.
+- Do not expect commands to run without a reachable Redis server. `new Redis()` connects to localhost by default.
+- Do not forget that pipeline results are per-command `[err, result]` pairs rather than a single ordinary command result.
+- Do not use a runner-injected `describe`, `it`, or `expect` in a direct script. The package is a Redis client; direct scripts use its programmatic API.
+- Do not copy the older default-import style into new TypeScript code when the named `{ Redis }` import is available; the default import is supported now but is planned for deprecation in the next major.
+
+## Not covered
+
+This skill does not cover Redis server installation or configuration, command-by-command Redis semantics, cluster setup, Sentinel, connection-retry tuning, transactions, locks, binary encoding beyond the documented Buffer variants, TypeScript compiler configuration, or ioredis's maintainer build/test/documentation commands. The examples only verify the directly exposed client surface without requiring a Redis server; command execution, Pub/Sub delivery, Lua evaluation, and stream consumption require a reachable Redis instance.

package/plugins/ip-address-10/.claude-plugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "name": "ip-address-10",
+  "version": "10.0.0",
+  "description": "Use ip-address ^10.0.0 for standalone IPv4 and IPv6 parsing, validation, subnet checks, conversions, special-address inspection, and URL parsing. This skill emphasizes the v10 native-BigInt API and avoids older v9 method names.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/ip-address-10/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/ip-address-10/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/ip-address-10/gemini-extension.json

@@ -0,0 +1 @@
+{ "name": "ip-address-10", "version": "10.0.0" }

package/plugins/ip-address-10/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "ip-address-10",
+  "version": "10.0.0",
+  "description": "Use ip-address ^10.0.0 for standalone IPv4 and IPv6 parsing, validation, subnet checks, conversions, special-address inspection, and URL parsing. This skill emphasizes the v10 native-BigInt API and avoids older v9 method names.",
+  "author": { "name": "modootoday" },
+  "license": "Elastic-2.0",
+  "repository": "https://github.com/modootoday/pmcp",
+  "homepage": "https://pmcp.build/skills/"
+}

package/plugins/ip-address-10/skills/ip-address/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: ip-address
+description: Use ip-address ^10.0.0 for standalone IPv4 and IPv6 parsing, validation, subnet checks, conversions, special-address inspection, and URL parsing. This skill emphasizes the v10 native-BigInt API and avoids older v9 method names.
+---
+
+Verified against ip-address@10.7.0 on 2026-09-08. 8 of 8 examples executed.
+
+# ip-address ^10.0.0
+
+`ip-address` 10.x exports `Address4`, `Address6`, and `AddressError`. It supports ESM and CommonJS and includes TypeScript declarations. The documented runtime requires Node.js 12 or newer. Install it before running the examples.
+
+## Importing
+
+Use the named ESM exports:
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert/strict';
+import { Address4, Address6 } from 'ip-address';
+
+assert.equal(Address4.isValid('192.168.1.1'), true);
+assert.equal(Address6.isValid('2001:db8::1'), true);
+assert.equal(Address6.isValid('not an address'), false);
+
+const v4 = new Address4('192.168.1.1/24');
+const v6 = new Address6('2001:db8::1/64');
+
+assert.ok(v4);
+assert.ok(v6);
+```
+
+CommonJS is also documented:
+
+```js
+const { Address6 } = require('ip-address');
+const address = new Address6('2001:0:ce49:7601:e866:efff:62c3:fffe');
+const teredo = address.inspectTeredo();
+console.log(teredo.client4);
+```
+
+## IPv4
+
+Construct an address with an optional CIDR prefix. `isValid` is a static validity check. IPv4 addresses support subnet membership, subnet boundaries, private/global checks, and alternate constructors.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert/strict';
+import { Address4 } from 'ip-address';
+
+const host = new Address4('192.168.1.42');
+const network = new Address4('192.168.1.0/24');
+
+assert.equal(host.isInSubnet(network), true);
+assert.equal(network.startAddress().correctForm(), '192.168.1.0');
+assert.equal(network.endAddress().correctForm(), '192.168.1.255');
+assert.equal(new Address4('192.168.1.1').isPrivate(), true);
+assert.equal(typeof new Address4('192.168.1.1').isGlobal(), 'boolean');
+```
+
+Available IPv4 constructors and checks include:
+
+- `new Address4(address)`
+- `Address4.isValid(address)`
+- `Address4.fromAddressAndMask(address, mask)`
+- `Address4.fromAddressAndWildcardMask(address, wildcardMask)`
+- `Address4.fromWildcard(input)`
+- `Address4.fromHex(hex)`
+- `Address4.fromInteger(integer)`
+- `isInSubnet(subnet)`
+- `startAddress()` and `endAddress()`
+- `isPrivate()` and `isGlobal()`
+- `correctForm()`
+
+The alternate constructors return `Address4` instances. `fromWildcard` takes a four-octet wildcard pattern; use `*` for wildcard octets.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert/strict';
+import { Address4 } from 'ip-address';
+
+const fromMask = Address4.fromAddressAndMask('192.168.1.42', '255.255.255.0');
+const fromWildcardMask = Address4.fromAddressAndWildcardMask('192.168.1.42', '0.0.0.255');
+const fromWildcard = Address4.fromWildcard('192.168.*.*');
+const fromHex = Address4.fromHex('c0a80101');
+const fromInteger = Address4.fromInteger(3232235777);
+
+for (const address of [fromMask, fromWildcardMask, fromWildcard, fromHex, fromInteger]) {
+  assert.ok(address instanceof Address4);
+}
+```
+
+## IPv6
+
+Construct an IPv6 address with an optional CIDR prefix and optionally an `optionalGroups` value. IPv6 provides canonical and native-BigInt forms, byte conversion, special-address predicates, embedded IPv4 handling, URL parsing, and protocol-specific inspection.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert/strict';
+import { Address6 } from 'ip-address';
+
+const address = new Address6('2001:db8::1/64');
+assert.equal(address.canonicalForm(), '2001:0db8:0000:0000:0000:0000:0000:0001');
+assert.equal(typeof address.bigInt(), 'bigint');
+assert.equal(Array.isArray(address.toByteArray()), true);
+
+const link = new Address6('fe80::1');
+assert.equal(link.isLinkLocal(), true);
+assert.equal(link.isMulticast(), false);
+assert.equal(link.isLoopback(), false);
+assert.equal(typeof link.isGlobal(), 'boolean');
+```
+
+The documented IPv6 surface includes:
+
+- `new Address6(address, optionalGroups?)`
+- `Address6.isValid(address)`
+- `Address6.fromBigInt(bigInt)`
+- `bigInt()`
+- `canonicalForm()` and `toByteArray()`
+- `isLinkLocal()`, `isMulticast()`, `isLoopback()`, and `isGlobal()`
+- `inspectTeredo()` and `inspect6to4()`
+- `toAddress4Nat64(prefix?)`
+- `embeddedIPv4()`
+- `href(optionalPort?)`
+- `link(options?)`, where options may contain `className`, `prefix`, and `v4`
+
+Use native `bigint` in v10:
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert/strict';
+import { Address6 } from 'ip-address';
+
+const original = new Address6('2001:db8::1');
+const numeric = original.bigInt();
+const restored = Address6.fromBigInt(numeric);
+
+assert.equal(typeof numeric, 'bigint');
+assert.ok(restored instanceof Address6);
+assert.equal(restored.canonicalForm(), original.canonicalForm());
+```
+
+Teredo addresses can expose the decoded client IPv4 address:
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert/strict';
+import { Address6 } from 'ip-address';
+
+const teredo = new Address6('2001:0:ce49:7601:e866:efff:62c3:fffe');
+assert.equal(teredo.inspectTeredo().client4, '157.60.0.1');
+```
+
+## IPv6 URLs and errors
+
+`Address6.fromURL(url)` returns either an error result with `address: null` and `port: null`, or a result containing an `Address6` and a nullable port.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert/strict';
+import { Address6 } from 'ip-address';
+
+const parsed = Address6.fromURL('http://[2001:db8::1]:8080/');
+assert.equal(parsed.port, 8080);
+assert.ok(parsed.address instanceof Address6);
+```
+
+`AddressError` can be constructed with a message and an optional parse message; its `parseMessage` property is exposed.
+
+```ts pmcp-example
+import { strict as assert } from 'node:assert/strict';
+import { AddressError } from 'ip-address';
+
+const error = new AddressError('invalid address', 'parse failed');
+assert.equal(error.parseMessage, 'parse failed');
+assert.equal(error.message, 'invalid address');
+```
+
+## v10 migration warning
+
+Do not copy the older v9 API names shown in older generated documentation:
+
+- `fromBigInteger()` became `fromBigInt()`.
+- `bigInteger()` became `bigInt()`.
+- v10 returns and accepts native JavaScript `BigInt` values rather than the removed `jsbn`-based shape.
+
+The package’s v10 generated documentation may still show `fromBigInteger` and `bigInteger`; follow the v10 migration names instead.
+
+## What this skill does not cover
+
+This skill does not cover browser bundling, the package’s build or release workflow, generated documentation, or command-line/tool execution. The research describes browser use through browserify but does not provide a standalone browser example. It also does not specify the exact results or input formats for every documented conversion, formatting, NAT64, 6to4, URL-error, or link option, so those details are left for the package’s TypeScript declarations or API documentation.

package/plugins/jackspeak-4/.claude-plugin/plugin.json

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