ekms 8.0.0-beta.9 → 8.0.0-beta.90

package/common/spock.js

@@ -1,4 +1,4 @@
-const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const crew = require('./crew')
 const spock_tests = require('./spock.test.json')
@@ -10,23 +10,20 @@ const template = {
   ]
 };
 
-const createConfig = () => {
-  const config = new Config({ name: 'spock', }, module)
-  config.add(crew())
-  return config
-}
-
 spock_instance.base = 'crew'
 // config.load(template, spock_instance)
+
 knowledgeModule( {
+  config: { name: 'spock', },
+  includes: [crew],
+
   module,
   description: 'Spock Simulator using a KM template',
-  createConfig,
   test: {
           name: './spock.test.json',
           contents: spock_tests,
           checks: {
-            context: defaultContextCheck,
+            context: defaultContextCheck(),
           },
         },
   template: {

package/common/stgame.js

@@ -1,4 +1,4 @@
-const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where, process : clientProcess } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const createCharacters = require('./characters')
 const stgame_tests = require('./stgame.test.json')
@@ -31,7 +31,8 @@ class KirkAPI {
 
   process(config, utterance) {
     this.kirk.server(config.getServer(), config.getAPIKey())
-    return this.kirk.process(utterance, { credentials: this.credentials })
+    // return this.kirk.process(utterance, { credentials: this.credentials })
+    return clientProcess(this.kirk, utterance, { credentials: this.credentials })
   }
   
   response({km, context, result}) {
@@ -52,8 +53,10 @@ class SpockAPI {
   }
 
   process(config, utterance) {
+    debugger
     this.spock.server(config.getServer(), config.getAPIKey())
-    return this.spock.process(utterance, { credentials: this.credentials })
+    // return this.spock.process(utterance, { credentials: this.credentials })
+    return clientProcess(this.spock, utterance, { credentials: this.credentials })
   }
   
   response({km, context, result}) {
@@ -61,35 +64,32 @@ class SpockAPI {
   }
 }
 
+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
+}
 
-const createConfig = () => {
-  const characters = createCharacters()
-  const kirk = createKirk()
-  const spock = createSpock()
-  characters.api = new KirkAPI(kirk);
-  characters.api = new SpockAPI(spock);
-  const config = new Config({ 
+knowledgeModule( {
+  config: { 
       name: 'stgame', 
       operators: [ "([a])" ],
       bridges: [ { id: 'a', level: 0, bridge: "{ ...next(operator) }" } ],
       words: {"?": [{"id": "a", "initial": "{}" }]},
-  }, module)
-  config.stop_auto_rebuild()
-  config.api = api
-  config.add(characters)
-  config.restart_auto_rebuild()
-  return config
-}
+  },
+  api: () => api,
+  includes: [createCharactersHelper],
 
-knowledgeModule( {
   module,
   description: 'Game simulator for trek-like characters',
-  createConfig,
   test: {
           name: './stgame.test.json',
           contents: stgame_tests,
           checks: {
-            context: defaultContextCheck,
+            context: defaultContextCheck(),
           },
         },
 })

package/common/stm.js

@@ -1,5 +1,8 @@
-const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { 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,14 @@ 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, frameOfReference } = {}) {
+    if (!frameOfReference) {
+      frameOfReference = this._objects
+    }
     // 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 +58,114 @@ class API {
       concept.value = value
     }
     concept.fromSTM = true
-    this._objects.mentioned.unshift(concept)
+    if (!concept.stm) {
+      concept.stm = {}
+    }
+    if (!concept.stm.id) {
+      concept.stm.id = this.getId()
+    }
+    frameOfReference.mentioned = (frameOfReference.mentioned || []).filter( (context) => context.stm && context.stm.id != concept.stm.id )
+    frameOfReference.mentioned.unshift(concept)
   }
 
-  mentions(context, useHierarchy=true) {
+  mentions({ context, frameOfReference, useHierarchy=true, all, condition = (() => true) } = {}) {
+    let mentioned = frameOfReference?.mentioned || this._objects.mentioned
+
+    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
-    for (let m of this._objects.mentioned) {
-      if (context.value && context.value == m.marker) {
-        return m
+    let findCounter = 0
+    for (let m of mentioned) {
+      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
-    for (let m of this._objects.mentioned) {
+    findCounter = 0
+    for (let m of 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) {
+      for (let m of 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,42 +173,104 @@ 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)
-  config.stop_auto_rebuild()
+const config = {
+  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: ['verb'],
+      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
+        }
+      },
+    },
+  ],
+}
 
-  config.initializer( ({config}) => {
+const initializer = ({config}) => {
     config.addArgs(({kms}) => ({
-      mentioned: (context) => {
-        kms.stm.api.mentioned(context)
+      mentioned: (args) => {
+        kms.stm.api.mentioned(args)
       },
-      mentions: (context) => {
-        return kms.stm.api.mentions(context)
+      mentions: (args) => {
+        return kms.stm.api.mentions(args)
       },
     }))
-  })
-  config.api = api
-
-  config.restart_auto_rebuild()
-  return config
-}
+  }
 
 knowledgeModule( { 
+  config,
+  api: () => new API(),
+  includes: [evaluate, articles],
+  initializer,
+
   module,
   description: 'short term memory',
-  createConfig,
   test: {
     name: './stm.test.json',
     contents: stm_tests,
     checks: {
-            context: defaultContextCheck,
-            objects: ['mentioned'],
+            context: [...defaultContextCheck(), 'pullFromContext', 'stm_id'],
+            objects: [{ property: 'mentioned', filter: helpers.defaultContextCheckProperties }],
           },
   },
 })