samagotchi 0.56.0 → 0.57.0

data/lib/samagotchi/web/public/app.js

@@ -66,6 +66,7 @@ import {
 } from "./timing.js";
 import { createLiveTurn } from "./live_turn.js";
 import { installRefClicks, setRefKinds } from "./refs.js";
+import { linkRefs, touchedFiles } from "./ref_scan.js";
 import { DONE_MS, applyInitEvent, dropDone, initRowHtml, newInitTasks, seedInitTasks } from "./init_row.js";
 import { isReportClient, hookNoticeLabel, llmContextNotice, newClientId, noticeLine, promptOps, snapshotEvents, workerGoneText } from "./turn_events.js";
 import { applyConfirm, drawCommandBubble, keptCommandBubbles, restoreCommandBubbles } from "./commands.js";
@@ -837,6 +838,7 @@ function renderHistory(items) {
   }
   if (typeof items[0] === "object" && items[0].role) {
     historyEl.replaceChildren(turnHistoryNodes(items, current.timing, { thumbs: (images) => thumbsHtml(selected, images) }));
+    linkTextRefs();
   } else {
     historyEl.innerHTML = items.map((c) => `<div class="bubble output">${escapeHtml(c)}</div>`).join("");
   }
@@ -901,20 +903,34 @@ async function readTurnEnd() {
   } catch(_){}
 }
 
+// The turn's answer as its rendered markdown, once it is final (the
+// turn-end read, an answer_display re-read); then its refs.
 function applyFinalMarkdown(messages) {
   const message = [...messages].reverse().find(
     (item) => item?.role === "assistant" && typeof item.html === "string",
   );
-  if (!message) return;
-
-  const bubble = findInTurnRoots(".bubble.output")
+  const bubble = message && findInTurnRoots(".bubble.output")
     .reverse()
     .find((item) => showsAnswer(item, message, normalize));
-  if (!bubble) return;
-
-  bubble.classList.add("markdown");
-  bubble.setAttribute(COPY_SOURCE_ATTR, copySource(message));
-  bubble.innerHTML = message.html;
+  if (bubble) {
+    bubble.classList.add("markdown");
+    bubble.setAttribute(COPY_SOURCE_ATTR, copySource(message));
+    bubble.innerHTML = message.html;
+  }
+  linkTextRefs();
+}
+
+// The `path:line` refs in the answers' and closed steps' texts that name a
+// file the session's rows (and cards) touched, on this page (ref_scan.js).
+// Not mid-stream: at a turn's end and after a reload's render. A ref
+// already made stays as it is.
+function linkTextRefs() {
+  const roots = turnRoots();
+  const touched = touchedFiles(roots);
+  if (!touched.size) return;
+  for (const root of roots) {
+    for (const el of root.querySelectorAll(".bubble.output, .gen:not(.live) > .gen-text")) linkRefs(el, touched, current.dir);
+  }
 }
 
 function seedSeenFromDom() {

data/lib/samagotchi/web/public/index.html

@@ -178,6 +178,17 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 .activity-diff>summary{cursor:pointer;font-size:12px;color:var(--text-muted);width:max-content;font-variant-numeric:tabular-nums}
 .activity-diff>summary:hover{color:var(--text-2)}
 .activity-diff[open]>summary{margin-bottom:4px}
+/* A read of the file as-is: its numbered lines, closed under the preview (read_view.js); open, they stand for it. */
+.activity-read{flex:1 1 100%;min-width:0;margin:2px 0 2px var(--row-gutter)}
+.activity-read>summary{cursor:pointer;font-size:12px;color:var(--text-muted);width:max-content;font-variant-numeric:tabular-nums}
+.activity-read>summary:hover{color:var(--text-2)}
+.activity-read[open]>summary{margin-bottom:4px}
+.activity-row:has(>.activity-read[open])>.activity-output{display:none}
+.read-lines{margin:0;padding:4px 0;background:var(--bg-inset);border:1px solid var(--border);border-radius:6px;font-size:12px;line-height:1.45;overflow:auto;max-height:420px}
+.read-lines code{display:block;min-width:max-content}
+.read-line{display:block;padding:0 10px 0 0;white-space:pre;color:var(--text-2)}
+.read-line::before{content:attr(data-line);display:inline-block;width:5ch;margin-right:10px;padding-right:6px;text-align:right;color:var(--text-faint);user-select:none;font-variant-numeric:tabular-nums}
+.read-meta{color:var(--text-faint)}
 /* An execute/task_create's full command, above its output and lined up with it: as written, its own scroll. */
 .activity-row>.activity-command{flex:1 1 100%;min-width:0;margin:4px 0 2px var(--row-gutter)}
 .activity-command pre{margin:0;max-height:160px;overflow:auto;white-space:pre-wrap;word-break:break-word;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;font-size:12px;line-height:1.45;color:var(--text-2);background:var(--bg-inset);border:1px solid var(--border);border-radius:6px;padding:6px 34px 6px 8px}
@@ -215,6 +226,7 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
   .activity-params{flex:1 1 0}
   .activity-output{margin-left:0}
   .activity-diff{margin-left:0}
+  .activity-read{margin-left:0}
   .activity-edit{margin-left:0}
   .activity-row>.activity-command{margin-left:0}
 }
@@ -371,8 +383,10 @@ button.task-stop:hover:not(:disabled){background:var(--danger-bg-dim);filter:non
 /* Refs (refs.js): text until hovered, and only for a kind this viewer has an action for (body.refs-file). */
 .refs-file .ref[data-ref-kind="file"]:hover{color:var(--accent);text-decoration:underline dotted;text-underline-offset:3px;cursor:pointer}
 .refs-file .ref[data-ref-kind="file"]:hover::after{content:"\2197";margin-left:.3em;color:var(--text-faint);display:inline-block}
-.refs-file .activity-row:has(.ref[data-ref-kind="file"]) .diff-line[data-line]:hover{cursor:pointer;box-shadow:inset 2px 0 var(--accent)}
-.refs-file .activity-row:has(.ref[data-ref-kind="file"]) .diff-line[data-line]:hover::after{content:"\2197  " attr(data-line);float:right;padding-left:12px;color:var(--text-faint)}
+.refs-file :is(.activity-row,.bubble.approval):has(.ref[data-ref-kind="file"]) .diff-line[data-line]:hover{cursor:pointer;box-shadow:inset 2px 0 var(--accent)}
+.refs-file :is(.activity-row,.bubble.approval):has(.ref[data-ref-kind="file"]) .diff-line[data-line]:hover::after{content:"\2197  " attr(data-line);float:right;padding-left:12px;color:var(--text-faint)}
+.refs-file .activity-row:has(.ref[data-ref-kind="file"]) .read-line[data-line]:hover{cursor:pointer;box-shadow:inset 2px 0 var(--accent)}
+.refs-file .activity-row:has(.ref[data-ref-kind="file"]) .read-line[data-line]:hover::before{color:var(--accent)}
 .diff-add{background:var(--diff-add-bg);color:var(--diff-add-text)}
 .diff-del{background:var(--diff-del-bg);color:var(--diff-del-text)}
 .diff-hunk{color:var(--text-faint)}

data/lib/samagotchi/web/public/question_card.js

@@ -49,9 +49,10 @@ export function relayView(pq) {
   };
 }
 
-// @return {null | {tool, what, isCommand, where, why, preview?, delegate?}};
-// preview is an edit/write's dry-run diff (diff_view.js draws it); delegate
-// is relayView's, for a delegate's approval
+// @return {null | {tool, what, isCommand, where, why, paths?, preview?, delegate?}};
+// paths are what +what+ joins when it shows paths (the card draws a ref
+// for each); preview is an edit/write's dry-run diff (diff_view.js draws
+// it); delegate is relayView's, for a delegate's approval
 export function approvalView(pq) {
   if (!isApproval(pq)) return null;
   const a = pq.approval || {};
@@ -74,6 +75,7 @@ export function approvalView(pq) {
     // A tool without a command or path (an MCP tool): its compact args.
     what: command || paths.join("\n") || a.args || "",
     isCommand: !!command,
+    ...(!command && paths.length ? { paths } : {}),
     where,
     why: `${reason} (${who})`,
     ...(a.preview && typeof a.preview === "object" ? { preview: a.preview } : {}),

data/lib/samagotchi/web/public/question_cards.js

@@ -254,7 +254,8 @@ export function createQuestionCards({
       const what = doc.createElement("pre");
       what.className = view.isCommand ? "approval-what command" : "approval-what paths";
       const code = doc.createElement("code");
-      code.textContent = view.what;
+      if (view.paths) appendPathRefs(code, view.paths);
+      else code.textContent = view.what;
       what.appendChild(code);
       box.appendChild(what);
     }
@@ -279,6 +280,25 @@ export function createQuestionCards({
     return box;
   }
 
+  // One file ref per path, a line each (refs.js: the card's path opens
+  // the current file at the dry run's first change). A directory (a
+  // plugin's path ending in /) stays plain text.
+  function appendPathRefs(code, paths) {
+    paths.forEach((path, i) => {
+      if (i) code.appendChild(doc.createTextNode("\n"));
+      if (String(path).endsWith("/")) {
+        code.appendChild(doc.createTextNode(String(path)));
+        return;
+      }
+      const ref = doc.createElement("span");
+      ref.className = "ref";
+      ref.dataset.refKind = "file";
+      ref.dataset.refPath = String(path);
+      ref.textContent = String(path);
+      code.appendChild(ref);
+    });
+  }
+
   // "Waiting for approval in parent ab12: answering here works too", or
   // an empty (hidden) line while the question isn't relayed.
   function renderRelayedTo(pq) {

data/lib/samagotchi/web/public/read_view.js

@@ -0,0 +1,74 @@
+// A read row's output as the file's lines, numbered, apart from the DOM.
+// Only when the output is the file text as-is: each numbered line is a
+// ref's line (refs.js opens the row's file there). The row's preview
+// (turn_html.js) strips any "[tag] " and cuts at 300 chars; numbering
+// needs the text exactly as read, so it is drawn on its own, closed.
+
+import { escapeHtml } from "./format.js";
+
+// What follows one of these isn't the file's next line: a ToolRunner cap
+// ("[cut: …]"), a head/tail preview's gap ("[... omitted …]") or the note
+// of a range clamped at the end of the file ("[read: end_line …]"). They
+// are appended at the end (a clamp note, then a cut), so only the last
+// MARKER_LINES lines can be one: such a line earlier is the file's own.
+const MARKER_LINES = 2;
+const MARKER = /^(?:\[cut: |\[\.\.\. omitted |\[read: end_line \d+ exceeds )/;
+
+// An image's line instead of its text: attached, or why not (ToolRunner).
+const IMAGE = /\((?:\d+×\d+ )?[A-Z]+\)(?: attached\.| is an image; | is not attached: )/;
+
+// The file text of a read row's output, or null when it isn't the file
+// as-is: an error, the head/tail preview of a big file, an image's line.
+function fileText(row) {
+  if (row?.tool !== "read" || row.status !== "ok" || row.ref?.kind !== "file" || row.images?.length) return null;
+  let text = String(row.output || "");
+  // The call the gate replaced says so on a line before the tag.
+  if (text.startsWith("ran as: ")) text = text.slice(text.indexOf("\n") + 1);
+  if (!text.startsWith("[read]\n")) return null;
+  text = text.slice("[read]\n".length);
+  if (!text || text.startsWith("Error: ") || text.startsWith("truncated=true\n")) return null;
+  if (!text.includes("\n") && IMAGE.test(text)) return null;
+  return text;
+}
+
+// @return {null | Array<{text, line}>} the output's lines, line null for
+// one that isn't the file's: a marker and all after it, and the "…" of a
+// reload's capped output (output_truncated; a cut line already says so
+// for a live one). The first line is the range's start_line (the ref's
+// line), else 1.
+export function readLines(row) {
+  const text = fileText(row);
+  if (text === null) return null;
+  const lines = text.split("\n");
+  // The file's last newline ends a line, it doesn't start one.
+  if (lines.at(-1) === "") lines.pop();
+  let next = Number(row.ref.line) || 1;
+  let numbering = true;
+  const out = [];
+  lines.forEach((line, i) => {
+    if (numbering && i >= lines.length - MARKER_LINES && MARKER.test(line)) {
+      numbering = false;
+      // The newline before a marker is the marker's: the blank it leaves
+      // isn't a line of the file.
+      if (i > 0 && lines[i - 1] === "" && out.at(-1)?.line !== null) out.pop();
+    }
+    out.push({ text: line, line: numbering ? next++ : null });
+  });
+  if (row.output_truncated && numbering) out.push({ text: "…", line: null });
+  return out;
+}
+
+// A read row's numbered lines behind a closed toggle ("lines 40–60"); ""
+// when its output isn't the file as-is.
+export function readLinesHtml(row) {
+  const lines = readLines(row);
+  const numbered = lines?.filter((l) => l.line !== null) || [];
+  if (!numbered.length) return "";
+  const first = numbered[0].line;
+  const last = numbered.at(-1).line;
+  const label = first === last ? `line ${first}` : `lines ${first}–${last}`;
+  const spans = lines.map(({ text, line }) => line === null
+    ? `<span class="read-line read-meta">${escapeHtml(text)}</span>`
+    : `<span class="read-line" data-line="${line}">${escapeHtml(text) || " "}</span>`).join("");
+  return `<details class="activity-read"><summary>${label}</summary><pre class="read-lines"><code>${spans}</code></pre></details>`;
+}

data/lib/samagotchi/web/public/ref_scan.js

@@ -0,0 +1,206 @@
+// `path:line` refs in an answer's or a step's text (traceable refs P3).
+// A name becomes a file ref (refs.js: span.ref with data-ref-kind="file")
+// only when it names a file the session's rows touched (their refs): the
+// answer's text is unchanged, it resolves on the page, and nothing the
+// session didn't touch gets linked. The scan is github-pr's LineLinker
+// (bundles/github-pr/plugin.rb) on the DOM: pre, links and fenced blocks
+// are left alone, inline code only when it is the ref alone, a bare URL's
+// text too.
+
+import { refAttrs } from "./refs.js";
+
+// A path (no spaces), a line, an optional end line and an optional column
+// (kept in the text, not used). LineLinker::REF.
+export const REF = /(?<![\w./@+~-])(?<path>[\w./@+~-]*[\w@+~-]):(?<from>\d+)(?:-(?<to>\d+))?(?::\d+)?(?![\w/])/;
+export const REF_ALONE = new RegExp(`^${REF.source}$`);
+// A ref, or a bare path (no `:line`): a bare one counts only when it is a
+// touched file exactly (resolveRef's +bare+). Not after a `\` or a `:`
+// either: the tail of `C:\x\foo.rb:3` or `host:lib/foo.rb:3` is another
+// machine's file.
+const REF_OR_PATH = /(?<![\w./@+~\\:-])(?<path>[\w./@+~-]*[\w@+~-])(?::(?<from>\d+)(?:-(?<to>\d+))?(?::\d+)?(?![\w/])|(?![\w/]|:\d))/g;
+const PATH_ALONE = /^(?<path>[\w./@+~-]*[\w@+~-])$/;
+const URL_SPAN = /[a-z][a-z0-9+.-]*:\/\/\S+/gi;
+const MARKDOWN_LINK = /\[[^\]]*\]\([^)]*\)/g;
+// A fenced code block's opening line (up to 3 spaces, then ``` or ~~~).
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+// Elements whose text is never scanned: code blocks, links (a github-pr
+// PR link stays the PR's), a ref already made.
+const SKIP = "pre, a, [data-ref-kind]";
+
+// The ref a match names: { path, line, endLine } or null. A path has a `/`
+// or an extension (`10:30` is a time, `host:8080` a port); line 0 is never
+// a ref; an end line not after the line is dropped.
+export function refOf(groups) {
+  const path = groups?.path || "";
+  if (!path.includes("/") && !/\.[A-Za-z0-9]+$/.test(path)) return null;
+  if (groups.from === undefined) return { path, line: null, endLine: null };
+  const line = Number(groups.from);
+  if (!line) return null;
+  const to = groups.to === undefined ? null : Number(groups.to);
+  return { path, line, endLine: to && to > line ? to : null };
+}
+
+// The absolute touched file +path+ names, or null: the path itself when
+// absolute, else the path under +cwd+ (`.` and `..` folded either way); else (not for a +bare+ path: no
+// `:line`) the ONE touched file ending in `/<path>`. Ambiguous: none.
+export function resolveRef(path, touched, cwd, { bare = false } = {}) {
+  const rel = String(path).replace(/^(?:\.\/)+/, "");
+  const exact = rel.startsWith("/") ? joinPath("", rel) : cwd ? joinPath(cwd, rel) : null;
+  if (exact && touched.has(exact)) return exact;
+  if (bare || rel.startsWith("/")) return null;
+  const tail = `/${rel.replace(/^(?:\.\.\/)+/, "")}`;
+  const found = [...touched].filter((file) => file.endsWith(tail));
+  return found.length === 1 ? found[0] : null;
+}
+
+// +rel+ under +dir+, `.` and `..` segments folded.
+function joinPath(dir, rel) {
+  const out = [];
+  for (const part of `${dir}/${rel}`.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") out.pop();
+    else out.push(part);
+  }
+  return `/${out.join("/")}`;
+}
+
+// [start, end, ref] for each ref in a plain +text+ that names a touched
+// file: fenced blocks, markdown links and URLs skipped, inline code only
+// as the ref alone (the span with its backticks). +touched+: a Set of
+// absolute paths; +cwd+: the session's working directory.
+export function textRefs(text, touched, cwd) {
+  if (!touched?.size || !text) return [];
+  const fences = fencedBlocks(text);
+  const skipped = [...fences, ...spans(text, URL_SPAN), ...spans(text, MARKDOWN_LINK)];
+  const code = inlineCode(text, fences);
+  const found = [];
+  for (const [start, end, inner] of code) {
+    if (insideAny(skipped, start, end)) continue;
+    const ref = aloneRef(inner, touched, cwd);
+    if (ref) found.push([start, end, ref]);
+  }
+  for (const match of text.matchAll(REF_OR_PATH)) {
+    const start = match.index;
+    const end = start + match[0].length;
+    if (insideAny(skipped, start, end) || insideAny(code, start, end)) continue;
+    const ref = resolved(refOf(match.groups), touched, cwd);
+    if (ref) found.push([start, end, ref]);
+  }
+  return found.sort((a, b) => a[0] - b[0]);
+}
+
+// The ref an inline code's text is when it is a ref (or a touched path)
+// alone, else null.
+function aloneRef(text, touched, cwd) {
+  const inner = String(text).trim();
+  const match = inner.match(REF_ALONE) || inner.match(PATH_ALONE);
+  return match ? resolved(refOf(match.groups), touched, cwd) : null;
+}
+
+function resolved(ref, touched, cwd) {
+  if (!ref) return null;
+  const path = resolveRef(ref.path, touched, cwd, { bare: ref.line === null });
+  return path ? { kind: "file", path, line: ref.line, end_line: ref.endLine } : null;
+}
+
+// The absolute paths of the file refs under +roots+ (the session's rows,
+// approval cards): what a text ref may name.
+export function touchedFiles(roots) {
+  const touched = new Set();
+  for (const root of roots) {
+    for (const el of root.querySelectorAll('[data-ref-kind="file"][data-ref-path]')) {
+      touched.add(el.dataset.refPath);
+    }
+  }
+  return touched;
+}
+
+// Wraps the refs in +el+'s text in span.ref (refs.js clicks and
+// hover them as it does a row title). Text inside pre, a link or a ref is
+// left alone; an inline code element is wrapped whole when it is a ref
+// alone. Runs again over the same element without wrapping twice.
+export function linkRefs(el, touched, cwd) {
+  if (!el || !touched?.size) return;
+  const doc = el.ownerDocument;
+  for (const code of [...el.querySelectorAll("code")]) {
+    if (code.closest(SKIP)) continue;
+    const ref = aloneRef(code.textContent, touched, cwd);
+    if (!ref) continue;
+    const span = refSpan(doc, ref);
+    code.replaceWith(span);
+    span.append(code);
+  }
+  const walker = doc.createTreeWalker(el, 4 /* NodeFilter.SHOW_TEXT */);
+  const nodes = [];
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    const skip = node.parentElement?.closest(`${SKIP}, code`);
+    if (!skip || !el.contains(skip)) nodes.push(node);
+  }
+  for (const node of nodes) wrapRefs(node, textRefs(node.data, touched, cwd));
+}
+
+function wrapRefs(node, hits) {
+  if (!hits.length) return;
+  const doc = node.ownerDocument;
+  const frag = doc.createDocumentFragment();
+  let pos = 0;
+  for (const [start, end, ref] of hits) {
+    if (start < pos) continue;
+    if (start > pos) frag.append(node.data.slice(pos, start));
+    const span = refSpan(doc, ref);
+    span.textContent = node.data.slice(start, end);
+    frag.append(span);
+    pos = end;
+  }
+  if (pos < node.data.length) frag.append(node.data.slice(pos));
+  node.replaceWith(frag);
+}
+
+function refSpan(doc, ref) {
+  const holder = doc.createElement("div");
+  holder.innerHTML = `<span class="ref"${refAttrs(ref)}></span>`;
+  return holder.firstChild;
+}
+
+// [start, end] of each fenced block (an unclosed one runs to the end).
+function fencedBlocks(text) {
+  const blocks = [];
+  let open = null;
+  let offset = 0;
+  for (const line of text.split(/(?<=\n)/)) {
+    const marker = line.match(FENCE_OPEN)?.[1];
+    if (!open && marker) {
+      open = [offset, marker];
+    } else if (open && marker && marker[0] === open[1][0] && marker.length >= open[1].length && line.trim() === marker) {
+      blocks.push([open[0], offset + line.length]);
+      open = null;
+    }
+    offset += line.length;
+  }
+  if (open) blocks.push([open[0], text.length]);
+  return blocks;
+}
+
+// [start, end, inner] of each inline code span outside +fences+: a run of
+// backticks to the next run of the same length.
+function inlineCode(text, fences) {
+  const runs = spans(text, /`+/g).filter(([start, end]) => !insideAny(fences, start, end));
+  const found = [];
+  let index = 0;
+  while (index < runs.length) {
+    const [start, end] = runs[index];
+    const closing = runs.findIndex(([s, e], k) => k > index && e - s === end - start);
+    if (closing < 0) { index += 1; continue; }
+    found.push([start, runs[closing][1], text.slice(end, runs[closing][0])]);
+    index = closing + 1;
+  }
+  return found;
+}
+
+function spans(text, regex) {
+  return [...text.matchAll(regex)].map((m) => [m.index, m.index + m[0].length]);
+}
+
+function insideAny(list, start, end) {
+  return list.some(([s, e]) => start >= s && end <= e);
+}

data/lib/samagotchi/web/public/refs.js

@@ -1,7 +1,8 @@
 // Refs: quiet links from what a turn touched to the thing itself. A ref is
 // a kind and a target: today a file tool's row title (the server's FileRef,
-// {kind: "file", path, line?, end_line?}) and that row's diff lines (the
-// same file at a line). The DOM carries data-ref-kind and the target's
+// {kind: "file", path, line?, end_line?}), that row's diff lines and a
+// read row's numbered lines (the same file at a line), and an edit/write
+// approval card's paths and its dry run's diff lines. The DOM carries data-ref-kind and the target's
 // attributes, never what a click does: that is an action, kept per kind in
 // REF_ACTIONS, and a click runs the first one available to this viewer. A
 // ref with none (a phone: no editor) stays plain text; the page marks the
@@ -51,19 +52,27 @@ export function availableKinds(viewer, actions = REF_ACTIONS) {
   return Object.keys(actions).filter((kind) => refAction(kind, viewer, actions));
 }
 
+// What owns a ref and its diff lines: a tool row, or an edit's approval
+// card (its paths and its dry run).
+const OWNERS = ".activity-row, .bubble.approval";
+
+// A line of the owner's file: a diff line, or a read row's numbered line.
+const LINES = ".diff-line[data-line], .read-line[data-line]";
+
 // What a click on +el+ points at: {kind, path, line, owner} or null. A row
-// title opens its file at the lines the call named (an edit without any at
-// its first changed line); a diff line (or a hunk header) in a row with a
-// ref opens the row's file at that line. A diff line outside a row (an
-// approval card's dry run) is none.
+// title (or an approval card's path) opens its file at the lines the call
+// named (an edit without any at its first changed line); a diff line (or a
+// hunk header) or a read row's numbered line, in a row or a card with a
+// ref, opens that file at that line.
+// A diff line elsewhere is none.
 export function refTarget(el) {
   const title = el?.closest?.("[data-ref-kind]");
   if (title) {
-    const owner = title.closest(".activity-row");
+    const owner = title.closest(OWNERS);
     return { ...targetOf(title), line: Number(title.dataset.refLine) || firstChange(owner), owner: owner || title };
   }
-  const diffLine = el?.closest?.(".diff-line[data-line]");
-  const owner = diffLine?.closest(".activity-row");
+  const diffLine = el?.closest?.(LINES);
+  const owner = diffLine?.closest(OWNERS);
   const ref = owner?.querySelector("[data-ref-kind]");
   if (!ref) return null;
   return { ...targetOf(ref), line: Number(diffLine.dataset.line), owner };
@@ -116,7 +125,7 @@ export function installRefClicks(root, viewer, { open = defaultOpen, selection =
   root.addEventListener("mouseover", (e) => {
     const target = refTarget(e.target);
     if (!target) return;
-    const el = e.target.closest("[data-ref-kind]") || e.target.closest(".diff-line[data-line]");
+    const el = e.target.closest("[data-ref-kind]") || e.target.closest(LINES);
     if (!el) return;
     if (el.dataset.refTitle === undefined) el.dataset.refTitle = el.getAttribute("title") || "";
     const own = el.dataset.refTitle;

data/lib/samagotchi/web/public/turn_html.js

@@ -8,6 +8,7 @@ import { copySourceAttr } from "./copy.js";
 import { activityDiffHtml } from "./diff_view.js";
 import { escapeHtml, userBodyHtml } from "./format.js";
 import { refAttrs } from "./refs.js";
+import { readLinesHtml } from "./read_view.js";
 import { formatDuration } from "./timing.js";
 import { emptyAnswerLine } from "./turn_events.js";
 
@@ -72,7 +73,8 @@ function llmEditHtml(row) {
 // else the full params line, on hover), the word an exception shows, the
 // call's duration, the full command (an execute/task_create's view, also
 // while it runs), the output once done (its "[tool]" tag dropped, 300 chars,
-// the rest on hover), its images (+thumbs+(images) draws them) and an
+// the rest on hover; a read of the file as-is also its numbered lines,
+// closed: read_view.js), its images (+thumbs+(images) draws them) and an
 // edit's collapsed diff, and a reloaded row's ✂ mark above its output. A
 // part with nothing to say is left out.
 export function toolRowHtml(row, { thumbs = () => "" } = {}) {
@@ -96,7 +98,7 @@ export function toolRowInnerHtml(row, { thumbs = () => "" } = {}) {
   const status = statusParts(row.status, { noMatch: !!row.no_match });
   return `${statusMarkHtml(status)}<span class="activity-tool">${escapeHtml(toolName(row))}</span>${params}${alias}${statusWordHtml(status)}` +
     `${duration ? `<span class="activity-duration">${escapeHtml(duration)}</span>` : ""}` +
-    `${commandBlockHtml(row.view, row.title)}${llmEditHtml(row)}${output}` +
+    `${commandBlockHtml(row.view, row.title)}${llmEditHtml(row)}${output}${output ? readLinesHtml(row) : ""}` +
     `${row.images?.length ? thumbs(row.images) : ""}${row.diff ? activityDiffHtml(row.diff) : ""}`;
 }
 

data/lib/samagotchi/web/public/turn_view.js

@@ -63,13 +63,15 @@ export function thinkingTemplate({ body, wrapped = true, line = null, cls = "thi
 
 // A step's narration: the live box of complete sentences (one per line,
 // the newest last), the live "…" until the first one, or a closed step's
-// full text. None when there is nothing to say.
+// full text. None when there is nothing to say. A closed step's text is
+// set whole (.textContent): its refs (ref_scan.js) split it into spans
+// that a text part's update would leave behind.
 function textTemplate(text, { live, sentences, placeholder }) {
   if (live && sentences?.length) {
     return html`<div class="gen-text streaming"><div class="narration">${sentences.map((s) => html`<div class="sentence">${s}</div>`)}</div></div>`;
   }
   if (live) return placeholder ? html`<div class="gen-text streaming">…</div>` : nothing;
-  return text ? html`<div class="gen-text">${text}</div>` : nothing;
+  return text ? html`<div class="gen-text" .textContent=${text}></div>` : nothing;
 }
 
 // One step, live or reloaded. +gen+: { text, thinking, tools, answer } (a
@@ -118,7 +120,7 @@ function rawNodes(markup) {
 // The parts of a drawn tool row a user may have changed (the command's
 // raw toggle, an opened diff) or that never change once there (the
 // thumbs): a redraw keeps them as they are.
-const KEPT_PARTS = ["activity-command", "activity-diff", "thumbs"];
+const KEPT_PARTS = ["activity-command", "activity-diff", "activity-read", "thumbs"];
 
 const childWith = (el, cls) => [...el.children].find((c) => c.classList.contains(cls));
 

data/lib/samagotchi/web/token.rb

@@ -5,6 +5,7 @@ require "securerandom"
 require_relative "../atomic_file"
 
 require_relative "../session"
+require_relative "../redacted_inspect"
 
 module Samagotchi
   module Web
@@ -62,6 +63,8 @@ module Samagotchi
       # its mtime changes (one stat per check), so `chi web --new-token`
       # takes effect at once, without a restart.
       class Source
+        include RedactedInspect
+
         attr_reader :path
 
         def initialize(path = Token.path)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.56.0
+  version: 0.57.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -203,6 +203,8 @@ files:
 - lib/samagotchi/bundles/mcp/plugin.rb
 - lib/samagotchi/bundles/skills/manifest.yml
 - lib/samagotchi/bundles/skills/plugin.rb
+- lib/samagotchi/bundles/slow-commands/manifest.yml
+- lib/samagotchi/bundles/slow-commands/plugin.rb
 - lib/samagotchi/bundles/source-links/hooks/source_links.rb
 - lib/samagotchi/bundles/source-links/manifest.yml
 - lib/samagotchi/bundles/source-links/source_links.md
@@ -400,6 +402,7 @@ files:
 - lib/samagotchi/reasoning_history_command.rb
 - lib/samagotchi/recap_setup.rb
 - lib/samagotchi/recap_store.rb
+- lib/samagotchi/redacted_inspect.rb
 - lib/samagotchi/relay.rb
 - lib/samagotchi/relay_desk.rb
 - lib/samagotchi/relay_verifier.rb
@@ -557,7 +560,9 @@ files:
 - lib/samagotchi/web/public/prompt_history.js
 - lib/samagotchi/web/public/question_card.js
 - lib/samagotchi/web/public/question_cards.js
+- lib/samagotchi/web/public/read_view.js
 - lib/samagotchi/web/public/reasoning_history_chip.js
+- lib/samagotchi/web/public/ref_scan.js
 - lib/samagotchi/web/public/refs.js
 - lib/samagotchi/web/public/restore.js
 - lib/samagotchi/web/public/route.js