ekms 9.5.1-beta.5 → 9.5.1-beta.6

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')
@@ -28,7 +29,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 +275,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 {
@@ -346,7 +349,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 +370,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,6 +408,15 @@ 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}', tense: '${def.tense}' }`})
+        }
+      }
+
       const operatorPlural = pluralize.singular(operator)
       const operatorSingular = pluralize.plural(operator)
       config.addWord(operatorSingular, { id: operator, initial: `{ value: '${operator}', number: 'one' }`})
@@ -413,6 +434,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], ['make', 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 1], ['whatCanQuestion', 0], [beforeIds[0], 0], ['make', 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 0], ['whatCanQuestionPassive', 0], [beforeIds[0], 0], ['beCanPassive', 0], ['make', 0], ['byCanPassive', 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 1], ['whatCanQuestionPassive', 0], [beforeIds[0], 0], ['beCanPassive', 0], ['make', 0], ['byCanPassive', 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 0], ['canPassive', 0], ['beCanPassive', 0], ['make', 0], ['byCanPassive', 0], [beforeIds[0], 0]], choose: 1 })
+      config.addAssociation({ context: [[afterIds[0], 1], ['canPassive', 0], ['beCanPassive', 0], ['make', 0], ['byCanPassive', 0], [beforeIds[0], 0]], choose: 1 })
+    }
+
     if (false) {
       config.addGenerator({
         notes: 'ordering generator for paraphrase',
@@ -440,22 +473,50 @@ 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, g, km, flatten}) => {
           const brief = km("dialogues").api.getBrief()
 
           const { 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 }))}`
+            const details = await g(Object.assign({}, evalue, { paraphrase: true }))
+            if (yesno) {
+              return `${yesno} ${details}`
+            }
+            else {
+              return details
+            }
           }
         }
       })
@@ -558,7 +619,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 +628,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 +659,7 @@ class API {
       relations = [relations]
     }
     for (const relation of relations) {
+      relation.truthValue = true
       this._objects.relations.push(relation)
     }
   }
@@ -642,7 +703,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)) {

package/common/helpers.js

@@ -1,13 +1,14 @@
 const pluralize = require('pluralize')
+const { flatten } = require('./runtime').theprogrammablemind
 
-const unshiftL = (list, element, max) => {
+function unshiftL(list, element, max) {
   if (list.length >= max) {
     list.pop()
   }
   list.unshift(element)
 }
 
-const pushL = (list, element, max) => {
+function pushL(list, element, max) {
   if (list.length >= max) {
     list.shift()
   }
@@ -15,11 +16,11 @@ const pushL = (list, element, max) => {
 }
 
 // X pm today or tomorrow
-const millisecondsUntilHourOfDay = (newDate, hour) => {
+function millisecondsUntilHourOfDay(newDate, hour) {
   const now = newDate()
   const target = newDate(now)
 
-  const addHours = (date, h) => {
+  function addHours(date, h) {
     date.setTime(date.getTime() + (h*60*60*1000));
   }
   const hours = target.getHours()
@@ -34,11 +35,11 @@ const millisecondsUntilHourOfDay = (newDate, hour) => {
   return diff;
 }
 
-const indent = (string, indent) => {
+function indent(string, indent) {
   return string.replace(/^/gm, ' '.repeat(indent));
 }
 
-const getCount = (context) => {
+function getCount(context) {
   if (context.quantity) {
     return context.quantity.value
   }
@@ -47,13 +48,23 @@ const getCount = (context) => {
   }
 }
 
-const words = (word, additional = {}) => {
+function words(word, additional = {}) {
   return [{ word: pluralize.singular(word), number: 'one', ...additional }, { word: pluralize.plural(word), number: 'many', ...additional }]
 }
 
-const isMany = (context) => {
-  if (((context || {}).value || {}).marker == 'list' && (((context || {}).value || {}).value || []).length > 1) {
-    return true
+function isMany(context) {
+  if (!context) {
+    return
+  }
+  // if (((context || {}).value || {}).marker == 'list' && (((context || {}).value || {}).value || []).length > 1) {
+  const isList = context.marker == 'list' || context.value?.marker == 'list'
+  if (isList) {
+    if (context.value?.length > 1) {
+      return true
+    }
+    if (context.value?.value?.length > 1) {
+      return true
+    }
   }
 
   let number = context.number
@@ -77,13 +88,13 @@ const isMany = (context) => {
   return false
 }
 
-const requiredArgument = (value, name) => {
+function requiredArgument(value, name) {
   if (!value) {
     throw new Error(`${name} is a required argument`)
   }
 }
 
-const chooseNumber = (context, one, many) => {
+function chooseNumber(context, one, many) {
   if (isMany(context)) {
     return many;
   } else {
@@ -91,7 +102,7 @@ const chooseNumber = (context, one, many) => {
   }
 }
 
-const zip = (...arrays) => {
+function zip(...arrays) {
   if (arrays == []) {
     return []
   }
@@ -107,15 +118,21 @@ const zip = (...arrays) => {
 }
 
 
-const focus = (context) => {
-  const helper = (context) => {
+function focus(context) {
+  function helper(context) {
     if (!context || !context.focusable) {
       return null
     }
     for (const property of context.focusable) {
       let focus = helper(context[property])
-      if (!focus && (context[property] || {}).focus) {
-        focus = context[property]
+      if (!focus) {
+        const flat = flatten(['list'], context[property])[0]
+        for (const element of flat) {
+          if (element.focus) {
+            focus = context[property]
+            break
+          }
+        }
       }
       return focus
     }
@@ -126,7 +143,7 @@ const focus = (context) => {
 
 // if property is a list make array of elements of the list, if not return an array with the property value
 // fromList
-const propertyToArray = (value) => {
+function propertyToArray(value) {
   if (Array.isArray(value)) {
     return value
   } else if (value.marker == 'list') {
@@ -136,7 +153,23 @@ const propertyToArray = (value) => {
   }
 }
 
-wordNumber = (word, toPlural) => {
+// values is marker: 'list' or some context
+function concats(values) {
+  combined = []
+  for (const value of values) {
+    if (value.marker == 'list') {
+      combined = combined.concat(value.value)
+    } else {
+      combined.push(value)
+    }
+  }
+  return {
+    marker: 'list',
+    value: combined
+  }
+}
+
+function wordNumber(word, toPlural) {
   if (toPlural) {
     return pluralize.plural(word)
   } else {
@@ -144,14 +177,14 @@ wordNumber = (word, toPlural) => {
   }
 }
 
-const toEValue = (context) => {
+function toEValue(context) {
   while( context.evalue ) {
     context = context.evalue
   }
 	return context;
 }
 
-const defaultObjectCheck = (extra = []) => {
+function defaultObjectCheck(extra = []) {
   return {
     objects: [
       {
@@ -162,11 +195,11 @@ const defaultObjectCheck = (extra = []) => {
   }
 }
 
-const defaultContextCheckProperties = (extra) => {
+function defaultContextCheckProperties(extra) {
   return ['marker', 'text', 'verbatim', 'value', 'evalue', 'isResponse', { properties: 'modifiers' }, { properties: 'postModifiers' }, ...extra]
 }
 
-const defaultContextCheck = ({marker, extra = [], exported = false} = {}) => {
+function defaultContextCheck({marker, extra = [], exported = false} = {}) {
   let match
   if (marker) {
     match = ({context}) => context.marker == marker
@@ -180,35 +213,37 @@ const defaultContextCheck = ({marker, extra = [], exported = 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
-    }
-    return hierarchy.isA(child, parent)
-  } else {
-    if (hierarchy.isA(child.marker || child, parent.marker || parent)) {
-      return true
+function isA(hierarchy) {
+  return (child, parent, { strict=false } = {}) => {
+    if (!child || !parent) {
+      return false
     }
-    for (const childT of child.types || [child]) {
-      for (const parentT of parent.types || [parent]) {
-        if (hierarchy.isA(childT, parentT)) {
-          return true
+
+    if (strict) {
+      if (child.marker) {
+        child = child.marker
+      }
+      if (parent.marker) {
+        parent = parent.marker
+      }
+      return hierarchy.isA(child, parent)
+    } else {
+      if (hierarchy.isA(child.marker || child, parent.marker || parent)) {
+        return true
+      }
+      for (const childT of child.types || [child]) {
+        for (const parentT of parent.types || [parent]) {
+          if (hierarchy.isA(childT, parentT)) {
+            return true
+          }
         }
       }
+      return false
     }
-    return false
   }
 }
 
-const getValue = (propertyPath, object) => {
+function getValue(propertyPath, object) {
   if (!propertyPath) {
     return
   }
@@ -223,7 +258,7 @@ const getValue = (propertyPath, object) => {
   return value
 }
 
-const processTemplateString = async (template, evaluate) => {
+async function processTemplateString(template, evaluate) {
   async function resolveWithCallback(strings, ...keys) {
     // const resolvedValues = await Promise.all(keys.map(key => lookupVariable(key)));
     const resolvedValues = await Promise.all(keys.map(async (key) => {
@@ -337,4 +372,5 @@ module.exports = {
   requiredArgument,
   isA,
   removeProp,
+  concats
 }

package/common/hierarchy.js

@@ -6,11 +6,11 @@ const pluralize = require('pluralize')
 const _ = require('lodash')
 const { isMany } = require('./helpers')
 
-const getTypes = ( km, concept, instance ) => {
+function getTypes( km, concept, instance ) {
   const propertiesAPI = km('properties').api;
   const conceptAPI = km('concept').api;
   const digraph = propertiesAPI.digraph;
-  const intersect = (set1, set2) => {
+  function intersect(set1, set2) {
     return new Set([...set1].filter(x => set2.has(x)))
   }
   const descendants = digraph.descendants(concept.value)
@@ -286,7 +286,7 @@ const config = {
   ]
 };
 
-const initializer = ({apis, hierarchy}) => {
+function initializer({apis, hierarchy}) {
     apis('stm').addIsA( (child, parent) => {
       return hierarchy.isA(child, parent) 
     })

package/common/kirk.instance.json

@@ -1666,7 +1666,7 @@
             "dead": true,
             "range": {
               "start": 0,
-              "end": 11
+              "end": 2
             },
             "types": [
               "self"

package/common/length.instance.json

@@ -1123,7 +1123,7 @@
             "word": "length",
             "range": {
               "start": 0,
-              "end": 20
+              "end": 5
             },
             "dead": true,
             "types": [
@@ -2756,7 +2756,7 @@
             "text": "meter centimeter foot and inch",
             "range": {
               "start": 0,
-              "end": 49
+              "end": 29
             },
             "types": [
               "list",