npm - @polycode-projects/the-mechanical-code-talker - Versions diffs - 5.0.6 → 5.0.7 - Mend

@polycode-projects/the-mechanical-code-talker 5.0.6 → 5.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (38) hide show

package/README.md +6 -0
package/bin/tmct.mjs +63 -2
package/package.json +1 -1
package/src/adapters/memory/core.mjs +23 -0
package/src/domain/ask-vocab.mjs +19 -0
package/src/domain/ask.mjs +8 -1
package/src/domain/interpret/strategies/keywords.mjs +30 -1
package/src/domain/memory/capability.mjs +15 -11
package/src/domain/router/drive.mjs +36 -17
package/src/domain/router/resolver.mjs +63 -17
package/src/domain/spider-fly-world.mjs +2 -2
package/src/domain/sprite-templates.mjs +19 -7
package/src/domain/syllogise.mjs +16 -6
package/src/domain/town-square-world.mjs +1 -1
package/src/services/adventure.mjs +8 -1
package/src/services/chat-page-viz.mjs +118 -23
package/src/services/chat-session.mjs +60 -10
package/src/services/chat.mjs +228 -24
package/src/services/extract-facts.mjs +47 -7
package/src/services/ingest-viz.mjs +108 -25
package/src/services/ledger-viz.mjs +4 -2
package/src/services/memory-panel-viz.mjs +44 -0
package/src/services/mud-viz.mjs +17 -0
package/src/services/mudiii-scene.mjs +271 -24
package/src/services/mudiii-turn.mjs +65 -9
package/src/services/mudiii-viz.mjs +302 -125
package/src/services/plan-viz.mjs +23 -2
package/src/services/predator-prey.mjs +82 -33
package/src/services/research-viz.mjs +12 -19
package/src/services/spider-fly-turn.mjs +7 -1
package/src/services/spider-fly-viz.mjs +10 -3
package/src/services/viz-ticker.mjs +15 -2
package/src/surfaces/http/server-http.mjs +90 -13
package/src/surfaces/web/memory-ask-browser.bundle.js +125 -125
package/src/surfaces/web/mud-browser-entry.mjs +33 -1
package/src/surfaces/web/tmct-surface.mjs +18 -6
package/src/tools/handlers/tmct-ask.mjs +15 -2
package/src/tools/server.mjs +31 -2

package/src/services/ingest-viz.mjs CHANGED Viewed

@@ -31,6 +31,7 @@ import {
   statsSummaryLine,
   clearSiteAssetCaches,
   fetchWithProgress,
+  loadSeedPayload,
   renderStatsPanelInto,
   loadProgressLine,
   factTripleParts,
@@ -43,7 +44,7 @@ const DEFAULT_TITLE = "the-mechanical-code-talker — ingest";
 /** The self-contained ingest page. Pure — the same output for the same
  *  `title` every time; every piece of state (the session, each grounded fact)
  *  is computed live in the browser once the sibling ingest bundle loads. */
-export function renderIngestHtml({ title = DEFAULT_TITLE, seedStamp = "" } = {}) {
+export function renderIngestHtml({ title = DEFAULT_TITLE, seedStamp = "", seedBytes = 0 } = {}) {
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -84,6 +85,14 @@ ${THEME_TOKENS_CSS}
   .topbar-right { display: flex; align-items: center; gap: .7rem; }
   .fact-pill { display: inline-flex; align-items: baseline; gap: .34rem; font-family: ${MONO_STACK}; font-size: .66rem; letter-spacing: .06em; text-transform: uppercase; color: var(--muted); border: 1px solid var(--corpus-t1); border-radius: 99px; padding: .2rem .8rem; background: var(--corpus-soft); white-space: nowrap; }
   .fact-pill .fact-pill-value { font-size: .94rem; letter-spacing: 0; font-variant-numeric: tabular-nums; font-weight: 600; color: var(--ink); }
+  /* While the starter memory streams in, the pill says so and breathes — the
+     same three-state pill chat.html carries, for the same reason: what this
+     page knows grows while you watch it. */
+  .fact-pill[data-state="loading"] { animation: pill-breathe 1.6s ease-in-out infinite; }
+  .fact-pill[data-state="loading"] .fact-pill-value { font-size: .66rem; letter-spacing: .06em; text-transform: uppercase; font-weight: 600; }
+  .fact-pill[data-state="failed"] { border-color: var(--miss-t1, var(--corpus-t1)); }
+  @keyframes pill-breathe { 0%, 100% { opacity: 1; } 50% { opacity: .55; } }
+  @media (prefers-reduced-motion: reduce) { .fact-pill[data-state="loading"] { animation: none; } }
   /* mode pills — Text | Document — the translate-tool idiom: two segments in
      one rounded track, the active one filled. */
@@ -186,9 +195,9 @@ ${THEME_TOKENS_CSS}
         <h1 class="subtitle">ingest &mdash; paste or drop text. It keeps the facts it can ground and skips the rest.</h1>
       </div>
       <div class="topbar-right">
-        <span class="fact-pill" id="factPill" aria-live="polite"
+        <span class="fact-pill" id="factPill" aria-live="polite" data-state="loading"
           title="every fact this page's memory holds right now — the starter memory it booted with plus everything it has grounded since">
-          <span class="fact-pill-value" id="factPillValue">&mdash;</span> facts in memory
+          <span class="fact-pill-value" id="factPillValue">loading</span><span id="factPillUnit"> starter memory&hellip;</span>
         </span>
         <div class="pills" role="group" aria-label="Input mode">
           <button type="button" id="modeText" aria-pressed="true">Text</button>
@@ -254,6 +263,7 @@ ${THEME_TOKENS_CSS}
   const statsSummaryLine = ${statsSummaryLine.toString()};
   const clearSiteAssetCaches = ${clearSiteAssetCaches.toString()};
   const fetchWithProgress = ${fetchWithProgress.toString()};
+  const loadSeedPayload = ${loadSeedPayload.toString()};
   const renderStatsPanelInto = ${renderStatsPanelInto.toString()};
   const el = (id) => document.getElementById(id);
@@ -275,7 +285,9 @@ ${THEME_TOKENS_CSS}
   const seedToggleEl = el("seedToggle");
   const fuzzyToggleEl = el("fuzzyToggle");
   const statsPanelEl = el("statsPanel");
+  const factPillEl = el("factPill");
   const factPillValueEl = el("factPillValue");
+  const factPillUnitEl = el("factPillUnit");
   const askFormEl = el("askForm");
   const askInputEl = el("askq");
   const askGoBtn = el("askGo");
@@ -470,7 +482,8 @@ ${THEME_TOKENS_CSS}
       try { stats = await window.tmct.page.memoryStats(session.memoryDir); }
       catch { return; }
     }
-    factPillValueEl.textContent = Number(stats.total || 0).toLocaleString();
+    lastStatsTotal = Number(stats.total || 0);
+    renderFactPill();
     renderStatsPanelInto(statsPanelEl, stats, {
       bandLabel: bandLabelFor,
       taughtHint: "nothing yet. Ingest some text and its grounded facts land here, with their source.",
@@ -496,6 +509,12 @@ ${THEME_TOKENS_CSS}
   // ever return the copy this page asked for. Empty in a build with no seed.
   const SEED_STAMP = ${JSON.stringify(seedStamp)};
   const SEED_QUERY = SEED_STAMP ? "?b=" + SEED_STAMP : "";
+  // The builder's own measurement of chat-seed.json, in decompressed bytes.
+  // The response cannot supply this: over a compressed transfer Content-Length
+  // is the wire size while the stream yields decompressed bytes, so the two
+  // are not the same quantity. Both numbers in the percentage below are
+  // decompressed bytes, which is what makes it a real fraction.
+  const SEED_BYTES = ${Number(seedBytes) || 0};
   let seedPayload = null;
   let seedFacts = 0;
@@ -509,29 +528,89 @@ ${THEME_TOKENS_CSS}
   // The one branch this page's seed choice makes: checked, fetch and parse
   // the same chat-seed.json chat.html embeds; unchecked, skip the request
   // outright and stay on the previous empty-store fast path.
-  //
-  // One retry with a cache-busting query param: a CDN edge can serve a
-  // corrupted or truncated precompressed response (a transient bad cache
-  // entry, not a code defect — real bytes decompress fine, and the same URL
-  // fetched moments later is clean), and JSON.parse throwing is the only
-  // signal of that. The bust param forces a fresh fetch past that one entry.
+  let seedLoadedBytes = 0;
+  let seedTotalBytes = SEED_BYTES;
+  let seedPercentShown = -1;
+  let lastStatsTotal = null;
+  /**
+   * What the starter memory is doing right now, published as tmct.seed —
+   * loading, indexing, ready, failed, or skipped when the seed toggle is off.
+   * The same five phases chat.html publishes, for the same reasons: the pill
+   * can say the memory is still growing, and a test that asserts on seeded
+   * content can wait for "ready" instead of guessing.
+   */
+  function setSeedPhase(phase, extra) {
+    window.tmct.seed = Object.assign({ state: phase, facts: seedFacts }, extra || {});
+    renderFactPill();
+  }
+  setSeedPhase("loading");
+  function noteSeedBytes(loaded, total) {
+    seedLoadedBytes = loaded;
+    seedTotalBytes = total;
+    const percent = seedProgressPercent();
+    if (percent === seedPercentShown) return;
+    seedPercentShown = percent;
+    renderFactPill();
+  }
+  /** Real progress, 0-100, or null when no true total is known — the pill then
+   *  shows that it is loading and no number, never a figure inferred from how
+   *  long it has been going. */
+  function seedProgressPercent() {
+    if (!(seedTotalBytes > 0)) return null;
+    return Math.min(100, Math.floor((seedLoadedBytes / seedTotalBytes) * 100));
+  }
+  function renderFactPill() {
+    const seedState = window.tmct.seed ? window.tmct.seed.state : "loading";
+    if (seedState === "loading") {
+      const percent = seedProgressPercent();
+      factPillEl.dataset.state = "loading";
+      factPillValueEl.textContent = percent === null ? "loading" : percent + "%";
+      factPillUnitEl.textContent = percent === null ? " starter memory\\u2026" : " of starter memory";
+      return;
+    }
+    // "ready" lands a moment before the first memoryStats read returns, and
+    // there is no count to show until it does. Holding the indexing words over
+    // that gap keeps the pill from flashing a zero it does not mean.
+    if (seedState === "indexing" || (seedState === "ready" && lastStatsTotal === null)) {
+      factPillEl.dataset.state = "loading";
+      factPillValueEl.textContent = "indexing";
+      factPillUnitEl.textContent = " " + seedFacts.toLocaleString() + " facts\\u2026";
+      return;
+    }
+    if (seedState === "failed" && lastStatsTotal === null) {
+      factPillEl.dataset.state = "failed";
+      factPillValueEl.textContent = "no";
+      factPillUnitEl.textContent = " starter memory";
+      return;
+    }
+    factPillEl.dataset.state = seedState === "failed" ? "failed" : "ready";
+    factPillValueEl.textContent = Number(lastStatsTotal || 0).toLocaleString();
+    factPillUnitEl.textContent = " facts in memory";
+  }
   async function fetchSeedIfWanted() {
-    if (!seedToggleEl.checked) { seedPayload = null; seedFacts = 0; return; }
-    for (let attempt = 1; attempt <= 2; attempt++) {
-      try {
-        const bust = attempt === 1 ? "" : (SEED_QUERY ? "&" : "?") + "retry=1";
-        const blob = await fetchWithProgress("./chat-seed.json" + SEED_QUERY + bust, (loaded, total) => noteProgress("seed", loaded, total));
-        seedPayload = JSON.parse(await blob.text());
-        seedFacts = (seedPayload.individuals || []).filter((i) => i.class === "Fact").length;
-        return;
-      } catch (err) {
-        if (attempt === 2) {
-          seedPayload = null;
-          seedFacts = 0;
-          console.warn("tmct ingest: chat-seed.json unavailable — starting unseeded", err);
-        }
-      }
+    if (!seedToggleEl.checked) {
+      seedPayload = null;
+      seedFacts = 0;
+      setSeedPhase("skipped");
+      return;
+    }
+    const outcome = await loadSeedPayload(fetchWithProgress, "./chat-seed.json", SEED_QUERY, (loaded, total) => {
+      noteProgress("seed", loaded, total || SEED_BYTES);
+      noteSeedBytes(loaded, total || SEED_BYTES);
+    });
+    seedPayload = outcome.payload;
+    seedFacts = outcome.status.facts;
+    if (outcome.status.state === "failed") {
+      console.error("tmct ingest: chat-seed.json unavailable — starting unseeded (" + outcome.status.error + ")");
+      setSeedPhase("failed", { error: outcome.status.error, attempts: outcome.status.attempts });
+      return;
     }
+    setSeedPhase("indexing", { attempts: outcome.status.attempts });
   }
   const cloneMemoryPayload = ${cloneMemoryPayload.toString()};
   async function newSession() {
@@ -610,6 +689,7 @@ ${THEME_TOKENS_CSS}
     session = await newSession();
     clearFactsPane();
     askLogEl.textContent = "";
+    if (window.tmct.seed.state === "indexing") setSeedPhase("ready");
     const stats = await window.tmct.page.memoryStats(session.memoryDir);
     statusEl.textContent = statsSummaryLine(stats, bandLabelFor) + ". Ready.";
     await renderStatsPanel(stats);
@@ -640,6 +720,9 @@ ${THEME_TOKENS_CSS}
     setMode(false);
     updateIngestEnabled();
     updateAskEnabled();
+    // The session holds the seed now, so the phase settles here rather than
+    // when the bytes landed: "ready" means queryable.
+    if (window.tmct.seed.state === "indexing") setSeedPhase("ready");
     const stats = await window.tmct.page.memoryStats(session.memoryDir);
     const winkPart = winkStatus === "loaded"
       ? "wink-nlp: loaded"

package/src/services/ledger-viz.mjs CHANGED Viewed

@@ -1237,7 +1237,9 @@ ${ledgerBundleAvailable ? `<script src="./ledger-browser.bundle.js"></script>` :
             // hold it), and resolveAnsweredTerm has no way to tell that
             // apart from the term genuinely being discussed.
             const hit = resolveAnsweredTerm(result.answer, q, LEDGER.terms, tmct.page.normFactTerm);
-            if (hit) refocusWithLabel(hit, q);
+            // No label: the breadcrumb falls back to the term itself
+            // (c.label || c.term) rather than showing the whole question.
+            if (hit) refocusWithLabel(hit);
           }
         } catch {
           pending.className = "a miss";
@@ -1440,7 +1442,7 @@ ${ledgerBundleAvailable ? `<script src="./ledger-browser.bundle.js"></script>` :
           // full-stop-terminated, rendered only when the engine deduced one.
           if (data && data.goal) addLine("a goal", "Goal (inferred): " + esc(data.goal.charAt(0).toUpperCase() + data.goal.slice(1)) + ".");
           const hit = resolveAnsweredTerm(answer, q, LEDGER.terms, tmct.page.normFactTerm);
-          if (hit) refocusWithLabel(hit, q);
+          if (hit) refocusWithLabel(hit);
         } else {
           const tips = LEDGER.terms.filter((t) => t.term.length >= 3).slice(0, 2)
             .map((t) => '"what is ' + esc(t.term) + '"').join(" \\u00b7 ");

package/src/services/memory-panel-viz.mjs CHANGED Viewed

@@ -104,6 +104,50 @@ export async function fetchWithProgress(url, onProgress) {
   return new Blob(chunks);
 }
+/**
+ * Fetch and parse the starter-memory seed, and say what actually happened.
+ *
+ * Resolves to `{ payload, status }` and never rejects. `payload` is the parsed
+ * seed, or null. `status` is the small, payload-free record a page publishes
+ * as `tmct.seed` and a test reads back:
+ *
+ *   { state: "loaded", facts, attempts }
+ *   { state: "failed", facts: 0, attempts, error }
+ *
+ * The record exists because a seed that failed to download and a store that is
+ * empty on purpose both leave the fact count at zero, and until now nothing
+ * downstream could tell them apart — not the page, which went on answering as
+ * a normal empty chat, and not a test, which could only report the zero. A
+ * page that cannot ground an answer must be able to say WHY it cannot, and
+ * that starts with knowing.
+ *
+ * It resolves rather than throwing because a failed seed is not a failed boot:
+ * you can still teach the page facts of your own. Boot carries on, and the
+ * caller decides what to show.
+ *
+ * Two attempts, the second under a cache-busting query param: a CDN edge can
+ * serve a corrupt, truncated or wrongly-encoded response, and a throw out of
+ * the read or the parse is the only signal of that. `seedQuery` already
+ * carries the build's own content-hash query string, if any, so the bust param
+ * joins with `&` or `?` accordingly.
+ */
+export async function loadSeedPayload(fetcher, url, seedQuery, onProgress) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= 2; attempt++) {
+    try {
+      const bust = attempt === 1 ? "" : (seedQuery ? "&" : "?") + "retry=1";
+      const blob = await fetcher(url + seedQuery + bust, onProgress);
+      const payload = JSON.parse(await blob.text());
+      const facts = (payload.individuals || []).filter((i) => i.class === "Fact").length;
+      return { payload, status: { state: "loaded", facts, attempts: attempt } };
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  const reason = lastError && lastError.message ? lastError.message : String(lastError);
+  return { payload: null, status: { state: "failed", facts: 0, attempts: 2, error: reason } };
+}
 /**
  * (Re)render the docked "this session's memory" panel into `panelEl` from a
  * memoryStats() result: a total-facts row, one row per seed band the session

package/src/services/mud-viz.mjs CHANGED Viewed

@@ -406,6 +406,7 @@ ${MUD_SHARE_SKIN}
     <section class="deck" aria-label="simulation controls">
       <div class="deck-controls">
         <button type="button" class="deck-play" id="autoToggle" aria-pressed="false">&#9654; play</button>
+        <button type="button" id="stepBtn">step</button>
         <button type="button" id="resetBtn">reset</button>
 ${scenarioList.length > 1 ? `        <select id="scenarioSelect" class="deck-select" aria-label="which burrow to play">
 ${scenarioList.map((s, i) => `          <option value="${i}"${i === 0 ? " selected" : ""}>${escapeHtml(s.label || scenarioLabel(s.worldPayload?.name))}</option>`).join("\n")}
@@ -2092,6 +2093,7 @@ function pageScript() {
   // that could start one is disabled for as long as the editor is open.
   function setPlayControlsEnabled(on) {
     el("autoToggle").disabled = !on;
+    el("stepBtn").disabled = !on || autoOn;
     el("playerCountSlider").disabled = !on;
     el("resetBtn").disabled = !on;
     for (const character of cast) {
@@ -2889,6 +2891,7 @@ function pageScript() {
   function wireDeck() {
     const playBtn = el("autoToggle");
+    const stepBtn = el("stepBtn");
     const delaySlider = el("delaySlider");
     const maxTurnsSlider = el("maxTurnsSlider");
     const playerCountSlider = el("playerCountSlider");
@@ -2898,6 +2901,7 @@ function pageScript() {
       autoOn = !autoOn;
       playBtn.setAttribute("aria-pressed", autoOn ? "true" : "false");
       playBtn.textContent = autoOn ? "\\u23F8 pause" : "\\u25B6 play";
+      stepBtn.disabled = autoOn;
       // Every animal in the world, pane or none: the deck's play control is the
       // world running, and an npc has no other control that could start it.
       for (const character of everyone()) {
@@ -2906,6 +2910,19 @@ function pageScript() {
         if (autoOn) ticker.play(); else ticker.pause();
       }
     });
+    // One whole turn: every animal in the world (pane or none, same "everyone"
+    // the play toggle above drives) takes exactly one tick, so every pane's own
+    // "turn N" reading is one higher once every stepOnce() below has settled.
+    // Each character keeps its own independent tick count (mud has no single
+    // shared "round" the way adventure/spider-fly's one-ticker world does), so
+    // stepping the whole deck is stepping every one of those counters once,
+    // not advancing one shared counter by one.
+    stepBtn.addEventListener("click", function () {
+      if (!session || autoOn) return;
+      stepBtn.disabled = true;
+      const steps = everyone().map(function (character) { return ensureTicker(character).stepOnce(); });
+      Promise.all(steps).finally(function () { stepBtn.disabled = autoOn; });
+    });
     delaySlider.addEventListener("input", function () {
       delayMs = Number(delaySlider.value);
       el("delayValue").textContent = delayMs + "ms";