ekms 8.0.0-beta.9 → 8.0.0-beta.91

package/common/properties.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 meta = require('./meta')
@@ -79,7 +79,7 @@ const template = {
 
 const api = new API();
 
-let configStruct = {
+let config = {
   name: 'properties',
   operators: [
     "([hierarchyAble|])",
@@ -112,22 +112,29 @@ let configStruct = {
     // ['concept', 'theAble'],
     // ['concept', 'queryable'],
     ['unknown', 'hierarchyAble'],
-    ['unknown', 'object'],
+    // ['unknown', 'object'],
     ['what', 'object'],
-    ['hierarchyAble', 'queryable'],
-    ['readonly', 'queryable'],
-    ['property', 'queryable'],
-    ['object', 'queryable'],
-    ['xfx', 'queryable'],
-    ['property', 'theAble'],
-    ['property', 'unknown'],
-    ['object', 'theAble'],
-    ['whose', 'object'],
-    ['have', 'canBeDoQuestion'],
-    ['have', 'canBeQuestion'],
+    // ['hierarchyAble', 'queryable'],
+    // ['readonly', 'queryable'],
+    // ['object', 'queryable'],
+    // ['xfx', 'queryable'],
+  
+    // ['property', 'queryable'],
+    // ['property', 'theAble'],
+    // ['property', 'unknown'],
+ 
+    // ['object', 'theAble'],
+    // ['whose', 'object'],
+    // ['have', 'canBeDoQuestion'],
+    // ['have', 'canBeQuestion'],
   ],
   bridges: [
-    { id: 'xfx', level: 0, bridge: "{ ...next(operator) }" },
+    { 
+      id: 'xfx', 
+      level: 0, 
+      isA: ['queryable'],
+      bridge: "{ ...next(operator) }" 
+    },
     { 
       id: 'between', 
       isA: ['preposition'],
@@ -136,7 +143,12 @@ let configStruct = {
     },
     { id: 'between', level: 1, bridge: "{ ...before[0], arguments: operator.arguments }" },
 
-    { id: 'hierarchyAble', level: 0, bridge: "{ ...next(operator) }" },
+    { 
+      id: 'hierarchyAble', 
+      level: 0, 
+      isA: ['queryable'],
+      bridge: "{ ...next(operator) }" 
+    },
     /*
     { 
       id: "modifies", 
@@ -144,37 +156,91 @@ let configStruct = {
       bridge: "{ ...next(operator), modifier: before[0], concept: after[0] }" 
     },
     */
-    { id: "readonly", level: 0, bridge: "{ ...next(operator) }" },
+    { 
+      id: "readonly", 
+      level: 0, 
+      isA: ['queryable'],
+      bridge: "{ ...next(operator) }" 
+    },
     // { id: "concept", level: 0, bridge: "{ ...next(operator) }" },
     // the cars dont have wings
     // greg doesnt have wings 
     // { id: "doesnt", level: 0, bridge: "{ ...context, number: operator.number, negation: true }*" },
     // { id: "doesnt", level: 0, bridge: "{ ...context, number: 'one', negation: true }*" },
     { id: "doesnt", level: 0, bridge: "{ ...context, number: operator.number, object.number: operator.number, negation: true }*" },
-    { id: "have", level: 0, bridge: "{ ...next(operator), object: { number: operator.number, ...before }, property: after[0], do: { left: 'object', right: 'property' } }" },
-    { id: "have", level: 1, bridge: "{ ...next(operator) }" },
+    { 
+      id: "have", 
+      level: 0, 
+      isA: ['canBeDoQuestion', 'canBeQuestion'],
+      localHierarchy: [['property', 'queryable'], ['property', 'theAble'], ['property', 'unknown'], ['object', 'unknown']],
+      bridge: "{ ...next(operator), object: { number: operator.number, ...before }, property: after[0], do: { left: 'object', right: 'property' } }" 
+    },
+    { 
+      id: "have", 
+      level: 1, 
+      localHierarchy: [['property', 'queryable'], ['property', 'theAble'], ['property', 'unknown']],
+      bridge: "{ ...next(operator) }" 
+    },
     { 
       id: "property", 
       words: ['properties'],
+      isA: ['queryable', 'theAble'],
+      level: 0, 
+      bridge: "{ ...next(operator) }" 
+    },
+    { 
+      id: "object", 
+      isA: ['queryable', 'theAble'],
       level: 0, 
       bridge: "{ ...next(operator) }" 
     },
-    { id: "object", level: 0, bridge: "{ ...next(operator) }" },
 
     // old
     // { id: "possession", level: 0, bridge: "{ ...next(operator), object: before[0] }" },
     // { id: "possession", level: 1, bridge: "{ ...after[0], object: operator.object, marker: operator('property', 0) }" },
 
-    { id: "possession", level: 0, inverted: true, bridge: "{ ...next(operator), possession: true, object: before[0], objects: before }" },
+    { 
+      id: "possession", 
+      level: 0, 
+      localHierarchy: [['property', 'queryable'], ['property', 'theAble'], ['property', 'unknown'], ['object', 'unknown']],
+      inverted: true, 
+      bridge: "{ ...next(operator), possession: true, object: before[0], objects: before }" 
+    },
     // greg44 { id: "possession", level: 1, inverted: true, bridge: "{ ...after[0], object: operator.object, possession: true, objects: append(default(after[0].objects, after), operator.objects), marker: operator('property', 0) }" },
-    { id: "possession", level: 1, inverted: true, bridge: "{ ...after[0], object: operator.object, possession: true, objects: append(default(after[0].objects, after), operator.objects), marker: after.marker, types: append(after[0].types, ['property']) }" },
+    { 
+      id: "possession", 
+      level: 1, 
+      localHierarchy: [['property', 'queryable'], ['property', 'theAble'], ['property', 'unknown'], ['object', 'unknown']],
+      inverted: true, 
+      bridge: "{ ...after[0], object: operator.object, possession: true, objects: append(default(after[0].objects, after), operator.objects), marker: after.marker, types: append(after[0].types, ['property']) }" 
+    },
     // TODO make object be after[0] that makes more sense
     // { id: "possession", level: 1, inverted: true, bridge: "{ ...after[0], object: after[0], objects: append(default(after[0].objects, after), operator.objects), marker: operator('property', 0) }" },
 
-    { id: "propertyOf", level: 0, bridge: "{ ...next(operator), object: after[0], objects: after }" },
-    { id: "propertyOf", level: 1, bridge: "{ ...before[0], object: operator.object, objects: append(default(before[0].objects, before), operator.objects) }" },
-    { id: "whose", level: 0, bridge: '{ ...after[0], query: true, whose: "whose", modifiers: append(["whose"], after[0].modifiers)}' },
-    { id: "objectPrefix", level: 0, bridge: '{ ...after[0], object: operator, objects: [after[0], operator] }' },
+    { 
+      id: "propertyOf", 
+      level: 0, 
+      localHierarchy: [['property', 'queryable'], ['property', 'theAble'], ['property', 'unknown'], ['object', 'unknown']],
+      bridge: "{ ...next(operator), object: after[0], objects: after }" 
+    },
+    { 
+      id: "propertyOf", 
+      level: 1, 
+      localHierarchy: [['property', 'queryable'], ['property', 'theAble'], ['property', 'unknown']],
+      bridge: "{ ...before[0], object: operator.object, objects: append(default(before[0].objects, before), operator.objects) }" 
+    },
+    { 
+      id: "whose", 
+      level: 0, 
+      isA: ['object'],
+      bridge: '{ ...after[0], query: true, whose: "whose", modifiers: append(["whose"], after[0].modifiers)}' 
+    },
+    { 
+      id: "objectPrefix", 
+      level: 0, 
+      localHierarchy: [['property', 'queryable'], ['property', 'theAble'], ['property', 'unknown']],
+      bridge: '{ ...after[0], object: operator, objects: [after[0], operator] }' 
+    },
   ],
   words: {
     literals: {
@@ -221,7 +287,7 @@ let configStruct = {
       notes: 'expression with constraints',
       where: where(),
       match: ({context}) => context.constraints && context.paraphrase,
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         // TODO assume one constaints deal with more in the future
         const constraint = context.constraints[0]
         const constrained = Object.assign({}, constraint.constraint)
@@ -234,86 +300,25 @@ let configStruct = {
         paraphrase.paraphrase = true;
         paraphrase[constraint.property] = property
         if (false && context.isResponse) {
-          return g({...constraint.paraphrase, paraphrase: true})
+          return await g({...constraint.paraphrase, paraphrase: true})
         } else {
-          return g(constrained)
+          return await g(constrained)
         }
       },
     },
     {
       where: where(),
       match: ({context}) => context.marker == 'xfx',
-      apply: ({context, g}) => `${context.word} between ${g(context.arguments)}`
-    },
-//   {
-//     notes: '"fire type, water type and earth type" to "fire water and earth type"',
-//     tests: [
-//       'chicken modifies strips',
-//     ],
-//     /*
-//       {
-//         "water": {
-//           "marker": "water",
-//           "value": "water",
-//           "word": "water"
-//         },
-//         "marker": "water_type",
-//         "modifiers": [
-//           "water"
-//         ],
-//         "types": [
-//           "water_type"
-//         ],
-//         "value": "water_type",
-//         "word": "type",
-//         "paraphrase": true
-//       },
-//     */
-//     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
-//     },
-//     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)
-//     }
-//   },
+      apply: async ({context, g}) => `${context.word} between ${await g(context.arguments)}`
+    },
     {
       notes: 'add possession ending',
       priority: -1, 
       where: where(),
       match: ({context}) => context.paraphrase && context.possessive,
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         context.possessive = false
-        const phrase = g(context)
+        const phrase = await g(context)
         context.possessive = true
         if (phrase.endsWith('s')) {
           return `${phrase}'`
@@ -322,13 +327,6 @@ let configStruct = {
         }
       }
     },
-    /*
-    {
-      where: where(),
-      match: ({context}) => context.marker == 'modifies' && context.paraphrase,
-      apply: ({context}) => `${context.modifier.word} modifies ${context.concept.word}`,
-    },
-    */
     {
       where: where(),
       match: ({context}) => context.marker == 'objectPrefix' && context.value == 'other' && context.paraphrase,
@@ -353,15 +351,8 @@ let configStruct = {
       notes: 'negative do questions',
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'canBeDoQuestion') && context.paraphrase && context.negation,
-      apply: ({context, g}) => {
-        /*
-        let query = ''
-        if (context.query) {
-          query = "?"
-        }
-        return `${g(context.object)} ${context.word} ${g(context.property)}${query}`
-        */
-        return `${g(context[context.do.left])} doesnt ${pluralize.plural(context.word)} ${g(context[context.do.right])}`
+      apply: async ({context, g}) => {
+        return `${await g(context[context.do.left])} doesnt ${pluralize.plural(context.word)} ${await g(context[context.do.right])}`
       },
     },
     {
@@ -369,23 +360,22 @@ let configStruct = {
       // debug: 'call9',
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'canBeDoQuestion') && context.paraphrase && context.query && context.do,
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         const right = context['do'].right
         if (context[right].query) {
             const left = context['do'].left
-            return `${g(context[right])} ${chooseNumber(context[right], "does", "do")} ${g(context[left])} ${context.word}`
+            return `${await g(context[right])} ${chooseNumber(context[right], "does", "do")} ${await g(context[left])} ${context.word}`
         } else {
-          // return `does ${g(context[context.do.left])} ${pluralize.singular(context.word)} ${g(context[context.do.right])}`
           // the marker is the infinite form
-          return `${chooseNumber(context[context.do.left], "does", "do")} ${g(context[context.do.left])} ${context.marker} ${g(context[context.do.right])}`
+          return `${chooseNumber(context[context.do.left], "does", "do")} ${await g(context[context.do.left])} ${context.marker} ${await g(context[context.do.right])}`
         }
       },
     },
     {
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'canBeDoQuestion') && context.paraphrase && !context.query,
-      apply: ({context, g}) => {
-        return `${g(context.object)} ${context.word} ${g(context.property)}`
+      apply: async ({context, g}) => {
+        return `${await g(context.object)} ${context.word} ${await g(context.property)}`
       }
     },
     {
@@ -393,17 +383,21 @@ let configStruct = {
       where: where(),
       // match: ({context}) => context.paraphrase && context.modifiers && context.object, 
       match: ({context}) => context.paraphrase && !context.possession && context.object, 
-      apply: ({context, g, gs}) => {
+      apply: async ({context, g, gs}) => {
                const base = { ...context }
                base.object = undefined;
                if (context.object.marker == 'objectPrefix') {
-                 return `${g(context.object)} ${g(base)}`
+                 return `${await g(context.object)} ${await g(base)}`
                } else {
                  if (context.objects) {
-                   return gs(context.objects.map( (c) => g({...c, paraphrase: true}) ), ' of ')
+                   const gObjects = []
+                   for (const object of context.objects) {
+                     gObjects.push(await g({...object, paraphrase: true}))
+                   }
+                   return await gs(gObjects, ' of ')
                  } else {
                    // TODO make paraphrase be a default when paraphrasing?
-                   return `${g(base)} of ${g({...context.object, paraphrase: true})}`
+                   return `${await g(base)} of ${await g({...context.object, paraphrase: true})}`
                  }
                }
              },
@@ -412,9 +406,9 @@ let configStruct = {
       // ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.value && !context.evaluate,
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.object && !context.possession && !context.evaluate && !context.object.marker == 'objectPrefix',
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
         const property = Object.assign({}, context, { object: undefined })
-        return `${g(property)} of ${g({ ...context.object, paraphrase: true })}`
+        return `${await g(property)} of ${await g({ ...context.object, paraphrase: true })}`
       }
     },
     {
@@ -422,25 +416,25 @@ let configStruct = {
       where: where(),
       // match: ({context}) => context.paraphrase && !context.modifiers && context.object, 
       match: ({context}) => !context.modifiers && context.object, 
-      apply: ({context, g, gs}) => {
+      apply: async ({context, g, gs}) => {
                if (context.objects) {
                  const objects = [ ...context.objects ]
                  objects.reverse()
                  let phrase = ''
                  let separator = ''
                  for (let i = 0; i < objects.length-1; ++i) {
-                   phrase = phrase + separator + g({...objects[i], paraphrase: context.paraphrase, possessive: true})
+                   phrase = phrase + separator + await g({...objects[i], paraphrase: context.paraphrase, possessive: true})
                    separator = ' '
                  }
-                 phrase = phrase + separator + g({...objects[objects.length-1], paraphrase: context.paraphrase})
+                 phrase = phrase + separator + await g({...objects[objects.length-1], paraphrase: context.paraphrase})
                  return phrase
                } else {
                  const base = { ...context }
                  base.object = undefined; // TODO make paraphrase be a default when paraphrasing?
                  if (context.object.marker == 'objectPrefix') {
-                   return `${g(context.object)} ${g(base)}`
+                   return `${await g(context.object)} ${await g(base)}`
                  } else {
-                   return `${g({...context.object, paraphrase: context.paraphrase})}'s ${g(base)}`
+                   return `${await g({...context.object, paraphrase: context.paraphrase})}'s ${await g(base)}`
                  }
                }  
              },
@@ -534,15 +528,15 @@ let configStruct = {
       notes: 'greg has eyes?',
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'have') && context.query,
-      apply: ({context, g, api, objects}) => {
+      apply: async ({context, g, api, objects}) => {
         const object = pluralize.singular(context.object.value);
         const property = pluralize.singular(context.property.value);
         context.isResponse = true
-        if (!api.knownObject(object)) {
-          context.verbatim = `There is no object named ${g({...context.object, paraphrase: true})}`
+        if (!await api.knownObject(object)) {
+          context.verbatim = `There is no object named ${await g({...context.object, paraphrase: true})}`
           return
         }
-        if (!api.hasProperty(object, property)) {
+        if (!await api.hasProperty(object, property)) {
           context.evalue = {
             marker: 'yesno', 
             value: false,
@@ -561,7 +555,7 @@ let configStruct = {
       where: where(),
       // match: ({context}) => context.marker == 'property' && context.same && context.object,
       match: ({context, hierarchy, uuid}) => hierarchy.isA(context.marker, 'property') && context.same && context.objects && !context[`disable${uuid}`],
-      apply: ({context, objects, km, api, log, s, uuid}) => {
+      apply: async ({context, fragments, objects, km, api, log, s, uuid}) => {
         const objectContext = context.object;
         const propertyContext = context;
         const objectId = context.object.value
@@ -576,7 +570,7 @@ let configStruct = {
         // greg HERE
         */
         propertyContext[`disable${uuid}`] = true
-        const propertyId = km("dialogues").api.evaluateToConcept(propertyContext, context, log, s).evalue;
+        const propertyId = (await km("dialogues").api.evaluateToConcept(propertyContext, context, log, s)).evalue;
         try{
           // greg
           // api.makeObject({config, context: objectContext, doPluralize: false})
@@ -588,8 +582,8 @@ let configStruct = {
         } catch (e) {
           log(`Error processing set property of an object: ${e}`)
           const config = km('properties')
-          const fragment = config.fragment("the property1 of object1 is value1")
-          const value = api.getProperty(objectId, propertyId)
+          const fragment = fragments("the property1 of object1 is value1")
+          const value = await api.getProperty(objectId, propertyId)
           if (value.value == context.same.value) {
             context.evalue = [
               { marker: 'yesno', value: true, paraphrase: true },
@@ -620,7 +614,7 @@ let configStruct = {
             context.evalue = [
               { marker: 'yesno', value: false, paraphrase: true },
             ]
-            context.evalue = context.evalue.concat(fragment.instantiate(mappings))
+            context.evalue = context.evalue.concat(await fragment.instantiate(mappings))
             context.evalue.forEach( (r) => r.paraphrase = true )
             context.isResponse = true
             context.sameWasProcessed = true
@@ -638,48 +632,47 @@ let configStruct = {
                       !context.evaluate.toConcept, // && !context.value,
                       // greghere
       // match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'property') && context.evaluate,
-      apply: ({context, api, kms, objects, g, s, log}) => {
+      apply: async ({context, api, kms, objects, g, s, log}) => {
         const toDo = [ ...context.objects ]
 
-        const toValue = (objectContext) => {
+        const toValue = async (objectContext) => {
           if (!objectContext.value) {
             return objectContext;
           }
           let objectValue = kms.stm.api.getVariable(objectContext.value);
-          if (!api.knownObject(objectValue)) {
-            context.verbatim = `There is no object named "${g({...objectContext, paraphrase: true})}"`
+          if (!await api.knownObject(objectValue)) {
+            context.verbatim = `There is no object named "${await g({...objectContext, paraphrase: true})}"`
             return
           }
           return objectValue
         }
 
         let currentContext = toDo.pop()
-        let currentValue = toValue(currentContext)
+        let currentValue = await toValue(currentContext)
         while (toDo.length > 0) {
           const nextContext = toDo.pop()
-          const nextValue = toValue(nextContext)
+          const nextValue = await toValue(nextContext)
           if (!nextValue) {
             // TODO maybe this I aware so it can say "I don't know about blah..." and below
             // if (currentContext.unknown || !currentContext.value) {
             if (!api.conceptExists(currentContext.value)) {
               // api.conceptExists(currentContext)
-              const objectPhrase = g({...currentContext, paraphrase: true})
+              const objectPhrase = await g({...currentContext, paraphrase: true})
               context.verbatim = `What "${objectPhrase}" means is unknown`
               return
             }
 
-            const propertyPhrase = g({...nextContext, paraphrase: true})
-            const objectPhrase = g({...currentContext, paraphrase: true})
+            const propertyPhrase = await g({...nextContext, paraphrase: true})
+            const objectPhrase = await g({...currentContext, paraphrase: true})
             context.verbatim = `There is no interpretation for "${propertyPhrase} of ${objectPhrase}"`
             return
           }
 
-          if (!api.knownProperty(currentContext, nextContext)) {
-            api.knownProperty(currentContext, nextContext)
-            context.verbatim = `There is no property ${g({...nextContext, paraphrase: true})} of ${g({...currentContext, paraphrase: true})}`
+          if (!await api.knownProperty(currentContext, nextContext)) {
+            context.verbatim = `There is no property ${await g({...nextContext, paraphrase: true})} of ${await g({...currentContext, paraphrase: true})}`
             return
           }
-          currentContext = api.getProperty(currentValue, nextValue, g)
+          currentContext = await api.getProperty(currentValue, nextValue, g)
           currentValue = currentContext.value
         }
         context.focusable = ['object[0]']
@@ -690,30 +683,26 @@ let configStruct = {
   ]
 };
 
-const createConfig = () => {
-  const config = new Config(configStruct, module)
-  config.stop_auto_rebuild()
-  config.api = api
-  config.add(concept(), meta(), dialogues())
-  config.restart_auto_rebuild()
-  return config
-}
-
 knowledgeModule( { 
+  config,
+  api: () => new API(),
+  includes: [concept, meta, dialogues],
+
   module,
   description: 'properties of objects',
-  createConfig,
   test: {
     name: './properties.test.json',
     contents: properties_tests,
     checks: {
-      context: defaultContextCheck,
+      context: defaultContextCheck(),
+      /*
       objects: [
         'children', 
         'concept', 
         'parents', 
         'properties'
       ]
+      */
     },
     include: {
       words: true,

package/common/punctuation.js

@@ -1,14 +1,15 @@
-const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const gdefaults = require('./gdefaults')
 const punctuation_tests = require('./punctuation.test.json')
 
-let configStruct = {
+let config = {
   name: 'punctuation',
   operators: [
     "([leftParenthesis|] (phrase) ([rightParenthesis|]))",
     "((before) [comma|])", // comma applies if before is dead
     "([colon|])",
+    "((sentence) <endOfSentence|>)",
     "([doubleQuote|] (!doubleQuote/*)* (doubleQuote/*))",
   ],
   bridges: [
@@ -30,7 +31,14 @@ let configStruct = {
       bridge: "{ ...next(operator) }",
       words: [{ word: ")", value: ')', depth: '-' }],
     },
-    { id: "colon", words: [':'],  },
+    { 
+      id: "colon", 
+      words: [':'],  
+    },
+    { 
+      id: "endOfSentence", words: ['.'],  
+      bridge: "{ ...before, postModifiers: append(before.postModifiers, ['endOfSentence']), endOfSentence: operator }",
+    },
     {
       id: "doubleQuote",
       level: 0,
@@ -45,22 +53,22 @@ let configStruct = {
       where: where(),
       priority: -1,
       match: ({context}) => context.parenthesis == '(',
-      apply: ({context, g}) => `(${g({ ...context, parenthesis: null })})` 
+      apply: async ({context, g}) => `(${await g({ ...context, parenthesis: null })})` 
     },
   ],
 };
 
-const createConfig = () => new Config(configStruct, module).add(gdefaults())
-
 knowledgeModule( {
+  config,
+  includes: [gdefaults],
+
   module,
-  createConfig,
   description: 'punctuation',
   test: {
     name: './punctuation.test.json',
     contents: punctuation_tests,
     checks: {
-            context: defaultContextCheck,
+            context: defaultContextCheck(),
           },
   },
 })