theprogrammablemind 7.5.8 → 7.6.0-beta.0

package/client.js

@@ -2,6 +2,7 @@ const { Semantics, Semantic } = require('./src/semantics')
 const { Generators, Generator } = require('./src/generators')
 const DigraphInternal = require('./src/digraph_internal')
 const Digraph = require('./src/digraph')
+const { project } = require('./src/project')
 const fetch = require('node-fetch')
 const base64 = require('base-64')
 const deepEqual = require('deep-equal')
@@ -9,20 +10,38 @@ const _ = require('lodash')
 const stringify = require('json-stable-stringify')
 const Lines = require('./lines')
 const flattens = require('./src/flatten')
-const { appendNoDups, InitCalls, updateQueries } = require('./src/helpers')
+const { appendNoDups, InitCalls, updateQueries, safeNoDups } = require('./src/helpers')
 const runtime = require('./runtime')
 const sortJson = runtime.sortJson
 
+const getConfig_getObjectsCheck = (testConfig) => {
+  return (testConfig.checks && testConfig.checks.objects) || []
+}
+
+const getConfig_getContextCheck = (testConfig) => {
+  return (testConfig.checks && testConfig.checks.context) || []
+}
+
+const pickContext = (testConfig) => (context) => {
+  return project(context, getConfig_getContextCheck(testConfig))
+}
+
+const pickObjects = (testConfig, objects) => {
+  return project(objects, getConfig_getObjectsCheck(testConfig))
+}
+
 const getAsk = (config) => (uuid) => (asks) => {
   for (let ask of asks) {
-    config.addMotivation({
+    config.addSemantic({
       uuid,
+      oneShot: true,
       match: (args) => ask.matchr(args),
       apply: (args) => ask.applyr(args)
     })
   }
-  config.addMotivation({
+  config.addSemantic({
       uuid,
+      oneShot: true,
       match: ({context}) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
       apply: (args) => {
         for (let ask of asks) {
@@ -37,7 +56,7 @@ const getAsk = (config) => (uuid) => (asks) => {
             }
           }
           if (matchq(args)) {
-            args.context.motivationKeep = true
+            // args.context.motivationKeep = true
             args.context.verbatim = applyq(args)
             args.context.isResponse = true;
             delete args.context.controlRemove;
@@ -49,6 +68,12 @@ const getAsk = (config) => (uuid) => (asks) => {
   })
 }
 
+const sameJSON = (json1, json2) => {
+  const sjson1 = sortJson(json1, { depth: 25 })
+  const sjson2 = sortJson(json2, { depth: 25 })
+  return JSON.stringify(sjson1) == JSON.stringify(sjson2)
+}
+
 const vimdiff = (actualJSON, expectedJSON) => {
   const path = '.'
   const actual = sortJson(actualJSON, { depth: 25 })
@@ -58,10 +83,9 @@ const vimdiff = (actualJSON, expectedJSON) => {
   // console.log(`vimdiff ${path}/actual.json ${path}/expected.json`)
   {
     const editor = runtime.process.env.EDITOR || 'vimdiff'
-    const child = runtime.child_process.spawn(editor, [`${path}/expected.json`, `${path}/actual.json`], { stdio: 'inherit' })
-    child.on('exit', function (e, code) {
-      console.log('finished')
-    })
+    // const child = runtime.child_process.spawn(editor, [`${path}/expected.json`, `${path}/actual.json`], { stdio: 'inherit' })
+    console.log(`${editor} ${path}/expected.json ${path}/actual.json`)
+    runtime.child_process.execSync(`${editor} ${path}/expected.json ${path}/actual.json`, {stdio: 'inherit'})
   }
 }
 
@@ -100,10 +124,24 @@ const asList = (context) => {
   }
 }
 
+class ErrorReason extends Error {
+   constructor(context) {
+     super(JSON.stringify(context))
+     this.reason = context
+   }
+}
+
 const setupArgs = (args, config, logs, hierarchy) => {
   config.setArgs(args)
-  args.calls = new InitCalls()
+  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])
+  }
   args.km = (name) => config.getConfig(name)
+  args.api = (name) => config.getConfig(name).api
+  args.error = (context) => {
+    throw new ErrorReason(context)
+  }
   args.kms = config.getConfigs()
   args.config = config
   args.hierarchy = hierarchy
@@ -111,6 +149,7 @@ const setupArgs = (args, config, logs, hierarchy) => {
   args.listable = listable(hierarchy)
   args.asList = asList
   args.retry = () => { throw new RetryError() }
+  args.fragments = (query) => config.fragment(query)
   const scopedAsk = getAsk(config)
 
   const getAPI = (uuid) => {
@@ -130,7 +169,6 @@ const setupArgs = (args, config, logs, hierarchy) => {
       apis: getAPIs(uuid)
     }
   }
-  args.motivation = (m) => config.addMotivation(m)
   args.breakOnSemantics = false
   args.theDebugger = {
     breakOnSemantics: (value) => args.breakOnSemantics = value
@@ -139,12 +177,15 @@ const setupArgs = (args, config, logs, hierarchy) => {
   args.g = (c) => config.getGenerators(logs).apply(args, c)
   args.gp = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: true, isResponse: false, response: false})
   args.gr = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: false, isResponse: true })
-  args.e = (c) => config.getEvaluator(args.s, logs, c)
+  if (!logs) {
+    debugger
+  }
+  args.e = (c) => config.getEvaluator(args.s, args.calls, logs, c)
   args.log = (message) => logs.push(message)
-  // config.getAddedArgs(args)
   args.gs = gs(args.g)
   args.gsp = gs(args.gp)
   args.gsr = gs(args.gr)
+  config.getAddedArgs(args)
 }
 
 const gs = (g) => (contexts, separator, lastSeparator) => {
@@ -272,7 +313,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))
@@ -282,7 +323,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) {
@@ -339,16 +391,21 @@ 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, instance, 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), instance }
+  if (!json.logs) {
+    json.logs = []
+  }
   setupArgs(args, config, json.logs, hierarchy)
   const toDo = [...contexts]
   args.insert = (context) => toDo.unshift(context)
@@ -356,28 +413,6 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
   config.debugLoops = commandLineArgs && commandLineArgs.debugLoops
   while (toDo.length > 0) {
     const context = toDo.shift()
-    /*
-    if (false && query) {
-      if (config.wasChanged()) {
-        // process contexts that overlap
-        overlap = lastRange
-      } else {
-        config.watch()
-      }
-      if (overlap) {
-        if (overlaps(overlap, context)) {
-          // okay
-          query = query.slice(overlap.end+1)
-          data.utterance = query
-          const json = await doWithRetries(retries, url, data)
-          toDo = setupContexts(json.contexts).slice(1) // take off the start context
-        }
-        overlap = undefined
-      }
-      lastRange = context.range
-    }
-    */
-
     args.calls.next()
     let contextPrime = context
     context.topLevel = true
@@ -385,25 +420,40 @@ 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)
-          try {
-            contextPrime = semantics.apply(args, context)
-          } catch( e ) {
-            if (e.message == 'Maximum call stack size exceeded') {
-              const mostCalled = semantics.getMostCalled()
-              e.message += `\nThe most called semantic was:\nnotes: ${mostCalled.notes}\nmatch: ${mostCalled.matcher.toString()}\napply: ${mostCalled._apply.toString()}\n`
-            }
-            throw e;
+        const semantics = config.getSemantics(json.logs)
+        try {
+          contextPrime = semantics.apply(args, context)
+        } catch( e ) {
+          if (e.message == 'Maximum call stack size exceeded') {
+            const mostCalled = semantics.getMostCalled()
+            e.message += `\nThe most called semantic was:\nnotes: ${mostCalled.notes}\nmatch: ${mostCalled.matcher.toString()}\napply: ${mostCalled._apply.toString()}\n`
+          }
+          // contextPrime = semantics.apply(args, { marker: 'error', context, error: e })
+          if (isInstance) {
+            console.log('error', e.error)
           }
+          contextPrime = semantics.apply(args, { 
+                marker: 'error', 
+                context, 
+                text: e ? e.toString() : 'not available', 
+                reason: e.reason, 
+                error: e.stack || e.error
+              })
         }
       }
       if (contextPrime.controlRemove) {
         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)
@@ -412,7 +462,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 })
@@ -422,6 +481,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 {
@@ -431,7 +494,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 = {
@@ -451,7 +514,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) => {
@@ -473,17 +536,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}`)
     }
   }
 }
@@ -496,8 +559,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)) {
@@ -520,10 +586,22 @@ const setupProcessB = ({ config, initializer, allowDelta=false } = {}) => {
   }
 }
 
-// instance template
-const processInstance = (config, instance) => {
+// instance template loadTemplate
+const loadInstance = (config, instance) => {
   const transitoryMode = global.transitoryMode
   global.transitoryMode = false
+
+  if (instance && (instance.associations || instance.learned_contextual_priorities)) {
+    if (!config.config.retrain) {
+      if (instance.associations) {
+        config.addAssociations(instance.associations)
+      }
+      if (instance.learned_contextual_priorities && instance.learned_contextual_priorities.length > 0) {
+        config.addPriorities(instance.learned_contextual_priorities)
+      }
+    }
+  }
+
   const { /* data, generators, semantics, */ hierarchy } = setupProcessB({ config })
   // for (const results of (instance.resultss || [])) {
   for (const i in (instance.resultss || [])) {
@@ -531,15 +609,21 @@ const processInstance = (config, instance) => {
     if (results.extraConfig) {
       // config.addInternal(results, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false)
       // config.addInternal(config.template.queries[i], { handleCalculatedProps: true } )
-      config.addInternal(instance.template.queries[i], { handleCalculatedProps: true } )
+      config.addInternal(instance.template.queries[i], { addFirst: true, handleCalculatedProps: true } )
     } else {
-      processContextsB({ config, hierarchy, json: results/*, generators, semantics */, commandLineArgs: {} })
+      if (results.skipSemantics) {
+        config.config.skipSemantics = results.skipSemantics
+      }
+      processContextsB({ config, hierarchy, json: results/*, generators, semantics */, commandLineArgs: {}, isInstance: `instance${i}`, instance: instance.queries[i] })
+      if (results.skipSemantics) {
+        config.config.skipSemantics = null
+      }
     }
   }
   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)
   }
@@ -553,7 +637,6 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
     if (writeTests) {
       config.rebuild()
       const objects = getObjects(config.config.objects)(config.uuid)
-      config.beforeQuery({ query, isModule: false, objects })
     }
   } catch(error) {
     throw error
@@ -561,7 +644,10 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
 
   let { data, /* generators, semantics, */ hierarchy } = setupProcessB({ config, initializer, allowDelta: true })
   if (commandLineArgs && commandLineArgs.checkForLoop) {
-    data.checkForLoop = true
+    data.checkForLoop = commandLineArgs.checkForLoop
+  }
+  if (rebuildingTemplate) {
+    data.errors_ignore_contextual_priorities_non_existant_ops = true
   }
   let queries = query.split('\\n')
 
@@ -578,6 +664,8 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
       contexts: [],
       generated: [],
       paraphrases: [],
+      paraphrasesParenthesized: [],
+      generatedParenthesized: [],
       responses: [],
       associations: [],
     }
@@ -613,9 +701,10 @@ 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.learned_contextual_priorities = json.learned_contextual_priorities
         response.hierarchy = json.hierarchy
         response.load_cache_time += json.load_cache_time
         appendNoDups(response.logs, json.logs)
@@ -626,10 +715,13 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         response.times += json.times
         response.trace = response.trace.concat(json.trace)
         response.version = json.version
+        response.explain_priorities = json.explain_priorities
 
         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)
       }
@@ -637,13 +729,18 @@ 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)
+      const saveObjects = {...config.config.objects}
+      saveObjects.nameToUUID = {}
+      for (let km of config.configs) {
+        saveObjects.nameToUUID[km.name] = km.uuid
+      }
+      writeTest(testsFN, query, saveObjects, 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)
   }
 }
 
@@ -677,11 +774,13 @@ const getConfigForTest = (config, testConfig) => {
   return configForTest
 }
 
-const runTest = async (config, expected, { verbose, afterTest, testConfig, debug }) => {
+const runTest = async (config, expected, { args, verbose, 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) {
@@ -700,8 +799,6 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
     objects = getObjects(config.config.objects)(config.getConfigs()[testConfig.testModuleName].uuid)
     testConfigName = testConfig.testModuleName
   }
-  config.beforeQuery({ query: test, isModule: false, objects })
-  // config.resetMotivations()
     try {
       const result = await _process(config, test, { errorHandler, isTest: true })
       result.query = test
@@ -716,66 +813,48 @@ 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)
+      let failed_paraphrasesParenthesized = !matching(result.paraphrasesParenthesized, expected.paraphrasesParenthesized)
+      let failed_generatedParenthesized = !matching(result.generatedParenthesized, expected.generatedParenthesized)
+      // TODO fix the naming conventions: camelcase + use actual instead of result
       const failed_responses = !matching(result.responses, expected.responses)
       const failed_contexts = !matching(result.contexts, expected.contexts)
       const failed_objects = !matching(actual_objects, expected_objects)
 
-      const pickEm = (getObjects) => {
-        const picked = {}
-        for (let prop of (testConfig.check || [])) {
-          if (prop.km) {
-            c = config.getConfig(prop.km)
-            o = getObjects(prop.km)
-            picked[prop.km] = {}
-            for (let p of c.testConfig.check) {
-              if (p.km) {
-                continue
-              }
-              picked[p] = o[p]
-            }
-          } else {
-            picked[prop] = getObjects(testConfigName)[prop]
-          }
-        }
-        return picked
+      if (args.testNoParenthesized) {
+        failed_paraphrasesParenthesized = false
+        failed_generatedParenthesized = false
       }
+
+      const pickedResultContexts = result.contexts.map(pickContext(testConfig))
+      const pickedExpectedContexts = expected.contexts.map(pickContext(testConfig))
+      const failedCheckedContexts = !matching(pickedResultContexts, pickedExpectedContexts)
+
       const expectedGetObjects = (name) => {
         if (!name) {
           name = config.name
         }
-        return expected.objects.namespaced[expected.objects.nameToUUID[name]]
+        return expected.objects.namespaced[expected.objects.nameToUUID[name]] || {}
       }
-      const expected_checked = sortJson(pickEm(expectedGetObjects), { depth: 25 })
+      const expected_checked = sortJson(pickObjects(testConfig, expectedGetObjects(testConfigName)), { depth: 25 })
       const actualGetObjects = (name) => {
         if (!name) {
           name = config.name
         }
         const km = config.configs.find( (km) => km.name == name )
-        return config.config.objects.namespaced[km.uuid]
+        return config.config.objects.namespaced[km.uuid] || {}
       }
-      const actual_checked = sortJson(pickEm(actualGetObjects), { depth: 25 })
+      const actual_checked = sortJson(pickObjects(testConfig, actualGetObjects(testConfigName)), { depth: 25 })
       const failed_checked = !matching(actual_objects, expected_objects)
 
       const failed_checks = !matching(actual_objects, expected_objects)
+      const failed_checked_objects = !matching(actual_checked, expected_checked)
       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
-      if (!failed) {
-        if (config.afterTest) {
-          failed = config.afterTest({ query: test, expected, actual: result, config })
-          if (failed) {
-            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 }
-            }
-          }
-        }
-      }
+      let failed = failed_checked_objects || failed_paraphrases || failed_paraphrasesParenthesized || failed_generatedParenthesized || failed_responses || failed_contexts || failed_objects || failed_config || failed_checked || failedCheckedContexts
 
       if (expected.metadata && result.metadata && failed) {
         const priorities = analyzeMetaData(expected.metadata, result.metadata)
@@ -787,8 +866,28 @@ 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, 
+            checkedContexts: pickedExpectedContexts,
+            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, 
+            checkedContexts: pickedResultContexts,
+            objects: actual_objects, 
+            config: actual_config 
+          }
         }
       }
     } catch(error) {
@@ -825,20 +924,16 @@ const runTestsHelper = async (config, tests, failed, juicyBits) => {
 
 const runTests = async (config, testFile, juicyBits) => {
   const tests = JSON.parse(runtime.fs.readFileSync(testFile))
-  config.beforeTests()
   if (juicyBits.verbose) {
     console.log('\n', testFile, '-----------------------------------------------', '\n')
   }
   const v = await runTestsHelper(config, [...tests], [], juicyBits)
-  config.afterTests()
   return v
 }
 
 const saveTest = async (testFile, config, test, expected, testConfig, saveDeveloper) => {
   config.rebuild()
   const objects = getObjects(config.config.objects)(config.uuid)
-  //config.resetMotivations()
-  config.beforeQuery({ query: test, isModule: false, objects })
   console.log(test)
   const result = await _process(config, test, { isTest: true })
   // const actualObjects = config.config.objects
@@ -850,7 +945,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) => {
@@ -1020,10 +1115,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) => {
@@ -1033,6 +1129,13 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
   }
   console.log("KM's loaded", config.configs.map((c) => c.name))
   console.log('This is the global objects from running semantics:\n', config.objects)
+  if (!_.isEmpty(responses.learned_contextual_priorities)) {
+    console.log('\nThe learned contextual priorties are :\n')
+    for (const lcp of responses.learned_contextual_priorities) {
+      console.log(`  ${JSON.stringify(lcp)},\n`)
+    }
+    console.log("\n")
+  }
   if (responses.logs) {
     console.log('Logs')
     responses.logs.forEach((log) => console.log(`    ${log}`))
@@ -1044,6 +1147,50 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
   } else {
     console.log('objects', runtime.util.inspect(config.get('objects'), { depth: Infinity, sorted: true }))
   }
+
+  const pickEm = () => {
+    const picked = {}
+    const namespaced = config.get('objects')['namespaced']
+    for (let prop of getConfig_getObjectCheck(config.testConfig)) {
+      if (prop.km) {
+        /*
+        const objects = namespaced[prop.km]]
+        picked[prop.km] = {}
+        for (let p of c.testConfig.check) {
+          if (p.km) {
+            continue
+          }
+          picked[p] = objects[p]
+        }
+        */
+        console.log('TODO implement this if needed')
+      } else {
+        const objects = namespaced[config.uuid]
+        picked[prop] = objects[prop]
+      }
+    }
+    return picked
+  }
+
+  if (responses.explain_priorities) {
+    console.log("Explain Priorities")
+    for ([inputss, outpus, reason] of responses.explain_priorities) {
+      console.log(`    ${JSON.stringify(inputss)} reason: ${reason}`)
+    }
+  }
+  const objects = config.get('objects').namespaced[config.uuid]
+  const picked = sortJson(pickObjects(config.testConfig, objects), { depth: 25 })
+  if (!_.isEmpty(picked)) {
+    console.log('--- Object showing only the checked values ---')
+    console.log(JSON.stringify(picked, null, 2))
+  }
+
+  const pickedResultContexts = responses.contexts.map(pickContext(config.testConfig))
+  if (pickedResultContexts.some( (context) => Object.keys(context).length > 0 )) {
+    console.log('--- Contexts showing only the checked values ---')
+    console.log(JSON.stringify(pickedResultContexts, null, 2))
+  }
+
   console.log('--- The contexts are ----------')
   console.log(JSON.stringify(sortJson(responses.contexts, { depth: 25 }), null, 2))
   console.log('')
@@ -1084,37 +1231,14 @@ const defaultProcess = ({ config, errorHandler }) => async (promise) => {
   }
 }
 
-/*
-const kmFileTemplate = (kmBaseName, kmName) =>
-`const entodicton = require('entodicton')
-const base = require('./${kmBaseName}').copy()
-const ${kmName}_tests = require('./${kmName}.test.json')
-const ${kmName}_instance = require('./${kmBaseName}.${kmName}.instance.json')
-
-const config = new entodicton.Config({ name: '${kmName}' })
-config.add(base)
-kirk_instance.base = '${kmBaseName}'
-config.load(${kmName}_instance)
-
-entodicton.knowledgeModule( {
-  module,
-  description: '${kmName} related concepts',
-  section,
-  config,
-  test: {
-          name: './${kmName}.test.json',
-          contents: ${kmName}_tests
-        },
-})
-`
-*/
-
-const build = async ({ config, target, template, errorHandler = defaultErrorHandler }) => {
+// builtTemplate saveInstance
+const rebuildTemplate = async ({ config, target, template, errorHandler = defaultErrorHandler }) => {
   const accumulators = {
     resultss: [],
     fragments: [],
     semantics: [],
     associations: [],
+    learned_contextual_priorities: [],
   }
   const looper = async (queries) => {
     if (queries.length === 0) {
@@ -1133,8 +1257,6 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
       if (property == 'fragments') {
         global.transitoryMode = true
       }
-      // greg32 
-      // config.addInternal( query )
       if (hierarchy) {
         for (let edge of hierarchy) {
           if (Array.isArray(edge)) {
@@ -1144,25 +1266,28 @@ 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}`)
         }
         global.transitoryMode = transitoryMode
         config.config.skipSemantics = null
         results.query = query.query
+        results.skipSemantics = skipSemantics
         results.development = query.development
         results.key = { query: query.query, hierarchy }
         accumulators[property].push(results)
         accumulators.associations = accumulators.associations.concat(results.associations)
+        accumulators.learned_contextual_priorities = accumulators.learned_contextual_priorities.concat(results.learned_contextual_priorities)
         await looper(queries)
       } catch(e) {
         const error = { errors: [e], query: query.query };
@@ -1174,6 +1299,12 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
       // it will just get added to the config
       const extraConfig = queryOrExtraConfig
       console.log('config', extraConfig)
+      try {
+        config.addInternal(_.cloneDeep(extraConfig), { handleCalculatedProps: true } )
+      } catch ( e ) {
+        const where = extraConfig.where ? ` ${extraConfig.where}` : ''
+        throw new Error(`Error processing extra config${where}: ${e.stack}}`)
+      }
       accumulators[property].push({ extraConfig: true, ...extraConfig })
       await looper(queries)
     }
@@ -1201,6 +1332,7 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
             delete result.version
             result.hierarchy.sort()
             stabilizeAssociations(result.associations)
+            result.learned_contextual_priorities = safeNoDups(result.learned_contextual_priorities)
           }
         }
       }
@@ -1221,14 +1353,14 @@ const build = async ({ config, target, template, errorHandler = defaultErrorHand
 
   const toProperties = (queryStringOrProperties) => {
     if (typeof queryStringOrProperties == 'string') {
-      return { query: queryStringOrProperties}
+      return { query: queryStringOrProperties }
     } else {
       return queryStringOrProperties
     }
   }
   let todo = []
-  todo = todo.concat((template.initializers || []).map((query) => { return { initializer: true, property: 'resultss', query, skipSemantics: false } }))
-  todo = todo.concat((template.queries || []).map((query) => { return { property: 'resultss', query, skipSemantics: false } }))
+  todo = todo.concat((template.initializers || []).map((query) => { return { initializer: true, property: 'resultss', query, skipSemantics: false || query.skipSemantics } }))
+  todo = todo.concat((template.queries || []).map((query) => { return { property: 'resultss', query, skipSemantics: false || query.skipSemantics} }))
   todo = todo.concat((template.fragments || []).map((query) => { return Object.assign({}, toProperties(query), { property: 'fragments', skipSemantics: false }) }))
   todo = todo.concat((template.semantics || []).map((definition) => { return { property: 'semantics', query: `${definition.from}\n${definition.to}`, skipSemantics: true } }))
   await looper(Object.assign([], todo))
@@ -1238,114 +1370,86 @@ const knowledgeModule = async ({
   module: moduleFromJSFile,
   description,
   section,
-  config,
+  // config, createConfig,
+  createConfig,
+  newWay,
   demo,
   test,
   template,
   errorHandler = defaultErrorHandler,
   process: processResults = defaultProcess,
   stopAtFirstFailure = true,
-  beforeQuery = () => {},
-  beforeTests = () => {},
-  afterTests = () => {},
-  beforeTest = () => {},
-  afterTest = () => {}
+  ...rest
 } = {}) => {
 
-  config.beforeQuery = beforeQuery 
-  config.beforeTests = beforeTests 
-  config.afterTests = afterTests 
-  config.beforeTest = beforeTest 
-  config.afterTest = afterTest 
+  const unknownArgs = Object.keys(rest)
+  if (unknownArgs.length > 0) {
+    throw new Error(`Unknown arguments to knowledgeModule: ${unknownArgs.join()}`)
+  }
 
   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."
-  }
-  if (!config) {
-    throw "'config' is a required parameter. The value should the config that defines the knowledge 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.name) {
-    throw "config must have 'name' set to the knowledge module name."
+  // if (!config && !createConfig) {
+  if (!createConfig) {
+    throw new Error("'config' or 'createConfig' is a required parameter. The value should the config that defines the knowledge module.")
   }
   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
-  let loadForTesting = false
-  if (global.theprogrammablemind) {
-    if (global.theprogrammablemind.loadForTesting[config.name]) {
-      loadForTesting = true
+
+  const setupConfig = (config) => {
+    if (!config.name) {
+      throw new Error("config must have 'name' set to the knowledge module name.")
     }
-  }
 
-  // remove test only stuff
-  if (!isProcess && !loadForTesting) {
-    config.config.operators = config.config.operators.filter( (operator) => {
-      if (operator.development) {
-        return false
-      } else {
-        return true
-      }
-    })
-    config.config.bridges = config.config.bridges.filter( (bridge) => {
-      if (bridge.development) {
-        return false
-      } else {
-        return true
+    config.description = description
+    if (typeof test === 'object') {
+      if (test.contents) {
+        config.tests = test.contents
+        test = test.name
       }
-    })
-  }
-
-  let module
-  if (_.isFunction(moduleFromJSFile)) {
-    module = moduleFromJSFile
-  } else {
-    module = () => {
-      config.rebuild({ isModule: true })
-      moduleFromJSFile.exports = config
-    }
-  }
-  processResults = processResults({ config, errorHandler })
-  config.description = description
-  config.demo = demo
-  if (typeof test === 'object') {
-    if (test.contents) {
-      config.tests = test.contents
-      test = test.name
-    }
-  } else {
-    if (runtime.fs && runtime.fs.existsSync(test)) {
-      config.tests = JSON.parse(runtime.fs.readFileSync(test))
     } else {
-      config.tests = {}
-    }
-  }
-  config.setTestConfig(testConfig)
- 
-  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.`
+      if (runtime.fs && runtime.fs.existsSync(test)) {
+        config.tests = JSON.parse(runtime.fs.readFileSync(test))
+      } else {
+        config.tests = []
       }
-      config.load(template.template, template.instance)
     }
+    config.setTestConfig(testConfig)
   }
+
+
   if (isProcess) {
+    const config = createConfig()
+    setupConfig(config)
+    processResults = processResults({ config, errorHandler })
     // setup();
     const parser = new runtime.ArgumentParser({
       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], ["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]))\''
+
+
     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' })
+    // parser.add_argument('-ttr', '--testToRun', { help: 'Only the specified test will be run' })
     parser.add_argument('-tva', '--testAllVerbose', { action: 'store_true', help: 'Run the tests in verbose mode. All the tests will be run instead of stopping at first failure. Create tests by running with the --query or --loop with the --save flag' })
+    parser.add_argument('-tnp', '--testNoParenthesized', { action: 'store_true', help: 'Don\' check parenthesized differences for the tests' })
     parser.add_argument('-n', '--count', { help: 'Number of times to run the tests. Default is one. Use this to check for flakey test. If possible the system will print out a message with the word "hint" suggesting how to fix the problem' })
     // parser.add_argument('-b', '--build', { help: 'Specify the template file name of the form <kmName>. There should be a file called <baseKmName>.<kmName>.template.json with the queries to run. For example { queries: [...] }. The template file will be run and generate an instantiation called <baseKmName>.<kmName>.instance.json and a file called <kmName>.js that will load the template file (this is file generated only if not already existing) and a test file called <KmName>.tests.json. This can then be loaded into an instance of the current knowledge module to setup initial conditions.' })
     parser.add_argument('-rt', '--rebuildTemplate', { action: 'store_true', help: 'Force a template rebuild' })
@@ -1353,45 +1457,84 @@ const knowledgeModule = async ({
     parser.add_argument('-i', '--info', { action: 'store_true', help: 'Print meta-data for the module' })
     parser.add_argument('-v', '--vimdiff', { action: 'store_true', help: 'For failures run vimdiff' })
     parser.add_argument('-g', '--greg', { action: 'store_true', help: 'Set the server to be localhost so I can debug stuff' })
-    parser.add_argument('-cl', '--checkForLoop', { action: 'store_true', help: 'Check for loops in the priorities' })
+    parser.add_argument('-cl', '--checkForLoop', { nargs: "?", help: 'Check for loops in the priorities, Optional argument is list of operator keys to consider. For example [["banana", 0], ["food", 1]]' })
     parser.add_argument('-r', '--retrain', { action: 'store_true', help: 'Get the server to retrain the neural nets' })
     parser.add_argument('-q', '--query', { help: 'Run the specified query' })
     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.' })
     parser.add_argument('-p', '--print', { help: 'Print the specified elements c === config, w === words, b === bridges, o === operators d === objects (d for data), h === hierarchy, g === generators, s === semantics, l === load t=tests ordering p === priorities a == associations j == JSON sent to server. for example --print wb' })
     parser.add_argument('-s', '--save', { action: 'store_true', help: 'When running with the --query flag this will save the current run to the test file. When running without the --query flag all tests will be run and resaved.' })
     parser.add_argument('-sd', '--saveDeveloper', { action: 'store_true', help: 'Same as -s but the query will not show up in the info command.' })
-    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', { action: 'store_true', help: helpDebugAssociation })
+    parser.add_argument('-dh', '--debugHierarchy', { action: 'store_true', help: helpDebugHierarchy })
+    parser.add_argument('-dp', '--debugPriority', { action: 'store_true', help: helpDebugPriority })
+    parser.add_argument('-dcp', '--debugContextualPriority', { action: 'store_true', help: helpDebugContextualPriority })
+    parser.add_argument('-db', '--debugBridge', { action: 'store_true', help: helpDebugBridge })
+    parser.add_argument('-do', '--debugOperator', { action: 'store_true', help: helpDebugOperator })
+    parser.add_argument('-ep', '--explainPriorities', { action: 'store_true', help: "The server will return all priorities including the generated one along with an explanation of there they came from"})
+    parser.add_argument('-dic', '--debugIncludeConvolutions', { nargs: "?", help: 'When running with the --debugIncludeConvolutions flag the logs will include convolutions which are somewhat annoyingly verbose. Default is false' })
 
     const args = parser.parse_args()
     args.count = args.count || 1
 
+    if (args.parenthesized) {
+      config.parenthesized = true
+    }
+    if (args.checkForLoop) {
+      try {
+        args.checkForLoop = JSON.parse(args.checkForLoop)
+        const isKey = (what) => {
+          if (!Array.isArray(what)) {
+            return false
+          }
+          if (what.length !== 2) {
+            return false
+          }
+          if (!typeof what[0] == 'string') {
+            return false
+          }
+          if (!typeof what[1] == 'number') {
+            return false
+          }
+          return true
+        }
+        if (!Array.isArray(args.checkForLoop) || args.checkForLoop.some((value) => !isKey(value))) {
+          throw new Error(`Error for the checkForLoop argument. Expected a JSON array of operator keys of the form "[<id>, <level>]"`)
+        }
+      } catch( e ) {
+        throw new Error(`Error parsing JSON of the checkForLoop argument. ${e}`)
+      }
+    } else {
+      if (process.argv.includes('--checkForLoop') || process.argv.includes('-cl')) {
+        args.checkForLoop = 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) {
@@ -1430,120 +1573,122 @@ const knowledgeModule = async ({
     if (args.debug) {
       config.config.debug = true
     }
-    config.config.debugIncludeConvolutions = args.debugIncludeConvolutions
 
-    if (template) {
-      const needsRebuild = config.needsRebuild(template.template, template.instance, options)
-      if (needsRebuild) {
-        console.log(`This module "${config.name}" needs rebuilding all other arguments will be ignored. Try again after the template is rebuilt.`)
-
-      }
-      config.load(template.template, template.instance, { rebuild: needsRebuild })
-      if (needsRebuild) {
-        return
-      }
+    if (args.explainPriorities) {
+      config.config.explain_priorities = true
     }
 
-    if (!args.save && !args.rebuildTemplate && !args.dontAddAssociations) {
-      config.addAssociationsFromTests(config.tests);
-      //for (let query in config.tests) {
-      //  config.addAssociations(config.tests[query].associations || []);
-      //}
-    }
+    config.config.debugIncludeConvolutions = args.debugIncludeConvolutions || process.argv.includes('--debugIncludeConvolutions') || process.argv.includes('-dic') 
 
-    /*
-    if (args.buildTemplate) {
-      if (template) {
-        config.rebuild()
-        config.load(template.template, template.instance, { rebuild: true })
+    let configPrinted = false
+    const printConfig = () => {
+      if (configPrinted) {
+        return
       }
-    }
-    */
-
-    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
+      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('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)
         }
-        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)
+        }
+      }
+    }
+
+    if (template) {
+      const needsRebuild = config.needsRebuild(template.template, template.instance, options)
+      if (needsRebuild) {
+        console.log(`This module "${config.name}" needs rebuilding all other arguments will be ignored. Try again after the template is rebuilt.`)
+        options.rebuild = true
+        config.config.rebuild = true
+      }
+      config.load(template.template, template.instance, { rebuild: needsRebuild })
+      printConfig()
+      if (needsRebuild) {
+        return
       }
     }
 
+    if (!args.save && !args.rebuildTemplate && !args.dontAddAssociations) {
+      config.addAssociationsFromTests(config.tests);
+    }
+
     if (args.retrain) {
       config.config.retrain = true
     }
@@ -1575,12 +1720,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) => {
-            if (results.length > 0 && args.vimdiff) {
-              for (const result of results) {
-                vimdiff(result.expected, result.actual)
-              }
-            }
+          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
@@ -1590,18 +1730,49 @@ const knowledgeModule = async ({
                 if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
                   hasError = true
                 }
+                if (!args.testNoParenthesized) {
+                    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
                 }
                 if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
                   hasError = true
                 }
+                if (!sameJSON(result.expected.checkedContexts, result.actual.checkedContexts)) {
+                  hasError = true
+                }
               }
 
               if (hasError) {
                 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)
+                  if (!args.testNoParenthesized) {
+                    show('paraphrases parenthesized', result.expected.paraphrasesParenthesized, result.actual.paraphrasesParenthesized)
+                  }
+                  show('responses', result.expected.responses, result.actual.responses)
+                  if (!args.testNoParenthesized) {
+                    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')
@@ -1620,6 +1791,7 @@ const knowledgeModule = async ({
                     newError = true
                     headerShown = true
                   }
+                  */
                   if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
                     if (!headerShown) {
                       console.log('  Failure')
@@ -1632,10 +1804,37 @@ const knowledgeModule = async ({
                     lines.setElement(1, 1, 'actual checked')
                     lines.setElement(2, 2, JSON.stringify(result.actual.checked, null, 2))
                     lines.log()
+                    if (args.vimdiff) {
+                      vimdiff(result.actual.checked, result.expected.checked)
+                    }
+                    newError = true
+                    headerShown = true
+                  }
+                  if (!sameJSON(result.expected.checkedContexts, result.actual.checkedContexts)) {
+                    if (!headerShown) {
+                      console.log('  Failure')
+                    }
+                    const widths = [4, 18, 72]
+                    const lines = new Lines(widths)
+                    lines.setElement(1, 1, 'expected checkedContexts', true)
+                    lines.setElement(2, 2, JSON.stringify(result.expected.checkedContexts, null, 2))
+                    lines.log()
+                    lines.setElement(1, 1, 'actual checkedContexts', true)
+                    lines.setElement(2, 2, JSON.stringify(result.actual.checkedContexts, null, 2))
+                    lines.log()
+                    if (args.vimdiff) {
+                      vimdiff(result.actual.checkedContexts, result.expected.checkedContexts)
+                    }
                     newError = true
                     headerShown = true
                   }
                 }
+              } else {
+                if (results.length > 0 && args.vimdiff) {
+                  for (const result of results) {
+                    vimdiff(result.actual, result.expected)
+                  }
+                }
               }
               if (!headerShown) {
                 if (!(useTestConfig.check && useTestConfig.check.length > 0)) {
@@ -1667,12 +1866,11 @@ const knowledgeModule = async ({
         if (query.length === 0) {
           return readline.close()
         }
-        // const promise = processResults(_process(config, query, { testsFN: test }))
         const promise = _process(config, query, { testsFN: test }).then((results) => {
           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(() => {
@@ -1695,20 +1893,65 @@ const knowledgeModule = async ({
       if (args.objectDiff) {
         global.beforeObjects = _.cloneDeep(objects)
       }
-      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) {
-    //  config.addAssociations(config.tests[query].associations || []);
-    //}
-    module()
+    const initConfig = (config) => {
+      setupConfig(config)
+
+      let loadForTesting = false
+      if (global.theprogrammablemind) {
+        if (global.theprogrammablemind.loadForTesting[config.name]) {
+          loadForTesting = true
+        }
+      }
+      // remove test only stuff
+      if (!isProcess && !loadForTesting) {
+        config.config.operators = config.config.operators.filter( (operator) => {
+          if (operator.development) {
+            return false
+          } else {
+            return true
+          }
+        })
+        config.config.bridges = config.config.bridges.filter( (bridge) => {
+          if (bridge.development) {
+            return false
+          } else {
+            return true
+          }
+        })
+      }
+
+      if (template) {
+        if (config.needsRebuild(template.template, template.instance, { isModule: !isProcess })) {
+          const error = `This module "${config.name}" cannot be used because the instance file needs rebuilding. Run on the command line with no arguments or the -rt argument to rebuild.`
+          throw new Error(error)
+        }
+        try {
+          config.load(template.template, template.instance)
+        } catch( e ) {
+          errorHandler(e)
+        }
+      }
+
+      config.addAssociationsFromTests(config.tests);
+    }
+
+    createConfigExport = () => {
+      const config = createConfig()
+      initConfig(config)
+      config.rebuild({ isModule: true })
+      return config
+    }
+    moduleFromJSFile.exports = createConfigExport
   }
+
 }
 
 /*
@@ -1762,7 +2005,7 @@ module.exports = {
   w,
   // submitBug,
   ensureTestFile,
-  build,
+  rebuildTemplate,
   processContext,
   processContexts,
   runTests,
@@ -1774,8 +2017,9 @@ module.exports = {
   Digraph,
   analyzeMetaData,
   processContextsB,
-  processInstance,
+  loadInstance,
   gs,
   flattens,
   writeTest
 }
+