tpmkms_4wp 9.5.1 → 9.6.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(),
@@ -206,10 +206,14 @@ const config = {
         // setup the read semantic
        
           // !topLevel or maybe !value??!?! 
-          const match = (defContext) => ({context}) => context.marker == (defContext.consequence || {}).marker && context.query // && !context.value
-          const apply = (DEFINITIONs, DERIVED) => {
+          function match(defContext) {
+            return ({context}) => context.marker == (defContext.consequence || {}).marker && context.query // && !context.value
+          }
+          function apply(DEFINITIONs, DERIVED) {
             const mappingss = translationMappings(DEFINITIONs, DERIVED)
-            const invertMappings = (mappings) => mappings.map( ({ from, to }) => { return { to: from, from: to } } )
+            function invertMappings(mappings) {
+              return mappings.map( ({ from, to }) => { return { to: from, from: to } } )
+            }
             return async ({context, s, config}) => { 
               DEFINITIONs = _.cloneDeep(DEFINITIONs)
               //const mappings = mappingss[0]
@@ -292,6 +296,7 @@ const config = {
           }
           if (context.to.value) {
             kms.stm.api.setVariable(context.from.value, context.to.value)
+            // config.addWord(context.from.word, context.to)
           } else {
             await kms.dialogues.api.makeObject({ context: context.from, types: context.to.types || [], config });
             kms.stm.api.setVariable(context.from.value, context.to)
@@ -306,15 +311,21 @@ const config = {
       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) => async ({context, s}) => {
-            TO = _.cloneDeep(TO)
-            for (const { from, to } of mappings) {
-              hashIndexesSet(TO, to, hashIndexesGet(context, from))
+          function matchByMarker(defContext) {
+            return ({context}) => context.marker == defContext.from.marker && !context.query && !context.objects
+          }
+          function matchByValue(defContext) {
+            return ({context}) => context.evalue == defContext.from.value && !context.query && !context.objects
+          }
+          function apply(mappings, TO) {
+            return async ({context, s}) => {
+              TO = _.cloneDeep(TO)
+              for (const { from, to } of mappings) {
+                hashIndexesSet(TO, to, hashIndexesGet(context, from))
+              }
+              toPrime = await s(TO)
+              context.result = toPrime.result
             }
-            toPrime = await s(TO)
-            context.result = toPrime.result
           }
           const mappings = translationMapping(context.from, context.to)
           let match = matchByMarker(context)
@@ -333,30 +344,36 @@ const config = {
 
         // setup the read semantic
         {
-          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) => async ({uuid, context, s, g, config}) => {
-            TO = _.cloneDeep(TO)
-            for (const { from, to } of mappings) {
-              hashIndexesSet(TO, to, hashIndexesGet(context, from))
-            }
-            // next move add debug arg to s and g
-            // TODO why is there query and evaluate?
-            if (context.query) {
-              TO.query = context.query
-            } else {
-              TO.evaluate = context.evaluate
-            }
-            TO[`disable${uuid}`] = true
-            toPrime = await s(TO)
-            if (context.query) {
-              if (toPrime.evalue) {
-                context.evalue = toPrime.evalue
+          function matchByMarker(defContext) {
+            return ({context, uuid}) => context.marker == defContext.from.marker && (context.query || context.evaluate) && !context[`disable${uuid}`]
+          }
+          function matchByValue(defContext) {
+            return ({context, uuid}) => context.value == defContext.from.value && (context.query || context.evaluate) && !context[`disable${uuid}`]
+          }
+          function apply(mappings, TO) {
+            return async ({uuid, context, s, g, config}) => {
+              TO = _.cloneDeep(TO)
+              for (const { from, to } of mappings) {
+                hashIndexesSet(TO, to, hashIndexesGet(context, from))
+              }
+              // next move add debug arg to s and g
+              // TODO why is there query and evaluate?
+              if (context.query) {
+                TO.query = context.query
+              } else {
+                TO.evaluate = context.evaluate
+              }
+              TO[`disable${uuid}`] = true
+              toPrime = await s(TO)
+              if (context.query) {
+                if (toPrime.evalue) {
+                  context.evalue = toPrime.evalue
+                } else {
+                  context.evalue = toPrime
+                }
               } else {
-                context.evalue = toPrime
+                context.evalue = toPrime.evalue
               }
-            } else {
-              context.evalue = toPrime.evalue
             }
           }
           const mappings = translationMapping(context.from, context.to)

package/common/nameable.js

@@ -1,5 +1,5 @@
 const { knowledgeModule, where } = require('./runtime').theprogrammablemind
-const { defaultContextCheck } = require('./helpers')
+const { defaultContextCheck, defaultContextCheckProperties } = require('./helpers')
 const helpers = require('./helpers')
 const stm = require('./stm')
 const nameable_tests = require('./nameable.test.json')
@@ -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}) => {
@@ -107,19 +107,26 @@ const config = {
       id: 'call',
       isA: ['verb'],
       bridge: "{ ...next(operator), nameable: after[0], name: after[1:][0] }",
-      // bridge: "{ ...next(operator), nameable: after[0], name: after[1] }",
-      // generatorp: async ({context, g}) => `call ${await g(context.nameable)} ${await g(context.name)}`,
       generatorp: async ({context, g, gs}) => `call ${await g(context.nameable)} ${await gs(context.name)}`,
-      semantic: async ({config, context, api, e}) => {
+      semantic: async ({config, context, api, e, verbatim, g}) => {
         // TODO find report being referred to
         const nameable = (await e(context.nameable)).evalue
+        if (!nameable) {
+          verbatim(`${await g(context.nameable)} is not known`)
+          return
+        }
         const name = context.name.map((n) => n.text).join(' ')
         // const name = context.name.text
         config.addWord(name, { id: nameable.marker, initial: `{ value: "${name}", pullFromContext: true, nameable_named: true }` })
         api.setName(nameable, name)
-      }
+      },
+      check: defaultContextCheckProperties(['nameable', 'name']),
+    },
+    { 
+      id: 'nameable', 
+      words: helpers.words('nameable'),
+      children: ['thisitthat'],
     },
-    { id: 'nameable', words: helpers.words('nameable')},
   ]
 }