@polycode-projects/seonix 0.10.10 → 0.10.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/seonix",
-  "version": "0.10.10",
+  "version": "0.10.14",
   "private": false,
   "type": "module",
   "description": "SEONIX — a deterministic, offline, $0 code-graph tool that makes a cheap coding agent edit like an expensive one. Indexes a repo with Python ast + git (zero model calls) and renders a bounded edit-digest.",
@@ -50,6 +50,7 @@
     "setup": "node scripts/setup.mjs",
     "bench": "node bench/run.mjs",
     "bench:quick": "node bench/run.mjs --instances 1 --runs 1",
+    "bench:telemetry": "node bench/run.mjs --suite django-lh --arms seonix-ask --instances 1 --runs 1 --telemetry",
     "join:telemetry": "node scripts/join-telemetry.mjs",
     "bench:lite": "node bench/run.mjs --suite lite",
     "bench:seonix": "node bench/run.mjs --suite django-lh --arms seonix,seonix-min --runs 5",
@@ -88,7 +89,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@polycode-projects/the-mechanical-code-talker": "^0.9.10",
+    "@polycode-projects/the-mechanical-code-talker": "^1.0.4",
     "cytoscape": "^3.30.0",
     "smol-toml": "^1.7.0",
     "tree-sitter": "^0.21.1",

package/src/ask-browser.bundle.js

@@ -590,6 +590,10 @@
     "touchs": "touches",
     "tuoches": "touches",
     "touhced": "touched",
+    // WHERE_MARKERS typo (0.9.13 Tier-1 playtest): "defined" itself had no typo
+    // entry, so "where is it defned" fell through to the bare-object search path
+    // instead of the where-shape ("no module matching 'it defned' found").
+    "defned": "defined",
     "chagned": "changed",
     "chnaged": "changed",
     "chagnes": "changes",
@@ -602,6 +606,17 @@
     "whcih": "which",
     "wich": "which",
     "whihc": "which",
+    // "wehre"/"whre" (0.9.13 Tier-1 playtest, "where is it defined" drill-down):
+    // the WHERE-DEFINED shape's own anchor word had NO typo tolerance at all
+    // (unlike which/what/does/the above), so a plain dropped/transposed letter
+    // fell straight through resolveObject and hit either the grammar wall or a
+    // bogus "no module matching 'it defined'" search. "were" (the missing-h
+    // homophone slip) is NOT curated here — it's a real word already load-bearing
+    // as the TEMPORAL_AUX auxiliary ("when were the modules last touched"), so
+    // that one typo is handled by its own anchored phrasing frame instead
+    // (normalize.mjs PHRASING_FRAMES) to avoid clobbering the legitimate reading.
+    "wehre": "where",
+    "whre": "where",
     // "wat" (chatbench cycle 2, tf-wat-calls): the internet-casual spelling of
     // "what" — neither curated noise nor a restorable trigger typo, so "wat calls
     // fnAlpha" used to die as "couldn't resolve one of the terms". Restored here
@@ -685,7 +700,8 @@
     "kinda",
     "sorta",
     "btw",
-    "by the way"
+    "by the way",
+    "you"
   ]);
   var CONTEXT_PRONOUNS = Object.freeze(["this", "it", "that", "here", "this one", "that one"]);
   var NEGATION_FRAMES = Object.freeze([
@@ -992,9 +1008,10 @@
     const words = rest.replace(/\?+\s*$/, "").trim().split(/\s+/);
     return LISTING_TAIL_KINDS.has((words[words.length - 1] || "").toLowerCase());
   };
-  var GREETING_PREAMBLE_RE = /^(?:hi|hiya|hello|hey|yo|howdy)(?:\s+there)?\s*[,—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
+  var GREETING_PREAMBLE_RE = /^(?:hi|hiya|hello|hey|yo|howdy|g'?day|good\s+(?:morning|afternoon|evening|day)|greetings|salutations)(?:\s+there)?\s*[,.—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
   var THANKS_PREAMBLE_RE = /^(?:thanks|thank\s+you|many\s+thanks|thx|ty|cheers)(?:\s+(?:so\s+much|a\s+lot|very\s+much|a\s+bunch))?\s*[,—–-]\s*(?:(?:just\s+a\s+)?quick\s+question\s*[,:—–-]?\s*)?(.+)$/i;
   var MODAL_WRAPPER_RE = /^(?:can|could|would|will)\s+you\s+(?:please\s+)?(.+?)(?:[,\s]+please)?\??$/i;
+  var EXPLAIN_WRAPPER_RE = /^explain\s+(?:to\s+me\s+|please\s+)*(.+?)\??$/i;
   var SHOW_GIVE_ME_RE = /^(?:show|give)\s+me\s+(?:the\s+)?(.+?)\??$/i;
   function applyPreambleFrames(text) {
     let q = String(text || "");
@@ -1006,6 +1023,8 @@
       if (m) q = m[1].trim();
       m = q.match(MODAL_WRAPPER_RE);
       if (m) q = m[1].trim();
+      m = q.match(EXPLAIN_WRAPPER_RE);
+      if (m && INTERROGATIVE_LEAD_RE.test(m[1].trim())) q = m[1].trim();
       m = q.match(SHOW_GIVE_ME_RE);
       if (m) {
         const rest = m[1].trim();
@@ -1027,6 +1046,18 @@
     }
     return q;
   }
+  var SELF_CORRECTION_RE = /^.+?(?:\s*(?:--|—|-)\s*)?\b(?:sorry|i\s+mean)\b\s*(?:--|—|-|,|:)\s*(.+)$/i;
+  function applySelfCorrectionFrames(text) {
+    let q = String(text || "");
+    for (let pass = 0; pass < 3; pass++) {
+      const m = q.match(SELF_CORRECTION_RE);
+      if (!m) break;
+      const next = m[1].trim();
+      if (!next || next === q) break;
+      q = next;
+    }
+    return q;
+  }
   var CONDITIONAL_VERB_GERUND = Object.freeze({
     imports: "importing",
     calls: "calling",
@@ -1073,6 +1104,7 @@
     q = q.replace(WRONG_WORD_RE, (m) => WRONG_WORDS[m.toLowerCase()]);
     q = q.replace(G_DROP, "$1ing");
     q = applyPreambleFrames(q);
+    q = applySelfCorrectionFrames(q);
     q = applySubordinationFrames(q);
     q = applyConditionalFrames(q);
     if (FILLER_WORDS.length) {
@@ -1111,6 +1143,15 @@
     { re: /^what\s+(?:defined|declared)\s+(?:the\s+)?(?:function\s+|method\s+|class\s+|module\s+|variable\s+|constant\s+)?(.+?)\??$/i, to: (m) => `where is ${m[1]} defined` },
     //   "where's X defined" (the "where's" contraction is not in the contraction table)
     { re: /^where'?s\s+(?:the\s+)?(.+?)\s+(defined|declared|located|implemented)\??$/i, to: (m) => `where is ${m[1]} ${m[2]}` },
+    //   "were is X defined" (0.9.13 Tier-1 playtest: the missing-h typo of "where").
+    //   NOT curated as a blanket MISSPELLINGS entry — "were" is a real word already
+    //   load-bearing as the TEMPORAL_AUX auxiliary ("when were the modules last
+    //   touched"), so a global word-boundary rewrite would clobber that reading.
+    //   This frame is anchored to the WHERE-DEFINED shape specifically ("were is
+    //   … defined/declared/located/implemented"), a construction no legitimate
+    //   temporal query produces ("were" as an auxiliary never leads directly into
+    //   a bare "is").
+    { re: /^were\s+is\s+(?:the\s+)?(.+?)\s+(defined|declared|located|implemented)\??$/i, to: (m) => `where is ${m[1]} ${m[2]}` },
     // PREDICATIVE QUALIFIER → the ATTRIBUTIVE form the grammar already answers. The
     // adjective-qualifier post-filters (ask-vocab.mjs QUALIFIERS: tested/untested,
     // public/private, exported, static/abstract/constant, …) parse in the ATTRIBUTIVE
@@ -1304,11 +1345,13 @@
     return /^[a-z]+$/.test(w) && !STOPWORDS2.has(w) && !VOCAB_WORDS.has(w);
   }
   function fuzzyVocabWord(w) {
-    const bound = fuzzyBound(w);
+    return fuzzyMatchInSet(w, FUZZY_TARGET_WORDS, fuzzyBound(w));
+  }
+  function fuzzyMatchInSet(w, candidates, bound = fuzzyBound(w)) {
     let best = bound + 1;
     let hit2 = null;
     let tied = false;
-    for (const target of FUZZY_TARGET_WORDS) {
+    for (const target of candidates) {
       const d = editDistance(w, target, Math.min(best, bound));
       if (d < best) {
         best = d;
@@ -2281,7 +2324,7 @@
   }
   var MAX_COMPOSE_DEPTH = 4;
   var NEST_SENTINEL = "zzinnerset";
-  var PRED_LEAD_SKIP = /* @__PURE__ */ new Set(["that", "which", "who", "are", "is", "was", "were", "do", "does", "also", "still", "both", "and"]);
+  var PRED_LEAD_SKIP = /* @__PURE__ */ new Set(["that", "which", "who", "are", "is", "was", "were", "do", "does", "also", "still", "both", "and", "then", "though"]);
   var FRAME_WORDS = /* @__PURE__ */ new Set(["which", "what", "who", "list", "show", "find", "give", "me", "us", "all"]);
   var entityNoun = (w) => ENTITY_TO_TYPE[w] ? { entityType: ENTITY_TO_TYPE[w], placeholder: false } : PLACEHOLDER_NOUNS.includes(w) ? { entityType: null, placeholder: true } : null;
   var isGerundVerb = (w) => !!VERB_TO_KIND[w] && w.endsWith("ing");
@@ -2291,7 +2334,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) || parseTemporal(w, lc, nlp, 0) || parseAnaphora(w, lc, nlp) || parseAggregate(w, lc, nlp) || parseSuperlative(w, lc, nlp) || parseFind(w, lc, nlp, 0) || parseList(w, lc, nlp, 0) || parseNested(w, lc, nlp, 0) || parseRelationalOrQualified(w, lc, nlp, 0);
+    return parseExistence(w, lc) || parseNegation(text, nlp, 0) || parseForwardNegation(w, lc, nlp) || parseTemporal(w, lc, nlp, 0) || parseAnaphora(w, lc, nlp) || parseAggregate(w, lc, nlp) || parseSuperlative(w, lc, nlp) || parseFind(w, lc, nlp, 0) || parseList(w, lc, nlp, 0) || parseNested(w, lc, nlp, 0) || parseRelationalOrQualified(w, lc, nlp, 0);
   }
   function complementAst(entityType, diffAtom) {
     return {
@@ -2441,6 +2484,9 @@
     return { node: "temporal", inner, entityType: noun && noun.entityType || null };
   }
   function parseAnaphora(w, lc, nlp) {
+    if (lc.length === 2 && lc[0] === "which" && (lc[1] === "ones" || lc[1] === "one")) {
+      return { node: "anaphora", mode: "list", filter: { type: "all" } };
+    }
     let p = -1;
     let viaOf = false;
     for (let i = 1; i < lc.length; i += 1) {
@@ -2477,6 +2523,46 @@
     }
     return void 0;
   }
+  function parseExistence(w, lc) {
+    let i;
+    if (lc[0] === "is" && lc[1] === "there") i = 2;
+    else if (lc[0] === "are" && lc[1] === "there") i = 2;
+    else return null;
+    const article = lc[i];
+    if (article === "a" || article === "an" || article === "any") i += 1;
+    else return null;
+    const noun = i < lc.length ? entityNoun(lc[i]) : null;
+    if (!noun || noun.placeholder || !noun.entityType) return null;
+    const entityType = noun.entityType;
+    i += 1;
+    let rest = lc.slice(i);
+    let restW = w.slice(i);
+    if (rest.length && rest[rest.length - 1] === "anywhere") {
+      rest = rest.slice(0, -1);
+      restW = restW.slice(0, -1);
+    } else if (rest.length >= 2 && rest[rest.length - 2] === "at" && rest[rest.length - 1] === "all") {
+      rest = rest.slice(0, -2);
+      restW = restW.slice(0, -2);
+    }
+    if (!rest.length) return { node: "exists", entityType, term: null, scopeModule: null };
+    if (rest[0] === "called" || rest[0] === "named") {
+      if (rest.length < 2) return { node: "miss", reason: `"${rest[0]}" needs a name afterward` };
+      const inIdx = rest.indexOf("in", 1);
+      if (inIdx > 0) {
+        const term2 = restW.slice(1, inIdx).join(" ").trim();
+        const scopeModule = restW.slice(inIdx + 1).join(" ").trim();
+        if (!term2 || !scopeModule) return { node: "miss", reason: `a named existence check needs both a name and a module after "in"` };
+        return { node: "exists", entityType, term: term2, scopeModule };
+      }
+      const term = restW.slice(1).join(" ").trim();
+      return term ? { node: "exists", entityType, term, scopeModule: null } : { node: "miss", reason: `"${rest[0]}" needs a name afterward` };
+    }
+    if (rest[0] === "in") {
+      const scopeModule = restW.slice(1).join(" ").trim();
+      return scopeModule ? { node: "exists", entityType, term: null, scopeModule } : { node: "miss", reason: `"in" needs a module afterward` };
+    }
+    return null;
+  }
   var AGG_TAIL_FILLER = /* @__PURE__ */ new Set([
     "total",
     "altogether",
@@ -2492,7 +2578,9 @@
     "index",
     "codebase",
     "repo",
-    "repository"
+    "repository",
+    "this",
+    "that"
   ]);
   function parseAggregate(w, lc, nlp) {
     const trig = AGGREGATE_TRIGGERS.find((t) => lc.slice(0, t.split(" ").length).join(" ") === t);
@@ -2524,6 +2612,7 @@
   var LIST_SKIP = /* @__PURE__ */ new Set(["the", "a", "an", "all", "me", "us"]);
   var LIST_TRIGGERS_SORTED = [...LIST_TRIGGERS].sort((a, b) => b.split(" ").length - a.split(" ").length);
   var LISTABLE_KINDS = "functions, classes, methods, modules, attributes, variables, or commits";
+  var SCOPE_PREPOSITIONS = /* @__PURE__ */ new Set(["in", "inside", "under"]);
   function parseList(w, lc, nlp, depth) {
     let i = 0;
     let interrogative = false;
@@ -2560,11 +2649,19 @@
     i += 1;
     const tail = w.slice(i);
     const tailMeaningful = lc.slice(i).some((t) => !STOPWORDS2.has(t) && !AGG_TAIL_FILLER.has(t));
-    if (interrogative && (tailMeaningful || tail.length === 0)) return null;
+    let scopeTailLc = lc.slice(i);
+    let scopeTailWords = tail;
+    if (scopeTailLc[0] === "is" || scopeTailLc[0] === "are") {
+      scopeTailLc = scopeTailLc.slice(1);
+      scopeTailWords = scopeTailWords.slice(1);
+    }
+    const scopedException = interrogative && SCOPE_PREPOSITIONS.has(scopeTailLc[0]);
+    if (interrogative && (tailMeaningful && !scopedException || tail.length === 0)) return null;
     let base;
     let scoped = false;
     if (tailMeaningful) {
-      const setAst = parseSetPhrase(`which ${[...quals, entWord, ...tail].join(" ")}`, nlp, (depth || 0) + 1);
+      const useTail = scopedException ? scopeTailWords : tail;
+      const setAst = parseSetPhrase(`which ${[...quals, entWord, ...useTail].join(" ")}`, nlp, (depth || 0) + 1);
       if (!setAst || setAst.node === "miss") return { node: "miss", reason: setAst && setAst.reason || "the list filter didn't parse" };
       base = setAst;
       scoped = true;
@@ -2709,7 +2806,7 @@
     const noun = i < lc.length ? entityNoun(lc[i]) : null;
     if (!noun) {
       const nextNoun = i + 1 < lc.length ? entityNoun(lc[i + 1]) : null;
-      if ((framed || quals.length) && nextNoun && /^[a-z]+$/.test(lc[i]) && !VERB_TO_KIND[lc[i]] && !STOPWORDS2.has(lc[i])) {
+      if ((framed || quals.length) && nextNoun && /^[a-z]+$/.test(lc[i]) && !VERB_TO_KIND[lc[i]] && !STOPWORDS2.has(lc[i]) && !CASCADE_NOISE_SET.has(lc[i])) {
         return { node: "find", entityType: nextNoun.entityType, term: w[i] };
       }
       return null;
@@ -3139,8 +3236,33 @@
     const winners = scored.filter((s) => s.score === best).map((s) => s.ind);
     return { compositeKind: "superlative", entityType: ast.entityType, metricNoun: ast.metricNoun, extreme: ast.extreme, score: best, matches: winners };
   }
+  function evalExists(graph, ast) {
+    const { entityType, term, scopeModule } = ast;
+    let scopeMatch = null;
+    if (scopeModule) {
+      const r = resolveObject(graph, scopeModule, { expectedClass: "Module" });
+      if (!r.match) return { compositeKind: "exists", entityType, term, scopeModule, scopeMiss: true, matches: [] };
+      scopeMatch = r.match;
+    }
+    if (term) {
+      const r = resolveObject(graph, term, { expectedClass: entityType });
+      const inScope = !scopeMatch || r.match && moduleIdOf2(graph, r.match) === scopeMatch.id;
+      const hit2 = r.match && inScope;
+      return {
+        compositeKind: "exists",
+        entityType,
+        term,
+        scopeModule,
+        scopeMatch,
+        matches: hit2 ? [r.match] : []
+      };
+    }
+    const pool = scopeMatch ? refineToEntities(graph, /* @__PURE__ */ new Set([scopeMatch.id]), entityType) : graph.individuals.filter((i) => i.class === entityType);
+    return { compositeKind: "exists", entityType, term: null, scopeModule, scopeMatch, matches: pool };
+  }
   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 === "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);
@@ -3175,6 +3297,27 @@
       }
       return { content: `couldn't compile this compositional question${result.reason ? ` (${result.reason})` : ""}. ${compositionalHint()}.`, miss: true, ambiguous: false };
     }
+    if (result.compositeKind === "exists") {
+      if (result.scopeMiss) {
+        return { content: `no module matching "${result.scopeModule}" found in the index.`, miss: true, ambiguous: false };
+      }
+      const kindSingular = nounFor(result.entityType, 1);
+      const kindPlural = nounFor(result.entityType, 2);
+      const scopeSuffix = result.scopeMatch ? ` in ${result.scopeMatch.label}` : "";
+      if (result.term) {
+        if (!result.matches.length) {
+          return { content: `No \u2014 no ${kindSingular} named "${result.term}" found${scopeSuffix}.`, miss: true, ambiguous: false };
+        }
+        const hit2 = result.matches[0];
+        const modLabel = moduleLabelOf(hit2);
+        const definedIn = hit2.class === "Module" ? "" : modLabel && modLabel !== "(unknown module)" ? `, defined in ${modLabel}` : "";
+        return { content: `Yes \u2014 ${hit2.label} is a ${kindSingular}${definedIn}.`, miss: false, ambiguous: false, matches: result.matches };
+      }
+      if (!result.matches.length) {
+        return { content: `No \u2014 no ${kindPlural} found${scopeSuffix}.`, miss: true, ambiguous: false };
+      }
+      return { content: `Yes \u2014 ${compositeList(result.matches)}${scopeSuffix}.`, 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: [] };
@@ -3771,7 +3914,8 @@
     }
     if (!result.objMatch && (!result.candidates || result.candidates.length === 0) && parsed.shape !== "ask") {
       const objText = String(parsed.object || "").trim();
-      const what = /^(?:commit[:\s])?[0-9a-f]{7,40}$/i.test(objText) ? "commit" : !objText.includes("/") && /^[\w$]+(\.[\w$]+)+$/.test(objText) ? "symbol" : "module";
+      const fallback = parsed.entityType && PLURAL_FORMS[parsed.entityType] ? nounFor(parsed.entityType, 1) : "module";
+      const what = /^(?:commit[:\s])?[0-9a-f]{7,40}$/i.test(objText) ? "commit" : !objText.includes("/") && /^[\w$]+(\.[\w$]+)+$/.test(objText) ? "symbol" : fallback;
       return {
         content: `no ${what} matching "${parsed.object}" found in the index.`,
         miss: true,

package/src/ask-browser.bundle.version

@@ -1 +1 @@
-0.9.10
+1.0.4