@agentforge/tools 0.16.24 → 0.16.25

package/dist/index.cjs

@@ -1941,11 +1941,52 @@ var objectOmitSchema = zod.z.object({
   object: zod.z.record(zod.z.any().describe("Property value")).describe("Source object"),
   properties: zod.z.array(zod.z.string().describe("String value")).describe("List of property names to omit")
 });
+
+// src/data/transformer/tools/shared.ts
+function getNestedValue(value, path12) {
+  return path12.split(".").reduce((current, key) => {
+    if (current == null) {
+      return void 0;
+    }
+    return Reflect.get(Object(current), key);
+  }, value);
+}
+function compareRelationalValues(left, right) {
+  const leftOperand = left;
+  const rightOperand = right;
+  if (leftOperand < rightOperand) {
+    return -1;
+  }
+  if (leftOperand > rightOperand) {
+    return 1;
+  }
+  return 0;
+}
+function pickObjectProperties(source, properties) {
+  const picked = {};
+  for (const property of properties) {
+    if (property in source) {
+      Object.defineProperty(picked, property, {
+        value: source[property],
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+  }
+  return picked;
+}
+function omitObjectProperties(source, properties) {
+  const omitted = { ...source };
+  for (const property of properties) {
+    delete omitted[property];
+  }
+  return omitted;
+}
+
+// src/data/transformer/tools/array-filter.ts
 function createArrayFilterTool() {
   return core.toolBuilder().name("array-filter").description("Filter an array based on a property value. Supports equality, comparison, and contains operations.").category(core.ToolCategory.UTILITY).tags(["array", "filter", "data", "transform"]).schema(arrayFilterSchema).implement(async (input) => {
-    const getNestedValue = (obj, path12) => {
-      return path12.split(".").reduce((current, key) => current?.[key], obj);
-    };
     const filtered = input.array.filter((item) => {
       const itemValue = getNestedValue(item, input.property);
       switch (input.operator) {
@@ -1954,9 +1995,9 @@ function createArrayFilterTool() {
         case "not-equals":
           return itemValue !== input.value;
         case "greater-than":
-          return itemValue > input.value;
+          return compareRelationalValues(itemValue, input.value) > 0;
         case "less-than":
-          return itemValue < input.value;
+          return compareRelationalValues(itemValue, input.value) < 0;
         case "contains":
           return String(itemValue).includes(String(input.value));
         case "starts-with":
@@ -1992,15 +2033,14 @@ function createArrayMapTool() {
 }
 function createArraySortTool() {
   return core.toolBuilder().name("array-sort").description("Sort an array by a property value. Supports ascending and descending order.").category(core.ToolCategory.UTILITY).tags(["array", "sort", "data", "transform"]).schema(arraySortSchema).implement(async (input) => {
-    const getNestedValue = (obj, path12) => {
-      return path12.split(".").reduce((current, key) => current?.[key], obj);
-    };
     const sorted = [...input.array].sort((a, b) => {
       const aValue = getNestedValue(a, input.property);
       const bValue = getNestedValue(b, input.property);
-      if (aValue < bValue) return input.order === "asc" ? -1 : 1;
-      if (aValue > bValue) return input.order === "asc" ? 1 : -1;
-      return 0;
+      const comparison = compareRelationalValues(aValue, bValue);
+      if (comparison === 0) {
+        return 0;
+      }
+      return input.order === "asc" ? comparison : comparison * -1;
     });
     return {
       sorted,
@@ -2026,24 +2066,10 @@ function createArrayGroupByTool() {
   }).build();
 }
 function createObjectPickTool() {
-  return core.toolBuilder().name("object-pick").description("Create a new object with only the specified properties from the source object.").category(core.ToolCategory.UTILITY).tags(["object", "pick", "data", "transform"]).schema(objectPickSchema).implement(async (input) => {
-    const picked = {};
-    for (const prop of input.properties) {
-      if (prop in input.object) {
-        picked[prop] = input.object[prop];
-      }
-    }
-    return picked;
-  }).build();
+  return core.toolBuilder().name("object-pick").description("Create a new object with only the specified properties from the source object.").category(core.ToolCategory.UTILITY).tags(["object", "pick", "data", "transform"]).schema(objectPickSchema).implement(async (input) => pickObjectProperties(input.object, input.properties)).build();
 }
 function createObjectOmitTool() {
-  return core.toolBuilder().name("object-omit").description("Create a new object excluding the specified properties from the source object.").category(core.ToolCategory.UTILITY).tags(["object", "omit", "data", "transform"]).schema(objectOmitSchema).implement(async (input) => {
-    const omitted = { ...input.object };
-    for (const prop of input.properties) {
-      delete omitted[prop];
-    }
-    return omitted;
-  }).build();
+  return core.toolBuilder().name("object-omit").description("Create a new object excluding the specified properties from the source object.").category(core.ToolCategory.UTILITY).tags(["object", "omit", "data", "transform"]).schema(objectOmitSchema).implement(async (input) => omitObjectProperties(input.object, input.properties)).build();
 }
 
 // src/data/transformer/index.ts