theprogrammablemind_4wp 7.10.0-beta.9 → 7.10.1-beta.0

package/client.js

@@ -1,5 +1,3 @@
-"use strict"
-
 const { Semantics, Semantic } = require('./src/semantics')
 const { Generators, Generator } = require('./src/generators')
 const DigraphInternal = require('./src/digraph_internal')
@@ -34,7 +32,7 @@ const pickObjects = (testConfig, objects) => {
 
 // move ask to the KM's since verbatim is called
 const getAsk = (config) => (uuid) => (asks) => {
-  for (let ask of asks) {
+  for (const ask of asks) {
     let oneShot = true // default
     if (ask.oneShot === false) {
       oneShot = false
@@ -47,41 +45,41 @@ const getAsk = (config) => (uuid) => (asks) => {
     })
   }
   let oneShot = true
-  for (let ask of asks) {
+  for (const ask of asks) {
     if (ask.oneShot === false) {
       oneShot = false
     }
   }
   config.addSemantic({
-      uuid,
-      oneShot,
-      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)
-            }
+    uuid,
+    oneShot,
+    match: ({ context }) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
+    apply: (args) => {
+      for (const 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.verbatim(applyq(args))
-            /*
+        }
+        if (matchq(args)) {
+          // args.context.motivationKeep = true
+          args.verbatim(applyq(args))
+          /*
             args.context.verbatim = applyq(args)
             args.context.isResponse = true;
             delete args.context.controlRemove;
             */
-            args.context.controlKeepMotivation = true;
-            break
-          }
+          args.context.controlKeepMotivation = true
+          break
         }
-        args.context.cascade = true
       }
+      args.context.cascade = true
+    }
   })
 }
 
@@ -102,7 +100,7 @@ const vimdiff = (actualJSON, expectedJSON) => {
     const editor = runtime.process.env.EDITOR || 'vimdiff'
     // const child = runtime.child_process.spawn(editor, [`${path}/expected.json`, `${path}/actual.json`], { stdio: 'inherit' })
     console.log(`${editor} ${path}/expected.json ${path}/actual.json`)
-    runtime.child_process.execSync(`${editor} ${path}/expected.json ${path}/actual.json`, {stdio: 'inherit'})
+    runtime.child_process.execSync(`${editor} ${path}/expected.json ${path}/actual.json`, { stdio: 'inherit' })
   }
 }
 
@@ -142,10 +140,10 @@ const asList = (context) => {
 }
 
 class ErrorReason extends Error {
-   constructor(context) {
-     super(JSON.stringify(context))
-     this.reason = context
-   }
+  constructor (context) {
+    super(JSON.stringify(context))
+    this.reason = context
+  }
 }
 
 const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
@@ -180,7 +178,7 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
     }
   }
   args.getUUIDScoped = (uuid) => {
-    return { 
+    return {
       ask: scopedAsk(uuid),
       api: getAPI(uuid),
       apis: getAPIs(uuid)
@@ -206,10 +204,10 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
       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})
+      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 })
+      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)
@@ -226,7 +224,7 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
 const gs = (g) => (contexts, separator, lastSeparator) => {
   if (!Array.isArray(contexts)) {
     debugger
-    throw new Error("Expected a list")
+    throw new Error('Expected a list')
   }
 
   let s = ''
@@ -290,10 +288,10 @@ const processContexts = (contexts, params) => {
 
 const getObjects = (objects) => {
   return (uuid) => {
-      if (objects && objects.namespaced) {
-        return objects.namespaced[uuid]
-      }
-      return objects
+    if (objects && objects.namespaced) {
+      return objects.namespaced[uuid]
+    }
+    return objects
   }
 }
 
@@ -318,7 +316,7 @@ const processContext = (context, { objects = {}, config, logs = [] }) => {
   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 })
+  const paraphrases = generators.apply({ ...args, assumed }, context, { paraphrase: true, response: false, isResponse: false })
   let responses = []
   if (context.isResponse) {
     responses = generated
@@ -343,7 +341,7 @@ const convertToStable = (objects) => {
 
 const writeTestFile = (fn, tests) => {
   const stabilize = (tests) => {
-    for (let test of tests) {
+    for (const test of tests) {
       for (opChoice of test.metadata.opChoices) {
         opChoice.ops.sort()
       }
@@ -359,30 +357,31 @@ const writeTest = (fn, query, objects, generated, paraphrases, responses, contex
   if (runtime.fs.existsSync(fn)) {
     tests = JSON.parse(runtime.fs.readFileSync(fn))
   }
-  for (let association of associations) {
+  for (const association of associations) {
     association.sort()
   }
   associations.sort()
   // tests[query] = sortJson({ paraphrases, responses, contexts, objects: convertToStable(objects), associations, metadata, config, developerTest: saveDeveloper }, { depth: 25 })
-  const results = sortJson({ 
-    query, 
-    paraphrases, 
-    responses, 
-    contexts, 
-    objects: convertToStable(objects), 
-    associations, 
-    metadata, 
-    config, 
-    developerTest: saveDeveloper, 
-    paraphrasesParenthesized, 
-    generatedParenthesized }, { depth: 25 })
-  let wasSet = false;
-  tests.forEach( (test, index) => {
+  const results = sortJson({
+    query,
+    paraphrases,
+    responses,
+    contexts,
+    objects: convertToStable(objects),
+    associations,
+    metadata,
+    config,
+    developerTest: saveDeveloper,
+    paraphrasesParenthesized,
+    generatedParenthesized
+  }, { depth: 25 })
+  let wasSet = false
+  tests.forEach((test, index) => {
     if (test.query == query) {
       tests[index] = results
       wasSet = true
     }
-  });
+  })
   if (!wasSet) {
     tests.push(results)
   }
@@ -391,7 +390,7 @@ const writeTest = (fn, query, objects, generated, paraphrases, responses, contex
 }
 
 const combineRange = (r1, r2) => {
-  let start = r2.start;
+  let start = r2.start
   if (r1.start < r2.start) {
     start = r1.start
   }
@@ -404,14 +403,14 @@ const combineRange = (r1, r2) => {
 
 const overlaps = (r1, context) => {
   if (!context.range) {
-    return true;
+    return true
   }
   const r2 = context.range
   if (r1.start <= r2.end && r1.start >= r2.start) {
-    return true;
+    return true
   }
   if (r1.end <= r2.end && r1.end >= r2.start) {
-    return true;
+    return true
   }
   return false
 }
@@ -450,7 +449,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
   setupArgs(args, config, json.logs, hierarchy)
   const toDo = [...contexts]
   args.insert = (context) => toDo.unshift(context)
-  let overlap, lastRange;
+  let overlap, lastRange
   config.debugLoops = commandLineArgs && commandLineArgs.debugLoops
   while (toDo.length > 0) {
     const context = toDo.shift()
@@ -466,7 +465,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
         const semantics = config.getSemantics(json.logs)
         try {
           contextPrime = semantics.apply(args, context)
-        } catch( e ) {
+        } 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`
@@ -475,36 +474,36 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
           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
-              })
+          contextPrime = semantics.apply(args, {
+            marker: 'error',
+            context,
+            text: e ? e.toString() : 'not available',
+            reason: e.reason,
+            error: e.stack || e.error
+          })
         }
       }
       if (contextPrime.controlRemove) {
         continue
       }
-      let assumed = { isResponse: true };
-      const generated = contextPrime.isResponse ? config.getGenerators(json.logs).apply({...args, assumed}, contextPrime, assumed) : ''
+      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) : ''
+        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 };
+      assumed = { paraphrase: true, isResponse: false, response: false }
       if (generateParenthesized) {
         config.parenthesized = false
       }
-      const paraphrases = config.getGenerators(json.logs).apply({...args, assumed}, contextPrime, assumed)
+      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)
+        paraphrasesParenthesized = config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
         config.parenthesized = false
       }
       contextsPrime.push(contextPrime)
@@ -580,7 +579,7 @@ const doWithRetries = async (n, url, queryParams, data) => {
   }
 }
 
-const setupProcessB = ({ config, initializer, allowDelta=false } = {}) => {
+const setupProcessB = ({ config, initializer, allowDelta = false } = {}) => {
   const key = config._key
 
   const data = Object.assign({ key, version: '3' }, { uuid: config._uuid })
@@ -593,8 +592,8 @@ const setupProcessB = ({ config, initializer, allowDelta=false } = {}) => {
   }
 
   // config.toServer(data)
- 
-  if (data.namespaces) { 
+
+  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
@@ -639,7 +638,7 @@ const loadInstance = (config, instance) => {
       // config.addInternal(results, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false)
       // config.addInternal(config.template.queries[i], { handleCalculatedProps: true } )
       const uuid = config.nameToUUID(instance.name)
-      config.addInternal(instance.template.queries[i], { uuid, addFirst: true, handleCalculatedProps: true } )
+      config.addInternal(_.cloneDeep(instance.template.queries[i]), { uuid, addFirst: true, handleCalculatedProps: true })
     } else if (results.apply) {
       const objects = config.get('objects')
       const args = { objects, getObjects: getObjects(objects) }
@@ -688,7 +687,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
       config.rebuild()
       const objects = getObjects(config.config.objects)(config.uuid)
     }
-  } catch(error) {
+  } catch (error) {
     throw error
   }
 
@@ -718,12 +717,12 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
       paraphrasesParenthesized: [],
       generatedParenthesized: [],
       responses: [],
-      associations: [],
+      associations: []
     }
 
     while (true) {
       if (queries.length === 0) {
-        break;
+        break
       }
 
       data.utterance = queries[0]
@@ -789,18 +788,18 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
 
     if (writeTests) {
       const actual_config = getConfigForTest(config, testConfig)
-      const saveObjects = {...config.config.objects}
+      const saveObjects = { ...config.config.objects }
       saveObjects.nameToUUID = {}
-      for (let km of config.configs) {
+      for (const km of config.configs) {
         saveObjects.nameToUUID[km.name] = km.uuid
       }
       writeTest(testsFN, query, saveObjects, response.generated, response.paraphrases, response.responses, response.contexts, response.associations, response.metadata, actual_config, saveDeveloper, response.paraphrasesParenthesized, response.generatedParenthesized)
     }
 
     return response
-  } catch(error) {
-      error.query = query
-      errorHandler(error)
+  } catch (error) {
+    error.query = query
+    errorHandler(error)
   }
 }
 
@@ -855,110 +854,110 @@ const runTest = async (config, expected, { args, verbose, testConfig, debug }) =
     objects = getObjects(config.config.objects)(config.getConfigs()[testConfig.testModuleName].uuid)
     testConfigName = testConfig.testModuleName
   }
-    try {
-      const result = await _process(config, test, { errorHandler, isTest: true })
-      result.query = test
-      if (debug) {
-        defaultInnerProcess(config, errorHandler, result)
-      }
-      if (verbose) {
-        const widths = [100, 60]
-        const lines = new Lines(widths)
-        lines.setElement(0, 0, test)
-        lines.setElement(0, 1, `time on server: ${result.times.toFixed(2)} client: ${(result.clientSideTimes/1000).toFixed(2)}`)
-        lines.log()
-      }
-      const expected_objects = sortJson(convertToStable(expected.objects), { depth: 25 })
-      delete expected_objects.nameToUUID
-      const actual_objects = sortJson(convertToStable(config.config.objects), { depth: 25 })
-      const failed_paraphrases = !matching(result.paraphrases, expected.paraphrases)
-      let failed_paraphrasesParenthesized = !matching(result.paraphrasesParenthesized, expected.paraphrasesParenthesized)
-      let failed_generatedParenthesized = !matching(result.generatedParenthesized, expected.generatedParenthesized)
-      // TODO fix the naming conventions: camelcase + use actual instead of result
-      const failed_responses = !matching(result.responses, expected.responses)
-      const failed_contexts = !matching(result.contexts, expected.contexts)
-      const failed_objects = !matching(actual_objects, expected_objects)
-
-      if (args.testNoParenthesized) {
-        failed_paraphrasesParenthesized = false
-        failed_generatedParenthesized = false
-      }
-
-      const pickedResultContexts = result.contexts.map(pickContext(testConfig))
-      const pickedExpectedContexts = expected.contexts.map(pickContext(testConfig))
-      const failedCheckedContexts = !matching(pickedResultContexts, pickedExpectedContexts)
-
-      const expectedGetObjects = (name) => {
-        if (!name) {
-          name = config.name
-        }
-        return expected.objects.namespaced[expected.objects.nameToUUID[name]] || {}
-      }
-      const expected_checked = sortJson(pickObjects(testConfig, expectedGetObjects(testConfigName)), { depth: 25 })
-      const actualGetObjects = (name) => {
-        if (!name) {
-          name = config.name
-        }
-        const km = config.configs.find( (km) => km.name == name )
-        return config.config.objects.namespaced[km.uuid] || {}
-      }
-      const actual_checked = sortJson(pickObjects(testConfig, actualGetObjects(testConfigName)), { depth: 25 })
-      const failed_checked = !matching(actual_objects, expected_objects)
-
-      const failed_checks = !matching(actual_objects, expected_objects)
-      const failed_checked_objects = !matching(actual_checked, expected_checked)
-      const actual_config = sortJson(convertToStable(getConfigForTest(config, testConfig)), { depth: 25 })
-      const expected_config = sortJson(convertToStable(expected.config), { depth: 25 })
-      const failed_config = !matching(actual_config, expected_config)
-      let failed = failed_checked_objects || failed_paraphrases || failed_paraphrasesParenthesized || failed_generatedParenthesized || failed_responses || failed_contexts || failed_objects || failed_config || failed_checked || failedCheckedContexts
-
-      if (expected.metadata && result.metadata && failed) {
-        const priorities = analyzeMetaData(expected.metadata, result.metadata)
-        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, 
-            paraphrasesParenthesized: expected.paraphrasesParenthesized, 
-            generatedParenthesized: expected.generatedParenthesized, 
-            results: expected.contexts, 
-            checked: expected_checked, 
-            checkedContexts: pickedExpectedContexts,
-            objects: expected_objects, 
-            config: expected.config 
-          },
-          actual: { 
-            responses: result.responses, 
-            paraphrases: result.paraphrases, 
-            paraphrasesParenthesized: result.paraphrasesParenthesized, 
-            generatedParenthesized: result.generatedParenthesized, 
-            results: result.contexts, 
-            checked: actual_checked, 
-            checkedContexts: pickedResultContexts,
-            objects: actual_objects, 
-            config: actual_config 
-          }
+  try {
+    const result = await _process(config, test, { errorHandler, isTest: true })
+    result.query = test
+    if (debug) {
+      defaultInnerProcess(config, errorHandler, result)
+    }
+    if (verbose) {
+      const widths = [100, 60]
+      const lines = new Lines(widths)
+      lines.setElement(0, 0, test)
+      lines.setElement(0, 1, `time on server: ${result.times.toFixed(2)} client: ${(result.clientSideTimes / 1000).toFixed(2)}`)
+      lines.log()
+    }
+    const expected_objects = sortJson(convertToStable(expected.objects), { depth: 25 })
+    delete expected_objects.nameToUUID
+    const actual_objects = sortJson(convertToStable(config.config.objects), { depth: 25 })
+    const failed_paraphrases = !matching(result.paraphrases, expected.paraphrases)
+    let failed_paraphrasesParenthesized = !matching(result.paraphrasesParenthesized, expected.paraphrasesParenthesized)
+    let failed_generatedParenthesized = !matching(result.generatedParenthesized, expected.generatedParenthesized)
+    // TODO fix the naming conventions: camelcase + use actual instead of result
+    const failed_responses = !matching(result.responses, expected.responses)
+    const failed_contexts = !matching(result.contexts, expected.contexts)
+    const failed_objects = !matching(actual_objects, expected_objects)
+
+    if (args.testNoParenthesized) {
+      failed_paraphrasesParenthesized = false
+      failed_generatedParenthesized = false
+    }
+
+    const pickedResultContexts = result.contexts.map(pickContext(testConfig))
+    const pickedExpectedContexts = expected.contexts.map(pickContext(testConfig))
+    const failedCheckedContexts = !matching(pickedResultContexts, pickedExpectedContexts)
+
+    const expectedGetObjects = (name) => {
+      if (!name) {
+        name = config.name
+      }
+      return expected.objects.namespaced[expected.objects.nameToUUID[name]] || {}
+    }
+    const expected_checked = sortJson(pickObjects(testConfig, expectedGetObjects(testConfigName)), { depth: 25 })
+    const actualGetObjects = (name) => {
+      if (!name) {
+        name = config.name
+      }
+      const km = config.configs.find((km) => km.name == name)
+      return config.config.objects.namespaced[km.uuid] || {}
+    }
+    const actual_checked = sortJson(pickObjects(testConfig, actualGetObjects(testConfigName)), { depth: 25 })
+    const failed_checked = !matching(actual_objects, expected_objects)
+
+    const failed_checks = !matching(actual_objects, expected_objects)
+    const failed_checked_objects = !matching(actual_checked, expected_checked)
+    const actual_config = sortJson(convertToStable(getConfigForTest(config, testConfig)), { depth: 25 })
+    const expected_config = sortJson(convertToStable(expected.config), { depth: 25 })
+    const failed_config = !matching(actual_config, expected_config)
+    const failed = failed_checked_objects || failed_paraphrases || failed_paraphrasesParenthesized || failed_generatedParenthesized || failed_responses || failed_contexts || failed_objects || failed_config || failed_checked || failedCheckedContexts
+
+    if (expected.metadata && result.metadata && failed) {
+      const priorities = analyzeMetaData(expected.metadata, result.metadata)
+      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,
+          paraphrasesParenthesized: expected.paraphrasesParenthesized,
+          generatedParenthesized: expected.generatedParenthesized,
+          results: expected.contexts,
+          checked: expected_checked,
+          checkedContexts: pickedExpectedContexts,
+          objects: expected_objects,
+          config: expected.config
+        },
+        actual: {
+          responses: result.responses,
+          paraphrases: result.paraphrases,
+          paraphrasesParenthesized: result.paraphrasesParenthesized,
+          generatedParenthesized: result.generatedParenthesized,
+          results: result.contexts,
+          checked: actual_checked,
+          checkedContexts: pickedResultContexts,
+          objects: actual_objects,
+          config: actual_config
         }
       }
-    } catch(error) {
-      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)
-        }
+    }
+  } 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
     }
+    throw error
+  }
 }
 
 const runTestsHelper = async (config, tests, failed, juicyBits) => {
@@ -996,9 +995,9 @@ const saveTest = async (testFile, config, test, expected, testConfig, saveDevelo
   const actualConfig = getConfigForTest(config, testConfig)
   const args = {
   }
-  const saveObjects = {...config.config.objects}
+  const saveObjects = { ...config.config.objects }
   saveObjects.nameToUUID = {}
-  for (let km of config.configs) {
+  for (const km of config.configs) {
     saveObjects.nameToUUID[km.name] = km.uuid
   }
   writeTest(testFile, test, saveObjects, result.generated, result.paraphrases, result.responses, result.contexts, result.associations, result.metadata, actualConfig, saveDeveloper, result.paraphrasesParenthesized, result.generatedParenthesized)
@@ -1020,7 +1019,7 @@ const saveTestsHelper = async (testFile, config, tests, todo, testConfig, saveDe
 const saveTests = (config, testFile, testConfig) => {
   const tests = JSON.parse(runtime.fs.readFileSync(testFile))
   console.log(testFile)
-  return saveTestsHelper(testFile, config, tests, tests.map( (test) => test.query ), testConfig)
+  return saveTestsHelper(testFile, config, tests, tests.map((test) => test.query), testConfig)
 }
 
 /*
@@ -1147,7 +1146,7 @@ const defaultErrorHandler = async (error) => {
     doErrorExit = true
   }
 
-  if (typeof runtime.process.exit == 'function' && doErrorExit) {
+  if (typeof runtime.process.exit === 'function' && doErrorExit) {
     runtime.process.exit(-1)
   }
 
@@ -1166,7 +1165,7 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
     for (const lcp of responses.learned_contextual_priorities) {
       console.log(`  ${JSON.stringify(lcp)},\n`)
     }
-    console.log("\n")
+    console.log('\n')
   }
   if (responses.logs) {
     console.log('Logs')
@@ -1182,8 +1181,8 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
 
   const pickEm = () => {
     const picked = {}
-    const namespaced = config.get('objects')['namespaced']
-    for (let prop of getConfig_getObjectCheck(config.testConfig)) {
+    const namespaced = config.get('objects').namespaced
+    for (const prop of getConfig_getObjectCheck(config.testConfig)) {
       if (prop.km) {
         /*
         const objects = namespaced[prop.km]]
@@ -1205,7 +1204,7 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
   }
 
   if (responses.explain_priorities) {
-    console.log("Explain Priorities")
+    console.log('Explain Priorities')
     for ([inputs, output, reason] of responses.explain_priorities) {
       console.log(`    inputs: ${JSON.stringify(inputs)} output: ${JSON.stringify(output)}  reason: ${reason}`)
     }
@@ -1218,7 +1217,7 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
   }
 
   const pickedResultContexts = responses.contexts.map(pickContext(config.testConfig))
-  if (pickedResultContexts.some( (context) => Object.keys(context).length > 0 )) {
+  if (pickedResultContexts.some((context) => Object.keys(context).length > 0)) {
     console.log('--- Contexts showing only the checked values ---')
     console.log(JSON.stringify(pickedResultContexts, null, 2))
   }
@@ -1257,7 +1256,7 @@ const defaultProcess = ({ config, errorHandler }) => async (promise) => {
   try {
     const responses = await promise
     defaultInnerProcess(config, errorHandler, responses)
-  } catch(error) { 
+  } catch (error) {
     error.config = config
     defaultErrorHandler(error)
   }
@@ -1270,7 +1269,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
     fragments: [],
     semantics: [],
     associations: [],
-    learned_contextual_priorities: [],
+    learned_contextual_priorities: []
   }
   const looper = async (queries) => {
     if (queries.length === 0) {
@@ -1280,7 +1279,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
     const { property, hierarchy, query: queryOrExtraConfig, previousResults, initializer, skipSemantics } = queries.shift()
     // queries are strings or { query: "blah", development: true/false }
     if (typeof queryOrExtraConfig === 'string' || queryOrExtraConfig.query) {
-      let query = queryOrExtraConfig;
+      let query = queryOrExtraConfig
       if (typeof queryOrExtraConfig === 'string') {
         query = { query }
       }
@@ -1290,7 +1289,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
         global.transitoryMode = true
       }
       if (hierarchy) {
-        for (let edge of hierarchy) {
+        for (const edge of hierarchy) {
           if (Array.isArray(edge)) {
             config.addHierarchy(edge[0], edge[1])
           } else {
@@ -1306,7 +1305,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
           prMessage = ' Using previous results. use -rtf for a hard rebuild of everything on the server side.'
           loadInstance(config, { resultss: [results] })
         } else {
-          results = await _process(config, query.query, {initializer, rebuildingTemplate: true})
+          results = await _process(config, query.query, { initializer, rebuildingTemplate: true })
         }
         if (config.config.debug) {
           // TODO pass in the error handler like the other ones
@@ -1330,12 +1329,12 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
         accumulators.associations = accumulators.associations.concat(results.associations)
         accumulators.learned_contextual_priorities = accumulators.learned_contextual_priorities.concat(results.learned_contextual_priorities)
         await looper(queries)
-      } catch(e) {
-        const error = { errors: [e], query: query.query };
+      } catch (e) {
+        const error = { errors: [e], query: query.query }
         config.config.skipSemantics = null
         errorHandler(error)
       }
-    } else if (typeof queryOrExtraConfig == 'function') {
+    } else if (typeof queryOrExtraConfig === 'function') {
       console.log('calling initialize function')
       const initFunction = queryOrExtraConfig
       const objects = config.get('objects')
@@ -1353,8 +1352,8 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
         await looper([])
       } else {
         try {
-          config.addInternal(_.cloneDeep(extraConfig), { handleCalculatedProps: true } )
-        } catch ( e ) {
+          config.addInternal(_.cloneDeep(extraConfig), { handleCalculatedProps: true })
+        } catch (e) {
           const where = extraConfig.where ? ` ${extraConfig.where}` : ''
           throw new Error(`Error processing extra config${where}: ${e.stack}}`)
         }
@@ -1368,11 +1367,11 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
     const instanceName = `${target}.instance.json`
     console.log(`Writing instance file ${instanceName}`)
     const stabilizeAssociations = (associations) => {
-      for (let association of associations) {
+      for (const association of associations) {
         association.sort()
       }
       associations.sort()
-    };
+    }
     const stabilizeOutput = (template) => {
       stabilizeAssociations(template.associations)
       const stabilize = (results) => {
@@ -1397,7 +1396,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
       stabilize(template.resultss)
       stabilize(template.fragments)
       return template
-    };
+    }
     stabilizeOutput(accumulators)
     runtime.fs.writeFileSync(instanceName, JSON.stringify(Object.assign({ queries: template.queries.map(updateQueries) }, accumulators), 0, 2))
 
@@ -1410,7 +1409,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
   }
 
   const toProperties = (queryStringOrProperties) => {
-    if (typeof queryStringOrProperties == 'string') {
+    if (typeof queryStringOrProperties === 'string') {
       return { query: queryStringOrProperties }
     } else {
       return queryStringOrProperties
@@ -1418,12 +1417,12 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
   }
   let todo = []
   todo = todo.concat((template.initializers || []).map((query) => { return { initializer: true, property: 'resultss', query, skipSemantics: false || query.skipSemantics } }))
-  todo = todo.concat((template.queries || []).map((query, index) => { 
+  todo = todo.concat((template.queries || []).map((query, index) => {
     let pr
     if (index < startOfChanges) {
-      pr = previousResultss[index] 
+      pr = previousResultss[index]
     }
-    return { property: 'resultss', query, previousResults: pr, skipSemantics: false || query.skipSemantics} 
+    return { property: 'resultss', query, previousResults: pr, skipSemantics: false || query.skipSemantics }
   }))
   todo = todo.concat((template.fragments || []).map((query) => { return Object.assign({}, toProperties(query), { property: 'fragments', skipSemantics: false }) }))
   todo = todo.concat((template.semantics || []).map((definition) => { return { property: 'semantics', query: `${definition.from}\n${definition.to}`, skipSemantics: true } }))
@@ -1467,15 +1466,19 @@ const knowledgeModuleImpl = async ({
   stopAtFirstFailure = true,
   ...rest
 } = {}) => {
-
-  template = _.cloneDeep(template)
-
-  // if (template.queries[91] && template.queries[91].bridge) {
-  if (template.queries[91]) {
-    debugger
+  /*
+  if (description == 'fastfood related concepts') {
     debugger
-    Object.freeze(template.queries[91])
+    global.old = template.template.queries[91].bridges[0]
   }
+  let old
+  if (template && template.template && template.template.queries) {
+    old = template.template.queries
+    template.template.queries = _.cloneDeep(template.template.queries)
+    template.wasCopied = true
+  }
+  */
+
   const unknownArgs = Object.keys(rest)
   if (unknownArgs.length > 0) {
     throw new Error(`Unknown arguments to knowledgeModule: ${unknownArgs.join()}`)
@@ -1506,10 +1509,10 @@ const knowledgeModuleImpl = async ({
     }
 
     config.description = description
-    if (typeof test === 'object') {
-      if (test.contents) {
-        config.tests = test.contents
-        test = test.name
+    if (typeof testConfig === 'object') {
+      if (testConfig.contents) {
+        config.tests = testConfig.contents
+        test = testConfig.name
       }
     } else {
       if (runtime.fs && runtime.fs.existsSync(test)) {
@@ -1521,7 +1524,6 @@ const knowledgeModuleImpl = async ({
     config.setTestConfig(testConfig)
   }
 
-
   if (isProcess) {
     const config = createConfig()
     setupConfig(config)
@@ -1538,7 +1540,6 @@ const knowledgeModuleImpl = async ({
     const helpDebugBridge = 'In order to get a debug break when a specific bridge is created set the DEBUG_BRIDGE environment variable to id/level to break on. For example DEBUG_BRIDGE=\'id#level\''
     const helpDebugOperator = 'In order to get a debug break when a specific hierarcy is created set the DEBUG_OPERATOR environment variable to debug any config loaded. For example DEBUG_OPERATOR=\'([operator] ([arg]))\''
 
-
     parser.add_argument('-tmn', '--testModuleName', { help: 'When running tests instead of using the current modules tests use the specified modules tests' })
     parser.add_argument('-t', '--test', { action: 'store_true', help: 'Run the tests. Create tests by running with the --query + --save flag' })
     parser.add_argument('-tv', '--testVerbose', { action: 'store_true', help: 'Run the tests in verbose mode. Create tests by running with the --query or --loop with the --save flag' })
@@ -1553,7 +1554,7 @@ const knowledgeModuleImpl = async ({
     parser.add_argument('-i', '--info', { action: 'store_true', help: 'Print meta-data for the module' })
     parser.add_argument('-v', '--vimdiff', { action: 'store_true', help: 'For failures run vimdiff' })
     parser.add_argument('-g', '--greg', { action: 'store_true', help: 'Set the server to be localhost so I can debug stuff' })
-    parser.add_argument('-cl', '--checkForLoop', { 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('-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' })
@@ -1565,7 +1566,7 @@ const knowledgeModuleImpl = async ({
     parser.add_argument('-p', '--print', { help: 'Print the specified elements c === config, w === words, b === bridges, o === operators d === objects (d for data), h === hierarchy, g === generators, s === semantics, l === load t=tests ordering p === priorities a == associations j == JSON sent to server. for example --print wb' })
     parser.add_argument('-s', '--save', { action: 'store_true', help: 'When running with the --query flag this will save the current run to the test file. When running without the --query flag all tests will be run and resaved.' })
     parser.add_argument('-sd', '--saveDeveloper', { action: 'store_true', help: 'Same as -s but the query will not show up in the info command.' })
-    parser.add_argument('-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('-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('-dh', '--debugHierarchy', { action: 'store_true', help: helpDebugHierarchy })
@@ -1573,8 +1574,8 @@ const knowledgeModuleImpl = async ({
     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' })
+    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
@@ -1605,9 +1606,9 @@ const knowledgeModuleImpl = async ({
           return true
         }
         if (!Array.isArray(args.checkForLoop) || args.checkForLoop.some((value) => !isKey(value))) {
-          throw new Error(`Error for the checkForLoop argument. Expected a JSON array of operator keys of the form "[<id>, <level>]"`)
+          throw new Error('Error for the checkForLoop argument. Expected a JSON array of operator keys of the form "[<id>, <level>]"')
         }
-      } catch( e ) {
+      } catch (e) {
         throw new Error(`Error parsing JSON of the checkForLoop argument. ${e}`)
       }
     } else {
@@ -1638,7 +1639,7 @@ const knowledgeModuleImpl = async ({
 
     if (args.clean) {
       const tests = JSON.parse(runtime.fs.readFileSync(testConfig.name))
-      for (let test of tests) {
+      for (const test of tests) {
         delete test.associations
       }
       writeTestFile(testConfig.name, tests)
@@ -1648,7 +1649,7 @@ const knowledgeModuleImpl = async ({
 
     if (args.deleteTest) {
       let tests = JSON.parse(runtime.fs.readFileSync(testConfig.name))
-      tests = tests.filter( (test) => test.query !== args.deleteTest );
+      tests = tests.filter((test) => test.query !== args.deleteTest)
       writeTestFile(testConfig.name, tests)
       console.log(`Remove the test for "${args.deleteTest}"`)
       return
@@ -1681,7 +1682,7 @@ const knowledgeModuleImpl = async ({
       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 = () => {
@@ -1691,7 +1692,7 @@ const knowledgeModuleImpl = async ({
       configPrinted = true
       if (args.print) {
         if (args.print.includes('t')) {
-          console.log("Test queries")
+          console.log('Test queries')
           let counter = 0
           for (const test of config.tests) {
             console.log(`${counter} - ${test.query}`)
@@ -1700,8 +1701,8 @@ const knowledgeModuleImpl = async ({
         }
         if (args.print.includes('c')) {
           const { data } = setupProcessB({ config })
-          console.log("Config as sent to server")
-          console.log(JSON.stringify(data, null, 2));
+          console.log('Config as sent to server')
+          console.log(JSON.stringify(data, null, 2))
         }
 
         if (args.print.includes('l')) {
@@ -1726,15 +1727,15 @@ const knowledgeModuleImpl = async ({
           }
         }
         if (args.print.includes('j')) {
-          const { data } = setupProcessB( { config } )
+          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) {
+          for (const property of properties) {
             console.log(`  ${property} ===============`)
-            for (let association of config.config.associations[property]) {
+            for (const association of config.config.associations[property]) {
               console.log(`  ${JSON.stringify(association)}`)
             }
           }
@@ -1743,12 +1744,12 @@ const knowledgeModuleImpl = async ({
           console.log(JSON.stringify(config.config.objects, null, 2))
         }
         if (args.print.includes('p')) {
-          for (let priority of config.config.priorities) {
+          for (const priority of config.config.priorities) {
             console.log(JSON.stringify(priority))
           }
         }
         if (args.print.includes('h')) {
-          for (let edge of config.config.hierarchy) {
+          for (const edge of config.config.hierarchy) {
             console.log(JSON.stringify(edge))
           }
         }
@@ -1778,7 +1779,6 @@ const knowledgeModuleImpl = async ({
 
     if (template) {
       let needsRebuild
-      console.log('template.template needs rebuild', template.template)
       if (args.rebuildTemplate && !args.rebuildTemplateFull) {
         // get the startOfChanges for the partial rebuild
         needsRebuild = config.needsRebuild(template.template, template.instance, { ...options, rebuild: false })
@@ -1789,7 +1789,7 @@ const knowledgeModuleImpl = async ({
 
       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('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
@@ -1797,7 +1797,7 @@ const knowledgeModuleImpl = async ({
       }
       try {
         config.load(template.template, template.instance, { rebuild: needsRebuild.needsRebuild || options.rebuild, previousResultss: needsRebuild.previousResultss, startOfChanges: needsRebuild.startOfChanges })
-      } catch( e ) {
+      } catch (e) {
         console.error(`Error loading template for ${config.name}. ${e.error ? e.error : e}${e.stack ? e.stack : ''}`)
         runtime.process.exit(-1)
       }
@@ -1849,12 +1849,12 @@ const knowledgeModuleImpl = async ({
                   hasError = true
                 }
                 if (!args.testNoParenthesized) {
-                    if (JSON.stringify(result.expected.paraphrasesParenthesized) !== JSON.stringify(result.actual.paraphrasesParenthesized)) {
-                      hasError = true
-                    }
-                    if (JSON.stringify(result.expected.generatedParenthesized) !== JSON.stringify(result.actual.generatedParenthesized)) {
-                      hasError = true
-                    }
+                  if (JSON.stringify(result.expected.paraphrasesParenthesized) !== JSON.stringify(result.actual.paraphrasesParenthesized)) {
+                    hasError = true
+                  }
+                  if (JSON.stringify(result.expected.generatedParenthesized) !== JSON.stringify(result.actual.generatedParenthesized)) {
+                    hasError = true
+                  }
                 }
                 if (JSON.stringify(result.expected.responses) !== JSON.stringify(result.actual.responses)) {
                   hasError = true
@@ -2000,13 +2000,13 @@ const knowledgeModuleImpl = async ({
           .then(() => {
             f()
           })
-          .catch( (e) => {
+          .catch((e) => {
             if (e.errno == 'ECONNREFUSED') {
               console.log(e)
               readline.close()
             } else {
               console.log(e)
-              f() 
+              f()
             }
           })
       })
@@ -2019,13 +2019,19 @@ const knowledgeModuleImpl = async ({
       }
       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);
+      } catch (error) {
+        console.log('Error', error)
       }
     }
     printConfig()
   } else {
     const initConfig = (config) => {
+      if (template) {
+        if (config.needsRebuild(template.template, template.instance, { isModule: !isProcess }).needsRebuild) {
+          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)
+        }
+      }
       setupConfig(config)
 
       let loadForTesting = false
@@ -2036,14 +2042,14 @@ const knowledgeModuleImpl = async ({
       }
       // remove test only stuff
       if (!isProcess && !loadForTesting) {
-        config.config.operators = config.config.operators.filter( (operator) => {
+        config.config.operators = config.config.operators.filter((operator) => {
           if (operator.development) {
             return false
           } else {
             return true
           }
         })
-        config.config.bridges = config.config.bridges.filter( (bridge) => {
+        config.config.bridges = config.config.bridges.filter((bridge) => {
           if (bridge.development) {
             return false
           } else {
@@ -2053,14 +2059,9 @@ const knowledgeModuleImpl = async ({
       }
 
       if (template) {
-        console.log('template.template needs rebuild', template.template)
-        if (config.needsRebuild(template.template, template.instance, { isModule: !isProcess }).needsRebuild) {
-          const error = `This module "${config.name}" cannot be used because the instance file needs rebuilding. Run on the command line with no arguments or the -rt argument to rebuild.`
-          throw new Error(error)
-        }
         try {
           config.load(template.template, template.instance)
-        } catch( e ) {
+        } catch (e) {
           errorHandler(e)
         }
       }
@@ -2096,19 +2097,19 @@ const ensureTestFile = (module, name, type) => {
   }
 }
 
-function where(goUp = 2) {
-  const e = new Error();
+function where (goUp = 2) {
+  const e = new Error()
   const regexForm1 = /\((.*):(\d+):(\d+)\)$/
   const regexForm2 = /at (.*):(\d+):(\d+)$/
-  const lines = e.stack.split("\n")
+  const lines = e.stack.split('\n')
   let line
   for (line of lines.slice(1)) {
-    if (!(line.includes("config.js:") || line.includes("client.js:"))) {
-      break;
+    if (!(line.includes('config.js:') || line.includes('client.js:'))) {
+      break
     }
   }
   // const line = e.stack.split("\n")[goUp];
-  const match = regexForm1.exec(line) || regexForm2.exec(line);
+  const match = regexForm1.exec(line) || regexForm2.exec(line)
   if (match) {
     return `${match[1]}:${match[2]}`
   } else {
@@ -2116,7 +2117,7 @@ function where(goUp = 2) {
   }
 }
 
-function w(func) {
+function w (func) {
   func.where = where(3)
   return func
 }
@@ -2148,4 +2149,3 @@ module.exports = {
   flattens,
   writeTest
 }
-