theprogrammablemind 7.6.0-beta.6 → 7.6.0-beta.8

package/client.js

@@ -173,22 +173,32 @@ const setupArgs = (args, config, logs, hierarchy) => {
   args.theDebugger = {
     breakOnSemantics: (value) => args.breakOnSemantics = value
   }
-  args.s = (c) => config.getSemantics(logs).apply(args, c)
-  args.g = (c) => config.getGenerators(logs).apply(args, c)
-  args.gp = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: true, isResponse: false, response: false})
-  args.gr = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: false, isResponse: true })
   if (!logs) {
     debugger
   }
-  args.e = (c) => config.getEvaluator(args.s, args.calls, logs, c)
   args.log = (message) => logs.push(message)
-  args.gs = gs(args.g)
-  args.gsp = gs(args.gp)
-  args.gsr = gs(args.gr)
+
+  args.addAssumedScoped = (args, assumed) => {
+    args.s = (c) => config.getSemantics(logs).apply(args, c)
+    args.g = (c) => config.getGenerators(logs).apply(args, c)
+    args.gp = (c) => config.getGenerators(logs).apply({...args, assumed: {paraphrase: true, isResponse: false, response: false}}, c, {paraphrase: true, isResponse: false, response: false})
+    args.gr = (c) => config.getGenerators(logs).apply({...args, assumed: {paraphrase: false, isResponse: true}}, { ...c, paraphrase: false, isResponse: true })
+    args.e = (c) => config.getEvaluator(args.s, args.calls, logs, c)
+    args.gs = gs(args.g)
+    args.gsp = gs(args.gp)
+    args.gsr = gs(args.gr)
+  }
+  // for semantics
+  args.addAssumedScoped(args, {})
   config.getAddedArgs(args)
 }
 
 const gs = (g) => (contexts, separator, lastSeparator) => {
+  if (!Array.isArray(contexts)) {
+    debugger
+    throw new Error("Expected a list")
+  }
+
   let s = ''
   if (!separator) {
     separator = ' '
@@ -276,8 +286,9 @@ const processContext = (context, { objects = {}, config, logs = [] }) => {
   setupArgs(args, config, logs, hierarchy)
 
   context = semantics.apply(args, context)
-  const generated = generators.apply(args, context)[0]
-  const paraphrases = generators.apply(args, context, { paraphrase: true, response: false, isResponse: false })[0]
+  const generated = generators.apply(args, context)
+  const assumed = { paraphrase: true, response: false, isResponse: false }
+  const paraphrases = generators.apply({...args, assumed}, context, { paraphrase: true, response: false, isResponse: false })
   let responses = []
   if (context.isResponse) {
     responses = generated
@@ -447,37 +458,29 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
         continue
       }
       let assumed = { isResponse: true };
-      const generated = contextPrime.isResponse ? config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0] : ''
+      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, contextPrime, assumed)[0] : ''
+        generatedParenthesized = contextPrime.isResponse ? config.getGenerators(json.logs).apply({...args, assumed}, contextPrime, assumed) : ''
         config.parenthesized = false
       }
       // assumed = { paraphrase: true, response: false };
-      assumed = { paraphrase: true };
-      args.g = (c) => config.getGenerators(json.logs).apply(args, c, assumed)
-      args.gp = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: true, isResponse: false, response: false }, assumed)
-      args.gr = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: false }, assumed)
-      args.gs = gs(args.g)
-      args.gsp = gs(args.gsp)
-      args.gsr = gs(args.gr)
+      assumed = { paraphrase: true, isResponse: false, response: false };
+      // args.g = (c) => config.getGenerators(json.logs).apply({...args, assumed}, c, assumed)
+      // args.gs = gs(args.g)
       if (generateParenthesized) {
         config.parenthesized = false
       }
-      const paraphrases = config.getGenerators(json.logs).apply(args, contextPrime, assumed)[0]
+      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, contextPrime, assumed)[0]
+        paraphrasesParenthesized = config.getGenerators(json.logs).apply({...args, assumed}, contextPrime, assumed)
         config.parenthesized = false
       }
-      args.g = (c) => config.getGenerators(json.logs).apply(args, c)
-      args.gp = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: true, isResponse: false, response: false })
-      args.gr = (c) => config.getGenerators(json.logs).apply(args, {...c, paraphrase: false })
-      args.gs = gs(args.g)
-      args.gsp = gs(args.gp)
-      args.gsr = gs(args.gr)
+      // args.g = (c) => config.getGenerators(json.logs).apply(args, c)
+      // args.gs = gs(args.g)
       contextsPrime.push(contextPrime)
       generatedPrime.push(generated)
       paraphrasesPrime.push(paraphrases)
@@ -1794,12 +1797,16 @@ const knowledgeModule = async ({
                   show('paraphrases', result.expected.paraphrases, result.actual.paraphrases)
                   if (!args.testNoParenthesized) {
                     show('paraphrases parenthesized', result.expected.paraphrasesParenthesized, result.actual.paraphrasesParenthesized)
+                    if (args.vimdiff) {
+                      vimdiff(result.actual.paraphrasesParenthesized, result.expected.paraphrasesParenthesized)
+                    }
+                  }
+                  /*
                   }
                   show('responses', result.expected.responses, result.actual.responses)
                   if (!args.testNoParenthesized) {
                     show('responses parenthesized', result.expected.generatedParenthesized, result.actual.generatedParenthesized)
                   }
-                  /*
                   if (JSON.stringify(result.expected.paraphrases) !== JSON.stringify(result.actual.paraphrases)) {
                     if (!headerShown) {
                       console.log('  Failure')

package/package.json

@@ -64,6 +64,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.6.0-beta.6",
+  "version": "7.6.0-beta.8",
   "license": "ISC"
 }

package/src/generators.js

@@ -73,7 +73,8 @@ class Generator {
     return matches
   }
 
-  apply (baseArgs, objects, g, gs, context, hierarchy, config, response, log, options = {}) {
+  // apply (baseArgs, objects, g, gs, context, hierarchy, config, response, log, options = {}) {
+  apply (baseArgs, objects, context, hierarchy, config, response, log, options = {}) {
     if (!log) {
       throw new Error('generators.apply argument log is required')
     }
@@ -103,12 +104,12 @@ class Generator {
             log, 
             global: 
             objects, 
-            g, 
+            // g, 
             n, 
             hierarchy, 
             context, 
             uuid: this.uuid, 
-            gs, 
+            // gs, 
             config, 
             response, 
             api: this.getAPI(config), 
@@ -165,136 +166,125 @@ class Generators {
     this.logs = logs
   };
 
-  // assumed - properties added to contexts before the generators are called. For setting paraphrase property
-  apply (args, contexts, assumed = {}, options = {}) {
+  // assumed - properties added to context before the generators are called. For setting paraphrase property
+  apply (args, context, assumed = {}, options = {}) {
+    if (Array.isArray(context)) {
+      return new Error("Expected a context not an array")
+    }
+    if (typeof context !== 'object') {
+      return String(context)
+    }
+
     const config = args.config
     const objects = args.objects
     const hierarchy = args.hierarchy
     const response = args.response
-    if (Array.isArray(contexts)) {
-      // no-op
-    } else if (typeof contexts === 'object') {
-      contexts = [contexts]
-    } else {
-      return String(contexts)
-    }
 
-    const contextsPrime = []
-    for (const icontext in contexts) {
-      let context = contexts[icontext]
-      context = Object.assign({}, context, assumed)
-      // let context_prime = JSON.stringify(context);
-      let generated = context
-      let applied = false
-      const stack = args.calls.push()
-      for (let igenerator = 0; igenerator < this.generators.length; ++igenerator) {
-        const generator = this.generators[igenerator]
-        if (generator.matches(args, objects, context, hierarchy, config, options)) {
-          const g = (context, options) => {
-            const r = this.apply(args, context, Object.assign({}, ((options||{}).assumed || {}), assumed), options)
-            if (Array.isArray(r)) {
-              return r.join(' ')
-            } else {
-              return r
-            }
-          }
-          const log = (message) => { this.logs.push(message) }
-          // this.logs.push(`Generators: applied ${generator.toString()}\n to\n ${JSON.stringify(context)}`)
-          let errorMessage = 'The apply function did not return a value'
-          try {
-            generated= generator.apply(args, objects, g, args.gs, context, hierarchy, config, response, log)
-          } catch( e ) {
-            // the next if handle this
-            generated = null
-            e.retryCall = () => generator.apply(args, objects, g, args.gs, context, hierarchy, config, response, log)
-            const help = 'The error has a retryCall property that will recall the function that failed.'
-            if (e.stack && e.message) {
-              const info = `${generator.notes ? generator.notes : ''}${generator.where ? generator.where : ''}`
-              errorMessage = `Error applying generator '${info}. Error is ${e.toString()} stack is ${e.stack}. Generator is ${generator.toString()}. ${help}`
-            } else if (e.error) {
-              const info = `${generator.notes ? generator.notes : ''}${generator.where ? generator.where : ''}`
-              errorMessage = `Error applying generator '${info}. Error is ${e.error.join()}. Generator is ${generator.toString()}. ${help}`
-            } else {
-							errorMessage = e.toString()
-						}
+    
+    // args = { ...args, ...args.getAssumedScoped(assumed) }
+    args.addAssumedScoped(args, assumed) 
+    context = Object.assign({}, context, args.assumed)
+    let generated = ''
+    let applied = false
+    const stack = args.calls.push()
+    for (let igenerator = 0; igenerator < this.generators.length; ++igenerator) {
+      const generator = this.generators[igenerator]
+      if (generator.matches(args, objects, context, hierarchy, config, options)) {
+        const log = (message) => { this.logs.push(message) }
+        // this.logs.push(`Generators: applied ${generator.toString()}\n to\n ${JSON.stringify(context)}`)
+        let errorMessage = 'The apply function did not return a value'
+        try {
+          generated= generator.apply(args, objects, context, hierarchy, config, response, log)
+        } catch( e ) {
+          // the next if handle this
+          generated = null
+          e.retryCall = () => generator.apply(args, objects, context, hierarchy, config, response, log)
+          const help = 'The error has a retryCall property that will recall the function that failed.'
+          if (e.stack && e.message) {
+            const info = `${generator.notes ? generator.notes : ''}${generator.where ? generator.where : ''}`
+            errorMessage = `Error applying generator '${info}. Error is ${e.toString()} stack is ${e.stack}. Generator is ${generator.toString()}. ${help}`
+          } else if (e.error) {
+            const info = `${generator.notes ? generator.notes : ''}${generator.where ? generator.where : ''}`
+            errorMessage = `Error applying generator '${info}. Error is ${e.error.join()}. Generator is ${generator.toString()}. ${help}`
+          } else {
+            errorMessage = e.toString()
           }
-          if (!generated && generated !== '') {
-            const widths = [10, 10, 90]
-            const lines = new Lines(widths)
-            lines.setElement(0, 0, 'Generator')
-            const source = `${generator.km}/#${generator.index}`
-            lines.setElement(0, 2, `ERROR while applying (${source}) ${generator.toLabel()}`)
-            lines.newRow()
-            lines.setElement(0, 2, generator.toString())
-            lines.newRow()
-            lines.setElement(0, 1, 'TO')
-            lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(helpers.sortJson(context, { depth: 25 })))})`)
-            lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
-            lines.newRow()
-            lines.setElement(0, 1, 'STACK')
-            lines.setElement(0, 2, stack)
-						lines.newRow()
-						lines.setElement(0, 1, 'DEBUG')
-						lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
-            lines.newRow()
-            lines.setElement(0, 1, 'ERROR')
-            lines.setElement(0, 2, errorMessage)
-            this.logs.push(lines.toString())
-            const message = `ERROR while applying (${source}) ${generator.toLabel()}\n to\n ${JSON.stringify(context, null, 2)}.\n${errorMessage}'`
-            // this.logs.push(message)
-            // return [message]
-            args.calls.pop()
-            throw { error: [message], logs: this.logs }
-          }
-          if (((config || {}).config || {}).debug) {
-            const widths = [10, 10, 90]
-            const lines = new Lines(widths)
-            lines.setElement(0, 0, 'Generator')
-            if (generator.index > -1 && generator.km) {
-              // lines.setElement(0, 2, `KM '${generator.km}' ordinal: ${generator.index}`)
-              lines.setElement(0, 2, generator.toLabel())
-            }
-            lines.newRow()
-            lines.setElement(0, 1, 'APPLIED')
+        }
+        if (!generated && generated !== '') {
+          const widths = [10, 10, 90]
+          const lines = new Lines(widths)
+          lines.setElement(0, 0, 'Generator')
+          const source = `${generator.km}/#${generator.index}`
+          lines.setElement(0, 2, `ERROR while applying (${source}) ${generator.toLabel()}`)
+          lines.newRow()
+          lines.setElement(0, 2, generator.toString())
+          lines.newRow()
+          lines.setElement(0, 1, 'TO')
+          lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(helpers.sortJson(context, { depth: 25 })))})`)
+          lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
+          lines.newRow()
+          lines.setElement(0, 1, 'STACK')
+          lines.setElement(0, 2, stack)
+          lines.newRow()
+          lines.setElement(0, 1, 'DEBUG')
+          lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
+          lines.newRow()
+          lines.setElement(0, 1, 'ERROR')
+          lines.setElement(0, 2, errorMessage)
+          this.logs.push(lines.toString())
+          const message = `ERROR while applying (${source}) ${generator.toLabel()}\n to\n ${JSON.stringify(context, null, 2)}.\n${errorMessage}'`
+          // this.logs.push(message)
+          // return [message]
+          args.calls.pop()
+          throw { error: [message], logs: this.logs }
+        }
+        if (((config || {}).config || {}).debug) {
+          const widths = [10, 10, 90]
+          const lines = new Lines(widths)
+          lines.setElement(0, 0, 'Generator')
+          if (generator.index > -1 && generator.km) {
+            // lines.setElement(0, 2, `KM '${generator.km}' ordinal: ${generator.index}`)
             lines.setElement(0, 2, generator.toLabel())
-            lines.newRow()
-            lines.setElement(0, 2, generator.toString())
-            lines.newRow()
-            lines.setElement(0, 1, 'RESULT')
-            lines.setElement(0, 2, generated)
-            lines.newRow()
-            lines.setElement(0, 1, 'STACK')
-            lines.setElement(0, 2, stack)
-						lines.newRow()
-						lines.setElement(0, 1, 'DEBUG')
-						lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
-						lines.newRow()
-            lines.setElement(0, 1, 'TO')
-            lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(helpers.sortJson(context, { depth: 25 })))})`)
-            lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
-            this.logs.push(lines.toString())
           }
-          applied = true
-          break
+          lines.newRow()
+          lines.setElement(0, 1, 'APPLIED')
+          lines.setElement(0, 2, generator.toLabel())
+          lines.newRow()
+          lines.setElement(0, 2, generator.toString())
+          lines.newRow()
+          lines.setElement(0, 1, 'RESULT')
+          lines.setElement(0, 2, generated)
+          lines.newRow()
+          lines.setElement(0, 1, 'STACK')
+          lines.setElement(0, 2, stack)
+          lines.newRow()
+          lines.setElement(0, 1, 'DEBUG')
+          lines.setElement(0, 2, `To debug this use args.callId == '${args.calls.current()}'`)
+          lines.newRow()
+          lines.setElement(0, 1, 'TO')
+          lines.setElement(0, 2, `(HASHCODE ${helpers.hashCode(JSON.stringify(helpers.sortJson(context, { depth: 25 })))})`)
+          lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
+          this.logs.push(lines.toString())
         }
+        applied = true
+        break
       }
-      args.calls.pop()
-      if (!applied && ((config || {}).config || {}).debug) {
-        const widths = [10, 10, 90]
-        const lines = new Lines(widths)
-        lines.setElement(0, 0, 'Generator')
-        lines.setElement(0, 2, 'No generator applied')
-        lines.newRow()
-        lines.setElement(0, 1, 'STACK')
-        lines.setElement(0, 2, stack)
-        lines.newRow()
-        lines.setElement(0, 1, 'TO')
-        lines.setElement(0, 2, JSON.stringify(context, null, 2))
-        this.logs.push(lines.toString())
-      }
-      contextsPrime.push((config || {}).parenthesized ? "(" + generated + ")" : generated)
     }
-    return contextsPrime
+    args.calls.pop()
+    if (!applied && ((config || {}).config || {}).debug) {
+      const widths = [10, 10, 90]
+      const lines = new Lines(widths)
+      lines.setElement(0, 0, 'Generator')
+      lines.setElement(0, 2, 'No generator applied')
+      lines.newRow()
+      lines.setElement(0, 1, 'STACK')
+      lines.setElement(0, 2, stack)
+      lines.newRow()
+      lines.setElement(0, 1, 'TO')
+      lines.setElement(0, 2, JSON.stringify(context, null, 2))
+      this.logs.push(lines.toString())
+    }
+    return ((config || {}).parenthesized ? "(" + generated + ")" : generated)
   }
 }