@jterrazz/intelligence 1.0.0

package/dist/adapters/utils/ai-response-parser.js

@@ -0,0 +1,334 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+import { z } from 'zod/v4';
+import { AIResponseParserError } from './ai-response-parser-error.js';
+/**
+ * Parses AI response text into structured data based on Zod schema
+ */ export var AIResponseParser = /*#__PURE__*/ function() {
+    "use strict";
+    function AIResponseParser(schema) {
+        _class_call_check(this, AIResponseParser);
+        _define_property(this, "schema", void 0);
+        this.schema = schema;
+    }
+    _create_class(AIResponseParser, [
+        {
+            key: "parse",
+            value: /**
+     * Parses the AI response text based on the configured schema
+     */ function parse(text) {
+                try {
+                    var cleanedText = this.cleanText(text);
+                    var json = this.extractJsonFromText(cleanedText);
+                    var unescapedJson = this.unescapeJsonValues(json);
+                    return this.schema.parse(unescapedJson);
+                } catch (error) {
+                    if (_instanceof(error, z.ZodError)) {
+                        throw new AIResponseParserError('Failed to validate response against schema', error, text);
+                    }
+                    throw error;
+                }
+            }
+        },
+        {
+            key: "cleanText",
+            value: /**
+     * Cleans text and finds the largest schema-compatible structure
+     */ function cleanText(text) {
+                var _this = this;
+                // First try to extract from markdown code blocks
+                var codeBlocks = text.match(/```(?:json)?\r?\n([^`]*?)\r?\n```/g);
+                if (codeBlocks) {
+                    // Try each code block and return the largest valid one
+                    var validBlocks = codeBlocks.map(function(block) {
+                        return _this.extractJsonFromCodeBlock(block);
+                    }).filter(function(block) {
+                        return block !== null;
+                    });
+                    if (validBlocks.length > 0) {
+                        return this.findLargestString(validBlocks);
+                    }
+                }
+                // If no valid code blocks, try to find JSON-like structures in the text
+                var jsonMatches = this.findJsonStructures(text);
+                if (jsonMatches.length > 0) {
+                    return this.findLargestString(jsonMatches);
+                }
+                // If no JSON structures found, clean and return the original text
+                return text.replace(/\s+/g, ' ').trim();
+            }
+        },
+        {
+            key: "convertToPrimitive",
+            value: /**
+     * Converts value to appropriate primitive type based on schema
+     */ function convertToPrimitive(value, schema) {
+                if (_instanceof(schema, z.ZodString)) {
+                    return String(value);
+                }
+                if (_instanceof(schema, z.ZodNumber)) {
+                    return Number(value);
+                }
+                if (_instanceof(schema, z.ZodBoolean)) {
+                    return Boolean(value);
+                }
+                if (_instanceof(schema, z.ZodNull)) {
+                    return null;
+                }
+                return value;
+            }
+        },
+        {
+            key: "extractArray",
+            value: /**
+     * Extracts array from text
+     */ function extractArray(text) {
+                var arrayStart = text.indexOf('[');
+                var arrayEnd = text.lastIndexOf(']');
+                if (arrayStart === -1 || arrayEnd === -1) {
+                    throw new AIResponseParserError('No array found in response', undefined, text);
+                }
+                try {
+                    return JSON.parse(text.slice(arrayStart, arrayEnd + 1));
+                } catch (error) {
+                    throw new AIResponseParserError('Failed to parse array JSON', error, text);
+                }
+            }
+        },
+        {
+            key: "extractJsonFromCodeBlock",
+            value: /**
+     * Extracts and validates JSON content from a code block
+     */ function extractJsonFromCodeBlock(block) {
+                var content = block.replace(/```(?:json)?\r?\n([^`]*?)\r?\n```/, '$1').trim();
+                try {
+                    // Attempt to parse as JSON to validate structure
+                    JSON.parse(content);
+                    return content;
+                } catch (e) {
+                    return null;
+                }
+            }
+        },
+        {
+            key: "extractJsonFromText",
+            value: /**
+     * Extracts and parses JSON from text based on schema type
+     */ function extractJsonFromText(text) {
+                if (_instanceof(this.schema, z.ZodArray)) {
+                    return this.extractArray(text);
+                }
+                if (_instanceof(this.schema, z.ZodObject)) {
+                    return this.extractObject(text);
+                }
+                if (_instanceof(this.schema, z.ZodString) || _instanceof(this.schema, z.ZodNumber) || _instanceof(this.schema, z.ZodBoolean) || _instanceof(this.schema, z.ZodNull)) {
+                    return this.extractPrimitive(text, this.schema);
+                }
+                throw new AIResponseParserError('Unsupported schema type', undefined, text);
+            }
+        },
+        {
+            key: "extractObject",
+            value: /**
+     * Extracts object from text
+     */ function extractObject(text) {
+                var objectStart = text.indexOf('{');
+                var objectEnd = text.lastIndexOf('}');
+                if (objectStart === -1 || objectEnd === -1) {
+                    throw new AIResponseParserError('No object found in response', undefined, text);
+                }
+                try {
+                    return JSON.parse(text.slice(objectStart, objectEnd + 1));
+                } catch (error) {
+                    throw new AIResponseParserError('Failed to parse object JSON', error, text);
+                }
+            }
+        },
+        {
+            key: "extractPrimitive",
+            value: /**
+     * Extracts and converts primitive value from text
+     */ function extractPrimitive(text, schema) {
+                var trimmed = text.trim();
+                // Try to parse as JSON first in case it's quoted
+                try {
+                    var parsed = JSON.parse(trimmed);
+                    return this.convertToPrimitive(parsed, schema);
+                } catch (e) {
+                    // If not valid JSON, use the raw string
+                    return this.convertToPrimitive(trimmed, schema);
+                }
+            }
+        },
+        {
+            key: "findJsonStructures",
+            value: /**
+     * Finds valid JSON structures in raw text
+     */ function findJsonStructures(text) {
+                var jsonMatches = [];
+                var depth = 0;
+                var start = -1;
+                for(var i = 0; i < text.length; i++){
+                    var char = text[i];
+                    if (char === '{' || char === '[') {
+                        if (depth === 0) start = i;
+                        depth++;
+                    } else if (char === '}' || char === ']') {
+                        depth--;
+                        if (depth === 0 && start !== -1) {
+                            var potentialJson = text.slice(start, i + 1);
+                            try {
+                                JSON.parse(potentialJson);
+                                jsonMatches.push(potentialJson);
+                            } catch (e) {
+                            // Invalid JSON, ignore
+                            }
+                        }
+                    }
+                }
+                return jsonMatches;
+            }
+        },
+        {
+            key: "findLargestString",
+            value: /**
+     * Returns the largest string from an array of strings
+     */ function findLargestString(strings) {
+                return strings.reduce(function(largest, current) {
+                    return current.length > largest.length ? current : largest;
+                }, strings[0]);
+            }
+        },
+        {
+            key: "unescapeJsonValues",
+            value: /**
+     * Recursively unescapes all string values in a JSON object/array
+     */ function unescapeJsonValues(json) {
+                var _this = this;
+                if (typeof json === 'string') {
+                    return this.unescapeText(json);
+                }
+                if (Array.isArray(json)) {
+                    return json.map(function(item) {
+                        return _this.unescapeJsonValues(item);
+                    });
+                }
+                if ((typeof json === "undefined" ? "undefined" : _type_of(json)) === 'object' && json !== null) {
+                    return Object.fromEntries(Object.entries(json).map(function(param) {
+                        var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+                        return [
+                            key,
+                            _this.unescapeJsonValues(value)
+                        ];
+                    }));
+                }
+                return json;
+            }
+        },
+        {
+            key: "unescapeText",
+            value: /**
+     * Unescapes common escaped characters in text
+     */ function unescapeText(text) {
+                return text.replace(/\\"/g, '"') // Unescape quotes
+                .replace(/\\n/g, '\n') // Unescape newlines
+                .replace(/\\r/g, '\r') // Unescape carriage returns
+                .replace(/\\t/g, '\t') // Unescape tabs
+                .replace(/\\\\/g, '\\') // Unescape backslashes
+                .replace(/\\u([0-9a-fA-F]{4})/g, function(_, code) {
+                    return String.fromCharCode(parseInt(code, 16));
+                }); // Unescape unicode
+            }
+        }
+    ]);
+    return AIResponseParser;
+}();
+
+//# sourceMappingURL=ai-response-parser.js.map

package/dist/adapters/utils/ai-response-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/adapters/utils/ai-response-parser.ts"],"sourcesContent":["import { z } from 'zod/v4';\n\nimport { AIResponseParserError } from './ai-response-parser-error.js';\n\n/**\n * Parses AI response text into structured data based on Zod schema\n */\nexport class AIResponseParser<T> {\n    constructor(private readonly schema: z.ZodSchema<T>) {}\n\n    /**\n     * Parses the AI response text based on the configured schema\n     */\n    public parse(text: string): T {\n        try {\n            const cleanedText = this.cleanText(text);\n            const json = this.extractJsonFromText(cleanedText);\n            const unescapedJson = this.unescapeJsonValues(json);\n            return this.schema.parse(unescapedJson);\n        } catch (error) {\n            if (error instanceof z.ZodError) {\n                throw new AIResponseParserError(\n                    'Failed to validate response against schema',\n                    error,\n                    text,\n                );\n            }\n            throw error;\n        }\n    }\n\n    /**\n     * Cleans text and finds the largest schema-compatible structure\n     */\n    private cleanText(text: string): string {\n        // First try to extract from markdown code blocks\n        const codeBlocks = text.match(/```(?:json)?\\r?\\n([^`]*?)\\r?\\n```/g);\n        if (codeBlocks) {\n            // Try each code block and return the largest valid one\n            const validBlocks = codeBlocks\n                .map((block) => this.extractJsonFromCodeBlock(block))\n                .filter((block): block is string => block !== null);\n\n            if (validBlocks.length > 0) {\n                return this.findLargestString(validBlocks);\n            }\n        }\n\n        // If no valid code blocks, try to find JSON-like structures in the text\n        const jsonMatches = this.findJsonStructures(text);\n        if (jsonMatches.length > 0) {\n            return this.findLargestString(jsonMatches);\n        }\n\n        // If no JSON structures found, clean and return the original text\n        return text.replace(/\\s+/g, ' ').trim();\n    }\n\n    /**\n     * Converts value to appropriate primitive type based on schema\n     */\n    private convertToPrimitive(value: unknown, schema: z.ZodType): unknown {\n        if (schema instanceof z.ZodString) {\n            return String(value);\n        }\n        if (schema instanceof z.ZodNumber) {\n            return Number(value);\n        }\n        if (schema instanceof z.ZodBoolean) {\n            return Boolean(value);\n        }\n        if (schema instanceof z.ZodNull) {\n            return null;\n        }\n        return value;\n    }\n\n    /**\n     * Extracts array from text\n     */\n    private extractArray(text: string): unknown {\n        const arrayStart = text.indexOf('[');\n        const arrayEnd = text.lastIndexOf(']');\n        if (arrayStart === -1 || arrayEnd === -1) {\n            throw new AIResponseParserError('No array found in response', undefined, text);\n        }\n        try {\n            return JSON.parse(text.slice(arrayStart, arrayEnd + 1));\n        } catch (error) {\n            throw new AIResponseParserError('Failed to parse array JSON', error, text);\n        }\n    }\n\n    /**\n     * Extracts and validates JSON content from a code block\n     */\n    private extractJsonFromCodeBlock(block: string): null | string {\n        const content = block.replace(/```(?:json)?\\r?\\n([^`]*?)\\r?\\n```/, '$1').trim();\n        try {\n            // Attempt to parse as JSON to validate structure\n            JSON.parse(content);\n            return content;\n        } catch {\n            return null;\n        }\n    }\n\n    /**\n     * Extracts and parses JSON from text based on schema type\n     */\n    private extractJsonFromText(text: string): unknown {\n        if (this.schema instanceof z.ZodArray) {\n            return this.extractArray(text);\n        }\n\n        if (this.schema instanceof z.ZodObject) {\n            return this.extractObject(text);\n        }\n\n        if (\n            this.schema instanceof z.ZodString ||\n            this.schema instanceof z.ZodNumber ||\n            this.schema instanceof z.ZodBoolean ||\n            this.schema instanceof z.ZodNull\n        ) {\n            return this.extractPrimitive(text, this.schema);\n        }\n\n        throw new AIResponseParserError('Unsupported schema type', undefined, text);\n    }\n\n    /**\n     * Extracts object from text\n     */\n    private extractObject(text: string): unknown {\n        const objectStart = text.indexOf('{');\n        const objectEnd = text.lastIndexOf('}');\n        if (objectStart === -1 || objectEnd === -1) {\n            throw new AIResponseParserError('No object found in response', undefined, text);\n        }\n        try {\n            return JSON.parse(text.slice(objectStart, objectEnd + 1));\n        } catch (error) {\n            throw new AIResponseParserError('Failed to parse object JSON', error, text);\n        }\n    }\n\n    /**\n     * Extracts and converts primitive value from text\n     */\n    private extractPrimitive(text: string, schema: z.ZodType): unknown {\n        const trimmed = text.trim();\n\n        // Try to parse as JSON first in case it's quoted\n        try {\n            const parsed = JSON.parse(trimmed);\n            return this.convertToPrimitive(parsed, schema);\n        } catch {\n            // If not valid JSON, use the raw string\n            return this.convertToPrimitive(trimmed, schema);\n        }\n    }\n\n    /**\n     * Finds valid JSON structures in raw text\n     */\n    private findJsonStructures(text: string): string[] {\n        const jsonMatches: string[] = [];\n        let depth = 0;\n        let start = -1;\n\n        for (let i = 0; i < text.length; i++) {\n            const char = text[i];\n            if (char === '{' || char === '[') {\n                if (depth === 0) start = i;\n                depth++;\n            } else if (char === '}' || char === ']') {\n                depth--;\n                if (depth === 0 && start !== -1) {\n                    const potentialJson = text.slice(start, i + 1);\n                    try {\n                        JSON.parse(potentialJson);\n                        jsonMatches.push(potentialJson);\n                    } catch {\n                        // Invalid JSON, ignore\n                    }\n                }\n            }\n        }\n\n        return jsonMatches;\n    }\n\n    /**\n     * Returns the largest string from an array of strings\n     */\n    private findLargestString(strings: string[]): string {\n        return strings.reduce(\n            (largest, current) => (current.length > largest.length ? current : largest),\n            strings[0],\n        );\n    }\n\n    /**\n     * Recursively unescapes all string values in a JSON object/array\n     */\n    private unescapeJsonValues(json: unknown): unknown {\n        if (typeof json === 'string') {\n            return this.unescapeText(json);\n        }\n        if (Array.isArray(json)) {\n            return json.map((item) => this.unescapeJsonValues(item));\n        }\n        if (typeof json === 'object' && json !== null) {\n            return Object.fromEntries(\n                Object.entries(json).map(([key, value]) => [key, this.unescapeJsonValues(value)]),\n            );\n        }\n        return json;\n    }\n\n    /**\n     * Unescapes common escaped characters in text\n     */\n    private unescapeText(text: string): string {\n        return text\n            .replace(/\\\\\"/g, '\"') // Unescape quotes\n            .replace(/\\\\n/g, '\\n') // Unescape newlines\n            .replace(/\\\\r/g, '\\r') // Unescape carriage returns\n            .replace(/\\\\t/g, '\\t') // Unescape tabs\n            .replace(/\\\\\\\\/g, '\\\\') // Unescape backslashes\n            .replace(/\\\\u([0-9a-fA-F]{4})/g, (_, code) => String.fromCharCode(parseInt(code, 16))); // Unescape unicode\n    }\n}\n"],"names":["z","AIResponseParserError","AIResponseParser","schema","parse","text","cleanedText","cleanText","json","extractJsonFromText","unescapedJson","unescapeJsonValues","error","ZodError","codeBlocks","match","validBlocks","map","block","extractJsonFromCodeBlock","filter","length","findLargestString","jsonMatches","findJsonStructures","replace","trim","convertToPrimitive","value","ZodString","String","ZodNumber","Number","ZodBoolean","Boolean","ZodNull","extractArray","arrayStart","indexOf","arrayEnd","lastIndexOf","undefined","JSON","slice","content","ZodArray","ZodObject","extractObject","extractPrimitive","objectStart","objectEnd","trimmed","parsed","depth","start","i","char","potentialJson","push","strings","reduce","largest","current","unescapeText","Array","isArray","item","Object","fromEntries","entries","key","_","code","fromCharCode","parseInt"],"mappings":"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"}