@polycode-projects/the-mechanical-code-talker 2.10.3 → 2.10.5

package/src/services/chat-page-viz.mjs

@@ -30,6 +30,7 @@
 // exist (both built earlier in that same script, for the embedded widget).
 import { THEME_TOKENS_CSS, SERIF_STACK, MONO_STACK, escapeHtml } from "./viz-theme.mjs";
 import { provBucketFor } from "./ledger-viz.mjs";
+import { sessionLogTimeOfDay, sessionLogHeaderMarkdown, sessionLogTurnMarkdown } from "./session-log-format.mjs";
 
 const DEFAULT_TITLE = "the-mechanical-code-talker — talk to it";
 
@@ -115,25 +116,37 @@ export function loadProgressLine(parts) {
 }
 
 /**
- * The exported transcript as one Markdown document: a title line naming the
- * site version and the export date, then every turn in order as
- * "**you:** ..." / "**tmct:** ...", with the provenance tier in parentheses
- * when the turn carried one. Reads the page's transcript MODEL (an array of
- * { role, text, chipTier }), never the DOM — the message column may
- * virtualize long chats someday, and an export must still carry every turn.
+ * The exported transcript as ONE Markdown document, in the SAME shape the
+ * Node CLI/TUI's own .tmct/session-<id>.md writes (session-log-format.mjs,
+ * spliced in beside this function below): a title naming the version and a
+ * short session id, one heading per turn at millisecond time-of-day
+ * precision, the question as a verbatim blockquote, the answer in a fenced
+ * block. No closing session-end line — unlike a CLI session's close(), an
+ * export can happen mid-conversation, before anything has actually ended.
  *
- * Self-contained (no outer refs), `.toString()`-splice safe — the same
- * discipline provenanceChipFor/loadProgressLine above hold.
+ * Reads the page's transcript MODEL (an array alternating { role: "you" |
+ * "tmct", text, chipTier, ts }, one entry per submit and per settled
+ * reply), never the DOM — the message column may virtualize long chats
+ * someday, and an export must still carry every turn.
+ *
+ * `headerMd`/`turnMd` are the injected session-log-format.mjs builders
+ * (spliced in as their own consts alongside this function) — injected
+ * rather than imported so this function stays `.toString()`-splice safe,
+ * the same discipline provenanceChipFor's injected `bucketFor` holds.
  */
-export function transcriptMarkdown(turns, meta) {
+export function transcriptMarkdown(turns, meta, headerMd, turnMd) {
   const version = (meta && meta.version) || "dev";
-  const date = (meta && meta.date) || "";
-  const lines = ["# tmct chat — v" + version + (date ? " — " + date : ""), ""];
-  for (const turn of turns || []) {
-    const tier = turn.chipTier ? " (" + turn.chipTier + ")" : "";
-    lines.push("**" + turn.role + ":** " + turn.text + tier, "");
+  const sessionId = (meta && meta.sessionId) || "";
+  const list = turns || [];
+  let doc = headerMd({ version: version, sessionId: sessionId, startedAt: list.length ? list[0].ts : Date.now() });
+  let turnNumber = 0;
+  for (let i = 0; i < list.length; i += 1) {
+    if (list[i].role !== "you") continue;
+    turnNumber += 1;
+    const reply = list[i + 1] && list[i + 1].role === "tmct" ? list[i + 1] : null;
+    doc += turnMd({ startedAt: list[i].ts, turnNumber: turnNumber, query: list[i].text, answer: reply ? reply.text : "" });
   }
-  return lines.join("\n");
+  return doc;
 }
 
 /** The self-contained "talk to it" full-screen page. Pure — the same output
@@ -304,12 +317,14 @@ ${THEME_TOKENS_CSS}
         <button type="submit" id="composerSend" aria-label="Send" disabled>&#8594;</button>
       </div>
       <div class="composer-tools">
-        <label class="liveLabel" title="Off by default. When on, a question nothing local can answer also asks en.wikipedia.org — two small requests per lookup, and the answer is cited (CC BY-SA).">
+        <label class="liveLabel" title="Off by default. When on, a question nothing local can answer also asks en.wikipedia.org — two small requests per lookup, and the answer is cited (CC BY-SA). Type /wiki supplement to also add a cited Wikipedia read-out under every grounded answer.">
           <input type="checkbox" id="liveToggle" role="switch" aria-label="ask Wikipedia when I don't know">
           <span class="toggle-track" aria-hidden="true"><span class="toggle-knob"></span></span>
           <span>ask Wikipedia when I don&#8217;t know</span>
         </label>
         <span class="tool-cluster">
+          <button type="button" id="ingestFile" class="tool-btn" title="load a .txt/.md file and teach every fact it recognizes into this session">ingest file</button>
+          <input type="file" id="ingestInput" accept=".txt,.md,text/plain,text/markdown" hidden>
           <button type="button" id="exportMd" class="tool-btn" title="download this conversation as Markdown">export .md</button>
           <button type="button" id="exportFacts" class="tool-btn" title="download this session's facts as JSONL (the tmct extract shape, provenance included)">export facts</button>
           <button type="button" id="printChat" class="tool-btn" title="print the whole conversation">print</button>
@@ -329,6 +344,9 @@ ${THEME_TOKENS_CSS}
   const provBucketFor = ${provBucketFor.toString()};
   const provenanceChipFor = ${provenanceChipFor.toString()};
   const loadProgressLine = ${loadProgressLine.toString()};
+  const sessionLogTimeOfDay = ${sessionLogTimeOfDay.toString()};
+  const sessionLogHeaderMarkdown = ${sessionLogHeaderMarkdown.toString()};
+  const sessionLogTurnMarkdown = ${sessionLogTurnMarkdown.toString()};
   const transcriptMarkdown = ${transcriptMarkdown.toString()};
   const el = (id) => document.getElementById(id);
 
@@ -763,8 +781,14 @@ ${THEME_TOKENS_CSS}
     window.tmctChatSession.turn(q)
       .then((result) => {
         settleAssistantBubble(pendingRow, result.answer, result.record);
-        if (result.record && result.record.via === "assert") scheduleSave();
-        return renderStatsPanel(); // a teach turn just grew this session's memory; a plain ask leaves it unchanged either way
+        // Persist on ANY store write, not just a teach turn: a learn-on-miss
+        // load (a child pack, a reference or live-Wikipedia article) and its
+        // auto-synthesis also append facts, and those were lost on reload when
+        // only via==="assert" saved. Commands write nothing, so they stay out.
+        // The save is debounced, so a read-through that changed nothing costs
+        // at most one coalesced write.
+        if (result.record && result.record.via !== "command") scheduleSave();
+        return renderStatsPanel(); // a teach or learned-load turn grew this session's memory; a plain ask leaves it unchanged either way
       })
       .catch((err) => settleAssistantBubble(pendingRow,
         "something went wrong answering that (" + (err && err.message ? err.message : err) + ") \\u2014 try rephrasing",
@@ -791,7 +815,8 @@ ${THEME_TOKENS_CSS}
   // @media print stylesheet above to un-pin the message column so every
   // turn reaches paper.
   el("exportMd").addEventListener("click", () => {
-    const md = transcriptMarkdown(transcript, { version: siteVersion, date: new Date(Date.now()).toISOString().slice(0, 10) });
+    const sessionId = (window.tmctChatSession && window.tmctChatSession.sessionId) || "";
+    const md = transcriptMarkdown(transcript, { version: siteVersion, sessionId: sessionId }, sessionLogHeaderMarkdown, sessionLogTurnMarkdown);
     const blob = new Blob([md], { type: "text/markdown" });
     const url = URL.createObjectURL(blob);
     const link = document.createElement("a");
@@ -829,6 +854,49 @@ ${THEME_TOKENS_CSS}
     setTimeout(() => URL.revokeObjectURL(url), 1000);
   });
 
+  // "ingest file" feeds a whole .txt/.md through the SAME session, one
+  // sentence at a time (window.tmctChat.splitSentences, then session.turn),
+  // teaching every sentence the recognizer grounds and skipping the rest
+  // honestly — the same pipeline the ingest page runs, reaching the chat's own
+  // memory so the taught facts answer questions straight away.
+  el("ingestFile").addEventListener("click", () => el("ingestInput").click());
+  el("ingestInput").addEventListener("change", async (e) => {
+    const file = e.target.files && e.target.files[0];
+    e.target.value = "";
+    const session = window.tmctChatSession;
+    if (!file || busy || !session || !window.tmctChat.splitSentences) return;
+    let text;
+    try {
+      text = await file.text();
+    } catch (err) {
+      addSystemLine("couldn't read that file (" + (err && err.message ? err.message : err) + ").");
+      return;
+    }
+    const sentences = window.tmctChat.splitSentences(text);
+    if (!sentences.length) { addSystemLine("nothing to ingest in " + file.name + "."); return; }
+    setBusy(true);
+    statusEl.textContent = "ingesting " + file.name + "\\u2026";
+    let grounded = 0;
+    try {
+      for (const sentence of sentences) {
+        const result = await session.turn(sentence);
+        if (result.record && result.record.via === "assert" && !result.record.miss) grounded += 1;
+      }
+    } catch (err) {
+      addSystemLine("something went wrong ingesting " + file.name + " (" + (err && err.message ? err.message : err) + ").");
+    }
+    if (grounded) scheduleSave();
+    const skipped = sentences.length - grounded;
+    addSystemLine("ingested " + file.name + " \\u2014 " + sentences.length + " sentence"
+      + (sentences.length === 1 ? "" : "s") + " read, " + grounded + " fact"
+      + (grounded === 1 ? "" : "s") + " added"
+      + (skipped ? ", " + skipped + " skipped (not a recognized fact shape)" : "") + ".");
+    await renderStatsPanel();
+    renderStatus();
+    setBusy(false);
+    inputEl.focus();
+  });
+
   // "reset to seed" is the full re-initialisation: drop the persisted payload
   // outright and reload, so boot re-seeds from the page's shipped seed as if on
   // a first visit. Harder than "forget everything", which only swaps the live

package/src/services/chat-session.mjs

@@ -28,6 +28,7 @@ import * as defaultSource from "../adapters/source.mjs";
 import { resolveExtensions, mergedLexiconExtra } from "./extensions.mjs";
 import { runTurn, hasSeededVocabulary, vocabExampleHint } from "./chat.mjs";
 import { resolveGameConfig } from "../domain/game-config.mjs";
+import { sessionLogHeaderMarkdown, sessionLogTurnMarkdown, sessionLogEndMarkdown } from "./session-log-format.mjs";
 
 /** Where session logs live, relative to the target repo. `.tmct/` is the repo's
  *  one artifact directory (gitignored, machine-local) — flip this single constant
@@ -243,7 +244,7 @@ export async function createSession({
   const sessionsDir = join(repo, SESSIONS_DIR_REL);
   await mkdir(logDir, { recursive: true });
   await mkdir(sessionsDir, { recursive: true });
-  const logFile = join(logDir, `session-${sessionId}.log`);
+  const logFile = join(logDir, `session-${sessionId}.md`);
   const sidecarFile = join(sessionsDir, `session-${sessionId}.jsonl`);
   const stream = createWriteStream(logFile, { flags: "a" });
   const sidecar = createWriteStream(sidecarFile, { flags: "a" });
@@ -255,7 +256,7 @@ export async function createSession({
   const writeSidecar = (obj) => flush(sidecar, JSON.stringify(obj) + "\n");
 
   const startIso = new Date().toISOString();
-  await writeLog(`# tmct chat ${version} — session started ${startIso} — repo ${repo}\n\n`);
+  await writeLog(sessionLogHeaderMarkdown({ version, sessionId, startedAt: startIso, repo }));
   await writeSidecar({ type: "session", id: sessionId, started: startIso, repo, tmctVersion: version });
 
   // Read-time graph upsert (sessions.mjs): after every turn, the session becomes /
@@ -363,14 +364,14 @@ export async function createSession({
       } catch (e) {
         const ts = new Date().toISOString();
         const message = e instanceof Error ? e.message : String(e);
-        await writeLog(`${ts}\n> ${line}\nerror: ${message}\n`);
+        await writeLog(sessionLogTurnMarkdown({ startedAt: ts, turnNumber: turns + 1, query: line, answer: `error: ${message}` }));
         const errorRecord = { type: "error", ts, query: line, error: message };
         await writeSidecar(errorRecord);
         turnRecords.push(errorRecord);
         turns += 1;
         return { answer: `Something went wrong answering that (${message}). Try rephrasing, or /help.`, end: false, prompt: promptFor(focus) };
       }
-      const { answer, logLines, record, focus: nextFocus, last: nextLast, end, narrate: nextNarrate, liveReference: nextLiveReference } = result;
+      const { answer, record, focus: nextFocus, last: nextLast, end, narrate: nextNarrate, liveReference: nextLiveReference } = result;
       focus = nextFocus;
       last = nextLast;
       if ("planState" in result) planState = result.planState;
@@ -378,8 +379,10 @@ export async function createSession({
       // same way a focus update does — apply them to this handle's
       // session-scoped state.
       if (typeof nextNarrate === "boolean") narrateOn = nextNarrate;
-      if (typeof nextLiveReference === "boolean") liveReferenceOn = nextLiveReference;
-      await writeLog(logLines.join("\n") + "\n");
+      // tri-state: false (off), true (rescue on a miss), or "supplement" (also
+      // append a cited read-out under every grounded answer).
+      if (typeof nextLiveReference === "boolean" || nextLiveReference === "supplement") liveReferenceOn = nextLiveReference;
+      await writeLog(sessionLogTurnMarkdown({ startedAt: record.ts, turnNumber: turns + 1, query: line, answer }));
       await writeSidecar(record);
       turnRecords.push(record);
       // One telemetry line per dispatched turn (OFF by default → no-op). query.raw is
@@ -401,7 +404,9 @@ export async function createSession({
       if (closed) return;
       closed = true;
       const endIso = new Date().toISOString();
-      await writeLog(`${endIso}\n> /exit\nsession end ${endIso}\n`);
+      const closingTurnNumber = turns + 1;
+      await writeLog(sessionLogTurnMarkdown({ startedAt: endIso, turnNumber: closingTurnNumber, query: "/exit", answer: "" }));
+      await writeLog(sessionLogEndMarkdown({ endedAt: endIso, turnCount: closingTurnNumber }));
       await writeSidecar({ type: "end", ts: endIso });
       await upsertGraph(endIso);
       await new Promise((resolve) => stream.end(resolve));