tpmkms 9.6.3-beta.2 → 9.6.3-beta.4

package/common/actions.instance.json

@@ -40,7 +40,7 @@
       "semantics": [
         {
           "match": "({context, isA}) => isA(context.marker, 'action')",
-          "apply": "({context, _continue, mentioned}) => {\n        mentioned(context)\n        _continue()\n      }"
+          "apply": "({context, _continue, remember}) => {\n        remember(context)\n        _continue()\n      }"
         }
       ]
     }

package/common/actions.js

@@ -39,8 +39,8 @@ const config = {
     {
       priority: -1,
       match: ({context, isA}) => isA(context.marker, 'action'),
-      apply: ({context, _continue, mentioned}) => {
-        mentioned(context)
+      apply: ({context, _continue, remember}) => {
+        remember(context)
         _continue()
       }
     },

package/common/dialogues.js

@@ -544,12 +544,12 @@ const config = {
           concept = two;
           value = one;
         }
-        // km('dialogues').api.mentioned(concept)
+        // km('dialogues').api.remember(concept)
         // TODO wtf is the next line?
         value = JSON.parse(JSON.stringify(value))
         const instance = await e(value)
         if (false && instance.evalue) {
-          km('stm').api.mentioned({ context: value })
+          km('stm').api.remember({ context: value })
         }
         if (instance.verbatim) {
           context.evalue = { verbatim: instance.verbatim }
@@ -647,7 +647,7 @@ const config = {
           for (const child of propertyToArray(one)) {
             await api.makeObject({ context: child, config, types: context.two.types || [] })
             kms.stm.api.setVariable(child.value, two)
-            kms.stm.api.mentioned({ context: child, value: two })
+            kms.stm.api.remember({ context: child, value: two })
           }
         }
       }

package/common/dimension.js

@@ -38,7 +38,7 @@ class API {
   }
 
   async getPreferredUnits(quantity) {
-    const preferredUnits = await this.args.mentions({
+    const preferredUnits = await this.args.recall({
       context: { marker: 'unit' },
       condition: (unit) => {
         if (quantity.unit.marker == 'unitPerUnit') {
@@ -57,7 +57,7 @@ class API {
   }
 
   setPreferredUnits(units) {
-    this.args.mentioned(units)
+    this.args.remember(units)
   }
 
   setMeasurementSystem(measurementSystem) {
@@ -108,7 +108,7 @@ class API {
         const formula = kms.formulas.api.get(to, [efrom.unit])
         if (!formula) {
           const reason = { marker: 'reason', focusableForPhrase: true, evalue: { marker: 'noconversion', from: efrom.unit, to } }
-          kms.stm.api.mentioned({ context: reason })
+          kms.stm.api.remember({ context: reason })
           error(reason)
         }
         kms.stm.api.setVariable(efrom.unit.value, efrom.amount)

package/common/drone.instance.json

@@ -95,7 +95,7 @@
           "isA": [
             "noun"
           ],
-          "semantic": "async ({objects, mentions, api, e, context, say}) => {\n            await api.back()\n          }"
+          "semantic": "async ({objects, api, e, context, say}) => {\n            await api.back()\n          }"
         },
         {
           "id": "forth",
@@ -322,7 +322,7 @@
               "time": "(@<= 'quantity' && context.unit.dimension == 'time')"
             }
           },
-          "semantic": "async ({context, mentioned, api, e, fragments, toFinalValue}) => {\n            let time = context.time \n            if (time.marker == 'forQuantity') {\n              time = time.quantity\n            }\n            const instantiation = await fragments(\"quantity in seconds\", { quantity: time})\n            const result = await e(instantiation)\n            const seconds = toFinalValue(toFinalValue(result).amount)\n            context.pauseSeconds = seconds\n            mentioned(context)\n            api.pause(seconds)\n          }"
+          "semantic": "async ({context, remember, api, e, fragments, toFinalValue}) => {\n            let time = context.time \n            if (time.marker == 'forQuantity') {\n              time = time.quantity\n            }\n            const instantiation = await fragments(\"quantity in seconds\", { quantity: time})\n            const result = await e(instantiation)\n            const seconds = toFinalValue(toFinalValue(result).amount)\n            context.pauseSeconds = seconds\n            remember(context)\n            api.pause(seconds)\n          }"
         },
         {
           "id": "stop",
@@ -333,7 +333,7 @@
             "1": "{ marker: 'drone' }"
           },
           "bridge": "{ ...next(operator), object: after[0], interpolate: [{ context: operator }, { property: 'object' }] }",
-          "semantic": "async ({mentioned, context, objects, api, say}) => {\n            await api.stop()\n            await api.markCurrentPoint()\n          }"
+          "semantic": "async ({context, objects, api, say}) => {\n            await api.stop()\n            await api.markCurrentPoint()\n          }"
         }
       ],
       "generators": [
@@ -353,11 +353,11 @@
         },
         {
           "match": "({context, contextHierarchy}) => {\n            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under(['doAction', 'evaluate'])) {\n              return false\n            }\n            \n            if (context.marker == 'path' || context.marker == 'this' || context.marker == 'that') {\n              return true\n            }\n          }",
-          "apply": "async ({context, frameOfReference, toArray, fragments, stm, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {\n            const pathComponents = toArray(await mentions({ context: { marker: 'pathComponent' }, all: true }))\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.points = pathComponents.reverse()\n            frameOfReference(path, { mentioned: 'points', reversed: true })\n            await mentioned(path)\n\n            _continue() // let the call pick the object out from the stm\n          }"
+          "apply": "async ({context, frameOfReference, toArray, fragments, stm, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {\n            const pathComponents = toArray(await recall({ context: { marker: 'pathComponent' }, all: true }))\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.instance = true\n            path.points = pathComponents.reverse()\n            frameOfReference(path, { mentioned: 'points', reversed: true })\n            await remember(path)\n\n            _continue() // let the call pick the object out from the stm\n          }"
         },
         {
           "match": "({context, contextHierarchy}) => {\n            if (!context.pullFromContext || !context.evaluate || !contextHierarchy.under('call') || context.notUnderCall) {\n              return false\n            }\n            \n            if (context.marker == 'point' || context.marker == 'ordinal') {\n              return true\n            }\n          }",
-          "apply": "async ({context, e, fragments, stm, toEValue, toArray, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {\n            const evaluated = await e({...context, notUnderCall: true})\n            const pointsContext = toEValue(evaluated)\n            const pathComponents = toArray(pointsContext)\n\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.points = pathComponents.reverse()\n            await mentioned(path)\n            resolveEvaluate(context, path)\n          }"
+          "apply": "async ({context, e, fragments, stm, toEValue, toArray, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {\n            const evaluated = await e({...context, notUnderCall: true})\n            const pointsContext = toEValue(evaluated)\n            const pathComponents = toArray(pointsContext)\n\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.points = [...pathComponents]\n            await remember(path)\n            resolveEvaluate(context, path)\n          }"
         },
         {
           "match": "({context}) => context.marker == 'thenTime'",
@@ -365,7 +365,7 @@
         },
         {
           "match": "({context}) => context.evaluate && ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path'",
-          "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api, mentions}) => {\n            const path = await mentions({ context: context.objects[1] })\n            if (!path?.points) {\n              return\n            }\n            if (context.marker == 'start') {\n              resolveEvaluate(context, path?.points[0])\n            } else if (context.marker == 'end') {\n              resolveEvaluate(context, path?.points[path?.points.length-1])\n            }\n          }"
+          "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api, recall}) => {\n            const path = await recall({ context: context.objects[1] })\n            if (!path?.points) {\n              return\n            }\n            if (context.marker == 'start') {\n              resolveEvaluate(context, path?.points[0])\n            } else if (context.marker == 'end') {\n              resolveEvaluate(context, path?.points[path?.points.length-1])\n            }\n          }"
         },
         {
           "match": "({context}) => context.marker == 'speed' && context.evaluate",
@@ -45297,6 +45297,24 @@
             0
           ]
         ],
+        [
+          [
+            "is",
+            0
+          ],
+          [
+            "list",
+            1
+          ],
+          [
+            "point",
+            0
+          ],
+          [
+            "unknown",
+            0
+          ]
+        ],
         [
           [
             "is",
@@ -85640,6 +85658,24 @@
         0
       ]
     ],
+    [
+      [
+        "is",
+        0
+      ],
+      [
+        "list",
+        1
+      ],
+      [
+        "point",
+        0
+      ],
+      [
+        "unknown",
+        0
+      ]
+    ],
     [
       [
         "is",

package/common/drone.js

@@ -14,6 +14,10 @@ const help = require('./help')
 const { rotateDelta, degreesToRadians, radiansToDegrees, cartesianToPolar, smallestRotate } = require('./helpers/drone')
 
 /*
+NEED TO CHECK ON ACTUAL DRONE
+
+   go to the second point of route 1
+
 DONE go back
 go back another point
 go back again
@@ -27,6 +31,9 @@ do route 1 pausing 10 seconds at each point
 
 forward 1 foot\nwest 1 foot\ngo back to the start         <<<<<<<<  turn the longer way not he shorter way
 forward 1 foot\nwest 1 foot\ncall the path route 1\ngo to the start of route 1\npatrol route 1\npatrol route 1   <<<<< does the patrol more than once
+call that route 1
+what are the paths
+list the paths
 
 ?? elipses of the verb go or some kind of conjunction?!?!?
 go forward 1 meter turn right forward 2 meters stop
@@ -299,7 +306,7 @@ class API {
     objects.history = []
     objects.sonicTest = 5
 
-    this.args.mentioned({ marker: 'point', ordinal: this.nextOrdinal(), point: { x: 0, y: 0 }, description: "start" })
+    this.args.remember({ marker: 'point', ordinal: this.nextOrdinal(), point: { x: 0, y: 0 }, description: "start" })
   }
 
   currentOrdinal() {
@@ -318,7 +325,7 @@ class API {
       return null // in motion
     }
     const ordinal = this.currentOrdinal()
-    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
     if (!current.startTime && !current.endTime && !current.durationInSeconds) {
       return lastPoint // did not move
     }
@@ -344,7 +351,7 @@ class API {
       return
     }
     const ordinal = this.nextOrdinal()
-    this.args.mentioned({ marker: 'point', ordinal, point })
+    this.args.remember({ marker: 'point', ordinal, point })
     this._objects.current.endTime = null
     this._objects.current.startTime = null
   }
@@ -412,13 +419,15 @@ class API {
       if (objects.current.timeRepeats) {
         this.startRepeats(objects.current.timeRepeats)
       }
-      let currentPoint = (await this.args.mentions({ context: { marker: 'point' } })).point
+      let currentPoint = (await this.args.recall({ context: { marker: 'point' } })).point
       this._objects.history.push({ marker: 'history', debug: 'doing path' })
       for (const pathComponent of objects.current.path) {
         if (pathComponent.marker == 'pause') {
           this.pause(pathComponent.pauseSeconds, { batched: true })
         } else {
-          const destinationPoint = pathComponent.point
+          const points = this.args.toArray(pathComponent)
+          // const destinationPoint = pathComponent.point
+          const destinationPoint = points[0].point || points[0]
           if (currentPoint.x == destinationPoint.x && currentPoint.y == destinationPoint.y) {
             // already there
           } else {
@@ -544,7 +553,7 @@ class API {
     } else {
       ordinal = this.currentOrdinal() - 1
     }
-    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
     if (!lastPoint) {
       this.args.say(`There is no previous point to go back to`)
       return
@@ -558,8 +567,8 @@ class API {
     const current = objects.current
     current.backAndForth = true
     const ordinal = this.currentOrdinal()
-    const currentPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
-    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })
+    const currentPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.recall({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })
     current.path.push(lastPoint)
     current.path.push(currentPoint)
     objects.runCommand = true
@@ -918,7 +927,7 @@ const template = {
         {
           id: 'back',
           isA: ['noun'],
-          semantic: async ({objects, mentions, api, e, context, say}) => {
+          semantic: async ({objects, api, e, context, say}) => {
             await api.back()
           }
         },
@@ -1050,7 +1059,7 @@ const template = {
               time: "(@<= 'quantity' && context.unit.dimension == 'time')",
             },
           },
-          semantic: async ({context, mentioned, api, e, fragments, toFinalValue}) => {
+          semantic: async ({context, remember, api, e, fragments, toFinalValue}) => {
             let time = context.time 
             if (time.marker == 'forQuantity') {
               time = time.quantity
@@ -1059,7 +1068,7 @@ const template = {
             const result = await e(instantiation)
             const seconds = toFinalValue(toFinalValue(result).amount)
             context.pauseSeconds = seconds
-            mentioned(context)
+            remember(context)
             api.pause(seconds)
           }
         },
@@ -1070,7 +1079,7 @@ const template = {
             1: "{ marker: 'drone' }",
           },
           bridge: "{ ...next(operator), object: after[0], interpolate: [{ context: operator }, { property: 'object' }] }",
-          semantic: async ({mentioned, context, objects, api, say}) => {
+          semantic: async ({context, objects, api, say}) => {
             await api.stop()
             await api.markCurrentPoint()
           }
@@ -1108,13 +1117,14 @@ const template = {
               return true
             }
           },
-          apply: async ({context, frameOfReference, toArray, fragments, stm, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {
-            const pathComponents = toArray(await mentions({ context: { marker: 'pathComponent' }, all: true }))
+          apply: async ({context, frameOfReference, toArray, fragments, stm, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {
+            const pathComponents = toArray(await recall({ context: { marker: 'pathComponent' }, all: true }))
             const path = (await fragments('path')).contexts()[0]
             delete path.value
+            path.instance = true
             path.points = pathComponents.reverse()
             frameOfReference(path, { mentioned: 'points', reversed: true })
-            await mentioned(path)
+            await remember(path)
 
             _continue() // let the call pick the object out from the stm
           },
@@ -1129,15 +1139,15 @@ const template = {
               return true
             }
           },
-          apply: async ({context, e, fragments, stm, toEValue, toArray, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {
+          apply: async ({context, e, fragments, stm, toEValue, toArray, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {
             const evaluated = await e({...context, notUnderCall: true})
             const pointsContext = toEValue(evaluated)
             const pathComponents = toArray(pointsContext)
 
             const path = (await fragments('path')).contexts()[0]
             delete path.value
-            path.points = pathComponents.reverse()
-            await mentioned(path)
+            path.points = [...pathComponents]
+            await remember(path)
             resolveEvaluate(context, path)
           },
         },
@@ -1151,8 +1161,8 @@ const template = {
         },
         {
           match: ({context}) => context.evaluate && ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path',
-          apply: async ({gp, s, context, objects, fragments, resolveEvaluate, api, mentions}) => {
-            const path = await mentions({ context: context.objects[1] })
+          apply: async ({gp, s, context, objects, fragments, resolveEvaluate, api, recall}) => {
+            const path = await recall({ context: context.objects[1] })
             if (!path?.points) {
               return
             }
@@ -1238,6 +1248,7 @@ knowledgeModule( {
         defaultContextCheck({ marker: 'path', exported: true, 
           extra: [
             'points', 
+            'instance',
             { 
               property: 'namespaced', 
               check: [