ekms 8.0.0 → 8.1.0-beta.1

package/common/animals.js

@@ -1,5 +1,5 @@
 const { defaultContextCheck } = require('./helpers')
-const { Config, knowledgeModule, where } = require('./runtime').theprogrammablemind
+const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const hierarchy = require('./hierarchy')
 const animals_tests = require('./animals.test.json')
 const animals_instance = require('./animals.instance.json')
@@ -25,26 +25,23 @@ const template = {
   ],
 }
 
-const createConfig = () => {
-  const config = new Config({ name: 'animals' }, module)
-  config.add(hierarchy())
-  return config
-}
-
 knowledgeModule( {
-    module,
-      description: 'animals related concepts',
-      createConfig, newWay: true,
-      test: {
-              name: './animals.test.json',
-              contents: animals_tests,
-              checks: {
-                context: defaultContextCheck,
-              },
+    config: { name: 'animals' },
+    includes: [hierarchy],
 
+    module,
+    description: 'animals related concepts',
+    newWay: true,
+    test: {
+            name: './animals.test.json',
+            contents: animals_tests,
+            checks: {
+              context: defaultContextCheck(),
             },
-      template: {
-        template,
-        instance: animals_instance
-      }
+
+          },
+    template: {
+      template,
+      instance: animals_instance
+    }
 })

package/common/articles.js

@@ -0,0 +1,103 @@
+const { knowledgeModule, where, stableId } = require('./runtime').theprogrammablemind
+const gdefaults = require('./gdefaults.js')
+const pos = require('./pos.js')
+const { defaultContextCheck } = require('./helpers')
+const tests = require('./articles.test.json')
+
+let config = {
+  name: 'articles',
+  operators: [
+    "([thisitthat|])",
+    "([it])",
+    "([this])",
+    "([that])",
+    "([queryable])",
+  /*
+    "(<what> ([whatAble|]))",
+    "([what:optional])",
+  */
+    "(<the|> ([theAble]))",
+    "(<a|a,an> ([theAble|]))",
+  ],
+  bridges: [
+    // { id: "what", level: 0, optional: "{ ...next(operator), query: ['what'], determined: true }", bridge: "{ ...after, query: ['what'], modifiers: ['what'], what: operator }" },
+    // { id: "whatAble", level: 0, bridge: "{ ...next(operator) }" },
+    { 
+      id: 'the', 
+      level: 0, 
+      bridge: '{ ...after[0], focusableForPhrase: true, pullFromContext: true, concept: true, wantsValue: true, determiner: "the", modifiers: append(["determiner"], after[0].modifiers)}' 
+    },
+    { 
+      id: "a", 
+      level: 0, 
+      // bridge: "{ ...after[0], pullFromContext: false, instance: true, concept: true, number: 'one', wantsValue: true, determiner: operator, modifiers: append(['determiner'], after[0].modifiers) }" 
+      bridge: "{ ...after[0], pullFromContext: false, instance: true, concept: true, number: 'one', wantsValue: true, determiner: operator, modifiers: append(['determiner'], after[0].modifiers) }" 
+    },
+    { id: "queryable" },
+    { 
+      id: "theAble", 
+      children: ['noun'],
+      bridge: "{ ...next(operator) }" 
+    },
+
+    { 
+      id: "thisitthat", 
+      level: 0, 
+      isA: ['queryable'], 
+      before: ['verb'],
+      bridge: "{ ...next(operator) }" 
+    },
+    { 
+      id: "it", 
+      level: 0, 
+      isA: ['thisitthat'], 
+      bridge: "{ ...next(operator), pullFromContext: true, unknown: true, determined: true }" 
+    },
+    { 
+      id: "this", 
+      level: 0, 
+      isA: ['thisitthat'], 
+      bridge: "{ ...next(operator), unknown: true, pullFromContext: true }" 
+    },
+    { 
+      id: "that", 
+      level: 0, 
+      isA: ['thisitthat'], 
+      bridge: "{ ...next(operator), unknown: true, pullFromContext: true }" 
+    },
+  ],
+  words: {
+    "literals": {
+      "the": [{"id": "the", "initial": "{ modifiers: [] }" }],
+    }
+  },
+  hierarchy: [
+    ['it', 'pronoun'],
+    ['this', 'pronoun'],
+    // ['questionMark', 'isEd'],
+    ['a', 'articlePOS'],
+    ['the', 'articlePOS'],
+    ['it', 'queryable'],
+    // ['it', 'toAble'],
+    ['this', 'queryable'],
+  ],
+
+};
+
+knowledgeModule( { 
+  config,
+  includes: [pos, gdefaults],
+
+  module,
+  description: 'articles',
+  newWay: true,
+  test: {
+    name: './articles.test.json',
+    contents: tests,
+    checks: {
+            objects: ['onNevermindWasCalled', 'nevermindType', 'idSuffix'],
+            context: defaultContextCheck(),
+          },
+
+  },
+})

package/common/articles.test.json

@@ -0,0 +1,310 @@
+[
+  {
+    "associations": [
+      [
+        [
+          "the",
+          0
+        ],
+        [
+          "theAble",
+          0
+        ]
+      ]
+    ],
+    "config": {
+    },
+    "contexts": [
+      {
+        "concept": true,
+        "dead": true,
+        "default": true,
+        "determiner": "the",
+        "focusableForPhrase": true,
+        "level": 1,
+        "marker": "theAble",
+        "modifiers": [
+          "determiner"
+        ],
+        "pullFromContext": true,
+        "range": {
+          "end": 10,
+          "start": 0
+        },
+        "text": "the theable",
+        "topLevel": true,
+        "types": [
+          "theAble"
+        ],
+        "value": "theAble",
+        "wantsValue": true,
+        "word": "theable"
+      }
+    ],
+    "developerTest": false,
+    "generatedParenthesized": [
+      ""
+    ],
+    "metadata": {
+      "opChoices": [
+        {
+          "counter": 1,
+          "op": [
+            "theAble",
+            0
+          ],
+          "ops": [
+            [
+              "the",
+              0
+            ],
+            [
+              "theAble",
+              0
+            ]
+          ]
+        },
+        {
+          "counter": 2,
+          "op": [
+            "the",
+            0
+          ],
+          "ops": [
+            [
+              "the",
+              0
+            ]
+          ]
+        }
+      ]
+    },
+    "objects": {
+      "nameToUUID": {
+        "articles": "articles1",
+        "gdefaults": "gdefaults2",
+        "pos": "pos2",
+        "tokenize": "tokenize2"
+      },
+      "namespaced": {
+        "articles1": {
+        },
+        "gdefaults2": {
+        },
+        "pos2": {
+        },
+        "tokenize2": {
+        }
+      },
+      "processed": [
+        {
+          "context": {
+            "concept": true,
+            "dead": true,
+            "default": true,
+            "determiner": "the",
+            "focusableForPhrase": true,
+            "level": 1,
+            "marker": "theAble",
+            "modifiers": [
+              "determiner"
+            ],
+            "pullFromContext": true,
+            "range": {
+              "end": 10,
+              "start": 0
+            },
+            "text": "the theable",
+            "topLevel": true,
+            "types": [
+              "theAble"
+            ],
+            "value": "theAble",
+            "wantsValue": true,
+            "word": "theable"
+          },
+          "generatedParenthesized": "",
+          "paraphrases": "the theable",
+          "paraphrasesParenthesized": "(the (theable))",
+          "responses": [
+            ""
+          ]
+        }
+      ]
+    },
+    "paraphrases": [
+      "the theable"
+    ],
+    "paraphrasesParenthesized": [
+      "(the (theable))"
+    ],
+    "query": "the theable",
+    "responses": [
+      ""
+    ]
+  },
+  {
+    "associations": [
+      [
+        [
+          "a",
+          0
+        ],
+        [
+          "theAble",
+          0
+        ]
+      ]
+    ],
+    "config": {
+    },
+    "contexts": [
+      {
+        "concept": true,
+        "dead": true,
+        "default": true,
+        "determiner": {
+          "default": true,
+          "level": 0,
+          "marker": "a",
+          "range": {
+            "end": 0,
+            "start": 0
+          },
+          "text": "a",
+          "word": "a"
+        },
+        "level": 1,
+        "marker": "theAble",
+        "modifiers": [
+          "determiner"
+        ],
+        "number": "one",
+        "pullFromContext": false,
+        "range": {
+          "end": 8,
+          "start": 0
+        },
+        "text": "a theable",
+        "topLevel": true,
+        "types": [
+          "theAble"
+        ],
+        "value": "theAble",
+        "wantsValue": true,
+        "word": "theable"
+      }
+    ],
+    "developerTest": false,
+    "generatedParenthesized": [
+      ""
+    ],
+    "metadata": {
+      "opChoices": [
+        {
+          "counter": 1,
+          "op": [
+            "theAble",
+            0
+          ],
+          "ops": [
+            [
+              "a",
+              0
+            ],
+            [
+              "theAble",
+              0
+            ]
+          ]
+        },
+        {
+          "counter": 2,
+          "op": [
+            "a",
+            0
+          ],
+          "ops": [
+            [
+              "a",
+              0
+            ]
+          ]
+        }
+      ]
+    },
+    "objects": {
+      "nameToUUID": {
+        "articles": "articles1",
+        "gdefaults": "gdefaults2",
+        "pos": "pos2",
+        "tokenize": "tokenize2"
+      },
+      "namespaced": {
+        "articles1": {
+        },
+        "gdefaults2": {
+        },
+        "pos2": {
+        },
+        "tokenize2": {
+        }
+      },
+      "processed": [
+        {
+          "context": {
+            "concept": true,
+            "dead": true,
+            "default": true,
+            "determiner": {
+              "default": true,
+              "level": 0,
+              "marker": "a",
+              "range": {
+                "end": 0,
+                "start": 0
+              },
+              "text": "a",
+              "word": "a"
+            },
+            "level": 1,
+            "marker": "theAble",
+            "modifiers": [
+              "determiner"
+            ],
+            "number": "one",
+            "pullFromContext": false,
+            "range": {
+              "end": 8,
+              "start": 0
+            },
+            "text": "a theable",
+            "topLevel": true,
+            "types": [
+              "theAble"
+            ],
+            "value": "theAble",
+            "wantsValue": true,
+            "word": "theable"
+          },
+          "generatedParenthesized": "",
+          "paraphrases": "a theable",
+          "paraphrasesParenthesized": "((a) (theable))",
+          "responses": [
+            ""
+          ]
+        }
+      ]
+    },
+    "paraphrases": [
+      "a theable"
+    ],
+    "paraphrasesParenthesized": [
+      "((a) (theable))"
+    ],
+    "query": "a theable",
+    "responses": [
+      ""
+    ]
+  }
+]

package/common/asking.instance.json

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

package/common/asking.js

@@ -0,0 +1,253 @@
+const { knowledgeModule, where, stableId } = require('./runtime').theprogrammablemind
+const meta = require('./meta.js')
+const gdefaults = require('./gdefaults.js')
+const sdefaults = require('./sdefaults.js')
+const conjunction = require('./conjunction.js')
+const asking_tests = require('./asking.test.json')
+const { defaultContextCheck, indent, focus, requiredArgument } = require('./helpers')
+const pluralize = require('pluralize')
+
+// TODO implement what / what did you say ...
+let config = {
+  name: 'asking',
+  operators: [
+    "([nevermind])",
+    { pattern: "([nevermindTestSetup] (allowed))", development: true },
+    { pattern: "([whichOnesTestSetup] (choices)*)", development: true },
+  ],
+  bridges: [
+    {
+      id: "nevermind",
+      bridge: "{ ...next(operator) }",
+      semantic: (args) => {
+        const {config, context} = args
+        // stop asking all questions
+        for (const semantic of config.semantics) {
+          if (semantic.isQuestion) {
+            let doRemove = true
+            if (semantic.onNevermind && semantic.getWasAsked() && !semantic.getWasApplied()) {
+              doRemove = semantic.onNevermind(args)
+            }
+            if (doRemove) {
+              config.removeSemantic(semantic)
+            }
+          }
+        }
+      }
+    },
+
+    {
+      id: "whichOnesTestSetup",
+      development: true,
+      generatorp: async ({context, gs}) => `${context.marker} ${await gs(context.choices)}`,
+      bridge: "{ ...next(operator), choices: after }",
+      semantic: ({askWhich, context}) => {
+        const choices = context.choices
+        const chosen = ({ choice, objects }) => {
+          objects.choice = choice
+        }
+
+        const question = async ({choices, g, gs, wasAsked, state}) => {
+          if (wasAsked) {
+            return `${await g(state.lastChoice)} is not a choice. The choices are: ${await gs(choices, ' ', ' or ')}`
+          } else {
+            return `Which value do you want: ${await gs(choices, ' ', ' or ')}`
+          }
+        }
+
+        const isChoice = ({context, choices, state}) => {
+          state.lastChoice = context
+          for (const choice of choices) {
+            if (choice.value == context.value) {
+              return true
+            }
+          }
+        }
+
+        const onNevermind = ({objects, context}) => {
+          objects.onNevermindWasCalled = true
+          return true
+        }
+
+        askWhich({ choices, chosen, question, isChoice, onNevermind })
+      }
+    },
+
+    {
+      id: "nevermindTestSetup",
+      development: true,
+      bridge: "{ ...next(operator), type: after[0], postModifiers: ['type'] }",
+      semantic: ({ask, context}) => {
+        const nevermindType = context.type.value
+        ask({
+          applyq: () => 'the test question?',
+          onNevermind: ({objects, context}) => {
+            objects.onNevermindWasCalled = true
+            objects.nevermindType = nevermindType
+            return nevermindType == 'accept'
+          },
+          matchr: () => false,
+          applyr: () => {},
+        })
+      }
+    },
+  ],
+};
+
+const getAsk = (config) => (uuid) => {
+    return (asks) => {
+    const ask = (ask) => {
+      let oneShot = true // default
+      if (ask.oneShot === false) {
+        oneShot = false
+      }
+
+      const id_q = stableId('semantic')
+      const id_rs = []
+      let wasAsked = false
+      let wasApplied = false
+      const getWasAsked = () => {
+        return wasAsked
+      }
+      const setWasAsked = (value) => {
+        wasAsked = value
+      }
+      const getWasApplied = () => {
+        return wasApplied
+      }
+      const setWasApplied = (value) => {
+        wasApplied = value
+      }
+
+      const semanticsr = ask.semanticsr || []
+      if (semanticsr.length == 0) {
+        semanticsr.push({ match: ask.matchr, apply: ask.applyr })
+      }
+      for (const semantic of semanticsr) {
+        const id_r = stableId('semantic')
+        id_rs.push(id_r)
+        config.addSemantic({
+          uuid,
+          id: id_r,
+          tied_ids: [id_q],
+          oneShot,
+          where: semantic.where || ask.where || where(2),
+          source: 'response',
+          match: (args) => semantic.match(args),
+          apply: async (args) => {
+            setWasApplied(true)
+            await semantic.apply(args)
+          },
+        })
+      }
+
+      config.addSemantic({
+        uuid,
+        oneShot,
+        id: id_q,
+        tied_ids: id_rs,
+        where: ask.where,
+        isQuestion: true,  // do one question at a time
+        getWasAsked,
+        getWasApplied,
+        onNevermind: ask.onNevermind,
+        source: 'question',
+        match: ({ context }) => context.marker == 'controlEnd' || context.marker == 'controlBetween',
+        apply: async (args) => {
+          let matchq = ask.matchq
+          let applyq = ask.applyq
+          if (!matchq) {
+            let wasAsked = false
+            matchq = () => !wasAsked,
+            applyq = (args) => {
+              wasAsked = true
+              return ask.applyq(args)
+            }
+          }
+          if (await matchq(args)) {
+            setWasApplied(false)
+            // args.context.motivationKeep = true
+            args.verbatim(await applyq({ ...args, wasAsked: getWasAsked() }))
+            setWasAsked(true)
+            args.context.controlKeepMotivation = true
+          }
+          args.context.cascade = true
+        }
+      })
+    }
+    if (!Array.isArray(asks)) {
+      asks = [asks]
+    }
+
+    [...asks].reverse().forEach( (a) => ask(a) )
+  }
+}
+
+
+const initializer = ({objects, config, isModule}) => {
+  config.addArgs(({config, api, isA}) => ({ 
+    getUUIDScoped: (uuid) => { 
+      const ask = getAsk(config)(uuid)
+      return {
+        ask,
+        askWhich: ({ choices, chosen, question, isChoice, onNevermind }) => {
+          let state = {}
+
+          requiredArgument(choices, 'choices')
+          requiredArgument(chosen, 'chosen')
+
+          if (!onNevermind) {
+            onNevermind = ({objects, context}) => {
+              return true
+            }
+          }
+
+          if (!question) {
+            const question = async ({choices, g, gs, wasAsked, state}) => {
+              if (wasAsked) {
+                return `${await g(state.lastChoice)} is not a choice. The choices are: ${await gs(choices, ' ', ' or ')}`
+              } else {
+                return `Which value do you want: ${await gs(choices, ' ', ' or ')}`
+              }
+            }
+          }
+
+          if (!isChoice) {
+            const isChoice = ({context, choices, state}) => {
+              state.lastChoice = context
+              for (const choice of choices) {
+                if (choice.value == context.value) {
+                  return true
+                }
+              }
+            }
+          }
+
+          ask({
+            applyq: async (args) => await question({...args, choices, state}),
+            onNevermind,
+            matchr: (args) => isChoice({...args, choices, state}),
+            applyr: (args) => chosen({...args, choice: args.context}),
+          })
+        }
+      } 
+    },
+  }))
+}
+
+knowledgeModule( { 
+  config,
+  includes: [conjunction, gdefaults, sdefaults],
+  initializer,
+  module,
+  description: 'asking the user questions',
+  newWay: true,
+  test: {
+    name: './asking.test.json',
+    contents: asking_tests,
+    checks: {
+      objects: ['onNevermindWasCalled', 'nevermindType', 'choice'],
+      context: defaultContextCheck(),
+    },
+  },
+})