toolcraft 0.0.116 → 0.0.118

package/node_modules/tiny-stdio-mcp-server/dist/uri-template.js

@@ -0,0 +1,363 @@
+const operatorOptions = {
+    "": { prefix: "", separator: ",", named: false, ifEmpty: "", allowReserved: false },
+    "+": { prefix: "", separator: ",", named: false, ifEmpty: "", allowReserved: true },
+    "#": { prefix: "#", separator: ",", named: false, ifEmpty: "", allowReserved: true },
+    ".": { prefix: ".", separator: ".", named: false, ifEmpty: "", allowReserved: false },
+    "/": { prefix: "/", separator: "/", named: false, ifEmpty: "", allowReserved: false },
+    ";": { prefix: ";", separator: ";", named: true, ifEmpty: "", allowReserved: false },
+    "?": { prefix: "?", separator: "&", named: true, ifEmpty: "=", allowReserved: false },
+    "&": { prefix: "&", separator: "&", named: true, ifEmpty: "=", allowReserved: false }
+};
+const operators = new Set(["", "+", "#", ".", "/", ";", "?", "&"]);
+const reservedCharacters = new Set(":/?#[]@!$&'()*+,;=".split(""));
+class ParsedUriTemplate {
+    segments;
+    constructor(segments) {
+        this.segments = segments;
+    }
+    expand(variables) {
+        return this.segments
+            .map((segment) => segment.kind === "literal" ? segment.value : expandExpression(segment, variables))
+            .join("");
+    }
+    match(uri) {
+        return matchSegments(this.segments, uri, 0, 0, {});
+    }
+}
+export function parseUriTemplate(template) {
+    if (typeof template !== "string") {
+        throw new Error("URI template must be a string.");
+    }
+    const segments = [];
+    let literalStart = 0;
+    let index = 0;
+    while (index < template.length) {
+        const character = template[index];
+        if (character === "}") {
+            throw syntaxError(template, index, "unmatched closing brace");
+        }
+        if (character !== "{") {
+            index += 1;
+            continue;
+        }
+        if (index > literalStart) {
+            segments.push({ kind: "literal", value: template.slice(literalStart, index) });
+        }
+        const closeIndex = template.indexOf("}", index + 1);
+        if (closeIndex === -1) {
+            throw syntaxError(template, index, "unclosed expression");
+        }
+        const expression = template.slice(index + 1, closeIndex);
+        if (expression.includes("{")) {
+            throw syntaxError(template, index, "nested expression");
+        }
+        segments.push(parseExpression(template, expression, index));
+        index = closeIndex + 1;
+        literalStart = index;
+    }
+    if (literalStart < template.length) {
+        segments.push({ kind: "literal", value: template.slice(literalStart) });
+    }
+    if (segments.length === 0) {
+        segments.push({ kind: "literal", value: "" });
+    }
+    return new ParsedUriTemplate(segments);
+}
+function parseExpression(template, expression, offset) {
+    if (expression.length === 0) {
+        throw syntaxError(template, offset, "empty expression");
+    }
+    const first = expression[0];
+    const operator = operators.has(first) && first !== "" ? first : "";
+    const variableList = operator === "" ? expression : expression.slice(1);
+    if (variableList.length === 0) {
+        throw syntaxError(template, offset, "expression has no variables");
+    }
+    if (operator === "" && isReservedOperatorCharacter(first)) {
+        throw syntaxError(template, offset, `unsupported operator ${first}`);
+    }
+    const variables = variableList
+        .split(",")
+        .map((variable) => parseVariableSpec(template, variable, offset));
+    return { kind: "expression", operator, variables };
+}
+function parseVariableSpec(template, source, offset) {
+    if (source.length === 0) {
+        throw syntaxError(template, offset, "empty variable specification");
+    }
+    const explode = source.endsWith("*");
+    const withoutExplode = explode ? source.slice(0, -1) : source;
+    const colonIndex = withoutExplode.indexOf(":");
+    if (explode && colonIndex !== -1) {
+        throw syntaxError(template, offset, "explode and prefix modifiers cannot be combined");
+    }
+    const name = colonIndex === -1 ? withoutExplode : withoutExplode.slice(0, colonIndex);
+    if (!isValidVariableName(name)) {
+        throw syntaxError(template, offset, `invalid variable name ${name}`);
+    }
+    if (colonIndex === -1) {
+        return { name, explode };
+    }
+    const prefixSource = withoutExplode.slice(colonIndex + 1);
+    if (!isValidPrefix(prefixSource)) {
+        throw syntaxError(template, offset, `invalid prefix modifier ${prefixSource}`);
+    }
+    return { name, explode: false, prefixLength: Number(prefixSource) };
+}
+function isValidVariableName(name) {
+    if (name.length === 0) {
+        return false;
+    }
+    let componentLength = 0;
+    for (let index = 0; index < name.length; index += 1) {
+        const character = name[index];
+        if (character === ".") {
+            if (componentLength === 0)
+                return false;
+            componentLength = 0;
+            continue;
+        }
+        if (character === "%") {
+            if (!isHex(name[index + 1]) || !isHex(name[index + 2]))
+                return false;
+            index += 2;
+            componentLength += 1;
+            continue;
+        }
+        if (!isVariableCharacter(character))
+            return false;
+        componentLength += 1;
+    }
+    return componentLength > 0;
+}
+function isValidPrefix(value) {
+    if (value.length === 0 || value.length > 4 || value[0] === "0") {
+        return false;
+    }
+    return [...value].every((character) => character >= "0" && character <= "9");
+}
+function isReservedOperatorCharacter(character) {
+    return "=,!@|".includes(character);
+}
+function isVariableCharacter(character) {
+    return ((character >= "a" && character <= "z") ||
+        (character >= "A" && character <= "Z") ||
+        (character >= "0" && character <= "9") ||
+        character === "_");
+}
+function isHex(character) {
+    return (character !== undefined &&
+        ((character >= "0" && character <= "9") ||
+            (character >= "a" && character <= "f") ||
+            (character >= "A" && character <= "F")));
+}
+function syntaxError(template, index, detail) {
+    return new Error(`Invalid URI template at ${index}: ${detail} (${template})`);
+}
+function expandExpression(expression, variables) {
+    const options = operatorOptions[expression.operator];
+    const parts = [];
+    for (const variable of expression.variables) {
+        const value = variables[variable.name];
+        if (value === undefined || value === null) {
+            continue;
+        }
+        parts.push(...expandVariable(variable, value, options));
+    }
+    return parts.length === 0 ? "" : `${options.prefix}${parts.join(options.separator)}`;
+}
+function expandVariable(variable, value, options) {
+    if (Array.isArray(value)) {
+        if (variable.prefixLength !== undefined) {
+            throw new Error(`Prefix modifier requires a scalar value: ${variable.name}`);
+        }
+        return expandList(variable, value, options);
+    }
+    if (isRecord(value)) {
+        if (variable.prefixLength !== undefined) {
+            throw new Error(`Prefix modifier requires a scalar value: ${variable.name}`);
+        }
+        return expandAssociative(variable, value, options);
+    }
+    const original = String(value);
+    const scalar = variable.prefixLength === undefined
+        ? original
+        : [...original].slice(0, variable.prefixLength).join("");
+    const encoded = encodeValue(scalar, options.allowReserved);
+    return [namedValue(variable.name, encoded, options)];
+}
+function expandList(variable, value, options) {
+    if (value.length === 0) {
+        return [];
+    }
+    const encoded = value.map((item) => encodeValue(String(item), options.allowReserved));
+    if (!variable.explode) {
+        return [namedValue(variable.name, encoded.join(","), options)];
+    }
+    if (!options.named) {
+        return encoded;
+    }
+    return encoded.map((item) => namedValue(variable.name, item, options));
+}
+function expandAssociative(variable, value, options) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+        return [];
+    }
+    const encoded = entries.map(([key, item]) => [
+        encodeValue(key, options.allowReserved),
+        encodeValue(String(item), options.allowReserved)
+    ]);
+    if (!variable.explode) {
+        return [namedValue(variable.name, encoded.flat().join(","), options)];
+    }
+    return encoded.map(([key, item]) => `${key}=${item}`);
+}
+function namedValue(name, value, options) {
+    if (!options.named) {
+        return value;
+    }
+    const encodedName = encodeValue(name, true);
+    if (value.length === 0) {
+        return `${encodedName}${options.ifEmpty}`;
+    }
+    return `${encodedName}=${value}`;
+}
+function encodeValue(value, allowReserved) {
+    let result = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (allowReserved && character === "%" && isHex(value[index + 1]) && isHex(value[index + 2])) {
+            result += value.slice(index, index + 3);
+            index += 2;
+            continue;
+        }
+        const codePoint = value.codePointAt(index);
+        if (codePoint === undefined)
+            continue;
+        const scalar = String.fromCodePoint(codePoint);
+        if (scalar.length === 2)
+            index += 1;
+        if (isUnreserved(scalar) || (allowReserved && reservedCharacters.has(scalar))) {
+            result += scalar;
+            continue;
+        }
+        for (const byte of new TextEncoder().encode(scalar)) {
+            result += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+        }
+    }
+    return result;
+}
+function isUnreserved(character) {
+    return ((character >= "a" && character <= "z") ||
+        (character >= "A" && character <= "Z") ||
+        (character >= "0" && character <= "9") ||
+        "-._~".includes(character));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function matchSegments(segments, uri, segmentIndex, uriIndex, captures) {
+    if (segmentIndex === segments.length) {
+        return uriIndex === uri.length ? captures : null;
+    }
+    const segment = segments[segmentIndex];
+    if (segment.kind === "literal") {
+        return uri.startsWith(segment.value, uriIndex)
+            ? matchSegments(segments, uri, segmentIndex + 1, uriIndex + segment.value.length, captures)
+            : null;
+    }
+    for (const endIndex of candidateExpressionEnds(segments, uri, segmentIndex, uriIndex)) {
+        const expressionCaptures = matchExpression(segment, uri.slice(uriIndex, endIndex));
+        if (expressionCaptures === null)
+            continue;
+        const result = matchSegments(segments, uri, segmentIndex + 1, endIndex, {
+            ...captures,
+            ...expressionCaptures
+        });
+        if (result !== null)
+            return result;
+    }
+    return null;
+}
+function candidateExpressionEnds(segments, uri, segmentIndex, uriIndex) {
+    const next = segments[segmentIndex + 1];
+    if (next === undefined) {
+        return [uri.length];
+    }
+    const boundary = next.kind === "literal" ? next.value : operatorOptions[next.operator].prefix;
+    if (boundary.length === 0) {
+        return descendingRange(uriIndex, uri.length);
+    }
+    const indices = [];
+    let searchIndex = uri.length;
+    while (searchIndex >= uriIndex) {
+        const found = uri.lastIndexOf(boundary, searchIndex);
+        if (found < uriIndex)
+            break;
+        indices.push(found);
+        searchIndex = found - 1;
+    }
+    return indices;
+}
+function descendingRange(start, end) {
+    const values = [];
+    for (let value = end; value >= start; value -= 1)
+        values.push(value);
+    return values;
+}
+function matchExpression(expression, expansion) {
+    const options = operatorOptions[expression.operator];
+    if (expansion.length === 0) {
+        return {};
+    }
+    if (options.prefix.length > 0 && !expansion.startsWith(options.prefix)) {
+        return null;
+    }
+    const body = options.prefix.length === 0 ? expansion : expansion.slice(options.prefix.length);
+    if (options.named) {
+        return matchNamedExpression(expression.variables, body, options.separator);
+    }
+    return matchPositionalExpression(expression.variables, body, options.separator);
+}
+function matchNamedExpression(variables, body, separator) {
+    const captures = {};
+    const fields = body.length === 0 ? [] : body.split(separator);
+    for (const variable of variables) {
+        const encodedName = encodeValue(variable.name, true);
+        const values = [];
+        for (const field of fields) {
+            const equalsIndex = field.indexOf("=");
+            const key = equalsIndex === -1 ? field : field.slice(0, equalsIndex);
+            if (key === encodedName) {
+                values.push(equalsIndex === -1 ? "" : field.slice(equalsIndex + 1));
+            }
+        }
+        if (values.length > 0) {
+            captures[variable.name] = decodeValue(values.join(variable.explode ? "," : ""));
+        }
+        else if (variable.explode && variables.length === 1 && body.length > 0) {
+            captures[variable.name] = decodeValue(body);
+        }
+    }
+    return captures;
+}
+function matchPositionalExpression(variables, body, separator) {
+    if (variables.length === 1) {
+        return { [variables[0].name]: decodeValue(body) };
+    }
+    const captures = {};
+    const fields = body.split(separator);
+    for (let index = 0; index < variables.length && index < fields.length; index += 1) {
+        captures[variables[index].name] = decodeValue(index === variables.length - 1 ? fields.slice(index).join(separator) : fields[index]);
+    }
+    return captures;
+}
+function decodeValue(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}

package/node_modules/tiny-stdio-mcp-server/package.json

@@ -49,9 +49,5 @@
   ],
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.25.3"
-  },
-  "dependencies": {
-    "uri-template": "^2.0.0",
-    "uri-template-lite": "^23.4.0"
   }
 }

package/node_modules/toolcraft-design/package.json

@@ -21,11 +21,6 @@
     "dist",
     "LICENSE"
   ],
-  "dependencies": {
-    "fast-string-width": "^3.0.2",
-    "fast-wrap-ansi": "^0.2.0",
-    "sisteransi": "^1.0.5"
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.116",
+  "version": "0.0.118",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -8,7 +8,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {

package/node_modules/yaml/LICENSE

@@ -0,0 +1,13 @@
+Copyright Eemeli Aro <eemeli@gmail.com>
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

package/node_modules/yaml/README.md

@@ -0,0 +1,172 @@
+# YAML <a href="https://www.npmjs.com/package/yaml"><img align="right" src="https://badge.fury.io/js/yaml.svg" title="npm package" /></a>
+
+`yaml` is a definitive library for [YAML](https://yaml.org/), the human friendly data serialization standard.
+This library:
+
+- Supports both YAML 1.1 and YAML 1.2 and all common data schemas,
+- Passes all of the [yaml-test-suite](https://github.com/yaml/yaml-test-suite) tests,
+- Can accept any string as input without throwing, parsing as much YAML out of it as it can, and
+- Supports parsing, modifying, and writing YAML comments and blank lines.
+
+The library is released under the ISC open source license, and the code is [available on GitHub](https://github.com/eemeli/yaml/).
+It has no external dependencies and runs on Node.js as well as modern browsers.
+
+For the purposes of versioning, any changes that break any of the documented endpoints or APIs will be considered semver-major breaking changes.
+Undocumented library internals may change between minor versions, and previous APIs may be deprecated (but not removed).
+
+The minimum supported TypeScript version of the included typings is 3.9;
+for use in earlier versions you may need to set `skipLibCheck: true` in your config.
+This requirement may be updated between minor versions of the library.
+
+For more information, see the project's documentation site: [**eemeli.org/yaml**](https://eemeli.org/yaml/)
+
+For build instructions and contribution guidelines, see [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
+
+To install:
+
+```sh
+npm install yaml
+# or
+deno add jsr:@eemeli/yaml
+```
+
+**Note:** These docs are for `yaml@2`. For v1, see the [v1.10.0 tag](https://github.com/eemeli/yaml/tree/v1.10.0) for the source and [eemeli.org/yaml/v1](https://eemeli.org/yaml/v1/) for the documentation.
+
+## API Overview
+
+The API provided by `yaml` has three layers, depending on how deep you need to go: [Parse & Stringify](https://eemeli.org/yaml/#parse-amp-stringify), [Documents](https://eemeli.org/yaml/#documents), and the underlying [Lexer/Parser/Composer](https://eemeli.org/yaml/#parsing-yaml).
+The first has the simplest API and "just works", the second gets you all the bells and whistles supported by the library along with a decent [AST](https://eemeli.org/yaml/#content-nodes), and the third lets you get progressively closer to YAML source, if that's your thing.
+
+A [command-line tool](https://eemeli.org/yaml/#command-line-tool) is also included.
+
+### Parse & Stringify
+
+```js
+import { parse, stringify } from 'yaml'
+```
+
+- [`parse(str, reviver?, options?): value`](https://eemeli.org/yaml/#yaml-parse)
+- [`stringify(value, replacer?, options?): string`](https://eemeli.org/yaml/#yaml-stringify)
+
+### Documents
+
+<!-- prettier-ignore -->
+```js
+import {
+  Document,
+  isDocument,
+  parseAllDocuments,
+  parseDocument
+} from 'yaml'
+```
+
+- [`Document`](https://eemeli.org/yaml/#documents)
+  - [`constructor(value, replacer?, options?)`](https://eemeli.org/yaml/#creating-documents)
+  - [`#contents`](https://eemeli.org/yaml/#content-nodes)
+  - [`#directives`](https://eemeli.org/yaml/#stream-directives)
+  - [`#errors`](https://eemeli.org/yaml/#errors)
+  - [`#warnings`](https://eemeli.org/yaml/#errors)
+- [`isDocument(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`parseAllDocuments(str, options?): Document[]`](https://eemeli.org/yaml/#parsing-documents)
+- [`parseDocument(str, options?): Document`](https://eemeli.org/yaml/#parsing-documents)
+
+### Content Nodes
+
+<!-- prettier-ignore -->
+```js
+import {
+  isAlias, isCollection, isMap, isNode,
+  isPair, isScalar, isSeq, Scalar,
+  visit, visitAsync, YAMLMap, YAMLSeq
+} from 'yaml'
+```
+
+- [`isAlias(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isCollection(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isMap(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isNode(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isPair(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isScalar(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`isSeq(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
+- [`new Scalar(value)`](https://eemeli.org/yaml/#scalar-values)
+- [`new YAMLMap()`](https://eemeli.org/yaml/#collections)
+- [`new YAMLSeq()`](https://eemeli.org/yaml/#collections)
+- [`doc.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createNode(value, options?): Node`](https://eemeli.org/yaml/#creating-nodes)
+- [`doc.createPair(key, value): Pair`](https://eemeli.org/yaml/#creating-nodes)
+- [`visit(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+- [`visitAsync(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+
+### Parsing YAML
+
+```js
+import { Composer, Lexer, Parser } from 'yaml'
+```
+
+- [`new Lexer().lex(src)`](https://eemeli.org/yaml/#lexer)
+- [`new Parser(onNewLine?).parse(src)`](https://eemeli.org/yaml/#parser)
+- [`new Composer(options?).compose(tokens)`](https://eemeli.org/yaml/#composer)
+
+## YAML.parse
+
+```yaml
+# file.yml
+YAML:
+  - A human-readable data serialization language
+  - https://en.wikipedia.org/wiki/YAML
+yaml:
+  - A complete JavaScript implementation
+  - https://www.npmjs.com/package/yaml
+```
+
+```js
+import fs from 'fs'
+import YAML from 'yaml'
+
+YAML.parse('3.14159')
+// 3.14159
+
+YAML.parse('[ true, false, maybe, null ]\n')
+// [ true, false, 'maybe', null ]
+
+const file = fs.readFileSync('./file.yml', 'utf8')
+YAML.parse(file)
+// { YAML:
+//   [ 'A human-readable data serialization language',
+//     'https://en.wikipedia.org/wiki/YAML' ],
+//   yaml:
+//   [ 'A complete JavaScript implementation',
+//     'https://www.npmjs.com/package/yaml' ] }
+```
+
+## YAML.stringify
+
+```js
+import YAML from 'yaml'
+
+YAML.stringify(3.14159)
+// '3.14159\n'
+
+YAML.stringify([true, false, 'maybe', null])
+// `- true
+// - false
+// - maybe
+// - null
+// `
+
+YAML.stringify({ number: 3, plain: 'string', block: 'two\nlines\n' })
+// `number: 3
+// plain: string
+// block: |
+//   two
+//   lines
+// `
+```
+
+---
+
+Browser testing provided by:
+
+<a href="https://www.browserstack.com/open-source">
+<img width=200 src="https://eemeli.org/yaml/images/browserstack.svg" alt="BrowserStack" />
+</a>

package/node_modules/yaml/bin.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { UserError, cli, help } from './dist/cli.mjs'
+
+cli(process.stdin, error => {
+  if (error instanceof UserError) {
+    if (error.code === UserError.ARGS) console.error(`${help}\n`)
+    console.error(error.message)
+    process.exitCode = error.code
+  } else if (error) throw error
+})