@polycode-projects/seonix 0.10.14 → 0.10.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polycode-projects/seonix",
-  "version": "0.10.14",
+  "version": "0.10.16",
   "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,7 +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",
+    "bench:telemetry": "node bench/run.mjs --suite django-lh --arms seonix --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",

package/src/concept-digest.mjs

@@ -0,0 +1,157 @@
+// concept-digest.mjs — PROTOTYPE, not wired into any product surface (PLAN_CONCEPT_DIGEST.md).
+//
+// Extracts concept words from a task prompt (reusing prose.mjs's two tokenizer primitives, §3.1),
+// then sweeps them type-scoped across the graph for literal file:line hits (§3.2). The
+// ask()-driven ontology sweep (§3.3) and the combined two-section digest (§3.5) are NOT
+// implemented this round — see the TODOs below and PLAN_CONCEPT_DIGEST.md §6/§7.
+//
+// §3.2(b): `identComponents` below is a standalone duplicate of codegraph.mjs's private (non-
+// exported) helper of the same name — pure string manipulation, no graph-shape dependency, so
+// duplicating it carries no correctness risk. `definesIndex`'s edge lookup, by contrast, uses
+// codegraph.mjs's own EXPORTED `edgesOfKind`/`relationKind` machinery directly rather than
+// re-deriving relation classification locally — that classification (PROP_KIND, the mgx/seon
+// alias table) is exactly the kind of thing that must never drift between two copies. Only
+// `matchSymbols`-shaped per-kind scoring (§3.2(a)) is still standalone-duplicated pending the
+// codegraph.mjs refactor PLAN_CONCEPT_DIGEST.md §3.2(a)/§7 phase 2 proposes.
+
+import { splitIdentifierWords, tokenizeProse } from "./prose.mjs";
+import { siteOf, edgesOfKind } from "./codegraph.mjs";
+
+const SYMBOL_CLASSES = { function: "Function", class: "Class", method: "Method", attribute: "Attribute", route: "Route" };
+export const LITERAL_SWEEP_KINDS = ["module", "function", "class", "method", "attribute", "route"];
+
+/** §3.1: the task prompt's concept words. NOT a bare `proseTokensFor({name, doc: promptText})`
+ *  call — proseTokensFor is built for a single SYMBOL name + its doc, and its `name` half
+ *  (splitIdentifierWords) deliberately carries NO stopword filter, because a real identifier
+ *  never contains an English stopword in the first place. A whole task PROMPT is different: it
+ *  mixes ordinary stopword-laden prose with embedded identifiers ("fix Truncator.chars"), so
+ *  feeding the same full prompt text through both proseTokensFor halves re-admits "the"/"and"/
+ *  "its" via the identifier-decomposition path even though tokenizeProse already dropped them
+ *  from the prose path (caught by this file's own test suite, §6 — see the "reuses prose.mjs's
+ *  stopword filter" test). The correct composition: decompose identifiers FIRST
+ *  (splitIdentifierWords, camelCase/snake/dotted boundaries), then run the DECOMPOSED text back
+ *  through tokenizeProse so the stopword filter applies to both origins uniformly, unioned with
+ *  tokenizeProse over the raw prompt (covers plain prose words untouched by decomposition). */
+export function extractConceptWords(promptText) {
+  const prose = tokenizeProse(promptText);
+  const decomposed = tokenizeProse(splitIdentifierWords(promptText).join(" "));
+  return [...new Set([...prose, ...decomposed])].sort();
+}
+
+/** Mirrors codegraph.mjs's private `identComponents` (camelCase/snake_case boundary split) —
+ *  duplicated per the file-header note above, not imported (it is not exported there). */
+function identComponents(name) {
+  return new Set(String(name).replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
+}
+
+/** subject id -> [defined symbol labels], built off codegraph.mjs's own EXPORTED `edgesOfKind`
+ *  (which in turn uses the real `relationKind` classifier — the mgx/seon PROP_KIND alias table
+ *  lives there ONCE; this file must never re-derive it, see the file-header note above). */
+function definesIndex(graph) {
+  const idx = new Map();
+  for (const e of edgesOfKind(graph, "defines")) {
+    if (!idx.has(e.subject)) idx.set(e.subject, []);
+    idx.get(e.subject).push(e.objectLabel || e.object);
+  }
+  return idx;
+}
+
+function siteFileLine(graph, id) {
+  const ind = graph.byId?.get?.(id);
+  const site = ind ? siteOf(ind) : null;
+  return site ? { file: site.path, line: site.start } : { file: null, line: null };
+}
+
+/** One module's combined literal-match text bag: lowercased path components + every defined
+ *  symbol's name components + (when present) its `prose_tokens` attribute — the same "per-module
+ *  combined text" idiom moduleEmbedTexts/definesIndex already use in codegraph.mjs (§3.2). */
+function moduleTextBag(ind, defines) {
+  const bag = new Set();
+  for (const c of String(ind.label).toLowerCase().split(/[^a-z0-9]+/).filter(Boolean)) bag.add(c);
+  for (const d of defines) for (const c of identComponents(d)) bag.add(c);
+  const prose = (ind.attributes || []).find((a) => a.key === "prose_tokens")?.value;
+  if (prose) for (const t of String(prose).split(/\s+/).filter(Boolean)) bag.add(t);
+  return bag;
+}
+
+/** §3.2 module-kind sweep: strict AND over each module's text bag (every concept word must be
+ *  present somewhere in the module), falling back to a coverage-ranked list when the AND-set is
+ *  empty — the same "try strict first, relax only on a genuine miss" shape as tmct's ask()
+ *  relaxation cascade (PLAN_CONCEPT_DIGEST.md §3.2). Never throws, never silently returns
+ *  nothing when SOME module matched at least one word. */
+function sweepModules(graph, conceptWords) {
+  const defIdx = definesIndex(graph);
+  const andHits = [];
+  const coverageHits = [];
+  for (const ind of graph.individuals) {
+    if ((ind.class || "") !== "Module") continue;
+    const defines = defIdx.get(ind.id) || [];
+    const bag = moduleTextBag(ind, defines);
+    const matched = conceptWords.filter((w) => bag.has(w));
+    if (!matched.length) continue;
+    const { file, line } = siteFileLine(graph, ind.id);
+    const hit = {
+      id: ind.id, label: ind.label, kind: "module", file: file || ind.label, line,
+      literalScore: matched.length, literalMatchedWords: matched, ontologyHits: [],
+    };
+    coverageHits.push(hit);
+    if (matched.length === conceptWords.length) andHits.push(hit);
+  }
+  const rank = (a, b) => b.literalScore - a.literalScore || String(a.label).length - String(b.label).length;
+  if (andHits.length) return andHits.sort(rank);
+  return coverageHits.sort(rank);
+}
+
+/** §3.2 symbol-kind sweep (function/class/method/attribute/route): coverage-ranked, NOT AND —
+ *  see PLAN_CONCEPT_DIGEST.md §3.2 for why AND is reserved for the module grain only. Mirrors
+ *  searchSymbols's own coverage-not-AND scoring shape (codegraph.mjs:1622-1656), applied per
+ *  concept word instead of per raw query token. */
+function sweepSymbols(graph, conceptWords, kind) {
+  const targetClass = SYMBOL_CLASSES[kind];
+  if (!targetClass) return [];
+  const hits = [];
+  for (const ind of graph.individuals) {
+    if ((ind.class || "") !== targetClass) continue;
+    const labelLc = String(ind.label).toLowerCase();
+    const comps = identComponents(ind.label);
+    const matched = conceptWords.filter((w) => comps.has(w) || labelLc.includes(w));
+    if (!matched.length) continue;
+    const { file, line } = siteFileLine(graph, ind.id);
+    hits.push({
+      id: ind.id, label: ind.label, kind, file, line,
+      literalScore: matched.length, literalMatchedWords: matched, ontologyHits: [],
+    });
+  }
+  return hits.sort((a, b) => b.literalScore - a.literalScore || String(a.label).length - String(b.label).length);
+}
+
+/** §3.2: the full type-specific literal sweep — module-kind AND (coverage fallback) UNION
+ *  symbol-kind coverage sweeps, one per requested kind. Returns a flat, per-kind-ranked hit list
+ *  (NOT deduped/combined with an ontology sweep — that composition is buildConceptDigest's job,
+ *  §3.5, not yet implemented — see the TODO at the bottom of this file). */
+export function literalSweep(graph, conceptWords, { kinds = LITERAL_SWEEP_KINDS } = {}) {
+  const words = [...new Set(conceptWords)];
+  if (!words.length) return [];
+  const out = [];
+  if (kinds.includes("module")) out.push(...sweepModules(graph, words));
+  for (const kind of kinds) {
+    if (kind === "module" || !SYMBOL_CLASSES[kind]) continue;
+    out.push(...sweepSymbols(graph, words, kind));
+  }
+  return out;
+}
+
+// TODO(concept-digest, ontology sweep — PLAN_CONCEPT_DIGEST.md §3.3/§7 phase 1): sentence-split
+// the prompt + templated subclass/superclass/find probes over extractConceptWords' output, run
+// through makeSeonixProvider(graph).ask(fragment) in-process (never a subprocess — §3.4), map
+// tmct_ask.matches[].id -> siteOf for file:line. Not implemented this round.
+export function ontologySweep(_graph, _promptText, _opts = {}) {
+  throw new Error("concept-digest: ontologySweep is not implemented yet — see PLAN_CONCEPT_DIGEST.md §3.3/§7");
+}
+
+// TODO(concept-digest, combine — PLAN_CONCEPT_DIGEST.md §3.5/§7 phase 1): dedupe literalSweep +
+// ontologySweep by individual id into the two-section {literal, ontology} digest + rendered text.
+// Depends on ontologySweep above; not implemented this round.
+export function buildConceptDigest(_graph, _promptText, _opts = {}) {
+  throw new Error("concept-digest: buildConceptDigest is not implemented yet — see PLAN_CONCEPT_DIGEST.md §3.5/§7");
+}

package/src/extract.mjs

@@ -438,21 +438,35 @@ export function buildEntities(modules, commits, { generatedAt = "", symbolHistor
       }
 
       // symbol-granular calls: caller fn/method → callee fn/class/method. The top-level
-      // function/class registry resolves first, unchanged (exactly ONE in-repo definition —
-      // same unique-name discipline as the module-coarse calls). On a complete miss there,
-      // receiver-typed call texts fall through to the tiered METHOD registry above, so
-      // `_svc.ProcessOrder(...)` reaches `B.ProcessOrder` even though no top-level symbol
-      // carries that name (C#/Java estates have none). Ambiguous / external names are
-      // dropped (honest Group-A). Reuses the per-function call names the extractors parsed.
+      // function/class registry resolves first (exactly ONE in-repo definition — same
+      // unique-name discipline as the module-coarse calls) UNLESS the name is globally
+      // ambiguous but the CALLING module's own imports narrow it to one candidate (a
+      // same-named top-level helper the caller never imported must not block resolution
+      // of the one it did — e.g. two files each define `parseEntities`, only one is
+      // imported by a given caller; mirrors the same-module/imported-tiering already used
+      // for base-class resolution above, minus a same-module tier: two SIBLING top-level
+      // defines of one name, in the SAME module as the caller, stay ambiguous — see
+      // "ambiguous call names are dropped" in test/extract.test.mjs). On a complete
+      // registry miss, receiver-typed call texts fall through to the tiered METHOD
+      // registry above, so `_svc.ProcessOrder(...)` reaches `B.ProcessOrder` even though no
+      // top-level symbol carries that name (C#/Java estates have none). Still-ambiguous /
+      // external names are dropped (honest Group-A). Reuses the per-function call names
+      // the extractors parsed.
       if ((d.kind === "function" || d.kind === "method") && d.calls?.length) {
         for (const callName of d.calls) {
           const ident = lastIdent(callName);
           if (!ident) continue;
           const ids = nameToSymbolIds.get(ident);
           let callee = null;
-          if (ids?.size === 1) callee = [...ids][0];
-          else if (!ids) callee = resolveMethodCallee(callName, ident, m.path); // method fallback on a clean miss only
-          if (!callee) continue; // ambiguous or external → drop
+          if (ids?.size === 1) {
+            callee = [...ids][0];
+          } else if (ids?.size > 1) {
+            const reachable = [...ids].filter((id) => imports.has(id.slice(3, id.lastIndexOf("#"))));
+            if (reachable.length === 1) callee = reachable[0];
+          } else {
+            callee = resolveMethodCallee(callName, ident, m.path); // method fallback on a clean miss only
+          }
+          if (!callee) continue; // still ambiguous or external → drop
           if (callee === oid) continue; // self-recursion not an edge
           const ckey = `${oid}>${callee}`;
           if (seenCallSymbol.has(ckey)) continue;