theprogrammablemind 7.5.6 → 7.5.7-beta.0

package/client.js

@@ -1,5 +1,6 @@
 const { Semantics, Semantic } = require('./src/semantics')
 const { Generators, Generator } = require('./src/generators')
+const DigraphInternal = require('./src/digraph_internal')
 const Digraph = require('./src/digraph')
 const fetch = require('node-fetch')
 const base64 = require('base-64')
@@ -228,7 +229,7 @@ const processContext = (context, { objects = {}, config, logs = [] }) => {
   const response = {} // NA but passed in
   // generators = new Generators(generators.map((g) => new Generator(normalizeGenerator(g))))
   // semantics = new Semantics(semantics.map((g) => new Semantic(normalizeSemantic(g))))
-  const hierarchy = new Digraph((config.config || {}).hierarchy || [])
+  const hierarchy = new DigraphInternal((config.config || {}).hierarchy || [])
 
   const args = { objects, response, getObjects: getObjects(objects) }
   setupArgs(args, config, logs, hierarchy)
@@ -244,14 +245,18 @@ const processContext = (context, { objects = {}, config, logs = [] }) => {
 }
 
 const convertToStable = (objects) => {
-  const stableObjects = Object.assign({}, objects)
-  stableObjects.namespaced = {}
-  let counter = 0
-  Object.keys(((objects || {}).namespaced || {})).forEach((uuid) => {
-    stableObjects.namespaced[`${counter}`] = objects.namespaced[uuid]
-    counter += 1
-  })
-  return stableObjects
+  if (true) {
+    return objects
+  } else {
+    const stableObjects = Object.assign({}, objects)
+    stableObjects.namespaced = {}
+    let counter = 0
+    Object.keys(((objects || {}).namespaced || {})).forEach((uuid) => {
+      stableObjects.namespaced[`${counter}`] = objects.namespaced[uuid]
+      counter += 1
+    })
+    return stableObjects
+  }
 }
 
 const writeTestFile = (fn, tests) => {
@@ -378,7 +383,7 @@ const processContextsB = ({ config, hierarchy, semantics, generators, json, isTe
     context.topLevel = true
     try {
       if (json.has_errors) {
-        throw new Error('There are errors in the logs')
+        throw new Error('There are errors in the logs. Run with the -d flag and grep for Error')
       }
       if (!config.get('skipSemantics')) {
         if (!config.doMotivations(args, context)) {
@@ -505,7 +510,7 @@ const setupProcessB = ({ config, initializer, allowDelta=false } = {}) => {
   delete data.generators
   // const semantics = new Semantics((data.semantics || []).map((g) => new Semantic(normalizeSemantic(g))))
   delete data.semantics
-  const hierarchy = new Digraph((config.config || {}).hierarchy || [])
+  const hierarchy = new DigraphInternal((config.config || {}).hierarchy || [])
 
   return {
     data,
@@ -690,8 +695,10 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
   }
 
   let objects = getObjects(config.config.objects)(config.uuid)
+  let testConfigName = config.name
   if (testConfig.testModuleName) {
     objects = getObjects(config.config.objects)(config.getConfigs()[testConfig.testModuleName].uuid)
+    testConfigName = testConfig.testModuleName
   }
   config.beforeQuery({ query: test, isModule: false, objects })
   // config.resetMotivations()
@@ -715,15 +722,40 @@ const runTest = async (config, expected, { verbose, afterTest, testConfig, debug
       const failed_contexts = !matching(result.contexts, expected.contexts)
       const failed_objects = !matching(actual_objects, expected_objects)
 
-      const pickEm = (objects) => {
+      const pickEm = (getObjects) => {
         const picked = {}
         for (let prop of (testConfig.check || [])) {
-          picked[prop] = objects[prop]
+          if (prop.km) {
+            c = config.getConfig(prop.km)
+            o = getObjects(prop.km)
+            picked[prop.km] = {}
+            for (let p of c.testConfig.check) {
+              if (p.km) {
+                continue
+              }
+              picked[p] = o[p]
+            }
+          } else {
+            picked[prop] = getObjects(testConfigName)[prop]
+          }
         }
         return picked
       }
-      const expected_checked = sortJson(pickEm(expected.objects.namespaced[0]), { depth: 25 })
-      const actual_checked = sortJson(pickEm(objects), { depth: 25 })
+      const expectedGetObjects = (name) => {
+        if (!name) {
+          name = config.name
+        }
+        return expected.objects.namespaced[expected.objects.nameToUUID[name]]
+      }
+      const expected_checked = sortJson(pickEm(expectedGetObjects), { 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(pickEm(actualGetObjects), { depth: 25 })
       const failed_checked = !matching(actual_objects, expected_objects)
 
       const failed_checks = !matching(actual_objects, expected_objects)
@@ -811,7 +843,14 @@ const saveTest = async (testFile, config, test, expected, testConfig, saveDevelo
   const result = await _process(config, test, { isTest: true })
   // const actualObjects = config.config.objects
   const actualConfig = getConfigForTest(config, testConfig)
-  writeTest(testFile, test, config.config.objects, result.generated, result.paraphrases, result.responses, result.contexts, result.associations, result.metadata, actualConfig, saveDeveloper)
+  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)
 }
 
 const saveTestsHelper = async (testFile, config, tests, todo, testConfig, saveDeveloper) => {
@@ -849,12 +888,22 @@ const showInfo = (description, section, config) => {
       visibleExamples.push(test.query)
     }
   }
-  const info = { name, description, examples: visibleExamples, section, includes, demo: config.demo }
+  const templateQueries = []
+  if (config.instances && config.instances.length > 0) {
+    for (let query of config.instances.slice(-1)[0].queries) {
+      if (typeof query == 'string') {
+        templateQueries.push(query)
+      }
+    }
+  }
+  const info = { name, description, examples: visibleExamples, template: templateQueries, section, includes, demo: config.demo }
+  /*
   if (config.instances.length > 0) {
     info.template = {
       base: config.instances[0].base
     }
   }
+  */
   console.log(JSON.stringify(info, null, 2))
 }
 
@@ -1265,9 +1314,11 @@ const knowledgeModule = async ({
   processResults = processResults({ config, errorHandler })
   config.description = description
   config.demo = demo
-  if (typeof test === 'object' && test.contents) {
-    config.tests = test.contents
-    test = test.name
+  if (typeof test === 'object') {
+    if (test.contents) {
+      config.tests = test.contents
+      test = test.name
+    }
   } else {
     if (runtime.fs && runtime.fs.existsSync(test)) {
       config.tests = JSON.parse(runtime.fs.readFileSync(test))
@@ -1275,6 +1326,7 @@ const knowledgeModule = async ({
       config.tests = {}
     }
   }
+  config.setTestConfig(testConfig)
  
   if (!isProcess) {
     if (template) {
@@ -1652,7 +1704,6 @@ const knowledgeModule = async ({
     }
   } else {
     config.addAssociationsFromTests(config.tests);
-    config.setTestConfig(testConfig)
     //for (let query in config.tests) {
     //  config.addAssociations(config.tests[query].associations || []);
     //}

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.6",
+  "version": "7.5.7-beta.0",
   "license": "ISC"
 }

package/src/config.js

@@ -3,7 +3,7 @@ const { Semantics, normalizeGenerator } = require('./semantics')
 const { Generators } = require('./generators')
 // const { uuid: uuidv4 } = require('uuidv4')
 const client = require('../client')
-const Digraph = require('./digraph')
+const DigraphInternal = require('./digraph_internal')
 const helpers = require('./helpers')
 const runtime = require('../runtime')
 const _ = require('lodash')
@@ -1287,7 +1287,7 @@ class Config {
       this.name = config.name
     }
     this.motivations = []
-    this.loadOrder = new Digraph()
+    this.loadOrder = new DigraphInternal()
     this.wasInitialized = false
     this.configs = []
     this._api = undefined
@@ -1300,7 +1300,7 @@ class Config {
       this.config = config
       handleCalculatedProps(this, config)
     }
-    this.hierarchy = new Digraph(this.config.hierarchy)
+    this.hierarchy = new DigraphInternal(this.config.hierarchy)
     this.initConfig = _.cloneDeep(this.config)
     this.configs.push(new KM({ config: this.config, getCounter: (name) => this.config.getCounter(name), uuid: this._uuid }))
 
@@ -1854,7 +1854,7 @@ class Config {
     this.resetDelta()
     const debug = this.config.debug;
     this.config = _.cloneDeep(this.initConfig)
-    this.hierarchy = new Digraph(this.config.hierarchy)
+    this.hierarchy = new DigraphInternal(this.config.hierarchy)
     if (debug) {
       this.config.debug = debug
     }
@@ -1918,7 +1918,7 @@ class Config {
       config.wasInitialized = false
       // TODO change name of config: to baseConfig:
       const kmFn = (name) => this.getConfig(name)
-      // const hierarchy = new Digraph((config.config || {}).hierarchy)
+      // const hierarchy = new DigraphInternal((config.config || {}).hierarchy)
       const args = { isModule, addWord: aw, km: kmFn, hierarchy: this.hierarchy, config, baseConfig: this, currentConfig: config, uuid: config._uuid, objects: namespacedObjects, namespace, api: config.api }
       config.initializerFn(args)
       if (config.initAfterApi) {

package/src/digraph.js

@@ -13,6 +13,38 @@ class Digraph {
     this._edges = edges
   }
 
+  // BFS
+  path(from, to) {
+    debugger
+    const frontier = { [from]: [[]] }
+    const done = new Set()
+    while (Object.keys(frontier).length > 0) {
+      const n = Object.keys(frontier)[0]
+      const ps = frontier[n]
+      if (to == n) {
+        return ps[0]
+      }
+      if (done.has(n)) {
+        delete frontier[n]
+        continue
+      }
+      done.add(n)
+      for (let edge of this._edges) {
+        if (edge.child == n) {
+          if (!frontier[edge.parent]) {
+            frontier[edge.parent] = []
+          }
+          for (let path of ps) {
+            if (edge.parent == to) {
+              return [...path, edge]
+            }
+            frontier[edge.parent].push([...path, edge])
+          }
+        }
+      }
+    }
+  }
+
   addEdges(edges) {
     for (let edge of edges) {
       this.addEdge(edge)

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/generators.js

@@ -115,6 +115,9 @@ class Generator {
             apis: this.getAPIs(config) 
           }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
+    if (this.property == 'generatorp') {
+      args.g = args.gp
+    }
     // if (this.callId) {
     // greg
     /*
@@ -262,10 +265,10 @@ class Generators {
             lines.newRow()
             lines.setElement(0, 1, 'STACK')
             lines.setElement(0, 2, stack)
-            lines.newRow()
 						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))