@polycode-projects/the-mechanical-code-talker 4.0.1 → 4.1.1

package/src/surfaces/web/ledger-browser-entry.mjs

@@ -16,9 +16,8 @@
 // class as chat/spider-fly/adventure/plan's own browser bundles) and is
 // never published — only the hosted demo site's public/ledger.html links to
 // it, as an optional sibling script the page degrades honestly without.
-import { runTurn, vocabExampleHint } from "../../services/chat.mjs";
-import { createInMemoryStore, normFactTerm, loadMemory } from "../../adapters/memory/core.mjs";
-import { serializeFactsJsonl } from "../../adapters/memory/export-jsonl.mjs";
+import { vocabExampleHint } from "../../services/chat.mjs";
+import { createInMemoryStore, normFactTerm, applySeedPayload } from "../../adapters/memory/core.mjs";
 import { splitSentencesPreservingPaths } from "../../services/sentences.mjs";
 import { parseEntities } from "../../domain/codegraph.mjs";
 import { loadLexicon } from "../../domain/grammar/lexicon.mjs";
@@ -26,6 +25,10 @@ import { registerWinkModel } from "../../adapters/wink-model.mjs";
 import { registerResearchProvider } from "../../adapters/corpus/wikipedia-live.mjs";
 import { computeLedgerDataFromPayload } from "../../services/ledger-viz.mjs";
 import { digestTermFromPayloadBrowser } from "./digest-client.mjs";
+import { createTurnSession } from "./turn-session.mjs";
+import { exportFactsJsonl } from "./memory-stats.mjs";
+import { publishTmctSurface } from "./tmct-surface.mjs";
+import { graphAsk, enginePlan } from "./engine-surface.mjs";
 
 /**
  * A browser ledger-dock session over the real turn engine — createChatSession's
@@ -34,7 +37,7 @@ import { digestTermFromPayloadBrowser } from "./digest-client.mjs";
  * a fact taught through the dock extends the SAME graph the page renders
  * from, never a disconnected one.
  *
- * Returns { memoryDir, sessionId, turn }, identical to createChatSession.
+ * Returns { memoryDir, sessionId, graph, turn }, identical to createChatSession.
  * ledger-viz.mjs's own inline script calls computeLedgerDataFromPayload
  * (re-exported below) on `memoryDir.payload` after a turn whose record shows
  * a successful write (`via: "assert"` or `via: "retract"`, `miss: false`) to
@@ -43,63 +46,28 @@ import { digestTermFromPayloadBrowser } from "./digest-client.mjs";
  */
 export function createLedgerSession({ seedPayload = null, vocabSeeded = false } = {}) {
   const memoryDir = createInMemoryStore();
-  // Spread onto the store's own empty payload so a partial seed still
-  // carries the classes/prefixes scaffolding the write path recounts —
-  // teach turns must work regardless of what the seed payload carries.
-  if (seedPayload) memoryDir.payload = { ...memoryDir.payload, ...seedPayload };
+  applySeedPayload(memoryDir, seedPayload);
 
   const graph = parseEntities({ individuals: [], objectProperties: [] });
   const lexicon = loadLexicon();
   const vocabHint = vocabExampleHint(vocabSeeded);
   const sessionId = globalThis.crypto?.randomUUID?.() ?? String(Date.now());
 
-  let focus = null;
-  let last = null;
-  let planState = null;
-  let researchState = null;
-
-  return {
-    memoryDir,
-    sessionId,
-
-    /** One dispatched turn. A throwing runTurn must never kill the session —
-     *  the page has no other chance to show this turn's answer. */
-    async turn(line) {
-      let result;
-      try {
-        result = await runTurn(line, {
-          config: null, source: null, graph, focus, last, memoryDir, sessionId,
-          env: {}, lexicon, vocabHint, planState, researchState,
-        });
-      } catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        return { answer: `Something went wrong answering that (${message}). Try rephrasing, or /help.`, end: false, record: null, research: null };
-      }
-      focus = result.focus;
-      last = result.last;
-      if ("planState" in result) planState = result.planState;
-      if ("researchState" in result) researchState = result.researchState;
-      // `research` distinguishes a queue snapshot (research turn) from null
-      // (a research turn that ended the run) from undefined (not a research
-      // turn) — the dock's controls only react to the first two.
-      return { answer: result.answer, end: Boolean(result.end), record: result.record ?? null, research: result.research };
-    },
-  };
-}
-
-/** The session's whole triple store as JSONL — the same
- *  { subject, predicate, object, provenance } shape `tmct extract` and
- *  `tmct memory --export` emit. The ledger dock's "export facts" control reads
- *  this and offers it as a download. */
-export async function exportFactsJsonl(memoryDir) {
-  return serializeFactsJsonl(await loadMemory(memoryDir));
+  const session = createTurnSession({ memoryDir, graph, lexicon, sessionId, vocabHint });
+  return { memoryDir, sessionId, graph, turn: session.turn };
 }
 
-// Re-exported so ledger-viz.mjs's own inline script never has to duplicate
-// the derivation logic that builds rows/terms/edges/contradictions/
-// worthALook/stats from a payload — the same posture chat-browser-entry.mjs
-// takes re-exporting registerWinkModel for its own page's CDN wink load.
-// splitSentences + exportFactsJsonl carry the dock's paste-and-drop ingest and
-// its JSONL export across the bundle boundary, the same one-serializer posture
-// chat-browser-entry.mjs holds for its own page.
-globalThis.tmctLedger = { createLedgerSession, computeLedgerDataFromPayload, normFactTerm, registerWinkModel, registerResearchProvider, splitSentences: splitSentencesPreservingPaths, exportFactsJsonl, digestTermFromPayloadBrowser };
+// `tmct.page` keeps what the page's own script renders with and the engine has
+// no plain-English form for: the payload-to-rows/terms/edges/stats derivation
+// the ledger view re-mounts from after a successful teach, the digest reader,
+// the wink and research seams, and the two serializers behind the dock's
+// paste-ingest and JSONL export.
+publishTmctSurface({
+  open: createLedgerSession,
+  ask: graphAsk,
+  plan: enginePlan,
+  page: {
+    computeLedgerDataFromPayload, normFactTerm, registerWinkModel, registerResearchProvider,
+    splitSentences: splitSentencesPreservingPaths, exportFactsJsonl, digestTermFromPayloadBrowser,
+  },
+});

package/src/surfaces/web/memory-ask-browser-entry.mjs

@@ -1,20 +1,62 @@
 // memory-ask-browser-entry.mjs — the esbuild entry for the ledger page's
 // chat dock (`tmct viz`, src/services/ledger-viz.mjs).
 //
-// Re-exports `factAnswer` (src/services/chat.mjs) and `createInMemoryStore`
-// (src/adapters/memory/core.mjs), which lets the dock hand `factAnswer` the page's
-// already-embedded payload with zero fs I/O. Called with `envelope: null,
-// miss: true` to arm factAnswer's bare-question regex fallbacks directly,
-// bypassing the structural-graph parse pipeline this dock has no use for.
+// The one COMMITTED browser bundle: `tmct viz` is a real CLI command run
+// against a user's own local .tmct store, so this ships with the package. It
+// deliberately carries the question lanes only (factAnswer/factReadBack) and
+// not the full turn engine — see ledger-browser-entry.mjs's header for the
+// contrast with the demo site's own 1.5MB dock.
+//
+// It publishes the SAME `globalThis.tmct` every other page does, through
+// tmct-surface.mjs, which imports nothing — so this bundle gets the shared
+// contract without the tool layer or the capability router coming with it.
+// `tmct.turn` and `tmct.plan` are unwired here and say so: this dock asks
+// questions, it does not hold a conversation or plan anything.
 import { factAnswer, factReadBack } from "../../services/chat.mjs";
 import { createInMemoryStore, normFactTerm } from "../../adapters/memory/core.mjs";
 import { digestTermFromPayloadBrowser } from "./digest-client.mjs";
+import { publishTmctSurface } from "./tmct-surface.mjs";
+
+/** A question-only session over a payload the page already embeds — no fs I/O,
+ *  no turn engine. Returns `{ memoryDir }`. */
+export function createMemoryAskSession({ payload = null } = {}) {
+  const memoryDir = createInMemoryStore();
+  if (payload) memoryDir.payload = payload;
+  return { memoryDir };
+}
+
+/**
+ * One question, answered from the page's own embedded store. Runs the same
+ * cascade `runAsk` runs — factAnswer first, then factReadBack, which is where
+ * the taught-relation chases live ("who is the grandfather of ishmael") that
+ * factAnswer's own lanes don't reach.
+ *
+ * Both are called with `envelope: null, miss: true`, which arms factAnswer's
+ * bare-question fallbacks directly and skips the structural-graph parse
+ * pipeline this dock has no use for.
+ *
+ * Returns `{ answer, data, miss }`. `data` is the reader's own result, so a
+ * caller still sees the inferred `goal` line it computed on the way.
+ */
+export async function askMemory(request, options, session) {
+  let fact = null;
+  try { fact = await factAnswer(session.memoryDir, request, null, true, {}); } catch { fact = null; }
+  if (!(fact && fact.text)) {
+    try { fact = await factReadBack(session.memoryDir, request, null, true, null); } catch { fact = null; }
+  }
+  if (!(fact && fact.text)) return { answer: null, data: null, miss: true };
+  return { answer: fact.text, data: fact, miss: false };
+}
 
-// normFactTerm is re-exported too, for the page's client-side term normalization.
-// factReadBack carries the taught-relation chases (grandfather-style questions)
-// that factAnswer's own lanes don't reach.
-// digestTermFromPayloadBrowser lets the CLI `tmct viz` page read a refocused
-// term back as a digest client-side, from the structure table the page embeds —
-// the same narrative the demo ledger's live bundle produces, over the same
-// static store this page already carries.
-globalThis.tmctMemoryAsk = { factAnswer, factReadBack, createInMemoryStore, normFactTerm, digestTermFromPayloadBrowser };
+// `tmct.page` keeps the term normalizer the dock refocuses the ledger with,
+// and the client-side digest reader — the narrative the demo ledger's live
+// bundle produces, over the static structure table this page embeds.
+// `fallback`, because the demo ledger page carries this bundle AND the full
+// turn engine at once: this one answers where it is alone, and steps aside
+// wherever the live dock is loaded, whichever order the two arrive in.
+publishTmctSurface({
+  open: createMemoryAskSession,
+  ask: askMemory,
+  page: { normFactTerm, digestTermFromPayloadBrowser },
+  fallback: true,
+});