theprogrammablemind 7.5.8-beta.1 → 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,13 +694,13 @@ 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
   } catch(error) {
       error.query = query
-      throw error
+      errorHandler(error)
   }
 }
 
@@ -697,11 +734,13 @@ const getConfigForTest = (config, testConfig) => {
   return configForTest
 }
 
-const runTest = async (config, expected, { verbose, afterTest, testConfig, debug }) => {
+const runTest = async (config, expected, { args, verbose, afterTest, testConfig, debug }) => {
   const test = expected.query
   // initialize in between test so state is not preserved since the test was adding without state
   config.rebuild()
-  config.addAssociationsFromTests(config.tests)
+  if (!args.dontAddAssociations) {
+    config.addAssociationsFromTests(config.tests)
+  }
   // config.addAssocationsFromTests(
   const errorHandler = (error) => {
     if (error.metadata) {
@@ -736,8 +775,11 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
         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)
@@ -782,7 +824,7 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
       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 })
@@ -790,8 +832,26 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
             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 
+              }
             }
           }
         }
@@ -807,8 +867,26 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
       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) {
@@ -866,13 +944,11 @@ const saveTest = async (testFile, config, test, expected, testConfig, saveDevelo
   const args = {
   }
   const saveObjects = {...config.config.objects}
-  /*
   saveObjects.nameToUUID = {}
   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)
@@ -1368,6 +1446,13 @@ const knowledgeModule = async ({
       description: 'Entodicton knowledge module'
     })
 
+    const helpDebugAssociation = 'In order to get a debug break when a specific association is created set the DEBUG_ASSOCIATION environment variable to the JSON of the association to break on. For example DEBUG_ASSOCIATION=\'["the#0", "mammel#0"]\' })'
+    const helpDebugHierarchy = 'In order to get a debug break when a specific hierarchy is created set the DEBUG_HIERARCHY environment variable to the JSON of the child-parent pair to break on. For example DEBUG_HIERARCHY=\'["cat#1", "mammel#1"]\' })'
+    const helpDebugPriority = 'In order to get a debug break when a specific set of priorities is created set set DEBUG_PRIORITY environment variable to the JSON of the priorities that you want to break on. For example DEBUG_PRIORITY=\'["verb#0", "article#0"]\' })'
+    const helpDebugBridge = 'In order to get a debug break when a specific bridge is created set the DEBUG_BRIDGE environment variable to id/level to break on. For example DEBUG_BRIDGE=\'id#level\' })'
+    const helpDebugOperator = 'In order to get a debug break when a specific hierarcy is created set the DEBUG_OPERATOR environment variable to debug any config loaded. For example DEBUG_OPERATOR=\'([operator] ([arg]))\' })'
+
+
     parser.add_argument('-tmn', '--testModuleName', { help: 'When running tests instead of using the current modules tests use the specified modules tests' })
     parser.add_argument('-t', '--test', { action: 'store_true', help: 'Run the tests. Create tests by running with the --query + --save flag' })
     parser.add_argument('-tv', '--testVerbose', { action: 'store_true', help: 'Run the tests in verbose mode. Create tests by running with the --query or --loop with the --save flag' })
@@ -1385,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.' })
@@ -1394,30 +1480,38 @@ const knowledgeModule = async ({
     parser.add_argument('-dic', '--debugIncludeConvolutions', { action: 'store_true', help: 'When running with the --debugIncludeConvolutions flag the logs will include convolutions which are somewhat annoying verbose. Default is false' })
     parser.add_argument('-dl', '--debugLoops', { action: 'store_true', help: 'When running with the --debugLoops flag the logs calls to semantics and generators will be immediately written to the console '})
     parser.add_argument('-d', '--debug', { action: 'store_true', help: 'When running with the --debug flag this set the debug flag in the config' })
-    parser.add_argument('-da', '--debugAssociation', { help: 'When running with the --debugAssociation flag the debugging will break when the specified association is added to the config' })
-    parser.add_argument('-dh', '--debugHierarchy', { help: 'When running with the --debugHierarchy flag the debugging will break when the specified child-parent pair is added to the config for the main config. Set DEBUG_HIERARCHY to debug any config loaded. For example DEBUG_HIERARCHY=\'["cat", "mammel"]\'' })
-    parser.add_argument('-db', '--debugBridge', { help: 'When running with the --debugBridge flag the debugging will break when the specified bridge is added to the config for the main config. Set DEBUG_BRIDGE to debug any config loaded. For example DEBUG_BRIDGE=\'id/level\'' })
-    parser.add_argument('-do', '--debugOperator', { help: 'When running with the --debugOperator flag the debugging will break when the specified operator is added to the config for the main config. Set DEBUG_OPERATOR to debug any config loaded. For example DEBUG_OPERATOR=\'([operator] ([arg]))\'' })
+    parser.add_argument('-da', '--debugAssociation', { help: helpDebugAssociation })
+    parser.add_argument('-dh', '--debugHierarchy', { help: helpDebugHierarchy })
+    parser.add_argument('-dp', '--debugPriority', { help: helpDebugPriority })
+    parser.add_argument('-db', '--debugBridge', { help: helpDebugBridge })
+    parser.add_argument('-do', '--debugOperator', { help: helpDebugOperator })
 
     const args = parser.parse_args()
     args.count = args.count || 1
 
+    if (args.parenthesized) {
+      config.parenthesized = true
+    }
+
     if (args.debugAssociation) {
-      global.entodictonDebugAssociation = JSON.parse(args.debugAssociation)
+      console.log(helpDebugAssociation)
+      runtime.process.exit(-1)
     }
     if (args.debugHierarchy) {
-      global.entodictonDebugHierarchy = JSON.parse(args.debugHierarchy)
+      console.log(helpDebugHierarchy)
+      runtime.process.exit(-1)
+    }
+    if (args.debugPriority) {
+      console.log(helpDebugPriority)
+      runtime.process.exit(-1)
     }
     if (args.debugBridge) {
-        // id/level
-      global.entodictonDebugBridge = args.debugBridge.split('/')
-      if (global.entodictonDebugBridge.length !== 2) {
-        console.log('Expected DEBUG_BRIDGE to be of the form "id/level"');
-      }
+      console.log(helpDebugBridge)
+      runtime.process.exit(-1)
     }
     if (args.debugOperator) {
-        // id/level
-      global.entodictonDebugOperator = args.debugOperator
+      console.log(helpDebugOperator)
+      runtime.process.exit(-1)
     }
 
     if (args.clean) {
@@ -1486,87 +1580,94 @@ const knowledgeModule = async ({
     }
     */
 
-    if (args.print) {
-      if (args.print.includes('t')) {
-        console.log("Test queries")
-        let counter = 0
-        for (const test of config.tests) {
-          console.log(`${counter} - ${test.query}`)
-          counter += 1
-        }
-      }
-      if (args.print.includes('c')) {
-        const { data } = setupProcessB({ config })
-        console.log("Config as sent to server")
-        console.log(JSON.stringify(data, null, 2));
+    let configPrinted = false
+    const printConfig = () => {
+      if (configPrinted) {
+        return
       }
+      configPrinted = true
+      if (args.print) {
+        if (args.print.includes('t')) {
+          console.log("Test queries")
+          let counter = 0
+          for (const test of config.tests) {
+            console.log(`${counter} - ${test.query}`)
+            counter += 1
+          }
+        }
+        if (args.print.includes('c')) {
+          const { data } = setupProcessB({ config })
+          console.log("Config as sent to server")
+          console.log(JSON.stringify(data, null, 2));
+        }
 
-      if (args.print.includes('l')) {
-        console.log('Module load ordering')
-        for (const km of config.configs) {
-          console.log(`  ${km.name}`)
+        if (args.print.includes('l')) {
+          console.log('Module load ordering')
+          for (const km of config.configs) {
+            console.log(`  ${km.name}`)
+          }
         }
-      }
-      if (args.print.includes('w')) {
-        for (const word in config.config.words) {
-          console.log(word.concat('          ', ...config.config.words[word].map((def) => JSON.stringify(def))))
+        if (args.print.includes('w')) {
+          for (const word in config.config.words) {
+            console.log(word.concat('          ', ...config.config.words[word].map((def) => JSON.stringify(def))))
+          }
         }
-      }
-      if (args.print.includes('b')) {
-        for (const bridge of config.config.bridges) {
-          console.log(JSON.stringify(bridge))
+        if (args.print.includes('b')) {
+          for (const bridge of config.config.bridges) {
+            console.log(JSON.stringify(bridge))
+          }
         }
-      }
-      if (args.print.includes('o')) {
-        for (const operator of config.config.operators) {
-          console.log(JSON.stringify(operator))
+        if (args.print.includes('o')) {
+          for (const operator of config.config.operators) {
+            console.log(JSON.stringify(operator))
+          }
         }
-      }
-      if (args.print.includes('j')) {
-        const { data } = setupProcessB( { config } )
-        console.log(JSON.stringify(data, null, 2))
-      }
-      if (args.print.includes('a')) {
-        console.log('associations ================')
-        const properties = ['negative', 'positive']
-        for (let property of properties) {
-          console.log(`  ${property} ===============`)
-          for (let association of config.config.associations[property]) {
-            console.log(`  ${JSON.stringify(association)}`)
+        if (args.print.includes('j')) {
+          const { data } = setupProcessB( { config } )
+          console.log(JSON.stringify(data, null, 2))
+        }
+        if (args.print.includes('a')) {
+          console.log('associations ================')
+          const properties = ['negative', 'positive']
+          for (let property of properties) {
+            console.log(`  ${property} ===============`)
+            for (let association of config.config.associations[property]) {
+              console.log(`  ${JSON.stringify(association)}`)
+            }
           }
         }
-      }
-      if (args.print.includes('d')) {
-        console.log(JSON.stringify(config.config.objects, null, 2))
-      }
-      if (args.print.includes('p')) {
-        for (let priority of config.config.priorities) {
-          console.log(JSON.stringify(priority))
+        if (args.print.includes('d')) {
+          console.log(JSON.stringify(config.config.objects, null, 2))
         }
-      }
-      if (args.print.includes('h')) {
-        for (let edge of config.config.hierarchy) {
-          console.log(JSON.stringify(edge))
+        if (args.print.includes('p')) {
+          for (let priority of config.config.priorities) {
+            console.log(JSON.stringify(priority))
+          }
         }
-      }
-      if (args.print.includes('g')) {
-        const easyToRead = _.cloneDeep(config.config.generators)
-        for (const semantic of easyToRead) {
-          semantic.match = semantic.match.toString()
-          semantic.apply = semantic.apply.toString()
-          if (semantic.applyWrapped) {
-            semantic.applyWrapped = semantic.applyWrapped.toString()
+        if (args.print.includes('h')) {
+          for (let edge of config.config.hierarchy) {
+            console.log(JSON.stringify(edge))
           }
         }
-        console.dir(easyToRead)
-      }
-      if (args.print.includes('s')) {
-        const easyToRead = _.cloneDeep(config.config.semantics)
-        for (const semantic of easyToRead) {
-          semantic.match = semantic.match.toString()
-          semantic.apply = semantic.apply.toString()
+        if (args.print.includes('g')) {
+          const easyToRead = _.cloneDeep(config.config.generators)
+          for (const semantic of easyToRead) {
+            semantic.match = semantic.match.toString()
+            semantic.apply = semantic.apply.toString()
+            if (semantic.applyWrapped) {
+              semantic.applyWrapped = semantic.applyWrapped.toString()
+            }
+          }
+          console.dir(easyToRead)
+        }
+        if (args.print.includes('s')) {
+          const easyToRead = _.cloneDeep(config.config.semantics)
+          for (const semantic of easyToRead) {
+            semantic.match = semantic.match.toString()
+            semantic.apply = semantic.apply.toString()
+          }
+          console.dir(easyToRead)
         }
-        console.dir(easyToRead)
       }
     }
 
@@ -1601,7 +1702,7 @@ const knowledgeModule = async ({
             test = useTestConfig.name
 
           }
-          runTests(config, test, { debug: args.debug, testConfig: useTestConfig, verbose: args.testVerbose || args.testAllVerbose, stopAtFirstError: !args.testAllVerbose }).then((results) => {
+          runTests(config, test, { args, debug: args.debug, testConfig: useTestConfig, verbose: args.testVerbose || args.testAllVerbose, stopAtFirstError: !args.testAllVerbose }).then((results) => {
             let newError = false
             if (results.length > 0) {
               let headerShown = false
@@ -1611,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
                 }
@@ -1623,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')
@@ -1641,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')
@@ -1702,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(() => {
@@ -1727,11 +1851,12 @@ const knowledgeModule = async ({
       }
       config.beforeQuery({ query: args.query, isModule: false, objects })
       try {
-        processResults(_process(config, args.query, { commandLineArgs: args, dontAddAssociations: args.dontAddAssociations, writeTests: args.save || args.saveDeveloper, saveDeveloper: args.saveDeveloper, testConfig, testsFN: test }))
+        await processResults(_process(config, args.query, { commandLineArgs: args, dontAddAssociations: args.dontAddAssociations, writeTests: args.save || args.saveDeveloper, saveDeveloper: args.saveDeveloper, testConfig, testsFN: test }))
       } catch( error ) {
         console.log('Error', error);
       }
     }
+    printConfig()
   } else {
     config.addAssociationsFromTests(config.tests);
     //for (let query in config.tests) {
@@ -1739,6 +1864,7 @@ const knowledgeModule = async ({
     //}
     module()
   }
+
 }
 
 /*

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.1",
+  "version": "7.5.8-beta.3",
   "license": "ISC"
 }

package/src/config.js

@@ -5,6 +5,7 @@ const { Generators } = require('./generators')
 const client = require('../client')
 const DigraphInternal = require('./digraph_internal')
 const helpers = require('./helpers')
+const { ecatch } = require('./helpers')
 const runtime = require('../runtime')
 const _ = require('lodash')
 
@@ -22,103 +23,131 @@ const indent = (string, indent) => {
 }
 
 const handleBridgeProps = (config, bridge) => {
-  if (!bridge.bridge) {
-    bridge.bridge = "{ ...next(operator) }"
-  }
-  if (!bridge.level) {
-    bridge.level = 0
-  }
-  if (bridge.children) {
-    for (let child of bridge.children) {
-      config.addHierarchy(child, bridge.id)
-    }
-  }
-  if (bridge.parents) {
-    for (let parent of bridge.parents) {
-      config.addHierarchy(bridge.id, parent)
-    }
-  }
-  if (bridge.isA) {
-    for (let parent of bridge.isA) {
-      config.addHierarchy(bridge.id, parent)
-    }
-  }
-  if (bridge.before) {
-    for (let after of bridge.before) {
-      if (typeof after == 'string') {
-        after = [after, 0]
+  ecatch(`While processing the bridge for ${bridge.id}#${bridge.level}`,
+    () => {
+      if (!bridge.bridge) {
+        bridge.bridge = "{ ...next(operator) }"
       }
-      config.addPriorities([after, [bridge.id, bridge.level]])
-    }
-  }
-  if (bridge.words) {
-    for (let def of bridge.words) {
-      if (typeof def == 'string') {
-        config.addWordInternal(def, {"id": bridge.id, "initial": `{ value: "${def}"}` })
-      } else {
-        const word = def.word
-        def = { initial: JSON.stringify(def), id: bridge.id, word: undefined }
-        config.addWordInternal(word, def)
+      if (!bridge.level) {
+        bridge.level = 0
+      }
+      if (bridge.children) {
+        for (let child of bridge.children) {
+          config.addHierarchy(child, bridge.id)
+        }
+      }
+      if (bridge.parents) {
+        for (let parent of bridge.parents) {
+          config.addHierarchy(bridge.id, parent)
+        }
+      }
+      if (bridge.isA) {
+        for (let parent of bridge.isA) {
+          config.addHierarchy(bridge.id, parent)
+        }
+      }
+      if (bridge.before) {
+        for (let after of bridge.before) {
+          if (typeof after == 'string') {
+            after = [after, 0]
+          }
+          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') {
+            config.addWordInternal(def, {"id": bridge.id, "initial": `{ value: "${def}"}` })
+          } else {
+            const word = def.word
+            def = { initial: JSON.stringify(def), id: bridge.id, word: undefined }
+            config.addWordInternal(word, def)
+          }
+        }
+      }
+      if (bridge.generator) {
+        config.config.generators.unshift(bridge.generator)
+      }
+      if (bridge.generators) {
+        const generators = [...bridge.generators]
+        generators.reverse()
+        for (let generator of generators) {
+          config.config.generators.unshift(generator)
+        }
+      }
+      if (bridge.generatorpr) {
+        bridge.generatorp = bridge.generatorpr
+        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: (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
+          where: bridge.generatorr.where || bridge.where || client.where(3),
+          match: ({context}) => bridge.id == context.marker && !context.paraphrase && (context.response || context.isResponse),
+          apply: (args) => bridge.generatorr(args),
+          applyWrapped: bridge.generatorr,
+          property: 'generatorr',
+        })
+      }
+      */
+      if (bridge.evaluator) {
+        config.config.semantics.unshift({ 
+          where: bridge.evaluator.where || bridge.where || client.where(3),
+          match: ({context}) => bridge.id == context.marker && context.evaluate,
+          apply: (args) => bridge.evaluator(args),
+          applyWrapped: bridge.evaluator,
+          property: 'evaluator',
+        })
+      }
+      if (bridge.semantic) {
+        config.config.semantics.unshift({ 
+          where: bridge.semantic.where || bridge.where || client.where(3),
+          match: ({context}) => bridge.id == context.marker,
+          apply: (args) => bridge.semantic(args),
+          applyWrapped: bridge.semantic,
+          property: 'semantic',
+        })
       }
     }
-  }
-  if (bridge.generator) {
-    config.config.generators.unshift(bridge.generator)
-  }
-  if (bridge.generators) {
-    const generators = [...bridge.generators]
-    generators.reverse()
-    for (let generator of generators) {
-      config.config.generators.unshift(generator)
-    }
-  }
-  if (bridge.generatorpr) {
-    bridge.generatorp = bridge.generatorpr
-    bridge.generatorr = bridge.generatorpr
-  }
-  if (bridge.generatorp) {
-    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,
-      property: 'generatorp',
-    })
-  }
-  if (bridge.generatorr) {
-    config.config.generators.unshift({ 
-      // TODO merge response and isResponse
-      where: bridge.generatorr.where || bridge.where || client.where(3),
-      match: ({context}) => bridge.id == context.marker && !context.paraphrase && (context.response || context.isResponse),
-      apply: (args) => bridge.generatorr(args),
-      applyWrapped: bridge.generatorr,
-      property: 'generatorr',
-    })
-  }
-  if (bridge.evaluator) {
-    config.config.semantics.unshift({ 
-      where: bridge.evaluator.where || bridge.where || client.where(3),
-      match: ({context}) => bridge.id == context.marker && context.evaluate,
-      apply: (args) => bridge.evaluator(args),
-      applyWrapped: bridge.evaluator,
-      property: 'evaluator',
-    })
-  }
-  if (bridge.semantic) {
-    config.config.semantics.unshift({ 
-      where: bridge.semantic.where || bridge.where || client.where(3),
-      match: ({context}) => bridge.id == context.marker,
-      apply: (args) => bridge.semantic(args),
-      applyWrapped: bridge.semantic,
-      property: 'semantic',
-    })
-  }
+  )
 }
 
 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)
@@ -138,13 +167,21 @@ if (runtime.process.env.DEBUG_HIERARCHY) {
   global.entodictonDebugHierarchy = JSON.parse(runtime.process.env.DEBUG_HIERARCHY)
 }
 
+if (runtime.process.env.DEBUG_PRIORITY) {
+  global.entodictonDebugPriority = JSON.parse(runtime.process.env.DEBUG_PRIORITY)
+}
+
+if (runtime.process.env.DEBUG_ASSOCIATION) {
+  global.entodictonDebugAssociation = JSON.parse(runtime.process.env.DEBUG_ASSOCIATION)
+}
+
 if (runtime.process.env.DEBUG_BRIDGE) {
   // id/level
   global.entodictonDebugBridge = runtime.process.env.DEBUG_BRIDGE.split('/')
   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) {
@@ -162,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) {
@@ -725,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
@@ -779,10 +816,15 @@ class Config {
     if (!this.config.priorities) {
       this.config.priorities = []
     }
+    if (global.entodictonDebugPriority) {
+      if (helpers.safeEquals(entodictonDebugPriority, priorities)) {
+        debugger; // debug hierarchy hit
+      }
+    }
     this.config.priorities.push(priorities)
     this._delta.json.priorities.push({ action: 'add', priorities })
   }
- 
+
   addHierarchy (child, parent) {
     if (child && parent || !child || Array.isArray(child) || (typeof child == 'string' && !parent)) {
       this.addHierarchyChildParent(child, parent)
@@ -795,13 +837,13 @@ 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])) {
+      if (helpers.safeEquals(entodictonDebugHierarchy, [child, parent])) {
         debugger; // debug hierarchy hit
       }
     }
@@ -812,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) {
@@ -848,7 +890,7 @@ class Config {
     }
     const bridges = this.config.bridges
     const def = Object.assign({}, bridge, { uuid: this._uuid })
-   
+  
     if (global.entodictonDebugBridge) {
       if (global.entodictonDebugBridge[0] == bridge.id && global.entodictonDebugBridge[1] == bridge.level) {
         debugger; // debug hierarchy hit
@@ -876,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) {
@@ -903,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) {
@@ -1180,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) {
@@ -1261,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}`)
       }
     }
 
@@ -1376,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) {
@@ -1449,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
@@ -1684,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}`)
         }
       }
     }
@@ -1921,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
@@ -2309,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}'`)
           }
         }
       }
@@ -2325,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)}`)
         }
       }
     }
@@ -2357,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)
@@ -2525,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]
       }
@@ -2643,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)}`)
     }
   }
 }
@@ -309,7 +316,16 @@ const functionsToStrings = (config) => {
   return config
 }
 
+const ecatch = (where, call) => {
+  try {
+    return call()
+  } catch( e ) {
+    throw new Error(`${where} ${e}`)
+  }
+}
+
 module.exports = { 
+  ecatch,
   functionsToStrings,
   updateQueries,
   mapInPlace,

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