@granular-software/sdk 0.4.25 → 0.4.27

package/dist/cli/index.js

@@ -13114,10 +13114,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(),
@@ -13210,12 +13215,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),
@@ -13303,7 +13314,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(
@@ -13313,7 +13328,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);
@@ -13361,6 +13380,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;
@@ -13372,9 +13395,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 toPascalCase2(value) {
@@ -13777,12 +13802,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",
@@ -13791,16 +13824,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) {
@@ -13811,7 +13854,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 } } }`
     }
   ];
 }
@@ -13821,7 +13864,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 }`."
       }
     ]
   },
@@ -14085,6 +14128,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) => {
@@ -14665,6 +14825,7 @@ var DEFAULT_METAMODEL_PACKAGES = [
   requiredMetamodelPackage,
   enumMetamodelPackage,
   filterByMetamodelPackage,
+  searchableMetamodelPackage,
   validationRuleMetamodelPackage,
   stateMachineMetamodelPackage,
   effectBehaviorsMetamodelPackage
@@ -14838,6 +14999,7 @@ Scalar fields can carry lightweight metamodels directly in their field spec:
       "type": "string",
       "required": true,
       "note": "Must use the canonical prefix",
+      "searchable": { "phonetic": true },
       "filterBy": true,
       "validate": [
         { "operator": "regex", "stringValue": "^TKT-[A-Z0-9-]+$" }
@@ -14858,11 +15020,24 @@ Scalar fields can carry lightweight metamodels directly in their field spec:
         { "operator": "gt", "numberValue": 0 },
         { "operator": "lt", "numberValue": 100 }
       ]
+    },
+    "internal_code": {
+      "type": "string",
+      "description": "Opaque implementation detail",
+      "searchable": false,
+      "filterBy": false
     }
   }
 }
 \`\`\`
 
+Scalar fields are filterable by default. Set \`"filterBy": false\` only when a field should not appear in generated filter surfaces.
+String fields are searchable by default. Set \`"searchable": false\` only when a field should be excluded from generated full-text search surfaces and heavy full-text indexes.
+\`search\` is broad class-wide retrieval across all searchable string fields of a class. It is not a field-scoped operator. Use \`filter\` for exact field-specific constraints, and combine \`search\` + \`filter\` when you need both flexible text matching and exact structure.
+Runtime note: class-wide \`search\` is implemented as one denormalized full-text search document per class instance, built from that instance's searchable string fields. Exact field constraints still belong in \`filter\`.
+Optional indexing note: \`"searchable": { "phonetic": true }\` keeps the field searchable and enables FalkorDB phonetic matching for the class-wide search index. Query syntax does not change; agents should keep using normal \`search\` strings.
+Without an explicit sort, indexed \`search\` results are returned in FalkorDB relevance order. If you pass a sort, that explicit sort takes precedence.
+
 Supported field metamodel keys:
 
 ${fieldMetamodelTable}
@@ -18203,6 +18378,22 @@ var Session = class {
       }
     };
   }
+  stringifyConversationValue(value) {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "boolean") {
+      return value ? "Confirmed" : "Canceled";
+    }
+    if (value === void 0) {
+      return "";
+    }
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
   // --- Public API ---
   get document() {
     return this.client.doc;
@@ -18353,6 +18544,20 @@ var Session = class {
       answer: resolvedAnswer,
       value: resolvedAnswer
     });
+    try {
+      const content = this.stringifyConversationValue(resolvedAnswer);
+      if (content.trim()) {
+        await this.appendConversationMessage({
+          role: "user",
+          content,
+          promptId
+        });
+      }
+    } catch {
+    }
+  }
+  async appendConversationMessage(input) {
+    return this.client.call("conversation.append", input);
   }
   /**
    * Get the current list of available effects.
@@ -18492,9 +18697,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);