tpmkms_4wp 8.0.0-beta.3 → 8.0.0-beta.30

package/common/math.js

@@ -33,22 +33,22 @@ const mathematicalOperator = (name, words, apply, before = []) => [
       id: `${name}Operator`, level: 0, 
       bridge: `{ ...next(operator), marker: next(operator('${name}Expression')), types: lub(append(['mathematicalExpression'], operator.types, before[0].types, after[0].types)), value: null, x: before[0], y: after[0], number: 'one', isResponse: true, evaluate: true }` ,
       // bridge: `{ ...next(operator), marker: next(operator('${name}Expression')), value: null, x: before[0], y: after[0], number: 'one', isResponse: true, evaluate: true }` ,
-      isA: ['mathematicalOperator'],
+      isA: ['mathematical_operator'],
       before,
       localHierarchy: [ ['unknown', 'number'] ],
       // levelSpecificHierarchy: [[1, 'mathematicalExpression']],
       words,
-      generatorp: ({gp, context}) => context.word,
+      generatorp: ({context}) => context.word,
   },
   { 
       where: where(),
       id: `${name}Expression`, level: 0, 
       bridge: "{ ...next(operator) }" ,
       isA: ['mathematicalExpression'],
-      generatorp: ({gp, context}) => `${gp(context.x)} ${context.word} ${gp(context.y)}`,
-      evaluator: ({e, context}) => {
-        const x = toValue(e(context.x)) 
-        const y = toValue(e(context.y))
+      generatorp: async ({gp, context}) => `${await gp(context.x)} ${context.word} ${await gp(context.y)}`,
+      evaluator: async ({e, context}) => {
+        const x = toValue(await e(context.x)) 
+        const y = toValue(await e(context.y))
         if (!x || !y) {
           // context.evalue = { ...context, paraphrase: true, x: { ...context.x, value: x }, y: { ...context.y, value: y } }
           context.isResponse = false
@@ -73,7 +73,7 @@ let configStruct = {
   name: 'math',
   operators: [
     "([mathematicalExpression])",
-    "([mathematicalOperator])",
+    "([mathematical_operator])",
     "(([number|]) [plusOperator] ([number|]))",
     "(([number|]) [minusOperator] ([number|]))",
     "(([number|]) [timesOperator] ([number|]))",
@@ -92,7 +92,7 @@ let configStruct = {
       isA: ['concept', 'number'],
     },
     { 
-      id: "mathematicalOperator", 
+      id: "mathematical_operator", 
       before: ['verby'],
       after: ['adjective'],
     },
@@ -108,14 +108,14 @@ let configStruct = {
 const template = {
   configs: [
     "mathematical modifies operator",
-    "* + / and - are mathematical operators",
     configStruct,
+    // "* + / and - are mathematical operators",
   ]
 }
 
-const createConfig = () => {
+const createConfig = async () => {
   const config = new Config({ name: 'math' }, module)
-  config.add(numbers(), dialogues(), punctuation(), countable(), comparable())
+  await config.add(numbers, dialogues, punctuation, countable, comparable)
   return config
 }
 

package/common/meta.js

@@ -130,8 +130,8 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker == 'orList' && context.paraphrase,
-      apply: ({context, gs}) => {
-        return gs(context.value, ', ', ' or ')
+      apply: async ({context, gs}) => {
+        return await gs(context.value, ', ', ' or ')
       },
       priority: -1,
     },
@@ -139,10 +139,8 @@ let configStruct = {
       priority: -1,
       where: where(),
       match: ({context}) => context.marker == 'means' && context.paraphrase,
-      apply: ({context, g}) => {
-        // const before = g({ ...context.from, paraphrase: true, debug: true})
-        const before = g({ ...context.from, paraphrase: true})
-        return `${g({ ...context.from, paraphrase: true})} means ${g(context.to)}`
+      apply: async ({context, g}) => {
+        return `${await g({ ...context.from, paraphrase: true})} means ${await g(context.to)}`
       }
     },
     { 
@@ -160,8 +158,8 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker === 'if',
-      apply: ({context, g}) => {
-        return `if ${g(context.antecedant)} then ${g(context.consequence)}`
+      apply: async ({context, g}) => {
+        return `if ${await g(context.antecedant)} then ${await g(context.consequence)}`
       },
       priority: -1,
     },
@@ -182,10 +180,10 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker == 'orList',
-      apply: ({context, s}) => {
+      apply: async ({context, s}) => {
         const response = []
         for (const value of context.value) {
-          response.push(s(value))
+          response.push(await s(value))
         }
         context.evalue = {
           marker: 'orList', 
@@ -205,7 +203,7 @@ let configStruct = {
           const apply = (DEFINITIONs, DERIVED) => {
             const mappingss = translationMappings(DEFINITIONs, DERIVED)
             const invertMappings = (mappings) => mappings.map( ({ from, to }) => { return { to: from, from: to } } )
-            return ({context, s, g, config}) => { 
+            return async ({context, s, config}) => { 
               DEFINITIONs = _.cloneDeep(DEFINITIONs)
               //const mappings = mappingss[0]
               let toPrimes = []
@@ -215,8 +213,7 @@ let configStruct = {
                 }
                 // next move add debug arg to s and g
                 TO.query = true
-                toPrimes.push([s(TO), mappings])
-                // toPrime = s(TO, { debug: { apply: true } })
+                toPrimes.push([await s(TO), mappings])
               }
 
               let hasResponse = false
@@ -271,7 +268,7 @@ let configStruct = {
             // match: match(context), 
             where: where(),
             match: match(context),
-            apply: apply(antecedants, _.cloneDeep(context.consequence)) ,
+            apply: apply(antecedants, _.cloneDeep(context.consequence)),
           }
           config.addSemantic(semantic)
       }
@@ -280,17 +277,14 @@ let configStruct = {
       notes: 'from means to where from is unknown',
       where: where(),
       match: ({context}) => context.marker == 'means' && context.from.marker == 'unknown',
-      apply: ({config, context, kms, e, isTest}) => {
+      apply: async ({config, context, kms, e, isTest}) => {
         if (false && isTest) {
           return
         } else if (kms.dialogues) {
           if (context.to.value) {
             kms.stm.api.setVariable(context.from.value, context.to.value)
           } else {
-            // config.addWord(context.from.word, 
             kms.dialogues.api.makeObject({ context: context.from, types: context.to.types || [], config });
-            // kms.dialogues.api.makeObject({ context: context.from, types: [], config });
-            // const r = e(context.to)
             kms.stm.api.setVariable(context.from.value, context.to)
           }
         }
@@ -300,17 +294,17 @@ let configStruct = {
       notes: 'x means y where x and y have known markers',
       where: where(),
       match: ({context}) => context.marker == 'means',
-      apply: ({config, context, g}) => {
+      apply: async ({config, context, g}) => {
         // setup the write semantic
         {
           const matchByMarker = (defContext) => ({context}) => context.marker == defContext.from.marker && !context.query && !context.objects
           const matchByValue = (defContext) => ({context}) => context.evalue == defContext.from.value && !context.query && !context.objects
-          const apply = (mappings, TO) => ({context, s}) => {
+          const apply = (mappings, TO) => async ({context, s}) => {
             TO = _.cloneDeep(TO)
             for (let { from, to } of mappings) {
               hashIndexesSet(TO, to, hashIndexesGet(context, from))
             }
-            toPrime = s(TO)
+            toPrime = await s(TO)
             context.result = toPrime.result
           }
           const mappings = translationMapping(context.from, context.to)
@@ -332,7 +326,7 @@ let configStruct = {
         {
           const matchByMarker = (defContext) => ({context, uuid}) => context.marker == defContext.from.marker && (context.query || context.evaluate) && !context[`disable${uuid}`]
           const matchByValue = (defContext) => ({context, uuid}) => context.value == defContext.from.value && (context.query || context.evaluate) && !context[`disable${uuid}`]
-          const apply = (mappings, TO) => ({uuid, context, s, g, config}) => {
+          const apply = (mappings, TO) => async ({uuid, context, s, g, config}) => {
             TO = _.cloneDeep(TO)
             for (let { from, to } of mappings) {
               hashIndexesSet(TO, to, hashIndexesGet(context, from))
@@ -345,8 +339,7 @@ let configStruct = {
               TO.evaluate = context.evaluate
             }
             TO[`disable${uuid}`] = true
-            // toPrime = s(TO, { debug: { apply: true } })
-            toPrime = s(TO)
+            toPrime = await s(TO)
             if (context.query) {
               if (toPrime.evalue) {
                 context.evalue = toPrime.evalue
@@ -359,7 +352,7 @@ let configStruct = {
           }
           const mappings = translationMapping(context.from, context.to)
           let match = matchByMarker(context)
-          context.metaInfo = `The mapping from from the expression being defined "${g({...context.from, paraphrase: true})}" to the definition phrase "${g({...context.to, paraphrase: true})}" is ${JSON.stringify(mappings)}`
+          context.metaInfo = `The mapping from from the expression being defined "${await g({...context.from, paraphrase: true})}" to the definition phrase "${await g({...context.to, paraphrase: true})}" is ${JSON.stringify(mappings)}`
           if (context.from.value) {
             match = matchByValue(context)
           }
@@ -378,12 +371,12 @@ let configStruct = {
   ],
 };
 
-const createConfig = () => {
+const createConfig = async () => {
   const config = new Config(configStruct, module)
   config.stop_auto_rebuild()
-  config.add(gdefaults())
+  await config.add(gdefaults)
 
-  config.initializer( ({config, addGenerator, isModule}) => {
+  await config.initializer( ({config, addGenerator, isModule}) => {
     if (!isModule) {
       addGenerator({
         where: where(),
@@ -393,7 +386,7 @@ const createConfig = () => {
     }
   })
   
-  config.restart_auto_rebuild()
+  await config.restart_auto_rebuild()
   return config
 }
 

package/common/negation.instance.json

@@ -0,0 +1,2 @@
+{
+}

package/common/negation.js

@@ -0,0 +1,38 @@
+const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { words, defaultContextCheck } = require('./helpers')
+const gdefaults = require('./gdefaults')
+const pos = require('./pos')
+const negation_tests = require('./negation.test.json')
+
+let configStruct = {
+  name: 'negation',
+  operators: [
+    "([negatable])",
+    "([not] (negatable/*))",
+  ],
+  bridges: [
+    { 
+      id: 'not', 
+      bridge: '{ ...after[0], negated: operator, modifiers: append(["negated"], after[0].modifiers) }',
+      before: ['verby'],
+      localHierarchy: [['unknown', 'negatable']],
+    },
+    { id: 'negatable', words: words('negatable') },
+  ],
+};
+
+const createConfig = async () => new Config(configStruct, module).add(gdefaults, pos)
+
+knowledgeModule( {
+  module,
+  createConfig,
+  description: 'negation',
+  test: {
+    name: './negation.test.json',
+    contents: negation_tests,
+    checks: {
+      context: defaultContextCheck,
+    },
+  },
+})
+

package/common/negation.test.json

@@ -0,0 +1,308 @@
+[
+  {
+    "associations": [
+      [
+        [
+          "negatable",
+          0
+        ],
+        [
+          "not",
+          0
+        ]
+      ]
+    ],
+    "config": {
+    },
+    "contexts": [
+      {
+        "dead": true,
+        "level": 1,
+        "marker": "negatable",
+        "modifiers": [
+          "negated"
+        ],
+        "negated": {
+          "default": true,
+          "level": 0,
+          "marker": "not",
+          "range": {
+            "end": 2,
+            "start": 0
+          },
+          "text": "not",
+          "value": "not",
+          "word": "not"
+        },
+        "number": "one",
+        "range": {
+          "end": 12,
+          "start": 0
+        },
+        "text": "not negatable",
+        "topLevel": true,
+        "types": [
+          "negatable"
+        ],
+        "word": "negatable"
+      }
+    ],
+    "developerTest": false,
+    "generatedParenthesized": [
+      ""
+    ],
+    "metadata": {
+      "opChoices": [
+        {
+          "counter": 1,
+          "op": [
+            "negatable",
+            0
+          ],
+          "ops": [
+            [
+              "negatable",
+              0
+            ],
+            [
+              "not",
+              0
+            ]
+          ]
+        },
+        {
+          "counter": 2,
+          "op": [
+            "not",
+            0
+          ],
+          "ops": [
+            [
+              "not",
+              0
+            ]
+          ]
+        }
+      ]
+    },
+    "objects": {
+      "nameToUUID": {
+        "gdefaults": "gdefaults2",
+        "negation": "negation1",
+        "tokenize": "tokenize2"
+      },
+      "namespaced": {
+        "gdefaults2": {
+        },
+        "negation1": {
+        },
+        "tokenize2": {
+        }
+      },
+      "processed": [
+        {
+          "context": {
+            "dead": true,
+            "level": 1,
+            "marker": "negatable",
+            "modifiers": [
+              "negated"
+            ],
+            "negated": {
+              "default": true,
+              "level": 0,
+              "marker": "not",
+              "range": {
+                "end": 2,
+                "start": 0
+              },
+              "text": "not",
+              "value": "not",
+              "word": "not"
+            },
+            "number": "one",
+            "range": {
+              "end": 12,
+              "start": 0
+            },
+            "text": "not negatable",
+            "topLevel": true,
+            "types": [
+              "negatable"
+            ],
+            "word": "negatable"
+          },
+          "generatedParenthesized": "",
+          "paraphrases": "not negatable",
+          "paraphrasesParenthesized": "((not) (negatable))",
+          "responses": [
+            ""
+          ]
+        }
+      ]
+    },
+    "paraphrases": [
+      "not negatable"
+    ],
+    "paraphrasesParenthesized": [
+      "((not) (negatable))"
+    ],
+    "query": "not negatable",
+    "responses": [
+      ""
+    ]
+  },
+  {
+    "associations": [
+      [
+        [
+          "negatable",
+          0
+        ],
+        [
+          "not",
+          0
+        ]
+      ]
+    ],
+    "config": {
+    },
+    "contexts": [
+      {
+        "dead": true,
+        "level": 1,
+        "marker": "negatable",
+        "modifiers": [
+          "negated"
+        ],
+        "negated": {
+          "default": true,
+          "level": 0,
+          "marker": "not",
+          "range": {
+            "end": 2,
+            "start": 0
+          },
+          "text": "not",
+          "value": "not",
+          "word": "not"
+        },
+        "number": "many",
+        "range": {
+          "end": 13,
+          "start": 0
+        },
+        "text": "not negatables",
+        "topLevel": true,
+        "types": [
+          "negatable"
+        ],
+        "word": "negatables"
+      }
+    ],
+    "developerTest": false,
+    "generatedParenthesized": [
+      ""
+    ],
+    "metadata": {
+      "opChoices": [
+        {
+          "counter": 1,
+          "op": [
+            "negatable",
+            0
+          ],
+          "ops": [
+            [
+              "negatable",
+              0
+            ],
+            [
+              "not",
+              0
+            ]
+          ]
+        },
+        {
+          "counter": 2,
+          "op": [
+            "not",
+            0
+          ],
+          "ops": [
+            [
+              "not",
+              0
+            ]
+          ]
+        }
+      ]
+    },
+    "objects": {
+      "nameToUUID": {
+        "gdefaults": "gdefaults2",
+        "negation": "negation1",
+        "tokenize": "tokenize2"
+      },
+      "namespaced": {
+        "gdefaults2": {
+        },
+        "negation1": {
+        },
+        "tokenize2": {
+        }
+      },
+      "processed": [
+        {
+          "context": {
+            "dead": true,
+            "level": 1,
+            "marker": "negatable",
+            "modifiers": [
+              "negated"
+            ],
+            "negated": {
+              "default": true,
+              "level": 0,
+              "marker": "not",
+              "range": {
+                "end": 2,
+                "start": 0
+              },
+              "text": "not",
+              "value": "not",
+              "word": "not"
+            },
+            "number": "many",
+            "range": {
+              "end": 13,
+              "start": 0
+            },
+            "text": "not negatables",
+            "topLevel": true,
+            "types": [
+              "negatable"
+            ],
+            "word": "negatables"
+          },
+          "generatedParenthesized": "",
+          "paraphrases": "not negatables",
+          "paraphrasesParenthesized": "((not) (negatables))",
+          "responses": [
+            ""
+          ]
+        }
+      ]
+    },
+    "paraphrases": [
+      "not negatables"
+    ],
+    "paraphrasesParenthesized": [
+      "((not) (negatables))"
+    ],
+    "query": "not negatables",
+    "responses": [
+      ""
+    ]
+  }
+]

package/common/numbers.js

@@ -2,6 +2,7 @@ const { Config, knowledgeModule, where } = require('./runtime').theprogrammablem
 const { defaultContextCheck } = require('./helpers')
 const numbers_tests = require('./numbers.test.json')
 const gdefaults = require('./gdefaults')
+const sdefaults = require('./sdefaults')
 
 /*
   TODO 
@@ -21,7 +22,6 @@ let configStruct = {
   version: '3',
   words: {
     "literals": {
-      // start with a space for regular expressions
       "one": [{"id": "number", "initial": "{ value: 1, instance:true }" }],
       "ones": [{"id": "number", "initial": "{ value: 1, number: 'many', instance:true }" }],
       "two": [{"id": "number", "initial": "{ value: 2 , instance:true}" }],
@@ -83,9 +83,9 @@ let configStruct = {
   ],
 };
 
-const createConfig = () => {
+const createConfig = async () => {
   const config = new Config(configStruct, module)
-  config.add(gdefaults())
+  await config.add(gdefaults, sdefaults)
   return config
 }