@polycode-projects/the-mechanical-code-talker 0.9.2 → 0.9.4

package/package.json

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

@@ -2052,6 +2052,32 @@ function relationTermOf(query, envelope) {
   return null;
 }
 
+/** A closed "describe"-intent wrapper: "can you describe X for me", "could you
+ *  tell me about X", "tell me more about X" → attempt tmct_describe(X). Found
+ *  live (playtest sprint round 2, SKILL_PLAYTEST_SPRINT.md): a describe-intent
+ *  question wrapped in an ordinary polite request ("can you tell me more about
+ *  Controller") fell all the way to the generic wall despite naming a real,
+ *  just-listed entity — nothing recognized the wrapper at all. Same closed
+ *  lead-in-alternation discipline as GREETING_PREAMBLE_RE/THANKS_PREAMBLE_RE
+ *  (normalize.mjs). Deliberately used only as a LAST-RESORT lane (see its call
+ *  site below) — "tell me about X" is ALSO the relation/concept force's own
+ *  trigger phrase for enumerable concepts ("tell me about inheritance"), so
+ *  this must never run before those have had their chance. */
+const DESCRIBE_WRAPPER_RE =
+  /^(?:(?:can|could|would)\s+you\s+(?:please\s+)?|please\s+)?(?:tell\s+me\s+(?:more\s+)?about|describe)\s+(.+?)(?:\s+for\s+me)?\s*\??$/i;
+
+async function describeWrapperAnswer(query, { config, source }) {
+  const m = DESCRIBE_WRAPPER_RE.exec(String(query || "").trim());
+  const term = m?.[1]?.trim();
+  if (!term) return null;
+  try {
+    const text = await dispatchTool("tmct_describe", { symbol: term }, { config, source });
+    return text ? { text } : null;
+  } catch {
+    return null; // unresolvable term — decline, the ordinary wall stands unchanged
+  }
+}
+
 /** THE RELATION CONCEPT FORCE — compose the three-band answer (curated relation
  *  definition + real example EDGES + pre-validated follow-ups) for a vague touch on a
  *  relation/edge kind ("what about imports", "what are the calls", "tell me about
@@ -2369,6 +2395,20 @@ async function runAsk(query, { config, source, graph, focus, last, templates, me
     const nudged = nudgeAnswer(query, newFocus);
     if (nudged) { answer = nudged; via = "miss"; }
   }
+  // (4d) DESCRIBE-WRAPPER RESCUE (playtest sprint round 2, SKILL_PLAYTEST_SPRINT.md)
+  // — "can you describe X for me" / "tell me more about X": a closed wrapper
+  // around an ordinary polite request naming a symbol. Tried ONLY here, after
+  // EVERY other lane (concept force, relation force, teach, author,
+  // presupposition, capability nudges) has already declined — "tell me about
+  // inheritance" must keep reaching the relation force's richer answer
+  // unmolested (that regression is exactly why this ISN'T inside asBareCommand,
+  // which runs first and would preempt every lane above). A last-resort rescue
+  // for what would otherwise become the generic wall, never a competing route:
+  // it only claims the turn if /describe actually resolves the captured term.
+  if (miss && recordMiss && via === "composed") {
+    const described = await describeWrapperAnswer(query, { config, source });
+    if (described) { answer = described.text; via = "describe"; recordMiss = false; }
+  }
   // (5) #1 SHORT TAILORED MISS — replace ONLY the engine's full grammar cheat-sheet
   // wall (WALL_MISS_RE). Receipt-bearing misses keep their specific wording.
   // WALL KINDNESS (0.8.2 WS4 (a)): when the PREVIOUS turn's answer was already a

package/src/interpret/normalize.mjs

@@ -485,6 +485,12 @@ export const STOPWORDS = new Set([
   // literally named "last" would be the accepted residual cost, same trade as
   // every other stopword.
   "last",
+  // frequency-adverb filler ("what does X usually change together with", "what does
+  // X typically call") — found live: "usually" glued onto the object term instead of
+  // being stripped, corrupting resolution ("src/core/store.mjs usually" instead of
+  // the module alone). Same trade as every other stopword: a symbol literally named
+  // "usually" would be the accepted residual cost.
+  "usually", "typically", "generally", "normally", "often", "commonly", "mostly",
 ]);
 
 /** Split free text into words: trailing "?" run stripped, commas treated as

package/src/interpret/strategies/keywords.mjs

@@ -150,6 +150,21 @@ export function parseKeywordSpot(text, nlp = null) {
   const consumed = new Set();
   const mark = (hit) => { if (hit) for (let i = hit.start; i < hit.end; i += 1) consumed.add(i); };
   mark(verbHit);
+  // A redundant SAME-KIND verb immediately after the matched one ("what TESTS
+  // cover X" — "tests" is read as the relation trigger, but "cover" — also a
+  // `tests` verb, ask-vocab.mjs's own synonym list — is the word the sentence
+  // actually intends as the verb) would otherwise fall into afterText raw and
+  // corrupt the object ("cover src/core/model.mjs" instead of the module alone).
+  // Anchored to the exact position right after verbHit (never a general re-scan),
+  // and gated on matching the SAME kind, so this can only strip a genuine
+  // restatement, never eat a real object term. Found live: "what tests cover X",
+  // "which tests test X" both misparsed this way before this fix.
+  for (const [phrase, kind] of Object.entries(VERB_TO_KIND)) {
+    if (kind !== verbHit.kind) continue;
+    const pWords = phrase.split(" ");
+    const start = verbHit.end;
+    if (pWords.every((w, j) => canonWords[start + j] === w)) { mark({ start, end: start + pWords.length }); break; }
+  }
   const entityHit = findPhrase(canonWords, ENTITY_TO_TYPE, consumed);
   mark(entityHit);
   const modifierHit = findPhrase(canonWords, MODIFIER_TO_KIND, consumed);