tpmkms_4wp 9.5.1 → 9.6.0

package/common/english_helpers.js

@@ -0,0 +1,336 @@
+function conjugateVerb(infinitive) {
+  if (typeof infinitive !== 'string' || infinitive.trim() === '') {
+    throw new Error('Input must be a non-empty string');
+  }
+
+  const baseVerb = infinitive.replace(/^to\s+/i, '').trim().toLowerCase();
+  if (!baseVerb) throw new Error('Input must be a non-empty string');
+
+  const conjugations = [];
+
+  // Add infinitive (bare form, no "to")
+  conjugations.push({
+    form: 'infinitive',
+    word: baseVerb,
+    tense: 'infinitive',
+    aspect: null,
+    number: 'none',
+    person: 'none'
+  });
+
+  // === Irregular verb database ===
+  const irregulars = {
+    be: {
+      present: {
+        singular: { first: 'am', second: 'are', third: 'is' },
+        plural:   { first: 'are', second: 'are', third: 'are' }
+      },
+      past: {
+        singular: { first: 'was', second: 'were', third: 'was' },
+        plural:   { first: 'were', second: 'were', third: 'were' }
+      },
+      pastParticiple: 'been',
+      presentParticiple: 'being'
+    },
+    have: {
+      present: {
+        singular: { first: 'have', second: 'have', third: 'has' },
+        plural:   { first: 'have', second: 'have', third: 'have' }
+      },
+      past: { singular: { first: 'had', second: 'had', third: 'had' }, plural: { first: 'had', second: 'had', third: 'had' } },
+      pastParticiple: 'had',
+      presentParticiple: 'having'
+    },
+    do: {
+      present: {
+        singular: { first: 'do', second: 'do', third: 'does' },
+        plural:   { first: 'do', second: 'do', third: 'do' }
+      },
+      past: { singular: { first: 'did', second: 'did', third: 'did' }, plural: { first: 'did', second: 'did', third: 'did' } },
+      pastParticiple: 'done',
+      presentParticiple: 'doing'
+    },
+    go: {
+      present: {
+        singular: { first: 'go', second: 'go', third: 'goes' },
+        plural:   { first: 'go', second: 'go', third: 'go' }
+      },
+      past: { singular: { first: 'went', second: 'went', third: 'went' }, plural: { first: 'went', second: 'went', third: 'went' } },
+      pastParticiple: 'gone',
+      presentParticiple: 'going'
+    },
+    say: {
+      present: {
+        singular: { first: 'say', second: 'say', third: 'says' },
+        plural:   { first: 'say', second: 'say', third: 'say' }
+      },
+      past: { 
+        singular: { first: 'said', second: 'said', third: 'said' }, 
+        plural: { first: 'said', second: 'said', third: 'said' } 
+      },
+      pastParticiple: 'said',
+      presentParticiple: 'saying'
+    },
+    make: {
+      present: {
+        singular: { first: 'make', second: 'make', third: 'makes' },
+        plural: { first: 'make', second: 'make', third: 'make' }
+      },
+      past: {
+        singular: { first: 'made', second: 'made', third: 'made' },
+        plural: { first: 'made', second: 'made', third: 'made' }
+      },
+      pastParticiple: 'made',
+      presentParticiple: 'making'
+    },
+    // Add more irregulars as needed...
+  };
+
+  const irreg = irregulars[baseVerb];
+
+  const numbers = ['singular', 'plural'];
+  const persons = ['first', 'second', 'third'];
+
+  // === Present tense ===
+  if (irreg) {
+    for (const num of numbers) {
+      for (const pers of persons) {
+        conjugations.push({
+          form: 'finite',
+          word: irreg.present[num][pers],
+          tense: 'present',
+          aspect: 'simple',
+          number: num,
+          person: pers
+        });
+      }
+    }
+  } else {
+    // Regular present tense
+    for (const num of numbers) {
+      for (const pers of persons) {
+        const word = conjugateRegularPresent(baseVerb, num, pers);
+        conjugations.push({
+          form: 'finite',
+          word,
+          tense: 'present',
+          aspect: 'simple',
+          number: num,
+          person: pers
+        });
+      }
+    }
+  }
+
+  // === Past tense (simple past) ===
+  let pastForm;
+  if (irreg && irreg.past) {
+    const pastMap = irreg.past;
+    for (const num of numbers) {
+      for (const pers of persons) {
+        conjugations.push({
+          form: 'finite',
+          word: pastMap[num][pers],
+          tense: 'past',
+          aspect: 'simple',
+          number: num,
+          person: pers
+        });
+      }
+    }
+    pastForm = pastMap.singular.first; // representative
+  } else {
+    pastForm = conjugateRegularPast(baseVerb);
+    for (const num of numbers) {
+      for (const pers of persons) {
+        conjugations.push({
+          form: 'finite',
+          word: pastForm,
+          tense: 'past',
+          aspect: 'simple',
+          number: num,
+          person: pers
+        });
+      }
+    }
+  }
+
+  // === Past Participle ===
+  const pastParticiple = irreg?.pastParticiple ?? conjugateRegularPast(baseVerb); // same as past for regular verbs
+  conjugations.push({
+    form: 'pastParticiple',
+    word: pastParticiple,
+    tense: 'perfect',
+    aspect: 'perfect',
+    number: 'none',
+    person: 'none'
+  });
+
+  // Optional: Present Participle (-ing form)
+  const presentParticiple = irreg?.presentParticiple ?? conjugatePresentParticiple(baseVerb);
+  conjugations.push({
+    form: 'presentParticiple',
+    word: presentParticiple,
+    tense: 'progressive',
+    aspect: 'continuous',
+    number: 'none',
+    person: 'none'
+  });
+
+  return conjugations;
+}
+
+// Helper: regular present 3rd person singular
+function conjugateRegularPresent(verb, number, person) {
+  if (number === 'singular' && person === 'third') {
+    if (/[sxz]$/.test(verb) || /[cs]h$/.test(verb) || /o$/.test(verb)) {
+      return verb + 'es';
+    }
+    if (/[^aeiou]y$/.test(verb)) {
+      return verb.slice(0, -1) + 'ies';
+    }
+    return verb + 's';
+  }
+ 1
+  return verb;
+}
+
+// Helper: regular past & past participle (same for regular verbs)
+function conjugateRegularPast(verb) {
+  if (verb.endsWith('e')) {
+    return verb + 'd';
+  }
+  if (/[aeiou][^aeiouyw]$/.test(verb.slice(-2)) && /[bcdfghjklmnpqrstvwxz]$/.test(verb)) {
+    // doubled consonant: stop → stopped
+    return verb + verb.slice(-1) + 'ed';
+  }
+  if (/[^aeiou]y$/.test(verb)) {
+    return verb.slice(0, -1) + 'ied';
+  }
+  return verb + 'ed';
+}
+
+// Helper: present participle (-ing)
+function conjugatePresentParticiple(verb) {
+  if (verb.endsWith('e') && !verb.endsWith('ee') && !verb.endsWith('ie') && !verb.endsWith('ye')) {
+    return verb.slice(0, -1) + 'ing';
+  }
+  if (/[aeiou][^aeiouyw]$/.test(verb.slice(-2)) && /[bcdfghjklmnpqrstvwxz]$/.test(verb.slice(-1))) {
+    return verb + verb.slice(-1) + 'ing'; // stop → stopping
+  }
+  if (verb.endsWith('ie')) {
+    return verb.slice(0, -2) + 'ying'; // lie → lying
+  }
+  return verb + 'ing';
+}
+
+// === Bonus: Improved getInfinitive with past participle support ===
+function getInfinitive(form) {
+  const word = form.trim().toLowerCase();
+  if (!word) throw new Error('Input must be a non-empty string');
+
+  // ------------------------------------------------------------
+  // 1. Irregular forms (present, past, past participle, -ing)
+  // ------------------------------------------------------------
+  const irregularMap = {
+    am: 'be', is: 'be', are: 'be',
+    was: 'be', were: 'be', been: 'be', being: 'be',
+    have: 'have', has: 'have', had: 'have',
+    do: 'do', does: 'do', did: 'do', done: 'do',
+    go: 'go', goes: 'go', went: 'go', gone: 'go',
+    say: 'say', says: 'say', said: 'say',
+    made: 'make',
+  };
+
+  if (irregularMap[word]) return irregularMap[word];
+
+  // ------------------------------------------------------------
+  // 2. Past tense / Past participle (regular verbs)
+  // ------------------------------------------------------------
+  if (word.endsWith('ed')) {
+    // 2a – cried → cry
+    if (word.endsWith('ied')) {
+      return word.slice(0, -3) + 'y';
+    }
+
+    // 2. liked, moved, danced → like, move, dance
+    //    These are verbs that end in 'e' → add only 'd' → ends with "ed", but third char from end is 'e'
+    if (word.length >= 3 && word[word.length - 3] === 'e') {
+      return word.slice(0, -1);  // remove only the final 'd'
+    }
+
+    // 2c – stopped, rubbed (consonant doubling)
+    let stem = word.slice(0, -2);              // remove "ed"
+    if (
+      stem.length >= 2 &&
+      stem[stem.length - 1] === stem[stem.length - 2] &&   // doubled consonant
+      !/[aeiou]/.test(stem[stem.length - 1])               // not a vowel
+    ) {
+      stem = stem.slice(0, -1);               // remove one of the doubled letters
+    }
+
+    const restoreECases = ['liked'];
+    if (restoreECases.includes(word)) {
+      stem += 'e';
+    }
+    return stem;
+  }
+
+  // ------------------------------------------------------------
+  // 3. Present participle (-ing)
+  // ------------------------------------------------------------
+  if (word.endsWith('ing')) {
+    let stem = word.slice(0, -3);
+
+    // lying → lie
+    if (word.endsWith('ying')) {
+      stem = word.slice(0, -4);
+      return stem + 'ie';
+    }
+
+    // Undo consonant doubling: stopping → stop, running → run
+    if (
+      stem.length >= 2 &&
+      stem[stem.length - 1] === stem[stem.length - 2] &&
+      !/[aeiou]/.test(stem[stem.length - 1])
+    ) {
+      stem = stem.slice(0, -1);
+    }
+
+    // DO NOT blindly add 'e' — this is the source of "walke", "runne", etc.
+    // Only add 'e' in known safe cases — or just don't do it.
+    // Here: we add 'e' only if the word is in a small whitelist of common cases
+    const restoreECases = ['dancing', 'making', 'taking', 'giving', 'living'];
+    if (restoreECases.includes(word)) {
+      stem += 'e';
+    }
+
+    return stem;
+  }
+  // ------------------------------------------------------------
+  // 4. Present 3rd-person singular
+  // ------------------------------------------------------------
+  if (word.endsWith('ies') && word.length > 3) {
+    return word.slice(0, -3) + 'y';           // flies → fly
+  }
+  if (word.endsWith('es') && word.length > 3) {
+    const stem = word.slice(0, -2);
+    if (/[sxz]$/.test(stem) || /[cs]h$/.test(stem) || stem.endsWith('o')) {
+      return stem;                           // watches → watch
+    }
+  }
+  if (word.endsWith('s') && !word.endsWith('ss') && word.length > 2) {
+    return word.slice(0, -1);                // walks → walk
+  }
+
+  // ------------------------------------------------------------
+  // 5. Nothing matched → return as-is
+  // ------------------------------------------------------------
+  return word;
+}
+
+module.exports = { 
+  conjugateVerb,
+  getInfinitive,
+}
+

package/common/errors.js

@@ -6,15 +6,15 @@ const tests = require('./errors.test.json')
 const config = {
   name: 'errors',
   operators: [
-    { pattern: "([drop] ([dropable]))", development: true },
+    { pattern: "([drop] ([dropable]))", scope: "testing" },
   ],
   bridges: [
     { 
       id: "drop", 
       bridge: "{ ...next(operator), arg: after[0] }", 
-      development: true
+      scope: "testing"
     },
-    { id: "dropable", development: true },
+    { id: "dropable", scope: "testing" },
   ],
   semantics: [
     {
@@ -53,13 +53,13 @@ knowledgeModule({
               ...defaultContextCheck(), 
               { 
                 property: 'quantity', 
-                filter: ['marker', 'value'],
+                check: ['marker', 'value'],
               },
               { 
                 property: 'pieces', 
-                filter: [
+                check: [
                   'marker', 'text',
-                  { property: 'count', filter: ['marker', 'value'] },
+                  { property: 'count', check: ['marker', 'value'] },
                 ] 
               }]
           },

package/common/evaluate.js

@@ -8,7 +8,7 @@ const config = {
   name: 'evaluate', 
   operators: [
     "([evaluate] (value))",
-    { pattern: "([value1])", development: true },
+    { pattern: "([value1])", scope: "testing" },
   ],
   bridges: [
     {
@@ -17,7 +17,7 @@ const config = {
       evaluator: ({context}) => {
         context.evalue = 'value1 after evaluation'
       },
-      development: true,
+      scope: "testing",
     },
     {
       where: where(),

package/common/events.js

@@ -24,8 +24,8 @@ const config = {
   operators: [
     "([after] ([event]) ([action]))",
     "(([changeable]) [changes])",
-    { pattern: "([event1])", development: true },
-    { pattern: "([action1])", development: true },
+    { pattern: "([event1])", scope: "testing" },
+    { pattern: "([action1])", scope: "testing" },
   ],
   bridges: [
     { 
@@ -62,12 +62,12 @@ const config = {
         }
       ]
     },
-    { id: "event1", level: 0, bridge: "{ ...next(operator) }", development: true },
-    { id: "action1", level: 0, bridge: "{ ...next(operator) }", development: true },
+    { id: "event1", level: 0, bridge: "{ ...next(operator) }", scope: "testing" },
+    { id: "action1", level: 0, bridge: "{ ...next(operator) }", scope: "testing" },
   ],
   hierarchy: [
-    { child: 'event1', parent: 'event', development: true },
-    { child: 'action1', parent: 'action', development: true },
+    { child: 'event1', parent: 'event', scope: "testing" },
+    { child: 'action1', parent: 'action', scope: "testing" },
     ['changes', 'event'],
   ],
   generators: [
@@ -81,7 +81,7 @@ const config = {
   semantics: [
     {
       notes: 'event1',
-      development: true,
+      scope: "testing",
       where: where(),
       match: ({context}) => context.marker == 'event1' && !context.event,
       apply: ({context, kms, insert}) => {
@@ -90,7 +90,7 @@ const config = {
     },
     {
       notes: 'action1',
-      development: true,
+      scope: "testing",
       where: where(),
       match: ({context, isA}) => context.marker == 'action1',
       apply: ({context, kms}) => {