ekms 8.0.0 → 8.1.0-beta.1

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',
@@ -81,7 +85,6 @@ class API {
         match: ({context}) => context[tm.to],
         apply: ({context}) => {
           // Object.assign(context[tm.to], from[tm.from])
-          // debugger;
           context[tm.to] = from[tm.from]
           if (context[tm.to]) {
             context[tm.to].instantiated = true
@@ -101,6 +104,7 @@ class API {
              localHierarchy,
              bridge: `{ 
                ...before, 
+               marker: '${after[0].tag}',
                constraints: [ 
                     { 
                        property: '${after[0].tag}', 
@@ -137,7 +141,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;
@@ -152,7 +156,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
@@ -169,13 +173,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(' ')}`
         }
       },
     })
@@ -195,19 +199,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])}`
       }
     })
     /*
@@ -251,12 +255,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)
           /*
@@ -270,11 +272,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)
           }
         }
       }
@@ -315,7 +317,12 @@ class API {
         allowDups: true,
       })
       // config.addOperator({ id: operator, level: 1, words: [operator] })
-      config.addBridge({ id: operator, level: 1, bridge: '{ ...next(operator) }', allowDups: true })
+      config.addBridge({ 
+        id: operator, 
+        level: 1, 
+        bridge: '{ ...next(operator) }', 
+        allowDups: true,
+      })
       config.addPriority({ "context": [['does', 0], [operator, 1], ], "choose": [0] })
       config.addPriority({ "context": [['doesnt', 0], [operator, 1], ], "choose": [0] })
       config.addPriority({ "context": [[operator, 0], ['does', 0], ], "choose": [0] })
@@ -323,14 +330,25 @@ class API {
     } else {
       config.addOperator({ pattern: `(${beforeOperators} [${operator}|] ${afterOperators})`, allowDups: true })
     }
- 
-    for (let argument of before.concat(after)) {
-      if (create.includes(argument.id)) {
-        // config.addHierarchy('unknown', argument.id)
-        // config.addHierarchy('what', argument.id)
-        // greg23 <<<<<<<<<<<< doing this
-        config.addHierarchy(argument.id, 'unknown')
-        config.addHierarchy(argument.id, 'what')
+
+    if (false) {
+      for (let argument of before.concat(after)) {
+        if (create.includes(argument.id)) {
+          // config.addHierarchy('unknown', argument.id)
+          // config.addHierarchy('what', argument.id)
+          // greg23 <<<<<<<<<<<< doing this
+          config.addHierarchy(argument.id, 'unknown')
+          config.addHierarchy(argument.id, 'what')
+        }
+      } 
+    } else {
+      for (let argument of before.concat(after)) {
+        if (create.includes(argument.id)) {
+          // config.addHierarchy(argument.id, 'unknown')
+          // config.addHierarchy(argument.id, 'what')
+          localHierarchy.push([argument.id, 'unknown'])
+          localHierarchy.push([argument.id, 'what'])
+        }
       }
     }
 
@@ -354,7 +372,13 @@ class API {
 
         const unflattenArgs = [ ...before.map( (arg) => arg.tag ), ...after.map( (arg) => arg.tag ) ] 
         const focusable = [ ...before.map( (arg) => arg.tag ), ...after.map( (arg) => arg.tag ) ] 
-        config.addBridge({ id: operator, level: 0, localHierarchy, bridge: `{ ... next(operator) ${doParams} ${beforeArgs} ${afterArgs}, unflatten: ${JSON.stringify(unflattenArgs)}, focusable: ${JSON.stringify(focusable)} }`, allowDups: true })
+        config.addBridge({ 
+          id: operator, 
+          level: 0, 
+          localHierarchy: [...localHierarchy, ['object', 'unknown']],
+          bridge: `{ ... next(operator) ${doParams} ${beforeArgs} ${afterArgs}, unflatten: ${JSON.stringify(unflattenArgs)}, focusable: ${JSON.stringify(focusable)} }`, 
+          allowDups: true 
+        })
         if (words.length > 0) {
           for (const word of words) {
             config.addWord(word, { id: operator, initial: `{ value: "${operator}" }` })
@@ -384,11 +408,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'])
@@ -400,7 +429,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 
@@ -415,7 +444,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 }))}`
         }
       }
     })
@@ -501,12 +530,6 @@ class API {
           for (let argument of context.focusable || []) {
             const value = api.toValue(context[argument])
             if (value) {
-              /*
-              if (value == 'cleo') {
-                debugger;
-                hierarchy.isA()
-              }
-              */
               const minimas = hierarchy.minima(context[argument].types)
               for (let type of minimas) {
                 if (config.exists(value)) {
@@ -635,8 +658,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)
         },
       })
     }
@@ -652,16 +675,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])
@@ -678,34 +703,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) {
-    if (property == 'properties') {
-      const objectProps = this.propertiesFH.getValue([object])
+  async getPropertyDirectly(object, property, g) {
+    if (property == 'property') {
+      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) {
@@ -733,8 +757,8 @@ class API {
     }
   }
 
-  knownObject(object) {
-    if (object == 'properties') {
+  async knownObject(object) {
+    if (object == 'property') {
       return object
     }
     if ((object || {}).value) {
@@ -742,11 +766,11 @@ class API {
     }
     const path = [object]
     // return this.knownPropertyNew(path)
-    return this.propertiesFH.knownProperty(path)
+    return await this.propertiesFH.knownProperty(path)
   }
 
-  hasProperty(object, property) {
-    if (property == 'properties') {
+  async hasProperty(object, property) {
+    if (property == 'property') {
       return true;
     }
 
@@ -755,7 +779,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] || [];
@@ -770,11 +794,12 @@ class API {
   }
 
   // NOT DONE
-  knownProperty(object, property) {
+  async knownProperty(object, property) {
     object = this.toValue(object)
     property = this.toValue(property)
-    if (property == 'properties') {
-      return true;
+    if (property == 'property') {
+      const objectProps = await this.propertiesFH.getValue([object])
+      return !_.isEmpty(objectProps)
     }
 
     // go up the hierarchy
@@ -782,7 +807,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] || [];
@@ -916,24 +941,7 @@ class API {
   }
 
   set config(config) {
-    debugger
     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

@@ -33,8 +33,8 @@ const getCount = (context) => {
   }
 }
 
-const words = (base, additional = {}) => {
-  return [{ word: pluralize.singular(base), number: 'one', ...additional }, { word: pluralize.plural(base), number: 'many', ...additional }]
+const words = (word, additional = {}) => {
+  return [{ word: pluralize.singular(word), number: 'one', ...additional }, { word: pluralize.plural(word), number: 'many', ...additional }]
 }
 
 const isMany = (context) => {
@@ -63,6 +63,12 @@ const isMany = (context) => {
   return false
 }
 
+const requiredArgument = (value, name) => {
+  if (!value) {
+    throw new Error(`${name} is a required argument`)
+  }
+}
+
 const chooseNumber = (context, one, many) => {
   if (isMany(context)) {
     return many;
@@ -131,31 +137,35 @@ const toEValue = (context) => {
 	return context;
 }
 
-const defaultContextProperties = ['marker', 'text', 'verbatim', 'isResponse'] 
-const defaultContextCheck = [
-  ...defaultContextProperties,
-  (object) => {
-    if (typeof object.value == 'object') {
-      return { property: 'value', filter: defaultContextProperties }
-    } else {
-      return 'value'
-    }
-  },
-  (object) => {
-    if (!Array.isArray(object.modifiers)) {
-      return
-    }
-    if (typeof object.modifiers[0] == 'object') {
-      return { property: 'modifiers', filter: defaultContextProperties }
-    } else {
-      return 'modifiers'
-    }
-  },
-  { property: 'modifiers', isPropertyList: true, filter: defaultContextProperties }
-]
+const defaultContextCheckProperties = ['marker', 'text', 'verbatim', 'isResponse', { property: 'response', filter: ['marker', 'text', 'verbatim'] }] 
+const defaultContextCheck = (properties = []) => {
+  return [
+    ...defaultContextCheckProperties,
+    ...properties.map((property) => { return { property, filter: defaultContextCheckProperties } }),
+    (object) => {
+      if (typeof object.value == 'object') {
+        return { property: 'value', filter: defaultContextCheckProperties }
+      } else {
+        return 'value'
+      }
+    },
+    (object) => {
+      if (!Array.isArray(object.modifiers)) {
+        return
+      }
+      if (typeof object.modifiers[0] == 'object') {
+        return { property: 'modifiers', filter: defaultContextCheckProperties }
+      } else {
+        return 'modifiers'
+      }
+    },
+    { property: 'modifiers', isPropertyList: true, filter: defaultContextCheckProperties }
+  ]
+}
 
 module.exports = {
   defaultContextCheck,
+  defaultContextCheckProperties,
 	toEValue,
   millisecondsUntilHourOfDay,
   indent,
@@ -167,4 +177,5 @@ module.exports = {
   words,
   propertyToArray,
   wordNumber,
+  requiredArgument,
 }

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|])",
@@ -52,6 +52,7 @@ let configStruct = {
     ['have', 'canBeDoQuestion'],
   ],
   priorities: [
+    { "context": [['isEd', 0], ['is', 0], ], "choose": [1] },
     { "context": [['a', 0], ['questionMark', 0], ['is', 0], ], "choose": [0] },
     // [['is', 0], ['hierarchyAble', 0]],
     // [['a', 0], ['is', 0], ['hierarchyAble', 0]],
@@ -61,7 +62,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 +73,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 +81,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 +104,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 +133,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 +148,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 +199,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 +267,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 +285,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,
@@ -312,7 +305,7 @@ knowledgeModule( {
     checks: {
       objects: ['children', 'concept', 'parents', 'properties'],
       checks: {
-            context: defaultContextCheck,
+            context: defaultContextCheck(),
           },
 
     },