@granular-software/sdk 0.4.26 → 0.4.28

package/dist/agent-evals.mjs

@@ -4909,9 +4909,24 @@ var Session = class {
    * Get domain documentation for LLMs. Returns types (preferred) or fallback.
    */
   async getDomainDocumentation() {
-    const types = await this.getDomainTypes();
-    if (types && (types.includes("export declare class") || types.includes("export async function"))) {
-      return types;
+    const [types, docs] = await Promise.all([
+      this.getDomainTypes(),
+      this.getDomainDocs()
+    ]);
+    const normalizedTypes = types.trim();
+    const normalizedDocs = docs.trim();
+    if (normalizedTypes && (normalizedTypes.includes("export declare class") || normalizedTypes.includes("export async function"))) {
+      if (!normalizedDocs) {
+        return normalizedTypes;
+      }
+      return [
+        normalizedTypes,
+        "Generated usage notes from ./sandbox-tools docs:",
+        normalizedDocs
+      ].join("\n\n");
+    }
+    if (normalizedDocs) {
+      return normalizedDocs;
     }
     const summary = await this.getDomain();
     return this.generateFallbackDocs(summary);
@@ -9721,10 +9736,15 @@ external_exports.union([
     scalarType: external_exports.string().optional()
   }).strict()
 ]);
+external_exports.union([
+  external_exports.boolean(),
+  external_exports.object({
+    enabled: external_exports.boolean().optional(),
+    phonetic: external_exports.boolean().optional()
+  }).strict()
+]);
 external_exports.object({
-  operator: external_exports.enum(
-    [...VALIDATION_RULE_OPERATORS]
-  ),
+  operator: external_exports.enum([...VALIDATION_RULE_OPERATORS]),
   stringValue: external_exports.string().optional(),
   numberValue: external_exports.number().optional(),
   booleanValue: external_exports.boolean().optional(),
@@ -9817,12 +9837,18 @@ function collectMetamodelSummarySelections(packages) {
   const propertyFields = [];
   const methodFields = [];
   for (const metamodelPackage of packages) {
-    pushUnique(classFields, metamodelPackage.summary.selections?.classFields || []);
+    pushUnique(
+      classFields,
+      metamodelPackage.summary.selections?.classFields || []
+    );
     pushUnique(
       propertyFields,
       metamodelPackage.summary.selections?.propertyFields || []
     );
-    pushUnique(methodFields, metamodelPackage.summary.selections?.methodFields || []);
+    pushUnique(
+      methodFields,
+      metamodelPackage.summary.selections?.methodFields || []
+    );
   }
   return {
     classFields: unique(classFields),
@@ -9910,7 +9936,11 @@ function createMetamodelRegistry(metamodelPackages) {
       return collectMetamodelSummarySelections(packages);
     },
     applyClassSummaryReaders(rawClass, classSummary) {
-      return applyMetamodelSummaryReadersToClass(packages, rawClass, classSummary);
+      return applyMetamodelSummaryReadersToClass(
+        packages,
+        rawClass,
+        classSummary
+      );
     },
     applyPropertySummaryReaders(rawProperty, propertySummary) {
       return applyMetamodelSummaryReadersToProperty(
@@ -9920,7 +9950,11 @@ function createMetamodelRegistry(metamodelPackages) {
       );
     },
     applyMethodSummaryReaders(rawMethod, methodSummary) {
-      return applyMetamodelSummaryReadersToMethod(packages, rawMethod, methodSummary);
+      return applyMetamodelSummaryReadersToMethod(
+        packages,
+        rawMethod,
+        methodSummary
+      );
     },
     applyClassIR(classIR, classSummary) {
       return applyMetamodelClassIR(packages, classIR, classSummary);
@@ -9968,6 +10002,10 @@ function mergeClassSummaryPatch(target, patch) {
 }
 function mergePropertySummaryPatch(target, patch) {
   pushUnique(target.notes, patch.notes || []);
+  if (patch.searchable !== void 0) target.searchable = patch.searchable;
+  if (patch.searchablePhonetic !== void 0) {
+    target.searchablePhonetic = patch.searchablePhonetic;
+  }
   if (patch.required !== void 0) target.required = patch.required;
   if (patch.enumRule !== void 0) target.enumRule = patch.enumRule;
   if (patch.filterBy !== void 0) target.filterBy = patch.filterBy;
@@ -9979,9 +10017,11 @@ function mergeMethodSummaryPatch(target, patch) {
   if (patch.effectKey !== void 0) target.effectKey = patch.effectKey;
   if (patch.description !== void 0) target.description = patch.description;
   if (patch.inputSchema !== void 0) target.inputSchema = patch.inputSchema;
-  if (patch.outputSchema !== void 0) target.outputSchema = patch.outputSchema;
+  if (patch.outputSchema !== void 0)
+    target.outputSchema = patch.outputSchema;
   if (patch.metamodels !== void 0) target.metamodels = patch.metamodels;
-  if (patch.effectBehaviors !== void 0) target.effectBehaviors = patch.effectBehaviors;
+  if (patch.effectBehaviors !== void 0)
+    target.effectBehaviors = patch.effectBehaviors;
   if (patch.static !== void 0) target.static = patch.static;
 }
 function toPascalCase(value) {
@@ -10487,12 +10527,20 @@ function defaultFilterOperators(scalarType) {
   switch ((scalarType || "").toLowerCase()) {
     case "number":
     case "date":
-      return ["equal_to", "greater_than", "less_than", "not_null"];
+      return [
+        "equal_to",
+        "greater_than",
+        "greater_than_or_equal_to",
+        "less_than",
+        "less_than_or_equal_to",
+        "not_null"
+      ];
     case "boolean":
-      return ["equal_to", "not_null"];
+      return ["equal_to", "true", "false", "not_null"];
     default:
       return [
         "equal_to",
+        "in",
         "contains",
         "not_contains",
         "starts_with",
@@ -10501,16 +10549,26 @@ function defaultFilterOperators(scalarType) {
       ];
   }
 }
+function supportsDefaultFilterBy(scalarType) {
+  return ["string", "number", "boolean", "date"].includes(
+    String(scalarType || "").toLowerCase()
+  );
+}
 function normalizeFilterByInput(filterBy, scalarType) {
-  if (!filterBy) return null;
+  if (filterBy === false) return null;
+  if (filterBy === void 0) {
+    if (!supportsDefaultFilterBy(scalarType)) return null;
+    return { operators: defaultFilterOperators(scalarType), scalarType };
+  }
   if (filterBy === true) {
-    return { operators: defaultFilterOperators(scalarType) };
+    return { operators: defaultFilterOperators(scalarType), scalarType };
   }
   if (Array.isArray(filterBy)) {
-    return { operators: filterBy };
+    return { operators: filterBy, scalarType };
   }
   return {
-    operators: filterBy.operators
+    operators: filterBy.operators,
+    scalarType: filterBy.scalarType || scalarType
   };
 }
 function buildFilterByFieldMutations(fieldPath, filterBy, scalarType) {
@@ -10521,7 +10579,7 @@ function buildFilterByFieldMutations(fieldPath, filterBy, scalarType) {
       label: `set filterBy on ${fieldPath}`,
       query: `mutation { at(path: ${JSON.stringify(fieldPath)}) { set_filter_by(operators: ${JSON.stringify(
         normalized.operators
-      )}) { operators } } }`
+      )}${normalized.scalarType ? `, scalar_type: ${JSON.stringify(normalized.scalarType)}` : ""}) { operators } } }`
     }
   ];
 }
@@ -10531,7 +10589,7 @@ var filterByMetamodelPackage = defineMetamodelPackage({
     fieldRows: [
       {
         key: "filterBy",
-        description: "Exposes filter operators for generated query surfaces. Accepts `true`, an operator array, or `{ operators, scalarType }`."
+        description: "Exposes filter operators for generated query surfaces. Scalar fields are filterable by default; set `filterBy: false` to opt out, or override with `true`, an operator array, or `{ operators, scalarType }`."
       }
     ]
   },
@@ -10795,6 +10853,123 @@ var requiredMetamodelPackage = defineMetamodelPackage({
   }
 });
 
+// ../metamodel-searchable/src/index.ts
+function supportsDefaultSearchable(scalarType) {
+  return String(scalarType || "").toLowerCase() === "string";
+}
+function normalizeSearchableInput(searchable, scalarType) {
+  if (!supportsDefaultSearchable(scalarType)) return null;
+  if (typeof searchable === "boolean" || searchable === void 0) {
+    return {
+      enabled: searchable !== false,
+      phonetic: false
+    };
+  }
+  const enabled = searchable.enabled !== false;
+  return {
+    enabled,
+    phonetic: enabled && searchable.phonetic === true
+  };
+}
+function buildSearchableFieldMutations(fieldPath, searchable, scalarType) {
+  const normalized = normalizeSearchableInput(searchable, scalarType);
+  if (normalized === null) return [];
+  return [
+    {
+      label: `set searchable on ${fieldPath}`,
+      query: `mutation { at(path: ${JSON.stringify(fieldPath)}) { set_searchable(enabled: ${normalized.enabled}, phonetic: ${normalized.phonetic}) { enabled phonetic } } }`
+    }
+  ];
+}
+var searchableMetamodelPackage = defineMetamodelPackage({
+  id: "searchable",
+  docs: {
+    fieldRows: [
+      {
+        key: "searchable",
+        description: "Controls full-text search exposure for string fields. String fields are searchable by default; set `searchable: false` to opt out, or use `searchable: { phonetic: true }` to keep the field searchable while enabling FalkorDB phonetic matching for class-wide search."
+      }
+    ]
+  },
+  graphql: {
+    typeDefs: [
+      `
+      type SearchableMetamodel {
+        model: Model!
+        enabled: Boolean!
+        phonetic: Boolean!
+      }
+
+      extend type Model {
+        searchable: SearchableMetamodel
+      }
+
+      extend type ModelMutation {
+        set_searchable(enabled: Boolean!, phonetic: Boolean): SearchableMetamodel
+      }
+      `
+    ],
+    createResolvers({ run }) {
+      return {
+        SearchableMetamodel: {
+          model: (value) => value.model,
+          enabled: (value) => value.enabled !== false,
+          phonetic: (value) => value.phonetic === true
+        },
+        Model: {
+          searchable: async (ant) => await run(ant.searchable())
+        },
+        ModelMutation: {
+          set_searchable: async (ant, { enabled, phonetic }) => {
+            return {
+              model: await run(ant.set_searchable(enabled, phonetic === true)),
+              enabled,
+              phonetic: phonetic === true
+            };
+          }
+        }
+      };
+    }
+  },
+  manifest: {
+    buildFieldMutations(fieldPath, spec) {
+      return buildSearchableFieldMutations(
+        fieldPath,
+        spec.searchable,
+        spec.type
+      );
+    }
+  },
+  summary: {
+    selections: {
+      propertyFields: [`searchable { enabled phonetic }`]
+    },
+    readPropertySummary(rawProperty) {
+      if (typeof rawProperty.searchable?.enabled !== "boolean") {
+        return {};
+      }
+      return {
+        searchable: rawProperty.searchable.enabled,
+        searchablePhonetic: rawProperty.searchable.phonetic === true
+      };
+    }
+  },
+  domain: {
+    applyToPropertyIR(propertyIR, propertySummary) {
+      if (String(propertySummary.type || "").toLowerCase() !== "string" || propertySummary.searchable === false) {
+        return propertyIR;
+      }
+      return {
+        ...propertyIR,
+        docs: [
+          ...propertyIR.docs,
+          propertySummary.searchablePhonetic ? "Searchable via `search` using FalkorDB full-text query syntax with phonetic matching enabled." : "Searchable via `search` using FalkorDB full-text query syntax."
+        ]
+      };
+    }
+  }
+});
+
 // ../metamodel-state-machine/src/index.ts
 function normalizeStateMachines(values) {
   return (values || []).map((machine) => {
@@ -11375,6 +11550,7 @@ var DEFAULT_METAMODEL_PACKAGES = [
   requiredMetamodelPackage,
   enumMetamodelPackage,
   filterByMetamodelPackage,
+  searchableMetamodelPackage,
   validationRuleMetamodelPackage,
   stateMachineMetamodelPackage,
   effectBehaviorsMetamodelPackage