ekms 8.0.0-beta.4 → 8.0.0-beta.41

package/common/spock.js

@@ -10,9 +10,9 @@ const template = {
   ]
 };
 
-const createConfig = () => {
+const createConfig = async () => {
   const config = new Config({ name: 'spock', }, module)
-  config.add(crew())
+  await config.add(crew)
   return config
 }
 

package/common/stgame.js

@@ -62,22 +62,26 @@ class SpockAPI {
 }
 
 
-const createConfig = () => {
-  const characters = createCharacters()
-  const kirk = createKirk()
-  const spock = createSpock()
-  characters.api = new KirkAPI(kirk);
-  characters.api = new SpockAPI(spock);
+const createConfig = async () => {
   const config = new Config({ 
       name: 'stgame', 
       operators: [ "([a])" ],
       bridges: [ { id: 'a', level: 0, bridge: "{ ...next(operator) }" } ],
       words: {"?": [{"id": "a", "initial": "{}" }]},
   }, module)
+
+  const createCharactersHelper = async () => {
+    const characters = await createCharacters()
+    const kirk = await createKirk()
+    const spock = await createSpock()
+    await characters.setApi(new KirkAPI(kirk))
+    await characters.setApi(new SpockAPI(spock))
+    return characters
+  }
   config.stop_auto_rebuild()
-  config.api = api
-  config.add(characters)
-  config.restart_auto_rebuild()
+  await config.setApi(api)
+  await config.add(createCharactersHelper)
+  await config.restart_auto_rebuild()
   return config
 }
 

package/common/stm.js

@@ -1,5 +1,8 @@
 const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
+const helpers = require('./helpers')
+const articles = require('./articles')
+const evaluate = require('./evaluate')
 const stm_tests = require('./stm.test.json')
 
 class API {
@@ -10,6 +13,11 @@ class API {
     ]
     this._objects.mentioned = []
     this._objects.variables = {}
+    this.idCounter = 0
+  }
+
+  getId() {
+    return ++this.idCounter
   }
 
   addIsA(isA) {
@@ -27,7 +35,11 @@ class API {
     return false
   }
 
-  mentioned(concept, value = undefined) {
+  getByType(type) {
+    return this._objects.mentioned.filter( (context) => this.isA(context.marker, type) )
+  }
+
+  mentioned({ context:concept, value=null } = {}) {
     // TODO value should perhaps have been called id as in concept id and then value could be value
     if (value) {
       concept = { ...concept, pullFromContext: false }
@@ -43,49 +55,112 @@ class API {
       concept.value = value
     }
     concept.fromSTM = true
+    if (!concept.stm) {
+      concept.stm = {}
+    }
+    if (!concept.stm.id) {
+      concept.stm.id = this.getId()
+    }
+    this._objects.mentioned = this._objects.mentioned.filter( (context) => context.stm && context.stm.id != concept.stm.id )
     this._objects.mentioned.unshift(concept)
   }
 
-  mentions(context, useHierarchy=true) {
+  mentions({ context, useHierarchy=true, all, condition = (() => true) } = {}) {
+    const findPrevious = !!context.stm_previous
+    const forAll = []
+    const addForAll = (context) => {
+      if (!forAll.find( (c) => c.stm.id == context.stm.id)) {
+        forAll.push(context)
+      }
+    }
+
     // care about value first
+    let findCounter = 0
     for (let m of this._objects.mentioned) {
-      if (context.value && context.value == m.marker) {
-        return m
+      if (context.value && (context.value == m.marker || context.value == m.value)) {
+        findCounter += 1
+        if (findPrevious && findCounter < 2) {
+          continue
+        }
+        if (condition()) {
+          if (all) {
+            allForAll(m)
+          } else {
+            return m
+          }
+        }
       }
     }
 
     if (!useHierarchy) {
       return
     }
+
     // care about marker second
+    findCounter = 0
     for (let m of this._objects.mentioned) {
       if (context.marker != 'unknown' && this.isA(m.marker, context.marker)) {
-        return m
+        findCounter += 1
+        if (findPrevious && findCounter < 2) {
+          continue
+        }
+        if (condition(m)) {
+          if (all) {
+            addForAll(m)
+          } else {
+            return m
+          }
+        }
       }
       // if (context.types && context.types.includes(m.marker)) {
       if (context.types) {
         for (let parent of context.types) {
           if (parent != 'unknown' && this.isA(m.marker, parent)) {
-            return m
+            findCounter += 1
+            if (findPrevious && findCounter < 2) {
+              continue
+            }
+            if (condition(m)) {
+              if (all) {
+                addForAll(m)
+              } else {
+                return m
+              }
+            }
           }
         }
       }
     }
 
+    findCounter = 0
     if (context.types && context.types.length == 1) {
       for (let m of this._objects.mentioned) {
         if (context.unknown) {
-          return m
+          findCounter += 1
+          if (findPrevious && findCounter < 2) {
+            continue
+          }
+          if (condition(m)) {
+            if (all) {
+              addForAll(m)
+            } else {
+              return m
+            }
+          }
         }
       }
     }
+
+    if (all) {
+      return forAll
+    }
   }
 
   getVariable(name) {
     if (!name) {
       return
     }
-    let valueNew = this.mentions({ marker: name, value: name }, false) || name
+    let valueNew = this.mentions({ context: { marker: name, value: name }, useHierarchy: false }) || name
     if (valueNew && valueNew.value) {
       valueNew = valueNew.value
     }
@@ -93,29 +168,97 @@ class API {
   }
 
   setVariable(name, value) {
-    this.mentioned({ marker: name }, value)
+    this.mentioned({ context: { marker: name }, value })
   }
 }
 
 const api = new API()
 
-let createConfig = () => {
-  const config = new Config({ name: 'stm' }, module)
+const configStruct = {
+  name: 'stm',
+  operators: [
+    "([stm_previous|previous] ([memorable]))",
+    "(([memorable]) [stm_before|before])",
+    "([remember] (memorable/*))",
+  ],
+  words: {
+    literals: {
+      "m1": [{"id": "memorable", development: true, "initial": "{ value: 'm1' }" }],
+      "m2": [{"id": "memorable", development: true, "initial": "{ value: 'm2' }" }],
+    },
+  },
+  bridges: [
+    { 
+      id: 'memorable', 
+      isA: ['theAble'],
+      words: helpers.words('memorable') 
+    },
+    { 
+      id: 'remember', 
+      bridge: "{ ...next(operator), postModifiers: ['rememberee'], rememberee: after[0] }",
+      isA: ['verby'],
+      semantic: async ({context, api, e}) => {
+        let value = (await e(context.rememberee)).evalue
+        if (value == context.rememberee.value) {
+          value = context.rememberee
+        }
+        api.mentioned({ context: value })
+      },
+    },
+    { 
+      id: 'stm_previous',
+      bridge: '{ ...after[0], modifiers: ["stm_previous"], stm_previous: operator, pullFromContext: true }',
+    },  
+    { 
+      id: 'stm_before',
+      isA: ['adjective'],
+      bridge: '{ ...before[0], postModifiers: ["stm_previous"], stm_previous: operator, pullFromContext: true }',
+    },  
+  ],
+  semantics: [
+    { 
+      where: where(),
+      notes: 'pull from context',
+      // match: ({context}) => context.marker == 'it' && context.pullFromContext, // && context.value,
+      match: ({context, callId}) => context.pullFromContext && !context.same, // && context.value,
+      apply: async ({callId, context, kms, e, log, retry}) => {
+        context.value = kms.stm.api.mentions({ context })
+        if (!context.value) {
+          // retry()
+          context.value = { marker: 'answerNotKnown' }
+          return
+        }
+        
+        const instance = await e(context.value)
+        if (instance.evalue && !instance.edefault) {
+          context.value = instance.evalue
+        }
+        if (context.evaluate) {
+          context.evalue = context.value
+        }
+      },
+    },
+  ],
+}
+
+let createConfig = async () => {
+  const config = new Config(configStruct, module)
   config.stop_auto_rebuild()
 
-  config.initializer( ({config}) => {
+  await config.initializer( ({config}) => {
     config.addArgs(({kms}) => ({
-      mentioned: (context) => {
-        kms.stm.api.mentioned(context)
+      mentioned: ({ context }) => {
+        kms.stm.api.mentioned({ context })
       },
-      mentions: (context) => {
-        return kms.stm.api.mentions(context)
+      mentions: ({ context }) => {
+        return kms.stm.api.mentions({ context })
       },
     }))
   })
-  config.api = api
+  await config.setApi(api)
+  await config.add(evaluate, articles)
 
-  config.restart_auto_rebuild()
+  await config.restart_auto_rebuild()
   return config
 }
 
@@ -127,7 +270,7 @@ knowledgeModule( {
     name: './stm.test.json',
     contents: stm_tests,
     checks: {
-            context: defaultContextCheck,
+            context: [...defaultContextCheck, 'pullFromContext', 'stm_id'],
             objects: ['mentioned'],
           },
   },