theprogrammablemind 7.5.8-beta.2 → 7.5.8-beta.3

package/client.js

@@ -288,7 +288,7 @@ const writeTestFile = (fn, tests) => {
   runtime.fs.writeFileSync(fn, stringify(tests, { space: 2 }), { encoding: 'utf8', flag: 'w+' })
 }
 
-const writeTest = (fn, query, objects, generated, paraphrases, responses, contexts, associations, metadata, config, saveDeveloper) => {
+const writeTest = (fn, query, objects, generated, paraphrases, responses, contexts, associations, metadata, config, saveDeveloper, paraphrasesParenthesized, generatedParenthesized) => {
   let tests = []
   if (runtime.fs.existsSync(fn)) {
     tests = JSON.parse(runtime.fs.readFileSync(fn))
@@ -298,7 +298,19 @@ const writeTest = (fn, query, objects, generated, paraphrases, responses, contex
   }
   associations.sort()
   // tests[query] = sortJson({ paraphrases, responses, contexts, objects: convertToStable(objects), associations, metadata, config, developerTest: saveDeveloper }, { depth: 25 })
-  results = sortJson({ query, paraphrases, responses, contexts, objects: convertToStable(objects), associations, metadata, config, developerTest: saveDeveloper }, { depth: 25 })
+  debugger
+  results = sortJson({ 
+    query, 
+    paraphrases, 
+    responses, 
+    contexts, 
+    objects: convertToStable(objects), 
+    associations, 
+    metadata, 
+    config, 
+    developerTest: saveDeveloper, 
+    paraphrasesParenthesized, 
+    generatedParenthesized }, { depth: 25 })
   let wasSet = false;
   tests.forEach( (test, index) => {
     if (test.query == query) {
@@ -360,6 +372,8 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
   const contextsPrime = []
   const generatedPrime = []
   const paraphrasesPrime = []
+  const paraphrasesParenthesizedPrime = []
+  const generatedParenthesizedPrime = []
   const responsesPrime = []
   const contexts = setupContexts(json.contexts)
 
@@ -423,7 +437,13 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
         continue
       }
       let assumed = { isResponse: true };
-      const generated = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
+      const generated = contextPrime.isResponse ? config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0] : ''
+      let generatedParenthesized = []
+      if (isTest) {
+        config.parenthesized = true
+        generatedParenthesized = contextPrime.isResponse ? config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0] : ''
+        config.parenthesized = false
+      }
       // assumed = { paraphrase: true, response: false };
       assumed = { paraphrase: true };
       args.g = (c) => config.getGenerators(json.logs).apply(args, c, assumed)
@@ -432,7 +452,16 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
       args.gs = gs(args.g)
       args.gsp = gs(args.gsp)
       args.gsr = gs(args.gr)
+      if (isTest) {
+        config.parenthesized = false
+      }
       const paraphrases = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
+      let paraphrasesParenthesized = []
+      if (isTest) {
+        config.parenthesized = true
+        paraphrasesParenthesized = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
+        config.parenthesized = false
+      }
       args.g = (c) => config.getGenerators(json.logs).apply(args, c)
       args.gp = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: true, isResponse: false, response: false })
       args.gr = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: false })
@@ -442,6 +471,10 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
       contextsPrime.push(contextPrime)
       generatedPrime.push(generated)
       paraphrasesPrime.push(paraphrases)
+      if (isTest) {
+        paraphrasesParenthesizedPrime.push(paraphrasesParenthesized)
+        generatedParenthesizedPrime.push(generatedParenthesized)
+      }
       if (contextPrime.isResponse) {
         responsesPrime.push(generated)
       } else {
@@ -451,7 +484,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
       // add results to processed list
       config.config.objects.processed = config.config.objects.processed || []
       config.config.objects.processed = config.config.objects.processed.slice(0, 5)
-      config.config.objects.processed.unshift({ context: contextPrime, paraphrases: paraphrases, responses: responsesPrime })
+      config.config.objects.processed.unshift({ context: contextPrime, paraphrases: paraphrases, paraphrasesParenthesized, generatedParenthesized, responses: responsesPrime })
     } catch (e) {
       if (Array.isArray(e)) {
         e = {
@@ -471,7 +504,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
       throw e
     }
   }
-  return { contextsPrime, generatedPrime, paraphrasesPrime, responsesPrime }
+  return { contextsPrime, generatedPrime, paraphrasesPrime, paraphrasesParenthesizedPrime, generatedParenthesizedPrime, responsesPrime }
 }
 
 const doWithRetries = async (n, url, queryParams, data) => {
@@ -493,17 +526,17 @@ const doWithRetries = async (n, url, queryParams, data) => {
     }
     if (result.status === 504) {
       if (n === 0) {
-        throw `Error ${result.status} - ${result.statusText}`
+        throw new Error(`Error ${result.status} - ${result.statusText}`)
       } else {
         continue
       }
     }
     if (result.status >= 500 && result.status < 600) {
-      throw `Error ${result.status} - ${result.statusText}.`
+      throw new Error(`Error ${result.status} - ${result.statusText}.`)
     } if (result.status >= 404) {
-      throw `Error ${result.status} - ${result.statusText} - Trying it connect to ${url}`
+      throw new Error(`Error ${result.status} - ${result.statusText} - Trying it connect to ${url}`)
     } else {
-      throw `Error ${result.status} - ${result.statusText}`
+      throw new Error(`Error ${result.status} - ${result.statusText}`)
     }
   }
 }
@@ -598,6 +631,8 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
       contexts: [],
       generated: [],
       paraphrases: [],
+      paraphrasesParenthesized: [],
+      generatedParenthesized: [],
       responses: [],
       associations: [],
     }
@@ -633,7 +668,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
       if (json.status !== 200) {
         throw json
       } else {
-        const { contextsPrime, generatedPrime, paraphrasesPrime, responsesPrime } =
+        const { contextsPrime, generatedPrime, paraphrasesPrime, paraphrasesParenthesizedPrime, generatedParenthesizedPrime, responsesPrime } =
                                   processContextsB({ isTest, config, hierarchy, json, commandLineArgs /*, generators, semantics */ })
         response.associations = json.associations
         response.hierarchy = json.hierarchy
@@ -650,6 +685,8 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         response.contexts = response.contexts.concat(contextsPrime)
         response.generated = response.generated.concat(generatedPrime)
         response.paraphrases = response.paraphrases.concat(paraphrasesPrime)
+        response.paraphrasesParenthesized = response.paraphrasesParenthesized.concat(paraphrasesParenthesizedPrime)
+        response.generatedParenthesized = response.generatedParenthesized.concat(generatedParenthesizedPrime)
         response.responses = response.responses.concat(responsesPrime)
         queries = queries.slice(1)
       }
@@ -657,7 +694,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
 
     if (writeTests) {
       const actual_config = getConfigForTest(config, testConfig)
-      writeTest(testsFN, query, config.config.objects, response.generated, response.paraphrases, response.responses, response.contexts, response.associations, response.metadata, actual_config, saveDeveloper)
+      writeTest(testsFN, query, config.config.objects, response.generated, response.paraphrases, response.responses, response.contexts, response.associations, response.metadata, actual_config, saveDeveloper, response.paraphrasesParenthesized, response.generatedParenthesized)
     }
 
     return response
@@ -738,8 +775,11 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
         lines.log()
       }
       const expected_objects = sortJson(convertToStable(expected.objects), { depth: 25 })
+      delete expected_objects.nameToUUID
       const actual_objects = sortJson(convertToStable(config.config.objects), { depth: 25 })
       const failed_paraphrases = !matching(result.paraphrases, expected.paraphrases)
+      const failed_paraphrasesParenthesized = !matching(result.paraphrasesParenthesized, expected.paraphrasesParenthesized)
+      const failed_generatedParenthesized = !matching(result.generatedParenthesized, expected.generatedParenthesized)
       const failed_responses = !matching(result.responses, expected.responses)
       const failed_contexts = !matching(result.contexts, expected.contexts)
       const failed_objects = !matching(actual_objects, expected_objects)
@@ -784,7 +824,7 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
       const actual_config = sortJson(convertToStable(getConfigForTest(config, testConfig)), { depth: 25 })
       const expected_config = sortJson(convertToStable(expected.config), { depth: 25 })
       const failed_config = !matching(actual_config, expected_config)
-      let failed = failed_paraphrases || failed_responses || failed_contexts || failed_objects || failed_config || failed_checked
+      let failed = failed_paraphrases || failed_paraphrasesParenthesized || failed_generatedParenthesized || failed_responses || failed_contexts || failed_objects || failed_config || failed_checked
       if (!failed) {
         if (config.afterTest) {
           failed = config.afterTest({ query: test, expected, actual: result, config })
@@ -792,8 +832,26 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
             return {
               utterance: test,
               errorFromAfterTest: failed,
-              expected: { responses: expected.responses, paraphrases: expected.paraphrases, results: expected.contexts, checked: expected_checked, objects: expected_objects, config: expected.config },
-              actual: { responses: result.responses, paraphrases: result.paraphrases, results: result.contexts, checked: actual_checked, objects: actual_objects, config: actual_config }
+              expected: { 
+                responses: expected.responses, 
+                paraphrases: expected.paraphrases, 
+                paraphrasesParenthesized: expected.paraphrasesParenthesized, 
+                generatedParenthesized: expected.generatedParenthesized, 
+                results: expected.contexts, 
+                checked: expected_checked, 
+                objects: expected_objects, 
+                config: expected.config 
+              },
+              actual: { 
+                responses: result.responses, 
+                paraphrases: result.paraphrases, 
+                paraphrasesParenthesized: result.paraphrasesParenthesized, 
+                generatedParenthesized: result.generatedParenthesized, 
+                results: result.contexts, 
+                checked: actual_checked, 
+                objects: actual_objects, 
+                config: actual_config 
+              }
             }
           }
         }
@@ -809,8 +867,26 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
       if (failed) {
         return {
           utterance: test,
-          expected: { responses: expected.responses, paraphrases: expected.paraphrases, results: expected.contexts, checked: expected_checked, objects: expected_objects, config: expected.config },
-          actual: { responses: result.responses, paraphrases: result.paraphrases, results: result.contexts, checked: actual_checked, objects: actual_objects, config: actual_config }
+          expected: { 
+            responses: expected.responses, 
+            paraphrases: expected.paraphrases, 
+            paraphrasesParenthesized: expected.paraphrasesParenthesized, 
+            generatedParenthesized: expected.generatedParenthesized, 
+            results: expected.contexts, 
+            checked: expected_checked, 
+            objects: expected_objects, 
+            config: expected.config 
+          },
+          actual: { 
+            responses: result.responses, 
+            paraphrases: result.paraphrases, 
+            paraphrasesParenthesized: result.paraphrasesParenthesized, 
+            generatedParenthesized: result.generatedParenthesized, 
+            results: result.contexts, 
+            checked: actual_checked, 
+            objects: actual_objects, 
+            config: actual_config 
+          }
         }
       }
     } catch(error) {
@@ -872,7 +948,7 @@ const saveTest = async (testFile, config, test, expected, testConfig, saveDevelo
   for (let km of config.configs) {
     saveObjects.nameToUUID[km.name] = km.uuid
   }
-  writeTest(testFile, test, saveObjects, result.generated, result.paraphrases, result.responses, result.contexts, result.associations, result.metadata, actualConfig, saveDeveloper)
+  writeTest(testFile, test, saveObjects, result.generated, result.paraphrases, result.responses, result.contexts, result.associations, result.metadata, actualConfig, saveDeveloper, result.paraphrasesParenthesized, result.generatedParenthesized)
 }
 
 const saveTestsHelper = async (testFile, config, tests, todo, testConfig, saveDeveloper) => {
@@ -1174,7 +1250,9 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
           defaultInnerProcess(config, defaultErrorHandler, results)
         }
         if (results.contexts.length > 1) {
-          console.log(`query ${query.query}. There is ${results.contexts.length} contexts in the results. Make sure its producing the results that you expect.`)
+          console.log(`query "${query.query}". There is ${results.contexts.length} contexts in the results. Make sure its producing the results that you expect.`)
+        } else if (results.paraphrases[0] != query.query) {
+          console.log(`query "${query.query}". The paraphrase is different from the query "${results.paraphrases[0]}".`)
         } else {
           console.log(`query ${query.query}`)
         }
@@ -1283,19 +1361,19 @@ const knowledgeModule = async ({
   const testConfig = test
 
   if (!moduleFromJSFile) {
-    throw "'module' is a required parameter. The value should be either 'module' or a lambda that will be called when the file is acting as a module."
+    throw new Error("'module' is a required parameter. The value should be either 'module' or a lambda that will be called when the file is acting as a module.")
   }
   if (!config) {
-    throw "'config' is a required parameter. The value should the config that defines the knowledge module."
+    throw new Error("'config' is a required parameter. The value should the config that defines the knowledge module.")
   }
   if (!config.name) {
-    throw "config must have 'name' set to the knowledge module name."
+    throw new Error("config must have 'name' set to the knowledge module name.")
   }
   if (!description) {
-    throw "'description' is a required parameter. The value should the description of the knowledge module."
+    throw new Error("'description' is a required parameter. The value should the description of the knowledge module.")
   }
   if (!test) {
-    throw "'test' is a required parameter. The value should the path to the file used to store the tests of the knowledge module and the contents of the file in the form { name: <filePath>, contexts: <json> }."
+    throw new Error("'test' is a required parameter. The value should the path to the file used to store the tests of the knowledge module and the contents of the file in the form { name: <filePath>, contexts: <json> }.")
   }
 
   const isProcess = require.main === moduleFromJSFile
@@ -1353,7 +1431,7 @@ const knowledgeModule = async ({
   if (!isProcess) {
     if (template) {
       if (config.needsRebuild(template.template, template.instance)) {
-        throw `This module "${config.name}" cannot be used because the instance file needs rebuilding. Run on the command line with no arguements or the -rt argument to rebuild.`
+        throw new Error(`This module "${config.name}" cannot be used because the instance file needs rebuilding. Run on the command line with no arguements or the -rt argument to rebuild.`)
       }
       try {
         config.load(template.template, template.instance)
@@ -1392,6 +1470,7 @@ const knowledgeModule = async ({
     parser.add_argument('-ip ', '--server', { help: 'Server to run against' })
     parser.add_argument('-qp ', '--queryParams', { help: 'Query params for the server call' })
     parser.add_argument('-dt', '--deleteTest', { help: 'Delete the specified query from the tests file.' })
+    parser.add_argument('--parenthesized', { action: 'store_true', help: 'Show the generated phrases with parenthesis.' })
     parser.add_argument('-c', '--clean', { help: 'Remove data from the test files. a === association' })
     parser.add_argument('-od', '--objectDiff', { action: 'store_true', help: 'When showing the objects use a colour diff' })
     parser.add_argument('-daa', '--dontAddAssociations', { action: 'store_true', help: 'Do not add associations from the tests.' })
@@ -1410,6 +1489,10 @@ const knowledgeModule = async ({
     const args = parser.parse_args()
     args.count = args.count || 1
 
+    if (args.parenthesized) {
+      config.parenthesized = true
+    }
+
     if (args.debugAssociation) {
       console.log(helpDebugAssociation)
       runtime.process.exit(-1)
@@ -1629,6 +1712,12 @@ const knowledgeModule = async ({
                 if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
                   hasError = true
                 }
+                if (JSON.stringify(result.expected.paraphrasesParenthesized) !== JSON.stringify(result.actual.paraphrasesParenthesized)) {
+                  hasError = true
+                }
+                if (JSON.stringify(result.expected.generatedParenthesized) !== JSON.stringify(result.actual.generatedParenthesized)) {
+                  hasError = true
+                }
                 if (JSON.stringify(result.expected.responses) !== JSON.stringify(result.actual.responses)) {
                   hasError = true
                 }
@@ -1641,6 +1730,22 @@ const knowledgeModule = async ({
                 console.log('**************************** ERRORS ************************')
                 for (const result of results) {
                   console.log('Utterance: ', result.utterance)
+                  const show = (label, expected, actual) => {
+                    if (JSON.stringify(expected) !== JSON.stringify(actual)) {
+                      if (!headerShown) {
+                        console.log('  Failure')
+                      }
+                      console.log(`    expected ${label}`, expected)
+                      console.log(`    actual ${label}  `, actual)
+                      newError = true
+                      headerShown = true
+                    }
+                  }
+                  show('paraphrases', result.expected.paraphrases, result.actual.paraphrases)
+                  show('paraphrases parenthesized', result.expected.paraphrasesParenthesized, result.actual.paraphrasesParenthesized)
+                  show('responses', result.expected.responses, result.actual.responses)
+                  show('responses parenthesized', result.expected.generatedParenthesized, result.actual.generatedParenthesized)
+                  /*
                   if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
                     if (!headerShown) {
                       console.log('  Failure')
@@ -1659,6 +1764,7 @@ const knowledgeModule = async ({
                     newError = true
                     headerShown = true
                   }
+                  */
                   if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
                     if (!headerShown) {
                       console.log('  Failure')
@@ -1720,7 +1826,7 @@ const knowledgeModule = async ({
           console.log(results.responses.join(' '))
         })
         if (!('then' in promise)) {
-          throw 'Return a promise from process in the definition of knowledgeModule'
+          throw new Error('Return a promise from process in the definition of knowledgeModule')
         }
         promise
           .then(() => {

package/lines.js

@@ -13,7 +13,7 @@ class Lines {
   setElement (row, column, value) {
     const values = value.toString().split('\n')
     if (column >= this.widths.length) {
-      throw "Column out of range."
+      throw new Error("Column out of range.")
     }
     const width = this.widths[column]
     let index = 0

package/package.json

@@ -63,6 +63,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.5.8-beta.2",
+  "version": "7.5.8-beta.3",
   "license": "ISC"
 }

package/src/config.js

@@ -54,6 +54,14 @@ const handleBridgeProps = (config, bridge) => {
           config.addPriorities([after, [bridge.id, bridge.level]])
         }
       }
+      if (bridge.after) {
+        for (let before of bridge.after) {
+          if (typeof before == 'string') {
+            before = [before, 0]
+          }
+          config.addPriorities([[bridge.id, bridge.level], before])
+        }
+      }
       if (bridge.words) {
         for (let def of bridge.words) {
           if (typeof def == 'string') {
@@ -80,15 +88,30 @@ const handleBridgeProps = (config, bridge) => {
         bridge.generatorr = bridge.generatorpr
       }
       if (bridge.generatorp) {
+        const match = bridge.generatorp.match || (() => true)
+        const apply = typeof bridge.generatorp == 'function' ? bridge.generatorp : bridge.generatorp.apply || bridge.generatorp
+        const level = bridge.generatorp.level >= 0 ? bridge.generatorp.level : bridge.level + 1
         config.config.generators.unshift({ 
           where: bridge.generatorp.where || bridge.where || client.where(4),
-          // match: ({context}) => bridge.id == context.marker && context.paraphrase,
-          match: ({context}) => bridge.id == context.marker && context.level == bridge.level + 1 && context.paraphrase,
-          apply: (args) => bridge.generatorp(args),
-          applyWrapped: bridge.generatorp,
+          match: (args) => bridge.id == args.context.marker && args.context.level == level && args.context.paraphrase && match(args),
+          apply: (args) => apply(args),
+          applyWrapped: apply,
           property: 'generatorp',
         })
       }
+      if (bridge.generatorr) {
+        const match = bridge.generatorr.match || (() => true)
+        const apply = typeof bridge.generatorr == 'function' ? bridge.generatorr : bridge.generatorr.apply || bridge.generatorr
+        const level = bridge.generatorr.level >= 0 ? bridge.generatorr.level : bridge.level + 1
+        config.config.generators.unshift({ 
+          where: bridge.generatorr.where || bridge.where || client.where(4),
+          match: (args) => bridge.id == args.context.marker && args.context.level == level && !args.context.paraphrase && (args.context.response || args.context.isResponse) && match(args),
+          apply: (args) => apply(args),
+          applyWrapped: apply,
+          property: 'generatorr',
+        })
+      }
+      /*
       if (bridge.generatorr) {
         config.config.generators.unshift({ 
           // TODO merge response and isResponse
@@ -99,6 +122,7 @@ const handleBridgeProps = (config, bridge) => {
           property: 'generatorr',
         })
       }
+      */
       if (bridge.evaluator) {
         config.config.semantics.unshift({ 
           where: bridge.evaluator.where || bridge.where || client.where(3),
@@ -123,7 +147,7 @@ const handleBridgeProps = (config, bridge) => {
 
 const handleCalculatedProps = (baseConfig, moreConfig) => {
   for (let bridge of moreConfig.bridges) {
-    const valid = [ 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
+    const valid = [ 'after', 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
                     'level', 'optional', 'selector', 'semantic',  'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where' ]
     helpers.validProps(valid, bridge, 'bridge')
     handleBridgeProps(baseConfig, bridge)
@@ -157,7 +181,7 @@ if (runtime.process.env.DEBUG_BRIDGE) {
   if (global.entodictonDebugBridge.length !== 2) {
     console.log('Expected DEBUG_BRIDGE to be of the form "id/level"');
   }
-  global.entodictonDebugBridge[1] = int(global.entodictonDebugBridge[1])
+  global.entodictonDebugBridge[1] = parseInt(global.entodictonDebugBridge[1])
 }
 
 if (runtime.process.env.DEBUG_OPERATOR) {
@@ -175,7 +199,7 @@ const hierarchyCanonical = (element) => {
 
 const isValidDef = (word, def, config) => {
   if (!def.id) {
-    throw `In the KM "${config.name}", for the word ${word} the following definition is missing the "id" property: ${JSON.stringify(def)}`
+    throw new Error(`In the KM "${config.name}", for the word ${word} the following definition is missing the "id" property: ${JSON.stringify(def)}`)
   }
   /*
   if (!def.initial) {
@@ -738,7 +762,7 @@ class Config {
           "semantics",
           "associations",
         ]
-        return !properties.find( (property) => instance[property].length > 0 )
+        return !properties.find( (property) => instance[property] && instance[property].length > 0 )
       }
       if (!isEmpty(instance)) {
         instance.name = this.name
@@ -813,10 +837,10 @@ class Config {
   addHierarchyProperties (edge) {
     const { child, parent } = edge
     if (typeof child !== 'string') {
-      throw `addHierarchy expected child property to be a string. got ${JSON.stringify(child)}`
+      throw new Error(`addHierarchy expected child property to be a string. got ${JSON.stringify(child)}`)
     }
     if (typeof parent !== 'string') {
-      throw `addHierarchy expected parent property to be a string. got ${JSON.stringify(parent)}`
+      throw new Error(`addHierarchy expected parent property to be a string. got ${JSON.stringify(parent)}`)
     }
     if (global.entodictonDebugHierarchy) {
       if (helpers.safeEquals(entodictonDebugHierarchy, [child, parent])) {
@@ -830,10 +854,10 @@ class Config {
 
   addHierarchyChildParent (child, parent) {
     if (typeof child !== 'string') {
-      throw `addHierarchy expected child to be a string. got ${JSON.stringify(child)}`
+      throw new Error(`addHierarchy expected child to be a string. got ${JSON.stringify(child)}`)
     }
     if (typeof parent !== 'string') {
-      throw `addHierarchy expected parent to be a string. got ${JSON.stringify(parent)}`
+      throw new Error(`addHierarchy expected parent to be a string. got ${JSON.stringify(parent)}`)
     }
 
     if (global.entodictonDebugHierarchy) {
@@ -894,10 +918,10 @@ class Config {
     }
 
     if (!(typeof generator.match === 'function')) {
-      throw 'addGenerator: Expected matcher to be a function'
+      throw new Error('addGenerator: Expected matcher to be a function')
     }
     if (!(typeof generator.apply === 'function')) {
-      throw 'addGenerator: Expected action to be a function'
+      throw new Error('addGenerator: Expected action to be a function')
     }
 
     if (!this.config.generators) {
@@ -921,10 +945,10 @@ class Config {
     }
 
     if (!(typeof semantic.match === 'function')) {
-      throw 'addSemantic: Expected match to be a function'
+      throw new Error('addSemantic: Expected match to be a function')
     }
     if (!(typeof semantic.apply === 'function')) {
-      throw 'addSemantic: Expected apply to be a function'
+      throw new Error('addSemantic: Expected apply to be a function')
     }
 
     if (!this.config.semantics) {
@@ -1198,7 +1222,7 @@ class Config {
   // configs = [ { config, namespace } ... ]
   constructor (config, module) {
     if (config instanceof Config) {
-      throw 'Excepted the config argument to be a hash not a Config object'
+      throw new Error('Excepted the config argument to be a hash not a Config object')
     }
 
     if (config) {
@@ -1279,7 +1303,7 @@ class Config {
       }
       duplicated = Array.from(duplicated)
       if (duplicated.length > 0) {
-        throw `In the KM ${config.name}, the following operators are duplicated in the bridges: ${duplicated}`
+        throw new Error(`In the KM ${config.name}, the following operators are duplicated in the bridges: ${duplicated}`)
       }
     }
 
@@ -1394,13 +1418,13 @@ class Config {
     if (this._api && this._api.multiApi) {
       this._api.add(this, this._api, api)
     } else {
-      throw "Can only add apis to a multi-api";
+      throw new Error("Can only add apis to a multi-api")
     }
   }
 
   set api (value) {
     if (!value.initialize) {
-      throw `Expected the API to have an initialize function for ${this.name}.`
+      throw new Error(`Expected the API to have an initialize function for ${this.name}.`)
     }
 
     if (this._api && this._api.multiApi) {
@@ -1467,7 +1491,7 @@ class Config {
   }
 
   doMotivations (args, context) {
-    args = Object.assign({}, args, { context })
+    args = Object.assign({}, args, { context, api: this.api })
     // console.log('src/config doMotivations this.uuid', this.uuid)
     // args.objects = args.getObjects(this.uuid)
     const motivations = this.motivations
@@ -1702,7 +1726,7 @@ class Config {
       for (let option of Object.keys(options)) {
         const validOptions = ['initAfterApi']
         if (!['initAfterApi'].includes(option)) {
-          throw `For Config.initializer, unrecognized option ${option}. The valid options are ${validOptions}`
+          throw new Error(`For Config.initializer, unrecognized option ${option}. The valid options are ${validOptions}`)
         }
       }
     }
@@ -1939,7 +1963,20 @@ class Config {
       // TODO change name of config: to baseConfig:
       const kmFn = (name) => this.getConfig(name)
       // const hierarchy = new DigraphInternal((config.config || {}).hierarchy)
-      const args = { isModule, addWord: aw, km: kmFn, hierarchy: this.hierarchy, config, baseConfig: this, currentConfig: config, uuid: config._uuid, objects: namespacedObjects, namespace, api: config.api }
+      const args = { 
+        isModule, 
+        addWord: aw, 
+        km: kmFn, 
+        hierarchy: this.hierarchy, 
+        config, 
+        baseConfig: this, 
+        currentConfig: config, 
+        uuid: config._uuid, 
+        objects: namespacedObjects, 
+        namespace, 
+        motivation: (m) => config.addMotivation(m),
+        api: config.api 
+      }
       config.initializerFn(args)
       if (config.initAfterApi) {
         // reverse the list
@@ -2327,14 +2364,14 @@ class Config {
 
   set (property, value) {
     if (!this.config.hasOwnProperty(property)) {
-      throw `Setting invalid property ${property}`
+      throw new Error(`Setting invalid property ${property}`)
     }
 
     if ('words' == property) {
       for (let word in value) {
         for (let def of value[word]) {
           if (!def['uuid']) {
-            throw `All definitions for '${property}' must have the uuid property set (config.uuid). uuid is missing from ${JSON.stringify(def)} for the word '${word}'`
+            throw new Error(`All definitions for '${property}' must have the uuid property set (config.uuid). uuid is missing from ${JSON.stringify(def)} for the word '${word}'`)
           }
         }
       }
@@ -2343,7 +2380,7 @@ class Config {
     if (['operators', 'bridges'].includes(property)) {
       for (let def of value) {
         if (!def['uuid']) {
-          throw `All definitions for '${property}' must have the uuid property set (config.uuid). uuid is missing from ${JSON.stringify(def)}`
+          throw new Error(`All definitions for '${property}' must have the uuid property set (config.uuid). uuid is missing from ${JSON.stringify(def)}`)
         }
       }
     }
@@ -2375,7 +2412,7 @@ class Config {
 
   add (more) {
     if (more === this) {
-      throw 'Cannot add an object to itself.'
+      throw new Error('Cannot add an object to itself.')
     }
     if (!(more instanceof Config)) {
       more = new Config(more)
@@ -2543,7 +2580,7 @@ class Config {
         this.config[key] = this.config[key].concat(more[key])
       } else {
         if (!(key in this.config)) {
-          throw `Unexpected property in config ${key}`
+          throw new Error(`Unexpected property in config ${key}`)
         }
         this.config[key] = more[key]
       }
@@ -2661,7 +2698,7 @@ class Config {
         this.config[key] = more[key].concat(this.config[key])
       } else {
         if (!(key in this.config)) {
-          throw `Unexpected property in config ${key}`
+          throw new Error(`Unexpected property in config ${key}`)
         }
         this.config[key] = more[key]
       }

package/src/generators.js

@@ -75,7 +75,7 @@ class Generator {
 
   apply (baseArgs, objects, g, gs, context, hierarchy, config, response, log, options = {}) {
     if (!log) {
-      throw 'generators.apply argument log is required'
+      throw new Error('generators.apply argument log is required')
     }
     if (baseArgs.call && config && sbaseArgs.calls.stack.length > config.maxDepth) {
       throw new Error(`Max depth of ${config.maxDepth} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
@@ -292,7 +292,7 @@ class Generators {
         lines.setElement(0, 2, JSON.stringify(context, null, 2))
         this.logs.push(lines.toString())
       }
-      contextsPrime.push(generated)
+      contextsPrime.push((config || {}).parenthesized ? "(" + generated + ")" : generated)
     }
     return contextsPrime
   }

package/src/helpers.js

@@ -54,6 +54,9 @@ const safeEquals = (v1, v2) => {
   } else if (type == 'function') {
     return v1.toString() == v2.toString()
   } else {
+    if (v1.length != v2.length) {
+      return false
+    }
     for (let key in v1) {
       if (!safeEquals(v1[key], v2[key])) {
         return false
@@ -235,13 +238,17 @@ const validProps = (valids, object, type) => {
   for (let prop of Object.keys(object)) {
     let okay = false
     for (valid of valids) {
-      if (prop.match(valid)) {
-        okay = true
+      if (typeof valid == 'string') {
+        okay = prop == valid
+      } else {
+        okay = prop.match(valid)
+      }
+      if (okay) {
         break
       }
     }
     if (!okay) {
-      throw `Unknown property "${prop}" in the ${type}. Valid properties are ${valids}. The ${type} is ${JSON.stringify(object)}`
+      throw new Error(`Unknown property "${prop}" in the ${type}. Valid properties are ${valids}. The ${type} is ${JSON.stringify(object)}`)
     }
   }
 }

package/src/semantics.js

@@ -89,7 +89,7 @@ class Semantic {
     // const ask = baseArgs.getAsk(this.uuid)
     if (!log) {
       console.trace()
-      throw 'log is a required argument'
+      throw new Error('log is a required argument')
     }
     const contextPrime = Object.assign({}, context)
     let n = (id) => id