@polycode-projects/the-mechanical-code-talker 1.10.11 → 1.10.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.10.11",
+  "version": "1.10.13",
   "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

@@ -2354,10 +2354,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 +2391,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 +2403,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. */
@@ -3729,8 +3746,10 @@ 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 m = /^mgx:([a-z]+)(?:-([a-z]+))?$/i.exec(String(predicate || ""));
+  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}`;
 
@@ -5452,6 +5471,31 @@ async function factReadBack(memoryDir, query, envelope, miss, graph = null, focu
       const premises = chain.map(factForStep);
       if (premises.every(Boolean)) return { text: `yes — ${renderIsaChain(premises)}`, replace: true };
     }
+    // MIXED-SOURCE EXTENSION of the chase above. The taught-only filter
+    // exists to stop PURE-ConceptNet coincidence chains, but it also blocked
+    // the everyday case where the operator anchors a term onto a corpus
+    // class ("every poodle is a dog") and asks up through the corpus's own
+    // hierarchy ("is a poodle an animal"). Corpus isa facts already answer
+    // the 1-hop direct question on their own, so letting them JOIN a chain
+    // that contains AT LEAST ONE operator-taught premise adds no fabrication
+    // surface — a chain of ONLY corpus edges still never answers here, and
+    // every premise is cited with its own source, corpus ones included. The
+    // shared taught-only rows above stay untouched: the disjoint and
+    // someValuesFrom chases keep their original, narrower discipline.
+    const mixedSubClassRows = isa.filter((f) => f.predicate === SC_PREDICATE);
+    const mixedTypeRows = isa.filter((f) => f.predicate === RDF_TYPE_PREDICATE);
+    const mixedFactForStep = (step) => (step.predicate === SC_PREDICATE ? mixedSubClassRows : mixedTypeRows)
+      .find((f) => f.subject === step.subject && f.object === step.object);
+    const mixedTypeEdges = mixedTypeRows.map((f) => [f.subject, f.object]);
+    const mixedSubClassEdges = mixedSubClassRows.map((f) => [f.subject, f.object]);
+    for (const subj of subjCandidates) {
+      const chain = findIsaChain(subj, objVariants, mixedTypeEdges, mixedSubClassEdges, { maxHops: 2 });
+      if (!chain) continue;
+      const premises = chain.map(mixedFactForStep);
+      if (premises.every(Boolean) && premises.some(isTaught)) {
+        return { text: `yes — ${renderIsaChain(premises)}`, replace: true };
+      }
+    }
     // LIVE cax-dw PROOF CHASE: every "yes" strategy above missed — check whether X's taught type
     // (lifted through its FULL ⊑-ancestor closure) is disjointWith the
     // queried class, via syllogise.mjs's deriveDisjointViolations, LIVE and
@@ -6029,9 +6073,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
@@ -6045,11 +6093,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 };
@@ -6057,6 +6109,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) : "";