theprogrammablemind 7.5.8-beta.7 → 7.5.8-beta.70

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')
@@ -13,16 +14,30 @@ const { appendNoDups, InitCalls, updateQueries } = require('./src/helpers')
 const runtime = require('./runtime')
 const sortJson = runtime.sortJson
 
+const getConfig_getObjectCheck = (testConfig) => {
+  return (testConfig.checks && testConfig.checks.objects) || testConfig.check || []
+}
+
+const getConfig_getContextCheck = (testConfig) => {
+  return (testConfig.checks && testConfig.checks.context) || []
+}
+
+const pickContext = (testConfig) => (context) => {
+  return project(context, getConfig_getContextCheck(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 +52,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;
@@ -58,7 +73,6 @@ const vimdiff = (actualJSON, expectedJSON) => {
   // console.log(`vimdiff ${path}/actual.json ${path}/expected.json`)
   {
     const editor = runtime.process.env.EDITOR || 'vimdiff'
-    debugger
     // 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'})
@@ -109,11 +123,12 @@ 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])
   }
   args.km = (name) => config.getConfig(name)
+  args.api = (name) => config.getConfig(name).api
   args.error = (context) => {
     throw new ErrorReason(context)
   }
@@ -124,6 +139,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) => {
@@ -143,7 +159,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
@@ -157,10 +172,10 @@ const setupArgs = (args, config, logs, hierarchy) => {
   }
   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) => {
@@ -298,7 +313,6 @@ 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 })
-  debugger
   results = sortJson({ 
     query, 
     paraphrases, 
@@ -367,7 +381,7 @@ 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 = []
@@ -378,7 +392,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
   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 = []
   }
@@ -389,28 +403,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
@@ -418,19 +410,21 @@ 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`
-            }
-            // contextPrime = semantics.apply(args, { marker: 'error', context, error: e })
-            contextPrime = semantics.apply(args, { marker: 'error', context, reason: e.reason })
+        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, reason: e.reason })
         }
       }
       if (contextPrime.controlRemove) {
@@ -439,7 +433,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
       let assumed = { isResponse: true };
       const generated = contextPrime.isResponse ? config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0] : ''
       let generatedParenthesized = []
-      if (isTest) {
+      if (generateParenthesized) {
         config.parenthesized = true
         generatedParenthesized = contextPrime.isResponse ? config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0] : ''
         config.parenthesized = false
@@ -452,12 +446,12 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
       args.gs = gs(args.g)
       args.gsp = gs(args.gsp)
       args.gsr = gs(args.gr)
-      if (isTest) {
+      if (generateParenthesized) {
         config.parenthesized = false
       }
       const paraphrases = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
       let paraphrasesParenthesized = []
-      if (isTest) {
+      if (generateParenthesized) {
         config.parenthesized = true
         paraphrasesParenthesized = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
         config.parenthesized = false
@@ -471,7 +465,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
       contextsPrime.push(contextPrime)
       generatedPrime.push(generated)
       paraphrasesPrime.push(paraphrases)
-      if (isTest) {
+      if (generateParenthesized) {
         paraphrasesParenthesizedPrime.push(paraphrasesParenthesized)
         generatedParenthesizedPrime.push(generatedParenthesized)
       }
@@ -549,8 +543,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)) {
@@ -574,7 +571,7 @@ const setupProcessB = ({ config, initializer, allowDelta=false } = {}) => {
 }
 
 // instance template
-const processInstance = (config, instance) => {
+const loadInstance = (config, instance) => {
   const transitoryMode = global.transitoryMode
   global.transitoryMode = false
   const { /* data, generators, semantics, */ hierarchy } = setupProcessB({ config })
@@ -584,15 +581,15 @@ 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: {} })
+      processContextsB({ config, hierarchy, json: results/*, generators, semantics */, commandLineArgs: {}, isInstance: `instance${i}`, instance: instance.queries[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)
   }
@@ -606,7 +603,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
@@ -614,7 +610,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')
 
@@ -681,6 +680,7 @@ 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)
@@ -694,7 +694,12 @@ 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, response.paraphrasesParenthesized, response.generatedParenthesized)
+      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
@@ -734,7 +739,7 @@ const getConfigForTest = (config, testConfig) => {
   return configForTest
 }
 
-const runTest = async (config, expected, { args, 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()
@@ -759,8 +764,6 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
     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
@@ -778,20 +781,30 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
       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)
+      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)
 
+      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 pickEm = (getObjects) => {
         const picked = {}
-        for (let prop of (testConfig.check || [])) {
+        for (let prop of getConfig_getObjectCheck(testConfig)) {
           if (prop.km) {
             c = config.getConfig(prop.km)
             o = getObjects(prop.km)
             picked[prop.km] = {}
-            for (let p of c.testConfig.check) {
+            for (let p of getConfig_getObjectCheck(c.testConfig)) {
               if (p.km) {
                 continue
               }
@@ -809,6 +822,7 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
         }
         return expected.objects.namespaced[expected.objects.nameToUUID[name]]
       }
+      sortJson(pickEm(expectedGetObjects), { depth: 25 })
       const expected_checked = sortJson(pickEm(expectedGetObjects), { depth: 25 })
       const actualGetObjects = (name) => {
         if (!name) {
@@ -824,38 +838,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_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 })
-          if (failed) {
-            return {
-              utterance: test,
-              errorFromAfterTest: failed,
-              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 
-              }
-            }
-          }
-        }
-      }
+      let failed = 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)
@@ -874,6 +857,7 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
             generatedParenthesized: expected.generatedParenthesized, 
             results: expected.contexts, 
             checked: expected_checked, 
+            checkedContexts: pickedExpectedContexts,
             objects: expected_objects, 
             config: expected.config 
           },
@@ -884,6 +868,7 @@ const runTest = async (config, expected, { args, verbose, afterTest, testConfig,
             generatedParenthesized: result.generatedParenthesized, 
             results: result.contexts, 
             checked: actual_checked, 
+            checkedContexts: pickedResultContexts,
             objects: actual_objects, 
             config: actual_config 
           }
@@ -923,20 +908,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
@@ -1118,10 +1099,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) => {
@@ -1142,6 +1124,43 @@ 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 picked = pickEm()
+  if (!_.isEmpty(picked)) {
+    console.log('--- checked object properties ---')
+    console.log(JSON.stringify(picked, null, 2))
+  }
+
   console.log('--- The contexts are ----------')
   console.log(JSON.stringify(sortJson(responses.contexts, { depth: 25 }), null, 2))
   console.log('')
@@ -1182,32 +1201,8 @@ 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 }) => {
+// loadTemplate BuiltTemplate
+const rebuildTemplate = async ({ config, target, template, errorHandler = defaultErrorHandler }) => {
   const accumulators = {
     resultss: [],
     fragments: [],
@@ -1231,8 +1226,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)) {
@@ -1244,7 +1237,7 @@ 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)
@@ -1274,6 +1267,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)
     }
@@ -1338,36 +1337,31 @@ 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 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 new Error("'config' is a required parameter. The value should the config that defines the knowledge module.")
-  }
-  if (!config.name) {
-    throw new Error("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 new Error("'description' is a required parameter. The value should the description of the knowledge module.")
@@ -1377,86 +1371,51 @@ const knowledgeModule = async ({
   }
 
   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 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)
-      } catch( e ) {
-        errorHandler(e)
+      if (runtime.fs && runtime.fs.existsSync(test)) {
+        config.tests = JSON.parse(runtime.fs.readFileSync(test))
+      } else {
+        config.tests = []
       }
     }
+    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", "mammel#0"]\' })'
-    const helpDebugHierarchy = 'In order to get a debug break when a specific hierarchy is created set the DEBUG_HIERARCHY environment variable to the JSON of the child-parent pair to break on. For example DEBUG_HIERARCHY=\'["cat#1", "mammel#1"]\' })'
-    const helpDebugPriority = 'In order to get a debug break when a specific set of priorities is created set set DEBUG_PRIORITY environment variable to the JSON of the priorities that you want to break on. For example DEBUG_PRIORITY=\'["verb#0", "article#0"]\' })'
-    const helpDebugBridge = 'In order to get a debug break when a specific bridge is created set the DEBUG_BRIDGE environment variable to id/level to break on. For example DEBUG_BRIDGE=\'id#level\' })'
-    const helpDebugOperator = 'In order to get a debug break when a specific hierarcy is created set the DEBUG_OPERATOR environment variable to debug any config loaded. For example DEBUG_OPERATOR=\'([operator] ([arg]))\' })'
+    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('-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' })
@@ -1464,7 +1423,7 @@ 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' })
@@ -1477,14 +1436,16 @@ const knowledgeModule = async ({
     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: helpDebugAssociation })
-    parser.add_argument('-dh', '--debugHierarchy', { help: helpDebugHierarchy })
-    parser.add_argument('-dp', '--debugPriority', { help: helpDebugPriority })
-    parser.add_argument('-db', '--debugBridge', { help: helpDebugBridge })
-    parser.add_argument('-do', '--debugOperator', { help: helpDebugOperator })
+    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
@@ -1492,7 +1453,35 @@ const knowledgeModule = async ({
     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) {
       console.log(helpDebugAssociation)
       runtime.process.exit(-1)
@@ -1550,7 +1539,12 @@ const knowledgeModule = async ({
     if (args.debug) {
       config.config.debug = true
     }
-    config.config.debugIncludeConvolutions = args.debugIncludeConvolutions
+
+    if (args.explainPriorities) {
+      config.config.explain_priorities = true
+    }
+
+    config.config.debugIncludeConvolutions = args.debugIncludeConvolutions || process.argv.includes('--debugIncludeConvolutions') || process.argv.includes('-dic') 
 
     if (template) {
       const needsRebuild = config.needsRebuild(template.template, template.instance, options)
@@ -1559,6 +1553,10 @@ const knowledgeModule = async ({
 
       }
       config.load(template.template, template.instance, { rebuild: needsRebuild })
+      if (config.name == 'ui') {
+        console.log('config.COUNTER', config.COUNTER)
+        debugger
+      }
       if (needsRebuild) {
         return
       }
@@ -1566,20 +1564,8 @@ const knowledgeModule = async ({
 
     if (!args.save && !args.rebuildTemplate && !args.dontAddAssociations) {
       config.addAssociationsFromTests(config.tests);
-      //for (let query in config.tests) {
-      //  config.addAssociations(config.tests[query].associations || []);
-      //}
     }
 
-    /*
-    if (args.buildTemplate) {
-      if (template) {
-        config.rebuild()
-        config.load(template.template, template.instance, { rebuild: true })
-      }
-    }
-    */
-
     let configPrinted = false
     const printConfig = () => {
       if (configPrinted) {
@@ -1712,11 +1698,13 @@ 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 (!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
@@ -1724,6 +1712,9 @@ const knowledgeModule = async ({
                 if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
                   hasError = true
                 }
+                if (JSON.stringify(result.expected.checkedContexts) !== JSON.stringify(result.actual.checkedContexts)) {
+                  hasError = true
+                }
               }
 
               if (hasError) {
@@ -1742,9 +1733,13 @@ const knowledgeModule = async ({
                     }
                   }
                   show('paraphrases', result.expected.paraphrases, result.actual.paraphrases)
-                  show('paraphrases parenthesized', result.expected.paraphrasesParenthesized, result.actual.paraphrasesParenthesized)
+                  if (!args.testNoParenthesized) {
+                    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 (!args.testNoParenthesized) {
+                    show('responses parenthesized', result.expected.generatedParenthesized, result.actual.generatedParenthesized)
+                  }
                   /*
                   if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
                     if (!headerShown) {
@@ -1783,6 +1778,24 @@ const knowledgeModule = async ({
                     newError = true
                     headerShown = true
                   }
+                  if (JSON.stringify(result.expected.checkedContexts) !== JSON.stringify(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) {
@@ -1821,7 +1834,6 @@ 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(' '))
         })
@@ -1849,7 +1861,6 @@ const knowledgeModule = async ({
       if (args.objectDiff) {
         global.beforeObjects = _.cloneDeep(objects)
       }
-      config.beforeQuery({ query: args.query, isModule: false, objects })
       try {
         await processResults(_process(config, args.query, { commandLineArgs: args, dontAddAssociations: args.dontAddAssociations, writeTests: args.save || args.saveDeveloper, saveDeveloper: args.saveDeveloper, testConfig, testsFN: test }))
       } catch( error ) {
@@ -1858,11 +1869,55 @@ const knowledgeModule = async ({
     }
     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
   }
 
 }
@@ -1918,7 +1973,7 @@ module.exports = {
   w,
   // submitBug,
   ensureTestFile,
-  build,
+  rebuildTemplate,
   processContext,
   processContexts,
   runTests,
@@ -1930,8 +1985,9 @@ module.exports = {
   Digraph,
   analyzeMetaData,
   processContextsB,
-  processInstance,
+  loadInstance,
   gs,
   flattens,
   writeTest
 }
+