tpmkms_4wp 9.5.1 → 9.6.0

package/common/helpers/dateTimeSelectors.js

@@ -86,8 +86,8 @@ function getTime(time) {
   return { hour, minute, second }
 }
 
-instantiate = (isA, now, context) => {
-  const getType = (context, type) => {
+function instantiate(isA, now, context) {
+  function getType(context, type) {
     if (context.marker == 'onDate_dates' && context.date?.marker == type) {
       return context.date
     } if (context.marker == type) {

package/common/helpers/dialogues.js

@@ -86,13 +86,18 @@ class API {
       return
     }
     // const concept = pluralize.singular(value)
-    const concept = this.toScopedId(context)
+    let concept = this.toScopedId(context)
+    const extraTypes = []
+    if (concept == 'unit' && context.objects) {
+      concept = context.objects.map((c) => this.toScopedId(c)).join("_")
+      types.push(this.toScopedId(context.objects[0]))
+    }
     if (config.exists(concept)) {
       return concept
     }
 
     // TODO handle the general case
-    const fixUps = (concept) => {
+    function fixUps(concept) {
       if (concept == '*') {
         return '\\*'
       }

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
@@ -65,7 +65,7 @@ const translationMapping = (from, to) => {
     if (matchField) {
       let found = false
       const todo = Object.keys(to).map( (key) => [key] )
-      while (!found) {
+      while (!found && todo.length > 0) {
         const tkey = todo.shift()
         const tvalue = hashIndexesGet(to, tkey);
         const fvalue = hashIndexesGet(from, [fkey]);
@@ -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,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)) {
@@ -703,7 +827,6 @@ class API {
   }
 
   setProperty(object, property, value, has, skipHandler) {
-    // debugger
     if (!skipHandler) {
       const handler = this.propertiesFH.getHandler([object, property])
       if (handler) {