theprogrammablemind_4wp 9.3.0-beta.5 → 9.3.0-beta.50

package/client.js

@@ -260,7 +260,7 @@ const throwErrorHandler = (error) => {
   throw error
 }
 
-const _process = async (config, query, { initializer, commandLineArgs, credentials, writeTests, isTest, saveDeveloper, rebuildingTemplate, testConfig, testsFN, errorHandler = throwErrorHandler } = {}) => {
+const _process = async (config, query, { initializer, commandLineArgs, credentials, writeTests, isProcess, isModule, isTest, saveDeveloper, rebuildingTemplate, testConfig, testsFN, errorHandler = throwErrorHandler } = {}) => {
   if (credentials) {
     config.server(credentials.server, credentials.key)
   }
@@ -315,7 +315,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
       if (queries.length === 0) {
         break
       }
-
+      config.updateData(data)
       data.utterance = queries[0]
       data.start_counter = startCounter
       let json = await doWithRetries(retries, url, queryParams, data)
@@ -345,13 +345,14 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         throw json
       } else {
         let clientSideTime
+        let start
         if (isTest) {
-          const start = runtime.performance.performance.now()
+          start = runtime.performance.performance.now()
         }
         const summary = { summaries: json.summaries, length: json.contexts.length }
         summaries.push(summary)
         const { contextsPrime, generatedPrime, paraphrasesPrime, paraphrasesParenthesizedPrime, generatedParenthesizedPrime, responsesPrime } =
-                                  await processContextsB({ isTest, rebuildingTemplate, config, hierarchy, json, commandLineArgs /*, generators, semantics */ })
+                                  await processContextsB({ isTest, isProcess, isModule, rebuildingTemplate, config, hierarchy, json, commandLineArgs /*, generators, semantics */ })
         if (isTest) {
           const end = runtime.performance.performance.now()
           clientSideTime = end - start
@@ -484,7 +485,7 @@ const runTest = async (config, expected, { args, verbose, testConfig, debug, tim
       setupArgs(args, config)
       await testConfig.initializer(args)
     }
-    const result = await _process(config, test, { errorHandler, isTest: true })
+    const result = await _process(config, test, { errorHandler, isTest: true, isProcess: true, isModule: false })
     result.query = test
     if (debug) {
       defaultInnerProcess(config, errorHandler, result)
@@ -623,7 +624,7 @@ const saveTest = async (testFile, config, test, expected, testConfig, saveDevelo
   await config.rebuild()
   const objects = getObjects(config.config.objects)(config.uuid)
   console.log(test)
-  const result = await _process(config, test, { isTest: true })
+  const result = await _process(config, test, { isTest: true, isProcess: true, isModule: true })
   // const actualObjects = config.config.objects
   const actualConfig = getConfigForTest(config, testConfig)
   const args = {
@@ -1879,7 +1880,7 @@ const knowledgeModuleImpl = async ({
           global.beforeObjects = _.cloneDeep(objects)
         }
         try {
-          await processResults(_process(config, args.query, { commandLineArgs: args, dontAddAssociations: args.dontAddAssociations, writeTests: args.save || args.saveDeveloper, saveDeveloper: args.saveDeveloper, testConfig, testsFN: test }))
+          await processResults(_process(config, args.query, { commandLineArgs: args, isProcess, isModule: !isProcess, dontAddAssociations: args.dontAddAssociations, writeTests: args.save || args.saveDeveloper, saveDeveloper: args.saveDeveloper, testConfig, testsFN: test }))
         } catch (error) {
           console.log('Error', error)
         }
@@ -1908,8 +1909,18 @@ const knowledgeModuleImpl = async ({
           loadForTesting = true
         }
       }
+      if (template) {
+        try {
+          await config.load(rebuildTemplate, template.template, template.instance)
+        } catch (e) {
+          errorHandler(e)
+        }
+      }
+
       // remove test only stuff
       if (!isProcess && !loadForTesting) {
+        config.removeDevelopmentElements(config.config)
+        /*
         config.config.operators = config.config.operators.filter((operator) => {
           if (operator.development) {
             return false
@@ -1924,21 +1935,14 @@ const knowledgeModuleImpl = async ({
             return true
           }
         })
-      }
-
-      if (template) {
-        try {
-          await config.load(rebuildTemplate, template.template, template.instance)
-        } catch (e) {
-          errorHandler(e)
-        }
+        */
       }
     }
 
     // no cache 21 minutes + rebuild fails "node tester_rebuild -m colors"
     // cache okay
-    const createConfigExport = async () => {
-      if (createConfig.cached) {
+    const createConfigExport = async (useCache = true) => {
+      if (useCache && createConfig.cached) {
         return createConfig.cached
       }
       const config = await createConfig()

package/package.json

@@ -69,6 +69,6 @@
     "sort-json": "^2.0.0",
     "uuid": "^8.3.2"
   },
-  "version": "9.3.0-beta.5",
+  "version": "9.3.0-beta.50",
   "license": "UNLICENSED"
 }

package/src/config.js

@@ -473,7 +473,7 @@ const handleCalculatedProps = (baseConfig, moreConfig, { addFirst, uuid } = {})
   if (moreConfig.bridges) {
     moreConfig.bridges = moreConfig.bridges.map((bridge) => {
       bridge = { ...bridge }
-      const valid = ['after', 'conditional', 'associations', 'before', 'bridge', 'development', 'skipable', 'return_type_selector', 'evaluator', 'evaluators', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'operator', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
+      const valid = ['after', 'conditional', 'associations', 'before', 'bridge', 'disabled', 'development', 'skipable', 'return_type_selector', 'evaluator', 'evaluators', 'generatorp', 'generatorr', 'generatorpr', 'generators', 'operator', 'id', 'convolution', 'inverted', 'isA', 'children', 'parents',
         'level', 'optional', 'selector', 'semantic', 'semantics', 'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where', 'uuid']
       helpers.validProps(valid, bridge, 'bridge')
       handleBridgeProps(baseConfig, bridge, { addFirst, uuid })
@@ -1055,8 +1055,8 @@ class Config {
 
   // value is in response field
   // TODO maybe generalize out query+evaluate along the lines of set value and set reference
-  async getEvaluator (s, calls, log, context) {
-    const instance = await s({ ...context, evaluate: true })
+  async getEvaluator (s, calls, log, context, args) {
+    const instance = await s({ ...args, ...context, evaluate: true })
     calls.touch(instance)
     if (!instance.evalue && !instance.verbatim && !instance.value) {
       this.warningNotEvaluated(log, context)
@@ -1214,43 +1214,6 @@ class Config {
             }
             return bridge
           })
-        } else {
-          /* done in updateQueries now
-          config.generators = (config.generators || []).map((generator) => {
-            generator = { ...generator }
-            delete generator.where
-            generator.match = generator.match.toString()
-            generator.apply = generator.apply.toString()
-            return generator
-          })
-          config.semantics = (config.semantics || []).map((semantic) => {
-            semantic = { ...semantic }
-            delete semantic.where
-            semantic.match = semantic.match.toString()
-            semantic.apply = semantic.apply.toString()
-            return semantic
-          })
-          config.bridges = (config.bridges || []).map((bridge) => {
-            bridge = { ...bridge }
-            delete bridge.where
-            if (bridge.generatorp) {
-              bridge.generatorp = bridge.generatorp.toString()
-            }
-            if (bridge.generatorr) {
-              bridge.generatorr = bridge.generatorr.toString()
-            }
-            if (bridge.generatorpr) {
-              bridge.generatorpr = bridge.generatorpr.toString()
-            }
-            if (bridge.evaluator) {
-              bridge.evaluator = bridge.evaluator.toString()
-            }
-            if (bridge.semantic) {
-              bridge.semantic = bridge.semantic.toString()
-            }
-            return bridge
-          })
-          */
         }
         return config
       }
@@ -1328,6 +1291,15 @@ class Config {
     }
   }
 
+  addEnable (key) {
+    this._enable.push(key)
+  }
+
+  updateData (data) {
+    data.enable = this._enable
+    this._enable = []
+  }
+
   toData (data) {
     Object.assign(data, this.config)
     // greg99 delete data.objects
@@ -1577,8 +1549,14 @@ class Config {
   }
 
   removeSemantic (deleteSemantic) {
-    const id = deleteSemantic.id || deleteSemantic
-    const todo = [id]
+    if (!Array.isArray(deleteSemantic)) {
+      deleteSemantic = [deleteSemantic]
+    }
+    const todo = []
+    for (const ds of deleteSemantic) {
+      const id = ds.id || ds
+      todo.push(id)
+    }
     const seen = new Set()
 
     while (todo.length > 0) {
@@ -1591,6 +1569,7 @@ class Config {
       if (index === -1) {
         continue
       }
+      // TODO change to tiedIs(s)
       for (const tied_id of this.config.semantics[index].tied_ids || []) {
         if (!seen.has(tied_id)) {
           todo.push(tied_id)
@@ -1951,6 +1930,7 @@ class Config {
       config.priorities = config.priorities || []
     }
 
+    this._enable = []
     this._apiKMs = apiKMs
 
     this.clientProcess = clientProcess
@@ -2190,7 +2170,6 @@ class Config {
       this._apiConstructor = constructor
       if (this._apiKMs.length > 0) {
         for (const name of this._apiKMs) {
-          debugger
           this.km(name)._api = value[name]
         }
       } else {
@@ -2802,6 +2781,10 @@ class Config {
       }
     }
 
+    if (this.isModule) {
+      this.removeDevelopmentElements(this.config)
+    }
+
     this.valid()
     this.checks()
   }
@@ -3187,7 +3170,7 @@ class Config {
   }
 
   // TODO get rid of useOldVersion arg
-  addInternal (more, { uuid, addFirst = false, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false, handleCalculatedProps: hcps = false } = {}) {
+  addInternal (more, { uuid, km, addFirst = false, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false, handleCalculatedProps: hcps = false } = {}) {
     validConfigProps(more)
     if (more instanceof Config) {
       more.initialize({ force: false })
@@ -3204,6 +3187,20 @@ class Config {
       handleCalculatedProps(this, more, { addFirst, uuid })
       applyUUID(more, uuid || this._uuid)
     }
+    if (km) {
+      if (more.semantics) {
+        more.semantics.map((s) => s.km = km)
+      }
+      if (more.generators) {
+        more.generators.map((g) => g.km = km)
+      }
+    }
+    const normalizeIsA = (edge) => {
+      if (edge.length == 3 || edge.parent || edge.child) {
+        return edge
+      }
+      return [...edge, false]
+    }
     for (const key of Object.keys(more)) {
       const value = more[key]
       // TODO remove name and description on the config bag
@@ -3247,9 +3244,9 @@ class Config {
           const hierarchy = this.config.words.hierarchy
           const moreHierarchy = more.words.hierarchy
           if (addFirst) {
-            this.config.words.hierarchy = moreHierarchy.concat(hierarchy)
+            this.config.words.hierarchy = moreHierarchy.concat(hierarchy.map(normalizeIsA))
           } else {
-            this.config.words.hierarchy = hierarchy.concat(moreHierarchy)
+            this.config.words.hierarchy = hierarchy.concat(moreHierarchy.map(normalizeIsA))
           }
         }
       } else if (key === 'name') {
@@ -3321,7 +3318,9 @@ class Config {
         // console.log('more', JSON.stringify(more, null, 2))
         // hierarchy must update in place and does not care about the list order
         if (key === 'hierarchy') {
-          this.config[key].push(...more[key])
+          const moreEdges = more[key].map(normalizeIsA)
+          this.config[key].push(...moreEdges)
+          this.hierarchy.addEdges(moreEdges)
         } else {
           if (addFirst) {
             this.config[key] = more[key].concat(this.config[key])

package/src/configHelpers.js

@@ -86,6 +86,9 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
     args.objects = config.get('objects')
     args.getObjects = getObjects(args.objects)
   }
+  args.enable = (key) => {
+    config.addEnable(key)
+  }
   if (args.uuid) {
     args.objects = args.getObjects(args.uuid)
   }
@@ -140,7 +143,7 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
       if (!c) {
         return
       }
-      return config.getEvaluator(args.s, args.calls, logs, c)
+      return config.getEvaluator(args.s, args.calls, logs, c, { isModule: args.isModule, isProcess: args.isProcess })
     }
     args.gs = gs(args.g)
     args.gsp = gs(args.gp)
@@ -257,18 +260,18 @@ const setupProcessB = ({ config, initializer, allowDelta = false, rebuildingTemp
 const setupContexts = (rawContexts) => {
   let first = true
   const contexts = []
-  contexts.push({ marker: 'controlStart', controlRemove: true })
+  contexts.push({ marker: 'controlStart', controlRemove: true, isControl: true })
   let previous
   for (const context of rawContexts) {
     if (first) {
       first = false
     } else {
-      contexts.push({ marker: 'controlBetween', controlRemove: true, previous })
+      contexts.push({ marker: 'controlBetween', controlRemove: true, isControl: true, previous })
     }
     contexts.push(context)
     previous = context
   }
-  contexts.push({ marker: 'controlEnd', controlRemove: true, previous })
+  contexts.push({ marker: 'controlEnd', controlRemove: true, isControl: true, previous })
 
   let _index = 0
   const id = (context) => {
@@ -279,7 +282,7 @@ const setupContexts = (rawContexts) => {
   return contexts
 }
 
-const processContextsB = async ({ config, hierarchy, semantics, generators, json, isTest, rebuildingTemplate, isInstance, instance, query, data, retries, url, commandLineArgs, forTemplate }) => {
+const processContextsB = async ({ config, hierarchy, semantics, generators, json, isTest, isProcess, isModule, rebuildingTemplate, isInstance, instance, query, data, retries, url, commandLineArgs, forTemplate }) => {
   // TODO fix this name to contextsPrime
   const contextsPrime = []
   const generatedPrime = []
@@ -290,7 +293,7 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
   const contexts = setupContexts(json.contexts)
 
   const objects = config.get('objects')
-  const args = { objects, isResponse: true, response: json, isTest, isInstance, getObjects: getObjects(objects), instance, contexts }
+  const args = { objects, isResponse: true, response: json, isTest, isInstance, getObjects: getObjects(objects), instance, contexts, isProcess, isModule }
   if (!json.logs) {
     json.logs = []
   }
@@ -441,14 +444,14 @@ const loadInstance = async (config, instance) => {
   */
 
   // const { /* data, generators, semantics, */ hierarchy } = setupProcessB({ config })
-  const hierarchy = config.hierarchy
   for (const i in (instance.resultss || [])) {
+    const hierarchy = config.hierarchy
     const results = instance.resultss[i]
     if (results.extraConfig) {
       // config.addInternal(results, useOldVersion = true, skipObjects = false, includeNamespaces = true, allowNameToBeNull = false)
       const uuid = config.nameToUUID(instance.name)
       // used to do a CLONE
-      config.addInternal(instance.template.configs[i], { uuid, addFirst: true, handleCalculatedProps: true })
+      config.addInternal(instance.template.configs[i], { uuid, km: instance.name, addFirst: true, handleCalculatedProps: true })
     } else if (results.apply) {
       const objects = getObjects(config.get('objects'))(config.uuid)
       const args = { objects, getObjects: getObjects(objects) }
@@ -468,6 +471,8 @@ const loadInstance = async (config, instance) => {
       const args = { config, hierarchy, json: results, commandLineArgs: {}, forTemplate: true }
       args.isInstance = `instance${i}`
       args.instance = ''
+      args.isProcess = !config.isModule
+      args.isModule = !!config.isModule
       await processContextsB(args)
       if (results.skipSemantics) {
         config.config.skipSemantics = null

package/src/debug.js

@@ -31,12 +31,12 @@ const wasHit = (name) => {
   return hits[name]
 }
 
-const counter = (name, breakAt = [], debugBreak = true) => {
+const counter = (name, { breakAt = [], debugBreak = true, tag = '' } = {}) => {
   if (!counters[name]) {
     counters[name] = 0
   }
   counters[name] += 1
-  console.log(`counters[${name}] = ${counters[name]}`)
+  console.log(`counters[${name}] = ${counters[name]} ${tag}`)
   unhit(name)
   if (Array.isArray(breakAt) && breakAt.includes(counters[name])) {
     if (debugBreak) {

package/src/helpers.js

@@ -310,6 +310,7 @@ const validProps = (valids, object, type) => {
       }
     }
     if (!okay) {
+      valids.sort()
       throw new Error(`Unknown property "${prop}" in the ${type}. Valid properties are ${valids.join(', ')}. The ${type} is ${JSON.stringify(object)}`)
     }
   }

package/src/project.js

@@ -3,6 +3,9 @@ const project = (object, filter) => {
   if (!object) {
     return
   }
+  if (typeof object === 'string' || typeof object === 'number') {
+    return object
+  }
 
   const projection = {}
   const set = (property, value) => {