tpmkms 9.8.0 → 9.9.0

package/common/dialogues.js

@@ -10,10 +10,10 @@ const negation = require('./negation.js')
 const punctuation = require('./punctuation.js')
 const stm = require('./stm.js')
 const _ = require('lodash')
-const { API } = require('./helpers/dialogues')
+const { API, focus } = require('./helpers/dialogues')
 const { isMany, propertyToArray, words } = require('./helpers')
 const dialogues_tests = require('./dialogues.test.json')
-const { defaultObjectCheck, defaultContextCheck, indent, focus } = require('./helpers')
+const { defaultObjectCheck, defaultContextCheck, indent } = require('./helpers')
 const pluralize = require('pluralize')
 
 function warningIsANotImplemented(log, context) {
@@ -57,6 +57,7 @@ const config = {
 
     "(<what> ([whatAble|]))",
     "([what:optional])",
+    "([who])",
 
     "([be] ([briefOrWordy|]))",
 
@@ -71,7 +72,6 @@ const config = {
     //"arm them, what, the phasers"
     //greg is a first name
     "([yesno|])",
-    { pattern: "([debug23])" },
 
     "([to] ([toAble|]))",
   ],
@@ -111,6 +111,7 @@ const config = {
     },
     {
       id: 'makeObject',
+      where: where(),
       bridge: "{ ...next(operator), object: after[0] }",
       enhanced_associations: false,
       generatorp: async ({context, gp}) => `${context.word} ${await gp(context.object)}`,
@@ -120,6 +121,7 @@ const config = {
     },
     {
       id: 'setIdSuffix',
+      where: where(),
       enhanced_associations: false,
       bridge: "{ ...next(operator), suffix: after[0] }",
       generatorp: async ({context, gp}) => `${context.word} ${await gp(context.suffix)}`,
@@ -129,6 +131,7 @@ const config = {
     },
     {
       id: 'resetIdSuffix',
+      where: where(),
       semantic: ({context, api}) => {
         api.setIdSuffix('')
       }
@@ -141,15 +144,20 @@ const config = {
       optional: { 1: "{ marker: 'unknown', implicit: true, concept: true }", }, 
     },
 
-    { id: "debug23" },
     { 
       id: "what", 
-      optional: "{ ...next(operator), query: ['what'], determined: true }", 
-      bridge: "{ ...after, query: ['what'], modifiers: ['what'], what: operator }" 
+      isA: ['queryable'],
+      optional: "{ ...next(operator), query: ['what'], determined: true, isVariable: true }", 
+      bridge: "{ ...after, query: ['what'], modifiers: ['what'], what: operator, isVariable: true }" 
+    },
+    {
+      id: "who",
+      isA: ['queryable'],
+      initial: { query: true, isVariable: true },
     },
     { id: "whatAble" },
 
-    // context.instance == variables.instance (unification)
+    // context.isInstance == variables.isInstance (unification)
     {   
         where: where(),
         id: "to", 
@@ -227,7 +235,8 @@ const config = {
   words: {
     "literals": {
       "?": [{"id": "questionMark", "initial": "{}" }],
-      "who": [{"id": "what", "initial": "{ modifiers: [], query: true }" }],
+      // TODO make who its own concept
+      // "who": [{"id": "what", "initial": "{ modifiers: [], query: true }" }],
       "yes": [{"id": "yesno", "initial": "{ value: true }" }],
       "no": [{"id": "yesno", "initial": "{ value: false }" }],
       "brief": [{"id": "briefOrWordy", "initial": "{ value: 'brief' }" }],
@@ -267,7 +276,6 @@ const config = {
     ['the', 'article'],
     ['theAble', 'queryable'],
     ['it', 'queryable'],
-    ['what', 'queryable'],
     ['whatAble', 'queryable'],
     ['negatable', 'queryable'],
     ['is', 'canBeQuestion'],
@@ -282,12 +290,13 @@ const config = {
     {
       where: where(),
       notes: "handle making responses brief",
-      match: ({context, objects, callId}) => (context.topLevel || context.isResponse) && objects.brief && !context.briefWasRun,
-      apply: async ({context, g}) => {
-        const focussed = focus(context)
-        context.briefWasRun = true
+      // TODO make this use callOnce
+      match: ({context, objects, callId}) => (context.topLevel || context.isResponse) && objects.brief && !context.briefWasRun && !context.paraphrase,
+      apply: async ({context, g, toEValue}) => {
+        const focussed = focus(toEValue(context))
+        focussed.briefWasRun = true
         const result = await g(focussed)
-        context.briefWasRun = false
+        focussed.briefWasRun = false
         return result
       },
       priority: -2,
@@ -301,13 +310,13 @@ const config = {
     {
       where: where(),
       notes: "unknown answer default response",
-      match: ({context, namespaced}) => context.marker == 'answerNotKnown' && context.brief,
+      match: ({context, namespaced}) => context.marker === 'undefined' && context.brief,
       apply: ({context}) => `not known`,
     },
     {
       where: where(),
       notes: "unknown answer default response",
-      match: ({context}) => context.marker == 'answerNotKnown',
+      match: ({context}) => context.marker === 'undefined',
       apply: ({context}) => `that is not known`,
     },
     {
@@ -405,7 +414,9 @@ const config = {
     },
     { 
       where: where(),
-      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'canBeQuestion') && context.paraphrase && context.topLevel && context.query,
+      match: ({context, hierarchy, debug}) => {
+        return hierarchy.isA(context.marker, 'canBeQuestion') && context.paraphrase && context.topLevel && context.query
+      },
       apply: async ({context, gp}) => {
         return `${await gp({...context, topLevel: undefined})}?` 
       },
@@ -422,15 +433,16 @@ const config = {
     { 
       where: where(),
       notes: 'is with a response defined',
-      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.evalue,
-      apply: async ({context, g, gs}) => {
+      // TODO change concept to be isConcept for the boolean case to avoid this confusion
+      match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.evalue && typeof context.evalue.concept !== 'boolean',
+      apply: async ({context, debug, g, gs}) => {
         const response = context.evalue;
         const concept = response.concept;
         if (concept) {
           concept.paraphrase = true
           concept.isSelf = true
-          const instance = await g(response.instance)
-          return `${await g(concept)} ${context.word} ${instance}` 
+          const isInstance = await g(response.isInstance)
+          return `${await g(concept)} ${context.word} ${isInstance}` 
         } else {
           if (Array.isArray(response)) {
             return `${await gs(response)}` 
@@ -444,8 +456,8 @@ const config = {
       where: where(),
       notes: 'x is y',
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && !context.evalue,
-      apply: async ({context, g, gp, debug, gr, callId}) => {
-        if ((context.two.evalue || {}).marker == 'answerNotKnown') {
+      apply: async ({isA, context, g, gp, debug, gr, callId}) => {
+        if ((context.two.evalue || {}).marker === 'undefined') {
           return await g(context.two.evalue)
         }
 
@@ -453,8 +465,8 @@ const config = {
           return `${await gp(context.one)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${await g(context.two)}`
         }
 
-        if (context.response) {
-          context = context.response
+        if (context.evalue) {
+          context = context.evalue
         }
 
         function hasFocus(property) {
@@ -477,6 +489,17 @@ const config = {
         } else {
           focus = 'one'
         }
+        const other = focus == 'one' ? 'two' : 'one' 
+        if (!isMany(context[focus]) && isMany(context[other])) {
+          focus = other
+        }
+        // idiom: dont say the name is it. say it is the name
+        if (focus == 'one' && isA(context[focus], 'thisitthat')) {
+          focus = other
+        }
+        if (focus == 'two' && context[other].isPropertyValue) {
+          focus = other
+        }
         // greg101
         if (focus == 'one') {
           let number = 'one'
@@ -487,7 +510,7 @@ const config = {
         } else {
           // TODO fix this using the assumed and that whole mess. change isResponse to useValue
           if (context.isResponse) {
-            return `${await gp(context.one, { assumed: { responding: true } })} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${await g(context.two)}`
+            return `${await gp(context.one, { assumed: { responding: true } })} ${isMany(context.one) ? "are" : "is"} ${await g(context.two)}`
           } else {
             return `${await gp(context.one)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${await gr(context.two)}`
           }
@@ -499,12 +522,14 @@ const config = {
   semantics: [
     {
       where: where(),
-      todo: 'debug23',
-      match: ({context}) => context.marker == 'debug23',
-      apply: ({context, hierarchy}) => {
-        debugger // eslint-disable-line no-debugger
-        debugger // eslint-disable-line no-debugger
+      match: ({context}) => {
+        return context.marker == 'unify' && context.terms.some((term) => ['what', 'who'].includes(term.marker))
       },
+      apply: async ({context, resolveEvaluate, e, toFinalValue}) => {
+        const value = context.terms.find((term) => !['what', 'who'].includes(term.marker))
+        instance = await e(value, where())
+        await resolveEvaluate(context, instance)
+      }
     },
     { 
       where: where(),
@@ -518,9 +543,10 @@ const config = {
       where: where(),
       match: ({context}) => context.marker === 'error',
       apply: async ({context, g, gp}) => {
-        context.evalue = "That is not known"
         if (context.reason) {
-          context.evalue += ` because ${await g(context.reason)}`
+          context.evalue = `${await g(context.reason)}`
+        } else {
+          context.evalue = "That is not known"
         }
         context.isResponse = true
       }
@@ -534,52 +560,83 @@ const config = {
         object is a type (is greg a human) // handled by queryBridge
       */
 
+      /*
+        what is the age of bob
+        the age of who is 30 years old
+
+        both are the sameA
+
+
+        what == the age
+        the age == 30 years old
+
+
+        resolve "the age of bob" + "30 years old"
+
+        what == "the age of bob" -> then resolve "the age of bob"
+        the age of who is 30 years old -> 30 years (age) of who
+
+
+
+        a b
+        one side is query so resolve the other one
+        a = "what" | "the age of who"
+        b = "the age of bob" | 30 years old
+        replace the main
+        "the age of bob" | 30 years old is who
+        resolve
+        30 years old | bob
+      */
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.query,
-      apply: async ({context, s, log, km, objects, e}) => {
+      apply: async ({context, s, log, km, objects, e, toEValue}) => {
         const one = context.one;
         const two = context.two;
-        let concept, value;
+
+        let query, value;
         if (one.query) {
-          concept = one;
+          query = one;
           value = two;
         } else {
-          concept = two;
+          query = two;
           value = one;
         }
-        // km('dialogues').api.remember(concept)
-        // TODO wtf is the next line?
-        value = JSON.parse(JSON.stringify(value))
-        const instance = await e(value)
-        if (false && instance.evalue) {
-          km('stm').api.remember({ context: value })
-        }
+
+        const unification = await e({
+          marker: 'unify',
+          terms: [query, value],
+        }, where())
+        instance = unification.evalue || { marker: 'undefined' }
+
         if (instance.verbatim) {
           context.evalue = { verbatim: instance.verbatim }
           context.isResponse = true
           return
         }
-        // instance.focusable = ['one', 'two']
-        // concept = JSON.parse(JSON.stringify(value)) 
-        concept = _.cloneDeep(value) 
+
+        if (toEValue(instance)?.marker === 'undefined') {
+          context.evalue = instance
+          context.isResponse = true
+          return
+        }
+
+        const concept = _.cloneDeep(value) 
         concept.isQuery = undefined
-        // greg101
-        // instance.focusableForPhrase = true
         instance.focus = true
         if (concept.hierarchy) {
           concept.focusableForPhrase = true
         }
-        // concept.focus = true
 
         const many = isMany(concept) || isMany(instance)
         const evalue = {
-          "default": true,
-          "marker": "is",
-          "one": concept,
-          "two": instance,
-          "focusable": ['two', 'one'],
-          "word": many ? "are" : "is",
-          "number": many ? "many" : undefined,
+          default: true,
+          marker: "is",
+          one: concept,
+          two: instance,
+          focusable: ['two', 'one'],
+          word: many ? "are" : "is",
+          number: many ? "many" : undefined,
         }
+
         context.evalue = evalue
         context.isResponse = true
       }
@@ -613,7 +670,7 @@ const config = {
       where: where(),
       notes: 'x is y. handles x is a kind of y or x = y in the stm',
       match: ({context}) => context.marker == 'is' && !context.query && context.one && context.two,
-      apply: async ({_continue, context, s, debug, log, api, kms, config}) => {
+      apply: async ({_continue, context, e, debug, log, api, kms, config}) => {
         function warningSameNotEvaluated(log, one) {
           const description = 'WARNING from Dialogues KM: For the "X is Y" type phrase implement a same handler.'
           const match = `({context}) => context.marker == '${one.marker}' && context.same && <other conditions as you like>`
@@ -625,8 +682,7 @@ const config = {
 
         const one = context.one;
         const two = context.two;
-        one.same = two;
-        const onePrime = await s(one)
+        const onePrime = await e({ marker: 'same', one: one, two: two }, where())
         if (!onePrime.sameWasProcessed) {
           warningSameNotEvaluated(log, one)
         } else {
@@ -635,7 +691,6 @@ const config = {
             context.isResponse = true
           }
         }
-        one.same = undefined
         if (!onePrime.sameWasProcessed) {
           _continue()
         }
@@ -659,14 +714,13 @@ const config = {
     {
       where: where(),
       notes: 'get variable from stm',
-      match: ({context, kms}) => context.evaluate && kms.stm.api.getVariable(context),
-      // match: ({context, kms}) => context.evaluate,
+      match: ({context, kms}) => kms.stm.api.getVariable(context),
       priority: -1,
       apply: async ({context, kms, e}) => {
         const api = kms.stm.api
         context.value = api.getVariable(context)
         if (context.value && context.value.marker) {
-          context.evalue = await e(context.value)
+          context.evalue = await e(context.value, where())
         }
         context.focusableForPhrase = true
       }
@@ -675,12 +729,7 @@ const config = {
 };
 
 function initializer({objects, config, isModule}) {
-  /* TODO add this beck in. some stuff from config needs to be here
-  config.addArgs((args) => ({ 
-    e: (context) => config.api.getEvaluator(args.s, args.log, context),
-  }))
-  */
-  config.addArgs(({config, api, isA}) => ({ 
+  config.addArgs(({config, api, isA, e}) => ({ 
     toScopedId: (context) => {
       return api('dialogues').toScopedId(context)
     },
@@ -690,6 +739,13 @@ function initializer({objects, config, isModule}) {
       }
     },
     values: propertyToArray,
+    unify: async (term1, term2) => {
+      const unification = await e({
+        marker: 'unify',
+        terms: [term1, term2],
+      }, where())
+      return unification?.evalue
+    }
   }))
   objects.mentioned = []
   objects.variables = {