tpmkms_4wp 8.0.0 → 8.1.0-beta.1

package/common/scorekeeper.js

@@ -1,4 +1,4 @@
-const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const dialogues = require('./dialogues')
 const numbers = require('./numbers')
@@ -43,7 +43,7 @@ const setNextPlayer = (km, objects) => {
         word: "turn"
       }
   const api = km('stm').api
-  api.mentioned(turn)
+  api.mentioned({ context: turn })
 }
 
 const addPlayer = (objects, config, player) => {
@@ -51,7 +51,7 @@ const addPlayer = (objects, config, player) => {
   objects.players.push(player);
 }
 
-let configStruct = {
+let config = {
   name: 'scorekeeper',
   operators: [
     "([next])",
@@ -122,36 +122,29 @@ let configStruct = {
     {
       where: where(),
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && context.isResponse && context.two && context.two.marker == 'next',
-      apply: ({context, g}) => {
+      apply: async ({context, g}) => {
                 const response = context.evalue;
                 const concept = response.two;
                 concept.paraphrase = true
                 concept.isSelf = true
-                const instance = g(concept.evalue)
+                const instance = await g(concept.evalue)
                 return instance
              }
     },
     {
       where: where(),
       match: ({context}) => context.marker == 'point' && context.isResponse && context.amount,
-      apply: ({context, g}) => `${g(context.amount)} points` 
+      apply: async ({context, g}) => `${await g(context.amount)} points` 
     },
     {
       where: where(),
       match: ({context}) => context.marker == 'scored' && context.paraphrase,
-      apply: ({context, g}) => `${g(context.player)} got ${g(context.points)}`
+      apply: async ({context, g}) => `${await g(context.player)} got ${await g(context.points)}`
     },
-    /*
-    {
-      where: where(),
-      match: ({context}) => context.marker == 'enumeration' && context.paraphrase,
-      apply: ({context, g}) => `${g(context.concept)} are ${g(context.items)}`
-    },
-    */
     {
       where: where(),
       match: ({context}) => context.marker == 'start' && context.paraphrase,
-      apply: ({context, g}) => `start ${g(context.arg)}`
+      apply: async ({context, g}) => `start ${await g(context.arg)}`
     },
 
   ],
@@ -161,7 +154,6 @@ let configStruct = {
       where: where(),
       match: ({context}) => context.marker == 'player' && context.same,
       apply: ({context, objects, config, km}) => {
-        //objects.players = context.same.value.map( (props) => props.value )
         const players = context.same.value.map( (props) => props.value )
         setPlayers(objects, config, players)
         for (let player of objects.players) {
@@ -205,11 +197,11 @@ let configStruct = {
               matchq: ({objects}) => objects.players.length == 0,
               applyq: () => 'who are the players?',
               matchr: ({context}) => context.marker == 'list',
-              applyr: ({context, gs, objects, config}) => {
+              applyr: async ({context, gs, objects, config}) => {
                         const players = context.value.map( (player) => player.value )
                         setPlayers(objects, config, players)
                         objects.allPlayersAreKnown = true;
-                        context.verbatim = `The players are ${gs(objects.players, ' ', ' and ')}`
+                        context.verbatim = `The players are ${await gs(objects.players, ' ', ' and ')}`
                         context.isResponse = true;
                       }
             }
@@ -242,12 +234,12 @@ let configStruct = {
     {
       where: where(),
       match: ({context}) => context.marker == 'player' && context.evaluate && context.pullFromContext,
-      apply: ({context, objects, gs}) => {
+      apply: async ({context, objects, gs}) => {
         const players = objects.players
         if (players.length == 0) {
           context.evalue = 'no one'
         } else {
-          context.evalue = gs(players, ' ', ' and ')
+          context.evalue = await gs(players, ' ', ' and ')
         }
       }
     },
@@ -350,21 +342,14 @@ let configStruct = {
   ],
 };
 
-const createConfig = () => {
-  const config = new Config(configStruct, module)
-  config.stop_auto_rebuild()
-  config.add(dialogues(), numbers(), properties())
-  config.initializer( ({objects, km, isModule}) => {
+const initializer = ({objects, km, isModule}) => {
     objects.players = []
     objects.nextPlayer = undefined;
     setNextPlayer(km, objects);
     objects.scores = {};
     objects.winningScore = null
     objects.allPlayersAreKnown = false;
-  })
-  config.restart_auto_rebuild()
-  return config
-}
+  }
 
 startWithDefault20 = [
   "greg got 1 point alice got 2 points greg got 1 point start a new game who is next",
@@ -382,14 +367,17 @@ startWithDefault20 = [
 ]
 
 knowledgeModule( { 
+  config,
+  includes: [dialogues, numbers, properties],
+  initializer,
+
   module,
   description: 'scorekeeper for card or dice games',
-  createConfig,
   test: {
     name: './scorekeeper.test.json',
     contents: scorekeeper_tests,
     checks: {
-            context: defaultContextCheck,
+            context: defaultContextCheck(),
           },
   },
   template: {

package/common/sdefaults.js

@@ -1,8 +1,8 @@
-const { Config, flatten, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { flatten, knowledgeModule, where } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const sdefaults_tests = require('./sdefaults.test.json')
 
-let configStruct = {
+let config = {
   name: 'sdefaults',
   semantics: [
     {
@@ -12,27 +12,36 @@ let configStruct = {
       // match: ({context}) => context.flatten || context.listable && context.value[0].flatten,
       match: ({context}) => context.flatten || context.listable && context.value.some((value) => value.flatten),
       // match: ({context}) => context.flatten || context.listable || (Array.isArray(context.value) && context.value.some((value) => value.flatten)),
-      apply: ({config, km, context, s}) => {
+      apply: async ({config, km, context, s}) => {
         const [flats, wf] = flatten(['list'], context)
         for (let flat of flats) {
-          s({ ...flat, flatten: false })
+          await s({ ...flat, flatten: false })
         }
       }
     },
+    {
+      notes: 'semanticIsEvaluate',
+      where: where(),
+      priority: -1,
+      match: ({context}) => context.semanticIsEvaluate,
+      apply: async ({context, e}) => {
+        context.value = await e({ ...context, semanticIsEvaluate: false })
+        context.isResponse
+      }
+    },
   ],
 };
 
-const createConfig = () => new Config(configStruct, module)
-
 knowledgeModule({ 
+  config,
+
   module,
   description: 'defaults for semantics',
-  createConfig,
   test: {
     name: './sdefaults.test.json',
     contents: sdefaults_tests,
     checks: {
-            context: defaultContextCheck,
+            context: defaultContextCheck(),
           },
   },
 })

package/common/sizeable.js

@@ -1,4 +1,4 @@
-const { Config, knowledgeModule, where, Digraph } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where, Digraph } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const dialogues = require("./hierarchy")
 const numbers = require("./numbers")
@@ -6,7 +6,7 @@ const sizeable_tests = require('./sizeable.test.json')
 
 // TODO 1 to 2 sizeables
 
-let configStruct = {
+let config = {
   name: 'sizeable',
   operators: [
     "(([size|]) [sizing] ([sizeable]))",
@@ -16,13 +16,18 @@ let configStruct = {
       id: "sizing", 
       level: 0, 
       convolution: true, 
-      before: ['verby'],
+      before: ['verb'],
       bridge: "{ ...after, size: before[0], modifiers: append(['size'], after.modifiers) }" 
     },
     { 
       id: "size", 
       parents: ['adjective'],
-      words: ['small', 'medium', 'large', 'half', 'full'],
+      words: [
+                { word: 'small', value: 'small' }, 
+                { word: 'medium', value: 'medium' }, 
+                { word: 'large', value: 'large' },
+                { word: 'half', value: 'half' }, 
+                { word: 'full', value: 'full' }],
       level: 0, 
       bridge: "{ ...next(operator) }" 
     },
@@ -47,21 +52,17 @@ let configStruct = {
   ]
 };
 
-const createConfig = () => {
-  const config = new Config(configStruct, module)
-  config.add(dialogues(), numbers())
-  return config
-}
-
 knowledgeModule({ 
+  config,
+  includes: [dialogues, numbers],
+
   module,
   description: 'Sizeable things',
-  createConfig,
   test: {
     name: './sizeable.test.json',
     contents: sizeable_tests,
     checks: {
-            context: defaultContextCheck,
+            context: [ ...defaultContextCheck(), { property: 'size', filter: ['value'] } ],
           },
   },
 })