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

package/package.json

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

@@ -1532,7 +1532,7 @@ const WALL_MISS_ANYWHERE_RE = /couldn't parse this as a graph question\. Try:/;
 // assert/memory path; when it can't be stored, say what CAN be remembered
 // 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-]+ (?:is|are) (?:a |an )?[\w-]+$/i;
+const BARE_DECLARATIVE_RE = /^(?:every |each |all |a |an )?[\w-]+(?: [\w-]+)? (?:is|are) (?:a |an )?[\w-]+$/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;
@@ -5452,6 +5452,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

package/src/grammar/ace.mjs

@@ -95,7 +95,7 @@ const stripDet = (tokens) =>
  *  with "a"/"an" — the one signal that a singular-plural-fold collision
  *  (die/dice, person/people, tooth/teeth) can be resolved by, rather than
  *  silently committing to whichever the lexicon happens to fold to first. */
-function resolveNP(lexicon, tokensIn) {
+function resolveNP(lexicon, tokensIn, { allowCompound = false } = {}) {
   const ns = lexicon.ns;
   const singularOnly = tokensIn.length > 1 && SINGULAR_ONLY_DET.has(tokensIn[0].toLowerCase());
   const tokens = stripDet(tokensIn);
@@ -131,6 +131,26 @@ function resolveNP(lexicon, tokensIn) {
       }
       return { term, individual: false, noun, extras, unknown: [] };
     }
+    // Two plain NOUNS in a row are ONE compound noun ("guinea pig", "sports
+    // car"), space-joined to match the corpus's own multi-word concepts
+    // ("schema person"), so the taught fact and the query side unify.
+    // STRICTLY OPT-IN per call site (allowCompound): only the patterns where
+    // a compound subject is safe request it — capability, quantified
+    // membership, disjointness, and the articled-complement copula. The
+    // generic relation walk and the bare-adjective copula never do, so a
+    // question lead ("does dog have…") or a property sentence ("checkout
+    // flow is deprecated") can never silently become an ACE teach. A
+    // DECLARED proper name in either slot ("GitLab pipeline") keeps the
+    // structural miss below — a name in the wrong slot, not a compound.
+    if (allowCompound
+      && !lookupProperName(lexicon, tokens[0]) && !lookupProperName(lexicon, tokens[1])
+      && /^[a-z][a-z'-]*$/i.test(tokens[0]) && /^[a-z][a-z'-]*$/i.test(tokens[1])) {
+      const n0 = lookupNoun(lexicon, tokens[0], { singularOnly: false });
+      const n1 = lookupNoun(lexicon, tokens[1], { singularOnly });
+      if (n0 && n1) {
+        return { term: `${ns}${tokens[0].toLowerCase()} ${tokens[1].toLowerCase()}`, individual: false, noun: n1, extras: [], unknown: [] };
+      }
+    }
     // only genuinely undeclared words are residue — a declared word in the
     // wrong slot ("GitLab pipeline") is a structural miss, not an unknown
     const unknown = tokens.filter((t) => !classify(t, lexicon));
@@ -326,13 +346,11 @@ function parseEvery(lexicon, toks, lower) {
   }
   const isIdx = lower.indexOf("is");
   if (isIdx <= 1 || isIdx === toks.length - 1) return null;
-  const np1 = resolveNP(lexicon, toks.slice(1, isIdx));
   const rest = toks.slice(isIdx + 1);
-  if (rest.length === 1) {
-    const adj = lookupAdjective(lexicon, rest[0]);
-    if (adj) return adjectiveCopula(lexicon, PATTERN_ADJECTIVE, np1, adj);
-  }
-  const np2 = resolveNP(lexicon, rest);
+  const everyAdjOnly = rest.length === 1 ? lookupAdjective(lexicon, rest[0]) : null;
+  const np1 = resolveNP(lexicon, toks.slice(1, isIdx), { allowCompound: !everyAdjOnly });
+  if (everyAdjOnly) return adjectiveCopula(lexicon, PATTERN_ADJECTIVE, np1, everyAdjOnly);
+  const np2 = resolveNP(lexicon, rest, { allowCompound: true });
   if (np1.term == null || np2.term == null) return missOrNull(PATTERN_SUB_CLASS_OF, [np1, np2]);
   if (np1.individual || np2.individual) return null; // "every X is chat.mjs" — not the fragment
   return hit(PATTERN_SUB_CLASS_OF, [np1, np2], [
@@ -344,8 +362,8 @@ function parseEvery(lexicon, toks, lower) {
 function parseDisjoint(lexicon, toks, lower) {
   const isIdx = lower.indexOf("is");
   if (isIdx <= 1 || isIdx === toks.length - 1) return null;
-  const np1 = resolveNP(lexicon, toks.slice(1, isIdx));
-  const np2 = resolveNP(lexicon, toks.slice(isIdx + 1));
+  const np1 = resolveNP(lexicon, toks.slice(1, isIdx), { allowCompound: true });
+  const np2 = resolveNP(lexicon, toks.slice(isIdx + 1), { allowCompound: true });
   if (np1.term == null || np2.term == null) return missOrNull(PATTERN_DISJOINT_WITH, [np1, np2]);
   if (np1.individual || np2.individual) return null;
   return hit(PATTERN_DISJOINT_WITH, [np1, np2], [
@@ -393,14 +411,14 @@ function parseOfForm(lexicon, toks, lower) {
 
 /** Patterns 2 (class assertion), 1's bare-copula variant, and 8's copula arm. */
 function parseCopula(lexicon, toks, lower, isIdx) {
-  const np1 = resolveNP(lexicon, toks.slice(0, isIdx));
   const rest = toks.slice(isIdx + 1);
   if (!rest.length) return null;
+  const np1 = resolveNP(lexicon, toks.slice(0, isIdx), { allowCompound: rest.length > 1 });
   if (rest.length === 1) {
     const adj = lookupAdjective(lexicon, rest[0]);
     if (adj) return adjectiveCopula(lexicon, PATTERN_ADJECTIVE, np1, adj);
   }
-  const np2 = resolveNP(lexicon, rest);
+  const np2 = resolveNP(lexicon, rest, { allowCompound: true });
   if (np1.term == null || np2.term == null) {
     return missOrNull(np1.individual ? PATTERN_TYPE_ASSERTION : PATTERN_SUB_CLASS_OF, [np1, np2]);
   }
@@ -448,7 +466,7 @@ export function parseAce(sentence, lexicon = loadLexicon()) {
  *  has no negative-capability predicate, and a silently dropped negation
  *  would invert the taught meaning. */
 function parseCapability(lexicon, toks, canIdx) {
-  const np1 = resolveNP(lexicon, toks.slice(0, canIdx));
+  const np1 = resolveNP(lexicon, toks.slice(0, canIdx), { allowCompound: true });
   if (np1.term == null) return null;
   // The capability's object is a VERB ("swim"), not a lexicon noun, so
   // resolveNP is the wrong resolver for it: accept exactly one bare word,