@polycode-projects/the-mechanical-code-talker 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/the-mechanical-code-talker",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "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/ask.mjs

@@ -320,6 +320,7 @@ function parseComposite(text, nlp) {
   const w = splitWords(text);
   const lc = w.map((x) => x.toLowerCase());
   return parseExistence(w, lc)
+    || parseQualifierCheck(w, lc)
     || parseNegation(text, nlp, 0)
     || parseForwardNegation(w, lc, nlp)
     || parseTemporal(w, lc, nlp, 0)
@@ -655,6 +656,43 @@ function parseExistence(w, lc) {
                // different (relationship) question; leave it for the parsers below.
 }
 
+/** QUALIFIER-CHECK: "is <term> [a/an] <qualifier> [<kind>]?", "is <term> not
+ *  <qualifier> …" — a single-ENTITY Yes/No property check ("is Task.title
+ *  public", "is it exported", "is that class abstract"), reusing the SAME
+ *  closed QUALIFIERS vocabulary and qualHolds() evaluator the attributive/
+ *  predicative-survey filters already fold over a SET ("public methods",
+ *  "which methods are public") — this is the missing single-entity sibling
+ *  (0.9.15 Tier-1 single-touch playtest: "is it a public attribute?", a
+ *  natural follow-up to a concept-force touch, had no recognizer at all and
+ *  hit the bare grammar wall — even "is Task.title public", a concretely
+ *  NAMED entity with no anaphora involved, walled the same way). Scoped
+ *  tight: a leading "is"/"are", then TERM tokens up to the FIRST recognized
+ *  qualifier word — a leading "the" and a trailing "a"/"an" article around
+ *  the boundary are dropped, and a trailing decorative kind noun ("… public
+ *  ATTRIBUTE") is simply never consumed, never required to agree with the
+ *  resolved entity's real class. Guarded off "is/are THERE …" (parseExistence
+ *  above owns that shape) and off any text with no qualifier word at all, so
+ *  it can never swallow a genuine relationship/existence question. The term
+ *  is resolved at EVAL time (a pronoun binds through the standing contextId,
+ *  exactly like every other object term), never here. */
+function parseQualifierCheck(w, lc) {
+  if (lc[0] !== "is" && lc[0] !== "are") return null;
+  if (lc[1] === "there") return null; // parseExistence's own shape
+  let qualIdx = -1;
+  let negated = false;
+  for (let i = 1; i < lc.length; i += 1) {
+    if (QUALIFIERS[lc[i]]) { qualIdx = i; negated = lc[i - 1] === "not"; break; }
+  }
+  if (qualIdx < 0) return null; // no qualifier word at all → not this shape
+  let termStart = 1;
+  if (lc[termStart] === "the") termStart += 1;
+  let termEnd = negated ? qualIdx - 1 : qualIdx;
+  if (termEnd > termStart && (lc[termEnd - 1] === "a" || lc[termEnd - 1] === "an")) termEnd -= 1;
+  const term = termEnd > termStart ? w.slice(termStart, termEnd).join(" ").trim() : "";
+  if (!term) return { node: "miss", reason: `"is/are <qualifier>" needs a named thing to check first` };
+  return { node: "qualCheck", term, qualifier: lc[qualIdx], negated };
+}
+
 /** Trailing "and that's the whole question" filler an aggregate/list tail can carry
  *  ("how many classes are there", "list functions in total", "which classes exist in
  *  the index") — a count/list over a bare kind is frequently phrased with such a tail,
@@ -1598,11 +1636,29 @@ function evalExists(graph, ast) {
   return { compositeKind: "exists", entityType, term: null, scopeModule, scopeMatch, matches: pool };
 }
 
+/** QUALIFIER-CHECK eval — resolve the term (a context pronoun binds through
+ *  contextId, exactly like resolveTermOrContext's every other caller), then
+ *  read the SAME qualHolds() predicate the set-filter path already uses.
+ *  `holds` here means "the STATEMENT AS ASKED is true" (negation already
+ *  folded in), so the renderer can answer Yes/No directly off it without
+ *  re-deriving the negation. An unresolved term is an honest miss, never a
+ *  guess — no different from any other named-object lookup. */
+function evalQualCheck(graph, ast, opts) {
+  const { term, qualifier, negated } = ast;
+  const r = resolveTermOrContext(graph, term, opts.contextId);
+  if (r.unresolvedPronoun) return { compositeKind: "qualCheck", qualCheckMiss: "pronoun", term, matches: [] };
+  if (!r.match) return { compositeKind: "qualCheck", qualCheckMiss: "unresolved", term, matches: [] };
+  const rawHolds = qualHolds(graph, r.match, QUALIFIERS[qualifier]);
+  const holds = negated ? !rawHolds : rawHolds;
+  return { compositeKind: "qualCheck", subject: r.match, qualifier, negated, holds, matches: [r.match] };
+}
+
 /** Compile any compositional AST to a result object traverse() returns for the
  *  simple path — {matches, …} plus compositeKind/compositeMiss flags render() reads. */
 export function evalComposite(graph, ast, opts = {}) {
   if (ast.node === "miss") return { compositeMiss: true, reason: ast.reason || null, matches: [] };
   if (ast.node === "exists") return evalExists(graph, ast);
+  if (ast.node === "qualCheck") return evalQualCheck(graph, ast, opts);
   if (ast.node === "count") return { compositeKind: "count", count: evalSet(graph, ast.base, opts).length, entityType: ast.entityType, matches: [] };
   if (ast.node === "list") return { compositeKind: "list", matches: evalSet(graph, ast.base, opts), entityType: ast.entityType, scoped: ast.scoped };
   if (ast.node === "superlative") return evalSuperlative(graph, ast);
@@ -1676,6 +1732,27 @@ function renderComposite(parsed, result) {
     }
     return { content: `Yes — ${compositeList(result.matches)}${scopeSuffix}.`, miss: false, ambiguous: false, matches: result.matches };
   }
+  // qualCheck: "is <term> [a/an] <qualifier> […]" — the single-entity sibling of
+  // "is there a/an <kind> …" above: a direct Yes/No over one already-named/-
+  // focused individual, never a set listing. `result.holds` already has the
+  // negation folded in (evalQualCheck), so the renderer states the actual truth
+  // plainly — "No — X is tested." for "is X not tested" when X IS tested, never
+  // an echo of the (now-false) question's own wording.
+  if (result.compositeKind === "qualCheck") {
+    if (result.qualCheckMiss === "pronoun") {
+      return { content: `"${result.term}" needs a selected node to refer to — click a node first, or name it directly.`, miss: true, ambiguous: false };
+    }
+    if (result.qualCheckMiss === "unresolved") {
+      return { content: `couldn't find "${result.term}" in the index to check.`, miss: true, ambiguous: false };
+    }
+    const label = result.subject.label;
+    const truePhrase = result.negated ? `not ${result.qualifier}` : result.qualifier;
+    const falsePhrase = result.negated ? result.qualifier : `not ${result.qualifier}`;
+    return {
+      content: `${result.holds ? "Yes" : "No"} — ${label} is ${result.holds ? truePhrase : falsePhrase}.`,
+      miss: false, ambiguous: false, matches: result.matches,
+    };
+  }
   if (result.compositeKind === "count") {
     const noun = result.entityType ? nounFor(result.entityType, result.count) : (result.count === 1 ? "result" : "results");
     return { content: `${result.count} ${noun}.`, miss: false, ambiguous: false, matches: [] };
@@ -2994,10 +3071,22 @@ export function relaxParse(graph, query, { nlp = undefined, contextId = null, pr
   // own as vocabulary/scaffolding? Guards against a relaxation that drops the actual
   // asked term and lets a bare marker slide into its place ("where is [X] defined" →
   // "where is defined", "defined" is a WHERE_MARKER, never the thing being located).
-  const hasRealTerm = (s) => splitWords(String(s || "")).some((w) => {
-    const lc = w.toLowerCase();
-    return !CONTENT_VOCAB.has(lc) && !STRUCTURAL_WORDS.has(lc);
-  });
+  // A bare CONTEXT PRONOUN ("it"/"this"/"that"/"here"/…) is the one exception: it IS
+  // the real, deliberate object here — it resolves through contextId, not through
+  // vocabulary the grammar "already owns" as scaffolding — so it must count as a real
+  // term rather than being mistaken for a dropped-into-place marker. Without this, a
+  // relaxed candidate whose object survived layer 2 as a lone pronoun ("what else is
+  // in that class" → drop "class"/"else" → "what does that contain") was rejected as
+  // if it named nothing at all, even though the pronoun resolves to a real, answerable
+  // focus (0.9.15 Tier-1 single-touch playtest).
+  const hasRealTerm = (s) => {
+    const whole = String(s || "").trim().toLowerCase();
+    if (CONTEXT_PRONOUNS.includes(whole)) return true;
+    return splitWords(whole).some((w) => {
+      const lc = w.toLowerCase();
+      return !CONTENT_VOCAB.has(lc) && !STRUCTURAL_WORDS.has(lc);
+    });
+  };
   // Accept a relaxed attempt ONLY if it is a genuinely answerable parse (terms resolve)
   // AND it renders a REAL positive answer — never another empty/miss (relaxation earns a
   // win only by turning a miss into an answer, never a differently-worded miss) — and

package/src/interpret/normalize.mjs

@@ -44,6 +44,33 @@ const correctionRe = (table) => new RegExp(
 const MISSPELLING_RE = correctionRe(MISSPELLINGS);
 const WRONG_WORD_RE = correctionRe(WRONG_WORDS);
 
+/** "that class"/"this module"/"that function" (a context pronoun immediately
+ *  followed by the SINGULAR kind noun it's already standing in for) -> the bare
+ *  pronoun alone (0.9.15 Tier-1 single-touch playtest). "which class contains
+ *  Task.complete" answers by NAMING the class ("… there is Task"); a curious
+ *  user's very next turn naturally says "what is in that class", not the bare
+ *  "what is in that" the grammar already understands. Left unstripped, the two
+ *  parse strategies disagreed on the SPAN (grammar kept "that class" as one
+ *  literal 2-word object term; keyword-spot split off "class" as an entityType
+ *  keyword, leaving bare "that" as the object) — same PARSE, different shape,
+ *  so merge.mjs's honest {ambiguousParse} tie fired even though a human reads
+ *  this as one unambiguous sentence. Folding the kind noun away BEFORE either
+ *  strategy runs leaves exactly one reading: CONTEXT_PRONOUNS' own existing
+ *  focus-resolution (ask.mjs's resolveTermOrContext) then takes it from there,
+ *  unchanged — this frame only removes the strategy disagreement, it does not
+ *  touch how the pronoun itself resolves. Singular kind nouns only ("that
+ *  classes" isn't grammatical, so plurals are never a real anaphora and are
+ *  left alone); "one" is excluded ("that one" is already its own literal
+ *  CONTEXT_PRONOUNS entry). */
+const KIND_NOUN_ANAPHORA_RE = /\b(this|that)\s+(class|module|function|method|attribute|variable|file|commit)\b/gi;
+
+// every relation verb phrase VERB_TO_KIND knows, as one alternation (longest-first
+// so a multi-word verb like "inherit from" wins over its own leading word "inherit"
+// appearing elsewhere) — feeds the DOES-X-VERB-ANYTHING-ELSE frame below, which needs
+// to recognize "does <subject> <ANY closed relation verb> anything/something [else]"
+// without hardcoding its own parallel verb list.
+const VERB_ALTERNATION = Object.keys(VERB_TO_KIND).sort((a, b) => b.length - a.length).map(escapeRegex).join("|");
+
 /** Just the curated MISSPELLINGS correction (ask-vocab.mjs), standalone — for a
  *  caller that needs typo-tolerant ANCHOR-WORD matching (a closed regex shape
  *  keyed on a literal "what"/"which"/"where" etc.) without running the rest of
@@ -158,6 +185,25 @@ const EXPLAIN_WRAPPER_RE = /^explain\s+(?:to\s+me\s+|please\s+)*(.+?)\??$/i;
  *  module" -> "describe store module"). */
 const SHOW_GIVE_ME_RE = /^(?:show|give)\s+me\s+(?:the\s+)?(.+?)\??$/i;
 
+/** Leading STACCATO connective before an ALREADY well-formed question ("and
+ *  what imports it", "so does it import anything else", "also where is X
+ *  defined") -> the question alone (0.9.15 Tier-1 single-touch playtest). A
+ *  rapid-fire drill-down naturally opens its next turn with a bare discourse
+ *  connective (chat.mjs's own STACCATO_LEAKED_CONNECTIVES set: and/also/so/
+ *  then/now, here joined by "but" for the same family); when what follows is
+ *  ALREADY an interrogative lead or an auxiliary-question opener, the
+ *  connective carries no query content of its own — conversational
+ *  scaffolding, same species as the greeting/subordination preambles. Gated
+ *  on the REMAINDER starting a real question, so a genuine mid-clause boolean
+ *  composition ("classes that inherit from Base and are tested") is never
+ *  touched — that "and" never sits at position 0 to begin with. Without this,
+ *  "and what imports it" parsed as an "ask"-shape question with "and" itself
+ *  MISREAD as the subject term — a miss the relaxation cascade can't rescue,
+ *  because "and" is protected CONTENT_VOCAB (a boolean connective elsewhere)
+ *  and the noise-strip layer never drops content vocab. */
+const LEADING_CONNECTIVE_RE = /^(?:and|also|so|then|now|but)\s+(.+)$/i;
+const QUESTION_AUX_LEAD_RE = /^(?:does|do|did|is|are|was|were|has|have|had|can|could|will|would|should)\b/i;
+
 /** Apply the closed preamble frames in order (greeting -> modal -> show/give-me),
  *  repeated to a small fixpoint so stacked wrappers ("hey, can you show me X
  *  please") peel fully. Pure and idempotent; unmatched text passes through. */
@@ -180,6 +226,11 @@ export function applyPreambleFrames(text) {
         q = (RELATION_VERB_RE.test(rest) || INTERROGATIVE_LEAD_RE.test(rest)) ? rest : `describe ${rest}`;
       }
     }
+    m = q.match(LEADING_CONNECTIVE_RE);
+    if (m) {
+      const rest = m[1].trim();
+      if (INTERROGATIVE_LEAD_RE.test(rest) || QUESTION_AUX_LEAD_RE.test(rest)) q = rest;
+    }
     if (q === before) break;
   }
   return q;
@@ -343,6 +394,7 @@ export function normalizeQuery(text) {
   q = q.replace(CONTRACTION_RE, (m) => CONTRACTIONS[m.toLowerCase()]);
   q = q.replace(MISSPELLING_RE, (m) => MISSPELLINGS[m.toLowerCase()]);
   q = q.replace(WRONG_WORD_RE, (m) => WRONG_WORDS[m.toLowerCase()]);
+  q = q.replace(KIND_NOUN_ANAPHORA_RE, (_, pron) => pron);
   q = q.replace(G_DROP, "$1ing");
   // closed preamble frames (greeting lead-in, modal wrapper, show/give-me
   // bridge) — AFTER the correction tables (a repaired "give me"/"show me" still
@@ -414,6 +466,23 @@ export const PHRASING_FRAMES = Object.freeze([
   { re: /^(?:the\s+)?(?:members?|methods?|attributes?|contents)\s+of\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
   //   "what's in X" / "what is in X" (contraction already expanded; sha handled above)
   { re: /^what\s+is\s+(?:in|inside)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
+  //   "what else is in X" (0.9.15 Tier-1 single-touch playtest) — the natural
+  //   "besides what I already know" drill-down after a members-of-class answer.
+  //   Distinct from the "what else does X <verb>" family (which the compositional
+  //   grammar already tolerates, dropping "else" as noise on its own): the "is
+  //   in" idiom is NOT a compositional marker, so parseComposite never sees it and
+  //   "what else is in X" fell through to the strategies with NO candidate at all
+  //   (neither recognizes the bare "is in" idiom once "else" sits in front of it).
+  //   The only rescue was the relaxation cascade's drop-unmatched layer — but that
+  //   layer refuses to accept a relaxed reading that still renders an honest EMPTY
+  //   (by design: relaxation must turn a miss into a real answer, never into
+  //   another kind of miss), so a genuinely empty class ("what else is in
+  //   Task.complete" — a method, no members) bottomed out at the bare grammar
+  //   wall instead of the specific "no contains edges" receipt. Routing this
+  //   frame onto the SAME direct "what does X contain" path the plain "what is
+  //   in X" frame above already uses sidesteps the cascade's conservative gate
+  //   entirely, so a real empty is reported honestly instead of walled.
+  { re: /^what\s+else\s+is\s+(?:in|inside)\s+(?:the\s+)?(.+?)\??$/i, to: (m) => `what does ${m[1]} contain` },
 
   // WHERE-DEFINED → "where is X defined". PAST TENSE ONLY ("what defined X", "what
   // declared X"): the PRESENT "what defines X" already parses as a reverse-defines
@@ -512,6 +581,26 @@ export const PHRASING_FRAMES = Object.freeze([
   // survey the bare "what is untested" frame lands on. Closed to the tests/coverage
   // object, so it can't swallow a general "what needs X".
   { re: /^what\s+needs\s+(?:to\s+be\s+)?(?:a\s+)?(?:tested|tests?|testing|coverage|covering)\??$/i, to: () => "untested modules" },
+
+  // DOES-X-VERB-ANYTHING-ELSE → the plain forward "what does X <verb>" listing
+  // (0.9.15 Tier-1 single-touch playtest). A very natural drill-down follow-up
+  // after a relation answer — "does listTasks call anything else", "does
+  // src/handlers/tasks.mjs import something else" — used to dead-end: "anything"/
+  // "something" [else] is a placeholder standing in for "the rest of the list",
+  // not a real object term, but the two parse strategies disagreed on the SPAN
+  // (grammar kept "anything else" whole as the object, keyword-spot dropped
+  // "anything" and kept only "else"), landing on the {ambiguousParse} surface —
+  // two nonsense readings offered as if one might be right. "what does X <verb>"
+  // is the exact working canonical shape (see the MEMBERS-of-class frames above),
+  // so rewriting the whole closed pattern onto it sidesteps the disagreement
+  // instead of teaching either strategy's tokenizer to special-case "else".
+  // Anchored to the closed VERB_TO_KIND vocabulary so it can never swallow a
+  // genuine named object that happens to start with "any"/"some" (only the bare
+  // placeholder nouns "anything"/"something", optionally trailed by "else", match).
+  {
+    re: new RegExp(`^(?:do|does)\\s+(.+?)\\s+(${VERB_ALTERNATION})\\s+(?:anything|something)(?:\\s+else)?\\??$`, "i"),
+    to: (m) => `what does ${m[1]} ${m[2]}`,
+  },
 ]);
 
 /** Apply the phrasing frames (members-of-class + where-defined) — first match wins