tpmkms 9.5.0 → 9.5.1-beta.10

package/common/fastfood.js

@@ -284,7 +284,7 @@ const template = {
     ({ask, api}) => {
       // see if followup for drink is needed
 
-      const hasDrink = (isA, item) => {
+      function hasDrink(isA, item) {
         let hasDrink = false
         for (const modification of (item.modifications || [])) {
           if (isA(modification.id, 'drink')) {
@@ -295,11 +295,11 @@ const template = {
         return hasDrink
       }
 
-      const needsDrink = (item) => {
+      function needsDrink (item) {
         return item.needsDrink
       }
 
-      const askAbout = ({api, isA}) => {
+      function askAbout({api, isA}) {
         const items = []
         for (const item of api.items()) {
           if (needsDrink(item) && !hasDrink(isA, item)) {
@@ -765,7 +765,7 @@ class State {
       return
     }
 
-    const addSize = (item, data) => {
+    function addSize(item, data) {
       if (item.size) {
         data.size = item.size.value
       }

package/common/formulas.instance.json

@@ -997,7 +997,7 @@
             "word": "formulas",
             "range": {
               "start": 0,
-              "end": 20
+              "end": 7
             },
             "dead": true,
             "types": [

package/common/formulas.js

@@ -13,7 +13,7 @@ const instance = require('./formulas.instance.json')
 /*
 const template = {
   configs: [
-    // { query: "x equals y + 4", development: true },
+    // { query: "x equals y + 4", scope: "testing" },
   ]
 }
 */

package/common/gdefaults.js

@@ -1,9 +1,9 @@
 const pluralize = require('pluralize')
-const { defaultContextCheck } = require('./helpers')
-const { knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { defaultContextCheck, getValue, isMany } = require('./helpers')
+const { knowledgeModule, where, flatten } = require('./runtime').theprogrammablemind
 const tokenize = require('./tokenize.js')
 const gdefaults_tests = require('./gdefaults.test.json')
-const { getValue, isMany } = require('./helpers.js')
+const englishHelpers = require('./english_helpers.js')
 const helpers = require('./helpers')
 
 const config = {
@@ -151,15 +151,56 @@ const config = {
     {
       where: where(),
       priority: -1,
-      match: ({context}) => context.evaluateWord && context.paraphrase && context.word && (context.number == 'many' || countext.number > 1),
+      match: ({context}) => context.evaluateWord && context.isVerb && context.paraphrase && context.word && context.number == 'one' && !context.imperative && !context.interpolate,
+      apply: ({context}) => {
+        const infinitive = englishHelpers.getInfinitive(context.word)
+        if (context.tense) {
+          const cases = englishHelpers.conjugateVerb(infinitive)
+          // console.log(JSON.stringify(cases, null, 2))
+          const def = cases.find((def) => def.tense == context.tense)
+          return def.word
+        } else {
+          return pluralize.plural(context.word)
+        }
+      },
+    },
+
+    {
+      where: where(),
+      priority: -1,
+      match: ({context}) => context.evaluateWord && context.isVerb && context.paraphrase && context.word && context.number == 'many' && !context.imperative && !context.interpolate,
+      apply: ({context}) => {
+        const infinitive = englishHelpers.getInfinitive(context.word)
+        const cases = englishHelpers.conjugateVerb(infinitive)
+        return pluralize.singular(context.word)
+      },
+    },
+
+    {
+      where: where(),
+      priority: -1,
+      match: ({context}) => context.evaluateWord && context.paraphrase && context.word && (context.number == 'many' || context.number > 1) && !context.interpolate,
       apply: ({context}) => pluralize.plural(context.word),
     },
 
     {
       where: where(),
       priority: -1,
-      match: ({context}) => context.evaluateWord && context.paraphrase && context.word && context.number == 'one',
-      apply: ({context}) => pluralize.singular(context.word),
+      match: ({context}) => context.evaluateWord && context.isVerb && context.paraphrase && context.word && context.number == 'one' && !context.imperative && !context.interpolate,
+      apply: ({context}) => {
+        const infinitive = englishHelpers.getInfinitive(context.word)
+        const cases = englishHelpers.conjugateVerb(infinitive)
+        return pluralize.plural(context.word)
+      },
+    },
+
+    {
+      where: where(),
+      priority: -1,
+      match: ({context}) => context.evaluateWord && context.paraphrase && context.word && context.number == 'one' && !context.interpolate,
+      apply: ({context}) => {
+        return pluralize.singular(context.word)
+      },
     },
 
     {
@@ -228,9 +269,10 @@ const config = {
   ],
 };
 
-const initializer = ({config}) => {
+function initializer({config}) {
     config.addArgs((args) => {
       return {
+        flatten,
         number: (context) => isMany(context) ? "many" : "one",
         // number/gender/person etc
         gw: (context, { number: numberContext }) => {
@@ -241,14 +283,14 @@ const initializer = ({config}) => {
           args.insert({ marker: 'verbatim', verbatim: text, isResponse: true })
         },
         interpolate: async (interpolate, context) => {
-          const evaluator = async (key) => {
+          async function evaluator(key) {
             if (Array.isArray(context[key])) {
               return args.gsp(context[key])
             } else {
               return args.gp(context[key])
             }
           }
-          const getValue = (keyOrValue) => {
+          function getValue(keyOrValue) {
             if (typeof keyOrValue == 'string' && context[keyOrValue]) {
               return context[keyOrValue]
             }
@@ -277,6 +319,13 @@ const initializer = ({config}) => {
                 let value = element
                 if (element.property) {
                   value = context[element.property]
+                  if (element.context) {
+                    Object.assign(value, element.context)
+                  }
+                }
+                // if (!value?.number && element.number) {
+                if (value?.number !== 'infinitive' && element.number) {
+                  value.number = isMany(context[element.number]) ? "many": "one"
                 }
                 if (value) {
                   strings.push(separator)

package/common/help.js

@@ -4,7 +4,7 @@ const dialogues = require('./dialogues')
 const help_tests = require('./help.test.json')
 const helpers = require('./helpers')
 
-const getHelp = (config, indent=2) => {
+function getHelp(config, indent=2) {
   indent = ' '.repeat(indent)
   let help = ''
   if (config.tests.length == 0) {
@@ -77,12 +77,12 @@ const config = {
   words: {
     "literals": {
       // "km1": { "the": [{"id": "the", "initial": "{ modifiers: [] }" }],
-      'km1': [{id: "km", initial: "{ value: 'km1', word: 'km1' }", development: true }],
+      'km1': [{id: "km", initial: "{ value: 'km1', word: 'km1' }", scope: "testing" }],
     }
   },
 };
 
-const initializer = ({ config, addWord, kms }) => {
+function initializer({ config, addWord, kms }) {
     const names = new Set()
     for (const name in kms) {
       names.add(name);

package/common/helpers/concept.js

@@ -38,7 +38,7 @@ class API {
     const modifierIds = modifiers.map( (modifier) => this.args.kms.dialogues.api.toScopedId(modifier) )
     const modifiersObjectId = `${modifierIds.join("_")}_${objectId}`
 
-    const toWord = (object) => {
+    function toWord(object) {
       if (typeof object == 'string') {
         return object
       }

package/common/helpers/conjunction.js

@@ -1,7 +1,13 @@
 const { propertyToArray } = require('../helpers.js')
 
-const asList = (context) => {
-  if (context.marker === 'list') {
+function asList(context) {
+  if (Array.isArray(context)) {
+    return {
+      marker: 'list',
+      // types: [context.marker],
+      value: context
+    }
+  } else if (context.marker === 'list') {
     return context
   }
   return {
@@ -11,60 +17,64 @@ const asList = (context) => {
   }
 }
 
-const listable = (hierarchy) => (c, type) => {
-  if (!c) {
-    return false
-  }
-  if (hierarchy.isA(c.marker, type)) {
-    return true
-  }
-  if (c.marker === 'list') {
-    for (const t of c.types) {
-      if (hierarchy.isA(t, type)) {
-        return true
+function listable(hierarchy) {
+  return (c, type) => {
+    if (!c) {
+      return false
+    }
+    if (hierarchy.isA(c.marker, type)) {
+      return true
+    }
+    if (c.marker === 'list') {
+      for (const t of c.types) {
+        if (hierarchy.isA(t, type)) {
+          return true
+        }
       }
     }
-  }
-  return false
-}
-
-const isA = (hierarchy) => (child, parent, { strict=false } = {}) => {
-  if (!child || !parent) {
     return false
   }
+}
 
-  if (strict) {
-    if (child.marker) {
-      child = child.marker
-    }
-    if (parent.marker) {
-      parent = parent.marker
+function isA(hierarchy) {
+  return (child, parent, { strict=false } = {}) => {
+    if (!child || !parent) {
+      return false
     }
-    return hierarchy.isA(child, parent)
-  } else {
-    const children = propertyToArray(child)
-    for (const child of children) {
-      let okay = false
-      if (hierarchy.isA(child.marker || child, parent.marker || parent)) {
-        okay = true
-      } else {
-        for (const childT of child.types || [child]) {
-          if (okay) {
-            break
-          }
-          for (const parentT of parent.types || [parent]) {
-            if (hierarchy.isA(childT, parentT)) {
-              okay = true
+
+    if (strict) {
+      if (child.marker) {
+        child = child.marker
+      }
+      if (parent.marker) {
+        parent = parent.marker
+      }
+      return hierarchy.isA(child, parent)
+    } else {
+      const children = propertyToArray(child)
+      for (const child of children) {
+        let okay = false
+        if (hierarchy.isA(child.marker || child, parent.marker || parent)) {
+          okay = true
+        } else {
+          for (const childT of child.types || [child]) {
+            if (okay) {
               break
             }
+            for (const parentT of parent.types || [parent]) {
+              if (hierarchy.isA(childT, parentT)) {
+                okay = true
+                break
+              }
+            }
           }
         }
+        if (!okay) {
+          return false
+        }
       }
-      if (!okay) {
-        return false
-      }
+      return true
     }
-    return true
   }
 }
 

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

@@ -92,7 +92,7 @@ class API {
     }
 
     // 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,