@vint.tri/report_gen_mcp 1.1.0 → 1.1.2

package/temp_npm_package/node_modules/zod-to-json-schema/dist/cjs/zodToJsonSchema.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.zodToJsonSchema = void 0;
-const parseDef_js_1 = require("./parseDef.js");
-const Refs_js_1 = require("./Refs.js");
-const any_js_1 = require("./parsers/any.js");
-const zodToJsonSchema = (schema, options) => {
-    const refs = (0, Refs_js_1.getRefs)(options);
-    let definitions = typeof options === "object" && options.definitions
-        ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
-            ...acc,
-            [name]: (0, parseDef_js_1.parseDef)(schema._def, {
-                ...refs,
-                currentPath: [...refs.basePath, refs.definitionPath, name],
-            }, true) ?? (0, any_js_1.parseAnyDef)(refs),
-        }), {})
-        : undefined;
-    const name = typeof options === "string"
-        ? options
-        : options?.nameStrategy === "title"
-            ? undefined
-            : options?.name;
-    const main = (0, parseDef_js_1.parseDef)(schema._def, name === undefined
-        ? refs
-        : {
-            ...refs,
-            currentPath: [...refs.basePath, refs.definitionPath, name],
-        }, false) ?? (0, any_js_1.parseAnyDef)(refs);
-    const title = typeof options === "object" &&
-        options.name !== undefined &&
-        options.nameStrategy === "title"
-        ? options.name
-        : undefined;
-    if (title !== undefined) {
-        main.title = title;
-    }
-    if (refs.flags.hasReferencedOpenAiAnyType) {
-        if (!definitions) {
-            definitions = {};
-        }
-        if (!definitions[refs.openAiAnyTypeName]) {
-            definitions[refs.openAiAnyTypeName] = {
-                // Skipping "object" as no properties can be defined and additionalProperties must be "false"
-                type: ["string", "number", "integer", "boolean", "array", "null"],
-                items: {
-                    $ref: refs.$refStrategy === "relative"
-                        ? "1"
-                        : [
-                            ...refs.basePath,
-                            refs.definitionPath,
-                            refs.openAiAnyTypeName,
-                        ].join("/"),
-                },
-            };
-        }
-    }
-    const combined = name === undefined
-        ? definitions
-            ? {
-                ...main,
-                [refs.definitionPath]: definitions,
-            }
-            : main
-        : {
-            $ref: [
-                ...(refs.$refStrategy === "relative" ? [] : refs.basePath),
-                refs.definitionPath,
-                name,
-            ].join("/"),
-            [refs.definitionPath]: {
-                ...definitions,
-                [name]: main,
-            },
-        };
-    if (refs.target === "jsonSchema7") {
-        combined.$schema = "http://json-schema.org/draft-07/schema#";
-    }
-    else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
-        combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
-    }
-    if (refs.target === "openAi" &&
-        ("anyOf" in combined ||
-            "oneOf" in combined ||
-            "allOf" in combined ||
-            ("type" in combined && Array.isArray(combined.type)))) {
-        console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
-    }
-    return combined;
-};
-exports.zodToJsonSchema = zodToJsonSchema;

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/Options.js

@@ -1,46 +0,0 @@
-export const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
-export const jsonDescription = (jsonSchema, def) => {
-    if (def.description) {
-        try {
-            return {
-                ...jsonSchema,
-                ...JSON.parse(def.description),
-            };
-        }
-        catch { }
-    }
-    return jsonSchema;
-};
-export const defaultOptions = {
-    name: undefined,
-    $refStrategy: "root",
-    basePath: ["#"],
-    effectStrategy: "input",
-    pipeStrategy: "all",
-    dateStrategy: "format:date-time",
-    mapStrategy: "entries",
-    removeAdditionalStrategy: "passthrough",
-    allowedAdditionalProperties: true,
-    rejectedAdditionalProperties: false,
-    definitionPath: "definitions",
-    target: "jsonSchema7",
-    strictUnions: false,
-    definitions: {},
-    errorMessages: false,
-    markdownDescription: false,
-    patternStrategy: "escape",
-    applyRegexFlags: false,
-    emailStrategy: "format:email",
-    base64Strategy: "contentEncoding:base64",
-    nameStrategy: "ref",
-    openAiAnyTypeName: "OpenAiAnyType"
-};
-export const getDefaultOptions = (options) => (typeof options === "string"
-    ? {
-        ...defaultOptions,
-        name: options,
-    }
-    : {
-        ...defaultOptions,
-        ...options,
-    });

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/Refs.js

@@ -1,22 +0,0 @@
-import { getDefaultOptions } from "./Options.js";
-export const getRefs = (options) => {
-    const _options = getDefaultOptions(options);
-    const currentPath = _options.name !== undefined
-        ? [..._options.basePath, _options.definitionPath, _options.name]
-        : _options.basePath;
-    return {
-        ..._options,
-        flags: { hasReferencedOpenAiAnyType: false },
-        currentPath: currentPath,
-        propertyPath: undefined,
-        seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
-            def._def,
-            {
-                def: def._def,
-                path: [..._options.basePath, _options.definitionPath, name],
-                // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-                jsonSchema: undefined,
-            },
-        ])),
-    };
-};

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/errorMessages.js

@@ -1,14 +0,0 @@
-export function addErrorMessage(res, key, errorMessage, refs) {
-    if (!refs?.errorMessages)
-        return;
-    if (errorMessage) {
-        res.errorMessage = {
-            ...res.errorMessage,
-            [key]: errorMessage,
-        };
-    }
-}
-export function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
-    res[key] = value;
-    addErrorMessage(res, key, errorMessage, refs);
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/getRelativePath.js

@@ -1,8 +0,0 @@
-export const getRelativePath = (pathA, pathB) => {
-    let i = 0;
-    for (; i < pathA.length && i < pathB.length; i++) {
-        if (pathA[i] !== pathB[i])
-            break;
-    }
-    return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
-};

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/index.js

@@ -1,40 +0,0 @@
-export * from "./Options.js";
-export * from "./Refs.js";
-export * from "./errorMessages.js";
-export * from "./getRelativePath.js";
-export * from "./parseDef.js";
-export * from "./parseTypes.js";
-export * from "./parsers/any.js";
-export * from "./parsers/array.js";
-export * from "./parsers/bigint.js";
-export * from "./parsers/boolean.js";
-export * from "./parsers/branded.js";
-export * from "./parsers/catch.js";
-export * from "./parsers/date.js";
-export * from "./parsers/default.js";
-export * from "./parsers/effects.js";
-export * from "./parsers/enum.js";
-export * from "./parsers/intersection.js";
-export * from "./parsers/literal.js";
-export * from "./parsers/map.js";
-export * from "./parsers/nativeEnum.js";
-export * from "./parsers/never.js";
-export * from "./parsers/null.js";
-export * from "./parsers/nullable.js";
-export * from "./parsers/number.js";
-export * from "./parsers/object.js";
-export * from "./parsers/optional.js";
-export * from "./parsers/pipeline.js";
-export * from "./parsers/promise.js";
-export * from "./parsers/readonly.js";
-export * from "./parsers/record.js";
-export * from "./parsers/set.js";
-export * from "./parsers/string.js";
-export * from "./parsers/tuple.js";
-export * from "./parsers/undefined.js";
-export * from "./parsers/union.js";
-export * from "./parsers/unknown.js";
-export * from "./selectParser.js";
-export * from "./zodToJsonSchema.js";
-import { zodToJsonSchema } from "./zodToJsonSchema.js";
-export default zodToJsonSchema;

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/package.json

@@ -1 +0,0 @@
-{"type":"module","main":"index.js"}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parseDef.js

@@ -1,62 +0,0 @@
-import { ignoreOverride } from "./Options.js";
-import { selectParser } from "./selectParser.js";
-import { getRelativePath } from "./getRelativePath.js";
-import { parseAnyDef } from "./parsers/any.js";
-export function parseDef(def, refs, forceResolution = false) {
-    const seenItem = refs.seen.get(def);
-    if (refs.override) {
-        const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
-        if (overrideResult !== ignoreOverride) {
-            return overrideResult;
-        }
-    }
-    if (seenItem && !forceResolution) {
-        const seenSchema = get$ref(seenItem, refs);
-        if (seenSchema !== undefined) {
-            return seenSchema;
-        }
-    }
-    const newItem = { def, path: refs.currentPath, jsonSchema: undefined };
-    refs.seen.set(def, newItem);
-    const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
-    // If the return was a function, then the inner definition needs to be extracted before a call to parseDef (recursive)
-    const jsonSchema = typeof jsonSchemaOrGetter === "function"
-        ? parseDef(jsonSchemaOrGetter(), refs)
-        : jsonSchemaOrGetter;
-    if (jsonSchema) {
-        addMeta(def, refs, jsonSchema);
-    }
-    if (refs.postProcess) {
-        const postProcessResult = refs.postProcess(jsonSchema, def, refs);
-        newItem.jsonSchema = jsonSchema;
-        return postProcessResult;
-    }
-    newItem.jsonSchema = jsonSchema;
-    return jsonSchema;
-}
-const get$ref = (item, refs) => {
-    switch (refs.$refStrategy) {
-        case "root":
-            return { $ref: item.path.join("/") };
-        case "relative":
-            return { $ref: getRelativePath(refs.currentPath, item.path) };
-        case "none":
-        case "seen": {
-            if (item.path.length < refs.currentPath.length &&
-                item.path.every((value, index) => refs.currentPath[index] === value)) {
-                console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
-                return parseAnyDef(refs);
-            }
-            return refs.$refStrategy === "seen" ? parseAnyDef(refs) : undefined;
-        }
-    }
-};
-const addMeta = (def, refs, jsonSchema) => {
-    if (def.description) {
-        jsonSchema.description = def.description;
-        if (refs.markdownDescription) {
-            jsonSchema.markdownDescription = def.description;
-        }
-    }
-    return jsonSchema;
-};

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parseTypes.js

@@ -1 +0,0 @@
-export {};

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/any.js

@@ -1,17 +0,0 @@
-import { getRelativePath } from "../getRelativePath.js";
-export function parseAnyDef(refs) {
-    if (refs.target !== "openAi") {
-        return {};
-    }
-    const anyDefinitionPath = [
-        ...refs.basePath,
-        refs.definitionPath,
-        refs.openAiAnyTypeName,
-    ];
-    refs.flags.hasReferencedOpenAiAnyType = true;
-    return {
-        $ref: refs.$refStrategy === "relative"
-            ? getRelativePath(anyDefinitionPath, refs.currentPath)
-            : anyDefinitionPath.join("/"),
-    };
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/array.js

@@ -1,26 +0,0 @@
-import { ZodFirstPartyTypeKind } from "zod";
-import { setResponseValueAndErrors } from "../errorMessages.js";
-import { parseDef } from "../parseDef.js";
-export function parseArrayDef(def, refs) {
-    const res = {
-        type: "array",
-    };
-    if (def.type?._def &&
-        def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
-        res.items = parseDef(def.type._def, {
-            ...refs,
-            currentPath: [...refs.currentPath, "items"],
-        });
-    }
-    if (def.minLength) {
-        setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
-    }
-    if (def.maxLength) {
-        setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
-    }
-    if (def.exactLength) {
-        setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
-        setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
-    }
-    return res;
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js

@@ -1,49 +0,0 @@
-import { setResponseValueAndErrors } from "../errorMessages.js";
-export function parseBigintDef(def, refs) {
-    const res = {
-        type: "integer",
-        format: "int64",
-    };
-    if (!def.checks)
-        return res;
-    for (const check of def.checks) {
-        switch (check.kind) {
-            case "min":
-                if (refs.target === "jsonSchema7") {
-                    if (check.inclusive) {
-                        setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-                    }
-                    else {
-                        setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
-                    }
-                }
-                else {
-                    if (!check.inclusive) {
-                        res.exclusiveMinimum = true;
-                    }
-                    setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-                }
-                break;
-            case "max":
-                if (refs.target === "jsonSchema7") {
-                    if (check.inclusive) {
-                        setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-                    }
-                    else {
-                        setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
-                    }
-                }
-                else {
-                    if (!check.inclusive) {
-                        res.exclusiveMaximum = true;
-                    }
-                    setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-                }
-                break;
-            case "multipleOf":
-                setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
-                break;
-        }
-    }
-    return res;
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js

@@ -1,5 +0,0 @@
-export function parseBooleanDef() {
-    return {
-        type: "boolean",
-    };
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js

@@ -1,4 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export function parseBrandedDef(_def, refs) {
-    return parseDef(_def.type._def, refs);
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js

@@ -1,4 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export const parseCatchDef = (def, refs) => {
-    return parseDef(def.innerType._def, refs);
-};

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/date.js

@@ -1,46 +0,0 @@
-import { setResponseValueAndErrors } from "../errorMessages.js";
-export function parseDateDef(def, refs, overrideDateStrategy) {
-    const strategy = overrideDateStrategy ?? refs.dateStrategy;
-    if (Array.isArray(strategy)) {
-        return {
-            anyOf: strategy.map((item, i) => parseDateDef(def, refs, item)),
-        };
-    }
-    switch (strategy) {
-        case "string":
-        case "format:date-time":
-            return {
-                type: "string",
-                format: "date-time",
-            };
-        case "format:date":
-            return {
-                type: "string",
-                format: "date",
-            };
-        case "integer":
-            return integerDateParser(def, refs);
-    }
-}
-const integerDateParser = (def, refs) => {
-    const res = {
-        type: "integer",
-        format: "unix-time",
-    };
-    if (refs.target === "openApi3") {
-        return res;
-    }
-    for (const check of def.checks) {
-        switch (check.kind) {
-            case "min":
-                setResponseValueAndErrors(res, "minimum", check.value, // This is in milliseconds
-                check.message, refs);
-                break;
-            case "max":
-                setResponseValueAndErrors(res, "maximum", check.value, // This is in milliseconds
-                check.message, refs);
-                break;
-        }
-    }
-    return res;
-};

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/default.js

@@ -1,7 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export function parseDefaultDef(_def, refs) {
-    return {
-        ...parseDef(_def.innerType._def, refs),
-        default: _def.defaultValue(),
-    };
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js

@@ -1,7 +0,0 @@
-import { parseDef } from "../parseDef.js";
-import { parseAnyDef } from "./any.js";
-export function parseEffectsDef(_def, refs) {
-    return refs.effectStrategy === "input"
-        ? parseDef(_def.schema._def, refs)
-        : parseAnyDef(refs);
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js

@@ -1,6 +0,0 @@
-export function parseEnumDef(def) {
-    return {
-        type: "string",
-        enum: Array.from(def.values),
-    };
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js

@@ -1,52 +0,0 @@
-import { parseDef } from "../parseDef.js";
-const isJsonSchema7AllOfType = (type) => {
-    if ("type" in type && type.type === "string")
-        return false;
-    return "allOf" in type;
-};
-export function parseIntersectionDef(def, refs) {
-    const allOf = [
-        parseDef(def.left._def, {
-            ...refs,
-            currentPath: [...refs.currentPath, "allOf", "0"],
-        }),
-        parseDef(def.right._def, {
-            ...refs,
-            currentPath: [...refs.currentPath, "allOf", "1"],
-        }),
-    ].filter((x) => !!x);
-    let unevaluatedProperties = refs.target === "jsonSchema2019-09"
-        ? { unevaluatedProperties: false }
-        : undefined;
-    const mergedAllOf = [];
-    // If either of the schemas is an allOf, merge them into a single allOf
-    allOf.forEach((schema) => {
-        if (isJsonSchema7AllOfType(schema)) {
-            mergedAllOf.push(...schema.allOf);
-            if (schema.unevaluatedProperties === undefined) {
-                // If one of the schemas has no unevaluatedProperties set,
-                // the merged schema should also have no unevaluatedProperties set
-                unevaluatedProperties = undefined;
-            }
-        }
-        else {
-            let nestedSchema = schema;
-            if ("additionalProperties" in schema &&
-                schema.additionalProperties === false) {
-                const { additionalProperties, ...rest } = schema;
-                nestedSchema = rest;
-            }
-            else {
-                // As soon as one of the schemas has additionalProperties set not to false, we allow unevaluatedProperties
-                unevaluatedProperties = undefined;
-            }
-            mergedAllOf.push(nestedSchema);
-        }
-    });
-    return mergedAllOf.length
-        ? {
-            allOf: mergedAllOf,
-            ...unevaluatedProperties,
-        }
-        : undefined;
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js

@@ -1,21 +0,0 @@
-export function parseLiteralDef(def, refs) {
-    const parsedType = typeof def.value;
-    if (parsedType !== "bigint" &&
-        parsedType !== "number" &&
-        parsedType !== "boolean" &&
-        parsedType !== "string") {
-        return {
-            type: Array.isArray(def.value) ? "array" : "object",
-        };
-    }
-    if (refs.target === "openApi3") {
-        return {
-            type: parsedType === "bigint" ? "integer" : parsedType,
-            enum: [def.value],
-        };
-    }
-    return {
-        type: parsedType === "bigint" ? "integer" : parsedType,
-        const: def.value,
-    };
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/map.js

@@ -1,26 +0,0 @@
-import { parseDef } from "../parseDef.js";
-import { parseRecordDef } from "./record.js";
-import { parseAnyDef } from "./any.js";
-export function parseMapDef(def, refs) {
-    if (refs.mapStrategy === "record") {
-        return parseRecordDef(def, refs);
-    }
-    const keys = parseDef(def.keyType._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", "items", "0"],
-    }) || parseAnyDef(refs);
-    const values = parseDef(def.valueType._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", "items", "1"],
-    }) || parseAnyDef(refs);
-    return {
-        type: "array",
-        maxItems: 125,
-        items: {
-            type: "array",
-            items: [keys, values],
-            minItems: 2,
-            maxItems: 2,
-        },
-    };
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js

@@ -1,16 +0,0 @@
-export function parseNativeEnumDef(def) {
-    const object = def.values;
-    const actualKeys = Object.keys(def.values).filter((key) => {
-        return typeof object[object[key]] !== "number";
-    });
-    const actualValues = actualKeys.map((key) => object[key]);
-    const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
-    return {
-        type: parsedTypes.length === 1
-            ? parsedTypes[0] === "string"
-                ? "string"
-                : "number"
-            : ["string", "number"],
-        enum: actualValues,
-    };
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/never.js

@@ -1,11 +0,0 @@
-import { parseAnyDef } from "./any.js";
-export function parseNeverDef(refs) {
-    return refs.target === "openAi"
-        ? undefined
-        : {
-            not: parseAnyDef({
-                ...refs,
-                currentPath: [...refs.currentPath, "not"],
-            }),
-        };
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/null.js

@@ -1,10 +0,0 @@
-export function parseNullDef(refs) {
-    return refs.target === "openApi3"
-        ? {
-            enum: ["null"],
-            nullable: true,
-        }
-        : {
-            type: "null",
-        };
-}

package/temp_npm_package/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js

@@ -1,33 +0,0 @@
-import { parseDef } from "../parseDef.js";
-import { primitiveMappings } from "./union.js";
-export function parseNullableDef(def, refs) {
-    if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) &&
-        (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
-        if (refs.target === "openApi3") {
-            return {
-                type: primitiveMappings[def.innerType._def.typeName],
-                nullable: true,
-            };
-        }
-        return {
-            type: [
-                primitiveMappings[def.innerType._def.typeName],
-                "null",
-            ],
-        };
-    }
-    if (refs.target === "openApi3") {
-        const base = parseDef(def.innerType._def, {
-            ...refs,
-            currentPath: [...refs.currentPath],
-        });
-        if (base && "$ref" in base)
-            return { allOf: [base], nullable: true };
-        return base && { ...base, nullable: true };
-    }
-    const base = parseDef(def.innerType._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "anyOf", "0"],
-    });
-    return base && { anyOf: [base, { type: "null" }] };
-}