tpmkms_4wp 9.2.0 → 9.3.0-beta.0

package/common/fastfood.js

@@ -369,6 +369,7 @@ const template = {
       hierarchy: [
         ['meal', 'toAble'],
         ['drink', 'toAble'],
+        ['smoothie_modifier', 'sizeable'],
       ],
       bridges: [
         { 
@@ -433,6 +434,12 @@ const template = {
           }
         },
       ],
+      associations: {
+        positive: [
+          { context: [['combo', 0], ['integer', 0]], choose: 0 },
+          { context: [['combo', 0], ['integer', 1]], choose: 0 },
+        ],
+      },
     },
   ],
 }

package/common/formulas.instance.json

@@ -1203,6 +1203,7 @@
         }
       ],
       "learned_contextual_priorities": [],
+      "rtf_associations": [],
       "query": "formulas are concepts",
       "key": {
         "query": "formulas are concepts"

package/common/gdefaults.js

@@ -4,6 +4,7 @@ const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const tokenize = require('./tokenize.js')
 const gdefaults_tests = require('./gdefaults.test.json')
 const { getValue, isMany } = require('./helpers.js')
+const helpers = require('./helpers')
 
 const config = {
   name: 'gdefaults',
@@ -29,6 +30,13 @@ const config = {
       apply: ({context, gp}) => gp(context.response),
     },
 
+    {
+      where: where(),
+      match: ({context}) => context.paraphrase && context.interpolate,
+      apply: async ({interpolate, context}) => {
+        return interpolate(context.interpolate, context)
+      }
+    },
     {
       where: where(),
       match: ({context}) => context.generate,
@@ -232,6 +240,16 @@ const initializer = ({config}) => {
         verbatim: (text) => {
           args.insert({ marker: 'verbatim', verbatim: text, isResponse: true })
         },
+        interpolate: async (interpolate, context) => {
+          const evaluator = async (key) => {
+            if (Array.isArray(context[key])) {
+              return args.gsp(context[key])
+            } else {
+              return args.gp(context[key])
+            }
+          }
+          return await helpers.processTemplateString(interpolate, evaluator)
+        }
       }
     })
   }

package/common/helpers/concept.js

@@ -106,6 +106,7 @@ class API {
       level: 0, 
       convolution: true,
       isA: [{ parent: 'adjective', instance: true }],
+      associator_return_type: [modifiersObjectId, 0],
       // isA: ['adjective'],
       before: ['verb'],
       bridge: `{ ...after[0], ${modifierProperties}, atomic: true, dead: true, marker: next(operator('${modifiersObjectId}')), value: '${modifiersObjectId}', modifiers: append([${modifierList}], after[0].modifiers)}`, 

package/common/helpers/dialogues.js

@@ -83,6 +83,9 @@ class API {
       return context.value
     }
     */
+    if (typeof context == 'string') {
+      context = { word: context, value: context }
+    }
     const { word, value, number } = context;
     if (!value) {
       return

package/common/helpers/properties.js

@@ -548,8 +548,7 @@ class API {
 
   makeObject(args) {
 		const types = [ 'hierarchyAble', 'object', 'property' ];
-    const { config } = args;
-    return this._km("dialogues").api.makeObject({ ...args, types });
+    return args.km("dialogues").api.makeObject({ ...args, types: (args.types || []).concat(types) });
   }
 
   relation_add (relations) {
@@ -704,6 +703,7 @@ class API {
   }
 
   setProperty(object, property, value, has, skipHandler) {
+    // debugger
     if (!skipHandler) {
       const handler = this.propertiesFH.getHandler([object, property])
       if (handler) {
@@ -794,31 +794,6 @@ class API {
 
   learnWords(config, context) {
   }
-/*
-  ensureDefault(map, key, default) {
-    if (!this._objects[map][key]) {
-      this._objects[map][key] = default
-    }
-    return this._objects[map][key]
-  }
-
-  pushListNoDups(list, value) {
-    if (list.includes(value)) {
-      return
-    }
-    list.push(value)
-  }
-
-  ensureConcept(concept) {
-    ensureDefault(this.properties, concept, {})
-    ensureDefault(this.concepts, concept, [])
-  }
-
-  canDo(object, ability) {
-    this.ensureConcept(object)
-    this.pushListNoDups(this.ensureList('abilities', object), ability)
-  }
-*/
   isA(child, ancestor) {
     // return this._objects.parents[child].includes(parent);
     const todo = [child];

package/common/helpers.js

@@ -151,11 +151,39 @@ const toEValue = (context) => {
 	return context;
 }
 
+const defaultContextCheckValidify = (properties) => {
+  for (const value of properties) {
+    if (typeof value == 'string') {
+      continue
+    }
+    if (typeof value.property == 'string' && value.filter) {
+      continue
+    }
+    throw new Error("Expected the <checks> argument to defaultContextCheck to be a list of <property> or { property: <property>, filter: <checks> }. Where <property> is a string.")
+  }
+}
+
 const defaultContextCheckProperties = ['marker', 'text', 'verbatim', 'isResponse', { property: 'response', filter: ['marker', 'text', 'verbatim'] }] 
+
+const expand_checks = (properties) => {
+  const expanded = []
+  for (const property of properties) {
+    defaultContextCheckValidify(properties)
+    if (typeof property == 'string') {
+      expanded.push({ property, filter: defaultContextCheckProperties })
+    } else {
+      expanded.push({ property: property.property, filter: [...defaultContextCheckProperties, ...expand_checks(property.filter)] })
+    }
+  }
+  return expanded
+}
+
 const defaultContextCheck = (properties = []) => {
+  defaultContextCheckValidify(properties)
   return [
     ...defaultContextCheckProperties,
-    ...properties.map((property) => { return { property, filter: defaultContextCheckProperties } }),
+    // ...properties.map((property) => { return { property, filter: defaultContextCheckProperties } }),
+    ...expand_checks(properties),
     (object) => {
       if (typeof object.value == 'object') {
         return { property: 'value', filter: defaultContextCheckProperties }
@@ -220,7 +248,48 @@ const getValue = (propertyPath, object) => {
   return value
 }
 
+const processTemplateString = async (template, evaluate) => {
+  async function resolveWithCallback(strings, ...keys) {
+    // const resolvedValues = await Promise.all(keys.map(key => lookupVariable(key)));
+    const resolvedValues = await Promise.all(keys.map(async (key) => {
+      return await evaluate(key)
+    }))
+
+    let result = strings[0];
+    for (let i = 0; i < resolvedValues.length; i++) {
+      result += resolvedValues[i] + strings[(i + 1)*2];
+    }
+    return result;
+  }
+
+  async function processTemplateString(template) {
+    // Split the template into strings and keys
+    const parts = template.split(/(\${[^}]+})/g);
+    const strings = [];
+    const keys = [];
+    for (const part of parts) {
+      if (part.startsWith("${") && part.endsWith("}")) {
+        keys.push(part.slice(2, -1)); // Extract key (e.g., "name" from "${name}")
+        strings.push(""); // Placeholder for interpolation
+      } else {
+        strings.push(part);
+      }
+    }
+
+    // Ensure the strings array has one more element than keys
+    if (strings.length === keys.length) {
+      strings.push("");
+    }
+
+    // Pass to the tagged template function
+    return resolveWithCallback(strings, ...keys);
+  }
+
+  return await processTemplateString(template)
+}
+
 module.exports = {
+  processTemplateString,
   unshiftL,
   pushL,
   getValue,

package/common/hierarchy.js

@@ -246,14 +246,15 @@ const config = {
        
         return listable(context, 'hierarchyAble') && context.same && context.same.concept && !context.query
       },
-      apply: ({callId, config, objects, km, context, asList, listable}) => {
+      apply: (args) => {
+        const {callId, config, objects, km, context, asList, listable} = args
         const api = km('properties').api
         const oneConcepts = asList(context);
         const twoConcepts = asList(context.same);
         for (const oneConcept of oneConcepts.value) {
           for (const twoConcept of twoConcepts.value) {
-            oneConceptId = api.makeObject({config, context: oneConcept})
-            twoConceptId = api.makeObject({config, context: twoConcept})
+            oneConceptId = api.makeObject({...args, context: oneConcept})
+            twoConceptId = api.makeObject({...args, context: twoConcept})
             api.rememberIsA(oneConceptId, twoConceptId)
             context.sameWasProcessed = true
           }