theprogrammablemind 7.12.8-beta.0 → 7.12.8-beta.10

package/client.js

@@ -646,17 +646,15 @@ const loadInstance = (config, instance) => {
     const results = instance.resultss[i]
     if (results.extraConfig) {
       // 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)
       // used to do a CLONE
-      // config.addInternal(_.cloneDeep(instance.template.queries[i]), { uuid, addFirst: true, handleCalculatedProps: true })
-      config.addInternal(instance.template.queries[i], { uuid, addFirst: true, handleCalculatedProps: true })
+      config.addInternal(instance.template.configs[i], { uuid, addFirst: true, handleCalculatedProps: true })
     } else if (results.apply) {
       const objects = config.get('objects')
       const args = { objects, getObjects: getObjects(objects) }
-      if (instance.queries) {
+      if (instance.configs) {
         args.isInstance = `instance${i}`
-        args.instance = instance.queries[i]
+        args.instance = instance.configs[i]
       }
 
       const uuid = config.nameToUUID(instance.name)
@@ -824,15 +822,27 @@ const getConfigForTest = (config, testConfig) => {
     // configForTest[key] = config.config[key]
     if (key === 'words') {
       const words = config.config.words
-      configForTest.words = {}
-      for (const key of Object.keys(words)) {
+      configForTest.words = {
+        literals: {},
+        patterns: [],
+        hierarchy: [],
+      }
+
+      const literals = config.config.words.literals
+      for (const key in literals) {
         const defs = []
-        for (const def of words[key]) {
+        for (const def of literals[key]) {
           // TODO handle thie uuids the right way
           defs.push(Object.assign({}, def, { uuid: undefined }))
         }
-        configForTest.words[key] = defs
+        configForTest.words.literals[key] = defs
       }
+
+      const patterns = config.config.words.patterns
+      configForTest.words.patterns = patterns.map((pattern) => Object.assign({}, pattern, { uuid: undefined }))
+
+      const hierarchy = config.config.words.hierarchy
+      configForTest.words.hierarchy = hierarchy.map((hierarchy) => Object.assign({}, hierarchy, { uuid: undefined }))
     } else if (key === 'operators') {
       configForTest.operators = config.config.operators.map((operator) => Object.assign({}, operator, { uuid: undefined }))
     } else if (key === 'bridges') {
@@ -1305,12 +1315,12 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
     associations: [],
     learned_contextual_priorities: []
   }
-  const looper = async (queries) => {
-    if (queries.length === 0) {
+  const looper = async (configs) => {
+    if (configs.length === 0) {
       finish()
       return
     }
-    const { property, hierarchy, query: queryOrExtraConfig, previousResults, initializer, skipSemantics } = queries.shift()
+    const { property, hierarchy, query: queryOrExtraConfig, previousResults, initializer, skipSemantics } = configs.shift()
     // queries are strings or { query: "blah", development: true/false }
     if (typeof queryOrExtraConfig === 'string' || queryOrExtraConfig.query) {
       let query = queryOrExtraConfig
@@ -1362,7 +1372,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
         accumulators[property].push(results)
         accumulators.associations = accumulators.associations.concat(results.associations)
         accumulators.learned_contextual_priorities = accumulators.learned_contextual_priorities.concat(results.learned_contextual_priorities)
-        await looper(queries)
+        await looper(configs)
       } catch (e) {
         const error = { errors: [e], query: query.query }
         config.config.skipSemantics = null
@@ -1376,7 +1386,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
       setupArgs(args, config, config.logs, hierarchy)
       initFunction(args)
       accumulators[property].push({ apply: queryOrExtraConfig })
-      await looper(queries)
+      await looper(configs)
     } else {
       // extra config is def from a time like operators or bridges or words etc
       // it will just get added to the config
@@ -1392,7 +1402,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
           throw new Error(`Error processing extra config${where}: ${e.stack}}`)
         }
         accumulators[property].push({ extraConfig: true, ...extraConfig })
-        await looper(queries)
+        await looper(configs)
       }
     }
   }
@@ -1432,7 +1442,7 @@ const rebuildTemplate = async ({ config, target, previousResultss, startOfChange
       return template
     }
     stabilizeOutput(accumulators)
-    runtime.fs.writeFileSync(instanceName, JSON.stringify(Object.assign({ queries: template.queries.map(updateQueries) }, accumulators), 0, 2))
+    runtime.fs.writeFileSync(instanceName, JSON.stringify(Object.assign({ configs: template.configs.map(updateQueries) }, accumulators), 0, 2))
 
     // km tests file
     const testsName = `./${target}.test.json`
@@ -1451,7 +1461,7 @@ 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.configs || []).map((query, index) => {
     let pr
     if (index < startOfChanges) {
       pr = previousResultss[index]
@@ -1501,19 +1511,6 @@ const knowledgeModuleImpl = async ({
   acceptsAdditionalConfig = false,
   ...rest
 } = {}) => {
-  /*
-  if (description == 'fastfood related concepts') {
-    debugger
-    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()}`)

package/package.json

@@ -65,6 +65,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.12.8-beta.0",
+  "version": "7.12.8-beta.10",
   "license": "UNLICENSED"
 }

package/src/config.js

@@ -26,6 +26,19 @@ const config_toServer = (config) => {
   // cant change things because copy breaks something
 }
 
+const initWords = (words) => {
+  if (!words.literals) {
+    words.literals = {}
+  }
+  if (!words.patterns) {
+    words.patterns = []
+  }
+  if (!words.hierarchy) {
+    words.hierarchy = []
+  }
+  return words
+}
+
 const debugPriority = (priority) => {
   if (global.entodictonDebugPriority) {
     if (helpers.subPriority(entodictonDebugPriority, priority)) {
@@ -123,6 +136,7 @@ const validConfigProps = (config) => {
 
 const setupInitializerFNArgs = (config, args) => {
   const aw = (word, def) => config.addWord(word, def, args.uuid)
+  const ap = (pattern, def) => config.addPattern(pattern, def, args.uuid)
   const ag = (generator) => config.addGenerator(generator, args.uuid, config.name)
   const km = (name) => config.getConfig(name)
   const apis = (name) => config.getConfig(name).api
@@ -130,6 +144,7 @@ const setupInitializerFNArgs = (config, args) => {
   return {
     ...args,
     addWord: aw,
+    addPattern: ap,
     addGenerator: ag,
     config: config.getPseudoConfig(args.uuid, args.currentConfig),
     km,
@@ -213,6 +228,9 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
           config.addHierarchy(child, bridge.id)
         }
       }
+      if (bridge.operator) {
+        config.addOperator(bridge.operator, uuid || config.uuid)
+      }
       if (bridge.parents) {
         for (const parent of bridge.parents) {
           config.addHierarchy(bridge.id, parent)
@@ -329,7 +347,7 @@ const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
       if (bridge.semantic) {
         const semantic = {
           where: bridge.semantic.where || bridge.where || client.where(3),
-          match: ({ context }) => bridge.id == context.marker,
+          match: ({ context }) => bridge.id == context.marker && !context.evaluate,
           apply: (args) => bridge.semantic(args),
           applyWrapped: bridge.semantic,
           property: 'semantic'
@@ -348,7 +366,7 @@ const handleCalculatedProps = (baseConfig, moreConfig, { addFirst, uuid } = {})
   if (moreConfig.bridges) {
     moreConfig.bridges = moreConfig.bridges.map((bridge) => {
       bridge = { ...bridge }
-      const valid = ['after', 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
+      const valid = ['after', 'before', 'bridge', 'development', 'evaluator', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'operator', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
         'level', 'optional', 'selector', 'semantic', 'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where', 'uuid']
       helpers.validProps(valid, bridge, 'bridge')
       handleBridgeProps(baseConfig, bridge, { addFirst, uuid })
@@ -409,10 +427,13 @@ const hierarchyCanonical = (element) => {
   }
 }
 
-const isValidDef = (word, def, config) => {
+const isValidWordDef = (word, def, config) => {
+  // TODO trie
+  /*
   if (!def.id) {
     throw new Error(`In the KM "${config.name}", for the word ${word} the following definition is missing the "id" property: ${JSON.stringify(def)}`)
   }
+  */
   /*
   if (!def.initial) {
     throw `In the KM "${config.name}", for the word ${word} the following definition is missing the "initial" property: ${JSON.stringify(def)}`
@@ -429,16 +450,20 @@ const hierarchyToCanonical = (edge) => {
 
 const addWord = (config, uuid) => ({ word, id, initial }) => {
   if (!config.words) {
-    config.words = {}
+    config.words = {
+      literals: {},
+      patterns: [],
+      hierarchy: [],
+    }
   }
-  const words = config.words
+  const literals = config.words.literals
   const def = { id, initial, uuid }
-  if (words[word]) {
-    if (!words[word].some((e) => helpers.safeEquals(e, def))) {
-      words[word].unshift(def)
+  if (literals[word]) {
+    if (!literals[word].some((e) => helpers.safeEquals(e, def))) {
+      literals[word].unshift(def)
     }
   } else {
-    words[word] = [def]
+    literals[word] = [def]
   }
 }
 
@@ -453,6 +478,7 @@ const normalizeConfig = (config) => {
         }
       }
     }
+
     if (config.bridges) {
       for (const bridge of config.bridges) {
         if (!bridge.level) {
@@ -471,6 +497,14 @@ const normalizeConfig = (config) => {
         }
       }
     }
+
+    if (config.operators) {
+      for (let i = 0; i < config.operators.length; ++i) {
+        if (typeof config.operators[i] === 'string') {
+          config.operators[i] = { pattern: config.operators[i] }
+        }
+      }
+    }
   }
 }
 
@@ -488,8 +522,17 @@ function configDup (config, options) {
 }
 
 function setWordsUUIDs (words, uuid) {
-  for (const key in words) {
-    words[key] = words[key].map((o) => Object.assign(o, { uuid }))
+  const literals = words.literals
+  for (const key in literals) {
+    literals[key] = literals[key].map((o) => Object.assign(o, { uuid }))
+  }
+  const patterns = words.patterns
+  for (const pattern of patterns) {
+    pattern.defs.map((def) => Object.assign(def, { uuid }))
+  }
+  const hierarchy = words.hierarchy
+  for (const pair of hierarchy) {
+    pair.uuid = uuid 
   }
 }
 
@@ -740,7 +783,7 @@ class Config {
     }
     const templateQueries = []
     if (this.instances && this.instances.length > 0) {
-      for (const query of this.instances.slice(-1)[0].queries) {
+      for (const query of this.instances.slice(-1)[0].configs) {
         if (typeof query === 'string') {
           templateQueries.push(query)
         }
@@ -764,6 +807,7 @@ class Config {
       addSemantic: (...args) => this.addSemantic(...args, uuid, config.name),
       removeSemantic: (...args) => this.removeSemantic(...args, uuid, config.name),
       addWord: (...args) => this.addWord(...args, uuid),
+      addPattern: (...args) => this.addPattern(...args, uuid),
 
       getHierarchy: (...args) => this.config.hierarchy,
       getBridges: (...args) => this.config.bridges,
@@ -785,28 +829,6 @@ class Config {
     }
   }
 
-  // return the config with just the elements from the included KM's
-  baseConfig () {
-    const operators = this.config.operators.filter((operator) => {
-      return operator.uuid !== this.uuid
-    })
-    const bridges = this.config.bridges.filter((bridge) => {
-      return bridge.uuid !== this.uuid
-    })
-    const words = {}
-    for (const word in this.config.words) {
-      const defs = this.config.words[word].filter((def) => def.uuid !== this.uuid)
-      if (defs.length > 0) {
-        words[word] = defs
-      }
-    }
-    return {
-      operators,
-      bridges,
-      words
-    }
-  }
-
   getCounter (maybeName = '') {
     const counter = this.configCounter
     this.configCounter += 1
@@ -843,7 +865,11 @@ class Config {
         namespaced: {}
       },
       description: '',
-      words: {}, // Done
+      words: {
+        literals: {},
+        patterns: [],
+        hierarchy: [],
+      }, // Done
       floaters: [],
       implicits: [],
       flatten: [],
@@ -1102,8 +1128,8 @@ class Config {
       return elements.map(toCanonicalQuery)
     }
 
-    const templateQueries = toCanonicalQueries(template.queries || []).map(helpers.updateQueries)
-    const instanceQueries = toCanonicalQueries(instance.queries || [])
+    const templateQueries = toCanonicalQueries(template.configs || []).map(helpers.updateQueries)
+    const instanceQueries = toCanonicalQueries(instance.configs || [])
     let sameQueries = true
     let startOfChanges
     for (let iq = 0; iq < templateQueries.length; ++iq) {
@@ -1124,7 +1150,6 @@ class Config {
     if (templateQueries.length < instanceQueries.length) {
       startOfChanges = instanceQueries.length
     }
-    // const sameQueries = helpers.safeEquals(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), toCanonicalQueries(instance.queries || []))
 
     if (debug) {
       if (!(instance && sameQueries && sameFragments)) {
@@ -1133,8 +1158,6 @@ class Config {
         console.log('sameFragments', sameFragments)
         // console.log("templateFragments", templateFragments)
         // console.log("instanceFragments", instanceFragments)
-        // console.log('template.queries', JSON.stringify(toCanonicalQueries(template.queries || []).map(helpers.updateQueries), null, 2))
-        // console.log("instance.queries", JSON.stringify(toCanonicalQueries(instance.queries || []), null, 2))
       }
     }
     if (startOfChanges || instance.resultss) {
@@ -1145,13 +1168,13 @@ class Config {
   }
 
   validifyTemplate (template) {
-    if (!template.queries && !template.fragments) {
-      throw new Error(`Expected the template for ${this.name} to be an object that can have the properties: queries and fragments`)
+    if (!template.configs && !template.fragments) {
+      throw new Error(`Expected the template for ${this.name} to be an object that can have the properties: configs and fragments`)
     }
-    for (const query of template.queries || []) {
+    for (const query of template.configs || []) {
       if (typeof query === 'string') {
       } else if (query instanceof Config) {
-        throw new Error(`For the template for ${this.name}, each element in queries should be either a string or a structure with a config (not a Config object).`)
+        throw new Error(`For the template for ${this.name}, each element in configs should be either a string or a structure with a config (not a Config object).`)
       }
     }
   }
@@ -1168,7 +1191,7 @@ class Config {
     this.logs.push(`loading template for ${this.name}`)
     if (options.rebuild) {
       // TODO fix beforeQuery
-      template = { fragments: [], queries: [], ...template }
+      template = { fragments: [], configs: [], ...template }
       template.fragments = template.fragments.concat(this.dynamicFragments)
       client.rebuildTemplate({ config: this, target: this.name, previousResultss: options.previousResultss, startOfChanges: options.startOfChanges, beforeQuery: () => {}, template, ...options })
     } else {
@@ -1176,7 +1199,7 @@ class Config {
       // this.initInstances.push({ ...instance, name: config.name })
       const isEmpty = (instance) => {
         const properties = [
-          'queries',
+          'configs',
           'resultss',
           'fragments',
           'semantics',
@@ -1189,7 +1212,7 @@ class Config {
         for (let i = 0; i < instance.resultss.length; ++i) {
           const result = instance.resultss[i]
           if (result.apply) {
-            result.apply = template.queries[i]
+            result.apply = template.configs[i]
           }
         }
         instance.name = this.name
@@ -1429,21 +1452,41 @@ class Config {
 
   addWordInternal (word, def, uuid) {
     if (!this.config.words) {
-      this.config.words = {}
+      this.config.words = {
+        literals: {},
+        patterns: [],
+        hierarchy: [],
+      }
     }
-    const words = this.config.words
+
+    const literals = this.config.words.literals
     def = Object.assign({}, def, { uuid: uuid || this._uuid })
-    if (words[word]) {
-      if (!words[word].some((e) => helpers.safeEquals(e, def))) {
-        words[word].unshift(def)
+    if (literals[word]) {
+      if (!literals[word].some((e) => helpers.safeEquals(e, def))) {
+        literals[word].unshift(def)
       }
     } else {
-      words[word] = [def]
+      literals[word] = [def]
     }
 
     this._delta.json.words.push({ action: 'add', word, def })
   }
 
+  addPattern (pattern, def, uuid) {
+    if (!this.config.words) {
+      this.config.words = {
+        literals: {},
+        patterns: [],
+        hierarchy: [],
+      }
+    }
+
+    const patterns = this.config.words.patterns
+    def = Object.assign({}, def, { uuid: uuid || this._uuid })
+    patterns.unshift({ pattern, defs: [def] })
+    this._delta.json.words.push({ action: 'add', pattern, defs: [def] })
+  }
+
   getAPI (uuid) {
     if (this._uuid === uuid) {
       return this.api
@@ -1637,13 +1680,35 @@ class Config {
     config.generators = config.generators.filter((element) => !element.development)
     config.semantics = config.semantics.filter((element) => !element.development)
     config.hierarchy = (config.hierarchy).filter((element) => !element.development)
-    for (const word in config.words) {
-      const defs = config.words[word] || []
-      config.words[word] = defs.filter((def) => !def.development)
-      if (config.words[word].length == 0) {
-        delete config.words[word]
+
+    const literals = config.words.literals
+    for (const word in literals) {
+      const defs = literals[word] || []
+      literals[word] = defs.filter((def) => !def.development)
+      if (literals[word].length == 0) {
+        delete literals[word]
+      }
+    }
+
+    const patterns = config.words.patterns || []
+    const patternsPrime = []
+    for (const pattern of patterns) {
+      let defs = pattern.defs || []
+      defs = defs.filter((def) => !def.development)
+      if (defs.length !== 0) {
+        patternsPrime.push({...pattern, defs})
       }
     }
+    config.words.patterns = patternsPrime
+
+    const hierarchy = config.words.hierarchy || []
+    const hierarchyPrime = []
+    for (const pair of hierarchy) {
+      if (!pair.development) {
+        hierarchyPrime.push(pair)
+      }
+    }
+    config.words.hierarchy = hierarchyPrime
   }
 
   // configs = [ { config, namespace } ... ]
@@ -1657,7 +1722,7 @@ class Config {
 
       config.operators = config.operators || []
       config.bridges = config.bridges || []
-      config.words = config.words || {}
+      config.words = config.words || { literals: {}, patterns: [], hierarchy: [] }
       config.generators = config.generators || []
       config.semantics = config.semantics || []
       config.hierarchy = config.hierarchy || []
@@ -1687,7 +1752,7 @@ class Config {
     this.instances = []
     this.logs = []
     this.dynamicFragments = []
-    // when running queries any bridges added are marked as transitory so that the associated will ignore those op's
+    // when running configs any bridges added are marked as transitory so that the associated will ignore those op's
     this.transitoryMode = false
 
     // check for duplicate bridges
@@ -1709,11 +1774,8 @@ class Config {
     }
 
     if (config && config.words) {
-      for (const word of Object.keys(config.words)) {
-        for (const def of config.words[word]) {
-          isValidDef(word, def, config)
-        }
-      }
+      initWords(config.words)
+      isValidWordDef(config.words)
     }
 
     if (config && config.priorities) {
@@ -2029,10 +2091,28 @@ class Config {
       this.config.namespaces = ns
     }
 
-    if (this.config.words) {
-      const words = this.config.words
-      for (const key in words) {
-        words[key].forEach((o) => {
+    if (!this.config.words) {
+      this.config.words = {}
+    }
+
+    if (this.config.words.literals) {
+      const literals = this.config.words.literals
+      for (const key in literals) {
+        literals[key].forEach((o) => {
+          if (o.uuid) {
+            if (map[o.uuid]) {
+              o.uuid = map[o.uuid]
+            }
+          } else {
+            o.uuid = this._uuid
+          }
+        })
+      }
+    }
+
+    const mapDefList = (list) => {
+      for (const element of list) {
+        element.defs.forEach((o) => {
           if (o.uuid) {
             if (map[o.uuid]) {
               o.uuid = map[o.uuid]
@@ -2044,6 +2124,22 @@ class Config {
       }
     }
 
+    if (this.config.words.patterns) {
+      mapDefList(this.config.words.patterns)
+    }
+
+    if (this.config.words.hierarchy) {
+      for (const o of this.config.words.hierarchy) {
+        if (o.uuid) {
+          if (map[o.uuid]) {
+            o.uuid = map[o.uuid]
+          }
+        } else {
+          o.uuid = this._uuid
+        }
+      }
+    }
+
     if (this.config.bridges) {
       this.config.bridges.forEach((bridge) => {
         if (bridge.uuid) {
@@ -2216,11 +2312,14 @@ class Config {
     }
     */
 
-    for (const key in this.config.words) {
-      const values = this.config.words[key]
-      if (values.some((word) => (Object.keys(word).includes('uuid') && !word.uuid))) {
-        debugBreak()
-        return false
+    const literals = this.config.words.literals
+    if (literals) {
+      for (const key in literals) {
+        const values = literals[key]
+        if (values.some((word) => (Object.keys(word).includes('uuid') && !word.uuid))) {
+          debugBreak()
+          return false
+        }
       }
     }
 
@@ -2434,7 +2533,7 @@ class Config {
       this.config.hierarchy = []
       this.config.priorities = []
       this.config.associations = { positive: [], negative: [] }
-      this.config.words = {}
+      this.config.words = initWords({})
 
       for (let i = 0; i < addInternals.length; ++i) {
         let name
@@ -2621,13 +2720,25 @@ class Config {
     }
 
     if (config.words) {
-      const words = {}
-      for (const word in config.words) {
-        words[word] = config.words[word].map((word) => {
+      const literals = {}
+      for (const word in config.words.literals) {
+        literals[word] = config.words.literals[word].map((word) => {
           return Object.assign({}, word, { id: toNS(word.id), uuid })
         })
       }
-      config.words = words
+      config.words.literals = literals
+
+      for (const pattern of config.words.patterns) {
+        pattern.defs.forEach((def) => {
+          def.id = toNS(def.id)
+          def.uuid = uuid
+        })
+      }
+
+      for (const pair of config.words.hierarchy) {
+        pair.child = toNS(pair.child)
+        pair.parent = toNS(pair.parent)
+      }
     }
 
     if (config.hierarchy) {
@@ -2748,6 +2859,7 @@ class Config {
       throw new Error(`Setting invalid property ${property}`)
     }
 
+    // TODO trie
     if (property == 'words') {
       for (const word in value) {
         for (const def of value[word]) {
@@ -2895,16 +3007,36 @@ class Config {
         continue
       }
       if (key === 'words') {
-        const configWords = this.config.words
-        const moreWords = more.words
-        for (const word of Object.keys(moreWords)) {
-          if (!configWords[word]) {
-            configWords[word] = []
+        if (more.words.literals) {
+          const literals = this.config.words.literals
+          const moreLiterals = more.words.literals
+          for (const word of Object.keys(moreLiterals)) {
+            if (!literals[word]) {
+              literals[word] = []
+            }
+            if (addFirst) {
+              literals[word] = moreLiterals[word].concat(literals[word])
+            } else {
+              literals[word] = literals[word].concat(moreLiterals[word])
+            }
+          }
+        }
+        if (more.words.patterns) {
+          const patterns = this.config.words.patterns
+          const morePatterns = more.words.patterns
+          if (addFirst) {
+            this.config.words.patterns = morePatterns.concat(patterns)
+          } else {
+            this.config.words.patterns = patterns.concat(morePatterns)
           }
+        }
+        if (more.words.hierarchy) {
+          const hierarchy = this.config.words.hierarchy
+          const moreHierarchy = more.words.hierarchy
           if (addFirst) {
-            configWords[word] = moreWords[word].concat(configWords[word])
+            this.config.words.hierarchy = moreHierarchy.concat(hierarchy)
           } else {
-            configWords[word] = configWords[word].concat(moreWords[word])
+            this.config.words.hierarchy = hierarchy.concat(moreHierarchy)
           }
         }
       } else if (key === 'name') {
@@ -3016,14 +3148,25 @@ class Config {
         continue
       }
       if (key === 'words') {
-        const configWords = this.config.words
-        const moreWords = more.words
-        for (const word of Object.keys(moreWords)) {
-          if (!configWords[word]) {
-            configWords[word] = []
+        if (this.config.words.literals) {
+          const literals = this.config.words.literals
+          const moreLiterals = more.words.literals
+          for (const word of Object.keys(moreLiterals)) {
+            if (!literals[word]) {
+              literals[word] = []
+            }
+            literals[word] = moreLiterals[word].concat(literals[word])
           }
-          // configWords[word] = configWords[word].concat(moreWords[word])
-          configWords[word] = moreWords[word].concat(configWords[word])
+        }
+        if (this.config.words.patterns) {
+          const patterns = this.config.words.patterns
+          const morePatterns = more.words.patterns
+          this.config.words.patterns = morePatterns.concat(patterns)
+        }
+        if (this.config.words.hierarchy) {
+          const hierarchy = this.config.words.hierarchy
+          const moreHierarchy = more.words.hierarchy
+          this.config.words.hierarchy = moreHierarchy.concat(hierarchy)
         }
       } else if (key === 'name') {
         /*