tpmkms 9.8.0 → 9.9.0

package/common/gdefaults.js

@@ -3,6 +3,7 @@ const { interpolate } = require('./helpers/gdefaults')
 const { defaultContextCheck, getValue, isMany } = require('./helpers')
 const { debug, knowledgeModule, where, flatten } = require('./runtime').theprogrammablemind
 const tokenize = require('./tokenize.js')
+const debugKM = require('./debug.js')
 const words = require('./words.js')
 const gdefaults_tests = require('./gdefaults.test.json')
 const englishHelpers = require('./english_helpers.js')
@@ -28,8 +29,8 @@ const config = {
      */
     {
       where: where(),
-      match: ({context}) => context.isResponse && context.response,
-      apply: ({context, gr}) => gr(context.response),
+      match: ({context}) => context.isResponse && context.evalue,
+      apply: ({context, gr}) => gr(context.evalue),
     },
 
     {
@@ -76,16 +77,13 @@ const config = {
 
     {
       where: where(),
-      // match: ({context}) => context.evalue && !context.paraphrase,
       match: ({context, callId}) => context.evalue && !context.paraphrase,
-      // match: ({context}) => context.evalue && context.isResponse,
       apply: async ({context, g}) => await g(context.evalue)
     },
 
     {
       where: where(),
       //({context}) => context.paraphrase && context.modifiers,
-      // match: ({context}) => context.paraphrase && (context.modifiers || context.postModifiers),
       match: ({context}) => (context.modifiers || context.postModifiers),
       apply: async ({context, g, gs, callId}) => {
         const text = []
@@ -141,95 +139,17 @@ const config = {
       }
     },
 
-    {
-      where: where(),
-      priority: -1,
-      match: ({context}) => context.marker == 'modifies' && context.evaluateWord && context.paraphrase && context.number == 'one',
-      apply: ({context}) => 'modifies'
-    },
-    {
-      where: where(),
-      priority: -1,
-      match: ({context}) => context.marker == 'modifies' && context.evaluateWord && context.paraphrase && (context.number == 'many' || context.number > 1),
-      apply: ({context}) => 'modify'
-    },
-
-    {
-      where: where(),
-      priority: -1,
-      // match: ({context}) => context.evaluateWord && context.isVerb && context.paraphrase && context.word && context.number == 'one' && !context.imperative && !context.interpolate,
-      match: ({context}) => context.evaluateWord && context.isVerb && context.paraphrase && context.word && !context.imperative && !context.interpolate,
-      apply: ({context}) => {
-        const infinitive = englishHelpers.getInfinitive(context.word)
-        if (context.form == 'infinitive') {
-          const cases = englishHelpers.conjugateVerb(infinitive)
-          const def = cases.find((def) => def.form == context.form)
-          return def.word
-        } else if (context.tense) {
-          const cases = englishHelpers.conjugateVerb(infinitive)
-          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.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)
-      },
-    },
-
     {
       where: where(),
       match: ({context}) => context.paraphrase && context.word && (context.number == 'many' || context.number > 1) && !context.isModifier,
-      apply: ({context}) => {
-        // TODO make the sentence that the plural celcius is celcius work
-        if (["fahrenheit", "celcius"].includes(context.word)) {
-          return context.word
-        }
-        return pluralize.plural(context.word)
+      apply: ({context, kms}) => {
+        return kms.words.api.toPlural(context)
       }
     },
 
     {
       where: where(),
-      // match: ({context}) => context.paraphrase && context.word && context.number == 'one',
-      match: ({context}) => context.word !== null && context.number == 'one',
+      match: ({context}) => !!context.word && context.number == 'one',
       apply: ({context}) => {
         return pluralize.singular(context.word)
       }
@@ -237,9 +157,6 @@ const config = {
 
     {
       where: where(),
-      // match: ({context}) => context.paraphrase && context.word,
-      // match: ({context}) => context.word && !context.value,
-      //match: ({context}) => context.word && typeof context.value == 'string',
       match: ({context}) => (context.paraphrase || typeof context.value == 'string') && context.word,
       apply: ({context}) => `${context.word}` 
     },
@@ -256,6 +173,12 @@ const config = {
       apply: async ({context, gs}) => await gs(context.value)
     },
 
+    {
+      where: where(),
+      match: ({context, namespaced}) => context.marker == 'labelledValue' && context.useColon,
+      apply: async ({context, g, debug, callId, gp}) => `${await gp(context.label)}: ${await g(context.value, { assumed: { brief: true } })}`
+    },
+
     {
       where: where(),
       match: ({context, namespaced}) => context.marker == 'labelledValue',
@@ -282,7 +205,7 @@ const config = {
 
     {
       where: where(),
-      match: ({context}) => context.marker == 'answerNotKnown',
+      match: ({context}) => context.marker === 'undefined',
       apply: ({context}) => 'That is not known',
     },
 
@@ -292,6 +215,12 @@ const config = {
       apply: ({context}) => context.marker,
     },
 
+    {
+      where: where(),
+      match: ({context}) => context.text,
+      apply: ({context}) => context.text,
+    },
+
     {
       where: where(),
       match: () => true,
@@ -319,11 +248,6 @@ function initializer({config}) {
           }
         },
         number: (context) => isMany(context) ? "many" : "one",
-        // number/gender/person etc
-        gw: (context, { number: numberContext }) => {
-          const number = numberContext ? args.number(numberContext) : context.number;
-          return args.gp( { ...context, evaluateWord: true, number } )
-        },
         verbatim, 
         say: verbatim,
         interpolate: interpolate(args),
@@ -333,7 +257,7 @@ function initializer({config}) {
 
 knowledgeModule({ 
   config,
-  includes: [tokenize, words],
+  includes: [tokenize, words, debugKM],
   initializer,
 
   module,

package/common/helpers/concept.js

@@ -49,14 +49,7 @@ class API {
     // TODO call evaluator to pick up overrides
     const objectSingular = pluralize.singular(objectWord)
     const objectPlural = pluralize.plural(objectWord)
-    // config.addOperator({ pattern: `(${modifierIds.map((modifierId) => `(${modifierId}/*)`).join(' ')} [${modifiersObjectId}] (${objectId}/0))`, allowDups: true })
-    if (false) {
-      config.addOperator({ pattern: `(${modifierIds.map((modifierId) => `(${modifierId}/*)`).join(' ')} [${modifiersObjectId}] (${objectId}/*))`, allowDups: true })
-    } else {
-      config.addOperator({ pattern: `(${modifierIds.map((modifierId) => `(@==${modifierId})`).join(' ')} [${modifiersObjectId}] (@==${objectId}))`, allowDups: true })
-    }
-    // config.addOperator({ pattern: `(<${modifierId}|> ([${objectId}|]))`, allowDups: true })
-    // config.addOperator({ pattern: `([${modifierObjectId}|])`, allowDups: true })
+    config.addOperator({ pattern: `(${modifierIds.map((modifierId) => `(@==${modifierId})`).join(' ')} [${modifiersObjectId}] (@==${objectId}))`, allowDups: true })
 
     const objectModifierConcept = `${objectId}_modifier`
     if (!config.exists(objectModifierConcept)) {
@@ -105,7 +98,7 @@ class API {
       id: modifiersObjectId, 
       level: 0, 
       convolution: true,
-      isA: [{ parent: 'adjective', instance: true }],
+      isA: [{ parent: 'adjective', isInstance: true }],
       associator_return_type: [modifiersObjectId, 0],
       useForArgumentInference: false,
       // isA: ['adjective'],

package/common/helpers/conjunction.js

@@ -59,6 +59,16 @@ function listable(hierarchy) {
 }
 
 function isA(hierarchy) {
+  const getId = (context) => {
+    if (typeof context === 'string') {
+      return context
+    }
+    if (context.marker === 'unknown') {
+      return context.value
+    }
+    return context.marker
+  }
+
   return (child, parent, { strict=false } = {}) => {
     const oneToOne = (child, parent) => {
       if (!child || !parent) {
@@ -77,7 +87,7 @@ function isA(hierarchy) {
         const children = propertyToArray(child)
         for (const child of children) {
           let okay = false
-          if (hierarchy.isA(child.marker || child, parent.marker || parent)) {
+          if (hierarchy.isA(getId(child), getId(parent))) {
             okay = true
           } else {
             for (const childT of child.types || [child]) {

package/common/helpers/dialogues.js

@@ -1,5 +1,6 @@
+const { flatten, debug } = require('../runtime').theprogrammablemind
 const pluralize = require('pluralize')
-const { indent, focus } = require('../helpers')
+const { asList } = require('./conjunction.js')
 
 class API {
   initialize({ objects }) {
@@ -27,22 +28,13 @@ class API {
     }
   }
 
-  warningNotEvaluated(log, value) {
-    const description = 'WARNING from Dialogues KM: For semantics, implement an evaluations handler, set "value" property of the operator to the value.'
-    const match = `({context}) => context.marker == '${value.marker}' && context.evaluate && <other conditions as you like>`
-    const apply = `({context}) => <do stuff...>; context.value = <value>`
-    const input = indent(JSON.stringify(value, null, 2), 2)
-    const message = `${description}\nThe semantic would be\n  match: ${match}\n  apply: ${apply}\nThe input context would be:\n${input}\n`
-    log(indent(message, 4))
-  }
-
   //
   // duck typing: for operators you want to use here
   //
   //   1. Use hierarchy to make them an instance of queryable. For example add hierarchy entry [<myClassId>, 'queryable']
   //   2. For semantics, if evaluate == true then set the 'value' property of the operator to the value.
   //   3. Generators will get contexts with 'response: true' set. Used for converting 'your' to 'my' to phrases like 'your car' or 'the car'.
-  //   4. Generators will get contexts with 'instance: true' and value set. For converting values like a date to a string.
+  //   4. Generators will get contexts with 'isInstance: true' and value set. For converting values like a date to a string.
   //
 
   // used with context sensitive words like 'it', 'that' etc. for example if you have a sentence "create a tank"
@@ -56,17 +48,6 @@ class API {
     return this._objects.brief
   }
 
-  async evaluateToConcept(value, context, log, s) {
-    value.evaluate = { toConcept: true }
-    const concept = await s(value)
-    if (!concept.evalue && !concept.verbatim) {
-      this.warningNotEvaluated(log, value);
-      concept.evalue = concept.value
-    }
-    delete concept.evaluate
-    return concept
-  }
-
   setupObjectHierarchy(config, id, { types } = {}) {
     for (let type of types) {
       if (typeof type !== 'string') {
@@ -108,7 +89,7 @@ class API {
     }
 
     initial.value = source_value || concept
-    await this.args.s({ value, makeObject: true, initial })
+    await this.args.e({ value, makeObject: true, initial })
     // config.addOperator({ pattern: `(["${fixUps(concept)}"])`, allowDups: true })
     config.addOperator({ pattern: `(["${concept}"|])`, allowDups: true })
     config.addBridge({ id: concept, level: 0, bridge: `{ ...operator, dead: true, value: or(operator.value, '${source_value || concept}') }` , allowDups: true })
@@ -151,6 +132,49 @@ class API {
   }
 }
 
+function focus(context) {
+  function helper(context) {
+    let focusable = context?.focusable
+    if (!focusable && context.marker == 'list') {
+      focusable = ['value']
+    }
+    if (!focusable) {
+      return null
+    }
+    for (const property of focusable) {
+      if (Array.isArray(context[property])) {
+        const array = context[property]
+        const focussed = []
+        for (const value of array) {
+          const focus = helper(value)
+          if (focus) {
+            focussed.push(focus)
+          }
+        }
+        if (focussed.length > 0) {
+          return asList(focussed)
+        }
+        continue
+      }
+
+      let focus = helper(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
+    }
+    return null
+  }
+  return helper(context) || context
+}
+
 module.exports = {
-  API
+  API,
+  focus,
 }

package/common/helpers/gdefaults.js

@@ -1,3 +1,4 @@
+const { getByPath, setByPath, } = require('../runtime').theprogrammablemind
 const helpers = require('../helpers')
 
 function interpolate(args) {
@@ -39,8 +40,13 @@ function interpolate(args) {
             strings.push(separator)
             strings.push(await args.gp({...context, interpolate: undefined}))
             separator = ' '
+          } else if (element.separator !== undefined && !element.values) {
+            separator = element.separator
           } else if (typeof element == 'string') {
-            separator = element
+            if (separator) {
+              strings.push(separator)
+            }
+            strings.push(element)
           } else if (element.separator && element.values) {
             let ctr = 0
             const each = element.each
@@ -70,20 +76,24 @@ function interpolate(args) {
               separator = ' '
             }
           } else if (element.property) {
-            value = context[element.property]
+            value = getByPath(context, element.property)
             if (value) {
               if (element.context) {
                 value = { ...value, ...element.context }
               }
               async function handleProperty(value) {
-                strings.push(separator)
                 if (element.isQuantified && number && isLastElement) {
                   value.number = number
                 }
+                let str = ''
                 if (Array.isArray(value)) {
-                  strings.push(await args.gsp(value))
+                  str = await args.gsp(value)
                 } else {
-                  strings.push(await args.gp(value))
+                  str = await args.gp(value)
+                }
+                if (str) {
+                  strings.push(separator)
+                  strings.push(str)
                 }
                 separator = ' '
               }