ekms 8.0.0 → 8.1.0

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,140 +14,142 @@ 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}) => {
-          // debugger;
-          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 })
         }
+        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,
     checks: {
-      context: defaultContextCheck,
+      context: defaultContextCheck(),
       objects: [],
     }
   }

package/common/conjunction.instance.json

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

package/common/conjunction.js

@@ -0,0 +1,104 @@
+const { knowledgeModule, where } = require('./runtime').theprogrammablemind
+const gdefaults = require('./gdefaults.js')
+const conjunction_tests = require('./conjunction.test.json')
+const { defaultContextCheck } = require('./helpers')
+
+let config = {
+  name: 'conjunction',
+  operators: [
+    "(x [list|and] y)",
+  ],
+  bridges: [
+    // context.instance == variables.instance (unification)
+    {
+      id: "list", 
+      level: 0, 
+      selector: {
+          match: "same", 
+          left: [ { pattern: '($type && context.instance == variables.instance)' } ], 
+          right: [ { pattern: '($type && context.instance == variables.instance)' } ], 
+          // left: [ { pattern: '($type)' } ], 
+          // right: [ { pattern: '($type)' } ], 
+          passthrough: true
+      }, 
+      bridge: "{ ...next(operator), listable: true, isList: true, value: append(before, after) }"
+    },
+    {
+      id: "list", 
+      level: 1, 
+      selector: {
+          match: "same", 
+          left: [ { pattern: '($type && context.instance == variables.instance)' } ], 
+          passthrough: true
+     }, 
+      bridge: "{ ...operator, value: append(before, operator.value) }"
+    },
+  ],
+  generators: [
+    {
+      where: where(),
+      notes: 'handle lists with yes no',
+      // ({context, hierarchy}) => context.marker == 'list' && context.paraphrase && context.value,
+      // ({context, hierarchy}) => context.marker == 'list' && context.value,
+      match: ({context, hierarchy}) => context.marker == 'list' && context.paraphrase && context.value && context.value.length > 0 && context.value[0].marker == 'yesno',
+      apply: async ({context, g, gs}) => {
+        return `${await g(context.value[0])} ${await gs(context.value.slice(1), ', ', ' and ')}`
+      }
+    },
+
+    {
+      where: where(),
+      notes: 'handle lists',
+      // ({context, hierarchy}) => context.marker == 'list' && context.paraphrase && context.value,
+      // ({context, hierarchy}) => context.marker == 'list' && context.value,
+      match: ({context, hierarchy}) => context.marker == 'list' && context.value,
+      apply: async ({context, gs}) => {
+        if (context.newLinesOnly) {
+          return await gs(context.value, '\n')
+        } else {
+          return await gs(context.value, ', ', ' and ')
+        }
+      }
+    },
+  ],
+};
+
+const initializer = ({objects, config, isModule}) => {
+  config.addArgs(({config, api, isA}) => ({ 
+    isAListable: (context, type) => {
+      if (context.marker == 'list' || context.listable) {
+        return context.value.every( (element) => isA(element.marker, type) )
+      } else {
+        return isA(context.marker, type)
+      } 
+    },
+    toContext: (v) => {
+      if (Array.isArray(v)) {
+        return { marker: 'list', level: 1, value: v }
+      }
+      if (v.marker == 'list') {
+        return v
+      }
+      return v
+    },
+  }))
+}
+
+knowledgeModule( { 
+  config,
+  includes: [gdefaults],
+  initializer,
+
+  module,
+  description: 'framework for conjunction',
+  newWay: true,
+  test: {
+    name: './conjunction.test.json',
+    contents: conjunction_tests,
+    checks: {
+            objects: ['idSuffix'],
+            context: defaultContextCheck(),
+          },
+
+  },
+})

package/common/conjunction.test.json

@@ -0,0 +1,322 @@
+[
+  {
+    "associations": [
+      [
+        [
+          "list",
+          0
+        ],
+        [
+          "unknown",
+          0
+        ]
+      ],
+      [
+        [
+          "list",
+          0
+        ],
+        [
+          "unknown",
+          0
+        ],
+        [
+          "unknown",
+          1
+        ]
+      ],
+      [
+        [
+          "list",
+          0
+        ],
+        [
+          "unknown",
+          1
+        ]
+      ],
+      [
+        [
+          "list",
+          1
+        ],
+        [
+          "unknown",
+          1
+        ]
+      ]
+    ],
+    "config": {
+    },
+    "contexts": [
+      {
+        "default": true,
+        "isList": true,
+        "level": 1,
+        "listable": true,
+        "marker": "list",
+        "range": {
+          "end": 8,
+          "start": 0
+        },
+        "text": "1 2 and 3",
+        "topLevel": true,
+        "types": [
+          "list",
+          "unknown"
+        ],
+        "value": [
+          {
+            "dead": true,
+            "level": 1,
+            "marker": "unknown",
+            "range": {
+              "end": 0,
+              "start": 0
+            },
+            "text": "1",
+            "types": [
+              "unknown"
+            ],
+            "unknown": true,
+            "value": "1",
+            "word": "1"
+          },
+          {
+            "dead": true,
+            "level": 1,
+            "marker": "unknown",
+            "range": {
+              "end": 2,
+              "start": 2
+            },
+            "text": "2",
+            "types": [
+              "unknown"
+            ],
+            "unknown": true,
+            "value": "2",
+            "word": "2"
+          },
+          {
+            "dead": true,
+            "level": 1,
+            "marker": "unknown",
+            "range": {
+              "end": 8,
+              "start": 8
+            },
+            "text": "3",
+            "types": [
+              "unknown"
+            ],
+            "unknown": true,
+            "value": "3",
+            "word": "3"
+          }
+        ],
+        "word": "and"
+      }
+    ],
+    "developerTest": false,
+    "generatedParenthesized": [
+      ""
+    ],
+    "metadata": {
+      "opChoices": [
+        {
+          "counter": 1,
+          "op": [
+            "unknown",
+            0
+          ],
+          "ops": [
+            [
+              "list",
+              0
+            ],
+            [
+              "unknown",
+              0
+            ],
+            [
+              "unknown",
+              0
+            ],
+            [
+              "unknown",
+              0
+            ]
+          ]
+        },
+        {
+          "counter": 2,
+          "op": [
+            "unknown",
+            0
+          ],
+          "ops": [
+            [
+              "list",
+              0
+            ],
+            [
+              "unknown",
+              0
+            ],
+            [
+              "unknown",
+              0
+            ]
+          ]
+        },
+        {
+          "counter": 3,
+          "op": [
+            "unknown",
+            0
+          ],
+          "ops": [
+            [
+              "list",
+              0
+            ],
+            [
+              "unknown",
+              0
+            ]
+          ]
+        },
+        {
+          "counter": 4,
+          "op": [
+            "list",
+            0
+          ],
+          "ops": [
+            [
+              "list",
+              0
+            ]
+          ]
+        },
+        {
+          "counter": 5,
+          "op": [
+            "list",
+            1
+          ],
+          "ops": [
+            [
+              "list",
+              1
+            ]
+          ]
+        }
+      ]
+    },
+    "objects": {
+      "nameToUUID": {
+        "conjunction": "conjunction1",
+        "gdefaults": "gdefaults2",
+        "tokenize": "tokenize2"
+      },
+      "namespaced": {
+        "conjunction1": {
+        },
+        "gdefaults2": {
+        },
+        "tokenize2": {
+        }
+      },
+      "processed": [
+        {
+          "context": {
+            "default": true,
+            "isList": true,
+            "level": 1,
+            "listable": true,
+            "marker": "list",
+            "range": {
+              "end": 8,
+              "start": 0
+            },
+            "text": "1 2 and 3",
+            "topLevel": true,
+            "types": [
+              "list",
+              "unknown"
+            ],
+            "value": [
+              {
+                "dead": true,
+                "level": 1,
+                "marker": "unknown",
+                "range": {
+                  "end": 0,
+                  "start": 0
+                },
+                "text": "1",
+                "types": [
+                  "unknown"
+                ],
+                "unknown": true,
+                "value": "1",
+                "word": "1"
+              },
+              {
+                "dead": true,
+                "level": 1,
+                "marker": "unknown",
+                "range": {
+                  "end": 2,
+                  "start": 2
+                },
+                "text": "2",
+                "types": [
+                  "unknown"
+                ],
+                "unknown": true,
+                "value": "2",
+                "word": "2"
+              },
+              {
+                "dead": true,
+                "level": 1,
+                "marker": "unknown",
+                "range": {
+                  "end": 8,
+                  "start": 8
+                },
+                "text": "3",
+                "types": [
+                  "unknown"
+                ],
+                "unknown": true,
+                "value": "3",
+                "word": "3"
+              }
+            ],
+            "word": "and"
+          },
+          "generatedParenthesized": "",
+          "paraphrases": "1, 2 and 3",
+          "paraphrasesParenthesized": "((1), (2) and (3))",
+          "responses": [
+            ""
+          ]
+        }
+      ]
+    },
+    "paraphrases": [
+      "1, 2 and 3"
+    ],
+    "paraphrasesParenthesized": [
+      "((1), (2) and (3))"
+    ],
+    "query": "1 2 and 3",
+    "responses": [
+      ""
+    ]
+  }
+]