theprogrammablemind 7.12.4 → 7.12.5

package/client.js

@@ -10,12 +10,47 @@ const _ = require('lodash')
 const stringify = require('json-stable-stringify')
 const Lines = require('./lines')
 const flattens = require('./src/flatten')
-const { appendNoDups, InitCalls, updateQueries, safeNoDups } = require('./src/helpers')
+const { appendNoDups, InitCalls, updateQueries, safeNoDups, stableId } = require('./src/helpers')
 const runtime = require('./runtime')
 const sortJson = runtime.sortJson
 
-const getConfig_getObjectsCheck = (testConfig) => {
-  return (testConfig.checks && testConfig.checks.objects) || []
+function where (goUp = 2) {
+  const e = new Error()
+  const regexForm1 = /\((.*):(\d+):(\d+)\)$/
+  const regexForm2 = /at (.*):(\d+):(\d+)$/
+  const lines = e.stack.split('\n')
+  let line
+  let match
+  for (line of lines.slice(1)) {
+    // if (!(line.includes('config.js:') || line.includes('client.js:') || line.includes('<anonymous>'))) {
+    if (!(line.includes('config.js:') || line.includes('client.js:'))) {
+      match = regexForm1.exec(line) || regexForm2.exec(line)
+      if (!match) {
+        continue
+      }
+      break
+    }
+  }
+  // const line = e.stack.split("\n")[goUp];
+  // const match = regexForm1.exec(line) || regexForm2.exec(line)
+  if (match) {
+    return `${match[1]}:${match[2]}`
+  } else {
+    return 'running in browser'
+  }
+}
+
+const getConfig_getObjectsCheck = (config, testConfig) => {
+  let testConfigName = config.name
+  if (testConfig.testModuleName) {
+    testConfigName = testConfig.testModuleName
+  }
+  const checks = (testConfig.checks && testConfig.checks.objects) || []
+  if (Array.isArray(checks)) {
+    return { [testConfigName]: checks }
+  } else {
+    return checks
+  }
 }
 
 const getConfig_getContextCheck = (testConfig) => {
@@ -26,61 +61,122 @@ const pickContext = (testConfig) => (context) => {
   return project(context, getConfig_getContextCheck(testConfig))
 }
 
-const pickObjects = (testConfig, objects) => {
-  return project(objects, getConfig_getObjectsCheck(testConfig))
+const pickObjects = (config, testConfig, getObjects) => {
+  /*
+  let testConfigName = config.name
+  if (testConfig.testModuleName) {
+    objects = getObjects(config.config.objects)(config.getConfigs()[testConfig.testModuleName].uuid)
+    testConfigName = testConfig.testModuleName
+  }
+  */
+  const checks = getConfig_getObjectsCheck(config, testConfig)
+  const projection = {}
+  for (let km in checks) {
+    const objects = getObjects(km)
+    if (!objects) {
+      throw new Error(`In the checks for ${config.name} the KM ${km} does not exist`)
+    }
+    projection[km] = project(objects, checks[km])
+  }
+  return projection
 }
 
-// move ask to the KM's since verbatim is called
-const getAsk = (config) => (uuid) => (asks) => {
-  for (const ask of asks) {
-    let oneShot = true // default
-    if (ask.oneShot === false) {
-      oneShot = false
-    }
-    config.addSemantic({
-      uuid,
-      oneShot,
-      match: (args) => ask.matchr(args),
-      apply: (args) => ask.applyr(args)
-    })
-  }
-  let oneShot = true
-  for (const ask of asks) {
-    if (ask.oneShot === false) {
-      oneShot = false
-    }
-  }
-  config.addSemantic({
-    uuid,
-    oneShot,
-    match: ({ context }) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
-    apply: (args) => {
-      for (const ask of asks) {
-        let matchq = ask.matchq
-        let applyq = ask.applyq
-        if (!matchq) {
-          let wasAsked = false
-          matchq = () => !wasAsked,
-          applyq = (args) => {
-            wasAsked = true
-            applyq(args)
+// move ask to the KM's since verbatim is called probably in dialogues?
+const getAsk = (config) => (uuid) => {
+    // if (!uuid) {
+    //  debugger
+    //}
+    return (asks) => {
+    const ask = (ask) => {
+      let oneShot = true // default
+      if (ask.oneShot === false) {
+        oneShot = false
+      }
+
+      const id_q = stableId('semantic')
+      const id_rs = []
+      let wasAsked = false
+      let wasApplied = false
+      const getWasAsked = () => {
+        return wasAsked
+      }
+      const setWasAsked = (value) => {
+        wasAsked = value
+      }
+      const getWasApplied = () => {
+        return wasApplied
+      }
+      const setWasApplied = (value) => {
+        wasApplied = value
+      }
+
+      const semanticsr = ask.semanticsr || []
+      if (semanticsr.length == 0) {
+        semanticsr.push({ match: ask.matchr, apply: ask.applyr })
+      }
+      for (const semantic of semanticsr) {
+        const id_r = stableId('semantic')
+        id_rs.push(id_r)
+        config.addSemantic({
+          uuid,
+          id: id_r,
+          tied_ids: [id_q],
+          oneShot,
+          where: semantic.where || ask.where || where(2),
+          source: 'response',
+          match: (args) => semantic.match(args),
+          apply: (args) => {
+            setWasApplied(true)
+            semantic.apply(args)
+          },
+        })
+      }
+      
+      config.addSemantic({
+        uuid,
+        oneShot,
+        id: id_q,
+        tied_ids: id_rs,
+        where: ask.where,
+        isQuestion: true,  // do one question at a time
+        getWasAsked,
+        getWasApplied,
+        onNevermind: ask.onNevermind,
+        source: 'question',
+        match: ({ context }) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
+        apply: (args) => {
+          let matchq = ask.matchq
+          let applyq = ask.applyq
+          if (!matchq) {
+            let wasAsked = false
+            matchq = () => !wasAsked,
+            applyq = (args) => {
+              wasAsked = true
+              return ask.applyq(args)
+            }
           }
+          if (matchq(args)) {
+            setWasAsked(true)
+            setWasApplied(false)
+            // args.context.motivationKeep = true
+            args.verbatim(applyq(args))
+            /*
+              args.context.verbatim = applyq(args)
+              args.context.isResponse = true;
+              delete args.context.controlRemove;
+              */
+            args.context.controlKeepMotivation = true
+          }
+          args.context.cascade = true
         }
-        if (matchq(args)) {
-          // args.context.motivationKeep = true
-          args.verbatim(applyq(args))
-          /*
-            args.context.verbatim = applyq(args)
-            args.context.isResponse = true;
-            delete args.context.controlRemove;
-            */
-          args.context.controlKeepMotivation = true
-          break
-        }
-      }
-      args.context.cascade = true
+      })
     }
-  })
+    if (!Array.isArray(asks)) {
+      asks = [asks]
+    }
+
+    [...asks].reverse().forEach( (a) => ask(a) )
+  }
 }
 
 const sameJSON = (json1, json2) => {
@@ -105,6 +201,9 @@ const vimdiff = (actualJSON, expectedJSON, title) => {
 }
 
 const listable = (hierarchy) => (c, type) => {
+  if (!c) {
+    return false
+  }
   if (hierarchy.isA(c.marker, type)) {
     return true
   }
@@ -119,6 +218,9 @@ const listable = (hierarchy) => (c, type) => {
 }
 
 const isA = (hierarchy) => (child, parent) => {
+  if (!child || !parent) {
+    return false
+  }
   if (child.marker) {
     child = child.marker
   }
@@ -147,7 +249,8 @@ class ErrorReason extends Error {
 }
 
 const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
-  config.setArgs(args)
+
+  // callId
   args.calls = new InitCalls(args.isInstance ? `${args.isInstance}#${config.name}` : config.name)
   if (global.theprogrammablemind && global.theprogrammablemind.loadForTesting) {
     args.calls = new InitCalls(Object.keys(global.theprogrammablemind.loadForTesting)[0])
@@ -165,32 +268,11 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   args.asList = asList
   args.retry = () => { throw new RetryError() }
   args.fragments = (query) => config.fragment(query)
-  const scopedAsk = getAsk(config)
-
-  const getAPI = (uuid) => {
-    if (config && config.getAPI) {
-      return config.getAPI(uuid)
-    }
-  }
-  const getAPIs = (uuid) => {
-    if (config && config.getAPIs) {
-      return config.getAPIs(uuid)
-    }
-  }
-  args.getUUIDScoped = (uuid) => {
-    return {
-      ask: scopedAsk(uuid),
-      api: getAPI(uuid),
-      apis: getAPIs(uuid)
-    }
-  }
-  Object.assign(args, args.getUUIDScoped(uuidForScoping))
   args.breakOnSemantics = false
   args.theDebugger = {
     breakOnSemantics: (value) => args.breakOnSemantics = value
   }
   if (!logs) {
-    debugger
   }
   args.log = (message) => logs.push(message)
 
@@ -219,6 +301,33 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   // for semantics
   args.addAssumedScoped(args, {})
   config.getAddedArgs(args)
+
+  const getAPI = (uuid) => {
+    if (config && config.getAPI) {
+      return config.getAPI(uuid)
+    }
+  }
+  const getAPIs = (uuid) => {
+    if (config && config.getAPIs) {
+      return config.getAPIs(uuid)
+    }
+  }
+  const scopedAsk = getAsk(config)
+  args.getUUIDScoped = (uuid) => {
+    return {
+      ask: scopedAsk(uuid),
+      api: getAPI(uuid),
+      apis: getAPIs(uuid)
+    }
+  }
+  Object.assign(args, args.getUUIDScoped(uuidForScoping || config.uuid))
+  /*
+  if (uuidForScoping) {
+    Object.assign(args, args.getUUIDScoped(uuidForScoping))
+  }
+  */
+  // sets args for all the API. that make a copy so the args must be fully setup by here except for scoped
+  config.setArgs(args)
 }
 
 const gs = (g) => (contexts, separator, lastSeparator) => {
@@ -657,10 +766,8 @@ const loadInstance = (config, instance) => {
         config.config.skipSemantics = results.skipSemantics
       }
       const args = { config, hierarchy, json: results, commandLineArgs: {} }
-      if (instance.queries) {
-        args.isInstance = `instance${i}`
-        args.instance = instance.queries[i]
-      }
+      args.isInstance = `instance${i}`
+      args.instance = ''
       processContextsB(args)
       if (results.skipSemantics) {
         config.config.skipSemantics = null
@@ -777,6 +884,7 @@ const _process = async (config, query, { initializer, commandLineArgs, credentia
         response.trace = response.trace.concat(json.trace)
         response.version = json.version
         response.explain_priorities = json.explain_priorities
+        response.contextual_priorities_ambiguities = json.contextual_priorities_ambiguities
 
         response.contexts = response.contexts.concat(contextsPrime)
         response.generated = response.generated.concat(generatedPrime)
@@ -851,11 +959,6 @@ const runTest = async (config, expected, { args, verbose, 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
-  }
   try {
     const result = await _process(config, test, { errorHandler, isTest: true })
     result.query = test
@@ -895,7 +998,7 @@ const runTest = async (config, expected, { args, verbose, testConfig, debug }) =
       }
       return expected.objects.namespaced[expected.objects.nameToUUID[name]] || {}
     }
-    const expected_checked = sortJson(pickObjects(testConfig, expectedGetObjects(testConfigName)), { depth: 25 })
+    const expected_checked = sortJson(pickObjects(config, testConfig, expectedGetObjects), { depth: 25 })
     const actualGetObjects = (name) => {
       if (!name) {
         name = config.name
@@ -903,7 +1006,7 @@ const runTest = async (config, expected, { args, verbose, testConfig, debug }) =
       const km = config.configs.find((km) => km.name == name)
       return config.config.objects.namespaced[km.uuid] || {}
     }
-    const actual_checked = sortJson(pickObjects(testConfig, actualGetObjects(testConfigName)), { depth: 25 })
+    const actual_checked = sortJson(pickObjects(config, testConfig, actualGetObjects), { depth: 25 })
     const failed_checked = !matching(actual_objects, expected_objects)
 
     const failed_checks = !matching(actual_objects, expected_objects)
@@ -1155,6 +1258,24 @@ const defaultErrorHandler = async (error) => {
   throw error
 }
 
+const printContextualPrioritiesAmbiguities = (cpa) => {
+  console.log('Contextual Priorities Ambiguities')
+  for (const counter in cpa) {
+    console.log(`  Counter ${counter}`)
+    for (const choices of cpa[counter]) {
+      console.log('     [')
+        for (const choice of choices) {
+          console.log('        [')
+          for (const element of choice) {
+            console.log(`          ${JSON.stringify(element)},`)
+          }
+          console.log('        ],')
+        }
+      console.log('     ],')
+    }
+  }
+}
+
 const defaultInnerProcess = (config, errorHandler, responses) => {
   if (responses.errors) {
     console.log('Errors')
@@ -1173,6 +1294,9 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
     console.log('Logs')
     responses.logs.forEach((log) => console.log(`    ${log}`))
   }
+  if (responses.contextual_priorities_ambiguities) {
+    printContextualPrioritiesAmbiguities(responses.contextual_priorities_ambiguities)
+  }
   console.log(responses.trace)
 
   if (global.beforeObjects) {
@@ -1211,8 +1335,15 @@ const defaultInnerProcess = (config, errorHandler, responses) => {
       console.log(`    inputs: ${JSON.stringify(inputs)} output: ${JSON.stringify(output)}  reason: ${reason}`)
     }
   }
-  const objects = config.get('objects').namespaced[config.uuid]
-  const picked = sortJson(pickObjects(config.testConfig, objects), { depth: 25 })
+  // const objects = config.get('objects').namespaced[config.uuid]
+  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 picked = sortJson(pickObjects(config, config.testConfig, actualGetObjects), { depth: 25 })
   if (!_.isEmpty(picked)) {
     console.log('--- Object showing only the checked values ---')
     console.log(JSON.stringify(picked, null, 2))
@@ -2024,6 +2155,13 @@ const knowledgeModuleImpl = async ({
       })
       f()
     } else if (args.query) {
+      let useTestConfig = testConfig
+      if (args.testModuleName) {
+        config.testConfig.testModuleName = args.testModuleName
+        config.testConfig.checks = config.getConfigs()[args.testModuleName].getTestConfig().checks
+        // useTestConfig = config.getConfigs()[args.testModuleName].getTestConfig()
+        // useTestConfig.testModuleName = args.testModuleName
+      }
       const objects = getObjects(config.config.objects)(config.uuid)
       // for the compare
       if (args.objectDiff) {
@@ -2118,26 +2256,6 @@ const ensureTestFile = (module, name, type) => {
   }
 }
 
-function where (goUp = 2) {
-  const e = new Error()
-  const regexForm1 = /\((.*):(\d+):(\d+)\)$/
-  const regexForm2 = /at (.*):(\d+):(\d+)$/
-  const lines = e.stack.split('\n')
-  let line
-  for (line of lines.slice(1)) {
-    if (!(line.includes('config.js:') || line.includes('client.js:'))) {
-      break
-    }
-  }
-  // const line = e.stack.split("\n")[goUp];
-  const match = regexForm1.exec(line) || regexForm2.exec(line)
-  if (match) {
-    return `${match[1]}:${match[2]}`
-  } else {
-    return 'running in browser'
-  }
-}
-
 function w (func) {
   func.where = where(3)
   return func

package/package.json

@@ -65,6 +65,6 @@
     "json-stable-stringify": "^1.0.1",
     "node-fetch": "^2.6.1"
   },
-  "version": "7.12.4",
+  "version": "7.12.5",
   "license": "UNLICENSED"
 }

package/src/config.js

@@ -199,7 +199,7 @@ const priority_valid = (cp) => {
   )
 }
 
-const handleBridgeProps = (config, bridge, addFirst) => {
+const handleBridgeProps = (config, bridge, { addFirst, uuid } = {}) => {
   ecatch(`While processing the bridge for ${bridge.id}#${bridge.level}`,
     () => {
       if (!bridge.bridge) {
@@ -260,7 +260,8 @@ const handleBridgeProps = (config, bridge, addFirst) => {
       }
       */
 
-      const addUUID = (obj) => { return { ...obj, uuid: config.uuid } }
+      const addUUID = (obj) => { return { ...obj, uuid: uuid || config.uuid } }
+
       if (bridge.generators) {
         const generators = [...bridge.generators]
         generators.reverse()
@@ -343,14 +344,14 @@ const handleBridgeProps = (config, bridge, addFirst) => {
   )
 }
 
-const handleCalculatedProps = (baseConfig, moreConfig, addFirst) => {
+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',
         'level', 'optional', 'selector', 'semantic', 'words', /Bridge$/, 'localHierarchy', 'levelSpecificHierarchy', 'where', 'uuid']
       helpers.validProps(valid, bridge, 'bridge')
-      handleBridgeProps(baseConfig, bridge, addFirst)
+      handleBridgeProps(baseConfig, bridge, { addFirst, uuid })
       return bridge
     })
   }
@@ -466,7 +467,7 @@ const normalizeConfig = (config) => {
     if (config.semantics) {
       for (const semantic of config.semantics) {
         if (semantic.oneShot) {
-          semantic.id = uuid()
+          semantic.id = semantic.id || helpers.stableId('semantic')
         }
       }
     }
@@ -901,6 +902,10 @@ class Config {
     }
   }
 
+  get semantics() {
+    return [...this.config.semantics]
+  }
+
   getSemantics (logs = []) {
     return new Semantics(this.config.semantics, logs, { km: this.name })
   }
@@ -1314,7 +1319,7 @@ class Config {
     if (global.transitoryMode) {
       def.transitoryMode = true
     }
-    handleBridgeProps(this, def)
+    handleBridgeProps(this, def, { uuid })
     bridges.push(def)
     this.checkBridges()
     this._delta.json.bridges.push({ action: 'add', bridge: def })
@@ -1365,9 +1370,28 @@ class Config {
   }
 
   removeSemantic (deleteSemantic) {
-    const index = this.config.semantics.findIndex((semantic) => semantic.id === deleteSemantic.id)
-    if (index >= 0) {
-      this.config.semantics.splice(index, 1)
+    const id = deleteSemantic.id || deleteSemantic
+    const todo = [id]
+    const seen = new Set()
+
+    while (todo.length > 0) {
+      const id = todo.pop()
+      if (seen.has(id)) {
+        continue
+      }
+      seen.add(id)
+      const index = this.config.semantics.findIndex((semantic) => semantic.id === id)
+      if (index == -1) {
+        continue
+      }
+      for (const tied_id of this.config.semantics[index].tied_ids || []) {
+        if (!seen.has(tied_id)) {
+          todo.push(tied_id)
+        }
+      }
+      if (index >= 0) {
+        this.config.semantics.splice(index, 1)
+      }
     }
   }
 
@@ -1555,7 +1579,7 @@ class Config {
           config._api.multiApi[api].args = args
         }
       } else {
-        config._api.args = args
+        config._api.args = { ...args, ...args.getUUIDScoped(config.uuid) }
       }
     }
 
@@ -2842,7 +2866,7 @@ class Config {
     debugConfigProps(more)
 
     if (hcps) {
-      handleCalculatedProps(this, more, addFirst)
+      handleCalculatedProps(this, more, { addFirst, uuid })
       applyUUID(more, uuid || this._uuid)
     }
     for (const key of Object.keys(more)) {
@@ -3078,5 +3102,5 @@ module.exports = {
   Config,
   config_toServer,
   operatorKey_valid,
-  handleBridgeProps
+  handleBridgeProps,
 }

package/src/helpers.js

@@ -374,7 +374,15 @@ const subPriority = (sub, sup) => {
   return true
 }
 
+const stableIds = {}
+const stableId = (tag) => {
+  const id = stableIds[tag] || 1
+  stableIds[tag] = id + 1
+  return id
+}
+
 module.exports = {
+  stableId,
   ecatch,
   functionsToStrings,
   updateQueries,

package/src/semantics.js

@@ -6,7 +6,7 @@ class Semantic {
   // constructor ({match, apply, uuid, index, km, notes}) {
   constructor (semantic) {
     semantic = normalizeSemantic(semantic)
-    const { match, apply, uuid, index, km, notes, priority, debug, where, applyWrapped, property, oneShot, id } = semantic
+    const { match, apply, uuid, index, km, notes, priority, debug, where, source, applyWrapped, property, oneShot, id, tied_ids, isQuestion } = semantic
     this.matcher = match
     this._apply = apply
     this._applyWrapped = applyWrapped
@@ -18,8 +18,11 @@ class Semantic {
     this.notes = notes
     this.callId = debug
     this.where = where
+    this.source = source
     this.oneShot = oneShot
+    this.isQuestion = isQuestion
     this.id = id
+    this.tied_ids = tied_ids || []
   }
 
   toLabel () {
@@ -184,11 +187,16 @@ class Semantics {
     let applied = false
     const stack = args.calls.push()
     let counter = 0
+    let seenQuestion = false
     for (const isemantic in this.semantics) {
       const semantic = this.semantics[isemantic]
       if (!semantic) {
         debugger
       }
+      // only one question at a time
+      if (semantic.isQuestion && seenQuestion) {
+        continue
+      }
       if (semantic.matches(args, context, options)) {
         if (!this.calls[counter]) {
           this.calls[counter] = 0
@@ -198,6 +206,7 @@ class Semantics {
         try {
           contextPrime = semantic.apply(args, context, s, log, options)
           if (!contextPrime.controlKeepMotivation && semantic.oneShot) {
+            // semantic.tied_ids.forEach((tied_id) => args.config.removeSemantic(tied_id))
             args.config.removeSemantic(semantic)
           }
         } catch (e) {
@@ -274,6 +283,7 @@ class Semantics {
           this.logs.push(lines.toString())
         }
         applied = true
+        seenQuestion = seenQuestion || semantic.isQuestion
         if (contextPrime.cascade) {
           contextPrime.cascade = false
         } else {