tpmkms_4wp 9.1.1 → 9.2.0-beta.1

package/common/gdefaults.js

@@ -4,6 +4,7 @@ const { knowledgeModule, where } = require('./runtime').theprogrammablemind
 const tokenize = require('./tokenize.js')
 const gdefaults_tests = require('./gdefaults.test.json')
 const { getValue, isMany } = require('./helpers.js')
+const helpers = require('./helpers')
 
 const config = {
   name: 'gdefaults',
@@ -29,6 +30,13 @@ const config = {
       apply: ({context, gp}) => gp(context.response),
     },
 
+    {
+      where: where(),
+      match: ({context}) => context.paraphrase && context.interpolate,
+      apply: async ({interpolate, context}) => {
+        return interpolate(context.interpolate, context)
+      }
+    },
     {
       where: where(),
       match: ({context}) => context.generate,
@@ -232,6 +240,12 @@ const initializer = ({config}) => {
         verbatim: (text) => {
           args.insert({ marker: 'verbatim', verbatim: text, isResponse: true })
         },
+        interpolate: async (interpolate, context) => {
+          const evaluator = async (key) => {
+            return args.gp(context[key])
+          }
+          return await helpers.processTemplateString(interpolate, evaluator)
+        }
       }
     })
   }

package/common/helpers/concept.js

@@ -50,7 +50,11 @@ class API {
     const objectSingular = pluralize.singular(objectWord)
     const objectPlural = pluralize.plural(objectWord)
     // config.addOperator({ pattern: `(${modifierIds.map((modifierId) => `(${modifierId}/*)`).join(' ')} [${modifiersObjectId}] (${objectId}/0))`, allowDups: true })
-    config.addOperator({ pattern: `(${modifierIds.map((modifierId) => `(${modifierId}/*)`).join(' ')} [${modifiersObjectId}] (${objectId}/*))`, allowDups: true })
+    if (false) {
+      config.addOperator({ pattern: `(${modifierIds.map((modifierId) => `(${modifierId}/*)`).join(' ')} [${modifiersObjectId}] (${objectId}/*))`, allowDups: true })
+    } else {
+      config.addOperator({ pattern: `(${modifierIds.map((modifierId) => `(@==${modifierId})`).join(' ')} [${modifiersObjectId}] (@==${objectId}))`, allowDups: true })
+    }
     // config.addOperator({ pattern: `(<${modifierId}|> ([${objectId}|]))`, allowDups: true })
     // config.addOperator({ pattern: `([${modifierObjectId}|])`, allowDups: true })
 
@@ -91,7 +95,7 @@ class API {
     })
     // modifierds.forEach((modifierId) => config.addWord(modifierId, { id: modifierId, initial: `{ value: '${modifierId}' }`}))
 
-    modifierIds.forEach((modifierId) => config.addBridge({ id: modifierId, level: 0, bridge: `{ ...next(operator), value: '${modifierId}' }`,  allowDups: true }))
+    modifierIds.forEach((modifierId) => config.addBridge({ id: modifierId, level: 0, bridge: `{ ...next(operator), value: or(operator.value, '${modifierId}') }`,  allowDups: true }))
     config.addBridge({ id: objectId, level: 0, bridge: `{ ...next(operator), value: '${objectId}' }`,  allowDups: true })
     // config.addBridge({ id: modifierObjectId, level: 0, bridge: `{ ...next(operator), value: '${modifierObjectId}' }`, allowDups: true })
     const modifierProperties = modifierIds.map((modifierId, index) => `'modifier_${modifierId}': before[${index}]`).join(', ')
@@ -102,6 +106,7 @@ class API {
       level: 0, 
       convolution: true,
       isA: [{ parent: 'adjective', instance: true }],
+      associator_return_type: [modifiersObjectId, 0],
       // isA: ['adjective'],
       before: ['verb'],
       bridge: `{ ...after[0], ${modifierProperties}, atomic: true, dead: true, marker: next(operator('${modifiersObjectId}')), value: '${modifiersObjectId}', modifiers: append([${modifierList}], after[0].modifiers)}`, 

package/common/helpers/dialogues.js

@@ -83,6 +83,9 @@ class API {
       return context.value
     }
     */
+    if (typeof context == 'string') {
+      context = { word: context, value: context }
+    }
     const { word, value, number } = context;
     if (!value) {
       return
@@ -102,7 +105,7 @@ class API {
     }
     // config.addOperator({ pattern: `(["${fixUps(concept)}"])`, allowDups: true })
     config.addOperator({ pattern: `(["${concept}"])`, allowDups: true })
-    config.addBridge({ id: concept, level: 0, bridge: `{ ...next(operator), value: '${source_value || concept}' }` , allowDups: true })
+    config.addBridge({ id: concept, level: 0, bridge: `{ ...next(operator), value: or(operator.value, '${source_value || concept}') }` , allowDups: true })
     const addConcept = (word, number) => {
       config.addWord(word, { id: concept, initial: `{ value: "${source_value || concept}", number: "${number}" }` } )
       const baseTypes = [

package/common/helpers/menus.js

@@ -0,0 +1,154 @@
+const calculateLefts = (defs) => {
+  const lefts = {}
+  calculateLeftsHelper(defs, lefts)
+  return lefts
+}
+
+const calculateLeftsHelper = (defs, lefts) => {
+  if (Array.isArray(defs)) {
+    let previous
+    for (const def of defs) {
+      if (previous) {
+        lefts[def.key] = previous.key
+        previous = def
+      } else {
+        previous = def
+      }
+    }
+  }
+  return lefts
+}
+
+const calculateRights = (defs) => {
+  const rights = {}
+  calculateRightsHelper(defs, rights)
+  return rights
+}
+
+const calculateRightsHelper = (defs, rights) => {
+  if (Array.isArray(defs)) {
+    let previous
+    for (const def of defs) {
+      if (previous) {
+        rights[previous.key] = def.key
+        previous = def
+      } else {
+        previous = def
+      }
+    }
+  }
+  return rights
+}
+
+const calculateDowns = (defs) => {
+  const downs = {}
+  calculateDownsHelper(defs, downs)
+  return downs
+}
+
+const calculateDownsHelper = (defs, downs) => {
+  if (Array.isArray(defs)) {
+    for (const def of defs) {
+      calculateDownsHelper(def, downs)
+    }
+  } else if (defs.children) {
+    if (defs.children.length > 0) {
+      downs[defs.key] = defs.children[0].key
+    }
+
+    let previous
+    for (const child of defs.children) {
+      if (child.divider) {
+        continue
+      }
+      if (previous) {
+        downs[previous.key] = child.key
+        previous = child
+      } else {
+        previous = child
+      }
+    }
+  }
+  return downs
+}
+
+const calculateUps = (defs) => {
+  const ups = {}
+  calculateUpsHelper(defs, ups)
+  return ups
+}
+
+const calculateUpsHelper = (defs, ups) => {
+  if (Array.isArray(defs)) {
+    for (const def of defs) {
+      calculateUpsHelper(def, ups)
+    }
+  } else if (defs.children) {
+    let previous
+    for (const child of defs.children) {
+      if (child.divider) {
+        continue
+      }
+      if (previous) {
+        ups[child.key] = previous.key
+        previous = child
+      } else {
+        previous = child
+      }
+    }
+  }
+  return ups
+}
+
+const calculateParents = (defs) => {
+  const parents = {}
+  calculateParentsHelper(defs, parents)
+  return parents
+}
+
+const calculateParentsHelper = (defs, parents) => {
+  if (Array.isArray(defs)) {
+    for (const def of defs) {
+      parents[def.key] = def.key
+      calculateParentsHelper(def, parents)
+    }
+  } else if (defs.children) {
+    for (const child of defs.children) {
+      if (child.divider) {
+        continue
+      }
+      parents[child.key] = defs.key
+    }
+  }
+  return parents
+}
+
+const calculatePaths = (defs) => {
+  const paths = {}
+  calculatePathsHelper(defs, paths)
+  return paths
+}
+
+const calculatePathsHelper = (defs, paths) => {
+  if (Array.isArray(defs)) {
+    for (const def of defs) {
+      calculatePathsHelper(def, paths)
+    }
+  } else {
+    paths[defs.key] = [defs.key]
+    for (const child of (defs.children || [])) {
+      paths[child.key] = [defs.key, child.key]
+    }
+  }
+  return paths
+}
+
+
+module.exports = {
+  calculateRights,
+  calculateLefts,
+  calculateDowns,
+  calculateUps,
+  calculateParents,
+  calculatePaths,
+}

package/common/helpers/properties.js

@@ -548,8 +548,7 @@ class API {
 
   makeObject(args) {
 		const types = [ 'hierarchyAble', 'object', 'property' ];
-    const { config } = args;
-    return this._km("dialogues").api.makeObject({ ...args, types });
+    return args.km("dialogues").api.makeObject({ ...args, types: (args.types || []).concat(types) });
   }
 
   relation_add (relations) {
@@ -704,6 +703,7 @@ class API {
   }
 
   setProperty(object, property, value, has, skipHandler) {
+    // debugger
     if (!skipHandler) {
       const handler = this.propertiesFH.getHandler([object, property])
       if (handler) {
@@ -794,31 +794,6 @@ class API {
 
   learnWords(config, context) {
   }
-/*
-  ensureDefault(map, key, default) {
-    if (!this._objects[map][key]) {
-      this._objects[map][key] = default
-    }
-    return this._objects[map][key]
-  }
-
-  pushListNoDups(list, value) {
-    if (list.includes(value)) {
-      return
-    }
-    list.push(value)
-  }
-
-  ensureConcept(concept) {
-    ensureDefault(this.properties, concept, {})
-    ensureDefault(this.concepts, concept, [])
-  }
-
-  canDo(object, ability) {
-    this.ensureConcept(object)
-    this.pushListNoDups(this.ensureList('abilities', object), ability)
-  }
-*/
   isA(child, ancestor) {
     // return this._objects.parents[child].includes(parent);
     const todo = [child];

package/common/helpers.js

@@ -1,5 +1,19 @@
 const pluralize = require('pluralize')
 
+const unshiftL = (list, element, max) => {
+  if (list.length >= max) {
+    list.pop()
+  }
+  list.unshift(element)
+}
+
+const pushL = (list, element, max) => {
+  if (list.length >= max) {
+    list.shift()
+  }
+  list.push(element)
+}
+
 // X pm today or tomorrow
 const millisecondsUntilHourOfDay = (newDate, hour) => {
   const now = newDate()
@@ -206,7 +220,50 @@ const getValue = (propertyPath, object) => {
   return value
 }
 
+const processTemplateString = async (template, evaluate) => {
+  async function resolveWithCallback(strings, ...keys) {
+    // const resolvedValues = await Promise.all(keys.map(key => lookupVariable(key)));
+    const resolvedValues = await Promise.all(keys.map(async (key) => {
+      return await evaluate(key)
+    }))
+
+    let result = strings[0];
+    for (let i = 0; i < resolvedValues.length; i++) {
+      result += resolvedValues[i] + strings[(i + 1)*2];
+    }
+    return result;
+  }
+
+  async function processTemplateString(template) {
+    // Split the template into strings and keys
+    const parts = template.split(/(\${[^}]+})/g);
+    const strings = [];
+    const keys = [];
+    for (const part of parts) {
+      if (part.startsWith("${") && part.endsWith("}")) {
+        keys.push(part.slice(2, -1)); // Extract key (e.g., "name" from "${name}")
+        strings.push(""); // Placeholder for interpolation
+      } else {
+        strings.push(part);
+      }
+    }
+
+    // Ensure the strings array has one more element than keys
+    if (strings.length === keys.length) {
+      strings.push("");
+    }
+
+    // Pass to the tagged template function
+    return resolveWithCallback(strings, ...keys);
+  }
+
+  return await processTemplateString(template)
+}
+
 module.exports = {
+  processTemplateString,
+  unshiftL,
+  pushL,
   getValue,
   defaultContextCheck,
   defaultContextCheckProperties,

package/common/hierarchy.js

@@ -246,14 +246,15 @@ const config = {
        
         return listable(context, 'hierarchyAble') && context.same && context.same.concept && !context.query
       },
-      apply: ({callId, config, objects, km, context, asList, listable}) => {
+      apply: (args) => {
+        const {callId, config, objects, km, context, asList, listable} = args
         const api = km('properties').api
         const oneConcepts = asList(context);
         const twoConcepts = asList(context.same);
         for (const oneConcept of oneConcepts.value) {
           for (const twoConcept of twoConcepts.value) {
-            oneConceptId = api.makeObject({config, context: oneConcept})
-            twoConceptId = api.makeObject({config, context: twoConcept})
+            oneConceptId = api.makeObject({...args, context: oneConcept})
+            twoConceptId = api.makeObject({...args, context: twoConcept})
             api.rememberIsA(oneConceptId, twoConceptId)
             context.sameWasProcessed = true
           }

package/common/kirk.instance.json

@@ -400,6 +400,11 @@
           "queryable",
           false
         ],
+        [
+          "doctor",
+          "rank",
+          false
+        ],
         [
           "doctor",
           "theAble",
@@ -495,11 +500,6 @@
           "theAble",
           false
         ],
-        [
-          "emotion",
-          "unknown",
-          false
-        ],
         [
           "evaluate",
           "verb",
@@ -510,6 +510,41 @@
           "article",
           false
         ],
+        [
+          "eye",
+          "hierarchyAble",
+          false
+        ],
+        [
+          "eye",
+          "isEdee",
+          false
+        ],
+        [
+          "eye",
+          "isEder",
+          false
+        ],
+        [
+          "eye",
+          "object",
+          false
+        ],
+        [
+          "eye",
+          "property",
+          false
+        ],
+        [
+          "eye",
+          "queryable",
+          false
+        ],
+        [
+          "eye",
+          "theAble",
+          false
+        ],
         [
           "feel",
           "canBeDoQuestion",
@@ -790,6 +825,11 @@
           "isEder",
           false
         ],
+        [
+          "mccoy",
+          "name",
+          false
+        ],
         [
           "mccoy",
           "object",
@@ -865,6 +905,41 @@
           "verb",
           false
         ],
+        [
+          "name",
+          "hierarchyAble",
+          false
+        ],
+        [
+          "name",
+          "isEdee",
+          false
+        ],
+        [
+          "name",
+          "isEder",
+          false
+        ],
+        [
+          "name",
+          "object",
+          false
+        ],
+        [
+          "name",
+          "property",
+          false
+        ],
+        [
+          "name",
+          "queryable",
+          false
+        ],
+        [
+          "name",
+          "theAble",
+          false
+        ],
         [
           "negatable",
           "queryable",
@@ -1185,6 +1260,41 @@
           "punctuation",
           false
         ],
+        [
+          "rank",
+          "hierarchyAble",
+          false
+        ],
+        [
+          "rank",
+          "isEdee",
+          false
+        ],
+        [
+          "rank",
+          "isEder",
+          false
+        ],
+        [
+          "rank",
+          "object",
+          false
+        ],
+        [
+          "rank",
+          "property",
+          false
+        ],
+        [
+          "rank",
+          "queryable",
+          false
+        ],
+        [
+          "rank",
+          "theAble",
+          false
+        ],
         [
           "readonly",
           "queryable",
@@ -1210,11 +1320,6 @@
           "queryable",
           false
         ],
-        [
-          "sentientBeing",
-          "unknown",
-          false
-        ],
         [
           "spock",
           "crew_member",
@@ -1240,6 +1345,11 @@
           "isEder",
           false
         ],
+        [
+          "spock",
+          "name",
+          false
+        ],
         [
           "spock",
           "object",
@@ -1260,6 +1370,41 @@
           "theAble",
           false
         ],
+        [
+          "status",
+          "hierarchyAble",
+          false
+        ],
+        [
+          "status",
+          "isEdee",
+          false
+        ],
+        [
+          "status",
+          "isEder",
+          false
+        ],
+        [
+          "status",
+          "object",
+          false
+        ],
+        [
+          "status",
+          "property",
+          false
+        ],
+        [
+          "status",
+          "queryable",
+          false
+        ],
+        [
+          "status",
+          "theAble",
+          false
+        ],
         [
           "stm_before",
           "adjective",
@@ -1567,6 +1712,7 @@
           "level": 2,
           "context_index": 1,
           "topLevel": true,
+          "context_id": 2,
           "touchedBy": [
             "kirk#call2"
           ]