theprogrammablemind 8.0.0-beta.9 → 8.0.0-beta.91

package/client.js

@@ -1,5 +1,7 @@
 const { Semantics, Semantic } = require('./src/semantics')
 const { Generators, Generator } = require('./src/generators')
+const { Config } = require('./src/config')
+const { loadInstance, ErrorReason, listable, setupArgs, gs, processContext, getObjects, setupProcessB, processContextsB  } = require('./src/configHelpers')
 const DigraphInternal = require('./src/digraph_internal')
 const Digraph = require('./src/digraph')
 const { project } = require('./src/project')
@@ -10,36 +12,10 @@ const _ = require('lodash')
 const stringify = require('json-stable-stringify')
 const Lines = require('./lines')
 const flattens = require('./src/flatten')
-const { appendNoDups, InitCalls, updateQueries, safeNoDups, stableId } = require('./src/helpers')
+const { appendNoDups, InitCalls, updateQueries, safeNoDups, stableId, where } = require('./src/helpers')
 const runtime = require('./runtime')
 const sortJson = runtime.sortJson
 
-function where (goUp = 2) {
-  const e = new Error()
-  const regexForm1 = /\((.*):(\d+):(\d+)\)$/
-  const regexForm2 = /at (.*):(\d+):(\d+)$/
-  const lines = e.stack.split('\n')
-  let line
-  let match
-  for (line of lines.slice(1)) {
-    // if (!(line.includes('config.js:') || line.includes('client.js:') || line.includes('<anonymous>'))) {
-    if (!(line.includes('config.js:') || line.includes('client.js:'))) {
-      match = regexForm1.exec(line) || regexForm2.exec(line)
-      if (!match) {
-        continue
-      }
-      break
-    }
-  }
-  // const line = e.stack.split("\n")[goUp];
-  // const match = regexForm1.exec(line) || regexForm2.exec(line)
-  if (match) {
-    return `${match[1]}:${match[2]}`
-  } else {
-    return 'running in browser'
-  }
-}
-
 const getConfig_getObjectsCheck = (config, testConfig) => {
   let testConfigName = config.name
   if (testConfig.testModuleName) {
@@ -108,164 +84,6 @@ const vimdiff = (actualJSON, expectedJSON, title) => {
   }
 }
 
-const listable = (hierarchy) => (c, type) => {
-  if (!c) {
-    return false
-  }
-  if (hierarchy.isA(c.marker, type)) {
-    return true
-  }
-  if (c.marker === 'list') {
-    for (const t of c.types) {
-      if (hierarchy.isA(t, type)) {
-        return true
-      }
-    }
-  }
-  return false
-}
-
-const isA = (hierarchy) => (child, parent) => {
-  if (!child || !parent) {
-    return false
-  }
-  if (child.marker) {
-    child = child.marker
-  }
-  if (parent.marker) {
-    parent = parent.marker
-  }
-  return hierarchy.isA(child, parent)
-}
-
-const asList = (context) => {
-  if (context.marker === 'list') {
-    return context
-  }
-  return {
-    marker: 'list',
-    types: [context.marker],
-    value: [context]
-  }
-}
-
-class ErrorReason extends Error {
-  constructor (context) {
-    super(JSON.stringify(context))
-    this.reason = context
-  }
-}
-
-const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
-
-  // callId
-  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
-  args.isA = isA(hierarchy)
-  args.listable = listable(hierarchy)
-  args.asList = asList
-  args.retry = () => { throw new RetryError() }
-  args.fragments = (query) => config.fragment(query)
-  args.breakOnSemantics = false
-  args.theDebugger = {
-    breakOnSemantics: (value) => args.breakOnSemantics = value
-  }
-  if (!logs) {
-  }
-  args.log = (message) => logs.push(message)
-
-  args.addAssumedScoped = (args, assumed) => {
-    const addAssumed = (args, ...moreAssumed) => {
-      return { ...args, assumed: Object.assign({}, assumed, (args.assumed || {}), ...moreAssumed) }
-    }
-
-    args.s = (c) => config.getSemantics(logs).apply(args, c)
-    args.g = (c, a = {}) => {
-      return config.getGenerators(logs).apply(addAssumed(args, a), c, a)
-    }
-    args.gp = (c, a = {}) => {
-      return config.getGenerators(logs).apply(addAssumed(args, a, { paraphrase: true, isResponse: false, response: false }), c, { paraphrase: true, isResponse: false, response: false })
-    }
-    args.gr = (c, a = {}) => {
-      return config.getGenerators(logs).apply(addAssumed(args, a, { paraphrase: false, isResponse: true }), { ...c, paraphrase: false, isResponse: true })
-    }
-    args.e = (c) => {
-      return config.getEvaluator(args.s, args.calls, logs, c)
-    }
-    args.gs = gs(args.g)
-    args.gsp = gs(args.gp)
-    args.gsr = gs(args.gr)
-  }
-  // for semantics
-  args.addAssumedScoped(args, {})
-
-  const getAPI = (uuid) => {
-    if (config && config.getAPI) {
-      return config.getAPI(uuid)
-    }
-  }
-  const getAPIs = (uuid) => {
-    if (config && config.getAPIs) {
-      return config.getAPIs(uuid)
-    }
-  }
-  args.getUUIDScoped = (uuid) => {
-    return {
-      api: getAPI(uuid),
-      apis: getAPIs(uuid)
-    }
-  }
-  config.getAddedArgs(args)
-
-  Object.assign(args, args.getUUIDScoped(uuidForScoping || config.uuid))
-  /*
-  if (uuidForScoping) {
-    Object.assign(args, args.getUUIDScoped(uuidForScoping))
-  }
-  */
-  // sets args for all the API. that make a copy so the args must be fully setup by here except for scoped
-  config.setArgs(args)
-}
-
-const gs = (g) => (contexts, separator, lastSeparator) => {
-  if (!Array.isArray(contexts)) {
-    debugger
-    throw new Error('Expected a list')
-  }
-
-  let s = ''
-  if (!separator) {
-    separator = ' '
-  }
-  if (!lastSeparator) {
-    lastSeparator = separator
-  }
-  let nextSeparator = ''
-  for (let i = 0; i < contexts.length; ++i) {
-    const context = contexts[i]
-    const value = g(context)
-    if (i > 0) {
-      if (i === contexts.length - 1) {
-        nextSeparator = lastSeparator
-      } else {
-        nextSeparator = separator
-      }
-    }
-    s += nextSeparator + value
-  }
-  return s
-}
-
 const matching = (actual, expected) => {
   if (!deepEqual(stringify(sortJson(actual, { depth: 25 })), stringify(sortJson(expected, { depth: 25 })))) {
     return false
@@ -290,56 +108,18 @@ const analyzeMetaData = (right, wrong) => {
   return []
 }
 
-const processContexts = (contexts, params) => {
+const processContexts = async (contexts, params) => {
   const contextsPrime = []
   const generated = []
   const logs = []
   for (const context of contexts) {
-    const result = processContext(context, Object.assign({}, params, { logs }))
+    const result = await processContext(context, Object.assign({}, params, { logs }))
     contextsPrime.push(result.context)
     generated.push(result.generated)
   }
   return { contexts: contextsPrime, generated, logs }
 }
 
-const getObjects = (objects) => {
-  return (uuid) => {
-    if (objects && objects.namespaced) {
-      return objects.namespaced[uuid]
-    }
-    return objects
-  }
-}
-
-const processContext = (context, { objects = {}, config, logs = [] }) => {
-  const generators = config.getGenerators(logs)
-  const semantics = config.getSemantics(logs)
-
-  // map to hash
-  config = config || {}
-  if (config.config) {
-    config = config
-  }
-
-  const response = {} // NA but passed in
-  // generators = new Generators(generators.map((g) => new Generator(normalizeGenerator(g))))
-  // semantics = new Semantics(semantics.map((g) => new Semantic(normalizeSemantic(g))))
-  const hierarchy = new DigraphInternal((config.config || {}).hierarchy || [])
-
-  const args = { objects, response, getObjects: getObjects(objects) }
-  setupArgs(args, config, logs, hierarchy)
-
-  context = semantics.apply(args, context)
-  const generated = generators.apply(args, context)
-  const assumed = { paraphrase: true, response: false, isResponse: false }
-  const paraphrases = generators.apply({ ...args, assumed }, context, { paraphrase: true, response: false, isResponse: false })
-  let responses = []
-  if (context.isResponse) {
-    responses = generated
-  }
-  return { context, generated, paraphrases, responses }
-}
-
 const convertToStable = (objects) => {
   if (true) {
     return objects
@@ -431,139 +211,6 @@ const overlaps = (r1, context) => {
   return false
 }
 
-const setupContexts = (rawContexts) => {
-  let first = true
-  const contexts = []
-  contexts.push({ marker: 'controlStart', controlRemove: true })
-  for (const context of rawContexts) {
-    if (first) {
-      first = false
-    } else {
-      contexts.push({ marker: 'controlBetween', controlRemove: true })
-    }
-    contexts.push(context)
-  }
-  contexts.push({ marker: 'controlEnd', controlRemove: true })
-  return contexts
-}
-
-const processContextsB = ({ config, hierarchy, semantics, generators, json, isTest, rebuildingTemplate, 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, 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)
-  let overlap, lastRange
-  config.debugLoops = commandLineArgs && commandLineArgs.debugLoops
-  while (toDo.length > 0) {
-    const context = toDo.shift()
-    args.calls.next()
-    let contextPrime = context
-    context.topLevel = true
-    try {
-      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')) {
-        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 (rebuildingTemplate) {
-            throw e
-          }
-        }
-      }
-      if (contextPrime.controlRemove) {
-        continue
-      }
-      let assumed = { isResponse: true }
-      const generated = contextPrime.isResponse ? config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
-      let generatedParenthesized = []
-      if (generateParenthesized) {
-        config.parenthesized = true
-        generatedParenthesized = contextPrime.isResponse ? config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
-        config.parenthesized = false
-      }
-      // assumed = { paraphrase: true, response: false };
-      assumed = { paraphrase: true, isResponse: false, response: false }
-      if (generateParenthesized) {
-        config.parenthesized = false
-      }
-      const paraphrases = config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
-      let paraphrasesParenthesized = []
-      if (generateParenthesized) {
-        config.parenthesized = true
-        paraphrasesParenthesized = config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
-        config.parenthesized = false
-      }
-      contextsPrime.push(contextPrime)
-      generatedPrime.push(generated)
-      paraphrasesPrime.push(paraphrases)
-      if (generateParenthesized) {
-        paraphrasesParenthesizedPrime.push(paraphrasesParenthesized)
-        generatedParenthesizedPrime.push(generatedParenthesized)
-      }
-      if (contextPrime.isResponse) {
-        responsesPrime.push(generated)
-      } else {
-        responsesPrime.push('')
-      }
-
-      // 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, paraphrasesParenthesized, generatedParenthesized, responses: responsesPrime })
-    } catch (e) {
-      if (Array.isArray(e)) {
-        e = {
-          errors: e
-        }
-      }
-      e.context = contextPrime
-      if (e.logs) {
-        e.logs = e.logs.concat(json.logs)
-      } else {
-        e.logs = json.logs
-      }
-      e.metadata = json.metadata
-      if (json.trace) {
-        e.trace = json.trace
-      }
-      throw e
-    }
-  }
-  return { contextsPrime, generatedPrime, paraphrasesPrime, paraphrasesParenthesizedPrime, generatedParenthesizedPrime, responsesPrime }
-}
-
 const doWithRetries = async (n, url, queryParams, data) => {
   if (!queryParams) {
     queryParams = ''
@@ -598,93 +245,6 @@ const doWithRetries = async (n, url, queryParams, data) => {
   }
 }
 
-const setupProcessB = ({ config, initializer, allowDelta = false } = {}) => {
-  const key = config._key
-
-  const data = Object.assign({ key, version: '3' }, { uuid: config._uuid })
-  if (allowDelta && config.allowDelta && config.hasDelta()) {
-    // console.log('config', config)
-    data.delta = config.delta()
-  } else {
-    config.toData(data)
-    // Object.assign(data, config.config)
-  }
-
-  // config.toServer(data)
-
-  if (data.namespaces) {
-    for (const uuid of Object.keys(data.namespaces)) {
-      const km = config.configs.find((km) => km.uuid === uuid)
-      data.namespaces[uuid].name = km.name
-    }
-  }
-
-  // const generators = new Generators((data.generators || []).map((g) => new Generator(normalizeGenerator(g))))
-  delete data.generators
-  // const semantics = new Semantics((data.semantics || []).map((g) => new Semantic(normalizeSemantic(g))))
-  delete data.semantics
-  const hierarchy = new DigraphInternal((config.config || {}).hierarchy || [])
-
-  return {
-    data,
-    // generators,
-    // semantics,
-    hierarchy
-  }
-}
-
-// 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 || [])) {
-    const results = instance.resultss[i]
-    if (results.extraConfig) {
-      // config.addInternal(results, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false)
-      const uuid = config.nameToUUID(instance.name)
-      // used to do a CLONE
-      config.addInternal(instance.template.configs[i], { uuid, addFirst: true, handleCalculatedProps: true })
-    } else if (results.apply) {
-      const objects = config.get('objects')
-      const args = { objects, getObjects: getObjects(objects) }
-      if (instance.configs) {
-        args.isInstance = `instance${i}`
-        args.instance = instance.configs[i]
-      }
-
-      const uuid = config.nameToUUID(instance.name)
-      setupArgs(args, config, config.logs, hierarchy, uuid)
-      results.apply(args)
-    } else {
-      if (results.skipSemantics) {
-        config.config.skipSemantics = results.skipSemantics
-      }
-      const args = { config, hierarchy, json: results, commandLineArgs: {} }
-      args.isInstance = `instance${i}`
-      args.instance = ''
-      processContextsB(args)
-      if (results.skipSemantics) {
-        config.config.skipSemantics = null
-      }
-    }
-  }
-  global.transitoryMode = transitoryMode
-}
-
 const throwErrorHandler = (error) => {
   throw error
 }
@@ -701,7 +261,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
   // ensure same start state
   try {
     if (writeTests) {
-      config.rebuild()
+      await config.rebuild()
       const objects = getObjects(config.config.objects)(config.uuid)
     }
   } catch (error) {
@@ -737,12 +297,14 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
       associations: []
     }
 
+    let startCounter = 0
     while (true) {
       if (queries.length === 0) {
         break
       }
 
       data.utterance = queries[0]
+      data.start_counter = startCounter
       let json = await doWithRetries(retries, url, queryParams, data)
       let resetData = false
       if (json.code == 'NOT_IN_CACHE') {
@@ -764,6 +326,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         }
       }
       json.contexts = json.results
+      startCounter= json.end_counter + 1
       delete json.results
       if (json.status !== 200) {
         throw json
@@ -773,7 +336,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
           start = runtime.performance.performance.now()
         }
         const { contextsPrime, generatedPrime, paraphrasesPrime, paraphrasesParenthesizedPrime, generatedParenthesizedPrime, responsesPrime } =
-                                  processContextsB({ isTest, rebuildingTemplate, config, hierarchy, json, commandLineArgs /*, generators, semantics */ })
+                                  await processContextsB({ isTest, rebuildingTemplate, config, hierarchy, json, commandLineArgs /*, generators, semantics */ })
         if (isTest) {
           end = runtime.performance.performance.now()
           clientSideTime = end - start
@@ -801,6 +364,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         response.generatedParenthesized = response.generatedParenthesized.concat(generatedParenthesizedPrime)
         response.responses = response.responses.concat(responsesPrime)
         queries = queries.slice(1)
+
       }
     }
 
@@ -828,7 +392,6 @@ const getConfigForTest = (config, testConfig) => {
   }
   const configForTest = {}
   for (const key of Object.keys(includes)) {
-    // configForTest[key] = config.config[key]
     if (key === 'words') {
       const words = config.config.words
       configForTest.words = {
@@ -838,7 +401,14 @@ const getConfigForTest = (config, testConfig) => {
       }
 
       const literals = config.config.words.literals
+      let includesWord = (word) => true
+      if (Array.isArray(includes.words)) {
+        includesWord = (word) => includes.words.includes(word)
+      }
       for (const key in literals) {
+        if (!includesWord(key)) {
+          continue
+        }
         const defs = []
         for (const def of literals[key]) {
           // TODO handle thie uuids the right way
@@ -847,15 +417,23 @@ const getConfigForTest = (config, testConfig) => {
         configForTest.words.literals[key] = defs
       }
 
-      const patterns = config.config.words.patterns
+      const patterns = config.config.words.patterns || []
       configForTest.words.patterns = patterns.map((pattern) => Object.assign({}, pattern, { uuid: undefined }))
 
-      const hierarchy = config.config.words.hierarchy
+      const hierarchy = config.config.words.hierarchy || []
       configForTest.words.hierarchy = hierarchy.map((hierarchy) => Object.assign({}, hierarchy, { uuid: undefined }))
     } else if (key === 'operators') {
-      configForTest.operators = config.config.operators.map((operator) => Object.assign({}, operator, { uuid: undefined }))
+      let include = (operator) => true
+      if (Array.isArray(includes.operators)) {
+        include = (operator) => includes.operators.includes(operator.pattern)
+      }
+      configForTest.operators = config.config.operators.filter( include ).map((operator) => Object.assign({}, operator, { uuid: undefined }))
     } else if (key === 'bridges') {
-      configForTest.bridges = config.config.bridges.map((bridge) => Object.assign({}, bridge, { uuid: undefined }))
+      let include = (operator) => true
+      if (Array.isArray(includes.bridges)) {
+        include = (bridge) => includes.bridges.includes(bridge.id)
+      }
+      configForTest.bridges = config.config.bridges.filter(include).map((bridge) => Object.assign({}, bridge, { uuid: undefined }))
     } else {
       configForTest[key] = config.config[key]
     }
@@ -865,8 +443,12 @@ const getConfigForTest = (config, testConfig) => {
 
 const runTest = async (config, expected, { args, verbose, testConfig, debug }) => {
   const test = expected.query
+  if (args.query && args.query != test) {
+    // no run this
+    return
+  }
   // initialize in between test so state is not preserved since the test was adding without state
-  config.rebuild()
+  await config.rebuild()
   const errorHandler = (error) => {
     if (error.metadata) {
       const priorities = analyzeMetaData(expected.metadata, error.metadata)
@@ -1012,7 +594,7 @@ const runTests = async (config, testFile, juicyBits) => {
 }
 
 const saveTest = async (testFile, config, test, expected, testConfig, saveDeveloper) => {
-  config.rebuild()
+  await config.rebuild()
   const objects = getObjects(config.config.objects)(config.uuid)
   console.log(test)
   const result = await _process(config, test, { isTest: true })
@@ -1033,11 +615,11 @@ const saveTestsHelper = async (testFile, config, tests, todo, testConfig, saveDe
     return
   }
   const test = todo.pop()
-  config.rebuild()
+  await config.rebuild()
   const result = await saveTest(testFile, config, test, tests[test], testConfig, saveDeveloper)
   // initialize in between test so state is not preserved since the test was adding without state
   // config.initialize({force: true})
-  config.rebuild()
+  await config.rebuild()
   return saveTestsHelper(testFile, config, tests, todo, testConfig, saveDeveloper)
 }
 
@@ -1324,6 +906,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
     associations: [],
     learned_contextual_priorities: []
   }
+  config.fragmentsBeingBuilt = []
   const looper = async (configs) => {
     if (configs.length === 0) {
       finish()
@@ -1331,14 +914,15 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
     }
     const { property, hierarchy, query: queryOrExtraConfig, previousResults, initializer, skipSemantics } = configs.shift()
     // queries are strings or { query: "blah", development: true/false }
-    if (typeof queryOrExtraConfig === 'string' || queryOrExtraConfig.query) {
+    if (typeof queryOrExtraConfig === 'string' || queryOrExtraConfig.query || queryOrExtraConfig.isFragment) {
       let query = queryOrExtraConfig
+      let isFragment = queryOrExtraConfig.isFragment
       if (typeof queryOrExtraConfig === 'string') {
         query = { query }
       }
-      config.config.skipSemantics = skipSemantics
+      config.config.skipSemantics = skipSemantics && !isFragment
       const transitoryMode = global.transitoryMode
-      if (property == 'fragments') {
+      if (isFragment || property == 'fragments') {
         global.transitoryMode = true
       }
       if (hierarchy) {
@@ -1356,7 +940,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
         if (previousResults && previousResults.query == query.query) {
           results = previousResults
           prMessage = ' Using previous results. use -rtf for a hard rebuild of everything on the server side.'
-          loadInstance(config, { resultss: [results] })
+          await loadInstance(config, { resultss: [results] })
         } else {
           results = await _process(config, query.query, { initializer, rebuildingTemplate: true })
         }
@@ -1367,18 +951,22 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
         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.`)
           throw new Error(`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) {
+        } else if (results.paraphrases[0].toLowerCase() !== query.query.toLowerCase()) {
           console.log(`query "${query.query}". The paraphrase is different from the query "${results.paraphrases[0]}".${prMessage}`)
         } else {
-          console.log(`query "${query.query}".${prMessage}`)
+          console.log(`query ${isFragment ? 'fragment' : ''}"${query.query}".${prMessage}`)
         }
         global.transitoryMode = transitoryMode
         config.config.skipSemantics = null
         results.query = query.query
+        results.isFragment = isFragment
         results.skipSemantics = skipSemantics
         results.development = query.development
         results.key = { query: query.query, hierarchy }
         accumulators[property].push(results)
+        if (isFragment) {
+          config.fragmentsBeingBuilt.push({ query: query.query, contexts: results.contexts })
+        }
         accumulators.associations = accumulators.associations.concat(results.associations)
         accumulators.learned_contextual_priorities = accumulators.learned_contextual_priorities.concat(results.learned_contextual_priorities)
         await looper(configs)
@@ -1392,8 +980,8 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
       const initFunction = queryOrExtraConfig
       const objects = config.get('objects')
       const args = { objects, getObjects: getObjects(objects) }
-      setupArgs(args, config, config.logs, hierarchy)
-      initFunction(args)
+      setupArgs(args, config, config.logs, config.hierarchy)
+      await initFunction(args)
       accumulators[property].push({ apply: queryOrExtraConfig })
       await looper(configs)
     } else {
@@ -1417,6 +1005,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
   }
 
   const finish = () => {
+    config.fragmentsBeingBuilt = []
     const instanceName = `${target}.instance.json`
     console.log(`Writing instance file ${instanceName}`)
     const stabilizeAssociations = (associations) => {
@@ -1505,11 +1094,16 @@ const checkTest = (testConfig) => {
 }
 
 const knowledgeModuleImpl = async ({
+  includes,
+  config : configStruct,
+  api,
+  initializer,
+  terminator,
+  multiApiInitializer,
+
   module: moduleFromJSFile,
   description,
   section,
-  // config, createConfig,
-  createConfig,
   newWay,
   demo,
   test,
@@ -1517,7 +1111,6 @@ const knowledgeModuleImpl = async ({
   errorHandler = defaultErrorHandler,
   process: processResults = defaultProcess,
   stopAtFirstFailure = true,
-  acceptsAdditionalConfig = false,
   ...rest
 } = {}) => {
   const unknownArgs = Object.keys(rest)
@@ -1530,10 +1123,29 @@ const knowledgeModuleImpl = async ({
   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 && !createConfig) {
-  if (!createConfig) {
+
+  if (!configStruct) {
     throw new Error("'config' or 'createConfig' is a required parameter. The value should the config that defines the knowledge module.")
   }
+
+  const createConfig = async () => {
+    const config = new Config(configStruct, moduleFromJSFile, _process)
+    config.setTerminator(terminator)
+    config.stop_auto_rebuild()
+    await config.add(...(includes || []))
+    if (api) {
+      config.setApi(api)
+    }
+    if (multiApiInitializer) {
+      await config.setMultiApi(multiApiInitializer)
+    }
+    if (initializer) {
+      config.initializer(initializer)
+    }
+    await config.restart_auto_rebuild()
+    return config
+  }
+
   if (!description) {
     throw new Error("'description' is a required parameter. The value should the description of the knowledge module.")
   }
@@ -1566,548 +1178,562 @@ const knowledgeModuleImpl = async ({
   }
 
   if (isProcess) {
-    const parser = new runtime.ArgumentParser({
-      description: 'Entodicton knowledge module'
-    })
-
-    const helpDebugWord = 'In order to get a debug break when a specific word is created set the DEBUG_WORD environment variable to the JSON of the association to break on. For example DEBUG_WORD=\'"the"\''
-    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 to break on. For example DEBUG_BRIDGE=\'car\''
-    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. Using optimization where if the query/config has not changed it will use the previous value. One there is a change all subsequence query/configs will be run.' })
-    parser.add_argument('-rtf', '--rebuildTemplateFull', { action: 'store_true', help: 'Force a template rebuild. Skip the optimization' })
-    parser.add_argument('-l', '--loop', { action: 'store_true', help: 'Run a loop so that multiply queries may be run' })
-    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', { 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', '--reset', { action: 'store_true', help: 'Get the server to bypass the cache and rebuild everything' })
-    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('-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('-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', { action: 'store_true', help: helpDebugAssociation })
-    parser.add_argument('-dw', '--debugWord', { action: 'store_true', help: helpDebugWord })
-    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.rebuildTemplateFull) {
-      args.rebuildTemplate = true
-    }
+    let config
+    try {
+      const parser = new runtime.ArgumentParser({
+        description: 'Entodicton knowledge module'
+      })
 
-    // dont debug the load of the KM's if rebuild template is on since we want to debug the template rebuild not the load
-    if (args.rebuildTemplate) {
-      global.pauseDebugging = true
-    }
+      const helpDebugWord = 'In order to get a debug break when a specific word is created set the DEBUG_WORD environment variable to the JSON of the association to break on. For example DEBUG_WORD=\'"the"\''
+      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 to break on. For example DEBUG_BRIDGE=\'car\''
+      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. if -q is specified the tests will be run for just the specified query.' })
+      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. Using optimization where if the query/config has not changed it will use the previous value. One there is a change all subsequence query/configs will be run.' })
+      parser.add_argument('-rtf', '--rebuildTemplateFull', { action: 'store_true', help: 'Force a template rebuild. Skip the optimization' })
+      parser.add_argument('-l', '--loop', { action: 'store_true', help: 'Run a loop so that multiply queries may be run' })
+      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', { 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', '--reset', { action: 'store_true', help: 'Get the server to bypass the cache and rebuild everything' })
+      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('-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('-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', { action: 'store_true', help: helpDebugAssociation })
+      parser.add_argument('-dw', '--debugWord', { action: 'store_true', help: helpDebugWord })
+      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.rebuildTemplateFull) {
+        args.rebuildTemplate = true
+      }
+
+      config = await createConfig()
+      
+      // dont debug the load of the KM's if rebuild template is on since we want to debug the template rebuild not the load
+      if (args.rebuildTemplate) {
+        global.pauseDebugging = true
+      }
 
-    const config = createConfig()
-    setupConfig(config)
-    processResults = processResults({ config, errorHandler })
+      setupConfig(config)
+      processResults = processResults({ config, errorHandler })
 
-    if (args.rebuildTemplate) {
-      global.pauseDebugging = false
-    }
+      if (args.rebuildTemplate) {
+        global.pauseDebugging = false
+      }
 
-    // setup();
+      // setup();
 
-    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 (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 (!typeof what[1] == 'number') {
-            return false
+          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>]"')
           }
-          return true
-        }
-        if (!Array.isArray(args.checkForLoop) || args.checkForLoop.some((value) => !isKey(value))) {
+        } catch (e) {
           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
+        }
       }
-    } else {
-      if (process.argv.includes('--checkForLoop') || process.argv.includes('-cl')) {
-        args.checkForLoop = true
+      if (args.debugAssociation) {
+        console.log(helpDebugAssociation)
+        runtime.process.exit(-1)
+      }
+      if (args.debugWord) {
+        console.log(helpDebugWord)
+        runtime.process.exit(-1)
+      }
+      if (args.debugHierarchy) {
+        console.log(helpDebugHierarchy)
+        runtime.process.exit(-1)
+      }
+      if (args.debugPriority) {
+        console.log(helpDebugPriority)
+        runtime.process.exit(-1)
+      }
+      if (args.debugBridge) {
+        console.log(helpDebugBridge)
+        runtime.process.exit(-1)
+      }
+      if (args.debugOperator) {
+        console.log(helpDebugOperator)
+        runtime.process.exit(-1)
       }
-    }
-    if (args.debugAssociation) {
-      console.log(helpDebugAssociation)
-      runtime.process.exit(-1)
-    }
-    if (args.debugWord) {
-      console.log(helpDebugWord)
-      runtime.process.exit(-1)
-    }
-    if (args.debugHierarchy) {
-      console.log(helpDebugHierarchy)
-      runtime.process.exit(-1)
-    }
-    if (args.debugPriority) {
-      console.log(helpDebugPriority)
-      runtime.process.exit(-1)
-    }
-    if (args.debugBridge) {
-      console.log(helpDebugBridge)
-      runtime.process.exit(-1)
-    }
-    if (args.debugOperator) {
-      console.log(helpDebugOperator)
-      runtime.process.exit(-1)
-    }
 
-    if (args.clean) {
-      const tests = JSON.parse(runtime.fs.readFileSync(testConfig.name))
-      for (const test of tests) {
-        delete test.associations
+      if (args.clean) {
+        const tests = JSON.parse(runtime.fs.readFileSync(testConfig.name))
+        for (const test of tests) {
+          delete test.associations
+        }
+        writeTestFile(testConfig.name, tests)
+        console.log(`Cleaned ${testConfig.name}`)
+        return
       }
-      writeTestFile(testConfig.name, tests)
-      console.log(`Cleaned ${testConfig.name}`)
-      return
-    }
 
-    if (args.deleteTest) {
-      let tests = JSON.parse(runtime.fs.readFileSync(testConfig.name))
-      tests = tests.filter((test) => test.query !== args.deleteTest)
-      writeTestFile(testConfig.name, tests)
-      console.log(`Remove the test for "${args.deleteTest}"`)
-      return
-    }
+      if (args.deleteTest) {
+        let tests = JSON.parse(runtime.fs.readFileSync(testConfig.name))
+        tests = tests.filter((test) => test.query !== args.deleteTest)
+        writeTestFile(testConfig.name, tests)
+        console.log(`Remove the test for "${args.deleteTest}"`)
+        return
+      }
 
-    const options = { rebuild: false }
-    if (args.rebuildTemplate) {
-      options.rebuild = true
-    }
-    if (args.greg) {
-      config.server('http://localhost:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
-    }
-    if (args.server) {
-      config.server(args.server)
-    }
+      const options = { rebuild: false }
+      if (args.rebuildTemplate) {
+        options.rebuild = true
+      }
+      if (args.greg) {
+        config.server('http://localhost:3000', '6804954f-e56d-471f-bbb8-08e3c54d9321')
+      }
+      if (args.server) {
+        config.server(args.server)
+      }
 
-    if (args.queryParams) {
-      config.setQueryParams(args.queryParams)
-    }
+      if (args.queryParams) {
+        config.setQueryParams(args.queryParams)
+      }
 
-    if (args.debug) {
-      config.config.debug = true
-    }
+      if (args.debug) {
+        config.config.debug = true
+      }
 
-    if (args.reset) {
-      config.config.skip_cache = true
-    }
+      if (args.reset) {
+        config.config.skip_cache = true
+      }
 
-    if (args.explainPriorities) {
-      config.config.explain_priorities = true
-    }
+      if (args.explainPriorities) {
+        config.config.explain_priorities = true
+      }
 
-    config.config.debugIncludeConvolutions = args.debugIncludeConvolutions || process.argv.includes('--debugIncludeConvolutions') || process.argv.includes('-dic')
+      config.config.debugIncludeConvolutions = args.debugIncludeConvolutions || process.argv.includes('--debugIncludeConvolutions') || process.argv.includes('-dic')
 
-    let configPrinted = false
-    const printConfig = () => {
-      if (configPrinted) {
-        return
-      }
-      configPrinted = true
-      if (args.print) {
-        if (args.print.includes('t')) {
-          console.log('Test queries')
-          let counter = 0
-          for (const test of config.tests) {
-            console.log(`${counter} - ${test.query}`)
-            counter += 1
-          }
-        }
-        if (args.print.includes('c')) {
-          const { data } = setupProcessB({ config })
-          console.log('Config as sent to server')
-          console.log(JSON.stringify(data, null, 2))
+      let configPrinted = false
+      const printConfig = () => {
+        if (configPrinted) {
+          return
         }
+        configPrinted = true
+        if (args.print) {
+          if (args.print.includes('t')) {
+            console.log('Test queries')
+            let counter = 0
+            for (const test of config.tests) {
+              console.log(`${counter} - ${test.query}`)
+              counter += 1
+            }
+          }
+          if (args.print.includes('c')) {
+            const { data } = setupProcessB({ config })
+            console.log('Config as sent to server')
+            console.log(JSON.stringify(data, null, 2))
+          }
 
-        if (args.print.includes('l')) {
-          console.log('Module load ordering')
-          for (const km of config.configs) {
-            console.log(`  ${km.name}`)
+          if (args.print.includes('l')) {
+            console.log('Module load ordering')
+            for (const km of config.configs) {
+              console.log(`  ${km.name}`)
+            }
           }
-        }
-        if (args.print.includes('w')) {
-          // { literals: Object, patterns: Array(2), hierarchy: Array(97) }
-          console.log('literals')
-          for (const word in config.config.words.literals) {
-            console.log('  ' + word.concat('          ', ...config.config.words.literals[word].map((def) => JSON.stringify(def))))
+          if (args.print.includes('w')) {
+            // { literals: Object, patterns: Array(2), hierarchy: Array(97) }
+            console.log('literals')
+            for (const word in config.config.words.literals) {
+              console.log('  ' + word.concat(...config.config.words.literals[word].map((def, i) => ((i > 0) ? ' '.repeat(4+word.length) : '  ') + JSON.stringify(def) + '\n')))
+            }
+            console.log('patterns')
+            for (const pattern of config.config.words.patterns) {
+              console.log('  ' + JSON.stringify(pattern))
+            }
           }
-          console.log('patterns')
-          for (const pattern of config.config.words.patterns) {
-            console.log('  ' + JSON.stringify(pattern))
+          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('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 (const property of properties) {
-            console.log(`  ${property} ===============`)
-            for (const association of config.config.associations[property]) {
-              console.log(`  ${JSON.stringify(association)}`)
+          if (args.print.includes('a')) {
+            console.log('associations ================')
+            const properties = ['negative', 'positive']
+            for (const property of properties) {
+              console.log(`  ${property} ===============`)
+              for (const 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 (const 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 (const edge of config.config.hierarchy) {
-            console.log(JSON.stringify(edge))
+          if (args.print.includes('p')) {
+            for (const 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 (const edge of config.config.hierarchy) {
+              console.log(JSON.stringify(edge))
             }
           }
-          console.dir(easyToRead)
-        }
-        if (args.print.includes('s')) {
-          const easyToRead = _.cloneDeep(config.config.semantics)
-          for (const semantic of easyToRead) {
-            semantic.match = semantic.match.toString()
-            semantic.apply = semantic.apply.toString()
+          if (args.print.includes('g')) {
+            const easyToRead = _.cloneDeep(config.config.generators)
+            for (const semantic of easyToRead) {
+              semantic.match = semantic.match.toString()
+              semantic.apply = semantic.apply.toString()
+              if (semantic.applyWrapped) {
+                semantic.applyWrapped = semantic.applyWrapped.toString()
+              }
+            }
+            console.dir(easyToRead)
+          }
+          if (args.print.includes('s')) {
+            const easyToRead = _.cloneDeep(config.config.semantics)
+            for (const semantic of easyToRead) {
+              semantic.match = semantic.match.toString()
+              semantic.apply = semantic.apply.toString()
+            }
+            console.dir(easyToRead)
           }
-          console.dir(easyToRead)
         }
       }
-    }
 
-    checkTemplate(template)
+      checkTemplate(template)
 
-    if (template) {
-      let needsRebuild
-      if (args.rebuildTemplate && !args.rebuildTemplateFull) {
-        // get the startOfChanges for the partial rebuild
-        needsRebuild = config.needsRebuild(template.template, template.instance, { ...options, rebuild: false })
-      } else {
-        // do a check or full rebuild
-        needsRebuild = config.needsRebuild(template.template, template.instance, options)
-      }
+      if (template) {
+        let needsRebuild
+        if (args.rebuildTemplate && !args.rebuildTemplateFull) {
+          // get the startOfChanges for the partial rebuild
+          needsRebuild = config.needsRebuild(template.template, template.instance, { ...options, rebuild: false })
+        } else {
+          // do a check or full rebuild
+          needsRebuild = config.needsRebuild(template.template, template.instance, options)
+        }
 
-      if (needsRebuild.needsRebuild) {
-        if (needsRebuild.previousResultss) {
-          console.log('Rebuild using the optimization to use previous results until a change is hit. For a full rebuild use -rtf')
+        if (needsRebuild.needsRebuild) {
+          if (needsRebuild.previousResultss) {
+            console.log('Rebuild using the optimization to use previous results until a change is hit. For a full rebuild use -rtf')
+          }
+          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
+        }
+        try {
+          await config.load(rebuildTemplate, template.template, template.instance, { rebuild: needsRebuild.needsRebuild || options.rebuild, previousResultss: needsRebuild.previousResultss, startOfChanges: needsRebuild.startOfChanges })
+        } catch (e) {
+          console.error(`Error loading template for ${config.name}. ${e.error ? e.error : e}${e.stack ? e.stack : ''}`)
+          runtime.process.exit(-1)
+        }
+        if (!args.query) {
+          printConfig()
+        }
+        if (needsRebuild.needsRebuild) {
+          return
         }
-        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
       }
-      try {
-        config.load(template.template, template.instance, { rebuild: needsRebuild.needsRebuild || options.rebuild, previousResultss: needsRebuild.previousResultss, startOfChanges: needsRebuild.startOfChanges })
-      } catch (e) {
-        console.error(`Error loading template for ${config.name}. ${e.error ? e.error : e}${e.stack ? e.stack : ''}`)
-        runtime.process.exit(-1)
+
+      if (args.retrain) {
+        config.config.retrain = true
       }
-      if (!args.query) {
-        printConfig()
+
+      if (args.saveDeveloper) {
+        args.save = true
       }
-      if (needsRebuild.needsRebuild) {
-        return
+      if (args.test || args.testVerbose || args.testAllVerbose || args.save) {
+        global.transitoryMode = true
       }
-    }
-
-    if (args.retrain) {
-      config.config.retrain = true
-    }
-
-    if (args.test || args.testVerbose || args.testAllVerbose || args.save) {
-      global.transitoryMode = true
-    }
-    if (!args.query && !args.test && !args.info && (args.save || args.saveDeveloper)) {
-      global.transitoryMode = true
-      saveTests(config, test, testConfig, args.saveDeveloper)
-    // } else if (args.build) {
-    } else if (args.info) {
-      showInfo(description, section, config)
-    } else if (args.test || args.testVerbose || args.testAllVerbose) {
-      // TODO make test always a string
-      if (typeof test === 'string') {
-        const l = (n, hasError) => {
-          if (n === 0) {
-            if (hasError) {
-              runtime.process.exit(-1)
+      if (!args.query && !args.test && !args.info && (args.save || args.saveDeveloper)) {
+        global.transitoryMode = true
+        await saveTests(config, test, testConfig, args.saveDeveloper)
+      // } else if (args.build) {
+      } else if (args.info) {
+        showInfo(description, section, config)
+      } else if (args.test || args.testVerbose || args.testAllVerbose) {
+        // TODO make test always a string
+        if (typeof test === 'string') {
+          const l = async (n, hasError) => {
+            if (n === 0) {
+              if (hasError) {
+                runtime.process.exit(-1)
+              }
+              return
             }
-            return
-          }
-          let useTestConfig = testConfig
-          if (args.testModuleName) {
-            useTestConfig = config.getConfigs()[args.testModuleName].getTestConfig()
-            useTestConfig.testModuleName = args.testModuleName
-            test = useTestConfig.name
-          }
-          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
-
-              let hasError = false
-              for (const result of results) {
-                if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
-                  result.hasError = true
-                }
-                if (!args.testNoParenthesized) {
-                  if (JSON.stringify(result.expected.paraphrasesParenthesized) !== JSON.stringify(result.actual.paraphrasesParenthesized)) {
+            let useTestConfig = testConfig
+            if (args.testModuleName) {
+              useTestConfig = config.getConfigs()[args.testModuleName].getTestConfig()
+              useTestConfig.testModuleName = args.testModuleName
+              test = useTestConfig.name
+            }
+            await 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
+
+                let hasError = false
+                for (const result of results) {
+                  if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
                     result.hasError = true
                   }
-                  if (JSON.stringify(result.expected.generatedParenthesized) !== JSON.stringify(result.actual.generatedParenthesized)) {
+                  if (!args.testNoParenthesized) {
+                    if (JSON.stringify(result.expected.paraphrasesParenthesized) !== JSON.stringify(result.actual.paraphrasesParenthesized)) {
+                      result.hasError = true
+                    }
+                    if (JSON.stringify(result.expected.generatedParenthesized) !== JSON.stringify(result.actual.generatedParenthesized)) {
+                      result.hasError = true
+                    }
+                  }
+                  if (JSON.stringify(result.expected.responses) !== JSON.stringify(result.actual.responses)) {
                     result.hasError = true
                   }
+                  if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
+                    result.hasError = true
+                  }
+                  if (!sameJSON(result.expected.checkedContexts, result.actual.checkedContexts)) {
+                    result.hasError = true
+                  }
+                  if (result.hasError) {
+                    hasError = true
+                  }
                 }
-                if (JSON.stringify(result.expected.responses) !== JSON.stringify(result.actual.responses)) {
-                  result.hasError = true
-                }
-                if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
-                  result.hasError = true
-                }
-                if (!sameJSON(result.expected.checkedContexts, result.actual.checkedContexts)) {
-                  result.hasError = true
-                }
-                if (result.hasError) {
-                  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 (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
+                        if (args.vimdiff) {
+                          vimdiff(actual, expected, `"${result.utterance}" - ${label}`)
+                        }
+                        result.hasError = 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')
                       }
-                      console.log(`    expected ${label}`, expected)
-                      console.log(`    actual ${label}  `, actual)
+                      console.log('    expected paraphrases', result.expected.paraphrases)
+                      console.log('    actual paraphrases  ', result.actual.paraphrases)
                       newError = true
                       headerShown = true
-                      if (args.vimdiff) {
-                        vimdiff(actual, expected, `"${result.utterance}" - ${label}`)
-                      }
-                      result.hasError = 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')
                     }
-                    console.log('    expected paraphrases', result.expected.paraphrases)
-                    console.log('    actual paraphrases  ', result.actual.paraphrases)
-                    newError = true
-                    headerShown = true
-                  }
-                  if (JSON.stringify(result.expected.responses) !== JSON.stringify(result.actual.responses)) {
-                    if (!headerShown) {
-                      console.log('  Failure')
+                    if (JSON.stringify(result.expected.responses) !== JSON.stringify(result.actual.responses)) {
+                      if (!headerShown) {
+                        console.log('  Failure')
+                      }
+                      console.log('    expected responses  ', result.expected.responses)
+                      console.log('    actual responses    ', result.actual.responses)
+                      newError = true
+                      headerShown = true
                     }
-                    console.log('    expected responses  ', result.expected.responses)
-                    console.log('    actual responses    ', result.actual.responses)
-                    newError = true
-                    headerShown = true
-                  }
-                  */
-                  if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
-                    if (!headerShown) {
-                      console.log('  Failure')
+                    */
+                    if (JSON.stringify(result.expected.checked) !== JSON.stringify(result.actual.checked)) {
+                      if (!headerShown) {
+                        console.log('  Failure')
+                      }
+                      const widths = [4, 18, 72]
+                      const lines = new Lines(widths)
+                      lines.setElement(1, 1, 'expected checked objects')
+                      lines.setElement(2, 2, JSON.stringify(result.expected.checked, null, 2))
+                      lines.log()
+                      lines.setElement(1, 1, 'actual checked objects')
+                      lines.setElement(2, 2, JSON.stringify(result.actual.checked, null, 2))
+                      lines.log()
+                      if (args.vimdiff) {
+                        show('checked properties for objects', result.expected.checked, result.actual.checked)
+                      }
+                      newError = true
+                      headerShown = true
                     }
-                    const widths = [4, 18, 72]
-                    const lines = new Lines(widths)
-                    lines.setElement(1, 1, 'expected checked objects')
-                    lines.setElement(2, 2, JSON.stringify(result.expected.checked, null, 2))
-                    lines.log()
-                    lines.setElement(1, 1, 'actual checked objects')
-                    lines.setElement(2, 2, JSON.stringify(result.actual.checked, null, 2))
-                    lines.log()
-                    if (args.vimdiff) {
-                      vimdiff(result.actual.checked, result.expected.checked)
+                    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 checked contexts', true)
+                      lines.setElement(2, 2, JSON.stringify(result.expected.checkedContexts, null, 2))
+                      lines.log()
+                      lines.setElement(1, 1, 'actual checked contexts', true)
+                      lines.setElement(2, 2, JSON.stringify(result.actual.checkedContexts, null, 2))
+                      lines.log()
+                      if (args.vimdiff) {
+                        show('checked properties for context', result.expected.checkedContexts, result.actual.checkedContexts)
+                      }
+                      newError = true
+                      headerShown = true
                     }
-                    newError = true
-                    headerShown = true
                   }
-                  if (!sameJSON(result.expected.checkedContexts, result.actual.checkedContexts)) {
-                    if (!headerShown) {
-                      console.log('  Failure')
+                } else {
+                  if (results.length > 0 && args.vimdiff) {
+                    for (const result of results) {
+                      vimdiff(result.actual, result.expected)
                     }
-                    const widths = [4, 18, 72]
-                    const lines = new Lines(widths)
-                    lines.setElement(1, 1, 'expected checked contexts', true)
-                    lines.setElement(2, 2, JSON.stringify(result.expected.checkedContexts, null, 2))
-                    lines.log()
-                    lines.setElement(1, 1, 'actual checked contexts', 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 (hasError) {
+                  if (!headerShown) {
+                    if (!(useTestConfig.check && useTestConfig.check.length > 0)) {
+                      console.log('There are failures due to things other than paraphrases, responses and checked properties being different. They are not shown because you ran -tv or -tva which only shows difference in paraphrase and results. Usually what I do is -s and do a diff to make sure there are no other problems. If the paraphrases or results were different they would have shown here.')
+                    }
                   }
-                }
-              }
-              if (hasError) {
-                if (!headerShown) {
                   if (!(useTestConfig.check && useTestConfig.check.length > 0)) {
-                    console.log('There are failures due to things other than paraphrases, responses and checked properties being different. They are not shown because you ran -tv or -tva which only shows difference in paraphrase and results. Usually what I do is -s and do a diff to make sure there are no other problems. If the paraphrases or results were different they would have shown here.')
-                  }
-                }
-                if (!(useTestConfig.check && useTestConfig.check.length > 0)) {
-                  console.log('use -v arg to write files expected.json and actual.json in the current directory for detailed comparison. Or do -s and then git diff the changes.')
-                  // console.log(JSON.stringify(contexts))
-                  let errorCount = 0
-                  for (const result of results) {
-                    if (result.hasError) {
-                      errorCount += 1
+                    console.log('use -v arg to write files expected.json and actual.json in the current directory for detailed comparison. Or do -s and then git diff the changes.')
+                    // console.log(JSON.stringify(contexts))
+                    let errorCount = 0
+                    for (const result of results) {
+                      if (result.hasError) {
+                        console.log(`FAILED ${result.utterance}`)
+                        errorCount += 1
+                      }
                     }
+                    console.log(`**************************** THERE WERE ${errorCount} TEST FAILURES ************************`)
                   }
-                  console.log(`**************************** THERE WERE ${errorCount} TEST FAILURES ************************`)
                 }
               }
-            }
-            // const contexts = { failures: results }
-            l(n - 1, hasError || newError)
-          }).catch((error) => {
-            console.error(error)
-            runtime.process.exit(-1)
-            errorHandler(error)
+              // const contexts = { failures: results }
+              l(n - 1, hasError || newError)
+            }).catch((error) => {
+              console.error(error)
+              runtime.process.exit(-1)
+              errorHandler(error)
+            })
+          }
+          await l(args.count, false)
+        } else {
+          test()
+        }
+      } else if (args.loop) {
+        const readline = runtime.readline.createInterface({ input: runtime.process.stdin, output: runtime.process.stdout })
+        const f = () => readline.question('Enter query? (newline to quit) ', query => {
+          query = query.trim()
+          if (query.length === 0) {
+            return readline.close()
+          }
+          const promise = _process(config, query, { testsFN: test }).then((results) => {
+            console.log(results.responses.join(' '))
           })
+          if (!('then' in promise)) {
+            throw new Error('Return a promise from process in the definition of knowledgeModule')
+          }
+          promise
+            .then(() => {
+              f()
+            })
+            .catch((e) => {
+              if (e.errno == 'ECONNREFUSED') {
+                console.log(e)
+                readline.close()
+              } else {
+                console.log(e)
+                f()
+              }
+            })
+        })
+        f()
+      } else if (args.query) {
+        let useTestConfig = testConfig
+        if (args.testModuleName) {
+          config.testConfig.testModuleName = args.testModuleName
+          config.testConfig.checks = config.getConfigs()[args.testModuleName].getTestConfig().checks
+          // useTestConfig = config.getConfigs()[args.testModuleName].getTestConfig()
+          // useTestConfig.testModuleName = args.testModuleName
         }
-        l(args.count, false)
-      } else {
-        test()
-      }
-    } else if (args.loop) {
-      const readline = runtime.readline.createInterface({ input: runtime.process.stdin, output: runtime.process.stdout })
-      const f = () => readline.question('Enter query? (newline to quit) ', query => {
-        query = query.trim()
-        if (query.length === 0) {
-          return readline.close()
+        const objects = getObjects(config.config.objects)(config.uuid)
+        // for the compare
+        if (args.objectDiff) {
+          global.beforeObjects = _.cloneDeep(objects)
         }
-        const promise = _process(config, query, { testsFN: test }).then((results) => {
-          console.log(results.responses.join(' '))
-        })
-        if (!('then' in promise)) {
-          throw new Error('Return a promise from process in the definition of knowledgeModule')
+        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) {
+          console.log('Error', error)
         }
-        promise
-          .then(() => {
-            f()
-          })
-          .catch((e) => {
-            if (e.errno == 'ECONNREFUSED') {
-              console.log(e)
-              readline.close()
-            } else {
-              console.log(e)
-              f()
-            }
-          })
-      })
-      f()
-    } else if (args.query) {
-      let useTestConfig = testConfig
-      if (args.testModuleName) {
-        config.testConfig.testModuleName = args.testModuleName
-        config.testConfig.checks = config.getConfigs()[args.testModuleName].getTestConfig().checks
-        // useTestConfig = config.getConfigs()[args.testModuleName].getTestConfig()
-        // useTestConfig.testModuleName = args.testModuleName
       }
-      const objects = getObjects(config.config.objects)(config.uuid)
-      // for the compare
-      if (args.objectDiff) {
-        global.beforeObjects = _.cloneDeep(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) {
-        console.log('Error', error)
+      printConfig()
+    } finally {
+      if (config) {
+        config.terminate()
       }
     }
-    printConfig()
   } else {
-    const initConfig = (config) => {
+    const initConfig = async (config) => {
       if (template) {
         if (config.needsRebuild(template.template, template.instance, { isModule: !isProcess }).needsRebuild) {
+          debugger
+          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)
         }
@@ -2140,24 +1766,21 @@ const knowledgeModuleImpl = async ({
 
       if (template) {
         try {
-          config.load(template.template, template.instance)
+          await config.load(rebuildTemplate, template.template, template.instance)
         } catch (e) {
           errorHandler(e)
         }
       }
     }
 
-    createConfigExport = (additionalConfig) => {
-      if (createConfig.cached) {
+    // no cache 21 minutes + rebuild fails "node tester_rebuild -m colors"
+    // cache okay
+    createConfigExport = async () => {
+      if (false && createConfig.cached) {
         return createConfig.cached
       }
-      const config = createConfig(acceptsAdditionalConfig ? additionalConfig : null)
-      if (!acceptsAdditionalConfig && additionalConfig) {
-        config.stop_auto_rebuild()
-        additionalConfig(config)
-        config.restart_auto_rebuild()
-      }
-      initConfig(config)
+      const config = await createConfig()
+      await initConfig(config)
       // config.rebuild({ isModule: true })
       createConfig.cached = config
       return createConfig.cached
@@ -2186,11 +1809,6 @@ const ensureTestFile = (module, name, type) => {
   }
 }
 
-function w (func) {
-  func.where = where(3)
-  return func
-}
-
 const knowledgeModule = async (...args) => {
   await knowledgeModuleImpl(...args).catch((e) => {
     console.error(e)
@@ -2201,9 +1819,6 @@ const knowledgeModule = async (...args) => {
 module.exports = {
   process: _process,
   stableId,
-  where,
-  w,
-  // submitBug,
   ensureTestFile,
   rebuildTemplate,
   processContext,
@@ -2220,5 +1835,6 @@ module.exports = {
   loadInstance,
   gs,
   flattens,
-  writeTest
+  writeTest,
+  getConfigForTest,
 }