ekms 8.0.0-beta.7 → 8.0.0-beta.71

package/common/concept.js

@@ -1,4 +1,4 @@
-const { Config, knowledgeModule, flatten, where, Digraph } = require('./runtime').theprogrammablemind
+const { knowledgeModule, flatten, where, Digraph } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const { API }= require('./helpers/concept')
 const dialogues = require('./dialogues.js')
@@ -14,135 +14,137 @@ const concept_instance = require('./concept.instance.json')
   plain and regular fries mean the same thing
 */
 
-const createConfig = () => {
-  const config = new Config({
-    name: 'concept',
-    operators: [
-      "((context.punctuation != true)* [modifies|] (concept))",
-      "([concept])",
-      "([literally] (modifies/0))",
-    ],
-    bridges: [
-      {
-        id: "modifies",
-        isA: ['verby'],
-        words: [{ word: 'modifies', number: 'one', flatten: false }, { word: 'modify', number: 'many', flatten: true }],
-        // bridge: "{ ...next(operator), modifiers: before, concept: after[0], flatten: true }"
-        bridge: "{ ...next(operator), modifiers: before, concept: after[0] }"
-      },
-      { id: "literally", bridge: "{ ...after[0], flatten: false, literally: true }" },
-      { id: "concept", bridge: "{ ...next(operator) }" },
-    ],
-    priorities: [
-      { "context": [['literally', 0], ['modifies', 0], ], "choose": [0] },
-    ],
-    hierarchy: [
-      ['concept', 'theAble'],
-      ['concept', 'queryable'],
-    ],
-    generators: [
-      {
-        notes: '"fire type, water type and earth type" to "fire water and earth type"',
-        /*
-          {
-            "water": {
-              "marker": "water",
-              "value": "water",
-              "word": "water"
-            },
-            "marker": "water_type",
-            "modifiers": [
-              "water"
-            ],
-            "types": [
-              "water_type"
-            ],
-            "value": "water_type",
-            "word": "type",
-            "paraphrase": true
+config = {
+  name: 'concept',
+  operators: [
+    "((context.punctuation != true)* [modifies|] (concept))",
+    "([concept])",
+    "([literally] (modifies/0))",
+  ],
+  bridges: [
+    {
+      id: "modifies",
+      isA: ['verb'],
+      words: [{ word: 'modifies', number: 'one', flatten: false }, { word: 'modify', number: 'many', flatten: true }],
+      // bridge: "{ ...next(operator), modifiers: before, concept: after[0], flatten: true }"
+      bridge: "{ ...next(operator), modifiers: before, concept: after[0] }"
+    },
+    { id: "literally", bridge: "{ ...after[0], flatten: false, literally: true }" },
+    { id: "concept", bridge: "{ ...next(operator) }" },
+  ],
+  priorities: [
+    { "context": [['literally', 0], ['modifies', 0], ], "choose": [0] },
+  ],
+  hierarchy: [
+    ['concept', 'theAble'],
+    ['concept', 'queryable'],
+  ],
+  generators: [
+    {
+      notes: '"fire type, water type and earth type" to "fire water and earth type"',
+      /*
+        {
+          "water": {
+            "marker": "water",
+            "value": "water",
+            "word": "water"
           },
-        */
-        where: where(),
-        match: ({context}) => {
-          if (!context.paraphrase) {
-            return
-          }
-          if (context.marker !== 'list') {
-            return
-          }
-          if ((context.value || []).length < 2) {
-            return
-          }
-          if (!context.value[0].word) {
-            return
-          }
-          const word = context.value[0].word
-
-          for (let value of context.value) {
-            if (!(value.modifiers && value.modifiers.length == 1 && value.word == word)) {
-              return
-            }
-          }
-          return true
+          "marker": "water_type",
+          "modifiers": [
+            "water"
+          ],
+          "types": [
+            "water_type"
+          ],
+          "value": "water_type",
+          "word": "type",
+          "paraphrase": true
         },
-        apply: ({g, context}) => {
-          const modifiers = context.value.map( (p) => p[p.modifiers[0]] )
-          context.word = context.value[0].word
-          context.value = null
-          context.modifiers = ['modifier']
-          context.modifier = {
-            marker: 'list',
-            paraphrase: true,
-            value: modifiers
-          }
-          context.paraphrase = true
-          return g(context)
+      */
+      where: where(),
+      match: ({context}) => {
+        if (!context.paraphrase) {
+          return
         }
-      },
-      {
-        where: where(),
-        match: ({context}) => context.marker == 'modifies' && context.paraphrase,
-        apply: ({context, gp, gw}) => {
-          if (context.literally) {
-            return `${context.modifiers.map(gp).join(" ")} literally ${gw(context, { number: context.modifiers[context.modifiers.length - 1] })} ${gp(context.concept)}`
-          } else {
-            return `${context.modifiers.map(gp).join(" ")} ${gw(context, { number: context.modifiers[context.modifiers.length - 1] })} ${gp(context.concept)}`
-          }
+        if (context.marker !== 'list') {
+          return
         }
-        // const chosen = chooseNumber(context, word.singular, word.plural)
-      },
-    ],
-    semantics: [
-      {
-        notes: 'define a modifier',
-        where: where(),
-        match: ({context}) => context.marker == 'modifies',
-        apply: ({config, query, km, context}) => {
-          let modifiers
-          if (context.literally) {
-            literalModifiers = context.modifiers[0]
-            modifiers = literalModifiers.value.map(modifier => modifier.value)
-            modifiers = modifiers.slice(0, -1).concat([literalModifiers.marker]).concat(modifiers.slice(-1))
-          } else {
-            modifiers = context.modifiers.map(modifier => modifier.value)
+        if ((context.value || []).length < 2) {
+          return
+        }
+        if (!context.value[0].word) {
+          return
+        }
+        const word = context.value[0].word
+
+        for (let value of context.value) {
+          if (!(value.modifiers && value.modifiers.length == 1 && value.word == word)) {
+            return
           }
-          // km('concept').api.kindOfConcept({ config, modifiers, object: context.concept.value || context.concept.marker })
-          km('concept').api.kindOfConcept({ config, modifiers, object: context.concept })
         }
+        return true
       },
-    ],
-  }, module)
-  config.stop_auto_rebuild()
-  config.api = new API()
-  config.add(dialogues())
-  config.restart_auto_rebuild()
-  return config
+      apply: async ({g, context}) => {
+        const modifiers = context.value.map( (p) => p[p.modifiers[0]] )
+        context.word = context.value[0].word
+        context.value = null
+        context.modifiers = ['modifier']
+        context.modifier = {
+          marker: 'list',
+          paraphrase: true,
+          value: modifiers
+        }
+        context.paraphrase = true
+        return await g(context)
+      }
+    },
+    {
+      where: where(),
+      match: ({context}) => context.marker == 'modifies' && context.paraphrase,
+      apply: async ({context, gp, gw}) => {
+        const modifiers = []
+        for (modifier of context.modifiers) {
+          modifiers.push(await gp(modifier))
+        }
+        if (context.literally) {
+          return `${modifiers.join(" ")} literally ${await gw(context, { number: context.modifiers[context.modifiers.length - 1] })} ${await gp(context.concept)}`
+        } else {
+          return `${modifiers.join(" ")} ${await gw(context, { number: context.modifiers[context.modifiers.length - 1] })} ${await gp(context.concept)}`
+        }
+      }
+      // const chosen = chooseNumber(context, word.singular, word.plural)
+    },
+  ],
+  semantics: [
+    {
+      notes: 'define a modifier',
+      where: where(),
+      match: ({context}) => context.marker == 'modifies',
+      apply: ({config, query, km, context}) => {
+        let modifiers
+        if (context.literally) {
+          literalModifiers = context.modifiers[0]
+          // modifiers = literalModifiers.value.map(modifier => modifier.value)
+          modifiers = literalModifiers.value
+          modifiers = modifiers.slice(0, -1).concat([literalModifiers.marker]).concat(modifiers.slice(-1))
+        } else {
+          modifiers = context.modifiers
+          // modifiers = context.modifiers.map(modifier => modifier.value)
+        }
+        // km('concept').api.kindOfConcept({ config, modifiers, object: context.concept.value || context.concept.marker })
+        km('concept').api.kindOfConcept({ config, modifiers, object: context.concept })
+      }
+    },
+  ],
 }
 
 knowledgeModule({ 
+  config,
+  includes: [dialogues],
+  api: () => new API(),
+
   module,
   description: 'The idea of a concept whatever that might end up being',
-  createConfig,
   test: {
     name: './concept.test.json',
     contents: concept_tests,

package/common/countable.js

@@ -1,4 +1,4 @@
-const { Config, knowledgeModule, where, Digraph } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where, Digraph } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const dialogues = require("./hierarchy")
 const numbers = require("./numbers")
@@ -11,12 +11,14 @@ const countable_tests = require('./countable.test.json')
     2 6 and 3 10 piece nuggets
  */
 
-let configStruct = {
+let config = {
   name: 'countable',
   operators: [
     "(([quantifier|]) [counting] ([countable]))",
     "(([number|]) [countOfPieces|] ([piece]))",
     "((countOfPieces/*) [countingPieces] ([hasCountOfPieces]))",
+    "([more] (countable/*))",
+    "([less] (countable/*))",
     "([all])",
     // everything
   ],
@@ -24,7 +26,7 @@ let configStruct = {
     { 
       id: "counting", 
       convolution: true, 
-      before: ['verby'],
+      before: ['verb'],
       bridge: "{ ...after, modifiers: append(['quantity'], after[0].modifiers), quantity: before[0], number: default(before[0].number, before[0].value), instance: true }" 
     },
     { 
@@ -44,6 +46,14 @@ let configStruct = {
     { 
       id: "piece", 
     },
+    { 
+      id: "more", 
+      bridge: "{ ...next(after[0]), more: operator, modifiers: append(['more'], after[0].modifiers) }",
+    },
+    { 
+      id: "less", 
+      bridge: "{ ...next(after[0]), less: operator, modifiers: append(['less'], after[0].modifiers) }",
+    },
     { 
       id: "quantifier", 
       children: ['number', 'all'],
@@ -63,28 +73,24 @@ let configStruct = {
     { 
       where: where(),
       match: ({context}) => false && context.quantity,
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         let number = context.quantity.number || 'one'
         if (context.quantity.value > 1) {
           number = 'many'
         }
-        const countable = g({ ...context, quantity: undefined, number})
-        return `${g(context.quantity)} ${countable}`
+        const countable = await g({ ...context, quantity: undefined, number})
+        return `${await g(context.quantity)} ${countable}`
       }
     },
   ]
 };
 
-const createConfig = () => {
-  const config = new Config(configStruct, module)
-  config.add(dialogues(), numbers())
-  return config
-}
-
 knowledgeModule({ 
+  config,
+  includes: [dialogues, numbers],
+
   module,
   description: 'Countable things',
-  createConfig,
   test: {
     name: './countable.test.json',
     contents: countable_tests,