ekms 9.5.0-beta.0 → 9.5.1-beta.0

package/common/helpers/properties.js

@@ -2,7 +2,7 @@ const pluralize = require('pluralize')
 const { unflatten, flattens, Digraph } = require('../runtime').theprogrammablemind
 const _ = require('lodash')
 const deepEqual = require('deep-equal')
-const { chooseNumber } = require('../helpers.js')
+const { chooseNumber, removeProp } = require('../helpers.js')
 const { Frankenhash } = require('./frankenhash.js')
 const { compose, translationMapping, translationMappingToInstantiatorMappings } = require('./meta.js')
 
@@ -263,12 +263,33 @@ class API {
   // relation -> the semantics will be implements using relations
   // edable: "y is owned by x" edable = { operator: 'owned' }
   createActionPrefix(args, semanticApply) {
-    const { operator, before=[], after=[], create=[], config, localHierarchy=[], relation, ordering, doAble, words = [], unflatten:unflattenArgs = [], focusable = [], edAble } = args;
-    // const before = [...]
-    // const after = [{tag: 'weapon', id: 'weapon'}]
-    // const create = ['arm', 'weapon']
+    const { 
+      operator, 
+      before=[], 
+      after=[], 
+      create:createInit=[], 
+      hierarchy=[], 
+      config, 
+      localHierarchy=[], 
+      relation, 
+      ordering, 
+      doAble, 
+      words = [], 
+      unflatten:unflattenArgs = [], 
+      focusable = [], 
+      edAble } = args;
+
+    const createToCanonical = (concept) => {
+      if (typeof concept == 'string') {
+        return { id: concept, isA: [] }
+      } else {
+        return { isA: [], ...concept }
+      }
+    }
 
-   if (doAble) {
+    const create = createInit.map(createToCanonical)
+
+    if (doAble) {
       if (before.length != 1) {
         throw "Expected exactly one before argument"
       }
@@ -323,7 +344,7 @@ class API {
       }
     }
 
-    create.map( (id) => {
+    create.map( ({ id, isA }) => {
       if (id === operator) {
         const tagsToProps = (where, args, suffix='') => {
           const i = 0;
@@ -341,13 +362,21 @@ class API {
           afterArgs = tagsToProps('after', after, '*')
         }
 
+        // const subjectContext = before[0].tag
+        // const interpolate = "[" + before.map((arg) => `{ property: '${arg.tag}' }`).concat(`{ ...operator, evaluateWord: true, number: ${subjectContext}.number }`).concat(after.map((arg) => `{ property: '${arg.tag}' }`)).join(',') + "]"
+        const imperative = (before.length == 0) ? "true" : "false"
+        // const interpolate = "[" + before.map((arg) => `{ property: '${arg.tag}' }`).concat(`{ ...operator, evaluateWord: true, imperative: ${imperative}, isVerb: true, number: 'one' }`).concat(after.map((arg) => `{ property: '${arg.tag}' }`)).join(',') + "]"
+        // const interpolateVerb = `{ property: "operator", context: { evaluateWord: true, imperative: ${imperative}, isVerb: true, number: 'one' } }`
+        const interpolateVerb = `{ property: "operator" }`
+        const interpolate = "[" + before.map((arg) => `{ property: '${arg.tag}' }`).concat(interpolateVerb).concat(after.map((arg) => `{ property: '${arg.tag}' }`)).join(',') + "]"
+
         const unflattenArgs = [ ...before.map( (arg) => arg.tag ), ...after.map( (arg) => arg.tag ) ] 
         const focusable = [ ...before.map( (arg) => arg.tag ), ...after.map( (arg) => arg.tag ) ] 
         config.addBridge({ 
           id: operator, 
           level: 0, 
           localHierarchy: [...localHierarchy, ['object', 'unknown']],
-          bridge: `{ ... next(operator) ${doParams} ${beforeArgs} ${afterArgs}, unflatten: ${JSON.stringify(unflattenArgs)}, focusable: ${JSON.stringify(focusable)} }`, 
+          bridge: `{ ... next(operator) ${doParams} ${beforeArgs} ${afterArgs}, operator: { ...operator, evaluateWord: true, imperative: ${imperative}, isVerb: true, number: 'one' }, unflatten: ${JSON.stringify(unflattenArgs)}, focusable: ${JSON.stringify(focusable)}, interpolate: ${interpolate} }`, 
           allowDups: true 
         })
         if (words.length > 0) {
@@ -360,6 +389,10 @@ class API {
       } else {
         config.addBridge({ id: id, allowDups: true })
       }
+
+      for (const parentId of isA) {
+        config.addHierarchy(id, parentId)
+      }
     })
 
     if (words.length == 0) {
@@ -369,6 +402,10 @@ class API {
       config.addWord(operatorPlural, { id: operator, initial: `{ value: '${operator}', number: 'many' }`})
     }
 
+    for (const { child, parent } of hierarchy) {
+      config.addHierarchy(child, parent)
+    }
+
     if (doAble) {
       config.addHierarchy(operator, 'canBeDoQuestion')
     }
@@ -376,49 +413,53 @@ class API {
     config.addPriority({ "context": [[operator, 0], ['means', 0], ], "choose": [0] })
     config.addPriority({ "context": [['article', 0], [operator, 0], ], "choose": [0] })
 
-    config.addGenerator({
-      notes: 'ordering generator for paraphrase',
-      match: ({context}) => context.marker == operator && context.paraphrase && !context.query,
-      apply: async ({context, gp, g}) => {
-        const beforeGenerator = []
-        for (const arg of before) {
-          beforeGenerator.push(await g(context[arg.tag]))
-        }
-        const afterGenerator = []
-        for (const arg of after) {
-          afterGenerator.push(await gp(context[arg.tag]))
-        }
-        const word = context.word
-        const sub = []
-        if (context.subphrase) {
-          sub.push(['that'])
+    if (false) {
+      config.addGenerator({
+        notes: 'ordering generator for paraphrase',
+        match: ({context}) => context.marker == operator && context.paraphrase && !context.query,
+        apply: async ({context, gp, g}) => {
+          const beforeGenerator = []
+          for (const arg of before) {
+            beforeGenerator.push(await g(context[arg.tag]))
+          }
+          const afterGenerator = []
+          for (const arg of after) {
+            afterGenerator.push(await gp(context[arg.tag]))
+          }
+          const word = context.word
+          const sub = []
+          if (context.subphrase) {
+            sub.push(['that'])
+          }
+          return beforeGenerator.concat(sub).concat([word]).concat(afterGenerator).join(' ')
         }
-        return beforeGenerator.concat(sub).concat([word]).concat(afterGenerator).join(' ')
-      }
-    })
+      })
+    }
 
-    config.addGenerator({
-      notes: 'ordering generator for response',
-      match: ({context}) => context.marker == operator && context.evalue && context.isResponse,
-      apply: async ({context, g, km}) => {
-        const brief = km("dialogues").api.getBrief()
-
-        const { evalue } = context 
-        let yesno = ''
-        if (!context.do.query || evalue.truthValueOnly || brief) {
-          if (evalue.truthValue) {
-            yesno = 'yes'
-          } else if (evalue.truthValue === false) {
-            yesno = 'no'
+    if (true) {
+      config.addGenerator({
+        notes: 'ordering generator for response',
+        match: ({context}) => context.marker == operator && context.evalue && context.isResponse,
+        apply: async ({context, g, km}) => {
+          const brief = km("dialogues").api.getBrief()
+
+          const { evalue } = context 
+          let yesno = ''
+          if (!context.do.query || evalue.truthValueOnly || brief) {
+            if (evalue.truthValue) {
+              yesno = 'yes'
+            } else if (evalue.truthValue === false) {
+              yesno = 'no'
+            }
+          }
+          if (evalue.truthValueOnly || brief) {
+            return `${yesno}`
+          } else {
+            return `${yesno} ${await g(Object.assign({}, evalue, { paraphrase: true }))}`
           }
         }
-        if (evalue.truthValueOnly || brief) {
-          return `${yesno}`
-        } else {
-          return `${yesno} ${await g(Object.assign({}, evalue, { paraphrase: true }))}`
-        }
-      }
-    })
+      })
+    }
  
     if (ordering) {
       config.addSemantic({
@@ -515,7 +556,7 @@ class API {
       config.addSemantic({
         notes: `getter for ${operator}`,
         match: ({context}) => context.marker == operator && context.query,
-        apply: ({context, km}) => {
+        apply: ({context, km, callId}) => {
           const api = km('properties').api
 
           context.evalue = {
@@ -552,6 +593,8 @@ class API {
   }
 
   relation_add (relations) {
+    removeProp(relations, (val, prop, obj) => prop === 'range')
+
     if (!Array.isArray(relations)) {
       relations = [relations]
     }
@@ -703,7 +746,6 @@ class API {
   }
 
   setProperty(object, property, value, has, skipHandler) {
-    // debugger
     if (!skipHandler) {
       const handler = this.propertiesFH.getHandler([object, property])
       if (handler) {

package/common/helpers.js

@@ -263,6 +263,58 @@ const processTemplateString = async (template, evaluate) => {
   return await processTemplateString(template)
 }
 
+// removeProp.js
+function removeProp(obj, testFn, { maxDepth = Infinity, seen = new WeakSet() } = {}) {
+  if (!obj || typeof obj !== 'object' || maxDepth <= 0) return obj;
+  if (seen.has(obj)) return obj;
+  seen.add(obj);
+
+  if (Array.isArray(obj)) {
+    // ---- ARRAY: process each element (but don't remove elements unless testFn says so)
+    let writeIdx = 0;
+    for (let i = 0; i < obj.length; i++) {
+      const element = obj[i];
+      const shouldRemoveElement = testFn(element, i, obj);
+
+      if (shouldRemoveElement) {
+        // Remove the whole array element
+        if (element && typeof element === 'object') {
+          // Still walk inside it in case testFn wants side effects
+          removeProp(element, testFn, { maxDepth: maxDepth - 1, seen });
+        }
+        // Skip writing it back
+      } else {
+        // Keep element, but walk into it to remove inner props
+        removeProp(element, testFn, { maxDepth: maxDepth - 1, seen });
+        if (writeIdx !== i) {
+          obj[writeIdx] = element;
+        }
+        writeIdx++;
+      }
+    }
+    obj.length = writeIdx;
+    return obj;
+  }
+
+  // ---- OBJECT: iterate over own keys
+  const keys = Reflect.ownKeys(obj);
+  for (const key of keys) {
+    const val = obj[key];
+    const shouldRemove = testFn(val, key, obj);
+
+    if (shouldRemove) {
+      delete obj[key];
+      if (val && typeof val === 'object') {
+        removeProp(val, testFn, { maxDepth: maxDepth - 1, seen });
+      }
+    } else {
+      removeProp(val, testFn, { maxDepth: maxDepth - 1, seen });
+    }
+  }
+
+  return obj;
+}
+
 module.exports = {
   processTemplateString,
   unshiftL,
@@ -284,4 +336,5 @@ module.exports = {
   wordNumber,
   requiredArgument,
   isA,
+  removeProp,
 }

package/common/latin.instance.json

@@ -4,7 +4,7 @@
       "apply": "({config}) => {\n      config.addArgs(({config, api, isA}) => ({\n        addLatinNoun: ({ id, nominative, genetive, development }) => {\n          config.addOperator({ pattern: `([${id}|])`, development: development })\n          config.addBridge({ id, isA: ['hierarchiable'] })\n          const declensions = getDeclensions(nominative, genetive)\n          for (const declension of declensions) {\n            config.addWord(declension.word, { id, initial: { ...declension, development } })\n          }\n        }\n      }))\n    }"
     },
     {
-      "apply": "({addLatinNoun}) => {\n      addLatinNoun({ id: 'davus_person', nominative: 'davus', development: true })\n      addLatinNoun({ id: 'titus_person', nominative: 'titus', development: true })\n      addLatinNoun({ id: 'pear_food', nominative: 'pirum', development: true })\n      addLatinNoun({ id: 'table_latin', nominative: 'mensa', development: true })\n    }"
+      "apply": "({addLatinNoun}) => {\n      addLatinNoun({ id: 'davus_person', nominative: 'davus', scope: \"testing\" })\n      addLatinNoun({ id: 'titus_person', nominative: 'titus', scope: \"testing\" })\n      addLatinNoun({ id: 'pear_food', nominative: 'pirum', scope: \"testing\" })\n      addLatinNoun({ id: 'table_latin', nominative: 'mensa', scope: \"testing\" })\n    }"
     },
     {
       "operators": [
@@ -238,7 +238,7 @@
       "apply": "({config}) => {\n      config.addArgs(({config, api, isA}) => ({\n        addLatinNoun: ({ id, nominative, genetive, development }) => {\n          config.addOperator({ pattern: `([${id}|])`, development: development })\n          config.addBridge({ id, isA: ['hierarchiable'] })\n          const declensions = getDeclensions(nominative, genetive)\n          for (const declension of declensions) {\n            config.addWord(declension.word, { id, initial: { ...declension, development } })\n          }\n        }\n      }))\n    }"
     },
     {
-      "apply": "({addLatinNoun}) => {\n      addLatinNoun({ id: 'davus_person', nominative: 'davus', development: true })\n      addLatinNoun({ id: 'titus_person', nominative: 'titus', development: true })\n      addLatinNoun({ id: 'pear_food', nominative: 'pirum', development: true })\n      addLatinNoun({ id: 'table_latin', nominative: 'mensa', development: true })\n    }"
+      "apply": "({addLatinNoun}) => {\n      addLatinNoun({ id: 'davus_person', nominative: 'davus', scope: \"testing\" })\n      addLatinNoun({ id: 'titus_person', nominative: 'titus', scope: \"testing\" })\n      addLatinNoun({ id: 'pear_food', nominative: 'pirum', scope: \"testing\" })\n      addLatinNoun({ id: 'table_latin', nominative: 'mensa', scope: \"testing\" })\n    }"
     },
     {
       "extraConfig": true,

package/common/latin.js

@@ -159,10 +159,10 @@ const template = {
       }))
     },
     ({addLatinNoun}) => {
-      addLatinNoun({ id: 'davus_person', nominative: 'davus', development: true })
-      addLatinNoun({ id: 'titus_person', nominative: 'titus', development: true })
-      addLatinNoun({ id: 'pear_food', nominative: 'pirum', development: true })
-      addLatinNoun({ id: 'table_latin', nominative: 'mensa', development: true })
+      addLatinNoun({ id: 'davus_person', nominative: 'davus', scope: "testing" })
+      addLatinNoun({ id: 'titus_person', nominative: 'titus', scope: "testing" })
+      addLatinNoun({ id: 'pear_food', nominative: 'pirum', scope: "testing" })
+      addLatinNoun({ id: 'table_latin', nominative: 'mensa', scope: "testing" })
     },
     config,
     ({addSuffix}) => addSuffix('que'),

package/common/listener.js

@@ -7,7 +7,7 @@ const listener_tests = require('./listener.test.json')
 const config = {
   name: 'listener',
   operators: [
-    { pattern: "([call])", development: true },
+    { pattern: "([call])", scope: "testing" },
   ],
   bridges: [
     {

package/common/math.instance.json

@@ -16,11 +16,11 @@
         "([divideByExpression|])",
         {
           "pattern": "([x])",
-          "development": true
+          "scope": "testing"
         },
         {
           "pattern": "([y])",
-          "development": true
+          "scope": "testing"
         }
       ],
       "bridges": [
@@ -47,7 +47,7 @@
           ],
           "level": 0,
           "bridge": "{ ...next(operator) }",
-          "development": true
+          "scope": "testing"
         },
         {
           "id": "y",
@@ -56,7 +56,7 @@
           ],
           "level": 0,
           "bridge": "{ ...next(operator) }",
-          "development": true
+          "scope": "testing"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/math.js:32",
@@ -1088,11 +1088,11 @@
         "([divideByExpression|])",
         {
           "pattern": "([x])",
-          "development": true
+          "scope": "testing"
         },
         {
           "pattern": "([y])",
-          "development": true
+          "scope": "testing"
         }
       ],
       "bridges": [
@@ -1119,7 +1119,7 @@
           ],
           "level": 0,
           "bridge": "{ ...next(operator) }",
-          "development": true
+          "scope": "testing"
         },
         {
           "id": "y",
@@ -1128,7 +1128,7 @@
           ],
           "level": 0,
           "bridge": "{ ...next(operator) }",
-          "development": true
+          "scope": "testing"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/math.js:32",

package/common/math.js

@@ -82,8 +82,8 @@ const config = {
     "([minusExpression|])", 
     "([timesExpression|])", 
     "([divideByExpression|])", 
-    { pattern: "([x])", development: true },
-    { pattern: "([y])", development: true },
+    { pattern: "([x])", scope: "testing" },
+    { pattern: "([y])", scope: "testing" },
   ],
   bridges: [
     { 
@@ -96,8 +96,8 @@ const config = {
       before: ['verb'],
       after: ['adjective'],
     },
-    { id: "x", isA: ['number'], level: 0, bridge: '{ ...next(operator) }', development: true},
-    { id: "y", isA: ['number'], level: 0, bridge: '{ ...next(operator) }', development: true},
+    { id: "x", isA: ['number'], level: 0, bridge: '{ ...next(operator) }', scope: "testing"},
+    { id: "y", isA: ['number'], level: 0, bridge: '{ ...next(operator) }', scope: "testing"},
     ...mathematicalOperator('plus', ['plus', '+'], (x, y) => x + y),
     ...mathematicalOperator('minus', ['minus', '-'], (x, y) => x - y),
     ...mathematicalOperator('times', ['times', '*'], (x, y) => x * y, [['plusOperator', 0], ['minusOperator', 0]]),

package/common/meta.js

@@ -26,13 +26,13 @@ const config = {
     "(([orAble|]) [orList|or] ([orAble|]))",
     // "cats is the plural of cat"
     // "is cat the plural of cats"
-    { pattern: "([x])", development: true },
+    { pattern: "([x])", scope: "testing" },
     // if f x then g x
-    { pattern: "([e])", development: true },
-    { pattern: "([f])", development: true },
-    { pattern: "([g])", development: true },
-    { pattern: "([undefined])", development: true },
-    { pattern: "([defined])", development: true },
+    { pattern: "([e])", scope: "testing" },
+    { pattern: "([f])", scope: "testing" },
+    { pattern: "([g])", scope: "testing" },
+    { pattern: "([undefined])", scope: "testing" },
+    { pattern: "([defined])", scope: "testing" },
 
     /*
     if creating a new word make a motivation to ask if word is plura or singlar of anohter wordA
@@ -61,9 +61,9 @@ const config = {
   //  [['means', 0], ['is', 0]],
   ],
   hierarchy: [
-    { child: 'e', parent: 'orAble', development: true },
-    { child: 'f', parent: 'orAble', development: true },
-    { child: 'g', parent: 'ifAble', development: true },
+    { child: 'e', parent: 'orAble', scope: "testing" },
+    { child: 'f', parent: 'orAble', scope: "testing" },
+    { child: 'g', parent: 'ifAble', scope: "testing" },
     { child: 'orAble', parent: 'ifAble' },
   ],
   bridges: [
@@ -94,12 +94,12 @@ const config = {
     { id: "then", level: 0, bridge: "{ ...next(operator), consequence: after[0] }" },
     { id: "ifAble" },
     { id: "orAble" },
-    { id: "x", development: true },
-    { id: "e", development: true },
-    { id: "f", development: true },
-    { id: "g", development: true },
-    { id: "undefined", development: true },
-    { id: "defined", development: true },
+    { id: "x", scope: "testing" },
+    { id: "e", scope: "testing" },
+    { id: "f", scope: "testing" },
+    { id: "g", scope: "testing" },
+    { id: "undefined", scope: "testing" },
+    { id: "defined", scope: "testing" },
 //    { id: "testWord2", level: 0, bridge: "{ ...next(operator) }" },
   ],
   version: '3',
@@ -107,12 +107,12 @@ const config = {
     "literals": {
       //  'testWord2': [{"id": "testWord2", "initial": "{ value: 'testWord2Value' }" }],
       // TODO make this development and select out for module
-      // 'x': [{id: "x", initial: "{ value: 'x' }", development: true }],
-      // 'f': [{id: "ifAble", initial: "{ word: 'f' }", development: true }],
-      // 'g': [{id: "ifAble", initial: "{ word: 'g' }", development: true }],
-      'f': [{id: "f", initial: "{ value: 'f', word: 'f' }", development: true }],
-      'x': [{id: "x", initial: "{ value: 'x', word: 'x' }", development: true }],
-      'gq': [{id: "g", initial: "{ word: 'gq', query: true }", development: true }],
+      // 'x': [{id: "x", initial: "{ value: 'x' }", scope: "testing" }],
+      // 'f': [{id: "ifAble", initial: "{ word: 'f' }", scope: "testing" }],
+      // 'g': [{id: "ifAble", initial: "{ word: 'g' }", scope: "testing" }],
+      'f': [{id: "f", initial: "{ value: 'f', word: 'f' }", scope: "testing" }],
+      'x': [{id: "x", initial: "{ value: 'x', word: 'x' }", scope: "testing" }],
+      'gq': [{id: "g", initial: "{ word: 'gq', query: true }", scope: "testing" }],
     }
   },
   generators: [
@@ -120,19 +120,19 @@ const config = {
       where: where(),
       match: ({context}) => context.marker == 'undefined',
       apply: ({context}) => 'undefined',
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),
       match: ({context}) => context.marker == 'defined',
       apply: ({context}) => 'defined',
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),
       match: ({context}) => context.evalue && !context.paraphrase,
       apply: ({context}) => context.evalue.verbatim,
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),
@@ -154,13 +154,13 @@ const config = {
       where: where(),
       match: ({context}) => context.marker === 'ifAble',
       apply: ({context}) => context.value,
-      development: true,
+      scope: "testing",
     },
     { 
       where: where(),
       match: ({context}) => ['x', 'g', 'f', 'e', 'ifAble'].includes(context.marker),
       apply: ({context}) => `${context.word}`,
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),
@@ -182,7 +182,7 @@ const config = {
         }
         context.isResponse = true
       },
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),

package/common/nameable.js

@@ -77,25 +77,25 @@ const config = {
   operators: [
     // "([call] ([nameable]) (name))",
     "([call] ([nameable]) (!@<=endOfSentence)*)",
-    { pattern: "([getNamesByType] (type))", development: true },
-    { pattern: "([m1])", development: true },
-//    { pattern: "([testPullFromContext] ([memorable]))", development: true }
+    { pattern: "([getNamesByType] (type))", scope: "testing" },
+    { pattern: "([m1])", scope: "testing" },
+//    { pattern: "([testPullFromContext] ([memorable]))", scope: "testing" }
   ],
   words: {
     literals: {
-//      "m1": [{"id": "memorable", development: true, "initial": "{ value: 'm1' }" }],
-//      "m2": [{"id": "memorable", development: true, "initial": "{ value: 'm2' }" }],
+//      "m1": [{"id": "memorable", scope: "testing", "initial": "{ value: 'm1' }" }],
+//      "m2": [{"id": "memorable", scope: "testing", "initial": "{ value: 'm2' }" }],
     },
   },
   bridges: [
     {
       id: 'm1',
       isA: ['memorable', 'nameable'],
-      development: true,
+      scope: "testing",
     },
     {
       id: 'getNamesByType',
-      development: true,
+      scope: "testing",
       isA: ['verb'],
       bridge: "{ ...next(operator), type: after[0] }",
       semantic: async ({context, api}) => {