tpmkms_4wp 8.0.0-beta.6 → 8.0.0-beta.61

package/common/helpers/properties.js

@@ -45,6 +45,10 @@ class API {
     }
 
     if (km('concept')) {
+      if (!km('concept').api) {
+        debugger
+        debugger
+      }
       km('concept').api.addDefaultTypesForObjectHierarchy([
         'theAble',
         'queryable',
@@ -136,7 +140,7 @@ class API {
       notes: 'semantic for setting value with constraint',
       match: ({context, isA}) => isA(context.marker, after[0].tag) && context.evaluate && context.constraints,
       // match: ({context, isA}) => context.marker == after[0].tag && context.evaluate,
-      apply: ({km, context, e, log, isA, s}) => {
+      apply: async ({km, context, e, log, isA}) => {
         const constraint = context.constraints[0];
         const value = constraint.constraint;
         let property = constraint.property;
@@ -151,7 +155,7 @@ class API {
         // value.greg = true
         // value.ownee.query = true
         value.query = true
-        let instance = e(value)
+        let instance = await e(value)
         if (instance.verbatim) {
           context.evalue = { verbatim: instance.verbatim }
           return
@@ -168,13 +172,13 @@ class API {
     config.addGenerator({
       notes: 'generator for constraint',
       match: ({context}) => context.marker == edAble.operator && context.paraphrase && context.constrained,
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         if (context[before[0].tag].marker == 'by') {
           // the cat wendy owned
-          return `${g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${g({...context[before[0].tag], paraphrase: true})}`
+          return `${await g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${await g({...context[before[0].tag], paraphrase: true})}`
         } else {
           // the cat owned by wendy
-          return `${g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${['by', g({...context[before[0].tag], paraphrase: true})].filter((t) => t).join(' ')}`
+          return `${await g({...context[after[0].tag], paraphrase: true})} ${edAble.word} ${['by', await g({...context[before[0].tag], paraphrase: true})].filter((t) => t).join(' ')}`
         }
       },
     })
@@ -194,19 +198,19 @@ class API {
 
         return false;
       },
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         const chosen = chooseNumber(context, word.singular, word.plural)
-        return `${g(context[before[0].tag])} ${chosen} ${g(context[after[0].tag])}`
+        return `${await g(context[before[0].tag])} ${chosen} ${await g(context[after[0].tag])}`
       }
     })
     config.addGenerator({
       match: ({context}) => context.marker == edAble.operator && context.isEd,
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         const chosen = chooseNumber(context[after[0].tag], 'is', 'are')
         if (context[before[0].tag].evalue && context[before[0].tag].evalue.marker == 'answerNotKnown') {
-          return g(context[before[0].tag])
+          return await g(context[before[0].tag])
         }
-        return `${g(context[after[0].tag])} ${chosen} ${edAble.word} by ${g(context[before[0].tag])}`
+        return `${await g(context[after[0].tag])} ${chosen} ${edAble.word} by ${await g(context[before[0].tag])}`
       }
     })
     /*
@@ -250,12 +254,10 @@ class API {
         notes: `generator for who/what is X owned by`,
         // match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.one && context.one.marker == 'ownee' && context.one.constraints && context.one.constraints[0] && context.one.constraints[0].constraint.marker == 'owned' && context.one.constraints[0].constraint.owner.implicit,
         match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.one && context.one.marker == after[0].tag && context.one.constraints && context.one.constraints[0] && context.one.constraints[0].constraint.marker == edAble.operator && context.one.constraints[0].constraint[before[0].tag].implicit,
-        apply: ({context, g, gs, callId}) => {
+        apply: async ({context, fragments, g, gs, callId}) => {
           const isToFromM = [{"from":["one"],"to":["two"]},{"from":["two"],"to":["one"]}]
-          const fromF = config.fragment(whoIsWhatVerbedBy).contexts()[0]
-          // const fromF = config.fragment[before[0].tag]"ownerVar is owneeVar owned by").contexts()[0]
-          // const toF = config.fragment("owneeVar is owned by ownerVar")
-          const toF = config.fragment(thisIsVerbedByThat)
+          const fromF = fragments(whoIsWhatVerbedBy).contexts()[0]
+          const toF = fragments(thisIsVerbedByThat)
           const to = toF.contexts()[0]
           const tm = translationMapping(fromF, to)
           /*
@@ -269,11 +271,11 @@ class API {
           // const from = context.one.constraints[0].constraint
           const from = context
           const im = translationMappingToInstantiatorMappings(tmPrime, from, to)
-          const translation = toF.instantiate(im)
+          const translation = await toF.instantiate(im)
           if (Array.isArray(translation)) {
-            return gs(translation)
+            return await gs(translation)
           } else {
-            return g(translation)
+            return await g(translation)
           }
         }
       }
@@ -383,11 +385,16 @@ class API {
     config.addGenerator({
       notes: 'ordering generator for paraphrase',
       match: ({context}) => context.marker == operator && context.paraphrase && !context.query,
-      apply: ({context, gp, g}) => {
-        const beforeGenerator = before.map( (arg) => g(context[arg.tag]) )
-        const afterGenerator = after.map( (arg) => gp(context[arg.tag]) )
+      apply: async ({context, gp, g}) => {
+        const beforeGenerator = []
+        for (const arg of before) {
+          beforeGenerator.push(await g(context[arg.tag]))
+        }
+        const afterGenerator = []
+        for (const arg of after) {
+          afterGenerator.push(await gp(context[arg.tag]))
+        }
         const word = context.word
-        // return beforeGenerator.concat([`${context.word}`]).concat(afterGenerator).join(' ')
         const sub = []
         if (context.subphrase) {
           sub.push(['that'])
@@ -399,7 +406,7 @@ class API {
     config.addGenerator({
       notes: 'ordering generator for response',
       match: ({context}) => context.marker == operator && context.evalue && context.isResponse,
-      apply: ({context, g, km}) => {
+      apply: async ({context, g, km}) => {
         const brief = km("dialogues").api.getBrief()
 
         const { evalue } = context 
@@ -414,7 +421,7 @@ class API {
         if (evalue.truthValueOnly || brief) {
           return `${yesno}`
         } else {
-          return `${yesno} ${g(Object.assign({}, evalue, { paraphrase: true }))}`
+          return `${yesno} ${await g(Object.assign({}, evalue, { paraphrase: true }))}`
         }
       }
     })
@@ -628,8 +635,8 @@ class API {
         setValue: ([object, property], value, has) => {
           return this.setProperty(object, property, value, has, true)
         },
-        getValue: ([object, property]) => {
-          return this.getPropertyDirectly(object, property)
+        getValue: async ([object, property]) => {
+          return await this.getPropertyDirectly(object, property)
         },
       })
     }
@@ -645,16 +652,18 @@ class API {
         error.code = 'ReadOnly'
         throw error
       },
-      getValue: ([object, property]) => {
-        return this.getPropertyDirectly(object, property)
+      getValue: async ([object, property]) => {
+        return await this.getPropertyDirectly(object, property)
       },
     })
     this.propertiesFH.setHandler(path, handler)
   }
 
-  getObject(object) {
+  /*
+  async getObject(object) {
     return this.propertiesFH.getValue([object])
   }
+  */
 
   getHandler(object, property) {
     return this.propertiesFH.getHandler([object, property])
@@ -671,34 +680,33 @@ class API {
     // return context.value
   }
 
-  getProperty(object, property, g) {
+  async getProperty(object, property, g) {
     object = this.toValue(object)
     property = this.toValue(property)
     const handler = this.propertiesFH.getHandler([object, property])
     if (handler) {
-      return handler.getValue([object, property])
+      return await handler.getValue([object, property])
     }
-    return this.getPropertyDirectly(object, property, g)
+    return await this.getPropertyDirectly(object, property, g)
   }
 
-  getPropertyDirectly(object, property, g) {
+  async getPropertyDirectly(object, property, g) {
     if (property == 'property') {
-      const objectProps = this.propertiesFH.getValue([object])
+      const objectProps = await this.propertiesFH.getValue([object])
       const values = []
       for (let key of Object.keys(objectProps)) {
         if (objectProps[key].has) {
-          // values.push(`${g(key)}: ${g({ ...objectProps[key].value, evaluate: true })}`)
-          values.push(`${g(key)}: ${g({ ...objectProps[key].value, paraphrase: true })}`)
+          values.push(`${await g(key)}: ${await g({ ...objectProps[key].value, paraphrase: true })}`)
         }
       }
       return { marker: 'list', value: values }
     } else {
-      return this.propertiesFH.getValue([object, property]).value
+      return (await this.propertiesFH.getValue([object, property])).value
     }
   }
 
-  hasProperty(object, property, has) {
-    return this.propertiesFH.getValue([object, property]).has
+  async hasProperty(object, property, has) {
+    return (await this.propertiesFH.getValue([object, property])).has
   }
 
   setProperty(object, property, value, has, skipHandler) {
@@ -726,7 +734,7 @@ class API {
     }
   }
 
-  knownObject(object) {
+  async knownObject(object) {
     if (object == 'property') {
       return object
     }
@@ -735,10 +743,10 @@ class API {
     }
     const path = [object]
     // return this.knownPropertyNew(path)
-    return this.propertiesFH.knownProperty(path)
+    return await this.propertiesFH.knownProperty(path)
   }
 
-  hasProperty(object, property) {
+  async hasProperty(object, property) {
     if (property == 'property') {
       return true;
     }
@@ -748,7 +756,7 @@ class API {
     const seen = [object];
     while (todo.length > 0) {
       const next = todo.pop();
-      if ((this.propertiesFH.getValue([next, property], false) || {}).has) {
+      if ((await this.propertiesFH.getValue([next, property], false) || {}).has) {
         return true
       }
       const parents = this._objects.parents[next] || [];
@@ -763,11 +771,11 @@ class API {
   }
 
   // NOT DONE
-  knownProperty(object, property) {
+  async knownProperty(object, property) {
     object = this.toValue(object)
     property = this.toValue(property)
     if (property == 'property') {
-      const objectProps = this.propertiesFH.getValue([object])
+      const objectProps = await this.propertiesFH.getValue([object])
       return !_.isEmpty(objectProps)
     }
 
@@ -776,7 +784,7 @@ class API {
     const seen = [object];
     while (todo.length > 0) {
       const next = todo.pop();
-      if ((this.propertiesFH.getValue([next, property], false) || {}).has) {
+      if ((await this.propertiesFH.getValue([next, property], false) || {}).has) {
         return true
       }
       const parents = this._objects.parents[next] || [];
@@ -911,22 +919,6 @@ class API {
 
   set config(config) {
     this._config = config
-    /*
-    const toJSON = (h) => {
-      if (h.child && h.parent) {
-        return h
-      } else {
-        return { child: h[0], parent: h[1] }
-      }
-    }
-    for (const tuple of [...config().config.hierarchy]) {
-      const h = toJSON(tuple);
-      // TODO should this notice development flag?
-      if (this.isOperator(h.child) && this.isOperator(h.parent)) {
-        this.rememberIsA(h.child, h.parent)
-      }
-    }
-    */
   }
 
   get config() {

package/common/helpers.js

@@ -131,12 +131,12 @@ const toEValue = (context) => {
 	return context;
 }
 
-const defaultContextProperties = ['marker', 'text', 'verbatim', 'isResponse'] 
+const defaultContextCheckProperties = ['marker', 'text', 'verbatim', 'isResponse', { property: 'response', filter: ['marker', 'text', 'verbatim'] }] 
 const defaultContextCheck = [
-  ...defaultContextProperties,
+  ...defaultContextCheckProperties,
   (object) => {
     if (typeof object.value == 'object') {
-      return { property: 'value', filter: defaultContextProperties }
+      return { property: 'value', filter: defaultContextCheckProperties }
     } else {
       return 'value'
     }
@@ -146,16 +146,17 @@ const defaultContextCheck = [
       return
     }
     if (typeof object.modifiers[0] == 'object') {
-      return { property: 'modifiers', filter: defaultContextProperties }
+      return { property: 'modifiers', filter: defaultContextCheckProperties }
     } else {
       return 'modifiers'
     }
   },
-  { property: 'modifiers', isPropertyList: true, filter: defaultContextProperties }
+  { property: 'modifiers', isPropertyList: true, filter: defaultContextCheckProperties }
 ]
 
 module.exports = {
   defaultContextCheck,
+  defaultContextCheckProperties,
 	toEValue,
   millisecondsUntilHourOfDay,
   indent,

package/common/hierarchy.js

@@ -1,4 +1,4 @@
-const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const properties = require('./properties')
 const hierarchy_tests = require('./hierarchy.test.json')
@@ -32,7 +32,7 @@ const getTypes = ( km, concept, instance ) => {
 
 // TODO the types of rank are x y z ....
 // TODO x is a kind of y
-let configStruct = {
+let config = {
   name: 'hierarchy',
   operators: [
     // "([hierarchyAble|])",
@@ -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);
@@ -288,23 +284,19 @@ let configStruct = {
   ]
 };
 
-const createConfig = () => {
-  const config = new Config(configStruct, module)
-  config.stop_auto_rebuild()
-  config.add(properties())
-  config.initializer( ({apis, hierarchy}) => {
+const initializer = ({apis, hierarchy}) => {
     apis('stm').addIsA( (child, parent) => {
       return hierarchy.isA(child, parent) 
     })
-  })
-  config.restart_auto_rebuild()
-  return config
-}
+  }
 
 knowledgeModule( { 
+  config,
+  includes: [properties],
+  initializer,
+
   module,
   description: 'hierarchy of objects',
-  createConfig,
   test: {
     name: './hierarchy.test.json',
     contents: hierarchy_tests,

package/common/javascript.js

@@ -1,9 +1,9 @@
-const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const dialogues = require('./dialogues')
 const javascript_tests = require('./javascript.test.json')
 
-let configStruct = {
+let config = {
   name: 'javascript',
   operators: [
     "((<let> ([variable|])) [assignment|] (value))",
@@ -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)}` 
       }
     },
   ],
@@ -60,22 +60,15 @@ let configStruct = {
   ],
 };
 
-const createConfig = () => {
-  const config = new Config(configStruct, module)
-  config.stop_auto_rebuild()
-  config.add(dialogues())
-
-  config.initializer( ({objects, uuid}) => {
+knowledgeModule( { 
+  config,
+  includes: [dialogues],
+  initializer: ({objects, uuid}) => {
     objects.variables = {}
-  })
-  config.restart_auto_rebuild()
-  return config
-}
+  },
 
-knowledgeModule( { 
   module,
   description: 'javascript interpreter',
-  createConfig,
   test: {
     name: './javascript.test.json',
     contents: javascript_tests,