@polycode-projects/the-mechanical-code-talker 0.4.0 → 0.6.0

package/src/ask.mjs

@@ -245,6 +245,7 @@ function parseComposite(text, nlp) {
   const w = splitWords(text);
   const lc = w.map((x) => x.toLowerCase());
   return parseNegation(text, nlp, 0)
+    || parseForwardNegation(w, lc, nlp)
     || parseAnaphora(w, lc, nlp)
     || parseAggregate(w, lc, nlp)
     || parseSuperlative(w, lc, nlp)
@@ -318,6 +319,54 @@ function parseNegation(text, nlp, depth = 0) {
   return complementAst(entityType, { op: "difference", kind: "set", ast: positive });
 }
 
+// B1 FORWARD NEGATION (Cycle 5, pron+neg) — the SUBJECT-side complement's mirror: "what
+// does[n't] <subj> <verb>" ("what doesn't it import", "what does app/lib/e.mjs not import")
+// is every individual of the verb's OBJECT grain that <subj> does NOT reach via that verb.
+// Distinct from parseNegation (which negates a queried KIND — "which modules do not import
+// X"): here the negation sits on a FORWARD clause whose subject is a named term or a focus
+// pronoun, so the universe is inferred from the verb's own edges (imports → Module) rather
+// than a stated kind noun. The subject is resolved LATE (at eval, through the same
+// contextId a plain "it" uses), so pronoun-binding composes with the complement for free.
+// Refused honestly (empty) when the verb's object grain is ambiguous or the subject can't
+// resolve — never a guess. Runs AFTER parseNegation, so the stated-kind form is unaffected.
+const FWD_NEG_FRAME = new Set(["what", "which", "thing", "things", "one", "ones", "stuff"]);
+function parseForwardNegation(w, lc, nlp) {
+  let i = 0;
+  while (i < lc.length && FWD_NEG_FRAME.has(lc[i])) i += 1;
+  if (!["do", "does", "did"].includes(lc[i])) return null;   // need the auxiliary lead
+  i += 1;
+  const rest = w.slice(i);
+  const restLc = lc.slice(i);
+  const notIdx = restLc.indexOf("not");
+  if (notIdx < 0) return null;                                // no negation → not this shape
+  const vh = findPhrase(restLc, VERB_TO_KIND);
+  if (!vh) return null;                                       // no relation verb → not this shape
+  // the subject term is whatever survives after removing "not", the verb phrase, "from",
+  // and question scaffolding — a bare pronoun "it" (not a stopword) survives and binds to
+  // the focus at eval time; a named module/symbol survives and resolves directly.
+  const subjTokens = rest.filter((_, j) => j !== notIdx && (j < vh.start || j >= vh.end)
+    && restLc[j] !== "from" && !STOPWORDS.has(restLc[j]));
+  const subjectTerm = subjTokens.join(" ").trim();
+  if (!subjectTerm) return null;
+  return { node: "forwardComplement", kind: vh.kind, subjectTerm };
+}
+
+/** The single OBJECT class a forward relation kind points at across the loaded graph
+ *  (imports → Module), or null when its objects span more than one class (an ambiguous
+ *  grain the complement's universe can't be pinned to). Ext: endpoints have no individual,
+ *  so they don't muddy the class vote. Used by the forwardComplement evaluator to bound
+ *  the universe it differences the positive forward set out of. */
+function kindObjectClass(graph, kind) {
+  const classes = new Set();
+  for (const k of kindsFor(kind)) {
+    for (const e of edgesOfKind(graph, k)) {
+      const o = graph.byId.get(e.object);
+      if (o && o.class) classes.add(o.class);
+    }
+  }
+  return classes.size === 1 ? [...classes][0] : null;
+}
+
 /** A set-producing sub-expression (used for nested inner clauses, boolean branches,
  *  and count restrictors): nested first, then the relational/qualifier/boolean
  *  parser, then a bare simple clause. Carries `depth` for the nesting cap. */
@@ -373,12 +422,21 @@ function parseNested(w, lc, nlp, depth) {
  *  uncompilable), or null. */
 function parseAnaphora(w, lc, nlp) {
   let p = -1;
+  let viaOf = false;
   for (let i = 1; i < lc.length; i += 1) {
-    if (ANAPHORA_TRIGGERS.includes(lc[i]) && lc[i - 1] === "of") { p = i; break; }
+    if (!ANAPHORA_TRIGGERS.includes(lc[i])) continue;
+    if (lc[i - 1] === "of") { p = i; viaOf = true; break; } // "how many of those", "which of them"
+    // BARE anaphoric pronoun as the FINAL word, directly after a count/list trigger
+    // ("count them", "count those", "list them") — the discourse-reference count/list over
+    // the previous answer with no "of" (Cycle 5, disc+count). Pinned to the terminal
+    // position so a mid-sentence "these"/"those" used as a determiner ("list these
+    // functions") is left for the ordinary list/clause path, not seized as an anaphor.
+    const headSoFar = lc.slice(0, i).join(" ");
+    if (i === lc.length - 1 && (AGGREGATE_TRIGGERS.includes(headSoFar) || LIST_TRIGGERS.includes(headSoFar))) { p = i; break; }
   }
   if (p < 0) return null;
-  const head = lc.slice(0, p - 1).join(" ");
-  const mode = /^(how many|how much|count)\b/.test(head) ? "count" : "list";
+  const head = (viaOf ? lc.slice(0, p - 1) : lc.slice(0, p)).join(" ");
+  const mode = AGGREGATE_TRIGGERS.includes(head) || /^(how many|how much|count|number|quantity|total)\b/.test(head) ? "count" : "list";
   const filter = parsePredicateFilter(w.slice(p + 1), nlp);
   if (filter === undefined) return { node: "miss", reason: "the follow-up filter didn't parse" };
   return { node: "anaphora", mode, filter };
@@ -772,6 +830,16 @@ function evalSet(graph, ast, opts) {
       const subs = new Set(kindsFor(ast.kind).flatMap((k) => edgesOfKind(graph, k)).map((e) => e.subject));
       return graph.individuals.filter((i) => subs.has(i.id) && (!ast.entityType || i.class === ast.entityType));
     }
+    // forward complement: the verb's object-grain universe MINUS what the (late-resolved,
+    // focus-bindable) subject reaches via that verb — "what doesn't it import".
+    case "forwardComplement": {
+      const r = resolveTermOrContext(graph, ast.subjectTerm, opts && opts.contextId);
+      if (!r.match) return [];                              // unresolved subject / focus-less pronoun → honest empty
+      const universeType = kindObjectClass(graph, ast.kind);
+      if (!universeType) return [];                         // ambiguous object grain → refuse honestly
+      const positive = new Set(forwardOverSet(graph, ast.kind, new Set([r.match.id])).map((x) => x.id));
+      return graph.individuals.filter((i) => i.class === universeType && !positive.has(i.id));
+    }
     case "reverseSet": {
       const ids = new Set(evalSet(graph, ast.inner, opts).map((i) => i.id));
       return reverseOverSet(graph, ast.kind, ast.entityType, ids);
@@ -1401,11 +1469,23 @@ export function traverse(graph, parsed, { contextId = null, prev = null } = {})
     };
   }
 
-  // reverse: "which <entityType> R <objMatch>"
+  // reverse: "which <entityType> R <objMatch>". GRAIN-AWARE (Cycle 5, lever 3): a kind
+  // that carries a symbol-grain sibling reads off the SIBLING when a fine SUBJECT grain
+  // was asked for ("which functions call X" → callsSymbol). It ALSO reads off the sibling
+  // when the RESOLVED OBJECT is itself a fine symbol, for EVERY kind with a sibling — not
+  // only touches: the module-coarse edge (calls Module→Module, touches Commit→Module) can
+  // NEVER point at a function/method, so a bare "what calls fnAlpha" scanning the coarse
+  // `calls` edges returned a FALSE empty ("No modules found …") while the graph records a
+  // real symbol-level caller (Widget.render --callsSymbol--> fnAlpha). The honest answer
+  // reads off callsSymbol at symbol grain; a truly-uncalled symbol still renders the
+  // honest empty, now with the accurate callsSymbol receipt. (Previously scoped to touches
+  // only, which left this exact callsSymbol caller invisible — a genuine correctness bug.)
   const symbolKind = SYMBOL_GRAIN_SIBLING[kind];
-  if (symbolKind && FINE_ENTITY_TYPES.has(entityType)) {
+  const objIsFineSymbol = !!(objMatch.class && FINE_ENTITY_TYPES.has(objMatch.class));
+  if (symbolKind && (FINE_ENTITY_TYPES.has(entityType) || objIsFineSymbol)) {
     const edges = edgesOfKind(graph, symbolKind).filter((e) => e.object === objMatch.id);
-    const matches = edges.map((e) => graph.byId.get(e.subject)).filter((i) => i && i.class === entityType);
+    const subjects = uniqueById(edges.map((e) => graph.byId.get(e.subject)).filter(Boolean));
+    const matches = (!entityType || entityType === "Change") ? subjects : subjects.filter((i) => i.class === entityType);
     return { matches, objMatch, candidates, traversal: `${symbolKind} edges where object = ${objMatch.label}`, ambiguous, matchedVia };
   }
 
@@ -1662,6 +1742,10 @@ function renderCore(parsed, result) {
         miss: true, ambiguous: false,
       };
     }
+    // NOTE (Cycle 5): a voice-nit rephrasing ("that directly <verb>") was reverted —
+    // the frozen v1 cases.jsonl pins the "whose module directly <verb>s X" wording
+    // (hm-empty-result-calls / tf-wat-calls / ns-wondering), and the case set is
+    // append-only/sacred mid-arc, so the honest-miss phrasing stays as-is.
     const entityWord = nounFor(parsed.entityType || "Module", 2);
     return {
       content: `No ${entityWord} found whose module directly ${verbFor(parsed.kind)} ${parsed.object}. (traversal: ${result.traversal || "no traversal resolved"})`,