theprogrammablemind_4wp 7.5.7 → 7.5.8-beta.1

package/client.js

@@ -58,10 +58,10 @@ const vimdiff = (actualJSON, expectedJSON) => {
   // console.log(`vimdiff ${path}/actual.json ${path}/expected.json`)
   {
     const editor = runtime.process.env.EDITOR || 'vimdiff'
-    const child = runtime.child_process.spawn(editor, [`${path}/expected.json`, `${path}/actual.json`], { stdio: 'inherit' })
-    child.on('exit', function (e, code) {
-      console.log('finished')
-    })
+    debugger
+    // 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'})
   }
 }
 
@@ -100,10 +100,23 @@ const asList = (context) => {
   }
 }
 
+class ErrorReason extends Error {
+   constructor(context) {
+     super(JSON.stringify(context))
+     this.reason = context
+   }
+}
+
 const setupArgs = (args, config, logs, hierarchy) => {
   config.setArgs(args)
-  args.calls = new InitCalls()
+  args.calls = new InitCalls(config.name)
+  if (global.theprogrammablemind && global.theprogrammablemind.loadForTesting) {
+    args.calls = new InitCalls(Object.keys(global.theprogrammablemind.loadForTesting)[0])
+  }
   args.km = (name) => config.getConfig(name)
+  args.error = (context) => {
+    throw new ErrorReason(context)
+  }
   args.kms = config.getConfigs()
   args.config = config
   args.hierarchy = hierarchy
@@ -139,7 +152,10 @@ const setupArgs = (args, config, logs, hierarchy) => {
   args.g = (c) => config.getGenerators(logs).apply(args, c)
   args.gp = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: true, isResponse: false, response: false})
   args.gr = (c) => config.getGenerators(logs).apply(args, { ...c, paraphrase: false, isResponse: true })
-  args.e = (c) => config.getEvaluator(args.s, logs, c)
+  if (!logs) {
+    debugger
+  }
+  args.e = (c) => config.getEvaluator(args.s, args.calls, logs, c)
   args.log = (message) => logs.push(message)
   // config.getAddedArgs(args)
   args.gs = gs(args.g)
@@ -349,6 +365,9 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
 
   const objects = config.get('objects')
   const args = { objects, isResponse: true, response: json, isTest, getObjects: getObjects(objects) }
+  if (!json.logs) {
+    json.logs = []
+  }
   setupArgs(args, config, json.logs, hierarchy)
   const toDo = [...contexts]
   args.insert = (context) => toDo.unshift(context)
@@ -395,7 +414,8 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
               const mostCalled = semantics.getMostCalled()
               e.message += `\nThe most called semantic was:\nnotes: ${mostCalled.notes}\nmatch: ${mostCalled.matcher.toString()}\napply: ${mostCalled._apply.toString()}\n`
             }
-            throw e;
+            // contextPrime = semantics.apply(args, { marker: 'error', context, error: e })
+            contextPrime = semantics.apply(args, { marker: 'error', context, reason: e.reason })
           }
         }
       }
@@ -846,10 +866,12 @@ const saveTest = async (testFile, config, test, expected, testConfig, saveDevelo
   const args = {
   }
   const saveObjects = {...config.config.objects}
+  /*
   saveObjects.nameToUUID = {}
   for (let 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)
 }
 
@@ -1333,7 +1355,11 @@ const knowledgeModule = async ({
       if (config.needsRebuild(template.template, template.instance)) {
         throw `This module "${config.name}" cannot be used because the instance file needs rebuilding. Run on the command line with no arguements or the -rt argument to rebuild.`
       }
-      config.load(template.template, template.instance)
+      try {
+        config.load(template.template, template.instance)
+      } catch( e ) {
+        errorHandler(e)
+      }
     }
   }
   if (isProcess) {
@@ -1576,11 +1602,6 @@ const knowledgeModule = async ({
 
           }
           runTests(config, test, { debug: args.debug, testConfig: useTestConfig, verbose: args.testVerbose || args.testAllVerbose, stopAtFirstError: !args.testAllVerbose }).then((results) => {
-            if (results.length > 0 && args.vimdiff) {
-              for (const result of results) {
-                vimdiff(result.expected, result.actual)
-              }
-            }
             let newError = false
             if (results.length > 0) {
               let headerShown = false
@@ -1632,10 +1653,19 @@ const knowledgeModule = async ({
                     lines.setElement(1, 1, 'actual checked')
                     lines.setElement(2, 2, JSON.stringify(result.actual.checked, null, 2))
                     lines.log()
+                    if (args.vimdiff) {
+                      vimdiff(result.actual.checked, result.expected.checked)
+                    }
                     newError = true
                     headerShown = true
                   }
                 }
+              } else {
+                if (results.length > 0 && args.vimdiff) {
+                  for (const result of results) {
+                    vimdiff(result.actual, result.expected)
+                  }
+                }
               }
               if (!headerShown) {
                 if (!(useTestConfig.check && useTestConfig.check.length > 0)) {

package/package.json

@@ -44,6 +44,7 @@
     "src/config.js",
     "src/copy.js",
     "src/digraph.js",
+    "src/digraph_internal.js",
     "src/generators.js",
     "src/semantics.js"
   ],
@@ -62,6 +63,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.5.7",
+  "version": "7.5.8-beta.1",
   "license": "ISC"
 }

package/src/config.js

@@ -79,7 +79,8 @@ const handleBridgeProps = (config, bridge) => {
   if (bridge.generatorp) {
     config.config.generators.unshift({ 
       where: bridge.generatorp.where || bridge.where || client.where(4),
-      match: ({context}) => bridge.id == context.marker && context.paraphrase,
+      // match: ({context}) => bridge.id == context.marker && context.paraphrase,
+      match: ({context}) => bridge.id == context.marker && context.level == bridge.level + 1 && context.paraphrase,
       apply: (args) => bridge.generatorp(args),
       applyWrapped: bridge.generatorp,
       property: 'generatorp',
@@ -614,8 +615,9 @@ class Config {
     return instance
   }
   */
-  getEvaluator (s, log, context) {
+  getEvaluator (s, calls, log, context) {
     const instance = s({ ...context, evaluate: true })
+    calls.touch(instance)
     if (!instance.evalue && !instance.verbatim && !instance.value) {
       this.warningNotEvaluated(log, context);
     }

package/src/digraph_internal.js

@@ -0,0 +1,131 @@
+const toA = (edge) => {
+  if (Array.isArray(edge)) {
+    return edge
+  } else {
+    return [edge.child, edge.parent]
+  }
+}
+
+class DigraphInternal {
+  // edges maybe either [child, parent] or { child, parent }
+  constructor (edges = []) {
+    // dont make a copy of edges. this is shared and that breaks stuff. TODO fix this
+    this._edges = edges
+  }
+
+  addEdges(edges) {
+    for (let edge of edges) {
+      this.addEdge(edge)
+    }
+  }
+
+  addEdge(edge) {
+    edge = toA(edge)
+    this._edges.push(edge)
+  }
+
+  get edges() {
+    return this._edges
+  }
+
+  set edges(edges) {
+    this._edges = edges
+  }
+
+/*
+  set edges(edges) {
+    this._edges = edges.map( toA )
+  }
+*/
+
+  acdcs (s, from, to) {
+    const todo = [s]
+    const seen = new Set([s])
+    const acdcs = new Set([])
+    while (todo.length > 0) {
+      const n = todo.pop()
+      this._edges.forEach((e) => {
+        e = toA(e)
+        if (e[from] === n) {
+          acdcs.add(e[to])
+          if (!seen.has(e[to])) {
+            todo.push(e[to])
+            seen.add(e[to])
+          }
+        }
+      })
+    }
+    return acdcs
+  }
+
+  isA (low, high) {
+    if (low === high) {
+      return true
+    }
+    return this.ancestors(low).has(high)
+  }
+
+  lessThan (low, high) {
+    if (low === high) {
+      return false
+    }
+    return this.ancestors(low).has(high)
+  }
+
+  descendants (s) {
+    return this.acdcs(s, 1, 0)
+  }
+
+  ancestors (s) {
+    return this.acdcs(s, 0, 1)
+  }
+
+  minima (nodes) {
+    let minima = new Set(nodes)
+    const ancestors = new Set([])
+    nodes.forEach((node) => {
+      this.ancestors(node).forEach((n) => ancestors.add(n))
+    })
+    ancestors.forEach((n) => minima.delete(n))
+    if (minima.size === 0) {
+      // all unrelated
+      minima = new Set(nodes)
+    }
+    return minima
+  }
+
+  maxima (nodes) {
+    const maxima = new Set(nodes)
+    const descendants = new Set([])
+    nodes.forEach((node) => {
+      this.descendants(node).forEach((n) => descendants.add(n))
+    })
+    descendants.forEach((n) => maxima.delete(n))
+    return maxima
+  }
+
+  add (child, parent) {
+    this._edges.push([child, parent])
+  }
+
+  addList (l) {
+    for (let i = 1; i < l.length; ++i) {
+      this._edges.push([l[i - 1], l[i]])
+    }
+  }
+
+  order (todo) {
+    const ordered = []
+    while (todo.length > 0) {
+      const nodes = this.minima(todo)
+      todo = todo.filter((e) => !nodes.has(e))
+      for (const node of nodes) {
+        ordered.push(node)
+      }
+      // ordered = ordered.concat([...nodes])
+    }
+    return ordered
+  }
+}
+
+module.exports = DigraphInternal

package/src/helpers.js

@@ -172,10 +172,11 @@ nextContextId = 0
 
 class InitCalls {
 
-  constructor() {
+  constructor(name) {
     this.nextCallId = 0
     this.nextContextId = 0
     this.stack = []
+    this.name = name
   }
 
   start() {
@@ -192,13 +193,13 @@ class InitCalls {
     // this.nextCallId += 1
     // this.stack.push(this.nextCallId)
     this.stack.push(this.nextCallId)
-    const calls = this.stack.map( (call) => `call${call}` )
+    const calls = this.stack.map( (call) => `${this.name}#call${call}` )
     // return `Context#${this.nextContextId}: ${calls}`
     return `Context#${nextContextId}: ${calls}`
   }
 
   current() {
-    return `call${this.stack[this.stack.length-1]}`
+    return `${this.name}#call${this.stack[this.stack.length-1]}`
   }
 
   touch(context) {

package/src/semantics.js

@@ -237,7 +237,7 @@ class Semantics {
           // this.logs.push(message)
           // return [message]
           args.calls.pop()
-          throw { error: [message], logs: this.logs }
+          throw { error: [message], logs: this.logs, reason: e.reason }
         }
         args.calls.touch(contextPrime)
         // this.logs.push(`Semantics: applied ${semantic.toString()}\n to\n ${JSON.stringify(context)}\n the result was ${JSON.stringify(contextPrime)}\n`)