toolcraft 0.0.92 → 0.0.94

package/dist/testing/parity.js

@@ -0,0 +1,384 @@
+import { isDeepStrictEqual } from "node:util";
+import { McpClient, McpError, ERROR_INVALID_PARAMS, createSdkTestPair } from "tiny-mcp-client";
+import { runCLI } from "../cli.js";
+import { UserError } from "../index.js";
+import { createMCPServer } from "../mcp.js";
+import { filterSchemaForScope } from "../schema-scope.js";
+import { createSDK } from "../sdk.js";
+class SurfaceScopeError extends Error {
+    constructor(surface, path) {
+        super(`Command "${path.join(" ")}" is filtered out of the ${surface} surface.`);
+        this.name = "SurfaceScopeError";
+    }
+}
+function splitWords(value) {
+    const words = [];
+    let current = "";
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index] ?? "";
+        const lower = char.toLowerCase();
+        const upper = char.toUpperCase();
+        const isSeparator = char === "-" || char === "_" || char === " " || char === ".";
+        if (isSeparator) {
+            if (current.length > 0) {
+                words.push(current.toLowerCase());
+                current = "";
+            }
+            continue;
+        }
+        const isUppercase = char !== lower && char === upper;
+        const previous = value[index - 1];
+        const next = value[index + 1];
+        const previousIsLowercase = previous !== undefined &&
+            previous === previous.toLowerCase() &&
+            previous !== previous.toUpperCase();
+        const nextIsLowercase = next !== undefined && next === next.toLowerCase() && next !== next.toUpperCase();
+        if (isUppercase && current.length > 0 && (previousIsLowercase || nextIsLowercase)) {
+            words.push(current.toLowerCase());
+            current = char;
+            continue;
+        }
+        current += char;
+    }
+    if (current.length > 0) {
+        words.push(current.toLowerCase());
+    }
+    return words;
+}
+function formatName(value, casing) {
+    const words = splitWords(value);
+    if (casing === "camel") {
+        return words
+            .map((word, index) => index === 0 ? word : `${word.slice(0, 1).toUpperCase()}${word.slice(1)}`)
+            .join("");
+    }
+    return words.join(casing === "kebab" ? "-" : "_");
+}
+function unwrapOptional(schema) {
+    return schema.kind === "optional" ? unwrapOptional(schema.inner) : schema;
+}
+function mapUnknownMCPObject(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [formatName(key, "snake"), child]));
+}
+function filterParams(schema, params, surface) {
+    const filtered = filterSchemaForScope(schema, surface);
+    if (filtered?.kind !== "object") {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(filtered.shape).flatMap(([key, childSchema]) => {
+        const value = params[key];
+        if (value === undefined) {
+            return [];
+        }
+        const unwrapped = unwrapOptional(childSchema);
+        if (unwrapped.kind === "object" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            return [[key, filterParams(unwrapped, value, surface)]];
+        }
+        return [[key, value]];
+    }));
+}
+function mapMCPValue(schema, value) {
+    const unwrapped = unwrapOptional(schema);
+    if (value === null || value === undefined) {
+        return value;
+    }
+    switch (unwrapped.kind) {
+        case "array":
+            return Array.isArray(value) ? value.map((item) => mapMCPValue(unwrapped.item, item)) : value;
+        case "object": {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, child]) => {
+                const childSchema = unwrapped.shape[key];
+                return [
+                    formatName(key, "snake"),
+                    childSchema === undefined ? child : mapMCPValue(childSchema, child)
+                ];
+            }));
+        }
+        case "record":
+            return typeof value === "object" && !Array.isArray(value)
+                ? Object.fromEntries(Object.entries(value).map(([key, child]) => [key, mapMCPValue(unwrapped.value, child)]))
+                : value;
+        case "oneOf": {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                return value;
+            }
+            const objectValue = value;
+            const discriminator = objectValue[unwrapped.discriminator];
+            const branch = typeof discriminator === "string" ? unwrapped.branches[discriminator] : undefined;
+            return branch === undefined
+                ? mapUnknownMCPObject(objectValue)
+                : mapMCPValue(branch, objectValue);
+        }
+        case "union": {
+            if (typeof value !== "object" || Array.isArray(value)) {
+                return value;
+            }
+            const objectValue = value;
+            const branch = unwrapped.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(objectValue, key)));
+            return branch === undefined
+                ? mapUnknownMCPObject(objectValue)
+                : mapMCPValue(branch, objectValue);
+        }
+        case "boolean":
+        case "enum":
+        case "json":
+        case "number":
+        case "string":
+            return value;
+    }
+}
+function success(value) {
+    return { ok: true, value, error: undefined };
+}
+function failure(error) {
+    return { ok: false, value: undefined, error };
+}
+async function runSDK(root, resolved, params, options) {
+    if (!resolved.command.scope.includes("sdk")) {
+        return failure(new SurfaceScopeError("sdk", resolved.path));
+    }
+    try {
+        let member = createSDK(root, options);
+        for (const segment of resolved.path) {
+            member = member[formatName(segment, "camel")];
+        }
+        if (typeof member !== "function") {
+            throw new Error(`SDK command "${resolved.path.join(".")}" is not callable.`);
+        }
+        return success(await member(filterParams(resolved.command.params, params, "sdk")));
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+function parseMcpValue(result, reference) {
+    if (result.structuredContent !== undefined) {
+        return result.structuredContent;
+    }
+    const text = result.content
+        .filter((item) => item.type === "text" && item.text !== undefined)
+        .map((item) => item.text)
+        .join("\n");
+    if (text.length === 0) {
+        return undefined;
+    }
+    if (reference?.ok === true && isDeepStrictEqual(text, reference.value)) {
+        return text;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+async function runMCP(root, resolved, params, options, reference) {
+    if (!resolved.command.scope.includes("mcp")) {
+        return failure(new SurfaceScopeError("mcp", resolved.path));
+    }
+    const server = createMCPServer(root, {
+        ...options,
+        name: `${root.name}-parity`,
+        version: "0.0.0",
+        casing: "snake"
+    });
+    const client = new McpClient({
+        clientInfo: { name: "toolcraft-parity", version: "0.0.0" }
+    });
+    const pair = await createSdkTestPair(server, () => client);
+    try {
+        const toolName = [root.name, ...resolved.path]
+            .map((segment) => formatName(segment, "snake"))
+            .join("__");
+        const argumentsValue = mapMCPValue(resolved.command.params, filterParams(resolved.command.params, params, "mcp"));
+        const result = await client.callTool({ name: toolName, arguments: argumentsValue });
+        return success(parseMcpValue(result, reference));
+    }
+    catch (error) {
+        if (error instanceof McpError && error.code === ERROR_INVALID_PARAMS) {
+            return failure(new UserError(error.message));
+        }
+        return failure(error);
+    }
+    finally {
+        await pair.cleanup();
+    }
+}
+function valueAtPath(value, path) {
+    return path.reduce((current, segment) => typeof current === "object" && current !== null
+        ? current[segment]
+        : undefined, value);
+}
+function appendCLIValue(argv, flag, value) {
+    if (typeof value === "boolean") {
+        argv.push(value ? flag : `--no-${flag.slice(2)}`);
+        return;
+    }
+    if (Array.isArray(value)) {
+        argv.push(flag, ...value.map((item) => String(item)));
+        return;
+    }
+    argv.push(flag, typeof value === "object" ? JSON.stringify(value) : String(value));
+}
+function appendCLIFlags(argv, schema, params, positionals, sourcePath = [], flagPath = []) {
+    for (const [key, rawSchema] of Object.entries(schema.shape)) {
+        const nextSourcePath = [...sourcePath, key];
+        const nextFlagPath = [...flagPath, formatName(key, "kebab")];
+        const displayPath = nextSourcePath.join(".");
+        const value = params[key];
+        if (value === undefined || positionals.has(displayPath)) {
+            continue;
+        }
+        const childSchema = unwrapOptional(rawSchema);
+        if (childSchema.kind === "object" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            appendCLIFlags(argv, childSchema, value, positionals, nextSourcePath, nextFlagPath);
+            continue;
+        }
+        if (childSchema.kind === "record" &&
+            typeof value === "object" &&
+            value !== null &&
+            !Array.isArray(value)) {
+            for (const [recordKey, recordValue] of Object.entries(value)) {
+                appendCLIValue(argv, `--${[...nextFlagPath, recordKey].join(".")}`, recordValue);
+            }
+            continue;
+        }
+        appendCLIValue(argv, `--${nextFlagPath.join(".")}`, value);
+    }
+}
+function buildCLIArgv(root, resolved, params) {
+    const visibleParams = filterParams(resolved.command.params, params, "cli");
+    const argv = ["node", root.name, ...resolved.path.map((segment) => formatName(segment, "kebab"))];
+    for (const positional of resolved.command.positional) {
+        const value = valueAtPath(visibleParams, positional.split("."));
+        if (Array.isArray(value)) {
+            argv.push(...value.map((item) => String(item)));
+        }
+        else if (value !== undefined) {
+            argv.push(String(value));
+        }
+    }
+    appendCLIFlags(argv, filterSchemaForScope(resolved.command.params, "cli"), visibleParams, new Set(resolved.command.positional));
+    argv.push("--output", "json", "--debug");
+    return argv;
+}
+function parseCLIValue(entries, reference) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry === undefined) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(entry);
+            if (reference?.ok !== true || isDeepStrictEqual(parsed, reference.value)) {
+                return parsed;
+            }
+            if (typeof parsed === "object" &&
+                parsed !== null &&
+                !Array.isArray(parsed) &&
+                Object.keys(parsed).length === 1 &&
+                Object.prototype.hasOwnProperty.call(parsed, "result") &&
+                isDeepStrictEqual(parsed.result, reference.value)) {
+                return reference.value;
+            }
+            if ((reference.value === null || reference.value === undefined) &&
+                isDeepStrictEqual(parsed, { ok: true })) {
+                return reference.value;
+            }
+            return parsed;
+        }
+        catch {
+            continue;
+        }
+    }
+    return entries.at(-1);
+}
+function parseCLIError(entries) {
+    const message = entries.at(-1) ?? "CLI command failed.";
+    const lines = message.split("\n");
+    const lastLine = lines.at(-1) ?? "";
+    if (lastLine.startsWith("Run ") && lastLine.endsWith(" --help for usage.")) {
+        lines.pop();
+    }
+    return new UserError(lines.join("\n"));
+}
+async function runCLISurface(root, resolved, params, options, reference) {
+    if (!resolved.command.scope.includes("cli")) {
+        return failure(new SurfaceScopeError("cli", resolved.path));
+    }
+    const entries = [];
+    const previousExitCode = process.exitCode;
+    process.exitCode = undefined;
+    try {
+        await runCLI(root, {
+            ...options,
+            argv: buildCLIArgv(root, resolved, params),
+            controls: { debug: true, output: true },
+            outputEmitter: (entry) => entries.push(entry)
+        });
+        if (process.exitCode !== undefined && process.exitCode !== 0) {
+            return failure(parseCLIError(entries));
+        }
+        return success(parseCLIValue(entries, reference));
+    }
+    catch (error) {
+        return failure(error);
+    }
+    finally {
+        process.exitCode = previousExitCode;
+    }
+}
+function errorIdentity(error) {
+    if (error instanceof Error) {
+        return { name: error.constructor.name, message: error.message };
+    }
+    return { name: typeof error, message: String(error) };
+}
+function outcomesAgree(left, right) {
+    if (left.ok !== right.ok) {
+        return false;
+    }
+    if (left.ok) {
+        return isDeepStrictEqual(left.value, right.value);
+    }
+    return isDeepStrictEqual(errorIdentity(left.error), errorIdentity(right.error));
+}
+function describeOutcome(surface, outcome) {
+    if (outcome.ok) {
+        return `${surface}: ok ${JSON.stringify(outcome.value)}`;
+    }
+    const error = errorIdentity(outcome.error);
+    return `${surface}: error ${error.name}: ${error.message}`;
+}
+export async function runParity(root, resolved, params, options) {
+    const sdk = await runSDK(root, resolved, params, options);
+    const mcp = await runMCP(root, resolved, params, options, sdk);
+    const cli = await runCLISurface(root, resolved, params, options, sdk);
+    const agree = outcomesAgree(sdk, mcp) && outcomesAgree(sdk, cli);
+    return {
+        sdk,
+        mcp,
+        cli,
+        agree,
+        ...(agree
+            ? {}
+            : {
+                diff: [
+                    `Surface outcomes differ for "${resolved.path.join(" ")}".`,
+                    describeOutcome("sdk", sdk),
+                    describeOutcome("mcp", mcp),
+                    describeOutcome("cli", cli)
+                ].join("\n")
+            })
+    };
+}

package/dist/testing/render-capture.d.ts

@@ -0,0 +1,6 @@
+import type { RenderPrimitives } from "../index.js";
+export interface RenderCapture {
+    primitives: RenderPrimitives;
+    output(): string;
+}
+export declare function createRenderCapture(): RenderCapture;

package/dist/testing/render-capture.js

@@ -0,0 +1,54 @@
+import { createLogger, light, renderTable, stripAnsi, withOutputFormat } from "toolcraft-design";
+const captureWidth = 80;
+function withoutColors(theme) {
+    return {
+        header: (text) => stripAnsi(theme.header(text)),
+        divider: (text) => stripAnsi(theme.divider(text)),
+        prompt: (text) => stripAnsi(theme.prompt(text)),
+        number: (text) => stripAnsi(theme.number(text)),
+        intro: (text) => stripAnsi(theme.intro(text)),
+        resolvedSymbol: stripAnsi(theme.resolvedSymbol),
+        errorSymbol: stripAnsi(theme.errorSymbol),
+        accent: (text) => stripAnsi(theme.accent(text)),
+        muted: (text) => stripAnsi(theme.muted(text)),
+        success: (text) => stripAnsi(theme.success(text)),
+        warning: (text) => stripAnsi(theme.warning(text)),
+        error: (text) => stripAnsi(theme.error(text)),
+        info: (text) => stripAnsi(theme.info(text)),
+        badge: (text) => stripAnsi(theme.badge(text)),
+        styles: {
+            accent: { ...theme.styles.accent },
+            muted: { ...theme.styles.muted },
+            success: { ...theme.styles.success },
+            warning: { ...theme.styles.warning },
+            error: { ...theme.styles.error },
+            info: { ...theme.styles.info }
+        }
+    };
+}
+function createCaptureTheme() {
+    return {
+        ...withoutColors(light),
+        intro: (text) => ` Poe - ${text} `
+    };
+}
+export function createRenderCapture() {
+    const output = [];
+    const captureTheme = createCaptureTheme();
+    const emit = (message) => {
+        output.push(stripAnsi(message));
+    };
+    return {
+        primitives: {
+            logger: createLogger(emit),
+            renderTable: (options) => withOutputFormat("terminal", () => stripAnsi(renderTable({
+                ...options,
+                theme: withoutColors(options.theme),
+                maxWidth: captureWidth
+            }))),
+            getTheme: () => captureTheme,
+            note: (message, title) => emit(title === undefined ? message : `${title}\n${message}`)
+        },
+        output: () => output.join("\n")
+    };
+}

package/dist/tiny-mcp-client.d.ts

@@ -0,0 +1 @@
+export * from "tiny-mcp-client";

package/dist/tiny-mcp-client.js

@@ -0,0 +1 @@
+export * from "tiny-mcp-client";

package/node_modules/@poe-code/agent-defs/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@poe-code/agent-defs",
   "version": "0.0.1",
-  "license": "MIT",
   "private": true,
+  "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,6 +16,12 @@
     "build": "node ../../scripts/guard-package-dist.mjs && tsc"
   },
   "files": [
-    "dist"
-  ]
+    "dist",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/agent-defs"
+  }
 }

package/node_modules/@poe-code/agent-human-in-loop/README.md

@@ -1,4 +1,4 @@
-## Overview
+# @poe-code/agent-human-in-loop
 
 `@poe-code/agent-human-in-loop` is a UI-only package for asking a human "approve this?" before an agent proceeds. The UI is providerized, sync vs async is the caller's choice because the API returns a Promise you can await immediately or hold and resolve later, and the package is approval-only: decline returns a declined outcome and can optionally capture a reason.
 
@@ -21,7 +21,13 @@ declare function mockProvider(
 - `osascriptProvider({ title?, binary? })` — macOS native dialog via `display dialog`. Mac only.
 - `mockProvider(answer | thunk)` — fixed or scripted answers for tests.
 
-## Env vars
+## Configuration Options
+
+- `osascriptProvider({ title?, binary? })`: optional dialog title and `osascript` binary path.
+- `mockProvider(answer)`: fixed approval result or callback for tests.
+- `requestApproval({ message, approveLabel?, declineLabel?, declineInputPrompt?, provider })`: approval prompt payload and provider.
+
+## Environment Variables
 
 None in v1.
 
@@ -29,6 +35,10 @@ None in v1.
 
 Messages and prompts are passed verbatim through the dialog; the provider escapes `"` and `\` for AppleScript string literals. Do not pass user-supplied AppleScript fragments expecting them to execute.
 
+## Manual QA
+
+Use [QA.md](QA.md) for package-level approval-flow checks after behavior changes.
+
 ## Example
 
 ```ts

package/node_modules/@poe-code/agent-human-in-loop/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@poe-code/agent-human-in-loop",
   "version": "0.0.1",
-  "license": "MIT",
   "private": true,
+  "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,7 +19,13 @@
     "dev": "tsx example.ts"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/agent-human-in-loop"
+  },
   "devDependencies": {}
 }

package/node_modules/@poe-code/agent-mcp-config/README.md

@@ -36,13 +36,13 @@ console.log(supportedAgents);
 
 `ApplyOptions` controls how mutations are applied:
 
-| Option | Type | Description |
-| ------ | ---- | ----------- |
-| `fs` | `FileSystem` | Filesystem adapter from `@poe-code/config-mutations`. |
-| `homeDir` | `string` | Home directory used to resolve `~` in agent config paths. |
-| `platform` | `"darwin" \| "linux" \| "win32"` | Selects platform-specific config paths. |
-| `dryRun` | `boolean` | Computes mutations without writing files. |
-| `observers` | `MutationObservers` | Receives mutation lifecycle events. |
+| Option      | Type                             | Description                                               |
+| ----------- | -------------------------------- | --------------------------------------------------------- |
+| `fs`        | `FileSystem`                     | Filesystem adapter from `@poe-code/config-mutations`.     |
+| `homeDir`   | `string`                         | Home directory used to resolve `~` in agent config paths. |
+| `platform`  | `"darwin" \| "linux" \| "win32"` | Selects platform-specific config paths.                   |
+| `dryRun`    | `boolean`                        | Computes mutations without writing files.                 |
+| `observers` | `MutationObservers`              | Receives mutation lifecycle events.                       |
 
 The package's built-in agent config table declares `configFile`, `configKey`,
 `format`, `shape`, and optional `mcpOutputFormat` per supported agent.

package/node_modules/@poe-code/agent-mcp-config/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@poe-code/agent-mcp-config",
   "version": "0.0.1",
-  "license": "MIT",
   "private": true,
+  "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,8 +16,14 @@
     "build": "node ../../scripts/guard-package-dist.mjs && tsc"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/agent-mcp-config"
+  },
   "dependencies": {
     "yaml": "^2.8.3"
   }

package/node_modules/@poe-code/config-mutations/README.md

@@ -38,14 +38,14 @@ await runMutations(
 
 `MutationContext` controls execution:
 
-| Option | Type | Description |
-| ------ | ---- | ----------- |
-| `fs` | `FileSystem` | Required filesystem adapter. |
-| `homeDir` | `string` | Required home directory for `~` expansion. |
-| `dryRun` | `boolean` | Reports changes without writing them. |
-| `observers` | `MutationObservers` | Receives mutation lifecycle events. |
-| `templates` | `TemplateLoader` | Loads templates referenced by template mutations. |
-| `pathMapper` | `PathMapper` | Redirects target directories for isolated config flows. |
+| Option       | Type                | Description                                             |
+| ------------ | ------------------- | ------------------------------------------------------- |
+| `fs`         | `FileSystem`        | Required filesystem adapter.                            |
+| `homeDir`    | `string`            | Required home directory for `~` expansion.              |
+| `dryRun`     | `boolean`           | Reports changes without writing them.                   |
+| `observers`  | `MutationObservers` | Receives mutation lifecycle events.                     |
+| `templates`  | `TemplateLoader`    | Loads templates referenced by template mutations.       |
+| `pathMapper` | `PathMapper`        | Redirects target directories for isolated config flows. |
 
 Mutation builders also expose per-mutation options such as target path, format,
 label, force removal, backup behavior, template id, and transform callbacks.

package/node_modules/@poe-code/config-mutations/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@poe-code/config-mutations",
   "version": "0.0.1",
-  "license": "MIT",
   "private": true,
+  "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,8 +20,14 @@
     "build": "node ../../scripts/guard-package-dist.mjs && tsc"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/config-mutations"
+  },
   "dependencies": {
     "jsonc-parser": "^3.3.1",
     "smol-toml": "^1.3.0",

package/node_modules/@poe-code/frontmatter/README.md

@@ -26,10 +26,10 @@ Duplicate mapping keys use YAML's last-wins behavior by default, matching the
 legacy frontmatter readers. Callers that need strict YAML mappings can pass
 `{ uniqueKeys: true }` to `parseFrontmatter` or `parseFrontmatterDocument`.
 
-## Environment
+## Environment Variables
 
 This package reads no environment variables.
 
-## Config
+## Configuration Options
 
 This package has no configuration options.

package/node_modules/@poe-code/frontmatter/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@poe-code/frontmatter",
   "version": "0.0.1",
-  "license": "MIT",
   "private": true,
+  "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,8 +18,14 @@
     "test:unit": "cd ../.. && vitest run packages/frontmatter/src"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/frontmatter"
+  },
   "dependencies": {
     "yaml": "^2.8.2"
   }