@polycode-projects/seonix 0.7.3 → 0.8.0

package/src/chat-shim.mjs

@@ -0,0 +1,37 @@
+// chat-shim.mjs — `seonix chat` is now tmct's chat over seonix's graph.
+//
+// PLAN_CHAT_EXTRACTION.md, the inversion: the conversational surface belongs to tmct
+// (@polycode-projects/the-mechanical-code-talker). seonix stops running its own REPL and
+// launches tmct's, handing it graph truth through tmct's provider seam. seonix's on-disk
+// graph is interned v2, which tmct cannot read raw, so we expand it first (seonix's own
+// parseEntities does the same). The old opt-in --with-claude/--with-copilot fallback does
+// not port: tmct is no-LLM by contract.
+import { runChat } from "@polycode-projects/the-mechanical-code-talker/chat";
+import { registerProvider } from "@polycode-projects/the-mechanical-code-talker/fetchEntities";
+import { join } from "node:path";
+import { expandGraphPayload } from "./graph-format.mjs";
+import { fetchEntities } from "./source.mjs";
+import { loadConfig, DEFAULT_GRAPH_REL } from "./config.mjs";
+
+/** The seonix graph config for a repo (mirrors cli.mjs's configFor): an explicit
+ *  --repo dir points at its .seonix/graph.json; otherwise the loaded (cwd) config. */
+function seonixConfigFor(repoPath) {
+  return repoPath ? { graphFile: join(repoPath, DEFAULT_GRAPH_REL) } : loadConfig();
+}
+
+/**
+ * Run tmct's chat over seonix's native graph. Registers the (expanded) seonix graph as
+ * tmct's in-process data provider, runs the REPL, then clears the provider so nothing
+ * leaks across calls (important for tests and repeated invocations).
+ * @param {{repoPath?: string, input?: NodeJS.ReadableStream, output?: NodeJS.WritableStream,
+ *          env?: object, cwd?: string, gitRoot?: Function}} [opts]
+ */
+export async function runSeonixChat({ repoPath, input, output, env, cwd, gitRoot } = {}) {
+  const payload = expandGraphPayload(await fetchEntities(seonixConfigFor(repoPath)));
+  registerProvider(() => payload);
+  try {
+    return await runChat({ repoPath, input, output, env, cwd, gitRoot });
+  } finally {
+    registerProvider(null);
+  }
+}

package/src/server.mjs

@@ -51,7 +51,7 @@ import {
   renderMethodHistory,
   renderClassHistory,
 } from "./codegraph.mjs";
-import { ask } from "./ask.mjs";
+import { makeSeonixProvider } from "./tmct-provider.mjs";
 
 const SNIPPET_MAX_LINES = 200;
 
@@ -367,11 +367,11 @@ export async function dispatchTool(name, args, { config, source = defaultSource
     const query = String(args?.query || "").trim();
     if (!query) throw new ToolError("query is required");
     const graph = await loadGraph(config, source);
-    const { content, seonix_ask } = ask(graph, query);
-    // Every dispatchTool caller (this MCP handler, the CLI fallback) expects a plain string —
-    // append the structured envelope as a delimited, machine-parseable block rather than
-    // changing that shared contract for one tool. PLAN_MECHANICAL_CHAT.md §6.2.
-    return `${content}\n\n---seonix_ask---\n${JSON.stringify(seonix_ask, null, 2)}`;
+    // The NL engine is tmct's now (PLAN_CHAT_EXTRACTION.md, the inversion): resolve through tmct's
+    // Repository Interface over seonix's graph. The `---seonix_ask---` delimited envelope is preserved
+    // so every dispatchTool caller (this MCP handler, the CLI fallback) is unchanged.
+    const { content, tmct_ask } = makeSeonixProvider(graph, { sourceAccess: false }).ask(query).value;
+    return `${content}\n\n---seonix_ask---\n${JSON.stringify(tmct_ask, null, 2)}`;
   }
   if (
     name === "seonix_tests_for" || name === "seonix_history" || name === "seonix_callers" ||

package/src/tmct-provider.mjs

@@ -0,0 +1,37 @@
+// tmct-provider.mjs — seonix as a tmct Repository-Interface provider.
+//
+// The inversion (PLAN_CHAT_EXTRACTION.md; tmct's PLAN_REPOSITORY_INTERFACE.md):
+// tmct owns the natural-language interpreter, and seonix hands it graph truth
+// through tmct's typed Repository Interface. seonix's parseEntities() result is
+// byte-identical in shape to tmct's, so tmct's createGraphService consumes it
+// directly. The only seonix-specific step is expanding the interned v2 on-disk
+// graph — which parseEntities already does (via graph-format's expandGraphPayload),
+// and tmct cannot read raw.
+//
+// Graph-only by default: sourceAccess=false, so snippet/context honestly answer
+// miss(NO_SOURCE). A caller with a working tree passes sourceAccess (and, later,
+// a source layer) to serve real bodies.
+import { createGraphService } from "@polycode-projects/the-mechanical-code-talker/graph-service";
+import { parseEntities } from "./codegraph.mjs";
+import { fetchEntities } from "./source.mjs";
+
+/**
+ * Wrap an already-parsed seonix graph (a parseEntities() result) as a tmct
+ * Repository-Interface service object.
+ * @param {object} graph  a parseEntities() result ({ individuals, byId, relations, … })
+ * @param {{sourceAccess?: boolean}} [opts]
+ */
+export function makeSeonixProvider(graph, { sourceAccess = false } = {}) {
+  return createGraphService(graph, { sourceAccess });
+}
+
+/**
+ * Load a seonix graph from a config ({ graphFile } or a registered provider) and
+ * wrap it as a tmct service. parseEntities expands the interned v2 payload.
+ * @param {object} config  a seonix config ({ graphFile })
+ * @param {{sourceAccess?: boolean}} [opts]
+ */
+export async function loadSeonixProvider(config, { sourceAccess = false } = {}) {
+  const graph = parseEntities(await fetchEntities(config));
+  return makeSeonixProvider(graph, { sourceAccess });
+}

package/src/viz.mjs

@@ -26,7 +26,8 @@ import { loadConfig } from "./config.mjs";
 import * as source from "./source.mjs";
 import { buildTemporalGraph, buildBrowserData, gitCommitOrder, gitCommitParents, renderBrowserHtml } from "./browser.mjs";
 import { extractTimeline, renderTimelineHtml } from "./timeline.mjs";
-import { winkBrowserBundle } from "./nlp-bundle.mjs";
+// The wink lemma tier is gone (PLAN_CHAT_EXTRACTION.md Stage 6): the ask panel runs tmct's engine
+// adapter-less, so there is no ~4 MB browser model to build. `--nlp` is now a no-op.
 
 // Portable single-file gate: above this serialized graph size, embedding the
 // full raw graph inline yields an unopenable multi-hundred-MB HTML, so the
@@ -189,17 +190,11 @@ export async function cytoscapeSource() {
  *  render logic. `export`/`import` lines stripped so the three files run as one
  *  plain <script> block; nothing here diverges from the node-tested source. */
 async function askSource() {
-  const [codegraph, vocab, ask] = await Promise.all(
-    ["codegraph.mjs", "ask-vocab.mjs", "ask.mjs"].map((f) => readFile(join(here, f), "utf8")),
-  );
-  // Non-greedy up to the closing `";` (not `$`-anchored): ask.mjs's own import spans
-  // multiple lines (a multi-name destructure), which a single-line `^...$` pattern
-  // silently leaves in place — and unlike a stray declaration, a surviving `import`
-  // is a hard SyntaxError in a classic (non-module) inlined <script>, not a quiet bug.
-  const strip = (src) => src
-    .replace(/^import\s[\s\S]*?from\s+"[^"]+";\s*$/gm, "")
-    .replace(/^export (?=(function|const|async function))/gm, "");
-  return [strip(codegraph), strip(vocab), strip(ask)].join("\n");
+  // The panel's mechanical NL engine is tmct's, prebuilt by scripts/build-ask-bundle.mjs into an
+  // IIFE (src/ask-browser.bundle.js) that registers globalThis.ask / parseEntities. We inline it
+  // verbatim into the viewer page (PLAN_CHAT_EXTRACTION.md, the tmct inversion). It runs adapter-less
+  // in the browser, so the old ~4 MB wink lemma bundle is gone. Regenerate: `npm run build:ask-bundle`.
+  return readFile(join(here, "ask-browser.bundle.js"), "utf8");
 }
 
 /** JSON safe to sit inside a <script> block (no </script> or comment-open breakouts). */
@@ -875,9 +870,9 @@ export async function runVizCli(argv) {
   });
   const cytoscape = await cytoscapeSource();
   const askEngine = await askSource();
-  // Build the wink lemma bundle once, only when --nlp asked for it (~4 MB; skip the
-  // work entirely otherwise). Wired below as a sibling asset (site) or inline (portable).
-  const nlpBundle = values.nlp ? await winkBrowserBundle() : null;
+  // The wink lemma tier was removed in Stage 6 (the panel runs tmct's engine adapter-less), so there
+  // is never a bundle to wire. `--nlp` is accepted but inert; the downstream null-guards no-op.
+  const nlpBundle = null;
   if (values.serve) {
     await startVizServer({ values, cytoscape, askEngine, nlpBundle, log: (s) => process.stderr.write(s) });
     return; // keeps serving until Ctrl-C

package/src/ask-nlp.mjs

@@ -1,73 +0,0 @@
-// ask-nlp.mjs — the OPTIONAL wink-nlp adapter behind ask.mjs's lemma/POS tier.
-//
-// BOUNDARY (hard, do not move): this file is Node-only and is NEVER inlined into
-// the viewer bundle. viz.mjs's askSource() inlines codegraph.mjs + ask-vocab.mjs +
-// ask.mjs ONLY and strips their import lines, so the portable single-file HTML has
-// no wink, no model, and no `nlpAdapter` binding at all — ask.mjs reaches this
-// module exclusively through a `typeof nlpAdapter === "function"` guard and
-// degrades to adapter-less parsing (lemma/POS tiers off; the curated tables and
-// the bounded edit-distance tier still work, browser and Node alike). Keeping the
-// ~1MB CJS model out of the page is the point of the split.
-//
-// wink-nlp and wink-eng-lite-web-model are CJS — loaded via createRequire, the
-// same Node-module-resolution approach viz.mjs uses to locate cytoscape (resolve
-// through the module system, never a guessed path). The require happens lazily on
-// first use and failure is cached as null: a checkout without the optional deps
-// installed answers exactly like the browser bundle, it never throws.
-
-import { createRequire } from "node:module";
-
-let cached; // undefined = not tried yet; null = unavailable (tried once, honestly off)
-
-/** Lazily build the {lemma, posTags} adapter, or null when wink isn't loadable.
- *  Deterministic: wink-nlp's tagger/lemmatiser is a fixed model with no sampling,
- *  so the same input always yields the same tags/lemmas across processes. */
-export function nlpAdapter() {
-  if (cached !== undefined) return cached;
-  try {
-    const require = createRequire(import.meta.url);
-    const winkNLP = require("wink-nlp");
-    const model = require("wink-eng-lite-web-model");
-    const nlp = winkNLP(model);
-    const its = nlp.its;
-    cached = {
-      /** Lowercase lemma of a single token ("imported" -> "import"); the word
-       *  itself when wink has nothing better (unknown words come back as-is). */
-      lemma(word) {
-        const w = String(word || "");
-        try {
-          const out = nlp.readDoc(w).tokens().out(its.lemma);
-          return String(out[0] || w).toLowerCase();
-        } catch {
-          return w.toLowerCase();
-        }
-      },
-      /** UPOS tags aligned to the CALLER's word array. wink re-tokenizes (it
-       *  splits "walk.mjs" into three tokens), so each input word is greedily
-       *  matched to the run of wink tokens that spell it and takes its FIRST
-       *  sub-token's tag; null per word on any surprise, never a throw. */
-      posTags(words) {
-        try {
-          const toks = nlp.readDoc(words.join(" ")).tokens();
-          const texts = toks.out();
-          const tags = toks.out(its.pos);
-          const out = [];
-          let k = 0;
-          for (const w of words) {
-            if (k >= texts.length) { out.push(null); continue; }
-            out.push(tags[k]);
-            let acc = texts[k];
-            k += 1;
-            while (acc.length < w.length && k < texts.length) { acc += texts[k]; k += 1; }
-          }
-          return out;
-        } catch {
-          return words.map(() => null);
-        }
-      },
-    };
-  } catch {
-    cached = null;
-  }
-  return cached;
-}