@orq-ai/evaluators 1.0.0-12

package/dist/lib/string-evaluators.d.ts

@@ -0,0 +1,30 @@
+import type { Evaluator } from "@orq-ai/evaluatorq";
+/**
+ * Validates that a string output does not exceed a maximum length
+ */
+export declare function maxLength(max: number): Evaluator;
+/**
+ * Validates that a string output meets a minimum length requirement
+ */
+export declare function minLength(min: number): Evaluator;
+/**
+ * Validates that the output contains a specific substring
+ */
+export declare function contains(substring: string, caseSensitive?: boolean): Evaluator;
+/**
+ * Validates that the output matches a regular expression pattern
+ */
+export declare function matchesPattern(pattern: RegExp | string, description?: string): Evaluator;
+/**
+ * Validates that the output starts with a specific prefix
+ */
+export declare function startsWith(prefix: string): Evaluator;
+/**
+ * Validates that the output ends with a specific suffix
+ */
+export declare function endsWith(suffix: string): Evaluator;
+/**
+ * Validates that the output is not empty or whitespace-only
+ */
+export declare const notEmpty: Evaluator;
+//# sourceMappingURL=string-evaluators.d.ts.map

package/dist/lib/string-evaluators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-evaluators.d.ts","sourceRoot":"","sources":["../../src/lib/string-evaluators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAsBhD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAsBhD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,UAAO,GAAG,SAAS,CAyB3E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CA0BxF;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAqBpD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAqBlD;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,SAkBtB,CAAC"}

package/dist/lib/string-evaluators.js

@@ -0,0 +1,168 @@
+/**
+ * Validates that a string output does not exceed a maximum length
+ */
+export function maxLength(max) {
+    return {
+        name: `max-length-${max}`,
+        scorer: async ({ output }) => {
+            if (output === undefined || output === null) {
+                return {
+                    value: false,
+                    explanation: "Output is null or undefined",
+                };
+            }
+            const length = typeof output === "string" ? output.length : String(output).length;
+            const isValid = length <= max;
+            return {
+                value: isValid,
+                explanation: isValid
+                    ? `Length ${length} is within limit (≤${max})`
+                    : `Length ${length} exceeds limit of ${max}`,
+            };
+        },
+    };
+}
+/**
+ * Validates that a string output meets a minimum length requirement
+ */
+export function minLength(min) {
+    return {
+        name: `min-length-${min}`,
+        scorer: async ({ output }) => {
+            if (output === undefined || output === null) {
+                return {
+                    value: false,
+                    explanation: "Output is null or undefined",
+                };
+            }
+            const length = typeof output === "string" ? output.length : String(output).length;
+            const isValid = length >= min;
+            return {
+                value: isValid,
+                explanation: isValid
+                    ? `Length ${length} meets minimum (≥${min})`
+                    : `Length ${length} is below minimum ${min}`,
+            };
+        },
+    };
+}
+/**
+ * Validates that the output contains a specific substring
+ */
+export function contains(substring, caseSensitive = true) {
+    return {
+        name: `contains-${substring.toLowerCase().replace(/\s+/g, "-")}`,
+        scorer: async ({ output }) => {
+            if (output === undefined || output === null) {
+                return {
+                    value: false,
+                    explanation: "Output is null or undefined",
+                };
+            }
+            const outputStr = String(output);
+            const searchStr = substring;
+            const found = caseSensitive
+                ? outputStr.includes(searchStr)
+                : outputStr.toLowerCase().includes(searchStr.toLowerCase());
+            return {
+                value: found,
+                explanation: found
+                    ? `Output contains "${substring}"`
+                    : `Output does not contain "${substring}"`,
+            };
+        },
+    };
+}
+/**
+ * Validates that the output matches a regular expression pattern
+ */
+export function matchesPattern(pattern, description) {
+    const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+    const patternStr = regex.source;
+    return {
+        name: `matches-pattern-${patternStr.slice(0, 20).replace(/[^a-z0-9]/gi, "-")}`,
+        scorer: async ({ output }) => {
+            if (output === undefined || output === null) {
+                return {
+                    value: false,
+                    explanation: "Output is null or undefined",
+                };
+            }
+            const matches = regex.test(String(output));
+            return {
+                value: matches,
+                explanation: matches
+                    ? description || `Output matches pattern /${patternStr}/`
+                    : description
+                        ? `Output does not match required pattern: ${description}`
+                        : `Output does not match pattern /${patternStr}/`,
+            };
+        },
+    };
+}
+/**
+ * Validates that the output starts with a specific prefix
+ */
+export function startsWith(prefix) {
+    return {
+        name: `starts-with-${prefix.toLowerCase().replace(/\s+/g, "-")}`,
+        scorer: async ({ output }) => {
+            if (output === undefined || output === null) {
+                return {
+                    value: false,
+                    explanation: "Output is null or undefined",
+                };
+            }
+            const starts = String(output).startsWith(prefix);
+            return {
+                value: starts,
+                explanation: starts
+                    ? `Output starts with "${prefix}"`
+                    : `Output does not start with "${prefix}"`,
+            };
+        },
+    };
+}
+/**
+ * Validates that the output ends with a specific suffix
+ */
+export function endsWith(suffix) {
+    return {
+        name: `ends-with-${suffix.toLowerCase().replace(/\s+/g, "-")}`,
+        scorer: async ({ output }) => {
+            if (output === undefined || output === null) {
+                return {
+                    value: false,
+                    explanation: "Output is null or undefined",
+                };
+            }
+            const ends = String(output).endsWith(suffix);
+            return {
+                value: ends,
+                explanation: ends
+                    ? `Output ends with "${suffix}"`
+                    : `Output does not end with "${suffix}"`,
+            };
+        },
+    };
+}
+/**
+ * Validates that the output is not empty or whitespace-only
+ */
+export const notEmpty = {
+    name: "not-empty",
+    scorer: async ({ output }) => {
+        if (output === undefined || output === null) {
+            return {
+                value: false,
+                explanation: "Output is null or undefined",
+            };
+        }
+        const trimmed = String(output).trim();
+        const isNotEmpty = trimmed.length > 0;
+        return {
+            value: isNotEmpty,
+            explanation: isNotEmpty ? "Output is not empty" : "Output is empty or whitespace-only",
+        };
+    },
+};

package/dist/lib/vector-utils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Vector utilities for cosine similarity and dot product calculations
+ *
+ * thanks @alexanderop
+ * @see https://alexop.dev/posts/how-to-implement-a-cosine-similarity-function-in-typescript-for-vector-comparison/
+ */
+/**
+ * Calculates the cosine similarity between two vectors
+ */
+export declare function cosineSimilarity(vecA: number[], vecB: number[]): number;
+/**
+ * Calculates the dot product of two vectors
+ */
+export declare function dotProduct(vecA: number[], vecB: number[]): number;
+/**
+ * Calculates the magnitude (length) of a vector
+ */
+export declare function magnitude(vec: number[]): number;
+/**
+ * Normalizes a vector (converts to unit vector)
+ */
+export declare function normalize(vec: number[]): number[];
+/**
+ * Converts cosine similarity to angular distance in degrees
+ */
+export declare function similarityToDegrees(similarity: number): number;
+//# sourceMappingURL=vector-utils.d.ts.map

package/dist/lib/vector-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-utils.d.ts","sourceRoot":"","sources":["../../src/lib/vector-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAgBvE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAQjE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,CAE/C;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAQjD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAI9D"}

package/dist/lib/vector-utils.js

@@ -0,0 +1,54 @@
+/**
+ * Vector utilities for cosine similarity and dot product calculations
+ *
+ * thanks @alexanderop
+ * @see https://alexop.dev/posts/how-to-implement-a-cosine-similarity-function-in-typescript-for-vector-comparison/
+ */
+/**
+ * Calculates the cosine similarity between two vectors
+ */
+export function cosineSimilarity(vecA, vecB) {
+    if (vecA.length !== vecB.length) {
+        throw new Error(`Vector dimensions don't match: ${vecA.length} vs ${vecB.length}`);
+    }
+    const dotProduct = vecA.reduce((sum, a, i) => sum + a * vecB[i], 0);
+    const magnitudeA = Math.hypot(...vecA);
+    const magnitudeB = Math.hypot(...vecB);
+    if (magnitudeA === 0 || magnitudeB === 0) {
+        return 0;
+    }
+    return dotProduct / (magnitudeA * magnitudeB);
+}
+/**
+ * Calculates the dot product of two vectors
+ */
+export function dotProduct(vecA, vecB) {
+    if (vecA.length !== vecB.length) {
+        throw new Error(`Vector dimensions don't match: ${vecA.length} vs ${vecB.length}`);
+    }
+    return vecA.reduce((sum, a, i) => sum + a * vecB[i], 0);
+}
+/**
+ * Calculates the magnitude (length) of a vector
+ */
+export function magnitude(vec) {
+    return Math.hypot(...vec);
+}
+/**
+ * Normalizes a vector (converts to unit vector)
+ */
+export function normalize(vec) {
+    const mag = magnitude(vec);
+    if (mag === 0) {
+        return Array(vec.length).fill(0);
+    }
+    return vec.map((v) => v / mag);
+}
+/**
+ * Converts cosine similarity to angular distance in degrees
+ */
+export function similarityToDegrees(similarity) {
+    // Clamp similarity to [-1, 1] to handle floating point errors
+    const clampedSimilarity = Math.max(-1, Math.min(1, similarity));
+    return Math.acos(clampedSimilarity) * (180 / Math.PI);
+}