tpmkms_4wp 9.5.1-beta.2 → 9.5.1-beta.20

package/common/helpers/formulas.js

@@ -13,7 +13,7 @@ function getVariables(expression, isVariable = (expression) => typeof expression
   return []
 }
 
-const match = (values, head, value) => {
+function match(values, head, value) {
   for (const prop in head) {
     if (head[prop] instanceof Function) {
       if (!head[prop](value[prop])) {
@@ -33,22 +33,24 @@ const match = (values, head, value) => {
   return true
 }
 
-const unify = (rule, value) => {
+function unify(rule, value) {
   const values = { ...rule.values }
   if (match(values, rule.head(values), value)) {
     return rule.body(values)
   }
 }
 
-const f = (values, variable) => (value) => {
-  if (!value) {
-    throw new Error("Value not present")
-  }
-  if (values[variable] && values[variable] != value) {
-    throw new Error("Variable already set to different value")
+function f(values, variable) {
+  return (value) => {
+    if (!value) {
+      throw new Error("Value not present")
+    }
+    if (values[variable] && values[variable] != value) {
+      throw new Error("Variable already set to different value")
+    }
+    values[variable] = value
+    return true
   }
-  values[variable] = value
-  return true
 }
 
 const rules = [
@@ -74,7 +76,7 @@ const rules = [
 ]
 
 function solveFor(expression, variable, isVariable = (expression) => typeof expression.value != 'number') {
-  const sameVar = (c1, c2) => {
+  function sameVar(c1, c2) {
     return c1.value == c2.value
   }
 

package/common/helpers/menus.js

@@ -1,10 +1,10 @@
-const calculateLefts = (defs) => {
+function calculateLefts(defs) {
   const lefts = {}
   calculateLeftsHelper(defs, lefts)
   return lefts
 }
 
-const calculateLeftsHelper = (defs, lefts) => {
+function calculateLeftsHelper(defs, lefts) {
   if (Array.isArray(defs)) {
     let previous
     for (const def of defs) {
@@ -19,13 +19,13 @@ const calculateLeftsHelper = (defs, lefts) => {
   return lefts
 }
 
-const calculateRights = (defs) => {
+function calculateRights(defs) {
   const rights = {}
   calculateRightsHelper(defs, rights)
   return rights
 }
 
-const calculateRightsHelper = (defs, rights) => {
+function calculateRightsHelper(defs, rights) {
   if (Array.isArray(defs)) {
     let previous
     for (const def of defs) {
@@ -40,13 +40,13 @@ const calculateRightsHelper = (defs, rights) => {
   return rights
 }
 
-const calculateDowns = (defs) => {
+function calculateDowns(defs) {
   const downs = {}
   calculateDownsHelper(defs, downs)
   return downs
 }
 
-const calculateDownsHelper = (defs, downs) => {
+function calculateDownsHelper(defs, downs) {
   if (Array.isArray(defs)) {
     for (const def of defs) {
       calculateDownsHelper(def, downs)
@@ -72,13 +72,13 @@ const calculateDownsHelper = (defs, downs) => {
   return downs
 }
 
-const calculateUps = (defs) => {
+function calculateUps(defs) {
   const ups = {}
   calculateUpsHelper(defs, ups)
   return ups
 }
 
-const calculateUpsHelper = (defs, ups) => {
+function calculateUpsHelper(defs, ups) {
   if (Array.isArray(defs)) {
     for (const def of defs) {
       calculateUpsHelper(def, ups)
@@ -100,13 +100,13 @@ const calculateUpsHelper = (defs, ups) => {
   return ups
 }
 
-const calculateParents = (defs) => {
+function calculateParents(defs) {
   const parents = {}
   calculateParentsHelper(defs, parents)
   return parents
 }
 
-const calculateParentsHelper = (defs, parents) => {
+function calculateParentsHelper(defs, parents) {
   if (Array.isArray(defs)) {
     for (const def of defs) {
       parents[def.key] = def.key
@@ -123,13 +123,13 @@ const calculateParentsHelper = (defs, parents) => {
   return parents
 }
 
-const calculatePaths = (defs) => {
+function calculatePaths(defs) {
   const paths = {}
   calculatePathsHelper(defs, paths)
   return paths
 }
 
-const calculatePathsHelper = (defs, paths) => {
+function calculatePathsHelper(defs, paths) {
   if (Array.isArray(defs)) {
     for (const def of defs) {
       calculatePathsHelper(def, paths)

package/common/helpers/meta.js

@@ -1,6 +1,6 @@
 const _ = require('lodash')
 
-const hashIndexesGet = (hash, indexes) => {
+function hashIndexesGet(hash, indexes) {
   let value = hash
   for (const i of indexes) {
     value = value[i]
@@ -8,7 +8,7 @@ const hashIndexesGet = (hash, indexes) => {
   return value
 }
 
-const hashIndexesSet = (hash, indexes, value) => {
+function hashIndexesSet(hash, indexes, value) {
   let currentValue = hash
   for (const i of indexes.slice(0, -1)) {
     if (!currentValue[i]) {
@@ -19,7 +19,7 @@ const hashIndexesSet = (hash, indexes, value) => {
   currentValue[indexes[indexes.length-1]] = value
 }
 
-const isPrefix = (prefix, fix) => {
+function isPrefix(prefix, fix) {
   return prefix.every((element, index) => {
     return prefix[index] === fix[index]
   })
@@ -27,11 +27,11 @@ const isPrefix = (prefix, fix) => {
 }
 
 // assumes isPrefix is true
-const replacePrefix = (prefix, prefixPrime, fix) => {
+function replacePrefix(prefix, prefixPrime, fix) {
   return prefixPrime.concat(fix.slice(prefix.length))
 }
 
-const compose = (m1s, m2s) => {
+function compose(m1s, m2s) {
   return m2s.map( (m2) => { 
     m1 = m1s.find( (m1) => isPrefix(m1.from, m2.from) )
     if (m1) {
@@ -48,7 +48,7 @@ const compose = (m1s, m2s) => {
           '[{"from":["two"],"to":["owner"]},{"from":["one"],"to":["ownee"]},{"from":["number"],"to":["number"]}]'
 */
 
-const translationMapping = (from, to) => {
+function translationMapping(from, to) {
   const mappings = []
   if (from.atomic) {
     return mappings
@@ -89,7 +89,7 @@ const translationMapping = (from, to) => {
   return mappings
 }
 
-const translationMappings = (froms, to) => {
+function translationMappings(froms, to) {
   const mappingss = []
   for (const from of froms) {
     mappingss.push(translationMapping(from, to))
@@ -97,7 +97,7 @@ const translationMappings = (froms, to) => {
   return mappingss
 }
 
-const translationMappingToInstantiatorMappings  = (translationMapping, from , to) => {
+function translationMappingToInstantiatorMappings(translationMapping, from , to) {
   return translationMapping.map( (tm) => {
     return {
       // match: ({context}) => context.value == to[tm.to].value,

package/common/helpers/properties.js

@@ -1,4 +1,5 @@
 const pluralize = require('pluralize')
+const { conjugateVerb } = require('../english_helpers')
 const { unflatten, flattens, Digraph } = require('../runtime').theprogrammablemind
 const _ = require('lodash')
 const deepEqual = require('deep-equal')
@@ -9,6 +10,24 @@ const { compose, translationMapping, translationMappingToInstantiatorMappings }
 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 {
@@ -274,12 +293,14 @@ class API {
       relation, 
       ordering, 
       doAble, 
+      flatten,
+      can,
       words = [], 
       unflatten:unflattenArgs = [], 
       focusable = [], 
       edAble } = args;
 
-    const createToCanonical = (concept) => {
+    function createToCanonical(concept) {
       if (typeof concept == 'string') {
         return { id: concept, isA: [] }
       } else {
@@ -308,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, 
@@ -328,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')
         }
@@ -346,7 +365,7 @@ class API {
 
     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) {
@@ -367,16 +386,25 @@ class API {
         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' } }`
-        const interpolateVerb = `{ property: "operator" }`
+        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}, operator: { ...operator, evaluateWord: true, imperative: ${imperative}, isVerb: true, number: 'one' }, unflatten: ${JSON.stringify(unflattenArgs)}, focusable: ${JSON.stringify(focusable)}, interpolate: ${interpolate} }`, 
+          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) {
@@ -396,10 +424,19 @@ class API {
     })
 
     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) {
@@ -413,6 +450,18 @@ class API {
     config.addPriority({ "context": [[operator, 0], ['means', 0], ], "choose": [0] })
     config.addPriority({ "context": [['article', 0], [operator, 0], ], "choose": [0] })
 
+    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 })
+    }
+
     if (false) {
       config.addGenerator({
         notes: 'ordering generator for paraphrase',
@@ -440,22 +489,54 @@ class API {
       config.addGenerator({
         notes: 'ordering generator for response',
         match: ({context}) => context.marker == operator && context.evalue && context.isResponse,
-        apply: async ({context, g, km}) => {
+        apply: async ({context, s, g, km, flatten}) => {
           const brief = km("dialogues").api.getBrief()
 
-          const { evalue } = context 
+          let { evalue } = context 
           let yesno = ''
-          if (!context.do.query || evalue.truthValueOnly || brief) {
-            if (evalue.truthValue) {
+          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) {
+            } else if (evalue.truthValue === false || context.truthValueOnly) {
               yesno = 'no'
             }
           }
-          if (evalue.truthValueOnly || brief) {
+          if (evalue.truthValueOnly) {
             return `${yesno}`
           } else {
-            return `${yesno} ${await g(Object.assign({}, evalue, { paraphrase: true }))}`
+            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
+            }
           }
         }
       })
@@ -535,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
@@ -558,7 +639,6 @@ class API {
         match: ({context}) => context.marker == operator && context.query,
         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 ) ))
@@ -568,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
           }
         }
       })
@@ -599,6 +679,7 @@ class API {
       relations = [relations]
     }
     for (const relation of relations) {
+      relation.truthValue = true
       this._objects.relations.push(relation)
     }
   }
@@ -642,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)) {