tpmkms_4wp 9.5.1 → 9.6.0-beta.0

package/common/helpers/properties.js

@@ -1,14 +1,33 @@
 const pluralize = require('pluralize')
+const { conjugateVerb } = require('../english_helpers')
 const { unflatten, flattens, Digraph } = require('../runtime').theprogrammablemind
 const _ = require('lodash')
 const deepEqual = require('deep-equal')
-const { chooseNumber } = require('../helpers.js')
+const { chooseNumber, removeProp } = require('../helpers.js')
 const { Frankenhash } = require('./frankenhash.js')
 const { compose, translationMapping, translationMappingToInstantiatorMappings } = require('./meta.js')
 
 class API {
   constructor() {
     this.digraph = new Digraph()
+    this.hierarchyWatchers = []
+  }
+
+  addHierarchyWatcher(watcher) {
+    this.hierarchyWatchers.push(watcher)
+  }
+
+  removeHierarchyWatcher(watcher) {
+    this.hierarchyWatchers = this.hierarchyWatchers.filter((w) => w.id == watcher.id)
+  }
+
+  seenHierarchyWatcher(watcherArgs) {
+    const args = { ...this.args, ...watcherArgs }
+    for (const { match, apply } of this.hierarchyWatchers) {
+      if (match(args)) {
+        apply(args)
+      }
+    }
   }
 
   initialize({ km, objects, config }) {
@@ -28,7 +47,7 @@ class API {
     this._km = km
     this.__config = config
     this.digraph = new Digraph()
-    const toJSON = (h) => {
+    function toJSON(h) {
       if (h.child && h.parent) {
         return h
       } else {
@@ -228,8 +247,8 @@ class API {
         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: async ({context, fragments, g, gs, callId}) => {
           const isToFromM = [{"from":["one"],"to":["two"]},{"from":["two"],"to":["one"]}]
-          const fromF = fragments(whoIsWhatVerbedBy).contexts()[0]
-          const toF = fragments(thisIsVerbedByThat)
+          const fromF = (await fragments(whoIsWhatVerbedBy)).contexts()[0]
+          const toF = await fragments(thisIsVerbedByThat)
           const to = toF.contexts()[0]
           const tm = translationMapping(fromF, to)
           /*
@@ -263,12 +282,35 @@ class API {
   // relation -> the semantics will be implements using relations
   // edable: "y is owned by x" edable = { operator: 'owned' }
   createActionPrefix(args, semanticApply) {
-    const { operator, before=[], after=[], create=[], config, localHierarchy=[], relation, ordering, doAble, words = [], unflatten:unflattenArgs = [], focusable = [], edAble } = args;
-    // const before = [...]
-    // const after = [{tag: 'weapon', id: 'weapon'}]
-    // const create = ['arm', 'weapon']
+    const { 
+      operator, 
+      before=[], 
+      after=[], 
+      create:createInit=[], 
+      hierarchy=[], 
+      config, 
+      localHierarchy=[], 
+      relation, 
+      ordering, 
+      doAble, 
+      flatten,
+      can,
+      words = [], 
+      unflatten:unflattenArgs = [], 
+      focusable = [], 
+      edAble } = args;
+
+    function createToCanonical(concept) {
+      if (typeof concept == 'string') {
+        return { id: concept, isA: [] }
+      } else {
+        return { isA: [], ...concept }
+      }
+    }
 
-   if (doAble) {
+    const create = createInit.map(createToCanonical)
+
+    if (doAble) {
       if (before.length != 1) {
         throw "Expected exactly one before argument"
       }
@@ -287,7 +329,6 @@ class API {
         pattern: `([(${beforeOperators} [${operator}|] ${afterOperators}^)])`, 
         allowDups: true,
       })
-      // config.addOperator({ id: operator, level: 1, words: [operator] })
       config.addBridge({ 
         id: operator, 
         level: 1, 
@@ -307,7 +348,6 @@ class API {
         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')
         }
@@ -323,9 +363,9 @@ class API {
       }
     }
 
-    create.map( (id) => {
+    create.map( ({ id, isA }) => {
       if (id === operator) {
-        const tagsToProps = (where, args, suffix='') => {
+        function tagsToProps(where, args, suffix='') {
           const i = 0;
           let r = ''
           for (const arg of args) {
@@ -341,13 +381,30 @@ class API {
           afterArgs = tagsToProps('after', after, '*')
         }
 
+        // const subjectContext = before[0].tag
+        // const interpolate = "[" + before.map((arg) => `{ property: '${arg.tag}' }`).concat(`{ ...operator, evaluateWord: true, number: ${subjectContext}.number }`).concat(after.map((arg) => `{ property: '${arg.tag}' }`)).join(',') + "]"
+        const imperative = (before.length == 0) ? "true" : "false"
+        // const interpolate = "[" + before.map((arg) => `{ property: '${arg.tag}' }`).concat(`{ ...operator, evaluateWord: true, imperative: ${imperative}, isVerb: true, number: 'one' }`).concat(after.map((arg) => `{ property: '${arg.tag}' }`)).join(',') + "]"
+        // const interpolateVerb = `{ property: "operator", context: { evaluateWord: true, imperative: ${imperative}, isVerb: true, number: 'one' } }`
+        let interpolateVerb
+        if (before.length > 0) {
+          interpolateVerb = `{ property: "operator", number: '${before[0].tag}' }`
+        } else {
+          interpolateVerb = `{ property: "operator" }`
+        }
+        const interpolate = "[" + before.map((arg) => `{ property: '${arg.tag}' }`).concat(interpolateVerb).concat(after.map((arg) => `{ property: '${arg.tag}' }`)).join(',') + "]"
+
         const unflattenArgs = [ ...before.map( (arg) => arg.tag ), ...after.map( (arg) => arg.tag ) ] 
         const focusable = [ ...before.map( (arg) => arg.tag ), ...after.map( (arg) => arg.tag ) ] 
+        let flattenProperty = ''
+        if (flatten) {
+          flattenProperty = ", flatten: true, relation: 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)} }`, 
+          bridge: `{ ... next(operator) ${flattenProperty} ${doParams} ${beforeArgs} ${afterArgs}, operator: { ...operator, evaluateWord: true, imperative: ${imperative}, isVerb: true, number: 'one' }, unflatten: ${JSON.stringify(unflattenArgs)}, focusable: ${JSON.stringify(focusable)}, interpolate: ${interpolate} }`, 
           allowDups: true 
         })
         if (words.length > 0) {
@@ -360,13 +417,30 @@ class API {
       } else {
         config.addBridge({ id: id, allowDups: true })
       }
+
+      for (const parentId of isA) {
+        config.addHierarchy(id, parentId)
+      }
     })
 
     if (words.length == 0) {
+      const createDef = createInit.find((def) => def.id == operator)
+      if (createDef && createDef.infinitive) {
+        const conjugation = conjugateVerb(createDef.infinitive)
+        if (can) {
+          const def = conjugation.find((def) => def.form == "pastParticiple")
+          config.addWord(def.word, { id: operator, initial: `{ value: '${operator}', isVerb: true, tense: '${def.tense}' }`})
+        }
+      }
+
       const operatorPlural = pluralize.singular(operator)
       const operatorSingular = pluralize.plural(operator)
-      config.addWord(operatorSingular, { id: operator, initial: `{ value: '${operator}', number: 'one' }`})
-      config.addWord(operatorPlural, { id: operator, initial: `{ value: '${operator}', number: 'many' }`})
+      config.addWord(operatorSingular, { id: operator, initial: `{ value: '${operator}', isVerb: true, number: 'one' }`})
+      config.addWord(operatorPlural, { id: operator, initial: `{ value: '${operator}', isVerb: true, number: 'many' }`})
+    }
+
+    for (const { child, parent } of hierarchy) {
+      config.addHierarchy(child, parent)
     }
 
     if (doAble) {
@@ -376,49 +450,97 @@ class API {
     config.addPriority({ "context": [[operator, 0], ['means', 0], ], "choose": [0] })
     config.addPriority({ "context": [['article', 0], [operator, 0], ], "choose": [0] })
 
-    config.addGenerator({
-      notes: 'ordering generator for paraphrase',
-      match: ({context}) => context.marker == operator && context.paraphrase && !context.query,
-      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
-        const sub = []
-        if (context.subphrase) {
-          sub.push(['that'])
-        }
-        return beforeGenerator.concat(sub).concat([word]).concat(afterGenerator).join(' ')
-      }
-    })
+    if (can) {
+      const beforeIds = before.map((def) => def.id)
+      const afterIds = after.map((def) => def.id)
+      config.addHierarchy(operator, 'canableAction')
+      config.addAssociation({ context: [[afterIds[0], 0], ['whatCanQuestion', 0], [beforeIds[0], 0], [operator, 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 1], ['whatCanQuestion', 0], [beforeIds[0], 0], [operator, 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 0], ['whatCanQuestionPassive', 0], [beforeIds[0], 0], ['beCanPassive', 0], [operator, 0], ['byCanPassive', 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 1], ['whatCanQuestionPassive', 0], [beforeIds[0], 0], ['beCanPassive', 0], [operator, 0], ['byCanPassive', 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 0], ['canPassive', 0], ['beCanPassive', 0], [operator, 0], ['byCanPassive', 0], [beforeIds[0], 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 1], ['canPassive', 0], ['beCanPassive', 0], [operator, 0], ['byCanPassive', 0], [beforeIds[0], 0]], choose: 1 })
+    }
 
-    config.addGenerator({
-      notes: 'ordering generator for response',
-      match: ({context}) => context.marker == operator && context.evalue && context.isResponse,
-      apply: async ({context, g, km}) => {
-        const brief = km("dialogues").api.getBrief()
-
-        const { evalue } = context 
-        let yesno = ''
-        if (!context.do.query || evalue.truthValueOnly || brief) {
-          if (evalue.truthValue) {
-            yesno = 'yes'
-          } else if (evalue.truthValue === false) {
-            yesno = 'no'
+    if (false) {
+      config.addGenerator({
+        notes: 'ordering generator for paraphrase',
+        match: ({context}) => context.marker == operator && context.paraphrase && !context.query,
+        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
+          const sub = []
+          if (context.subphrase) {
+            sub.push(['that'])
+          }
+          return beforeGenerator.concat(sub).concat([word]).concat(afterGenerator).join(' ')
         }
-        if (evalue.truthValueOnly || brief) {
-          return `${yesno}`
-        } else {
-          return `${yesno} ${await g(Object.assign({}, evalue, { paraphrase: true }))}`
+      })
+    }
+
+    if (true) {
+      config.addGenerator({
+        notes: 'ordering generator for response',
+        match: ({context}) => context.marker == operator && context.evalue && context.isResponse,
+        apply: async ({context, s, g, km, flatten}) => {
+          const brief = km("dialogues").api.getBrief()
+
+          let { evalue } = context 
+          let yesno = ''
+          let hasVariables = false
+          if (context.focusable) {
+            for (const f of context.focusable) {
+              if (context[f].query) {
+                hasVariables = true
+                break
+              }
+            }
+          }
+          
+          // if (!context.do?.query || evalue.truthValueOnly || context.truthValueOnly || brief) {
+          if (evalue.truthValueOnly || context.truthValueOnly || context.wantsTruthValue || !hasVariables) {
+            function any(value, test) {
+              if (test(value)) {
+                return true
+              }
+              const values = flatten(['list'], value)[0]
+              for (const value of values) {
+                if (test(value)) {
+                  return true
+                }
+              }
+            }
+            if (any(evalue, (value) => value.truthValue)) {
+              yesno = 'yes'
+            } else if (evalue.truthValue === false || context.truthValueOnly) {
+              yesno = 'no'
+            }
+          }
+          if (evalue.truthValueOnly) {
+            return `${yesno}`
+          } else {
+            if (context.voice) {
+              evalue = await s({ ...evalue, toVoice: context.voice, flatten: false})
+            }
+
+            const details = await g(Object.assign({}, evalue, { paraphrase: true }))
+            if (yesno) {
+              return `${yesno} ${details}`
+            }
+            else {
+              return details
+            }
+          }
         }
-      }
-    })
+      })
+    }
  
     if (ordering) {
       config.addSemantic({
@@ -494,7 +616,7 @@ class API {
     if (relation) {
       config.addSemantic({
         notes: `setter for ${operator}`,
-        match: ({context}) => context.marker == operator,
+        match: ({context}) => context.marker == operator && !context.toVoice,
         apply: ({context, km, hierarchy, config}) => {
           const api = km('properties').api
           // add types for arguments
@@ -515,9 +637,8 @@ class API {
       config.addSemantic({
         notes: `getter for ${operator}`,
         match: ({context}) => context.marker == operator && context.query,
-        apply: ({context, km}) => {
+        apply: ({context, km, callId}) => {
           const api = km('properties').api
-
           context.evalue = {
             marker: 'list',
             value: unflatten(api.relation_get(context, before.concat(after).map( (arg) => arg.tag ) ))
@@ -527,8 +648,8 @@ class API {
           if (context.evalue.value.length == 0) {
             context.evalue.marker = 'answerNotKnown';
             context.evalue.value = [];
-            context.evalue.marker = 'answerNotKnown';
-            context.evalue.value = [];
+          } else {
+            // context.evalue.truthValue = true
           }
         }
       })
@@ -552,10 +673,13 @@ class API {
   }
 
   relation_add (relations) {
+    removeProp(relations, (val, prop, obj) => prop === 'range')
+
     if (!Array.isArray(relations)) {
       relations = [relations]
     }
     for (const relation of relations) {
+      relation.truthValue = true
       this._objects.relations.push(relation)
     }
   }
@@ -599,7 +723,7 @@ class API {
     return value
   }
 
-  relation_get(context, args) {
+  relation_get (context, args) {
     const andTheAnswerIs = []
     for (const relation of this._objects.relations) {
       if (this.relation_match(args, context, relation)) {
@@ -669,8 +793,7 @@ class API {
     if (!context) {
       return;
     }
-    return this._km("stm").api.getVariable(context.value);
-    // return context.value
+    return this._km("stm").api.getVariable(context) || context.value;
   }
 
   async getProperty(object, property, g) {
@@ -703,7 +826,6 @@ class API {
   }
 
   setProperty(object, property, value, has, skipHandler) {
-    // debugger
     if (!skipHandler) {
       const handler = this.propertiesFH.getHandler([object, property])
       if (handler) {