theprogrammablemind_4wp 7.5.8-beta.2 → 7.5.8-beta.21

package/client.js

@@ -109,7 +109,7 @@ class ErrorReason extends Error {
 
 const setupArgs = (args, config, logs, hierarchy) => {
   config.setArgs(args)
-  args.calls = new InitCalls(config.name)
+  args.calls = new InitCalls(args.isInstance ? `${args.isInstance}#${config.name}` : config.name)
   if (global.theprogrammablemind && global.theprogrammablemind.loadForTesting) {
     args.calls = new InitCalls(Object.keys(global.theprogrammablemind.loadForTesting)[0])
   }
@@ -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,18 @@ 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 })
+  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) {
@@ -355,16 +366,18 @@ const setupContexts = (rawContexts) => {
   return contexts
 }
 
-const processContextsB = ({ config, hierarchy, semantics, generators, json, isTest, query, data, retries, url, commandLineArgs }) => {
+const processContextsB = ({ config, hierarchy, semantics, generators, json, isTest, isInstance, query, data, retries, url, commandLineArgs }) => {
   // TODO fix this name to contextsPrime
   const contextsPrime = []
   const generatedPrime = []
   const paraphrasesPrime = []
+  const paraphrasesParenthesizedPrime = []
+  const generatedParenthesizedPrime = []
   const responsesPrime = []
   const contexts = setupContexts(json.contexts)
 
   const objects = config.get('objects')
-  const args = { objects, isResponse: true, response: json, isTest, getObjects: getObjects(objects) }
+  const args = { objects, isResponse: true, response: json, isTest, isInstance, getObjects: getObjects(objects), isInstance }
   if (!json.logs) {
     json.logs = []
   }
@@ -404,6 +417,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
       if (json.has_errors) {
         throw new Error('There are errors in the logs. Run with the -d flag and grep for Error')
       }
+      const generateParenthesized = isTest || (commandLineArgs && commandLineArgs.save)
       if (!config.get('skipSemantics')) {
         if (!config.doMotivations(args, context)) {
           const semantics = config.getSemantics(json.logs)
@@ -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 (generateParenthesized) {
+        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 (generateParenthesized) {
+        config.parenthesized = false
+      }
       const paraphrases = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
+      let paraphrasesParenthesized = []
+      if (generateParenthesized) {
+        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 (generateParenthesized) {
+        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}`)
     }
   }
 }
@@ -516,8 +549,11 @@ const setupProcessB = ({ config, initializer, allowDelta=false } = {}) => {
     // console.log('config', config)
     data.delta = config.delta()
   } else {
-    Object.assign(data, config.config)
+    config.toData(data)
+    // Object.assign(data, config.config)
   }
+
+  // config.toServer(data)
  
   if (data.namespaces) { 
     for (const uuid of Object.keys(data.namespaces)) {
@@ -553,13 +589,13 @@ const processInstance = (config, instance) => {
       // config.addInternal(config.template.queries[i], { handleCalculatedProps: true } )
       config.addInternal(instance.template.queries[i], { handleCalculatedProps: true } )
     } else {
-      processContextsB({ config, hierarchy, json: results/*, generators, semantics */, commandLineArgs: {} })
+      processContextsB({ config, hierarchy, json: results/*, generators, semantics */, commandLineArgs: {}, isInstance: `instance${i}` })
     }
   }
   global.transitoryMode = transitoryMode
 }
 
-const _process = async (config, query, { initializer, commandLineArgs, credentials, writeTests, isTest, saveDeveloper, testConfig, testsFN, errorHandler = defaultErrorHandler } = {}) => {
+const _process = async (config, query, { initializer, commandLineArgs, credentials, writeTests, isTest, saveDeveloper, rebuildingTemplate, testConfig, testsFN, errorHandler = defaultErrorHandler } = {}) => {
   if (credentials) {
     config.server(credentials.server, credentials.key)
   }
@@ -583,6 +619,9 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
   if (commandLineArgs && commandLineArgs.checkForLoop) {
     data.checkForLoop = true
   }
+  if (rebuildingTemplate) {
+    data.errors_ignore_contextual_priorities_non_existant_ops = true
+  }
   let queries = query.split('\\n')
 
   try {
@@ -598,6 +637,8 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
       contexts: [],
       generated: [],
       paraphrases: [],
+      paraphrasesParenthesized: [],
+      generatedParenthesized: [],
       responses: [],
       associations: [],
     }
@@ -633,7 +674,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 +691,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 +700,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 +781,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 +830,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 +838,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 +873,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 +954,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) => {
@@ -1042,10 +1124,11 @@ const defaultErrorHandler = async (error) => {
     doErrorExit = true
   }
 
-  if (doErrorExit) {
+  if (typeof runtime.process.exit == 'function' && doErrorExit) {
     runtime.process.exit(-1)
   }
-  // throw error
+
+  throw error
 }
 
 const defaultInnerProcess = (config, errorHandler, responses) => {
@@ -1168,13 +1251,15 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
       }
 
       try {
-        const results = await _process(config, query.query, {initializer})
+        const results = await _process(config, query.query, {initializer, rebuildingTemplate: true})
         if (config.config.debug) {
           // TODO pass in the error handler like the other ones
           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}`)
         }
@@ -1271,9 +1356,15 @@ const knowledgeModule = async ({
   beforeTests = () => {},
   afterTests = () => {},
   beforeTest = () => {},
-  afterTest = () => {}
+  afterTest = () => {},
+  ...rest
 } = {}) => {
 
+  const unknownArgs = Object.keys(rest)
+  if (unknownArgs.length > 0) {
+    throw new Error(`Unknown arguments to knowledgeModule: ${unknownArgs.join()}`)
+  }
+
   config.beforeQuery = beforeQuery 
   config.beforeTests = beforeTests 
   config.afterTests = afterTests 
@@ -1283,19 +1374,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 +1444,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,9 +1459,10 @@ 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 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], ["mammal", 1]]\' })'
+    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 helpDebugContextualPriority = 'In order to get a debug break when a specific set of contextual priorities is created set set DEBUG_CONTEXTUAL_PRIORITY environment variable to the JSON of the priorities that you want to break on. For example DEBUG_CONTEXTUAL_PRIORITY=\'{ context: [["verb", 0], ["article", 0], select: 1}\' })'
     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]))\' })'
 
@@ -1392,6 +1484,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.' })
@@ -1404,12 +1497,17 @@ const knowledgeModule = async ({
     parser.add_argument('-da', '--debugAssociation', { help: helpDebugAssociation })
     parser.add_argument('-dh', '--debugHierarchy', { help: helpDebugHierarchy })
     parser.add_argument('-dp', '--debugPriority', { help: helpDebugPriority })
+    parser.add_argument('-dcp', '--debugContextualPriority', { help: helpDebugContextualPriority })
     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) {
       console.log(helpDebugAssociation)
       runtime.process.exit(-1)
@@ -1629,6 +1727,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 +1745,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 +1779,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 +1841,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(() => {
@@ -1829,3 +1950,4 @@ module.exports = {
   flattens,
   writeTest
 }
+

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.21",
   "license": "ISC"
 }

package/src/config.js

@@ -22,6 +22,90 @@ const indent = (string, indent) => {
     return string.replace(/^/gm, ' '.repeat(indent));
 }
 
+const config_toServer = (config) => {
+  if (config.contextual_priorities) {
+    config.contextual_priorities = config.contextual_priorities.map((cp) => {
+      return [cp.context, cp.choose]
+    })
+  }
+}
+
+const contextual_priorities_toServer = (cp) => {
+  if (cp.context && cp.choose) {
+    return [cp.context, cp.choose]
+  }
+  return cp
+}
+
+const contextual_priorities_toClient = (cp) => {
+  if (cp.context && cp.choose) {
+    return cp
+  }
+  return { context: cp[0], choose: cp[1] }
+}
+
+const operatorKey_valid = (key) => {
+  if (
+        !_.isArray(key) ||
+        key.length != 2 ||
+        !_.isString(key[0]) ||
+        !_.isInteger(key[1]) ||
+        key[1] < 0
+     ) {
+
+    let details = ''
+    if (!_.isArray(key)) {
+      details = "Expected an array."
+    } else if (key.length != 2) {
+      details = "Expected an array of length two."
+    } else if (!_.isString(key[0])) {
+      details = "Expected element zero to be a string that is an operator id."
+    } else if (!_.isInteger(key[1])) {
+      details = "Expected element one to be a number that is an operator level."
+    } else if (key[1] < 0) {
+      details = "Expected element one to be a number that is an operator level which is greater than zero."
+    }
+    throw new Error(`${JSON.stringify(key)} is not a valid operator key. Values are of the form [<operatorId>, <operatorLevel>]. ${details}`)
+  }
+}
+
+const elist = (list, check, prefix) => {
+  for ([index, element] of list.entries()) {
+    try {
+      check(element)
+    } catch( e ) {
+      throw new Error(prefix(index, e))
+    }
+  }
+}
+const contextual_priorities_valid = (cps) => {
+  elist(cps, (cp) => contextual_priority_valid(cp),  (index, e) => `contextual_priorities has an invalid contextual priority at position ${index}. ${e}`)
+}
+
+const contextual_priority_valid = (cp) => {
+  if (!cp.context) {
+    throw new Error(`The contextual priority ${JSON.stringify(cp)} is missing the "context" property. That is a list of the operator keys that are to be prioritized differently.`)
+  }
+  if (!_.isArray(cp.context)) {
+    throw new Error(`The contextual priority ${JSON.stringify(cp)} has an invalid "context" value. That is a list of the operator keys that are to be prioritized differently.`)
+  }
+  elist(cp.context, (element) => operatorKey_valid(element), (index, e) => `The contextual priority ${JSON.stringify(cp)} has an invalid operator key at position ${index}. ${e}`)
+  if (!_.isArray(cp.choose)) {
+    throw new Error(`The contextual priority ${JSON.stringify(cp)} has an invalid "choose" value. The value should be a list of the operators in the context to consider for prioritization.`)
+  }
+  elist(cp.choose, 
+      (element) => {
+        if (!element && element !== 0) {
+          throw new Error(`The value should be an index into the "context" property of the operator that is to be considered for prioritization.`)
+        }
+        if (!_.isInteger(element) || element < 0 || element >= cp.context.length) {
+          throw new Error(`The value should be an index into the "context" property of the operator that is to be considered for prioritization. Valid values are between 0 and ${cp.context.length-1}.`)
+        }
+      }, 
+      (index, e) => `The choose property in the contextual priority ${JSON.stringify(cp)} has an invalid index at position ${index}. ${e}`
+  )
+}
+
 const handleBridgeProps = (config, bridge) => {
   ecatch(`While processing the bridge for ${bridge.id}#${bridge.level}`,
     () => {
@@ -54,6 +138,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 +172,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 +206,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 +231,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)
@@ -147,6 +255,10 @@ if (runtime.process.env.DEBUG_PRIORITY) {
   global.entodictonDebugPriority = JSON.parse(runtime.process.env.DEBUG_PRIORITY)
 }
 
+if (runtime.process.env.DEBUG_CONTEXTUAL_PRIORITY) {
+  global.entodictonDebugContextualPriority = JSON.parse(runtime.process.env.DEBUG_CONTEXTUAL_PRIORITY)
+}
+
 if (runtime.process.env.DEBUG_ASSOCIATION) {
   global.entodictonDebugAssociation = JSON.parse(runtime.process.env.DEBUG_ASSOCIATION)
 }
@@ -157,7 +269,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 +287,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) {
@@ -465,6 +577,31 @@ const multiApiImpl = (initializer) => {
 
 class Config {
 
+  toServer (config) {
+    return config_toServer(config)
+  }
+
+  getPsuedoConfig() {
+    return {
+      description: "this is a pseudo config that has limited functionality due to being available in the initializer function context",
+      addAssociation: (...args) => this.addAssociation(...args),
+      addAssociations: (...args) => this.addAssociations(...args),
+      addBridge: (...args) => this.addBridge(...args),
+      addContextualPriority: (...args) => this.addContextualPriority(...args),
+      addGenerator: (...args) => this.addGenerator(...args),
+      addHierarchy: (...args) => this.addHierarchy(...args),
+      addOperator: (...args) => this.addOperator(...args),
+      addPriorities: (...args) => this.addPriorities(...args),
+      addSemantic: (...args) => this.addSemantic(...args),
+      addWord: (...args) => this.addWord(...args),
+
+      addArgs: (...args) => this.addArgs(...args),
+      getBridge: (...args) => this.getBridge(...args),
+      fragment: (...args) => this.fragment(...args),
+      addAPI: (...args) => this.addAPI(...args),
+    }
+  }
+
   inDevelopmentMode (call) {
     config.developmentModeOn += 1
     try {
@@ -524,6 +661,7 @@ class Config {
       },
       eqClasses: [],
       priorities: [], // Done
+      contextual_priorities: [],
       version: '3',
       debug: false,
       associations: { // Done
@@ -562,6 +700,7 @@ class Config {
           'namespaces',
           'eqClasses',
           'priorities',
+          'contextual_priorities',
           'associations',
           'words',
           'floaters',
@@ -715,6 +854,11 @@ class Config {
     }
   }
 
+  toData (data) {
+    Object.assign(data, this.config)
+    config_toServer(data)
+  }
+
   load (template, instance, options = { rebuild: false } ) {
     this.validifyTemplate(template)
     instance.template = template
@@ -738,7 +882,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
@@ -801,6 +945,22 @@ class Config {
     this._delta.json.priorities.push({ action: 'add', priorities })
   }
 
+  // [ operators: <list of [id, level]>, select: <index of prioritized operator> ]
+  addContextualPriority(contextual_priority) {
+    if (!this.config.contextual_priorities) {
+      this.config.contextual_priorities = []
+    }
+    if (global.entodictonDebugContextualPriority) {
+      if (helpers.safeEquals(entodictonDebugContextualPriority, contextual_priorities)) {
+        debugger; // debug hierarchy hit
+      }
+    }
+    contextual_priority_valid(contextual_priority)
+    this.config.contextual_priorities.push(contextual_priority)
+    const cpServer = contextual_priorities_toServer(contextual_priority)
+    this._delta.json.contextual_priorities.push({ action: 'add', contextual_priority: cpServer })
+  }
+
   addHierarchy (child, parent) {
     if (child && parent || !child || Array.isArray(child) || (typeof child == 'string' && !parent)) {
       this.addHierarchyChildParent(child, parent)
@@ -813,10 +973,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 +990,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) {
@@ -857,7 +1017,11 @@ class Config {
   }
 
   getBridge (id, level) {
-    return this.config.bridges.find( (bridge) => bridge.id == id && bridge.level == level )
+    if (level) {
+      return this.config.bridges.find( (bridge) => bridge.id == id && bridge.level == level )
+    } else {
+      return this.config.bridges.find( (bridge) => bridge.id == id)
+    }
   }
 
   addBridge (bridge) {
@@ -894,10 +1058,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 +1085,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 +1362,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) {
@@ -1209,6 +1373,7 @@ class Config {
         'operators', 
         'words', 
         'priorities', 
+        'contextual_priorities', 
         'associations', 
         'name', 
         'version', 
@@ -1238,6 +1403,7 @@ class Config {
       config.hierarchy = config.hierarchy || []
       config.associations = config.associations || { negative: [], positive: [] }
       config.priorities = config.priorities || []
+      config.contextual_priorities = config.contextual_priorities || []
     }
 
     this.maxDepth = 20 // for generators and semantics
@@ -1279,7 +1445,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}`)
       }
     }
 
@@ -1291,6 +1457,10 @@ class Config {
       }
     }
 
+    if (config && config.contextual_priorities) {
+      contextual_priorities_valid(config.contextual_priorities)
+    }
+
     normalizeConfig(config)
 
     // set the default server so stuff just works
@@ -1361,7 +1531,10 @@ class Config {
   }
 
   delta () {
-    return { cacheKey: this._delta.cacheKey, json: this._delta.json }
+    return { 
+      cacheKey: this._delta.cacheKey, 
+      json: this._delta.json 
+    }
   }
 
   resetDelta (cacheKey) {
@@ -1373,6 +1546,7 @@ class Config {
         bridges: [],
         associations: [],
         priorities: [],
+        contextual_priorities: [],
         hierarchy: [],
       }
     }
@@ -1394,13 +1568,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 +1641,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
@@ -1510,6 +1684,7 @@ class Config {
     cp.transitoryMode = this.transitoryMode
     cp.configs = this.configs.map((km) => km.copy2(Object.assign({}, options, { getCounter: (name) => cp.getCounter(name), callInitializers: false })))
     cp._uuid = cp.configs[0]._uuid
+    // update uuid here set the uuid in the objects and add error checking
     cp.initializerFn = this.initializerFn
     cp.initAfterApi = this.initAfterApi
     cp._api = _.cloneDeep(this._api)
@@ -1665,21 +1840,23 @@ class Config {
       if (config instanceof Config) {
         // const aw = addWord(this.config, config.uuid)
         const aw = (word, def) => this.addWord(word, def)
+        const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
         this.get('objects').namespaced[config._uuid] = objects
         if (config._api) {
           config._api.objects = objects
           config._api.config = () => this
         }
-        config.initializerFn({ addWord: aw, km, config, baseConfig: this, currentConfig: config, objects, namespace, uuid, api: config.api })
+        config.initializerFn({ addWord: aw, addGenerator: ag, km, testConfig: config, config: this.getPsuedoConfig(), baseConfig: this, currentConfig: config, objects, namespace, uuid, api: config.api })
       } else {
         // const aw = addWord(this.config, this.uuid)
         const aw = (word, def) => this.addWord(word, def)
+        const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
         this.get('objects').namespaced[this._uuid] = objects
         if (config._api) {
           config._api.objects = objects
           config._api.config = () => this
         }
-        this.initializerFn({ addWord: aw, km, config: this, baseConfig: this, currentConfig: this, objects, namespace, uuid, api: this.api })
+        this.initializerFn({ addWord: aw, addGenerator: ag, km, testConfig: this, config: this.getPsuedoConfig(), baseConfig: this, currentConfig: this, objects, namespace, uuid, api: this.api })
       }
     })
     this.instances.forEach((instance) => client.processInstance(this, instance))
@@ -1689,10 +1866,11 @@ class Config {
     if (force || !this.wasInitialized) {
       // const aw = addWord(this.config, this.uuid)
       const aw = (word, def) => this.addWord(word, def)
+      const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
       const km = (name) => this.getConfig(name)
       // this.initializerFn({ addWord: aw, km, config: this, baseConfig: this, currentConfig: this, objects: this.get('objects'), uuid: this._uuid, namespace: '', api: this.api })
       const objects = this.config.objects.namespaced[this._uuid]
-      this.initializerFn({ addWord: aw, km, config: this, baseConfig: this, currentConfig: this, objects, uuid: this._uuid, namespace: '', api: this.api })
+      this.initializerFn({ addWord: aw, addGenerator: ag, km, testConfig: this, config: this.getPsuedoConfig(), baseConfig: this, currentConfig: this, objects, uuid: this._uuid, namespace: '', api: this.api })
       this.wasInitialized = true
     }
   }
@@ -1702,7 +1880,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}`)
         }
       }
     }
@@ -1910,6 +2088,7 @@ class Config {
     const initAfterApis = []
     const reverseIt = true
     const interleaved = true
+    let isAfterApi = false
     this.configs.forEach((km) => {
       const namespace = km.namespace
       this.config.objects.namespaced[km._uuid] = {}
@@ -1917,6 +2096,7 @@ class Config {
       this.setupNamespace(km)
       // const aw = addWord(km.config.config ? km.config.config : km.config, km.config.uuid)
       const aw = (word, def) => this.addWord(word, def)
+      const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
       let config = km.config
      
       if (config.addedArgss) { 
@@ -1937,9 +2117,32 @@ class Config {
       }
       config.wasInitialized = false
       // TODO change name of config: to baseConfig:
-      const kmFn = (name) => this.getConfig(name)
+      const kmFn = (name) => {
+        const config = this.getConfig(name)
+        return config
+      }
       // 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 = new Object({ 
+        isModule, 
+        addWord: aw, 
+        addGenerator: ag,
+        km: kmFn, 
+        hierarchy: this.hierarchy, 
+        testConfig: config,
+        config: this.getPsuedoConfig(), 
+        baseConfig: this, 
+        currentConfig: config, 
+        uuid: config._uuid, 
+        objects: namespacedObjects, 
+        namespace, 
+        motivation: (m) => this.addMotivation(m),
+        get api() {
+          if (!isAfterApi) {
+            throw new Error("APIs should not be accessed in the initializer until after they are all initialized. Call initializer like config.initializer(fn, { initAfterApi: true }). Then the args to the initalizer will include isAfterApi which can be used to determine if the initialize is being run before or after the API's are initialized. The default is before.")
+          }
+          return config.api 
+        }
+      })
       config.initializerFn(args)
       if (config.initAfterApi) {
         // reverse the list
@@ -1991,6 +2194,7 @@ class Config {
       this.config.semantics = []
     }
 
+    isAfterApi = true
     if (!interleaved) {
       for (const config of addInternals) {
         if (!reverseIt) {
@@ -2005,7 +2209,7 @@ class Config {
       }
       for (let init of initAfterApis) {
         // init.args.isAfterApi = true
-        init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi: true })
+        init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi })
       }
       this.instances.forEach((instance) => client.processInstance(this, instance))
     } else {
@@ -2014,6 +2218,7 @@ class Config {
         bridges: this.config.bridges,
         hierarchy: this.config.hierarchy,
         priorities: this.config.priorities,
+        contextual_priorities: this.config.contextual_priorities,
         associations: this.config.associations,
         words: this.config.words
       }
@@ -2022,6 +2227,7 @@ class Config {
       this.config.bridges = []
       this.config.hierarchy = []
       this.config.priorities = []
+      this.config.contextual_priorities = []
       this.config.associations = { positive: [], negative: [] }
       this.config.words = {}
 
@@ -2040,7 +2246,7 @@ class Config {
         }
         if (initAfterApis[i]) {
           const init = initAfterApis[i]
-          init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi: true })
+          init.config.initializerFn({ ...init.args, kms: this.getConfigs(), isAfterApi})
         }
         const instance = this.instances.find((instance) => instance.name == name)
         if (instance) {
@@ -2173,11 +2379,13 @@ class Config {
         if (config instanceof Config) {
           // const aw = addWord(this.config, config.uuid)
           const aw = (word, def) => this.addWord(word, def)
-          config.initializerFn({ isModule: this.isModule, addWord: aw, baseConfig: this, km, currentConfig: config, config, objects: nsobjects, namespace, uuid, api: config.api })
+          const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
+          config.initializerFn({ isModule: this.isModule, addWord: aw, addGenerator: ag, baseConfig: this, km, currentConfig: config, testConfig: config, config: this.getPsuedoConfig(), objects: nsobjects, namespace, uuid, api: config.api })
         } else {
           // const aw = addWord(this.config, this.uuid)
           const aw = (word, def) => this.addWord(word, def)
-          this.initializerFn({ isModule: this.isModule, addWord: aw, baseConfig: this, km, currentConfig: this, config: this, objects: nsobjects, namespace, uuid, api: this.api })
+          const ag = (matchOrGenerator, applyOrNothing) => this.addGenerator(matchOrGenerator, applyOrNothing)
+          this.initializerFn({ isModule: this.isModule, addWord: aw, addGenerator: ag, baseConfig: this, km, currentConfig: this, testConfig: this, config: this.getPsuedoConfig(), objects: nsobjects, namespace, uuid, api: this.api })
         }
       })
     }
@@ -2242,6 +2450,20 @@ class Config {
       config.priorities = priorities
     }
 
+    if (config.contextual_priorities) {
+      let contextual_priorities = config.contextual_priorities
+      contextual_priorities = contextual_priorities.map((cp) => {
+        const { context, choose } = cp
+        return {
+          context: context.map((id) => {
+            return [toNS(id[0]), id[1]]
+          }),
+          choose
+        }
+      })
+      config.contextual_priorities = contextual_priorities
+    }
+
     for (const bag of bags) {
       if (config[bag]) {
         config[bag] = config[bag].map((b) => {
@@ -2327,14 +2549,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 +2565,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 +2597,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 +2765,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 +2883,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]
       }
@@ -2671,5 +2893,7 @@ class Config {
 }
 
 module.exports = {
-  Config
+  Config,
+  config_toServer,
+  operatorKey_valid,
 }

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