ekms 8.0.0-beta.6 → 8.0.0-beta.60

package/common/math.js

@@ -1,4 +1,4 @@
-const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const dialogues = require('./dialogues')
 const numbers = require('./numbers')
@@ -33,22 +33,22 @@ const mathematicalOperator = (name, words, apply, before = []) => [
       id: `${name}Operator`, level: 0, 
       bridge: `{ ...next(operator), marker: next(operator('${name}Expression')), types: lub(append(['mathematicalExpression'], operator.types, before[0].types, after[0].types)), value: null, x: before[0], y: after[0], number: 'one', isResponse: true, evaluate: true }` ,
       // bridge: `{ ...next(operator), marker: next(operator('${name}Expression')), value: null, x: before[0], y: after[0], number: 'one', isResponse: true, evaluate: true }` ,
-      isA: ['mathematicalOperator'],
+      isA: ['mathematical_operator'],
       before,
       localHierarchy: [ ['unknown', 'number'] ],
       // levelSpecificHierarchy: [[1, 'mathematicalExpression']],
       words,
-      generatorp: ({gp, context}) => context.word,
+      generatorp: ({context}) => context.word,
   },
   { 
       where: where(),
       id: `${name}Expression`, level: 0, 
       bridge: "{ ...next(operator) }" ,
       isA: ['mathematicalExpression'],
-      generatorp: ({gp, context}) => `${gp(context.x)} ${context.word} ${gp(context.y)}`,
-      evaluator: ({e, context}) => {
-        const x = toValue(e(context.x)) 
-        const y = toValue(e(context.y))
+      generatorp: async ({gp, context}) => `${await gp(context.x)} ${context.word} ${await gp(context.y)}`,
+      evaluator: async ({e, context}) => {
+        const x = toValue(await e(context.x)) 
+        const y = toValue(await e(context.y))
         if (!x || !y) {
           // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }
           context.isResponse = false
@@ -69,11 +69,11 @@ const mathematicalOperator = (name, words, apply, before = []) => [
   }
 ]
     
-let configStruct = {
+let config = {
   name: 'math',
   operators: [
     "([mathematicalExpression])",
-    "([mathematicalOperator])",
+    "([mathematical_operator])",
     "(([number|]) [plusOperator] ([number|]))",
     "(([number|]) [minusOperator] ([number|]))",
     "(([number|]) [timesOperator] ([number|]))",
@@ -92,8 +92,8 @@ let configStruct = {
       isA: ['concept', 'number'],
     },
     { 
-      id: "mathematicalOperator", 
-      before: ['verby'],
+      id: "mathematical_operator", 
+      before: ['verb'],
       after: ['adjective'],
     },
     { id: "x", isA: ['number'], level: 0, bridge: '{ ...next(operator) }', development: true},
@@ -108,20 +108,16 @@ let configStruct = {
 const template = {
   configs: [
     "mathematical modifies operator",
-    "* + / and - are mathematical operators",
-    configStruct,
+    config,
+    // "* + / and - are mathematical operators",
   ]
 }
 
-const createConfig = () => {
-  const config = new Config({ name: 'math' }, module)
-  config.add(numbers(), dialogues(), punctuation(), countable(), comparable())
-  return config
-}
-
 knowledgeModule( { 
+  config: { name: 'math' },
+  includes: [numbers, dialogues, punctuation, countable, comparable],
+
   module,
-  createConfig,
   description: 'talking about math',
   template: { template, instance },
   test: {

package/common/meta.js

@@ -1,4 +1,4 @@
-const { Config, knowledgeModule, ensureTestFile, where, unflatten, flattens } = require('./runtime').theprogrammablemind
+const { knowledgeModule, ensureTestFile, where, unflatten, flattens } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const _ = require('lodash')
 const gdefaults = require('./gdefaults.js')
@@ -17,7 +17,7 @@ const template = {
 };
 
 // TODO -> if a car's top speed is over 200 mph then the car is fast
-let configStruct = {
+let config = {
   name: 'meta',
   operators: [
     "((phrase) [means] (phrase))",
@@ -130,8 +130,8 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker == 'orList' && context.paraphrase,
-      apply: ({context, gs}) => {
-        return gs(context.value, ', ', ' or ')
+      apply: async ({context, gs}) => {
+        return await gs(context.value, ', ', ' or ')
       },
       priority: -1,
     },
@@ -139,10 +139,8 @@ let configStruct = {
       priority: -1,
       where: where(),
       match: ({context}) => context.marker == 'means' && context.paraphrase,
-      apply: ({context, g}) => {
-        // const before = g({ ...context.from, paraphrase: true, debug: true})
-        const before = g({ ...context.from, paraphrase: true})
-        return `${g({ ...context.from, paraphrase: true})} means ${g(context.to)}`
+      apply: async ({context, g}) => {
+        return `${await g({ ...context.from, paraphrase: true})} means ${await g(context.to)}`
       }
     },
     { 
@@ -160,8 +158,8 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker === 'if',
-      apply: ({context, g}) => {
-        return `if ${g(context.antecedant)} then ${g(context.consequence)}`
+      apply: async ({context, g}) => {
+        return `if ${await g(context.antecedant)} then ${await g(context.consequence)}`
       },
       priority: -1,
     },
@@ -182,10 +180,10 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker == 'orList',
-      apply: ({context, s}) => {
+      apply: async ({context, s}) => {
         const response = []
         for (const value of context.value) {
-          response.push(s(value))
+          response.push(await s(value))
         }
         context.evalue = {
           marker: 'orList', 
@@ -205,7 +203,7 @@ let configStruct = {
           const apply = (DEFINITIONs, DERIVED) => {
             const mappingss = translationMappings(DEFINITIONs, DERIVED)
             const invertMappings = (mappings) => mappings.map( ({ from, to }) => { return { to: from, from: to } } )
-            return ({context, s, g, config}) => { 
+            return async ({context, s, config}) => { 
               DEFINITIONs = _.cloneDeep(DEFINITIONs)
               //const mappings = mappingss[0]
               let toPrimes = []
@@ -215,8 +213,7 @@ let configStruct = {
                 }
                 // next move add debug arg to s and g
                 TO.query = true
-                toPrimes.push([s(TO), mappings])
-                // toPrime = s(TO, { debug: { apply: true } })
+                toPrimes.push([await s(TO), mappings])
               }
 
               let hasResponse = false
@@ -271,7 +268,7 @@ let configStruct = {
             // match: match(context), 
             where: where(),
             match: match(context),
-            apply: apply(antecedants, _.cloneDeep(context.consequence)) ,
+            apply: apply(antecedants, _.cloneDeep(context.consequence)),
           }
           config.addSemantic(semantic)
       }
@@ -280,17 +277,14 @@ let configStruct = {
       notes: 'from means to where from is unknown',
       where: where(),
       match: ({context}) => context.marker == 'means' && context.from.marker == 'unknown',
-      apply: ({config, context, kms, e, isTest}) => {
+      apply: async ({config, context, kms, e, isTest}) => {
         if (false && isTest) {
           return
         } else if (kms.dialogues) {
           if (context.to.value) {
             kms.stm.api.setVariable(context.from.value, context.to.value)
           } else {
-            // config.addWord(context.from.word, 
             kms.dialogues.api.makeObject({ context: context.from, types: context.to.types || [], config });
-            // kms.dialogues.api.makeObject({ context: context.from, types: [], config });
-            // const r = e(context.to)
             kms.stm.api.setVariable(context.from.value, context.to)
           }
         }
@@ -300,17 +294,17 @@ let configStruct = {
       notes: 'x means y where x and y have known markers',
       where: where(),
       match: ({context}) => context.marker == 'means',
-      apply: ({config, context, g}) => {
+      apply: async ({config, context, g}) => {
         // setup the write semantic
         {
           const matchByMarker = (defContext) => ({context}) => context.marker == defContext.from.marker && !context.query && !context.objects
           const matchByValue = (defContext) => ({context}) => context.evalue == defContext.from.value && !context.query && !context.objects
-          const apply = (mappings, TO) => ({context, s}) => {
+          const apply = (mappings, TO) => async ({context, s}) => {
             TO = _.cloneDeep(TO)
             for (let { from, to } of mappings) {
               hashIndexesSet(TO, to, hashIndexesGet(context, from))
             }
-            toPrime = s(TO)
+            toPrime = await s(TO)
             context.result = toPrime.result
           }
           const mappings = translationMapping(context.from, context.to)
@@ -332,7 +326,7 @@ let configStruct = {
         {
           const matchByMarker = (defContext) => ({context, uuid}) => context.marker == defContext.from.marker && (context.query || context.evaluate) && !context[`disable${uuid}`]
           const matchByValue = (defContext) => ({context, uuid}) => context.value == defContext.from.value && (context.query || context.evaluate) && !context[`disable${uuid}`]
-          const apply = (mappings, TO) => ({uuid, context, s, g, config}) => {
+          const apply = (mappings, TO) => async ({uuid, context, s, g, config}) => {
             TO = _.cloneDeep(TO)
             for (let { from, to } of mappings) {
               hashIndexesSet(TO, to, hashIndexesGet(context, from))
@@ -345,8 +339,7 @@ let configStruct = {
               TO.evaluate = context.evaluate
             }
             TO[`disable${uuid}`] = true
-            // toPrime = s(TO, { debug: { apply: true } })
-            toPrime = s(TO)
+            toPrime = await s(TO)
             if (context.query) {
               if (toPrime.evalue) {
                 context.evalue = toPrime.evalue
@@ -359,7 +352,7 @@ let configStruct = {
           }
           const mappings = translationMapping(context.from, context.to)
           let match = matchByMarker(context)
-          context.metaInfo = `The mapping from from the expression being defined "${g({...context.from, paraphrase: true})}" to the definition phrase "${g({...context.to, paraphrase: true})}" is ${JSON.stringify(mappings)}`
+          context.metaInfo = `The mapping from from the expression being defined "${await g({...context.from, paraphrase: true})}" to the definition phrase "${await g({...context.to, paraphrase: true})}" is ${JSON.stringify(mappings)}`
           if (context.from.value) {
             match = matchByValue(context)
           }
@@ -378,29 +371,12 @@ let configStruct = {
   ],
 };
 
-const createConfig = () => {
-  const config = new Config(configStruct, module)
-  config.stop_auto_rebuild()
-  config.add(gdefaults())
-
-  config.initializer( ({config, addGenerator, isModule}) => {
-    if (!isModule) {
-      addGenerator({
-        where: where(),
-        match: ({context}) => context.marker == 'unknown',
-        apply: ({context}) => `${context.word}`
-      })
-    }
-  })
-  
-  config.restart_auto_rebuild()
-  return config
-}
-
 knowledgeModule({ 
+  config,
+  includes: [gdefaults],
+
   module,
   description: 'Ways of defining new language elements',
-  createConfig,
   test: {
     name: './meta.test.json',
     contents: meta_tests,

package/common/nameable.instance.json

@@ -0,0 +1,2 @@
+{
+}

package/common/nameable.js

@@ -0,0 +1,135 @@
+const { knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { defaultContextCheck } = require('./helpers')
+const helpers = require('./helpers')
+const stm = require('./stm')
+const nameable_tests = require('./nameable.test.json')
+
+class API {
+  initialize({ objects, km, kms }) {
+    this.objects = objects
+    this.objects.named = {}
+  }
+
+  // report is a context
+  setName(context, name) {
+    if (!context.stm) {
+      context.stm = {}
+    }
+    if (!context.stm.names) {
+      context.stm.names = []
+    }
+    context.stm.names.push(name)
+  }
+
+  get(type, name) {
+    return this.args.kms.stm.api.mentions({ 
+      context: type, 
+      condition: (context) => {
+        if (context.stm && context.stm.names) {
+          return context.stm.names.includes(name)
+        }
+      }
+    })
+  }
+
+  getNamesByType(type) {
+    const contexts = this.args.kms.stm.api.getByType(type)
+    const names = new Set()
+    for (const context of contexts) {
+      if (context.stm.names) {
+        for (const name of context.stm.names) {
+          names.add(name)
+        }
+      }
+    }
+    return [...names]
+  }
+
+  getNames(nameable) {
+    return (nameable.stm && nameable.stm.names) || []
+  }
+
+  /*
+  getNames() {
+    const current = this.current()
+    console.log('getReportNames current', JSON.stringify(current, null, 2))
+    return Object.keys(this.objects.namedReports).map( (name) => {
+      const selected = (current.names || []).includes(name)
+      return { name, selected, id: name }
+    })
+  }
+  */
+
+  setCurrent(name) {
+    const context = this.objects.named[name]
+    if (context) {
+      this.args.km('stm').api.mentioned({ context })
+    }
+  }
+}
+
+const api = new API()
+
+const config = {
+  name: 'nameable',
+  operators: [
+    "([call] ([nameable]) (name))",
+    { pattern: "([getNamesByType] (type))", development: true },
+    { pattern: "([m1])", development: true },
+//    { pattern: "([testPullFromContext] ([memorable]))", development: true }
+  ],
+  words: {
+    literals: {
+//      "m1": [{"id": "memorable", development: true, "initial": "{ value: 'm1' }" }],
+//      "m2": [{"id": "memorable", development: true, "initial": "{ value: 'm2' }" }],
+    },
+  },
+  bridges: [
+    {
+      id: 'm1',
+      isA: ['memorable', 'nameable'],
+      development: true,
+    },
+    {
+      id: 'getNamesByType',
+      development: true,
+      isA: ['verb'],
+      bridge: "{ ...next(operator), type: after[0] }",
+      semantic: async ({context, api}) => {
+        context.response = api.getNamesByType(context.type.value).join(" ")
+        context.isResponse = true
+      }
+    },
+    {
+      id: 'call',
+      isA: ['verb'],
+      bridge: "{ ...next(operator), nameable: after[0], name: after[1] }",
+      generatorp: async ({context, g}) => `call ${await g(context.nameable)} ${await g(context.name)}`,
+      semantic: async ({config, context, api, e}) => {
+        // TODO find report being referred to
+        const nameable = (await e(context.nameable)).evalue
+        const name = context.name.text
+        config.addWord(name, { id: nameable.marker, initial: `{ value: "${name}", pullFromContext: true, nameable_named: true }` })
+        api.setName(nameable, name)
+      }
+    },
+    { id: 'nameable', words: helpers.words('nameable')},
+  ]
+}
+
+knowledgeModule( { 
+  config,
+  api: () => new API(),
+  includes: [stm],
+
+  module,
+  description: 'namable objects',
+  test: {
+    name: './nameable.test.json',
+    contents: nameable_tests,
+    checks: {
+            context: [...defaultContextCheck, 'pullFromContext'],
+            objects: ['mentioned', { km: 'stm' }],
+          },
+  },
+})