@kamilio/wire 0.1.0

package/node_modules/toolcraft/dist/sdk.js

@@ -0,0 +1,494 @@
+import { access, lstat, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { ToolcraftBugError, UserError, assertCommandRequirements, resolveCommandSecrets } from "./index.js";
+import { writeErrorReport } from "./error-report.js";
+import { mergeApprovalsGroup } from "./human-in-loop/approvals-commands.js";
+import { invokeWithHumanInLoop } from "./human-in-loop/index.js";
+import { hasMcpProxyGroups, resolveMcpProxies } from "./mcp-proxy.js";
+import { getExpectedNumberDescription, isValidNumberSchemaValue } from "./number-schema.js";
+import { filterSchemaForScope } from "./schema-scope.js";
+import { enableSourceMaps } from "./stack-trim.js";
+import { suggest } from "./suggest.js";
+import { throwValidationErrors } from "./validation-errors.js";
+import { createRuntimeLogger } from "./runtime-logging.js";
+const RESERVED_SERVICE_NAMES = new Set([
+    "params",
+    "secrets",
+    "fetch",
+    "fs",
+    "env",
+    "diagnostics",
+    "progress",
+    "runtimeOptions",
+    "root"
+]);
+const RESERVED_SERVICE_NAMES_MESSAGE = "Available reserved names: params, secrets, fetch, fs, env, diagnostics, progress, runtimeOptions, root.";
+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 formatSegment(segment) {
+    return splitWords(segment)
+        .map((word, index) => (index === 0 ? word : `${word[0]?.toUpperCase() ?? ""}${word.slice(1)}`))
+        .join("");
+}
+function unwrapOptional(schema) {
+    if (schema.kind === "optional") {
+        return unwrapOptional(schema.inner);
+    }
+    return schema;
+}
+function isOptional(schema) {
+    return schema.kind === "optional";
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createFs() {
+    return {
+        readFile: async (path, encoding = "utf8") => readFile(path, { encoding }),
+        writeFile: async (path, contents, options) => {
+            await writeFile(path, contents, options);
+        },
+        exists: async (path) => {
+            try {
+                await access(path);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        lstat: async (path) => lstat(path),
+        rename: async (fromPath, toPath) => rename(fromPath, toPath),
+        unlink: async (path) => unlink(path)
+    };
+}
+function createEnv(values = process.env) {
+    return {
+        get(key) {
+            return values[key];
+        }
+    };
+}
+function validateServices(services) {
+    for (const name of Object.keys(services)) {
+        if (RESERVED_SERVICE_NAMES.has(name)) {
+            throw new Error(`Service name "${name}" is reserved. Choose a different name. ${RESERVED_SERVICE_NAMES_MESSAGE}`);
+        }
+    }
+}
+function formatAvailableList(values) {
+    return `Available: ${[...values].sort().join(", ")}.`;
+}
+function formatEnumError(value, schema, label) {
+    const suggestionLine = typeof value === "string"
+        ? formatEnumSuggestionLine(value, schema.values.map((candidate) => String(candidate)))
+        : " ";
+    return `Invalid value for "${label}".${suggestionLine}Expected one of: ${schema.values.map((candidate) => String(candidate)).join(", ")}, got ${describeReceived(value)}.`;
+}
+function formatEnumSuggestionLine(value, values) {
+    const suggestions = suggest(value, values);
+    return suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?\n` : " ";
+}
+function describeReceived(value) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "missing";
+    if (Array.isArray(value))
+        return `array(${value.length})`;
+    if (typeof value === "object")
+        return "object";
+    if (typeof value === "string") {
+        const s = value.length > 40 ? `${value.slice(0, 40)}…` : value;
+        return `${JSON.stringify(s)}`;
+    }
+    return JSON.stringify(value);
+}
+function validateSchemaValue(schema, value, label, errors) {
+    const unwrappedSchema = unwrapOptional(schema);
+    if (value === null && unwrappedSchema.nullable === true) {
+        return null;
+    }
+    switch (unwrappedSchema.kind) {
+        case "string":
+            if (typeof value !== "string") {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected a string, got ${describeReceived(value)}.`
+                });
+            }
+            else {
+                validateStringConstraints(unwrappedSchema, value, label, errors);
+            }
+            return value;
+        case "number":
+            if (!isValidNumberSchemaValue(value, unwrappedSchema)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected ${getExpectedNumberDescription(unwrappedSchema)}, got ${describeReceived(value)}.`
+                });
+            }
+            return value;
+        case "boolean":
+            if (typeof value !== "boolean") {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected a boolean, got ${describeReceived(value)}.`
+                });
+            }
+            return value;
+        case "enum":
+            if (!unwrappedSchema.values.includes(value)) {
+                errors.push({ path: label, message: formatEnumError(value, unwrappedSchema, label) });
+            }
+            return value;
+        case "array":
+            if (!Array.isArray(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an array, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            validateArrayConstraints(unwrappedSchema, value, label, errors);
+            return value.map((item, index) => validateSchemaValue(unwrappedSchema.item, item, `${label}[${index}]`, errors));
+        case "object":
+            return validateObjectSchema(unwrappedSchema, value, label, errors);
+        case "json":
+            return value;
+        case "record": {
+            if (!isPlainObject(value)) {
+                errors.push({
+                    path: label,
+                    message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+                });
+                return value;
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+                key,
+                validateSchemaValue(unwrappedSchema.value, item, `${label}.${key}`, errors)
+            ]));
+        }
+        case "oneOf": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const discriminator = value[unwrappedSchema.discriminator];
+            const branch = typeof discriminator === "string" ? unwrappedSchema.branches[discriminator] : undefined;
+            if (branch === undefined) {
+                return value;
+            }
+            const { [unwrappedSchema.discriminator]: ignoredDiscriminator, ...branchValue } = value;
+            void ignoredDiscriminator;
+            return {
+                [unwrappedSchema.discriminator]: discriminator,
+                ...validateObjectSchema(branch, branchValue, label, errors)
+            };
+        }
+        case "union": {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const branch = unwrappedSchema.branches.find((candidate) => Object.keys(candidate.shape).every((key) => candidate.shape[key]?.kind === "optional" ||
+                Object.prototype.hasOwnProperty.call(value, formatSegment(key))));
+            return branch === undefined ? value : validateObjectSchema(branch, value, label, errors);
+        }
+    }
+}
+function validateStringConstraints(schema, value, label, errors) {
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected a string with length at least ${schema.minLength}, got string with length ${value.length}.`
+        });
+    }
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected a string with length at most ${schema.maxLength}, got string with length ${value.length}.`
+        });
+    }
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}": "${value}" does not match pattern "${schema.pattern}".`
+        });
+    }
+}
+function validateArrayConstraints(schema, value, label, errors) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an array with at least ${schema.minItems} items, got array(${value.length}).`
+        });
+    }
+    if (schema.maxItems !== undefined && value.length > schema.maxItems) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an array with at most ${schema.maxItems} items, got array(${value.length}).`
+        });
+    }
+}
+function validateObjectSchema(schema, value, label, errors) {
+    if (!isPlainObject(value)) {
+        errors.push({
+            path: label,
+            message: `Invalid value for "${label}". Expected an object, got ${describeReceived(value)}.`
+        });
+        return {};
+    }
+    const result = {};
+    const expectedKeys = new Map();
+    for (const [key, childSchema] of Object.entries(schema.shape)) {
+        expectedKeys.set(formatSegment(key), [key, childSchema]);
+    }
+    for (const key of Object.keys(value)) {
+        if (!expectedKeys.has(key)) {
+            if (schema.additionalProperties === true) {
+                Object.defineProperty(result, key, {
+                    value: value[key],
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+                continue;
+            }
+            const fieldLabel = label.length === 0 ? key : `${label}.${key}`;
+            errors.push({
+                path: fieldLabel,
+                message: `Unexpected parameter "${fieldLabel}". ${formatAvailableList([...expectedKeys.keys()].map((expectedKey) => label.length === 0 ? expectedKey : `${label}.${expectedKey}`))}`
+            });
+        }
+    }
+    for (const [inputKey, [outputKey, rawChildSchema]] of expectedKeys.entries()) {
+        const childSchema = unwrapOptional(rawChildSchema);
+        const hasValue = Object.prototype.hasOwnProperty.call(value, inputKey);
+        const fieldLabel = label.length === 0 ? inputKey : `${label}.${inputKey}`;
+        if (!hasValue) {
+            if (childSchema.default !== undefined) {
+                Object.defineProperty(result, outputKey, {
+                    value: childSchema.default,
+                    enumerable: true,
+                    configurable: true,
+                    writable: true
+                });
+                continue;
+            }
+            if (isOptional(rawChildSchema)) {
+                continue;
+            }
+            errors.push({ path: fieldLabel, message: `Missing required parameter "${fieldLabel}".` });
+            continue;
+        }
+        Object.defineProperty(result, outputKey, {
+            value: validateSchemaValue(rawChildSchema, value[inputKey], fieldLabel, errors),
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    return result;
+}
+function validateUniqueSDKParameterMembers(schema) {
+    const sourceKeysByMember = new Map();
+    for (const [key, rawChildSchema] of Object.entries(schema.shape)) {
+        const member = formatSegment(key);
+        const existingKey = sourceKeysByMember.get(member);
+        if (existingKey !== undefined) {
+            throw new UserError(`Parameters "${existingKey}" and "${key}" use conflicting SDK member "${member}".`);
+        }
+        sourceKeysByMember.set(member, key);
+        const childSchema = unwrapOptional(rawChildSchema);
+        if (childSchema.kind === "object") {
+            validateUniqueSDKParameterMembers(childSchema);
+        }
+    }
+}
+function validateSDKArguments(schema, argumentsValue) {
+    const errors = [];
+    const result = validateObjectSchema(schema, argumentsValue ?? {}, "", errors);
+    throwValidationErrors(errors);
+    return result;
+}
+function defineMember(target, key, value) {
+    if (Object.prototype.hasOwnProperty.call(target, key)) {
+        throw new Error(`Duplicate SDK member "${key}".`);
+    }
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: false,
+        writable: false
+    });
+}
+export function createSDK(root, options = {}) {
+    enableSourceMaps();
+    const mergedRoot = options.approvals === true ? mergeApprovalsGroup(root) : root;
+    if (!hasMcpProxyGroups(mergedRoot)) {
+        return createResolvedSDK(mergedRoot, options);
+    }
+    return createDeferredSDK(mergedRoot, options);
+}
+function createResolvedSDK(root, options = {}) {
+    const services = options.services ?? {};
+    const runtimeOptions = options.humanInLoop ?? {};
+    const runtimeFetch = options.fetch ?? globalThis.fetch;
+    const diagnostics = createRuntimeLogger({
+        level: options.logLevel,
+        logger: options.logger
+    });
+    void options.casing;
+    validateServices(services);
+    function build(node, path) {
+        if (node.kind === "command") {
+            const sdkParamsSchema = filterSchemaForScope(node.params, "sdk");
+            if (sdkParamsSchema?.kind === "object") {
+                validateUniqueSDKParameterMembers(sdkParamsSchema);
+            }
+            return async (params) => {
+                const commandPath = [...path, node.name].join(".");
+                let secrets;
+                let validatedParams;
+                try {
+                    secrets = resolveCommandSecrets(node);
+                    const baseContext = {
+                        ...services,
+                        runtimeOptions,
+                        root,
+                        secrets,
+                        fetch: runtimeFetch,
+                        fs: createFs(),
+                        env: createEnv(),
+                        diagnostics,
+                        progress(message) {
+                            diagnostics.emit({ level: "info", message, category: "progress" });
+                        }
+                    };
+                    await assertCommandRequirements(node, { ...baseContext, params: undefined }, {
+                        apiVersion: options.apiVersion
+                    });
+                    const paramsSchema = filterSchemaForScope(node.params, "sdk");
+                    if (paramsSchema === undefined || paramsSchema.kind !== "object") {
+                        throw new ToolcraftBugError(`command "${node.name}" must define an object params schema for SDK.`);
+                    }
+                    validatedParams = validateSDKArguments(paramsSchema, params);
+                    return await invokeWithHumanInLoop(node, {
+                        ...baseContext,
+                        params: validatedParams
+                    }, runtimeOptions, commandPath);
+                }
+                catch (error) {
+                    await writeErrorReport({
+                        command: node,
+                        commandPath,
+                        env: process.env,
+                        error,
+                        errorReports: options.errorReports,
+                        params: validatedParams,
+                        projectRoot: options.projectRoot,
+                        secrets
+                    });
+                    throw error;
+                }
+            };
+        }
+        const output = {};
+        const sourceNamesByMember = new Map();
+        const nextPath = node === root ? path : [...path, node.name];
+        for (const child of node.children) {
+            let childValue;
+            if (child.kind === "command") {
+                if (!child.scope.includes("sdk")) {
+                    continue;
+                }
+                childValue = build(child, nextPath);
+            }
+            else {
+                childValue = build(child, nextPath);
+                if (!isPlainObject(childValue) || Object.keys(childValue).length === 0) {
+                    continue;
+                }
+            }
+            const member = formatSegment(child.name);
+            if (member === "then") {
+                throw new UserError(`SDK member "${child.name}" uses reserved member "then".`);
+            }
+            const existingName = sourceNamesByMember.get(member);
+            if (existingName !== undefined) {
+                throw new UserError(`SDK members "${existingName}" and "${child.name}" use conflicting member "${member}".`);
+            }
+            sourceNamesByMember.set(member, child.name);
+            defineMember(output, member, childValue);
+        }
+        return output;
+    }
+    return build(root, []);
+}
+function createDeferredSDK(root, options) {
+    let sdkPromise;
+    const resolveSDK = () => {
+        sdkPromise ??= (async () => {
+            await resolveMcpProxies(root, { projectRoot: options.projectRoot });
+            return createResolvedSDK(root, options);
+        })();
+        return sdkPromise;
+    };
+    const resolvePath = async (path) => {
+        let current = await resolveSDK();
+        for (const segment of path) {
+            if (typeof segment !== "string" && typeof segment !== "number") {
+                return undefined;
+            }
+            current = current[segment];
+        }
+        return current;
+    };
+    const createPathProxy = (path) => new Proxy(() => undefined, {
+        apply(_target, _thisArg, argumentsList) {
+            return resolvePath(path).then((value) => {
+                if (typeof value !== "function") {
+                    throw new TypeError(`SDK member "${path.map(String).join(".")}" is not callable.`);
+                }
+                return value(...argumentsList);
+            });
+        },
+        get(_target, property) {
+            if (property === "then") {
+                return path.length === 0 ? resolveSDK().then.bind(resolveSDK()) : undefined;
+            }
+            return createPathProxy([...path, property]);
+        }
+    });
+    return createPathProxy([]);
+}

package/node_modules/toolcraft/dist/source-snippet.d.ts

@@ -0,0 +1,8 @@
+export interface SourceSnippetOptions {
+    source: string;
+    line: number;
+    column?: number;
+    context?: number;
+    filePath?: string;
+}
+export declare function renderSourceSnippet(opts: SourceSnippetOptions): string;

package/node_modules/toolcraft/dist/source-snippet.js

@@ -0,0 +1,42 @@
+import { text } from "toolcraft-design";
+export function renderSourceSnippet(opts) {
+    const lines = opts.source.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+    const line = clampInteger(opts.line, 1, Math.max(lines.length, 1));
+    const context = Math.max(0, Math.floor(opts.context ?? 2));
+    const startLine = Math.max(1, line - context);
+    const endLine = Math.min(lines.length, line + context);
+    const gutterWidth = String(endLine).length;
+    const output = [];
+    if (opts.filePath !== undefined) {
+        output.push(muted(`--> ${opts.filePath}:${line}${opts.column === undefined ? "" : `:${Math.max(1, opts.column)}`}`));
+    }
+    output.push(renderDivider(gutterWidth));
+    for (let currentLine = startLine; currentLine <= endLine; currentLine += 1) {
+        const sourceLine = lines[currentLine - 1] ?? "";
+        output.push(`${muted(String(currentLine).padStart(gutterWidth, " "))} | ${sourceLine}`);
+        if (currentLine === line && opts.column !== undefined) {
+            const column = Math.max(1, Math.floor(opts.column));
+            output.push(`${muted(" ".repeat(gutterWidth))} | ${" ".repeat(column - 1)}${error("^")}`);
+        }
+    }
+    output.push(renderDivider(gutterWidth));
+    return output.join("\n");
+}
+function renderDivider(gutterWidth) {
+    return `${muted(" ".repeat(gutterWidth))} |`;
+}
+function clampInteger(value, min, max) {
+    if (!Number.isFinite(value)) {
+        return min;
+    }
+    return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function muted(value) {
+    return shouldStyleStderr() ? text.muted(value) : value;
+}
+function error(value) {
+    return shouldStyleStderr() ? text.error(value) : value;
+}
+function shouldStyleStderr() {
+    return process.stderr.isTTY === true;
+}

package/node_modules/toolcraft/dist/stack-trim.d.ts

@@ -0,0 +1,4 @@
+export type DebugStackMode = "trim" | "raw";
+export declare function enableSourceMaps(): void;
+export declare function formatDebugStack(stack: string, mode: DebugStackMode): string;
+export declare function trimStack(stack: string): string;

package/node_modules/toolcraft/dist/stack-trim.js

@@ -0,0 +1,70 @@
+const HIDDEN_FRAME_SUMMARY_PREFIX = "    … (";
+const HIDDEN_FRAME_SUMMARY_SUFFIX = " hidden — pass --debug=raw to show)";
+export function enableSourceMaps() {
+    process.setSourceMapsEnabled?.(true);
+}
+export function formatDebugStack(stack, mode) {
+    return mode === "raw" ? stack : trimStack(stack);
+}
+export function trimStack(stack) {
+    const sections = splitStackSections(stack);
+    const trimmed = sections.map((section) => trimStackSection(section));
+    const hiddenFrameCount = trimmed.reduce((count, section) => count + section.hiddenFrameCount, 0);
+    if (hiddenFrameCount === 0) {
+        return stack;
+    }
+    return trimmed.flatMap((section) => section.lines).join("\n");
+}
+function splitStackSections(stack) {
+    const lines = stack.split("\n");
+    const firstLine = lines[0];
+    if (firstLine === undefined) {
+        return [];
+    }
+    const sections = [{ header: firstLine, lines: [] }];
+    for (const line of lines.slice(1)) {
+        if (isCauseHeader(line)) {
+            sections.push({ header: line, lines: [] });
+            continue;
+        }
+        sections[sections.length - 1]?.lines.push(line);
+    }
+    return sections;
+}
+function trimStackSection(section) {
+    const userFrames = [];
+    const skippedFrames = [];
+    for (const line of section.lines) {
+        if (isFrameworkOrRuntimeFrame(line)) {
+            skippedFrames.push(line);
+            continue;
+        }
+        userFrames.push(line);
+    }
+    if (skippedFrames.length === 0) {
+        return {
+            lines: [section.header, ...section.lines],
+            hiddenFrameCount: 0
+        };
+    }
+    return {
+        lines: [section.header, ...userFrames, formatHiddenFrameSummary(skippedFrames.length)],
+        hiddenFrameCount: skippedFrames.length
+    };
+}
+function isCauseHeader(line) {
+    return line.trimStart().startsWith("[cause]:");
+}
+function isFrameworkOrRuntimeFrame(line) {
+    const normalized = line.replaceAll("\\", "/");
+    return (normalized.includes("node_modules/toolcraft/") ||
+        normalized.includes("node_modules/toolcraft-openapi/") ||
+        normalized.includes("node_modules/toolcraft-schema/") ||
+        normalized.includes("node_modules/commander/") ||
+        normalized.includes("node:internal/") ||
+        normalized.includes("/packages/toolcraft/src/"));
+}
+function formatHiddenFrameSummary(count) {
+    const plural = count === 1 ? "" : "s";
+    return `${HIDDEN_FRAME_SUMMARY_PREFIX}${count} framework / runtime frame${plural}${HIDDEN_FRAME_SUMMARY_SUFFIX}`;
+}

package/node_modules/toolcraft/dist/suggest.d.ts

@@ -0,0 +1,4 @@
+export declare function suggest(input: string, candidates: readonly string[], opts?: {
+    max?: number;
+    threshold?: number;
+}): string[];

package/node_modules/toolcraft/dist/suggest.js

@@ -0,0 +1,46 @@
+export function suggest(input, candidates, opts = {}) {
+    if (input.length === 0) {
+        return [];
+    }
+    const max = opts.max ?? 3;
+    const threshold = opts.threshold ?? Math.max(1, Math.floor(input.length / 4));
+    return candidates
+        .map((candidate) => ({
+        candidate,
+        distance: damerauLevenshtein(input, candidate)
+    }))
+        .filter(({ distance }) => distance <= threshold)
+        .sort((left, right) => {
+        if (left.distance !== right.distance) {
+            return left.distance - right.distance;
+        }
+        return left.candidate.localeCompare(right.candidate);
+    })
+        .slice(0, max)
+        .map(({ candidate }) => candidate);
+}
+function damerauLevenshtein(left, right) {
+    const distances = Array.from({ length: left.length + 1 }, () => Array.from({ length: right.length + 1 }, () => 0));
+    for (let row = 0; row <= left.length; row += 1) {
+        distances[row][0] = row;
+    }
+    for (let column = 0; column <= right.length; column += 1) {
+        distances[0][column] = column;
+    }
+    for (let row = 1; row <= left.length; row += 1) {
+        for (let column = 1; column <= right.length; column += 1) {
+            const substitutionCost = left[row - 1] === right[column - 1] ? 0 : 1;
+            const deletion = distances[row - 1][column] + 1;
+            const insertion = distances[row][column - 1] + 1;
+            const substitution = distances[row - 1][column - 1] + substitutionCost;
+            distances[row][column] = Math.min(deletion, insertion, substitution);
+            if (row > 1 &&
+                column > 1 &&
+                left[row - 1] === right[column - 2] &&
+                left[row - 2] === right[column - 1]) {
+                distances[row][column] = Math.min(distances[row][column], distances[row - 2][column - 2] + 1);
+            }
+        }
+    }
+    return distances[left.length][right.length];
+}

package/node_modules/toolcraft/dist/user-error.d.ts

@@ -0,0 +1,6 @@
+export declare class UserError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare class ToolcraftBugError extends Error {
+    constructor(message: string);
+}