theprogrammablemind 7.1.4-beta.3

package/client.js

@@ -0,0 +1,1473 @@
+const { Semantics, Semantic } = require('./src/semantics')
+const { Generators, Generator } = require('./src/generators')
+const Digraph = require('./src/digraph')
+const fetch = require('node-fetch')
+const base64 = require('base-64')
+const deepEqual = require('deep-equal')
+const _ = require('lodash')
+const stringify = require('json-stable-stringify')
+const Lines = require('./lines')
+const flattens = require('./src/flatten')
+const { appendNoDups, InitCalls } = require('./src/helpers')
+const sortJson = require('sort-json')
+const util = require('util')
+const { diffString } = require('json-diff')
+
+const isJest = () => {
+  return process.env.JEST_WORKER_ID !== undefined;
+}
+
+let fs
+let ArgumentParser
+if (typeof window === 'undefined' || isJest()) {
+  fs = require('fs')
+  ArgumentParser = require('argparse').ArgumentParser
+}
+
+const ask = (config) => (asks) => {
+  for (let ask of asks) {
+    config.addMotivation({
+      match: (args) => ask.matchr(args),
+      apply: (args) => ask.applyr(args)
+    })
+  }
+  config.addMotivation({
+      match: ({context}) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
+      apply: (args) => {
+        for (let ask of asks) {
+          let matchq = ask.matchq
+          let applyq = ask.applyq
+          if (!matchq) {
+            let wasAsked = false
+            matchq = () => !wasAsked,
+            applyq = (args) => {
+              wasAsked = true
+              applyq(args)
+            }
+          }
+          if (matchq(args)) {
+            args.context.motivationKeep = true
+            args.context.verbatim = applyq(args)
+            args.context.isResponse = true;
+            delete args.context.controlRemove;
+            args.context.controlKeepMotivation = true;
+            break
+          }
+        }
+     }
+  })
+}
+
+const vimdiff = (actualJSON, expectedJSON) => {
+  const path = '.'
+  const actual = sortJson(actualJSON, { depth: 25 })
+  fs.writeFileSync(`${path}/actual.json`, JSON.stringify(actual, 0, 2))
+  const expected = sortJson(expectedJSON, { depth: 25 })
+  fs.writeFileSync(`${path}/expected.json`, JSON.stringify(expected, 0, 2))
+  // console.log(`vimdiff ${path}/actual.json ${path}/expected.json`)
+  {
+    const editor = process.env.EDITOR || 'vimdiff'
+    const child = child_process.spawn(editor, [`${path}/expected.json`, `${path}/actual.json`], { stdio: 'inherit' })
+    child.on('exit', function (e, code) {
+      console.log('finished')
+    })
+  }
+}
+
+const listable = (hierarchy) => (c, type) => {
+  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) => hierarchy.isA(child, parent)
+
+const asList = (context) => {
+  if (context.marker === 'list') {
+    return context
+  }
+  return {
+    marker: 'list',
+    types: [context.marker],
+    value: [context]
+  }
+}
+
+const setupArgs = (args, config, logs, hierarchy) => {
+  config.setArgs(args)
+  args.calls = new InitCalls()
+  args.km = (name) => config.getConfig(name)
+  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.ask = ask(config)
+  args.motivation = (m) => config.addMotivation(m)
+  args.s = (c) => config.getSemantics(logs).apply(args, c)
+  args.g = (c) => config.getGenerators(logs).apply(args, c)
+  args.gp = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: true, isResponse: false, response: false})
+  args.gr = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: false, isResponse: true })
+  args.e = (c) => config.getEvaluator(args.s, logs, c)
+  args.log = (message) => logs.push(message)
+  // config.getAddedArgs(args)
+  args.gs = gs(args.g)
+  args.gsp = gs(args.gp)
+  args.gsr = gs(args.gr)
+}
+
+const gs = (g) => (contexts, separator, lastSeparator) => {
+  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
+  }
+  return true
+}
+
+const analyzeMetaData = (right, wrong) => {
+  const rOpChoices = right.opChoices
+  const wOpChoices = wrong.opChoices
+  if (!rOpChoices || !wOpChoices) {
+    return []
+  }
+  const n = rOpChoices.length > wOpChoices.length ? wOpChoices.length : rOpChoices.length
+  for (let i = 0; i < n; ++i) {
+    const rOp = rOpChoices[i].op
+    const wOp = wOpChoices[i].op
+    if (rOp[0] !== wOp[0] || rOp[1] !== wOp[1]) {
+      return [rOpChoices[i].ops.filter((op) => !(op[0] === rOp[0] && op[1] === rOp[1])).concat([rOp])]
+    }
+  }
+  return []
+}
+
+const processContexts = (contexts, params) => {
+  const contextsPrime = []
+  const generated = []
+  const logs = []
+  for (const context of contexts) {
+    const result = processContext(context, Object.assign({}, params, { logs }))
+    contextsPrime.push(result.context)
+    generated.push(result.generated)
+  }
+  return { contexts: contextsPrime, generated, logs }
+}
+
+const getObjects = (objects) => (uuid) => {
+  if (objects && objects.namespaced) {
+    objects = 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 Digraph((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)[0]
+  const paraphrases = generators.apply(args, context, { paraphrase: true, response: false, isResponse: false })[0]
+  let responses = []
+  if (context.isResponse) {
+    responses = generated
+  }
+  return { context, generated, paraphrases, responses }
+}
+
+const convertToStable = (objects) => {
+  const stableObjects = Object.assign({}, objects)
+  stableObjects.namespaced = {}
+  let counter = 0
+  Object.keys(((objects || {}).namespaced || {})).forEach((uuid) => {
+    stableObjects.namespaced[`${counter}`] = objects.namespaced[uuid]
+    counter += 1
+  })
+  return stableObjects
+}
+
+const writeTestFile = (fn, tests) => {
+  const stabilize = (tests) => {
+    for (let test of tests) {
+      for (opChoice of test.metadata.opChoices) {
+        opChoice.ops.sort()
+      }
+      test.metadata.opChoices.sort()
+    }
+  }
+  stabilize(tests)
+  fs.writeFileSync(fn, stringify(tests, { space: 2 }), { encoding: 'utf8', flag: 'w+' })
+}
+
+const writeTest = (fn, query, objects, generated, paraphrases, responses, contexts, associations, metadata, config, saveDeveloper) => {
+  let tests = []
+  if (fs.existsSync(fn)) {
+    tests = JSON.parse(fs.readFileSync(fn))
+  }
+  for (let association of associations) {
+    association.sort()
+  }
+  associations.sort()
+  // tests[query] = sortJson({ paraphrases, responses, contexts, objects: convertToStable(objects), associations, metadata, config, developerTest: saveDeveloper }, { depth: 25 })
+  results = sortJson({ query, paraphrases, responses, contexts, objects: convertToStable(objects), associations, metadata, config, developerTest: saveDeveloper }, { depth: 25 })
+  let wasSet = false;
+  tests.forEach( (test, index) => {
+    if (test.query == query) {
+      tests[index] = results
+      wasSet = true
+    }
+  });
+  if (!wasSet) {
+    tests.push(results)
+  }
+  // fs.writeFileSync(fn, stringify(tests, { space: 2 }), { encoding: 'utf8', flag: 'w+' })
+  writeTestFile(fn, tests)
+}
+
+const processContextsB = ({ config, hierarchy, semantics, generators, json, isTest }) => {
+  // TODO fix this name to contextsPrime
+  const contextsPrime = []
+  const generatedPrime = []
+  const paraphrasesPrime = []
+  const responsesPrime = []
+  const contexts = []
+  let first = true
+  contexts.push({ marker: 'controlStart', controlRemove: true })
+  for (const context of json.contexts) {
+    if (first) {
+      first = false
+    } else {
+      contexts.push({ marker: 'controlBetween', controlRemove: true })
+    }
+    contexts.push(context)
+  }
+  contexts.push({ marker: 'controlEnd', controlRemove: true })
+  const objects = config.get('objects')
+  const args = { objects, isResponse: true, response: json, isTest, getObjects: getObjects(objects) }
+  setupArgs(args, config, json.logs, hierarchy)
+  const toDo = [...contexts]
+  args.insert = (context) => toDo.unshift(context)
+  while (toDo.length > 0) {
+    args.calls.next()
+    const context = toDo.shift()
+    let contextPrime = context
+    context.topLevel = true
+    try {
+      if (json.has_errors) {
+        throw new Error('There are errors in the logs')
+      }
+      if (!config.get('skipSemantics')) {
+        if (!config.doMotivations(args, context)) {
+          const semantics = config.getSemantics(json.logs)
+          try {
+            contextPrime = semantics.apply(args, context)
+          } catch( e ) {
+            if (e.message == 'Maximum call stack size exceeded') {
+              const mostCalled = semantics.getMostCalled()
+              e.message += `\nThe most called semantic was:\nnotes: ${mostCalled.notes}\nmatch: ${mostCalled.matcher.toString()}\napply: ${mostCalled._apply.toString()}\n`
+            }
+            throw e;
+          }
+        }
+      }
+      if (contextPrime.controlRemove) {
+        continue
+      }
+      let assumed = { isResponse: true };
+      const generated = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
+      // assumed = { paraphrase: true, response: false };
+      assumed = { paraphrase: true };
+      args.g = (c) => config.getGenerators(json.logs).apply(args, c, assumed)
+      args.gp = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: true, isResponse: false, response: false }, assumed)
+      args.gr = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: false }, assumed)
+      args.gs = gs(args.g)
+      args.gsp = gs(args.gsp)
+      args.gsr = gs(args.gr)
+      const paraphrases = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
+      args.g = (c) => config.getGenerators(json.logs).apply(args, c)
+      args.gp = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: true, isResponse: false, response: false })
+      args.gr = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: false })
+      args.gs = gs(args.g)
+      args.gsp = gs(args.gp)
+      args.gsr = gs(args.gr)
+      contextsPrime.push(contextPrime)
+      generatedPrime.push(generated)
+      paraphrasesPrime.push(paraphrases)
+      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, 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, responsesPrime }
+}
+
+const doWithRetries = async (n, url, data) => {
+  for (let i = 0; i < n; ++i) {
+    const result = await fetch(`${url}/process`, {
+      method: 'POST',
+      body: JSON.stringify(data),
+      timeout: 1000 * 60 * 5, // it does not respect this timeout so that's why I have the retries
+      headers: {
+        mode: 'no-cors',
+        'Content-Type': 'application/json'
+      }
+    })
+    if (result.ok) {
+      return JSON.parse(JSON.stringify(await result.json()))
+    }
+    if (result.status === 504) {
+      if (n === 0) {
+        throw `Error ${result.status} - ${result.statusText}`
+      } else {
+        continue
+      }
+    }
+    if (result.status >= 500 && result.status < 600) {
+      throw `Error ${result.status} - ${result.statusText}. If you are using the researcher version try restarting your entodicton server. If takes a few minutes to be up.`
+    } else {
+      throw `Error ${result.status} - ${result.statusText}`
+    }
+  }
+}
+
+const setupProcessB = ({ config }) => {
+  const key = config._key
+
+  const data = Object.assign({ key, version: '3' }, config.config)
+  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 Digraph((config.config || {}).hierarchy || [])
+
+  return {
+    data,
+    // generators,
+    // semantics,
+    hierarchy
+  }
+}
+
+// instance template
+const processInstance = (config, instance) => {
+  const transitoryMode = global.transitoryMode
+  global.transitoryMode = false
+  const { /* data, generators, semantics, */ hierarchy } = setupProcessB({ config })
+  for (const results of (instance.resultss || [])) {
+    if (results.extraConfig) {
+      // config.addInternal(results, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false)
+      config.addInternal(results)
+    } else {
+      processContextsB({ config, hierarchy, json: results/*, generators, semantics */ })
+    }
+  }
+  global.transitoryMode = transitoryMode
+}
+
+const _process = async (config, query, { credentials, writeTests, isTest, saveDeveloper, testConfig, testsFN, errorHandler = defaultErrorHandler, beforeQuery } = {}) => {
+  if (credentials) {
+    config.server(credentials.server, credentials.key)
+  }
+  const url = config._server
+  const retries = 2
+  writeTests = !!writeTests
+
+  // ensure same start state
+  try {
+    if (writeTests) {
+      config.rebuild()
+      const objects = getObjects(config.config.objects)(config.uuid)
+      beforeQuery({ query, isModule: false, objects })
+    }
+  } catch(error) {
+    throw error
+  }
+
+  const { data, /* generators, semantics, */ hierarchy } = setupProcessB({ config })
+  let queries = query.split('\\n')
+
+  try {
+    const response = {
+      hierarchy: [],
+      load_cache_time: 0.0,
+      logs: [],
+      metadata: {
+        opChoices: []
+      },
+      times: 0.0,
+      trace: '',
+      contexts: [],
+      generated: [],
+      paraphrases: [],
+      responses: [],
+      associations: [],
+    }
+
+    while (true) {
+      if (queries.length === 0) {
+        break;
+      }
+      data.utterance = queries[0]
+      const json = await doWithRetries(retries, url, data)
+      json.contexts = json.results
+      delete json.results
+      if (json.status !== 200) {
+        throw json
+      } else {
+        const { contextsPrime, generatedPrime, paraphrasesPrime, responsesPrime } =
+                                  processContextsB({ isTest, config, hierarchy, json/*, generators, semantics */ })
+        response.associations = json.associations
+        response.hierarchy = json.hierarchy
+        response.load_cache_time += json.load_cache_time
+        appendNoDups(response.logs, json.logs)
+        response.memory_free_percent = json.memory_free_percent
+        // appendNoDups(response.metadata.associations, json.metadata.associations)
+        // appendNoDups(response.metadata.priorities, json.metadata.priorities)
+        appendNoDups(response.metadata.opChoices, json.metadata.opChoices)
+        response.times += json.times
+        response.trace = response.trace.concat(json.trace)
+        response.version = json.version
+
+        response.contexts = response.contexts.concat(contextsPrime)
+        response.generated = response.generated.concat(generatedPrime)
+        response.paraphrases = response.paraphrases.concat(paraphrasesPrime)
+        response.responses = response.responses.concat(responsesPrime)
+        queries = queries.slice(1)
+      }
+    }
+
+    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)
+    }
+
+    return response
+  } catch(error) {
+      error.query = query
+      throw error
+  }
+}
+
+const getConfigForTest = (config, testConfig) => {
+  const includes = testConfig.include || testConfig.includes
+  if (!includes) {
+    return {}
+  }
+  const configForTest = {}
+  for (const key of Object.keys(includes)) {
+    // configForTest[key] = config.config[key]
+    if (key === 'words') {
+      const words = config.config.words
+      configForTest.words = {}
+      for (const key of Object.keys(words)) {
+        const defs = []
+        for (const def of words[key]) {
+          // TODO handle thie uuids the right way
+          defs.push(Object.assign({}, def, { uuid: undefined }))
+        }
+        configForTest.words[key] = defs
+      }
+    } else if (key === 'operators') {
+      configForTest.operators = config.config.operators.map((operator) => Object.assign({}, operator, { uuid: undefined }))
+    } else if (key === 'bridges') {
+      configForTest.bridges = config.config.bridges.map((bridge) => Object.assign({}, bridge, { uuid: undefined }))
+    } else {
+      configForTest[key] = config.config[key]
+    }
+  }
+  return configForTest
+}
+
+const runTest = async (config, expected, { verbose, beforeQuery, afterTest, testConfig, debug }) => {
+  const test = expected.query
+  // initialize in between test so state is not preserved since the test was adding without state
+  config.rebuild()
+  config.addAssociationsFromTests(config.tests)
+  // config.addAssocationsFromTests(
+  const errorHandler = (error) => {
+    if (error.metadata) {
+      const priorities = analyzeMetaData(expected.metadata, error.metadata)
+      if (priorities.length > 0) {
+        const log = `Hint, if the results are flakey try adding the specified priorities ${JSON.stringify(priorities)}`
+        error.logs.push(log)
+      }
+    }
+    defaultErrorHandler(error)
+  }
+
+  const objects = getObjects(config.config.objects)(config.uuid)
+  beforeQuery({ query: test, isModule: false, objects })
+  config.resetMotivations()
+    try {
+      const result = await _process(config, test, { errorHandler, isTest: true })
+      result.query = test
+      if (debug) {
+        defaultInnerProcess(config, errorHandler, result)
+      }
+      if (verbose) {
+        const widths = [100, 20]
+        const lines = new Lines(widths)
+        lines.setElement(0, 0, test)
+        lines.setElement(0, 1, `time on server ${result.times.toFixed(2)}`)
+        lines.log()
+      }
+      const expected_objects = sortJson(convertToStable(expected.objects), { depth: 25 })
+      const actual_objects = sortJson(convertToStable(config.config.objects), { depth: 25 })
+      const failed_paraphrases = !matching(result.paraphrases, expected.paraphrases)
+      const failed_responses = !matching(result.responses, expected.responses)
+      const failed_contexts = !matching(result.contexts, expected.contexts)
+      const failed_objects = !matching(actual_objects, expected_objects)
+      const actual_config = sortJson(convertToStable(getConfigForTest(config, testConfig)), { depth: 25 })
+      const expected_config = sortJson(convertToStable(expected.config), { depth: 25 })
+      const failed_config = !matching(actual_config, expected_config)
+      let failed = failed_paraphrases || failed_responses || failed_contexts || failed_objects || failed_config
+      if (!failed) {
+        if (afterTest) {
+          failed = afterTest({ query: test, expected, actual: result, config })
+          if (failed) {
+            return {
+              utterance: test,
+              errorFromAfterTest: failed,
+              expected: { responses: expected.responses, paraphrases: expected.paraphrases, results: expected.contexts, objects: expected_objects, config: expected.config },
+              actual: { responses: result.responses, paraphrases: result.paraphrases, results: result.contexts, objects: actual_objects, config: actual_config }
+            }
+          }
+        }
+      }
+
+      if (expected.metadata && result.metadata && failed) {
+        const priorities = analyzeMetaData(expected.metadata, result.metadata)
+        if (priorities.length > 0) {
+          const log = `Hint, if the results are flakey try adding the specified priorities ${JSON.stringify(priorities)}`
+          result.logs.push(log)
+        }
+      }
+      if (failed) {
+        return {
+          utterance: test,
+          expected: { responses: expected.responses, paraphrases: expected.paraphrases, results: expected.contexts, objects: expected_objects, config: expected.config },
+          actual: { responses: result.responses, paraphrases: result.paraphrases, results: result.contexts, objects: actual_objects, config: actual_config }
+        }
+      }
+    } catch(error) {
+      if (verbose) {
+        console.log(test)
+      }
+      if (error.metadata) {
+        const priorities = analyzeMetaData(expected.metadata, error.metadata)
+        if (priorities.length > 0) {
+          const log = `Hint, if the results are flakey try adding the specified priorities ${JSON.stringify(priorities)}`
+          error.logs.push(log)
+        }
+      }
+      throw error
+    }
+}
+
+const runTestsHelper = async (config, tests, failed, juicyBits) => {
+  const { stopAtFirstError } = juicyBits
+  while (true) {
+    if (tests.length === 0) {
+      return Promise.resolve(failed)
+    }
+    const test = tests.shift()
+    const result = await runTest(config, test, juicyBits)
+    if (result != null) {
+      failed.push(result)
+      if (stopAtFirstError) {
+        return failed
+      }
+    }
+  }
+}
+
+const runTests = async (config, testFile, juicyBits) => {
+  const tests = JSON.parse(fs.readFileSync(testFile))
+  const { beforeTests, afterTests } = juicyBits
+  beforeTests()
+  if (juicyBits.verbose) {
+    console.log('\n', testFile, '-----------------------------------------------', '\n')
+  }
+  const v = await runTestsHelper(config, [...tests], [], juicyBits)
+  afterTests()
+  return v
+}
+
+const saveTest = async (testFile, config, test, expected, beforeQuery, testConfig, saveDeveloper) => {
+  config.rebuild()
+  const objects = getObjects(config.config.objects)(config.uuid)
+  config.resetMotivations()
+  beforeQuery({ query: test, isModule: false, objects })
+  console.log(test)
+  const result = await _process(config, test, { isTest: true })
+  // const actualObjects = config.config.objects
+  const actualConfig = getConfigForTest(config, testConfig)
+  writeTest(testFile, test, config.config.objects, result.generated, result.paraphrases, result.responses, result.contexts, result.associations, result.metadata, actualConfig, saveDeveloper)
+}
+
+const saveTestsHelper = async (testFile, config, tests, todo, beforeQuery, testConfig, saveDeveloper) => {
+  if (todo.length === 0) {
+    return
+  }
+  const test = todo.pop()
+  config.rebuild()
+  const result = await saveTest(testFile, config, test, tests[test], beforeQuery, testConfig, saveDeveloper)
+  // initialize in between test so state is not preserved since the test was adding without state
+  // config.initialize({force: true})
+  config.rebuild()
+  return saveTestsHelper(testFile, config, tests, todo, beforeQuery, testConfig, saveDeveloper)
+}
+
+const saveTests = (config, testFile, beforeQuery, testConfig) => {
+  const tests = JSON.parse(fs.readFileSync(testFile))
+  console.log(testFile)
+  return saveTestsHelper(testFile, config, tests, tests.map( (test) => test.query ), beforeQuery, testConfig)
+}
+
+/*
+const showExamples = (testFile) => {
+  const tests = JSON.parse(fs.readFileSync(testFile))
+  Object.keys(tests).forEach((test) => console.log(test))
+}
+*/
+
+const showInfo = (description, section, config) => {
+  const name = config.name
+  const includes = config.configs.slice(1).map((km) => km.config.name)
+  const visibleExamples = []
+  for (const test of config.tests) {
+    if (!test.developerTest) {
+      visibleExamples.push(test.query)
+    }
+  }
+  const info = { name, description, examples: visibleExamples, section, includes, demo: config.demo }
+  if (config.instances.length > 0) {
+    info.template = {
+      base: config.instances[0].base
+    }
+  }
+  console.log(JSON.stringify(info, null, 2))
+}
+
+const submitBugToAPI = async (subscription_id, subscription_password, config) => {
+  console.log('********* Submitting bug *********')
+  const body = { description: config.config.description, config: config.config }
+  // fetch('http://localhost:5000/bug', {
+  fetch('https://thinktelligence.com/api/bug', {
+    method: 'POST',
+    body: JSON.stringify(body),
+    headers: {
+      mode: 'no-cors', // Type of mode of the request
+      'Content-Type': 'application/json', // request content type
+      Authorization: 'Basic ' + base64.encode(subscription_id + ':' + subscription_password)
+    }
+  }).then((result) => result.json())
+    .then((json) => {
+      if (json.status === 404) {
+        console.log(`Error submitting the bug: ${json.status} ${json.statusText}`)
+      } else {
+        console.log(`New bug id id ${json.id}`)
+      }
+    })
+}
+
+const submitBug = async (subscription_id, subscription_password, config, utterance, retries = 2) => {
+  // TODO remove these from the config
+  const properties = ['expected_contexts', 'expected_generated']
+  properties.forEach((property) => {
+    if (!config.get('expected_contexts')) {
+      throw 'Missing property expected_contexts'
+    }
+  })
+
+  return _process(config, utterance)
+    .then((responses) => {
+      let hasError = false
+      if (!matching(responses.contexts, config.config.expected_contexts)) {
+        console.log('JSON does not match')
+        console.log('actual', JSON.stringify(responses.contexts))
+        console.log('expected', JSON.stringify(config.config.expected_contexts))
+        hasError = true
+      }
+      if (!matching(responses.generated, config.config.expected_generated)) {
+        console.log('Generated does not match')
+        console.log('actual', JSON.stringify(responses.generated))
+        console.log('expected', JSON.stringify(config.config.expected_generated))
+        hasError = true
+      }
+
+      if (hasError) {
+        submitBugToAPI(subscription_id, subscription_password, config)
+      } else {
+        throw '\n\n *** The expected contexts matched the generated contexts so the bug was not submitted since its working. ***\n\n:'
+      }
+    })
+    .catch((error) => {
+      console.log('Error', error)
+      throw error
+    })
+}
+
+const defaultErrorHandler = async (error) => {
+  if (error.logs) {
+    console.log('\nlogs: ')
+    for (const log of error.logs) {
+      console.log('\n  ', log)
+    }
+  }
+
+  if (error.trace) {
+    console.log('trace: ', error.trace)
+  }
+
+  if (error.config) {
+    console.log('objects', util.inspect(error.config.get('objects'), { depth: Infinity, sorted: true }))
+  }
+
+  if (error.stack) {
+    console.log('error: ')
+    console.log(error.stack)
+  }
+
+  if (error.errors) {
+    console.log('error: ')
+    for (const e of error.errors) {
+      if (e.logs) {
+        console.log('\nlogs: ')
+        for (const log of e.logs) {
+          console.log('\n  ', log)
+        }
+      }
+      if (e.error) {
+        console.log('\n  ', e.error)
+      } else {
+        console.log('\n  ', e)
+      }
+    }
+  }
+  if (error.error) {
+    console.log('error: ')
+    for (const e of error.error) {
+      console.log('\n  ', e)
+    }
+  }
+
+  if (error.query) {
+    console.log('query: ', error.query)
+  }
+
+  // throw error
+}
+
+const defaultInnerProcess = (config, errorHandler, responses) => {
+  if (responses.errors) {
+    console.log('Errors')
+    responses.errors.forEach((error) => console.log(`    ${error}`))
+  }
+  console.log("KM's loaded", config.configs.map((c) => c.name))
+  console.log('This is the global objects from running semantics:\n', config.objects)
+  if (responses.logs) {
+    console.log('Logs')
+    responses.logs.forEach((log) => console.log(`    ${log}`))
+  }
+  console.log(responses.trace)
+
+  if (global.beforeObjects) {
+    console.log('objects', diffString(global.beforeObjects, config.get('objects')))
+  } else {
+    console.log('objects', util.inspect(config.get('objects'), { depth: Infinity, sorted: true }))
+  }
+  console.log('--- The contexts are ----------')
+  console.log(JSON.stringify(sortJson(responses.contexts, { depth: 25 }), null, 2))
+  console.log('')
+  /*
+  console.log('--- The generated strings are ----------')
+  for (const response of responses.generated) {
+    console.log(response)
+  }
+  */
+  console.log('')
+  const widths = [60, 10, 72]
+  const lines = new Lines(widths)
+  lines.setElement(0, 0, '--- The paraphrases are ----------')
+  lines.setElement(0, 2, '--- The response strings are ----------')
+  lines.log()
+  for (let i = 0; i < responses.paraphrases.length; ++i) {
+    // dont show events
+    if (responses.contexts[i].hidden) {
+      continue
+    }
+    lines.setElement(0, 0, responses.paraphrases[i])
+    if ((responses.responses[i] || []).length > 0) {
+      lines.setElement(0, 2, responses.responses[i])
+    } else {
+      lines.setElement(0, 2, '')
+    }
+    lines.log()
+  }
+}
+
+const defaultProcess = ({ config, errorHandler }) => async (promise) => {
+  try {
+    const responses = await promise
+    defaultInnerProcess(config, errorHandler, responses)
+  } catch(error) { 
+    error.config = config
+    defaultErrorHandler(error)
+  }
+}
+
+/*
+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, beforeQuery, template, errorHandler = defaultErrorHandler }) => {
+  const accumulators = {
+    resultss: [],
+    fragments: [],
+    semantics: [],
+    associations: [],
+  }
+  const looper = (queries) => {
+    if (queries.length === 0) {
+      finish()
+      return
+    }
+    const { property, hierarchy, query: queryOrExtraConfig, skipSemantics } = queries.shift()
+    // queries are strings or { query: "blah", development: true/false }
+    if (typeof queryOrExtraConfig === 'string' || queryOrExtraConfig.query) {
+      let query = queryOrExtraConfig;
+      if (typeof queryOrExtraConfig === 'string') {
+        query = { query }
+      }
+      console.log('query', query.query)
+      config.config.skipSemantics = skipSemantics
+      const transitoryMode = global.transitoryMode
+      if (property == 'fragments') {
+        global.transitoryMode = true
+      }
+      // greg32 
+      // config.addInternal( query )
+      if (hierarchy) {
+        for (let edge of hierarchy) {
+          if (Array.isArray(edge)) {
+            config.addHierarchy(edge[0], edge[1])
+          } else {
+            config.addHierarchy(edge)
+          }
+        }
+      }
+
+      try {
+        const results = _process(config, query.query, { beforeQuery })
+        if (config.config.debug) {
+          // TODO pass in the error handler like the other ones
+          defaultInnerProcess(config, defaultErrorHandler, results)
+        }
+        global.transitoryMode = transitoryMode
+        config.config.skipSemantics = null
+        results.query = query.query
+        results.development = query.development
+        results.key = { query: query.query, hierarchy }
+        accumulators[property].push(results)
+        accumulators.associations = accumulators.associations.concat(results.associations)
+        looper(queries)
+      } catch(e) {
+        const error = { errors: [e], query: query.query };
+        config.config.skipSemantics = null
+        errorHandler(error)
+      }
+    } else {
+      // extra config is def from a time like operators or bridges or words etc
+      // it will just get added to the config
+      const extraConfig = queryOrExtraConfig
+      console.log('config', extraConfig)
+      accumulators[property].push({ extraConfig: true, ...extraConfig })
+      looper(queries)
+    }
+  }
+
+  const finish = () => {
+    const instanceName = `${target}.instance.json`
+    console.log(`Writing instance file ${instanceName}`)
+    const stabilizeAssociations = (associations) => {
+      for (let association of associations) {
+        association.sort()
+      }
+      associations.sort()
+    };
+    const stabilizeOutput = (template) => {
+      stabilizeAssociations(template.associations)
+      const stabilize = (results) => {
+        for (let result of results) {
+          if (result.extraConfig) {
+          } else {
+            delete result.load_cache_time
+            delete result.times
+            delete result.memory_free_percent
+            result.hierarchy.sort()
+            stabilizeAssociations(result.associations)
+          }
+        }
+      }
+      stabilize(template.resultss)
+      stabilize(template.fragments)
+      return template
+    };
+    stabilizeOutput(accumulators)
+    fs.writeFileSync(instanceName, JSON.stringify(Object.assign({ queries: template.queries }, accumulators), 0, 2))
+
+    // km tests file
+    const testsName = `./${target}.test.json`
+    if (!fs.existsSync(testsName)) {
+      console.log(`Writing km file tests file "${testsName}" since it does not exist`)
+      fs.writeFileSync(testsName, JSON.stringify({}, 0, 2))
+    }
+  }
+
+  const toProperties = (queryStringOrProperties) => {
+    if (typeof queryStringOrProperties == 'string') {
+      return { query: queryStringOrProperties}
+    } else {
+      return queryStringOrProperties
+    }
+  }
+  let todo = (template.queries || []).map((query) => { return { property: 'resultss', query, skipSemantics: false } })
+  todo = todo.concat((template.fragments || []).map((query) => { return Object.assign({}, toProperties(query), { property: 'fragments', skipSemantics: false }) }))
+  todo = todo.concat((template.semantics || []).map((definition) => { return { property: 'semantics', query: `${definition.from}\n${definition.to}`, skipSemantics: true } }))
+  looper(Object.assign([], todo))
+}
+
+const knowledgeModule = async ({
+  module: moduleFromJSFile,
+  description,
+  section,
+  config,
+  demo,
+  test,
+  template,
+  errorHandler = defaultErrorHandler,
+  process: processResults = defaultProcess,
+  stopAtFirstFailure = true,
+  beforeQuery = () => {},
+  beforeTests = () => {},
+  afterTests = () => {},
+  beforeTest = () => {},
+  afterTest = () => {}
+} = {}) => {
+
+  const isProcess = require.main === moduleFromJSFile
+  const testConfig = test
+
+  // remove test only stuff
+  if (!isProcess) {
+    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 (!moduleFromJSFile) {
+    throw "'module' is a required parameter. The value should be either 'module' or a lambda that will be called when the file is acting as a module."
+  }
+  if (!config) {
+    throw "'config' is a required parameter. The value should the config that defines the knowledge module."
+  }
+  if (!config.name) {
+    throw "config must have 'name' set to the knowledge module name."
+  }
+  if (!description) {
+    throw "'description' is a required parameter. The value should the description of the knowledge module."
+  }
+  if (!test) {
+    throw "'test' is a required parameter. The value should the path to the file used to store the tests of the knowledge module and the contents of the file in the form { name: <filePath>, contexts: <json> }."
+  }
+
+  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' && test.contents) {
+    config.tests = test.contents
+    test = test.name
+  } else {
+    if (fs && fs.existsSync(test)) {
+      config.tests = JSON.parse(fs.readFileSync(test))
+    } else {
+      config.tests = {}
+    }
+  }
+ 
+  if (!isProcess) {
+    if (template) {
+      if (config.needsRebuild(template.template, template.instance)) {
+        throw `This module "${config.name}" cannot be used because the instance file needs rebuilding. Run on the command line with no arguements or the -rt argument to rebuild.`
+      }
+      config.load(template.template, template.instance)
+    }
+  }
+
+  if (isProcess) {
+    // setup();
+    const parser = new ArgumentParser({
+      description: 'Entodicton knowledge module'
+    })
+
+    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('-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' })
+    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('-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('-qd', '--queryDelete', { help: 'Delete the specified query from the tests file' })
+    parser.add_argument('-c', '--clean', { help: 'Remove data from the test files. a === association' })
+    parser.add_argument('-od', '--objectDiff', { action: 'store_true', help: 'When showing the objects use a colour diff' })
+    parser.add_argument('-daa', '--dontAddAssociations', { action: 'store_true', help: 'Do not add associations from the tests.' })
+    parser.add_argument('-p', '--print', { help: 'Print the specified elements c === config, w === words, b === bridges, o === operators d === objects (d for data), h === hierarchy, g === generators, s === semantics, l === load t=tests ordering p === priorities a == associations j == JSON sent to server. for example --print wb' })
+    parser.add_argument('-s', '--save', { action: 'store_true', help: 'When running with the --query flag this will save the current run to the test file. When running without the --query flag all tests will be run and resaved.' })
+    parser.add_argument('-sd', '--saveDeveloper', { action: 'store_true', help: 'Same as -s but the query will not show up in the info command.' })
+    parser.add_argument('-d', '--debug', { action: 'store_true', help: 'When running with the --debug flag this set the debug flag in the config' })
+    parser.add_argument('-da', '--debugAssociation', { help: 'When running with the --debugAssociation flag the debugging will break when the specified association is added to the config' })
+    parser.add_argument('-dh', '--debugHierarchy', { help: 'When running with the --debugHierarchy flag the debugging will break when the specified child-parent pair is added to the config for the main config. Set DEBUG_HIERARCHY to debug any config loaded. For example DEBUG_HIERARCHY=\'["cat", "mammel"]\'' })
+    parser.add_argument('-db', '--debugBridge', { help: 'When running with the --debugBridge flag the debugging will break when the specified bridge is added to the config for the main config. Set DEBUG_BRIDGE to debug any config loaded. For example DEBUG_BRIDGE=\'id/level\'' })
+
+    const args = parser.parse_args()
+    args.count = args.count || 1
+
+    if (args.debugAssociation) {
+      global.entodictonDebugAssociation = JSON.parse(args.debugAssociation)
+    }
+    if (args.debugHierarchy) {
+      global.entodictonDebugHierarchy = JSON.parse(args.debugHierarchy)
+    }
+    if (args.debugBridge) {
+        // id/level
+      global.entodictonDebugBridge = args.debugBridge.split('/')
+      if (global.entodictonDebugBridge.length !== 2) {
+        console.log('Expected DEBUG_BRIDGE to be of the form "id/level"');
+      }
+    }
+
+    if (args.clean) {
+      const tests = JSON.parse(fs.readFileSync(testConfig.name))
+      for (let test of tests) {
+        delete test.associations
+      }
+      writeTestFile(testConfig.name, tests)
+      console.log(`Cleaned ${testConfig.name}`)
+      return
+    }
+
+    if (args.queryDelete) {
+      let tests = JSON.parse(fs.readFileSync(testConfig.name))
+      tests = tests.filter( (test) => test.query !== args.queryDelete );
+      writeTestFile(testConfig.name, tests)
+      console.log(`Remove the test for "${args.queryDelete}"`)
+      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.debug) {
+      config.config.debug = true
+    }
+
+    if (template) {
+      const needsRebuild = config.needsRebuild(template.template, template.instance, options)
+      if (needsRebuild) {
+        console.log(`This module "${config.name}" needs rebuilding all other arguments will be ignored. Try again after the template is rebuilt.`)
+
+      }
+      config.load(template.template, template.instance, { rebuild: needsRebuild })
+      if (needsRebuild) {
+        return
+      }
+    }
+
+    if (!args.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 })
+      }
+    }
+    */
+
+    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('w')) {
+        for (const word in config.config.words) {
+          console.log(word.concat('          ', ...config.config.words[word].map((def) => JSON.stringify(def))))
+        }
+      }
+      if (args.print.includes('b')) {
+        for (const bridge of config.config.bridges) {
+          console.log(JSON.stringify(bridge))
+        }
+      }
+      if (args.print.includes('o')) {
+        for (const operator of config.config.operators) {
+          console.log(JSON.stringify(operator))
+        }
+      }
+      if (args.print.includes('j')) {
+        const { data } = setupProcessB( { config } )
+        console.log(JSON.stringify(data, null, 2))
+      }
+      if (args.print.includes('a')) {
+        console.log('associations ================')
+        const properties = ['negative', 'positive']
+        for (let property of properties) {
+          console.log(`  ${property} ===============`)
+          for (let association of config.config.associations[property]) {
+            console.log(`  ${JSON.stringify(association)}`)
+          }
+        }
+      }
+      if (args.print.includes('d')) {
+        console.log(JSON.stringify(config.config.objects, null, 2))
+      }
+      if (args.print.includes('p')) {
+        for (let priority of config.config.priorities) {
+          console.log(JSON.stringify(priority))
+        }
+      }
+      if (args.print.includes('h')) {
+        for (let edge of config.config.hierarchy) {
+          console.log(JSON.stringify(edge))
+        }
+      }
+      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()
+        }
+        console.dir(easyToRead)
+      }
+      if (args.print.includes('s')) {
+        const easyToRead = _.cloneDeep(config.config.semantics)
+        for (const semantic of easyToRead) {
+          semantic.match = semantic.match.toString()
+          semantic.apply = semantic.apply.toString()
+        }
+        console.dir(easyToRead)
+      }
+    }
+
+    if (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, beforeQuery, testConfig, args.saveDeveloper)
+    // } else if (args.build) {
+    // build({ config, target: args.build, beforeQuery, errorHandler })
+    } 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) => {
+          if (n === 0) {
+            return
+          }
+          runTests(config, test, { debug: args.debug, testConfig: testConfig, verbose: args.testVerbose || args.testAllVerbose, stopAtFirstError: !args.testAllVerbose, beforeQuery, beforeTests, afterTests, beforeTest, afterTest }).then((results) => {
+            if (results.length > 0 && args.vimdiff) {
+              for (const result of results) {
+                vimdiff(result.expected, result.actual)
+              }
+            }
+            if (results.length > 0) {
+              let headerShown = false
+              console.log('**************************** ERRORS ************************')
+              for (const result of results) {
+                console.log('Utterance: ', result.utterance)
+                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)
+
+                  headerShown = true
+                }
+                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)
+                  headerShown = true
+                }
+              }
+              if (!headerShown) {
+                console.log('There are failures due to things other than paraphrases and response 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.')
+              }
+              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))
+              console.log('**************************** ERRORS ************************')
+            }
+            // const contexts = { failures: results }
+            l(n - 1)
+          }).catch((error) => {
+            errorHandler(error)
+          })
+        }
+        l(args.count)
+      } else {
+        test()
+      }
+    } else if (args.loop) {
+      const readline = require('readline').createInterface({ input: process.stdin, output: process.stdout })
+      const f = () => readline.question('Enter query? (newline to quit) ', query => {
+        query = query.trim()
+        if (query.length === 0) {
+          return readline.close()
+        }
+        // const promise = processResults(_process(config, query, { testsFN: test }))
+        const promise = _process(config, query, { testsFN: test }).then((results) => {
+          console.log(results.responses.join(' '))
+        })
+        if (!('then' in promise)) {
+          throw 'Return a promise from process in the definition of knowledgeModule'
+        }
+        promise.then(() => f()).catch( (e) => f() )
+      })
+      f()
+    } else if (args.query) {
+      const objects = getObjects(config.config.objects)(config.uuid)
+      // for the compare
+      if (args.objectDiff) {
+        global.beforeObjects = _.cloneDeep(objects)
+      }
+      beforeQuery({ query: args.query, isModule: false, objects })
+      try {
+        processResults(_process(config, args.query, { dontAddAssociations: args.dontAddAssociations, writeTests: args.save || args.saveDeveloper, saveDeveloper: args.saveDeveloper, testConfig, testsFN: test, beforeQuery }))
+      } catch( error ) {
+        console.log('Error', error);
+      }
+    }
+  } else {
+    config.addAssociationsFromTests(config.tests);
+    //for (let query in config.tests) {
+    //  config.addAssociations(config.tests[query].associations || []);
+    //}
+    module()
+  }
+}
+
+/*
+const test = (name) => {
+  return {
+    test: test,
+    contents: require(name)
+  }
+}
+*/
+
+const ensureTestFile = (module, name, type) => {
+  const isProcess = require.main === module
+  if (isProcess) {
+    const fn = `./${name}.${type}.json`
+    if (!fs.existsSync(fn)) {
+      console.log('writing')
+      fs.writeFileSync(fn, '[]')
+    }
+  }
+}
+
+function where(goUp = 2) {
+  const e = new Error();
+  const regexForm1 = /\((.*):(\d+):(\d+)\)$/
+  const regexForm2 = /at (.*):(\d+):(\d+)$/
+  const line = e.stack.split("\n")[goUp];
+  const match = regexForm1.exec(line) || regexForm2.exec(line);
+  return `${match[1]}:${match[2]}`
+}
+
+function w(func) {
+  func.where = where(3)
+  return func
+}
+
+module.exports = {
+  process: _process,
+  where,
+  w,
+  submitBug,
+  ensureTestFile,
+  build,
+  processContext,
+  processContexts,
+  runTests,
+  knowledgeModule,
+  Semantics,
+  Semantic,
+  Generators,
+  Generator,
+  Digraph,
+  analyzeMetaData,
+  processContextsB,
+  processInstance,
+  gs,
+  flattens,
+  writeTest
+}