@polycode-projects/the-mechanical-code-talker 1.10.12 → 1.10.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.10.12",
+  "version": "1.10.14",
   "private": false,
   "type": "module",
   "description": "The Mechanical Code Talker (tmct) — a tolerant, offline, $0 chat surface that guides you toward precision queries about a software repository. ELIZA/PARRY-style but domain-obsessed with code. No model calls; no codebase index of its own.",

package/src/chat.mjs

@@ -1533,6 +1533,12 @@ const WALL_MISS_ANYWHERE_RE = /couldn't parse this as a graph question\. Try:/;
 // instead of the grammar wall or a silent data loss.
 const TEACH_RE = /^(?:please\s+)?(?:i\s+(?:want|wanted)\s+you\s+to\s+|i(?:'d|\s+would)\s+like\s+you\s+to\s+)?(?:remember|note|keep in mind|jot down|for the record|fyi|learn)\b(?:\s+(?:this|that|also))?[:,]?\s*(?:that\s+)?(.+?)[.?!]*$/i;
 const BARE_DECLARATIVE_RE = /^(?:every |each |all |a |an )?[\w-]+(?: [\w-]+)? (?:is|are) (?:a |an )?[\w-]+$/i;
+/** "X is <comparative> than Y" — the comparative teach/ask surface. The
+ *  comparative slot is closed by SHAPE (-er word, better/worse, or a
+ *  more/less + adjective pair), never a hand-list of adjectives. */
+const COMPARATIVE_SRC = "(?:[a-z]+er|better|worse|(?:more|less)\\s+[a-z]+)";
+const COMPARATIVE_TEACH_RE = new RegExp(`^(?:the\\s+|an?\\s+)?([\\w'-]+(?:\\s+[\\w'-]+)?)\\s+(?:is|are)\\s+(${COMPARATIVE_SRC})\\s+than\\s+(.+)$`, "i");
+const COMPARATIVE_ASK_RE = new RegExp(`^(?:is|are)\\s+(.+?)\\s+(${COMPARATIVE_SRC})\\s+than\\s+(.+?)[?.!\\s]*$`, "i");
 /** Interrogative / auxiliary leads that make an "X is a Y"-shaped line a QUESTION
  *  ("what is a cache", "is a module a component"), never a teach declarative. */
 const QUESTION_LEAD_RE = /^(?:what|who|which|where|when|why|how|is|are|do|does|did|can|could|should|would|will|has|have)\b/i;
@@ -2354,10 +2360,10 @@ async function generalVerbTeach(payload) {
   if (verb === "cannot") return null;
   if (GENERAL_VERB_DETERMINER_RE.test(subjectRaw)) return null; // not a bare-name subject
   const subject = subjectRaw.trim();
-  const object = objectRaw.replace(/^an?\s+/i, "").trim();
+  const folded = foldPrepositionIntoPredicate(await generalVerbPredicate(verb), objectRaw);
+  const object = folded.object.replace(/^an?\s+/i, "").trim();
   if (!subject || !object) return null; // no well-formed triple — honest decline (point 6)
-  const predicate = await generalVerbPredicate(verb);
-  return { subject, predicate, object };
+  return { subject, predicate: folded.predicate, object };
 }
 
 /** Is `word` a genuine NOUN/PROPN, per wink-nlp's optional POS tagger
@@ -2391,7 +2397,7 @@ async function subjectIsNounOrPropn(word) {
 // query is never shadowed. Reuses generalVerbTeach's own exclude guards and
 // generalVerbPredicate, plus the SAME adverb-skip, so the two never disagree. ----
 const GENERAL_VERB_YESNO_RE = new RegExp(`^(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)\\s+(.+?)[?.!\\s]*$`, "i");
-const GENERAL_VERB_OPEN_RE = new RegExp(`^what\\s+(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+)[?.!\\s]*$`, "i");
+const GENERAL_VERB_OPEN_RE = new RegExp(`^what\\s+(?:does|did)\\s+([\\w'-]+)\\s+${TEACH_ADVERB_SKIP_SRC}([a-z]+(?:\\s+(?:on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside))?)[?.!\\s]*$`, "i");
 /** GENERAL_VERB_EXCLUDE_RE was written for generalVerbTeach's fully-conjugated
  *  declarative verb ("X OWNS Y", "X MAINTAINS Y") — but "does/did X <verb> Y"
  *  captures the BARE INFINITIVE after do-support ("does X OWN Y", never "does X
@@ -2403,6 +2409,23 @@ const GENERAL_VERB_OPEN_RE = new RegExp(`^what\\s+(?:does|did)\\s+([\\w'-]+)\\s+
  *  The query-side guard needs the bare-infinitive counterpart too. */
 const GENERAL_VERB_QUERY_EXCLUDE_RE = /^(?:be|own|maintain)$/i;
 
+/** Closed prepositions the general-verb teach/query lanes FOLD INTO the
+ *  minted predicate: "disk-1 rests on peg-a" stores mgx:rest-on with object
+ *  "peg-a", never mgx:rest with the meaning-bearing "on" buried inside the
+ *  object where no read-back can match it. */
+const GENERAL_VERB_PREP_RE = /^(on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside)\s+(.+)$/i;
+/** Fold a leading preposition from `objectRaw` into a minted mgx:<lemma>
+ *  predicate. Curated predicates (mgx:hasA, mgx:capableOf — anything not the
+ *  plain lowercase mint shape) are never suffixed. Returns {predicate,
+ *  object} either way. */
+function foldPrepositionIntoPredicate(predicate, objectRaw) {
+  const prepM = String(objectRaw || "").match(GENERAL_VERB_PREP_RE);
+  if (prepM && /^mgx:[a-z]+$/.test(predicate)) {
+    return { predicate: `${predicate}-${prepM[1].toLowerCase()}`, object: prepM[2].trim() };
+  }
+  return { predicate, object: String(objectRaw || "").trim() };
+}
+
 /** Sentence forms to try asserting for a teach payload: the payload as-is, and
  *  (if it carries no determiner) its "every …" universal — the ACE-OWL shape the
  *  grammar actually lands. */
@@ -2862,7 +2885,7 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
 
   let payload = null;
   if (wrapped && /\b(?:is|are)\b/i.test(wrapped)) payload = wrapped;
-  else if (BARE_DECLARATIVE_RE.test(raw) && !QUESTION_LEAD_RE.test(raw) && !(await hasMidSentenceInterrogative(raw))) payload = raw;
+  else if ((BARE_DECLARATIVE_RE.test(raw) || COMPARATIVE_TEACH_RE.test(raw)) && !QUESTION_LEAD_RE.test(raw) && !(await hasMidSentenceInterrogative(raw))) payload = raw;
   if (!payload) {
     // "remember margo eats ribs", re-escaping here through a combination
     // that mechanism's own deliberate subject-shape restriction doesn't
@@ -2880,6 +2903,19 @@ async function teachLane(query, { memoryDir, sessionId = "", lexicon = null, cac
   // Try to store it (a live session provides the write target). assertTurn returns
   // the "noted — remembered …" confirmation or null (grammar miss / unknown words).
   if (memoryDir) {
+    // COMPARATIVE frame — "disk-1 is smaller than disk-2" → mgx:smaller-than.
+    // Checked ahead of the ACE candidates: the copula plus "than" is not in
+    // the ACE fragment at all, and letting it fall through produced the
+    // both-sides-ungrounded decline (honest but unactionable — no phrasing
+    // it could suggest would have stored a comparison).
+    const comp = String(payload).trim().match(COMPARATIVE_TEACH_RE);
+    if (comp) {
+      const compPredicate = `mgx:${comp[2].toLowerCase().replace(/\s+/g, "-")}-than`;
+      const stored = await teachFact(memoryDir, sessionId, {
+        subject: comp[1].trim(), predicate: compPredicate, object: comp[3].trim(),
+      });
+      if (stored) return stored;
+    }
     for (const cand of assertCandidates(payload)) {
       // assertTurn ITSELF records the "every" quantifier (point 3) on a plain
       // universal success, so every caller (this loop AND the top-level
@@ -3729,8 +3765,15 @@ function thirdPersonSingularSurface(lemma) {
 }
 function predicatePhrase(predicate) {
   if (FACT_PREDICATE_PHRASES[predicate]) return FACT_PREDICATE_PHRASES[predicate];
-  const m = /^mgx:([a-z]+)$/i.exec(String(predicate || ""));
-  return m ? thirdPersonSingularSurface(m[1]) : predicate;
+  const p = String(predicate || "");
+  // a comparative renders as its copula surface: mgx:smaller-than ->
+  // "is smaller than" (never a 3sg fold — "smallers" isn't a word)
+  const comp = /^mgx:([a-z]+(?:-[a-z]+)*)-than$/i.exec(p);
+  if (comp) return `is ${comp[1].replace(/-/g, " ")} than`;
+  const m = /^mgx:([a-z]+)(?:-([a-z]+))?$/i.exec(p);
+  if (!m) return predicate;
+  // a folded preposition renders back naturally: mgx:rest-on -> "rests on"
+  return `${thirdPersonSingularSurface(m[1])}${m[2] ? ` ${m[2]}` : ""}`;
 }
 const factPhrase = (f) => `${f.subject} ${predicatePhrase(f.predicate)} ${f.object}`;
 
@@ -4366,6 +4409,30 @@ export async function factAnswer(memoryDir, query, envelope, miss, biasByBundle
   }
   if (!miss) return null;
 
+  // (b0-comp) "is disk-1 smaller than disk-2" — yes iff the exact taught
+  // comparative fact exists; otherwise an honest, specific miss whose teach
+  // hint is the EXACT phrasing the comparative teach frame accepts. Never an
+  // inverted guess: "disk-1 is smaller than disk-2" proves nothing here
+  // about "is disk-2 smaller than disk-1" (the frame stores no
+  // antisymmetry), so the reverse question stays a can't-confirm.
+  const compAsk = q.match(COMPARATIVE_ASK_RE);
+  if (compAsk) {
+    const compWord = compAsk[2].toLowerCase().replace(/\s+/g, "-");
+    const compPredicate = `mgx:${compWord}-than`;
+    const facts = await memoryFacts(memoryDir);
+    const subj = factTermVariants(normFactTerm, compAsk[1].replace(/^(?:an?|the)\s+/i, "").trim());
+    const obj = factTermVariants(normFactTerm, compAsk[3].replace(/^(?:an?|the)\s+/i, "").trim());
+    const hit = facts.find((f) => f.predicate === compPredicate && subj.has(f.subject) && obj.has(f.object));
+    if (hit) return { text: `yes — ${renderFactLine(hit)}`, replace: true };
+    const known = facts.filter((f) => f.predicate === compPredicate && (subj.has(f.subject) || subj.has(f.object)));
+    const shown = known.length ? ` I do know: ${known.slice(0, 3).map(renderFactLine).join("; ")}.` : "";
+    return {
+      text: `I can't confirm that — nothing I remember compares them that way.${shown} If it's true, teach me: "${compAsk[1].trim()} is ${compAsk[2].toLowerCase()} than ${compAsk[3].trim()}".`,
+      replace: true,
+      miss: true,
+    };
+  }
+
   // (b0) Derived forward yes/no readers — FORWARD_YESNO_MARKERS, one per
   // renderable relation. Runs BEFORE the isa lane because ISA_ASK_RE's lazy
   // subject otherwise swallows these shapes whole ("is a wheel part of a
@@ -6054,9 +6121,13 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
     const verb = verbRaw.toLowerCase();
     if (!GENERAL_VERB_EXCLUDE_RE.test(verb) && !GENERAL_VERB_QUERY_EXCLUDE_RE.test(verb)) {
       const subject = subjectRaw.trim();
-      const object = objectRaw.replace(/^an?\s+/i, "").trim();
+      // the SAME preposition fold the teach side applies, so "does disk-1
+      // rest on peg-a" looks up mgx:rest-on/"peg-a", matching what
+      // generalVerbTeach actually stored
+      const folded = foldPrepositionIntoPredicate(await generalVerbPredicate(verb), objectRaw);
+      const object = folded.object.replace(/^an?\s+/i, "").trim();
       if (subject && object) {
-        const predicate = await generalVerbPredicate(verb);
+        const predicate = folded.predicate;
         const subjVariants = factTermVariants(normFactTerm, subject);
         const objVariants = factTermVariants(normFactTerm, object);
         const hit = rows
@@ -6070,11 +6141,15 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
   const genOpen = q.match(GENERAL_VERB_OPEN_RE);
   if (genOpen && !GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(q)) {
     const [, subjectRaw, verbRaw] = genOpen;
-    const verb = verbRaw.toLowerCase();
+    // "what does disk-1 rest on" captures "rest on" — split the folded
+    // preposition back off and suffix the minted predicate, mirroring the
+    // teach side's foldPrepositionIntoPredicate
+    const [verb, verbPrep] = verbRaw.toLowerCase().split(/\s+/);
     if (!GENERAL_VERB_EXCLUDE_RE.test(verb) && !GENERAL_VERB_QUERY_EXCLUDE_RE.test(verb)) {
       const subject = subjectRaw.trim();
       if (subject) {
-        const predicate = await generalVerbPredicate(verb);
+        let predicate = await generalVerbPredicate(verb);
+        if (verbPrep && /^mgx:[a-z]+$/.test(predicate)) predicate = `${predicate}-${verbPrep}`;
         const subjVariants = factTermVariants(normFactTerm, subject);
         const hits = rankByBiasThenTrust(rows.filter((f) => f.predicate === predicate && subjVariants.has(f.subject)), biasByBundle);
         if (hits.length) return { ...renderMany(hits), generalVerbQuery: true };
@@ -6082,6 +6157,26 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
     }
   }
 
+  // "what rests on peg-a" / "who sits on the chair" — the reverse-by-OBJECT
+  // mirror of the two general-verb readers above, for taught prepositional
+  // facts. Only ever diverts on a REAL stored hit (the predicate is minted
+  // from the surface verb + folded preposition, so a code question like
+  // "what calls chat.mjs" — no such taught fact — falls through untouched;
+  // this also outranks the spell-corrector's "rests"→"tests" misread, which
+  // otherwise walls this exact phrasing).
+  const genReverse = q.match(/^(?:what|who)\s+([a-z]+)\s+(on|in|at|onto|upon|under|over|beside|near|behind|above|below|inside|outside)\s+(.+?)[?.!\s]*$/i);
+  if (genReverse && !GENERAL_VERB_ANYWHERE_EXCLUDE_RE.test(q)) {
+    const [, verbSurface, prep, objectRaw] = genReverse;
+    const verb = verbSurface.toLowerCase();
+    if (!GENERAL_VERB_EXCLUDE_RE.test(verb) && !GENERAL_VERB_QUERY_EXCLUDE_RE.test(verb) && !GENERAL_VERB_NOT_A_VERB_RE.test(verb)) {
+      let predicate = await generalVerbPredicate(verb);
+      if (/^mgx:[a-z]+$/.test(predicate)) predicate = `${predicate}-${prep.toLowerCase()}`;
+      const objVariants = factTermVariants(normFactTerm, objectRaw.replace(/^(?:an?|the)\s+/i, "").trim());
+      const hits = rankByBiasThenTrust(rows.filter((f) => f.predicate === predicate && objVariants.has(f.object)), biasByBundle);
+      if (hits.length) return { ...renderMany(hits), generalVerbQuery: true };
+    }
+  }
+
   // (b) RECALL — "what did i tell you about X": every remembered fact mentioning X.
   const told = q.match(TOLD_ABOUT_RE);
   if (told) {

package/src/finish.mjs

@@ -230,14 +230,18 @@ function ruleArticle(segments, rule) {
   for (let i = 0; i < out.length; i += 1) {
     const seg = out[i];
     if (seg.type !== "prose") continue;
-    // (a) in-span "a artifact" / "an module" (case-insensitive; case preserved)
-    seg.text = seg.text.replace(/\b(a|an)(\s+)([A-Za-z][\w-]*)/gi, (m, art, sp, word) => {
+    // (a) in-span "a artifact" / "an module" (case-insensitive; case preserved).
+    // A hyphen before the candidate article means it's the tail of a
+    // hyphenated NAME ("peg-a", "option-a"), not an article — rewriting it
+    // corrupts user-quoted data ("peg-a\nUtterance" read as "a Utterance").
+    seg.text = seg.text.replace(/(^|[^\w-])(a|an)(\s+)([A-Za-z][\w-]*)/gi, (m, pre, art, sp, word) => {
       const vowel = beginsWithVowelSound(word, rule);
       if (vowel === null) return m;
-      return matchCase(art, vowel ? "an" : "a") + sp + word;
+      return pre + matchCase(art, vowel ? "an" : "a") + sp + word;
     });
     // (b) boundary: prose ends "…a " / "…an ", next span carries the word
-    const bm = seg.text.match(/(^|[^\w])(a|an)(\s+)$/i);
+    // (same hyphenated-name guard as (a))
+    const bm = seg.text.match(/(^|[^\w-])(a|an)(\s+)$/i);
     if (bm) {
       const next = out[i + 1];
       const word = next && typeof next.text === "string" ? leadingWord(next.text) : "";