ekms 8.0.0-beta.21 → 8.0.0-beta.23

package/common/hierarchy.js

@@ -61,7 +61,7 @@ let configStruct = {
       notes: 'what type is pikachu',
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.query && !['what'].includes(context.one.marker) && !['what'].includes(context.two.marker) && (context.one.query || context.two.query),
-      apply: ({context, hierarchy, km, log, e, s}) => {
+      apply: async ({context, hierarchy, km, log, e}) => {
         const one = context.one;
         const two = context.two;
         let concept, value;
@@ -72,7 +72,7 @@ let configStruct = {
           concept = two;
           value = one;
         }
-        let instance = e(value)
+        let instance = await e(value)
         if (instance.verbatim) {
           context.evalue = { verbatim: instance.verbatim }
           context.isResponse = true
@@ -80,9 +80,6 @@ let configStruct = {
         }
         instance = getTypes(km, concept, instance)
 
-        // instance.focusable = ['one', 'two']
-        // concept = JSON.parse(JSON.stringify(value)) 
-        // greg
         concept = _.cloneDeep(value)
         concept.isQuery = undefined
 
@@ -106,10 +103,10 @@ let configStruct = {
       notes: 'type of pikachu',  // the types of type is the next one
       where: where(),
       match: ({context}) => context.marker == 'type' && context.evaluate && context.object && context.objects[context.objects.length-1].number == 'one' && pluralize.isSingular(context.objects[0].word),
-      apply: ({context, objects, e, gs, km, log, s}) => {
+      apply: async ({context, objects, e, gs, km, log}) => {
         const concept = context.objects[0];
         const value = context.objects[1];
-        let instance = e(value)
+        let instance = await e(value)
         if (instance.verbatim) {
           context.evalue = { verbatim: instance.verbatim }
           return
@@ -135,14 +132,14 @@ let configStruct = {
         }
         return hierarchy.isA(context.marker, 'is') && context.query && args( { types: ['hierarchyAble', 'hierarchyAble'], properties: ['one', 'two'] } )
       },
-      apply: ({context, km, objects, g}) => {
+      apply: async ({context, km, objects, g}) => {
         const api = km('properties').api
         const one = context.one
         const two = context.two
         const oneId = pluralize.singular(one.value);
         if (!api.conceptExists(oneId)) {
           context.evalue = {
-            verbatim: `I don't know about ${g({ ...one, paraphrase: true})}` 
+            verbatim: `I don't know about ${await g({ ...one, paraphrase: true})}` 
           }
           context.isResponse = true
           return
@@ -150,7 +147,7 @@ let configStruct = {
         const twoId = pluralize.singular(two.value);
         if (!api.conceptExists(twoId)) {
           context.evalue = {
-            verbatim: `I don't know about ${g({ ...two, paraphrase: true})}` 
+            verbatim: `I don't know about ${await g({ ...two, paraphrase: true})}` 
           }
           context.isResponse = true
           return
@@ -201,7 +198,6 @@ let configStruct = {
     },
     {
       notes: 'humans are mammels',
-      // match: ({context, listable}) => listable(context, 'unknown') && context.same,
       where: where(),
       match: ({context, listable, hierarchy, isA, callId}) => {
         if (!context.same) {
@@ -270,7 +266,7 @@ let configStruct = {
       notes: 'types of type', // what are the types of animals
       where: where(),
       match: ({context}) => context.marker == 'type' && context.evaluate && context.object,
-      apply: ({context, objects, gs, km, isA}) => {
+      apply: ({context, objects, km, isA}) => {
         const api = km('properties').api
         const conceptApi = km('concept').api
         const type = pluralize.singular(context.object.value);
@@ -292,7 +288,7 @@ const createConfig = async () => {
   const config = new Config(configStruct, module)
   config.stop_auto_rebuild()
   await config.add(properties)
-  config.initializer( ({apis, hierarchy}) => {
+  await config.initializer( ({apis, hierarchy}) => {
     apis('stm').addIsA( (child, parent) => {
       return hierarchy.isA(child, parent) 
     })

package/common/javascript.js

@@ -36,14 +36,14 @@ let configStruct = {
     { 
       where: where(),
       match: ({context}) => context.marker == 'assignment' && context.paraphrase, 
-      apply: ({context, g}) => `let ${g(context.variable)} = ${g(context.value)}` 
+      apply: async ({context, g}) => `let ${await g(context.variable)} = ${await g(context.value)}` 
     },
     { 
       where: where(),
       match: ({context}) => context.marker == 'assignment' && context.isResponse, 
-      apply: ({context, g}) => {
-        const value = g(context.variable)
-        return `${g(context.variable)} == ${g(context.value)}` 
+      apply: async ({context, g}) => {
+        // const value = await g(context.variable)
+        return `${await g(context.variable)} == ${await g(context.value)}` 
       }
     },
   ],
@@ -65,7 +65,7 @@ const createConfig = async () => {
   config.stop_auto_rebuild()
   await config.add(dialogues)
 
-  config.initializer( ({objects, uuid}) => {
+  await config.initializer( ({objects, uuid}) => {
     objects.variables = {}
   })
   await config.restart_auto_rebuild()

package/common/math.instance.json

@@ -77,7 +77,7 @@
             "plus",
             "+"
           ],
-          "generatorp": "({gp, context}) => context.word"
+          "generatorp": "({context}) => context.word"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/math.js:44",
@@ -87,8 +87,8 @@
           "isA": [
             "mathematicalExpression"
           ],
-          "generatorp": "({gp, context}) => `${gp(context.x)} ${context.word} ${gp(context.y)}`",
-          "evaluator": "({e, context}) => {\n        const x = toValue(e(context.x)) \n        const y = toValue(e(context.y))\n        if (!x || !y) {\n          // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }\n          context.isResponse = false\n        } else {\n          context.evalue = apply(x, y)\n          context.evalue.isResponse = true\n          context.evalue.paraphrase = false\n          // context.paraphrase = false\n          // context.isResponse = true\n        }\n        /*\n        if (!context.value) {\n          context.isResponse = false\n          context.paraphrase = true\n        }\n        */\n      }"
+          "generatorp": "async ({gp, context}) => `${await gp(context.x)} ${context.word} ${await gp(context.y)}`",
+          "evaluator": "async ({e, context}) => {\n        const x = toValue(await e(context.x)) \n        const y = toValue(await e(context.y))\n        if (!x || !y) {\n          // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }\n          context.isResponse = false\n        } else {\n          context.evalue = apply(x, y)\n          context.evalue.isResponse = true\n          context.evalue.paraphrase = false\n          // context.paraphrase = false\n          // context.isResponse = true\n        }\n        /*\n        if (!context.value) {\n          context.isResponse = false\n          context.paraphrase = true\n        }\n        */\n      }"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/math.js:32",
@@ -109,7 +109,7 @@
             "minus",
             "-"
           ],
-          "generatorp": "({gp, context}) => context.word"
+          "generatorp": "({context}) => context.word"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/math.js:44",
@@ -119,8 +119,8 @@
           "isA": [
             "mathematicalExpression"
           ],
-          "generatorp": "({gp, context}) => `${gp(context.x)} ${context.word} ${gp(context.y)}`",
-          "evaluator": "({e, context}) => {\n        const x = toValue(e(context.x)) \n        const y = toValue(e(context.y))\n        if (!x || !y) {\n          // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }\n          context.isResponse = false\n        } else {\n          context.evalue = apply(x, y)\n          context.evalue.isResponse = true\n          context.evalue.paraphrase = false\n          // context.paraphrase = false\n          // context.isResponse = true\n        }\n        /*\n        if (!context.value) {\n          context.isResponse = false\n          context.paraphrase = true\n        }\n        */\n      }"
+          "generatorp": "async ({gp, context}) => `${await gp(context.x)} ${context.word} ${await gp(context.y)}`",
+          "evaluator": "async ({e, context}) => {\n        const x = toValue(await e(context.x)) \n        const y = toValue(await e(context.y))\n        if (!x || !y) {\n          // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }\n          context.isResponse = false\n        } else {\n          context.evalue = apply(x, y)\n          context.evalue.isResponse = true\n          context.evalue.paraphrase = false\n          // context.paraphrase = false\n          // context.isResponse = true\n        }\n        /*\n        if (!context.value) {\n          context.isResponse = false\n          context.paraphrase = true\n        }\n        */\n      }"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/math.js:32",
@@ -150,7 +150,7 @@
             "times",
             "*"
           ],
-          "generatorp": "({gp, context}) => context.word"
+          "generatorp": "({context}) => context.word"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/math.js:44",
@@ -160,8 +160,8 @@
           "isA": [
             "mathematicalExpression"
           ],
-          "generatorp": "({gp, context}) => `${gp(context.x)} ${context.word} ${gp(context.y)}`",
-          "evaluator": "({e, context}) => {\n        const x = toValue(e(context.x)) \n        const y = toValue(e(context.y))\n        if (!x || !y) {\n          // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }\n          context.isResponse = false\n        } else {\n          context.evalue = apply(x, y)\n          context.evalue.isResponse = true\n          context.evalue.paraphrase = false\n          // context.paraphrase = false\n          // context.isResponse = true\n        }\n        /*\n        if (!context.value) {\n          context.isResponse = false\n          context.paraphrase = true\n        }\n        */\n      }"
+          "generatorp": "async ({gp, context}) => `${await gp(context.x)} ${context.word} ${await gp(context.y)}`",
+          "evaluator": "async ({e, context}) => {\n        const x = toValue(await e(context.x)) \n        const y = toValue(await e(context.y))\n        if (!x || !y) {\n          // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }\n          context.isResponse = false\n        } else {\n          context.evalue = apply(x, y)\n          context.evalue.isResponse = true\n          context.evalue.paraphrase = false\n          // context.paraphrase = false\n          // context.isResponse = true\n        }\n        /*\n        if (!context.value) {\n          context.isResponse = false\n          context.paraphrase = true\n        }\n        */\n      }"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/math.js:32",
@@ -190,7 +190,7 @@
           "words": [
             "/"
           ],
-          "generatorp": "({gp, context}) => context.word"
+          "generatorp": "({context}) => context.word"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/math.js:44",
@@ -200,8 +200,8 @@
           "isA": [
             "mathematicalExpression"
           ],
-          "generatorp": "({gp, context}) => `${gp(context.x)} ${context.word} ${gp(context.y)}`",
-          "evaluator": "({e, context}) => {\n        const x = toValue(e(context.x)) \n        const y = toValue(e(context.y))\n        if (!x || !y) {\n          // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }\n          context.isResponse = false\n        } else {\n          context.evalue = apply(x, y)\n          context.evalue.isResponse = true\n          context.evalue.paraphrase = false\n          // context.paraphrase = false\n          // context.isResponse = true\n        }\n        /*\n        if (!context.value) {\n          context.isResponse = false\n          context.paraphrase = true\n        }\n        */\n      }"
+          "generatorp": "async ({gp, context}) => `${await gp(context.x)} ${context.word} ${await gp(context.y)}`",
+          "evaluator": "async ({e, context}) => {\n        const x = toValue(await e(context.x)) \n        const y = toValue(await e(context.y))\n        if (!x || !y) {\n          // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }\n          context.isResponse = false\n        } else {\n          context.evalue = apply(x, y)\n          context.evalue.isResponse = true\n          context.evalue.paraphrase = false\n          // context.paraphrase = false\n          // context.isResponse = true\n        }\n        /*\n        if (!context.value) {\n          context.isResponse = false\n          context.paraphrase = true\n        }\n        */\n      }"
         }
       ]
     }

package/common/math.js

@@ -38,17 +38,17 @@ const mathematicalOperator = (name, words, apply, before = []) => [
       localHierarchy: [ ['unknown', 'number'] ],
       // levelSpecificHierarchy: [[1, 'mathematicalExpression']],
       words,
-      generatorp: ({gp, context}) => context.word,
+      generatorp: ({context}) => context.word,
   },
   { 
       where: where(),
       id: `${name}Expression`, level: 0, 
       bridge: "{ ...next(operator) }" ,
       isA: ['mathematicalExpression'],
-      generatorp: ({gp, context}) => `${gp(context.x)} ${context.word} ${gp(context.y)}`,
-      evaluator: ({e, context}) => {
-        const x = toValue(e(context.x)) 
-        const y = toValue(e(context.y))
+      generatorp: async ({gp, context}) => `${await gp(context.x)} ${context.word} ${await gp(context.y)}`,
+      evaluator: async ({e, context}) => {
+        const x = toValue(await e(context.x)) 
+        const y = toValue(await e(context.y))
         if (!x || !y) {
           // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }
           context.isResponse = false

package/common/meta.js

@@ -130,8 +130,8 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker == 'orList' && context.paraphrase,
-      apply: ({context, gs}) => {
-        return gs(context.value, ', ', ' or ')
+      apply: async ({context, gs}) => {
+        return await gs(context.value, ', ', ' or ')
       },
       priority: -1,
     },
@@ -139,10 +139,8 @@ let configStruct = {
       priority: -1,
       where: where(),
       match: ({context}) => context.marker == 'means' && context.paraphrase,
-      apply: ({context, g}) => {
-        // const before = g({ ...context.from, paraphrase: true, debug: true})
-        const before = g({ ...context.from, paraphrase: true})
-        return `${g({ ...context.from, paraphrase: true})} means ${g(context.to)}`
+      apply: async ({context, g}) => {
+        return `${await g({ ...context.from, paraphrase: true})} means ${await g(context.to)}`
       }
     },
     { 
@@ -160,8 +158,8 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker === 'if',
-      apply: ({context, g}) => {
-        return `if ${g(context.antecedant)} then ${g(context.consequence)}`
+      apply: async ({context, g}) => {
+        return `if ${await g(context.antecedant)} then ${await g(context.consequence)}`
       },
       priority: -1,
     },
@@ -182,10 +180,10 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker == 'orList',
-      apply: ({context, s}) => {
+      apply: async ({context, s}) => {
         const response = []
         for (const value of context.value) {
-          response.push(s(value))
+          response.push(await s(value))
         }
         context.evalue = {
           marker: 'orList', 
@@ -205,7 +203,7 @@ let configStruct = {
           const apply = (DEFINITIONs, DERIVED) => {
             const mappingss = translationMappings(DEFINITIONs, DERIVED)
             const invertMappings = (mappings) => mappings.map( ({ from, to }) => { return { to: from, from: to } } )
-            return ({context, s, g, config}) => { 
+            return async ({context, s, config}) => { 
               DEFINITIONs = _.cloneDeep(DEFINITIONs)
               //const mappings = mappingss[0]
               let toPrimes = []
@@ -215,8 +213,7 @@ let configStruct = {
                 }
                 // next move add debug arg to s and g
                 TO.query = true
-                toPrimes.push([s(TO), mappings])
-                // toPrime = s(TO, { debug: { apply: true } })
+                toPrimes.push([await s(TO), mappings])
               }
 
               let hasResponse = false
@@ -271,7 +268,7 @@ let configStruct = {
             // match: match(context), 
             where: where(),
             match: match(context),
-            apply: apply(antecedants, _.cloneDeep(context.consequence)) ,
+            apply: apply(antecedants, _.cloneDeep(context.consequence)),
           }
           config.addSemantic(semantic)
       }
@@ -280,17 +277,14 @@ let configStruct = {
       notes: 'from means to where from is unknown',
       where: where(),
       match: ({context}) => context.marker == 'means' && context.from.marker == 'unknown',
-      apply: ({config, context, kms, e, isTest}) => {
+      apply: async ({config, context, kms, e, isTest}) => {
         if (false && isTest) {
           return
         } else if (kms.dialogues) {
           if (context.to.value) {
             kms.stm.api.setVariable(context.from.value, context.to.value)
           } else {
-            // config.addWord(context.from.word, 
             kms.dialogues.api.makeObject({ context: context.from, types: context.to.types || [], config });
-            // kms.dialogues.api.makeObject({ context: context.from, types: [], config });
-            // const r = e(context.to)
             kms.stm.api.setVariable(context.from.value, context.to)
           }
         }
@@ -300,17 +294,17 @@ let configStruct = {
       notes: 'x means y where x and y have known markers',
       where: where(),
       match: ({context}) => context.marker == 'means',
-      apply: ({config, context, g}) => {
+      apply: async ({config, context, g}) => {
         // setup the write semantic
         {
           const matchByMarker = (defContext) => ({context}) => context.marker == defContext.from.marker && !context.query && !context.objects
           const matchByValue = (defContext) => ({context}) => context.evalue == defContext.from.value && !context.query && !context.objects
-          const apply = (mappings, TO) => ({context, s}) => {
+          const apply = (mappings, TO) => async ({context, s}) => {
             TO = _.cloneDeep(TO)
             for (let { from, to } of mappings) {
               hashIndexesSet(TO, to, hashIndexesGet(context, from))
             }
-            toPrime = s(TO)
+            toPrime = await s(TO)
             context.result = toPrime.result
           }
           const mappings = translationMapping(context.from, context.to)
@@ -332,7 +326,7 @@ let configStruct = {
         {
           const matchByMarker = (defContext) => ({context, uuid}) => context.marker == defContext.from.marker && (context.query || context.evaluate) && !context[`disable${uuid}`]
           const matchByValue = (defContext) => ({context, uuid}) => context.value == defContext.from.value && (context.query || context.evaluate) && !context[`disable${uuid}`]
-          const apply = (mappings, TO) => ({uuid, context, s, g, config}) => {
+          const apply = (mappings, TO) => async ({uuid, context, s, g, config}) => {
             TO = _.cloneDeep(TO)
             for (let { from, to } of mappings) {
               hashIndexesSet(TO, to, hashIndexesGet(context, from))
@@ -345,8 +339,7 @@ let configStruct = {
               TO.evaluate = context.evaluate
             }
             TO[`disable${uuid}`] = true
-            // toPrime = s(TO, { debug: { apply: true } })
-            toPrime = s(TO)
+            toPrime = await s(TO)
             if (context.query) {
               if (toPrime.evalue) {
                 context.evalue = toPrime.evalue
@@ -359,7 +352,7 @@ let configStruct = {
           }
           const mappings = translationMapping(context.from, context.to)
           let match = matchByMarker(context)
-          context.metaInfo = `The mapping from from the expression being defined "${g({...context.from, paraphrase: true})}" to the definition phrase "${g({...context.to, paraphrase: true})}" is ${JSON.stringify(mappings)}`
+          context.metaInfo = `The mapping from from the expression being defined "${await g({...context.from, paraphrase: true})}" to the definition phrase "${await g({...context.to, paraphrase: true})}" is ${JSON.stringify(mappings)}`
           if (context.from.value) {
             match = matchByValue(context)
           }
@@ -383,7 +376,7 @@ const createConfig = async () => {
   config.stop_auto_rebuild()
   await config.add(gdefaults)
 
-  config.initializer( ({config, addGenerator, isModule}) => {
+  await config.initializer( ({config, addGenerator, isModule}) => {
     if (!isModule) {
       addGenerator({
         where: where(),

package/common/ordering.js

@@ -39,7 +39,7 @@ const createConfig = async () => {
   await config.add(hierarchy)
 // config.load(template, ordering_instance)
 
-  config.initializer(({config, km}) => {
+  await config.initializer(({config, km}) => {
     const oapi = km('ordering').api
     oapi.createOrdering({ name: 'preference', categories: [ ['love', 'like'], ['hate', 'dislike'] ], ordering: [ ['love', 'like'], ['like', 'dislike'], ['dislike', 'hate'] ] })
     const papi = km('properties').api

package/common/people.js

@@ -49,7 +49,7 @@ const createConfig = async () => {
   const config = new Config(configStruct, module)
   config.stop_auto_rebuild()
   await config.add(hierarchy)
-  config.initializer( ({baseConfig, context, apis, isModule}) => {
+  await config.initializer( ({baseConfig, context, apis, isModule}) => {
     // const api = km('properties').api
     const api = apis('properties')
     // setup paraphrase
@@ -65,7 +65,6 @@ const createConfig = async () => {
               edAble: { operator: 'owned', word: 'owned' },
               config: baseConfig
             })
-
   })
   await config.restart_auto_rebuild()
   return config

package/common/percentages.js

@@ -20,9 +20,9 @@ let configStruct = {
       id: "percentageOf", 
       words: ['percent', '%'],
       bridge: "{ ...next(operator), percentage: before[0], isResponse: true, semanticIsEvaluate: true, value: after[0] }",
-      evaluator: ({context, e}) => {
+      evaluator: async ({context, e}) => {
         const scale = context.percentage.scale
-        const number = e(context.value)
+        const number = await e(context.value)
         const percentage = number.value * scale.value / 100
         const result = { ...number, value: percentage, word: null, text: null }
         context.evalue = result