theprogrammablemind_4wp 9.5.1 → 9.6.0

package/src/configHelpers.js

@@ -97,11 +97,11 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   if (args.uuid) {
     args.objects = args.getObjects(args.uuid)
   }
-  if (!hierarchy) {
-    hierarchy = config.hierarchy
+  if (!hierarchy && config.getHierarchy) {
+    hierarchy = config.getHierarchy()
   }
   // callId
-  args.calls = new InitCalls(args.isInstance ? `${args.isInstance}#${config.name}` : config.name)
+  args.calls = new InitCalls(args.isInstance ? `${args.isInstance}#${config.getName()}` : config.getName())
   if (global.theprogrammablemind && global.theprogrammablemind.loadForTesting) {
     args.calls = new InitCalls(Object.keys(global.theprogrammablemind.loadForTesting)[0])
   }
@@ -112,14 +112,18 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
     throw new ErrorReason(context)
   }
   args.kms = config.getConfigs()
-  args.config = config
+  args.config = config.getPseudoConfig(uuidForScoping, config)
   args.hierarchy = hierarchy
   args.isA = isA(hierarchy)
   // args.listable = listable(hierarchy)
   // args.asList = asList
   args.retry = () => { throw new RetryError() }
-  args.fragments = (query) => {
-    return config.fragment(args, query)
+  // mappings are optional
+  args.fragments = (query, mappings) => {
+    return config.fragment(args, query, mappings)
+  }
+  args.fragmentMapper = (values, fromModelQuery, toModelQuery) => {
+    return config.fragmentMapper(args, values, fromModelQuery, toModelQuery)
   }
   args.breakOnSemantics = false
   args.theDebugger = {
@@ -133,20 +137,35 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   args.addPattern = (pattern, def) => config.addPattern(pattern, args.uuid)
   args.addGenerator = (generator) => config.addGenerator(generator, args.uuid, config.name)
 
+  if (config.getTestConfig()?.testModuleName) {
+    args.testModuleName = config.getTestConfig().testModuleName
+  }
   args.addAssumedScoped = (args, assumed) => {
     const addAssumed = (args, ...moreAssumed) => {
       return { ...args, assumed: Object.assign({}, assumed, (args.assumed || {}), ...moreAssumed) }
     }
 
-    args.s = (c) => config.getSemantics(logs).apply(args, c)
-    args.g = (c, a = {}) => {
-      return config.getGenerators(logs).apply(addAssumed(args, a), c, a)
+    args.s = (c, options = {}) => config.getSemantics(logs).apply(args, c, options)
+    args.g = (c, rest = {}) => {
+      // if (JSON.stringify(rest) !== '{}' && !(rest.assumed || rest.options)) {
+      //   debugger
+      // }
+      const { assumed = {}, options = {} } = rest
+      return config.getGenerators(logs).apply(addAssumed(args, assumed), c, assumed, options)
     }
-    args.gp = (c, a = {}) => {
-      return config.getGenerators(logs).apply(addAssumed(args, a, { paraphrase: true, isResponse: false, response: false }), c, { paraphrase: true, isResponse: false, response: false })
+    args.gp = (c, rest = {}) => {
+      // if (JSON.stringify(rest) !== '{}' && !(rest.assumed || rest.options)) {
+      //   debugger
+      // }
+      const { assumed = {}, options = {} } = rest
+      return config.getGenerators(logs).apply(addAssumed(args, assumed, { paraphrase: true, isResponse: false, response: false }), c, { paraphrase: true, isResponse: false, response: false }, options)
     }
-    args.gr = (c, a = {}) => {
-      return config.getGenerators(logs).apply(addAssumed(args, a, { paraphrase: false, isResponse: true }), { ...c, paraphrase: false, isResponse: true })
+    args.gr = (c, rest  = {}) => {
+      // if (JSON.stringify(rest) !== '{}' && !(rest.assumed || rest.options)) {
+      //   debugger
+      // }
+      const { assumed = {}, options = {} } = rest
+      return config.getGenerators(logs).apply(addAssumed(args, assumed, { paraphrase: false, isResponse: true }), { ...c, paraphrase: false, isResponse: true }, options)
     }
     args.e = (c) => {
       if (!c) {
@@ -179,14 +198,8 @@ const setupArgs = (args, config, logs, hierarchy, uuidForScoping) => {
   }
   config.getAddedArgs(args)
 
-  Object.assign(args, args.getUUIDScoped(uuidForScoping || config.uuid))
+  Object.assign(args, args.getUUIDScoped(uuidForScoping || config.getUUID()))
   args.apis = args.apis || ((name) => config.getConfig(name).api)
-  /*
-  if (uuidForScoping) {
-    Object.assign(args, args.getUUIDScoped(uuidForScoping))
-  }
-  */
-  // sets args for all the API. that make a copy so the args must be fully setup by here except for scoped
   config.setArgs(args)
 }
 
@@ -199,6 +212,22 @@ const getObjects = (objects) => {
   }
 }
 
+const run = async (config, handler) => {
+  // map to hash
+  config = config || {}
+  if (config.config) {
+    config = config
+  }
+
+  const hierarchy = new DigraphInternal((config.config || {}).hierarchy || [])
+
+  const objects = config.config.objects.namespaced[config.uuid]
+  const logs = []
+  const args = {}
+  setupArgs(args, config, logs, hierarchy)
+  return handler(args)
+}
+
 const processContext = async (context, { objects = {}, config, logs = [] }) => {
   const generators = config.getGenerators(logs)
   const semantics = config.getSemantics(logs)
@@ -291,7 +320,7 @@ const setupContexts = (rawContexts) => {
   return contexts
 }
 
-const processContextsB = async ({ config, hierarchy, semantics, generators, json, isTest, isProcess, isModule, rebuildingTemplate, isInstance, instance, query, data, retries, url, commandLineArgs, forTemplate }) => {
+const processContextsB = async ({ config, hierarchy, semantics, generators, json, isTest, isProcess, isModule, rebuildingTemplate, isInstance, instance, query, data, retries, url, commandLineArgs, forTemplate, contextIdCounter }) => {
   // TODO fix this name to contextsPrime
   const contextsPrime = []
   const generatedPrime = []
@@ -311,14 +340,13 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
   args.insert = (context) => toDo.unshift(context)
   let overlap, lastRange
   config.debugLoops = commandLineArgs && commandLineArgs.debugLoops
-  let context_id_counter = 0
   while (toDo.length > 0) {
     const context = toDo.shift()
     args.calls.next()
     let contextPrime = context
     context.topLevel = true
-    context_id_counter += 1
-    context.context_id = context_id_counter
+    contextIdCounter += 1
+    context.context_id = contextIdCounter
     try {
       if (json.has_errors) {
         throw new Error('There are errors in the logs. Run with the -d flag and grep for Error')
@@ -328,6 +356,9 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
         const semantics = config.getSemantics(json.logs)
         try {
           contextPrime = await semantics.apply(args, context)
+          // contextPrime.greg = 'yes'
+//          console.log("context_id", context.context_id)
+//          console.log("semantics.apply", JSON.stringify(contextPrime, null, 2))
         } catch (e) {
           if (e.message == 'Maximum call stack size exceeded') {
             const mostCalled = semantics.getMostCalled()
@@ -368,21 +399,21 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
         const generated = contextPrime.isResponse ? await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
         let generatedParenthesized = []
         if (generateParenthesized) {
-          config.parenthesized = true
+          config.setParenthesized(true)
           generatedParenthesized = contextPrime.isResponse ? await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed) : ''
-          config.parenthesized = false
+          config.setParenthesized(false)
         }
         // assumed = { paraphrase: true, response: false };
         assumed = { paraphrase: true, isResponse: false, response: false }
         if (generateParenthesized) {
-          config.parenthesized = false
+          config.setParenthesized(false)
         }
         const paraphrases = await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
         let paraphrasesParenthesized = []
         if (generateParenthesized) {
-          config.parenthesized = true
+          config.setParenthesized(true)
           paraphrasesParenthesized = await config.getGenerators(json.logs).apply({ ...args, assumed }, contextPrime, assumed)
-          config.parenthesized = false
+          config.setParenthesized(false)
         }
         contextsPrime.push(contextPrime)
         generatedPrime.push(generated)
@@ -421,7 +452,7 @@ const processContextsB = async ({ config, hierarchy, semantics, generators, json
       throw e
     }
   }
-  return { contextsPrime, generatedPrime, paraphrasesPrime, paraphrasesParenthesizedPrime, generatedParenthesizedPrime, responsesPrime }
+  return { contextsPrime, generatedPrime, paraphrasesPrime, paraphrasesParenthesizedPrime, generatedParenthesizedPrime, responsesPrime, updatedContextIdCounter: contextIdCounter }
 }
 
 // instance template loadTemplate
@@ -429,11 +460,6 @@ const loadInstance = async (config, instance) => {
   const transitoryMode = global.transitoryMode
   global.transitoryMode = false
 
-  /*
-  if (config.name == 'people' && instance.name == 'people') {
-    debugger
-  }
-  */
   const rl = instance.resultss.length
   if (rl > 0) {
     config.addAssociations(instance.resultss[instance.resultss.length - 1].rtf_associations || [])
@@ -479,6 +505,9 @@ const loadInstance = async (config, instance) => {
         args.isModule = true
         args.isProcess = false
       }
+      if (instance.name == config.testConfig.testModuleName) {
+        args.isTesting = true
+      }
       await results.apply(args)
     } else if (results.isFragment) {
     } else {
@@ -490,6 +519,9 @@ const loadInstance = async (config, instance) => {
       args.instance = ''
       args.isProcess = !config.isModule
       args.isModule = !!config.isModule
+      if (instance.name == config.testConfig.testModuleName) {
+        args.isTesting = true
+      }
       await processContextsB(args)
       if (results.skipSemantics) {
         config.config.skipSemantics = null
@@ -505,6 +537,7 @@ module.exports = {
   // listable,
   setupArgs,
   processContext,
+  run,
   getObjects,
   gs,
   processContextsB,

package/src/fragments.js

@@ -0,0 +1,83 @@
+const _ = require('lodash')
+const helpers = require('./helpers')
+
+function fragmentInstantiator (args, contexts) {
+  return new Object({ 
+    contexts: () => {
+      return _.cloneDeep(contexts)
+    },
+    instantiate: async (mappings) => {
+      const instantiated = _.cloneDeep(contexts)
+      const todo = [{ context: instantiated, path: [] }]
+      args = { ...args }
+      while (todo.length > 0) {
+        const { context, path } = todo.pop()
+        args.context = context
+        args.path = path
+        for (const mapping of mappings) {
+          if (await mapping.match(args)) {
+            await mapping.apply(args)
+          }
+        }
+        for (const key of Object.keys(context)) {
+          // if (['number', 'string', 'boolean'].includes(typeof (context[key]))) {
+          if (!helpers.isCompound(context[key])) {
+            continue
+          }
+          if (context[key].instantiated) {
+            continue
+          }
+          todo.push({ context: context[key], path: [...path, key] })
+        }
+      }
+      if (contexts.length == 1 && instantiated.length == 1) {
+        return instantiated[0]
+      } else {
+        return instantiated
+      }
+    }
+  })
+}
+
+async function fragmentMapperInstantiator(values, modelFrom, modelTo) {
+  const paths = {}
+  for (const value of values) {
+    paths[value] = { value }
+  }
+
+  {
+    const fi = fragmentInstantiator({paths}, modelFrom)
+    await fi.instantiate([
+      {
+        match: ({context, path}) => values.includes(context.value),
+        apply: ({context, path}) => paths[context.value].from = path
+      },
+    ])
+  }
+
+  {
+    const fi = fragmentInstantiator({paths}, modelTo)
+    await fi.instantiate([
+      {
+        match: ({context, path}) => values.includes(context.value),
+        apply: ({context, path}) => paths[context.value].to = path
+      },
+    ])
+  }
+  return {
+    instantiate: (actualFrom) => {
+      const actualTo = structuredClone(modelTo)
+      for (const value in paths) {
+        const { from, to } = paths[value]
+        const actualValue = helpers.getByPath(actualFrom, from, null)
+        helpers.setByPath(actualTo, to, actualValue)
+      }
+      return actualTo
+    }
+  }
+}
+
+module.exports = {
+  fragmentInstantiator,
+  fragmentMapperInstantiator,
+}

package/src/generators.js

@@ -26,11 +26,13 @@ class Generator {
     }
   }
 
+  /*
   getAPIs (config) {
     if (config && config._api && config._api.multiApi) {
       return config._api.apis
     }
   }
+  */
 
   toLabel () {
     const where = this.where ? `where: "${this.where}"` : ''
@@ -59,7 +61,7 @@ class Generator {
       context,
       callId,
       api: this.getAPI(config),
-      apis: this.getAPIs(config)
+      apis: config.getAPIs(),
     }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
     // return this.match(args)
@@ -78,11 +80,11 @@ class Generator {
     if (!log) {
       throw new Error('generators.apply argument log is required')
     }
-    if (baseArgs.call && config && baseArgs.calls.stack.length > config.maxDepth) {
-      throw new Error(`Max depth of ${config.maxDepth} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
+    if (baseArgs.call && config && baseArgs.calls.stack.length > config.getMaxDepth()) {
+      throw new Error(`Max depth of ${config.getMaxDepth()} for calls has been exceeded. maxDepth can be set on the config object. To see the calls run with the --dl or set the debugLoops property on the config`)
     }
 
-    if (config && config.debugLoops) {
+    if (config && config.getDebugLoops()) {
       console.log('apply', this.toLabel())
     }
     // this.getAPI(config)
@@ -113,7 +115,7 @@ class Generator {
       config,
       response,
       api: this.getAPI(config),
-      apis: this.getAPIs(config)
+      apis: config.getAPIs()
     }
     const args = Object.assign({}, baseArgs, moreArgs, (baseArgs.getUUIDScoped || (() => { return {} }))(this.uuid))
     if (this.property === 'generatorp') {
@@ -182,10 +184,10 @@ class Generators {
       const generator = this.generators[igenerator]
       if (await generator.matches(args, objects, context, hierarchy, config, options)) {
         const log = (message) => { this.logs.push(message) }
-        // this.logs.push(`Generators: applied ${generator.toString()}\n to\n ${JSON.stringify(context)}`)
+        // this.logs.push(`Generators: applied ${generator.toString()}\n to\n ${stringify(context)}`)
         let errorMessage = 'The apply function did not return a value'
         try {
-          generated = await generator.apply(args, objects, context, hierarchy, config, response, log)
+          generated = await generator.apply(args, objects, context, hierarchy, config, response, log, options)
         } catch (e) {
           // the next if handle this
           generated = null
@@ -202,7 +204,7 @@ class Generators {
           }
         }
         if (!generated && generated !== '') {
-          const widths = [10, 10, 90]
+          const widths = Lines.addRemainder([10, 10])
           const lines = new Lines(widths)
           lines.setElement(0, 0, 'Generator')
           const source = `${generator.km}/#${generator.index}`
@@ -212,7 +214,7 @@ class Generators {
           lines.newRow()
           lines.setElement(0, 1, 'TO')
           lines.setElement(0, 2, `context_id: ${context.context_id}`)
-          lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 25 }), null, 2))
+          lines.setElement(1, 2, JSON.stringify(helpers.sortJson(context, { depth: 10 }), null, 2))
           lines.newRow()
           lines.setElement(0, 1, 'STACK')
           lines.setElement(0, 2, stack)
@@ -229,8 +231,8 @@ class Generators {
           args.calls.pop()
           throw { error: [message], logs: this.logs }
         }
-        if (((config || {}).config || {}).debug) {
-          const widths = [10, 10, 90]
+        if (config.getDebug()) {
+          const widths = Lines.addRemainder([10, 10])
           const lines = new Lines(widths)
           lines.setElement(0, 0, 'Generator')
           if (generator.index > -1 && generator.km) {
@@ -262,8 +264,8 @@ class Generators {
       }
     }
     args.calls.pop()
-    if (!applied && ((config || {}).config || {}).debug) {
-      const widths = [10, 10, 90]
+    if (!applied && config.getDebug()) {
+      const widths = Lines.addRemainder([10, 10])
       const lines = new Lines(widths)
       lines.setElement(0, 0, 'Generator')
       lines.setElement(0, 2, 'No generator applied')
@@ -275,7 +277,11 @@ class Generators {
       lines.setElement(0, 2, JSON.stringify(context, null, 2))
       this.logs.push(lines.toString())
     }
-    return ((config || {}).parenthesized ? '(' + generated + ')' : generated)
+    let parenthesized = false
+    if (config && config.getParenthesized()) {
+      parenthesized = true
+    }
+    return parenthesized ? '(' + generated + ')' : generated
   }
 }
 

package/src/helpers.js

@@ -292,8 +292,53 @@ const hashCode = (str) => {
   return hash
 }
 
-const sortJson = (json) => {
-  return json
+/**
+ * Recursively sorts object keys alphabetically.
+ * Fully handles arrays (including objects inside arrays) and preserves Date/other non-plain objects.
+ *
+ * @param {any} input - The value to sort (object, array, primitive, etc.)
+ * @param {Object} [options]
+ *   - ignoreCase: boolean (default false) – case-insensitive sort
+ *   - reverse: boolean (default false) – reverse alphabetical order
+ * @returns {any} New sorted value
+ */
+function sortJson(input, options = {}) {
+  const { ignoreCase = false, reverse = false } = options;
+
+  // Helper: is this a plain object {} (not Array, Date, Map, null, etc.)
+  function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && value.constructor === Object;
+  }
+
+  // Handle arrays: map over elements and recurse
+  if (Array.isArray(input)) {
+    return input.map(item => sortJson(item, options));
+  }
+
+  // If not a plain object, return unchanged (preserves Date, Map, Set, primitives, etc.)
+  if (!isPlainObject(input)) {
+    return input;
+  }
+
+  // Sorter for keys
+  const sorter = (a, b) => {
+    const A = ignoreCase ? a.toLowerCase() : a;
+    const B = ignoreCase ? b.toLowerCase() : b;
+    return reverse ? B.localeCompare(A) : A.localeCompare(B);
+  };
+
+  // Build new sorted object
+  const sorted = {};
+
+  Object.keys(input)
+    .sort(sorter)
+    .forEach(key => {
+      const value = input[key];
+      // Always recurse: handles nested objects and arrays properly
+      sorted[key] = sortJson(value, options);
+    });
+
+  return sorted;
 }
 
 const validProps = (valids, object, type) => {
@@ -436,6 +481,63 @@ const stableId = (tag) => {
   return id
 }
 
+function getByPath(obj, path, defaultValue) {
+  let current = obj;
+  for (const key of path) {
+    if (current === null || current === undefined) return defaultValue;
+    if (typeof current !== 'object') return defaultValue;
+    current = current[key];
+  }
+  return current === undefined ? defaultValue : current;
+}
+
+/**
+ * Set a value in an object by path array.
+ * Automatically creates missing objects {} or arrays [] as needed.
+ *
+ * @param {Object} obj - The root object to modify
+ * @param {Array<string|number>} path - Array of keys/indices
+ * @param {*} value - Value to set
+ * @returns {*} The set value (for chaining)
+ */
+function setByPath(obj, path, value) {
+  if (!Array.isArray(path) || path.length === 0) {
+    throw new Error('Path must be a non-empty array');
+  }
+
+  let current = obj;
+
+  for (let i = 0; i < path.length; i++) {
+    const key = path[i];
+    const isLast = i === path.length - 1;
+
+    if (isLast) {
+      // Final step — just assign
+      current[key] = value;
+    } else {
+      // Not last — ensure next level exists
+      const nextKey = path[i + 1];
+
+      if (current[key] == null) {
+        // Auto-create: array if next key is number, otherwise object
+        current[key] = typeof nextKey === 'number' || String(nextKey >>> 0) === nextKey
+          ? []
+          : {};
+      } else if (Array.isArray(current[key]) && typeof nextKey !== 'number') {
+        // Safety: if current is array but next key isn't a valid index → convert to object
+        current[key] = { ...current[key] };
+      } else if (!Array.isArray(current[key]) && typeof nextKey === 'number') {
+        // If next expects array but current is object → convert
+        current[key] = Object.values(current[key]);
+      }
+
+      current = current[key];
+    }
+  }
+
+  return value;
+}
+
 module.exports = {
   stableId,
   ecatch,
@@ -462,5 +564,7 @@ module.exports = {
   where,
   w,
   suggestAssociationsFix,
-  suggestAssociationsFixFromSummaries
+  suggestAssociationsFixFromSummaries,
+  getByPath,
+  setByPath,
 }

package/src/project2.js

@@ -1,7 +1,32 @@
-function project(source, filters) {
+function areFirstNEqual(arr1, arr2, n) {
+  if (n <= 0) return true;
+  if (arr1.length < n || arr2.length < n) return false;
+
+  for (let i = 0; i < n; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function project(source, filters, path=[]) {
   if (['string', 'number'].includes(typeof source)) {
     return source
   }
+  if (Array.isArray(source)) {
+    const result = []
+    for (const value of source) {
+      result.push(project(value, filters, [...path, '*']))
+    }
+    return result
+  }
+  function isPlainObject(obj) {
+    return Object.prototype.toString.call(obj) === '[object Object]';
+  }
+  if (!isPlainObject(source) && !Array.isArray(source)) {
+    return source
+  }
 
   if (Object.keys(source).length === 0 && filters.length === 0) {
     return {};
@@ -11,7 +36,7 @@ function project(source, filters) {
   const filter = filters.find(f => f.match({ context: source }));
   if (!filter) {
     if (Array.isArray(source)) {
-      return source.map((element) => project(element, filters))
+      return source.map((element) => project(element, filters, [...path, '*']))
     }
     return {};
   }
@@ -22,6 +47,7 @@ function project(source, filters) {
   // update 
   const updatedProperties = []
   for (const property of properties) {
+    // property that contains a list of properties to be checked
     if (property.properties) {
       for (const moreProperty of source[property.properties] || []) {
         updatedProperties.push(moreProperty)
@@ -35,10 +61,34 @@ function project(source, filters) {
   // Build the result object
   const result = {};
   properties.forEach(prop => {
-    if (source.hasOwnProperty(prop)) {
+    if (prop.path && (prop.path.length === path.length + 1) && areFirstNEqual(path, prop.path, path.length) && source.hasOwnProperty(prop.path[path.length])) {
+      const endProp = prop.path[path.length]
+      if (Array.isArray(source[endProp])) {
+        result[endProp] = []
+        for (const key in source[endProp]) {
+          result[endProp].push(project(source[endProp][key], filters, [...path, endProp, key]))
+        }
+      } else {
+        result[endProp] = {}
+        for (const key in source[endProp]) {
+          result[endProp][key] = project(source[endProp][key], filters, [...path, endProp, key])
+        }
+      }
+    } else if (source.hasOwnProperty(prop)) {
       // If the property is an object and not null, recursively project it
       if (typeof source[prop] === 'object' && source[prop] !== null) {
-        result[prop] = project(source[prop], filters);
+        result[prop] = project(source[prop], filters, [...path, prop]);
+      } else {
+        // Copy primitive or null properties directly
+        result[prop] = source[prop];
+      }
+    } else if (prop.property && source.hasOwnProperty(prop.property)) {
+      // If the property is an object and not null, recursively project it
+      if (typeof source[prop.property] === 'object' && source[prop.property] !== null) {
+        result[prop.property] = {}
+        for (const key of prop.check) {
+          result[prop.property][key] = project(source[prop.property][key], filters, [...path, prop.property, key]);
+        }
       } else {
         // Copy primitive or null properties directly
         result[prop] = source[prop];