tpmkms_4wp 9.3.0-beta.9 → 9.4.0

package/common/reminders.js

@@ -3,57 +3,182 @@ const { defaultContextCheck } = require('./helpers')
 const reminders_tests = require('./reminders.test.json')
 const reminders_instance = require('./reminders.instance.json')
 const selfKM = require('./self')
-const dates = require('./dates')
-const time = require('./time')
-const reminders_helpers = require('./helpers/reminders')
+const dateTimeSelectors = require('./dateTimeSelectors')
 const helpers = require('./helpers')
 
+/*
+   friday instead
+   change it to friday
+   delete it
+   make it friday instead
+   2 sundays from now
+   the sunday after july 1st
+   remind every truck driver to whatever tomorrow at 8 am
+   add the user greg
+   add greg as a user
+*/
+
+const query = (missing, reminder_id) => {
+  return  {
+    where: where(),
+    // oneShot: false,
+    onNevermind: ({verbatim, ...args}) => {
+      const api = args.kms.reminders.api
+      api.delete_reminder(reminder_id)
+    },
+
+    matchq: ({ api, context }) => api.missing(missing, reminder_id) && context.marker == 'controlEnd',
+    applyq: async ({ api, context, gs, enable }) => {
+      context.cascade = false
+      const item = api.missing(missing, reminder_id)
+      let who
+      if (Array.isArray(item.who)) {
+        who = await gs(item.who.map((who) => who.text), ', ', ' and ')
+      } else {
+        if (item.who.text == 'me') {
+          who = 'you'
+        } else {
+          who = item.who.text
+        }
+      }
+      if (item.missingDate) {
+        return `When should I remind ${who} to ${item.text}`
+      }
+      if (item.missingReminder) {
+        enable(['remindResponse', 0])
+        return `What should I remind ${who} to do?`
+      }
+    },
+
+    matchr: ({ isA, api, context }) => {
+      if (context.evaluate || context.isControl || context.isResponse) {
+        return false
+      }
+      const gotADate = ((isA(context.marker, 'onDateValue_dates') || isA(context.marker, 'dateTimeSelector')) && api.missing(missing, reminder_id))
+      if (missing == 'missingDate') {
+        return gotADate
+      } else {
+        // return !gotADate && !context.isControl
+      }
+      return false
+    },
+    applyr: async ({ context, api, gp }) => {
+      const item = api.missing(missing, reminder_id)
+      await api.update({ id: item.id, dateTimeSelector: context, dateTimeSelectorText: await gp(context) })
+    }
+  }
+}
+
 class API {
   initialize({ objects }) {
     this._objects = objects
     this._objects.reminders = []
     this._objects.id = 0
+    this._objects.current = null
+    this._objects.defaultTime = { hour: 9, minute: 0, second: 0, millisecond: 0 }
   }
 
-  add(reminder) {
+  async add(reminder) {
+    await this.instantiate(reminder)
     const id = ++this._objects.id
     reminder.id = id
     this._objects.reminders.push(reminder)
     this.args.mentioned({ context: reminder })
+    this._objects.current = id
+  }
+
+  getCurrentId() {
+    return this._objects.current
+  }
+
+  // addUser to current
+  addUser(user) {
+    const reminder = this.reminders().find((r) => r.id == this._objects.current)
+    if (reminder) {
+      if (Array.isArray(reminder.who)) {
+        reminder.who = [...reminder.who, user]
+      } else {
+        reminder.who = [reminder.who, user]
+      }
+    }
+  }
+
+  removeUser(user) {
+    const reminder = this.reminders().find((r) => r.id == this._objects.current)
+    if (reminder) {
+      reminder.who = reminder.who.filter((who) => who.remindee_id != user.remindee_id)
+    }
+  }
+
+  async addRemindable(id, text) {
+    if (!text) {
+      text = id
+    }
+    await this.args.makeObject({ ...this.args, context: { word: text, value: id, number: 'one', remindee_id: id }, initial: { remindee_id: `${id}` }, types: ['remindable'] })
+  }
+
+  async instantiate(reminder) {
+    if (reminder.dateTimeSelector) {
+      reminder.dateTimeSelector.defaultTime = this._objects.defaultTime
+    }
+    const value = await this.args.e(reminder.dateTimeSelector)
+    reminder.nextISODate = value?.evalue
   }
 
-  instantiate(reminder) {
-    let now;
-    if (this.args.isProcess) {
-      // so the unit tests work consistently
-      now = new Date(2025, 6, 29, 14, 52, 0)
+  contextToWho(who) {
+    if (who.isList) {
+      const whos = []
+      for (const element of this.args.values(who)) {
+        whos.push(this.contextToWho(element))
+      }
+      return whos
     } else {
-      now = new Date()
+      return { id: who.value || who.text, text: who.text, remindee_id: who.remindee_id }
+    }
+  }
+
+  missing(what, reminder_id) {
+    const reminder = this.reminder(reminder_id)
+    if (what == 'missingReminder' && !reminder.text) {
+      return { when: true, who: reminder.who, text: reminder.text, id: reminder.id, missingReminder: true }
+    }
+    if (what == 'missingDate' && !reminder.dateTimeSelector) {
+      return { when: true, who: reminder.who, text: reminder.text, id: reminder.id, missingDate: true }
     }
-    reminder.nextISODate = reminders_helpers.instantiate(now, reminder)
   }
 
-  // the user of the KM can override this. this can be used to sync the GUI and the LUI
-  getCurrent() {
+  reminder(id) {
+    return this._objects.reminders.find((reminder) => reminder.id == id)
   }
 
-  askAbout() {
+  reminders() {
+    return this._objects.reminders
+  }
+
+  setReminders(reminders) {
+    this._objects.reminders = reminders
+  }
+
+  askAbout(what) {
     const items = []
-    for (const item of this._objects.reminders) {
-      if (!item.date) {
-        items.push({ when: true, text: item.text, id: item.id })
+    for (const item of this.reminders()) {
+      if (this.missing('missingReminder', item.id)) {
+        items.push(this.missing('missingReminder', item.id))
+      }
+      if (this.missing('missingDate', item.id)) {
+        items.push(this.missing('missingDate', item.id))
       }
     }
     return items
   }
 
   show() {
-    if (this._objects.reminders.length == 0) {
+    if (this.reminders().length == 0) {
       return "There are no reminders"
     }
     let s = 'The reminders are\n'
     let counter = 1
-    for (const item of this._objects.reminders) {
+    for (const item of this.reminders()) {
       s += `    ${counter}. ${item.text}\n`
       counter += 1
     }
@@ -61,21 +186,27 @@ class API {
     // -> return a table object. then have ability to talk about the table. maybe later let's focus on this for now
   }
 
-  delete_reminder(ordinal) {
-    if (ordinal < 1 || ordinal > this._objects.reminders.length) {
-      return `Not possible`
+  delete_reminder(id) {
+    const reminder = this.reminders().find((reminder) => reminder.id)
+    if (reminder) {
+      if (reminder.cleanUp) {
+        reminder.cleanUp()
+      }
+      this.setReminders(this.reminders().filter((reminder) => reminder.id != id))
     }
-    this._objects.reminders = this._objects.reminders.splice(ordinal, 1)
   }
 
-  update(update) {
+  async update(update) {
+    if (!update.id) {
+      update.id = this.getCurrentId()
+    }
     for (const item of this._objects.reminders) {
       if (item.id == update.id) {
         Object.assign(item, update)
+        await this.instantiate(item)
         return
       }
     }
-
   }
 }
 
@@ -86,39 +217,108 @@ const template = {
   configs: [
     { 
       operators: [
-        "([reminderTime|])",
-        "([remind] (self/*) (!@<= 'onDate')*)",
-        "([onDate|on] (reminderTime))",
-        "([remind:withDateBridge] (self/*) (!@<= 'onDate')* (onDate))",
-        "([remind:withDateAndTimeBridge] (self/*) (!@<= 'onDate')* (onDate) (atTime))",
+        "([remindable])",
+        { pattern: "([addRemindable] (word)*)", development: true },
+        "([remind:justWhoBridge] (remindable/*))",
+        "([remind] (remindable/*) (!@<= 'dateTimeSelector' && !@<= 'inAddition')*)",
+        "([remind:withDateBridge] (remindable/*) (!@<= 'dateTimeSelector' && !@<= 'inAddition')* (dateTimeSelector))",
+        "([remind:withDateFirstBridge] (remindable/*) (dateTimeSelector) (!@<= 'dateTimeSelector' && !@<= 'inAddition')*)",
+        "([remind:withDateAndTimeBridge] (remindable/*) (!@<= 'dateTimeSelector' && !@<= 'inAddition')* (dateTimeSelector) (atTime))",
+        "([remindResponse] (!@<= 'remindResponse' && !@<= 'dateTimeSelector' && !@<= 'inAddition')+ (dateTimeSelector))",
         "([show] ([reminders]))",
         "([delete_reminders|delete,cancel] (number/*))",
+        "([add] (remindable/*))",
+        "([remove|] (remindable/*))",
+        "((verb/*) [inAddition|also,too])",
       ],
       bridges: [
+        {
+          id: 'inAddition',
+          after: ['verb'],
+          bridge: "{ ...before[0], inAddition: true, verb: before[0], operator: operator, interpolate: '${verb} ${operator}' }",
+        },
+        {
+          id: 'add',
+          isA: ['verb'],
+          bridge: "{ ...next(operator), arg: after[0], operator: operator, interpolate: '${operator} ${arg}' }",
+          semantic: ({api, context}) => {
+            api.addUser(api.contextToWho(context.arg))
+          }
+        },
+        {
+          id: 'remove',
+          words: ['delete', 'remove'],
+          isA: ['verb'],
+          bridge: "{ ...next(operator), arg: after[0], operator: operator, interpolate: '${operator} ${arg}' }",
+          semantic: ({api, context}) => {
+            api.removeUser(api.contextToWho(context.arg))
+          }
+        },
+        {
+          id: 'addRemindable',
+          isA: ['verb'],
+          development: true,
+          bridge: "{ ...next(operator), flatten: true, arg: after[0], operator: operator, interpolate: '${operator} ${arg}' }",
+          semantic: async ({api, context}) => {
+            const name = context.arg.map( (word) => word.text ).join(' ')
+            await api.addRemindable(name)
+          }
+        },
+        {
+          id: 'remindable',
+          isA: ['listable'],
+        },
+        {
+          id: 'remindResponse',
+          isA: ['verb'],
+          convolution: true,
+          disabled: true,
+          bridge: "{ ...next(operator), operator: operator, reminder: after[0], date: after[1], interpolate: '${reminder} ${date}' }",
+          semantic: async ({context, api, gp, gsp}) => {
+            const text = await gsp(context.reminder.slice(0));
+            const update = { text }
+            if (context.date) {
+              update.dateTimeSelector = context.date
+              update.dateTimeSelectorText = await gp(context.date)
+            }
+            await api.update(update)
+          }
+        },
         {
           id: 'remind',
           isA: ['verb'],
+          localHierarchy: [['self', 'remindable']],
           bridge: "{ ...next(operator), operator: operator, who: after[0], reminder: after[1], interpolate: '${operator} ${who} ${reminder}' }",
+          justWhoBridge: "{ ...next(operator), bridge: 'justWhoBridge', operator: operator, who: after[0], interpolate: '${operator} ${who}' }",
           withDateBridge: "{ ...next(operator), operator: operator, who: after[0], reminder: after[1], date: after[2], interpolate: '${operator} ${who} ${reminder} ${date}' }",
+          withDateFirstBridge: "{ ...next(operator), operator: operator, who: after[0], reminder: after[2], date: after[1], interpolate: '${operator} ${who} ${date} ${reminder}' }",
           withDateAndTimeBridge: "{ ...next(operator), operator: operator, who: after[0], reminder: after[1], date: after[2], time: after[3], interpolate: '${operator} ${who} ${reminder} ${date} ${time}' }",
-          semantic: async ({api, gsp, context}) => {
-            const text = await gsp(context.reminder.slice(1));
-            const reminder = { text, date: context.date, time: context.time }
-            api.instantiate(reminder)
-            api.add(reminder)
-          },
-        },
-        {
-          id: 'reminderTime',
-          children: [
-            'day_dates',
-            'month_dates',
+          semantics: [
+            {
+              match: ({context}) => context.marker == 'remind' && context.inAddition,
+              apply: ({context, api}) => {
+                api.addUser(api.contextToWho(context.who))
+              }
+            },
           ],
-        },
-        { 
-          id: 'onDate', 
-          isA: ['preposition'],
-          bridge: "{ ...next(operator), date: after[0], onDate: operator, interpolate: '${onDate} ${date}' }",
+          semantic: async ({ask, api, gsp, gp, context}) => {
+            const who = api.contextToWho(context.who)
+            let text;
+            if (context.reminder) {
+              text = await gsp(context.reminder.slice(1));
+            }
+            const reminder = { text, dateTimeSelector: context.date, who }
+            if (context.date) {
+              reminder.dateTimeSelector = context.date
+              reminder.dateTimeSelectorText = await gp(context.date)
+            }
+            // await api.instantiate(reminder)
+            await api.add(reminder)
+            reminder.cleanUp = ask([
+              query('missingReminder', reminder.id),
+              query('missingDate', reminder.id),
+            ])
+          },
         },
         { 
           id: 'reminders', 
@@ -145,48 +345,20 @@ const template = {
         },
       ]
     },
+    /*
     ({ask, api}) => {
       ask([
-        {
-          where: where(),
-          oneShot: false,
-          onNevermind: ({verbatim, ...args}) => {
-            // this is cross km boundaries from the dialogues km to this one so the api if for dialogs.
-            // i need to get the one for fastfood here.
-            const api = args.kms.fastfood.api
-            const needsDrink = askAbout({ args, api })
-            for (const item of needsDrink) {
-              api.remove(item)
-            }
-          },
-
-          matchq: ({ api, context }) => api.askAbout().length > 0 && context.marker == 'controlEnd',
-          applyq: ({ api, context }) => {
-            context.cascade = false
-            const items = api.askAbout()
-            const item = items[0]
-            return 'When should I remind you to ' + item.text;
-          },
-
-          matchr: ({ isA, api, context }) => {
-            if (isA(context.marker, 'reminderTime') && api.askAbout().length > 0) {
-                return true
-            }
-            return false
-          },
-          applyr: ({ context, api }) => {
-            const items = api.askAbout()
-            api.update({ id: items[0].id, date: context })
-          }
-        },
+        query('missingReminder'),
+        query('missingDate'),
       ])
     }
+    */
   ],
 }
 
 knowledgeModule( { 
   config: { name: 'reminders' },
-  includes: [time, dates, selfKM],
+  includes: [dateTimeSelectors, selfKM],
   api: () => new API(),
 
   module,
@@ -195,11 +367,21 @@ knowledgeModule( {
     name: './reminders.test.json',
     contents: reminders_tests,
     checks: {
-      context: defaultContextCheck(['who', 'reminder']),
+      context: [defaultContextCheck({ extra: ['who', 'reminder'] })],
       objects: [
         { 
           property: 'reminders',
-          filter: [ 'text', 'date', 'time', 'nextISODate', 'stm' ],
+          filter: [ 
+            'text', 
+            'dateTimeSelectorText', 
+            'nextISODate', 
+            'who', 
+            'stm',
+            {
+              property: 'dateTimeSelector', 
+              filter: ['marker', 'text', 'value'],
+            },
+          ],
         }
       ],
     },