ekms 9.6.3-beta.9 → 9.7.0

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')
@@ -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)
   }
 
-  recall({ context, frameOfReference, useHierarchy=true, all, condition = (() => true), filter = ((result) => result) } = {}) {
-    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,6 +116,9 @@ class API {
     // care about value first
     let findCounter = 0
     for (const m of mentioned) {
+      if (stopCondition(m)) {
+        break
+      }
       if (context.value && (context.value == m.marker || context.value == m.value)) {
         findCounter += 1
         if (findPrevious && findCounter < 2) {
@@ -141,6 +148,9 @@ class API {
     // care about marker second
     findCounter = 0
     for (const m of mentioned) {
+      if (stopCondition(m)) {
+        break
+      }
       if (context.marker != 'unknown' && this.isA(m.marker, context.marker)) {
         findCounter += 1
         if (findPrevious && findCounter < 2) {
@@ -160,6 +170,9 @@ class API {
       // 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) {
@@ -192,6 +205,9 @@ class API {
           if (findPrevious && findCounter < 2) {
             continue
           }
+          if (stopCondition(m)) {
+            break
+          }
           if (condition(m)) {
             if (all) {
               addForAll(m)
@@ -233,6 +249,8 @@ const config = {
     "(<stm_previous|previous> ([memorable]))",
     "(([memorable]) <stm_before|before>)",
     "([remember] (memorable/*))",
+    "([recall] (memorable/*))",
+    "([delete|delete,forget] ([deletable]))",
   ],
   words: {
     literals: {
@@ -241,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', 
@@ -275,6 +320,19 @@ 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,
@@ -294,7 +352,6 @@ const config = {
         }
 
         if (!context.value) {
-          // retry()
           context.evalue = { marker: 'answerNotKnown' }
           return
         }
@@ -328,6 +385,23 @@ function initializer({config}) {
       }
     },
 
+    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)
@@ -358,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'] }]
+                    }] 
+                  }] ,
+                },
+              ],
+            },
   },
 })