ekms 9.6.3 → 9.7.0

package/common/reports.js

@@ -38,7 +38,7 @@ function compareValue(property, v1, v2) {
 function newReport({km, objects}) {
   objects.tempReportId += 1
   const reportId = `tempReport${objects.tempReportId}`
-  km('stm').api.mentioned({ context: { marker: "report", text: reportId, types: [ "report" ], value: reportId, word: reportId } })
+  km('stm').api.remember({ context: { marker: "report", text: reportId, types: [ "report" ], value: reportId, word: reportId } })
   // name to listing
   objects.listings[reportId] = {
       columns: ['name', 'supplier'],
@@ -344,7 +344,7 @@ const config = {
         const name = context.name.map((n) => n.text).join('')
         objects.listings[name] = {...listing}
         config.addWord(`${name}`,  { id: 'report', initial: `{ value: "${name}" }` })
-        km('stm').api.mentioned({
+        km('stm').api.remember({
           context: {
                   marker: "report",
                   text: name,

package/common/scorekeeper.js

@@ -43,7 +43,7 @@ function setNextPlayer(km, objects) {
         word: "turn"
       }
   const api = km('stm').api
-  api.mentioned({ context: turn })
+  api.remember({ context: turn })
 }
 
 function addPlayer(objects, config, player) {

package/common/sdefaults.js

@@ -1,5 +1,6 @@
 const { flatten, knowledgeModule, where, debug } = require('./runtime').theprogrammablemind
 const { defaultContextCheck, concats, toEValue, toFinalValue } = require('./helpers')
+const control = require('./control')
 const sdefaults_tests = require('./sdefaults.test.json')
 
 class API {
@@ -14,6 +15,8 @@ class API {
   }
 }
 
+// TODO generalize this for avoiding recusive call without changing the context properties
+
 const config = {
   name: 'sdefaults',
   semantics: [
@@ -22,13 +25,17 @@ const config = {
       where: where(),
       priority: -1,
       // match: ({context}) => context.flatten || context.listable && context.value[0].flatten,
-      match: ({context}) => context.flatten || context.listable && context.value.some((value) => value.flatten),
+      // match: (args) => okay(args, ({context}) => (context.flatten || context.listable && context.value.some((value) => value.flatten))),
+      match: (args) => args.callOnce(args, ({context}) => (context.flatten || context.listable && context.value.some((value) => value.flatten))),
       // match: ({context}) => context.flatten || context.listable || (Array.isArray(context.value) && context.value.some((value) => value.flatten)),
-      apply: async ({config, km, context, s}) => {
+      apply: async ({config, km, context, s, _continue}) => {
         const [flats, wf] = flatten(['list'], context)
         const evalues = []
         for (const flat of flats) {
-          const result = await s({ ...flat, flatten: false })
+          if (!flat.control) {
+            flat.control = context.control
+          }
+          const result = await s(flat)
           if (result.evalue) {
             evalues.push(result.evalue)
           }
@@ -37,17 +44,22 @@ const config = {
           context.evalue = concats(evalues)
           context.isResponse = true
         }
+        context.control.seen.length = 0
       }
     },
     {
       notes: 'flatten relation',
       where: where(),
       priority: -1,
-      match: ({context}) => context.flatten && context.relation,
+      // match: ({context}) => context.flatten && context.relation,
+      match: (args) => args.callOnce(args, ({context}) => (context.flatten && context.relation)),
       apply: async ({config, km, context, s}) => {
         const [flats, wf] = flatten(['list'], context)
         for (const flat of flats) {
-          await s({ ...flat, flatten: false })
+          if (!flat.control) {
+            flat.control = context.control
+          }
+          await s(flat)
         }
       }
     },
@@ -85,6 +97,7 @@ function initializer({objects, config, isModule}) {
 
 knowledgeModule({ 
   config,
+  includes: [control],
   initializer,
   api: () => new API(),
 

package/common/spock.instance.json

@@ -395,6 +395,16 @@
           "theAble",
           false
         ],
+        [
+          "deletable",
+          "deletable",
+          false
+        ],
+        [
+          "delete",
+          "verb",
+          false
+        ],
         [
           "distributable",
           "queryable",
@@ -965,6 +975,11 @@
           "adjective",
           false
         ],
+        [
+          "memorable",
+          "deletable",
+          false
+        ],
         [
           "memorable",
           "theAble",
@@ -1415,6 +1430,11 @@
           "theAble",
           false
         ],
+        [
+          "recall",
+          "verb",
+          false
+        ],
         [
           "remember",
           "verb",

package/common/stm.js

@@ -1,5 +1,5 @@
 const { knowledgeModule, where, debug } = require('./runtime').theprogrammablemind
-const { defaultContextCheck } = require('./helpers')
+const { defaultContextCheckProperties, defaultContextCheck } = require('./helpers')
 const helpers = require('./helpers')
 const helpers_conjunction = require('./helpers/conjunction')
 const articles = require('./articles')
@@ -41,7 +41,7 @@ class API {
     return this._objects.mentioned.filter( (context) => this.isA(context.marker, type) )
   }
 
-  mentioned(args) {
+  remember(args) {
     let concept, value, frameOfReference
     if (!args.context) {
       concept = args
@@ -51,6 +51,10 @@ class API {
       frameOfReference = args.frameOfReference
     }
 
+    if (concept.pullFromContext) {
+      return
+    }
+
     if (!frameOfReference) {
       frameOfReference = this._objects
     }
@@ -76,8 +80,8 @@ class API {
     helpers.unshiftL(frameOfReference.mentioned, concept, this.maximumMentioned)
   }
 
-  mentions({ context, frameOfReference, useHierarchy=true, all, lastN, condition = (() => true) } = {}) {
-    let mentioned = this._objects.mentioned
+  recall({ context, frameOfReference, useHierarchy=true, all, stopCondition = (() => false), condition = (() => true), filter = ((result) => result) } = {}) {
+    let mentioned = this._objects.mentioned.filter((m) => !m.namespaced?.stm?.deleted)
     let reversed = false
     if (frameOfReference) {
       if (frameOfReference.namespaced?.stm?.mentioned) {
@@ -97,7 +101,7 @@ class API {
     if (!mentioned) {
       return
     }
-    const findPrevious = !!context.stm_previous
+    const findPrevious = !!context?.stm_previous
     const forAll = []
     function addForAll(context) {
       if (!forAll.find( (c) => c.namespaced.stm.id == context.namespaced.stm.id)) {
@@ -112,7 +116,7 @@ class API {
     // care about value first
     let findCounter = 0
     for (const m of mentioned) {
-      if (lastN === 0) {
+      if (stopCondition(m)) {
         break
       }
       if (context.value && (context.value == m.marker || context.value == m.value)) {
@@ -124,20 +128,17 @@ class API {
           continue
         }
         if (condition(m)) {
-          if (all || lastN) {
+          if (all) {
             addForAll(m)
-            if (lastN) {
-              lastN -= 1
-            }
           } else {
-            return m
+            return filter(m)
           }
         }
       }
     }
 
-    if (lastN === 0) {
-      return forAll
+    if (forAll.length > 0) {
+      return filter(forAll)
     }
 
     if (!useHierarchy) {
@@ -147,7 +148,7 @@ class API {
     // care about marker second
     findCounter = 0
     for (const m of mentioned) {
-      if (lastN === 0) {
+      if (stopCondition(m)) {
         break
       }
       if (context.marker != 'unknown' && this.isA(m.marker, context.marker)) {
@@ -159,19 +160,19 @@ class API {
           continue
         }
         if (condition(m)) {
-          if (all || lastN) {
+          if (all) {
             addForAll(m)
-            if (lastN) {
-              lastN -= 1
-            }
           } else {
-            return m
+            return filter(m)
           }
         }
       }
       // if (context.types && context.types.includes(m.marker)) {
       if (context.types) {
         for (const parent of context.types) {
+          if (stopCondition(m)) {
+            break
+          }
           if (parent != 'unknown' && this.isA(m.marker, parent)) {
             findCounter += 1
             if (findPrevious && findCounter < 2) {
@@ -181,13 +182,10 @@ class API {
               continue
             }
             if (condition(m)) {
-              if (all || lastN) {
-                if (lastN) {
-                  lastN -= 1
-                }
+              if (all) {
                 addForAll(m)
               } else {
-                return m
+                return filter(m)
               }
             }
           }
@@ -195,37 +193,34 @@ class API {
       }
     }
 
-    if (lastN === 0) {
-      return forAll
+    if (forAll.length > 0) {
+      return filter(forAll)
     }
 
     findCounter = 0
     if (context.types && context.types.length == 1) {
       for (const m of mentioned) {
-        if (lastN === 0) {
-          break
-        }
         if (context.unknown) {
           findCounter += 1
           if (findPrevious && findCounter < 2) {
             continue
           }
+          if (stopCondition(m)) {
+            break
+          }
           if (condition(m)) {
-            if (all || lastN) {
+            if (all) {
               addForAll(m)
-              if (lastN) {
-                lastN -= 1
-              }
             } else {
-              return m
+              return filter(m)
             }
           }
         }
       }
     }
 
-    if (all || lastN) {
-      return forAll
+    if (forAll.length > 0) {
+      return filter(forAll)
     }
   }
 
@@ -233,7 +228,7 @@ class API {
     if (!context || context.marker == 'mentions') {
       return
     }
-    let valueNew = this.mentions({ context, useHierarchy: false, condition: (context) => context.isVariable })
+    let valueNew = this.recall({ context, useHierarchy: false, condition: (context) => context.isVariable })
     if (valueNew && valueNew.value) {
       valueNew = valueNew.value
     }
@@ -241,7 +236,7 @@ class API {
   }
 
   setVariable(variableName, value) {
-    this.mentioned({ context: { marker: variableName, isVariable: true }, value })
+    this.remember({ context: { marker: variableName, isVariable: true }, value })
   }
 }
 
@@ -254,6 +249,8 @@ const config = {
     "(<stm_previous|previous> ([memorable]))",
     "(([memorable]) <stm_before|before>)",
     "([remember] (memorable/*))",
+    "([recall] (memorable/*))",
+    "([delete|delete,forget] ([deletable]))",
   ],
   words: {
     literals: {
@@ -262,10 +259,37 @@ const config = {
     },
   },
   bridges: [
+    { 
+      id: 'deletable', 
+    },
+    { 
+      id: 'delete', 
+      isA: ['verb'],
+      bridge: "{ ...next(operator), deletable: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'deletable' }] }",
+      semantic: async ({context, recall}) => {
+        const object = await recall({ context: context.deletable })
+        if (object) {
+          object.namespaced.stm.deleted = true
+          for (const callback of object.namespaced.stm.callbacks || []) {
+            callback.callback(object)
+          }
+        }
+      }
+    },
     { 
       id: 'memorable', 
-      isA: ['theAble'],
-      words: helpers.words('memorable') 
+      isA: ['theAble', 'deletable'],
+      words: helpers.words('memorable'),
+      check: defaultContextCheckProperties(),
+    },
+    { 
+      id: 'recall', 
+      bridge: "{ ...next(operator), postModifiers: ['recallee'], recallee: after[0] }",
+      isA: ['verb'],
+      semantic: async ({context, recall, resolveResponse, e}) => {
+        const object = await recall({ context: context.recallee })
+        resolveResponse(context, object)
+      },
     },
     { 
       id: 'remember', 
@@ -276,7 +300,7 @@ const config = {
         if (value == context.rememberee.value) {
           value = context.rememberee
         }
-        api.mentioned({ context: value })
+        api.remember({ context: value })
       },
     },
     { 
@@ -296,11 +320,24 @@ const config = {
     },  
   ],
   semantics: [
+    {
+      where: where(),
+      match: ({context}) => context.marker == 'mentions' && context.evaluate && context.args?.context?.distributer,
+      apply: async ({callId, _continue, toList, context, kms, e, log, toArray, retry}) => {
+        context.args.filter ??= (r) => r
+        context.args.all = true
+        const oldFilter = context.args.filter
+        context.args.filter = (result) => {
+          return oldFilter(result)
+        }
+        _continue()
+      }
+    },
     {
       where: where(),
       match: ({context}) => context.marker == 'mentions' && context.evaluate,
       apply: ({context, kms, toList, resolveEvaluate}) => {
-        resolveEvaluate(context, kms.stm.api.mentions(context.args))
+        resolveEvaluate(context, kms.stm.api.recall(context.args))
       }
     },
     { 
@@ -308,14 +345,13 @@ const config = {
       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, mentions, toList, context, kms, e, log, retry}) => {
-        context.value = (await mentions({ context }))
+      apply: async ({callId, recall, toList, context, kms, e, log, retry}) => {
+        context.value = (await recall({ context }))
         if (Array.isArray(context.value)) {
           context.value = toList(context.value)
         }
 
         if (!context.value) {
-          // retry()
           context.evalue = { marker: 'answerNotKnown' }
           return
         }
@@ -334,8 +370,8 @@ const config = {
 
 function initializer({config}) {
   config.addArgs(({kms, e, toList}) => ({
-    mentioned: (args) => {
-      kms.stm.api.mentioned(args)
+    remember: (args) => {
+      kms.stm.api.remember(args)
     },
 
     frameOfReference: (context, { mentioned, reversed } = {}) => {
@@ -349,7 +385,24 @@ function initializer({config}) {
       }
     },
 
-    mentions: async (args) => {
+    addCallback: (context, callback) => {
+      // init
+      context.namespaced ??= {}
+      context.namespaced.stm ??= {}
+      context.namespaced.stm.callbackCounter ??= 1
+      context.namespaced.stm.callbacks ??= []
+
+      // meat
+      context.namespaced.stm.callbackCounter += 1
+      const counter = context.namespaced.stm.callbackCounter
+      context.namespaced.stm.callbacks.push({ callback, counter })
+      callback.removeCallback = () => {
+        context.namespaced.stm.callbacks = context.namespaced.stm.callbacks.filter((cb) => cb.counter != counter)
+      }
+      return counter
+    },
+
+    recall: async (args) => {
       if (args.frameOfReference?.nameable_named) {
         const result = await e(args.frameOfReference)
         if (result.evalue) {
@@ -379,10 +432,19 @@ knowledgeModule( {
     name: './stm.test.json',
     contents: stm_tests,
     checks: {
-             context: [defaultContextCheck({ extra: ['pullFromContext', 'stm_id'] })],
-             objects: [{ path: ['mentioned'] }],
-             // objects: [defaultContextCheck({ extra: ['mentioned'] })],
-             // objects: [{ property: 'mentioned', check: helpers.defaultContextCheckProperties }],
-          },
+              context: [defaultContextCheck({ extra: ['pullFromContext', 'stm_id'] })],
+              objects: [
+                { 
+                  property: 'mentioned', 
+                  check: [{ 
+                    property: (key) => typeof key == 'number',
+                    check: [{ 
+                      property: 'namespaced', 
+                      check: [{ property: 'stm', check: ['id', 'deleted', 'named'] }]
+                    }] 
+                  }] ,
+                },
+              ],
+            },
   },
 })