@saadnvd1/agent-os 0.3.770 → 0.3.775

package/data/shares/queries.ts

@@ -1,6 +1,7 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import type {
   CreatedShare,
+  MessageList,
   PreviewRequest,
   SharePreview,
   SharesResponse,
@@ -40,6 +41,16 @@ export function useSharePreview() {
   });
 }
 
+/** Every message of a chat, for picking the part to share. */
+export function useShareMessages() {
+  return useMutation({
+    mutationFn: async (req: PreviewRequest) =>
+      json<MessageList>(
+        await post("/api/shares/preview", { ...req, listOnly: true })
+      ),
+  });
+}
+
 /** The share as a PDF, printed by the server. */
 export function useSharePdf() {
   return useMutation({

package/hooks/usePaletteCommands.ts

@@ -17,7 +17,10 @@ export function usePaletteCommands(
   });
   const shape = commands
     ? commands
-        .map((c) => `${c.id}\u0000${c.title}\u0000${c.hint ?? ""}`)
+        .map(
+          (c) =>
+            `${c.id}\u0000${c.title}\u0000${c.hint ?? ""}\u0000${c.status ?? ""}`
+        )
         .join("\u0001")
     : null;
   useEffect(() => {

package/lib/artifacts/actions.ts

@@ -7,6 +7,7 @@ export type ArtifactActionId =
   | "share"
   | "open"
   | "download"
+  | "compare"
   | "open-pr"
   | "copy-path"
   | "open-in-files";
@@ -36,16 +37,25 @@ export interface ArtifactVersion {
 
 export interface PageVersions {
   pageId: string;
+  // The page's name: its latest version's title.
+  title: string;
   latestId: string;
   versions: ArtifactVersion[];
   actions: ArtifactAction[];
 }
 
-export function pageActions(ctx: { pdf: boolean }): ArtifactAction[] {
+// versions: how many versions the page has; Compare needs two.
+export function pageActions(ctx: {
+  pdf: boolean;
+  versions?: number;
+}): ArtifactAction[] {
   return [
     { id: "fullscreen", label: "Full screen" },
     { id: "share", label: "Share" },
     { id: "open", label: "Open" },
+    ...((ctx.versions ?? 1) > 1
+      ? [{ id: "compare" as const, label: "Compare" }]
+      : []),
     {
       id: "download",
       label: "Download",

package/lib/artifacts/compare/compareVersions.ts

@@ -0,0 +1,66 @@
+import { getArtifact, readArtifactHtml } from "../store";
+import { toVersion } from "../versions";
+import { diffLines } from "./diff";
+import { extractText } from "./extractText";
+import type { CompareMode, CompareResult } from "./types";
+
+// Per version; bigger pages are only shown side by side.
+export const MAX_COMPARE_BYTES = 512 * 1024;
+
+const NOT_FOUND = {
+  ok: false,
+  status: 404,
+  error: "Version not found",
+} as const;
+
+// Two versions of one page in one session, as a diff. Both must belong to
+// the session asked about and to the same page: an id from anywhere else
+// reads as not found, so ids can't be probed across sessions.
+export async function compareVersions(
+  sessionId: string,
+  fromId: string,
+  toId: string,
+  mode: CompareMode
+): Promise<CompareResult> {
+  const from = getArtifact(fromId);
+  const to = getArtifact(toId);
+  if (!from || !to) return NOT_FOUND;
+  if (from.session_id !== sessionId || to.session_id !== sessionId)
+    return NOT_FOUND;
+  if (from.page_id !== to.page_id)
+    return {
+      ok: false,
+      status: 400,
+      error: "Those versions belong to different pages",
+    };
+
+  const head = {
+    ok: true,
+    mode,
+    from: toVersion(from),
+    to: toVersion(to),
+  } as const;
+  const tooBig = (a: { bytes: number | null }) =>
+    (a.bytes ?? 0) > MAX_COMPARE_BYTES;
+  const tooLarge = (reason: string): CompareResult => ({
+    ...head,
+    tooLarge: true,
+    reason,
+  });
+  if (tooBig(from) || tooBig(to)) return tooLarge("too large to diff");
+
+  const [a, b] = await Promise.all([
+    readArtifactHtml(from),
+    readArtifactHtml(to),
+  ]);
+  if (a === null || b === null) return NOT_FOUND;
+  if (a.length > MAX_COMPARE_BYTES || b.length > MAX_COMPARE_BYTES)
+    return tooLarge("too large to diff");
+
+  const result =
+    mode === "source"
+      ? diffLines(a, b)
+      : diffLines(extractText(a), extractText(b));
+  if (!result.ok) return tooLarge("too many changes to diff");
+  return { ...head, summary: result.summary, lines: result.lines };
+}

package/lib/artifacts/compare/diff.ts

@@ -0,0 +1,178 @@
+// A line diff (Myers' O(ND)) with a word diff inside the changed lines that
+// pair up. Bounded: past the limits it gives up instead of burning the CPU.
+
+import type { DiffLine, DiffSummary, WordPart } from "./types";
+
+export const MAX_LINES = 20_000;
+// Edit distance past which two texts are different enough not to diff.
+export const MAX_EDITS = 4_000;
+const MAX_WORD_TOKENS = 600;
+
+type Op = { t: "eq" | "add" | "del"; i: number; j: number };
+
+// Edit script from a to b, or null when it needs more than maxEdits.
+function myers(a: string[], b: string[], maxEdits: number): Op[] | null {
+  const n = a.length;
+  const m = b.length;
+  const max = Math.min(n + m, maxEdits);
+  const offset = max + 1;
+  const v = new Int32Array(2 * max + 3);
+  const trace: Int32Array[] = [];
+  let found = -1;
+  for (let d = 0; d <= max && found < 0; d++) {
+    trace.push(v.slice());
+    for (let k = -d; k <= d; k += 2) {
+      let x =
+        k === -d || (k !== d && v[offset + k - 1] < v[offset + k + 1])
+          ? v[offset + k + 1]
+          : v[offset + k - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && a[x] === b[y]) {
+        x++;
+        y++;
+      }
+      v[offset + k] = x;
+      if (x >= n && y >= m) {
+        found = d;
+        break;
+      }
+    }
+  }
+  if (found < 0) return null;
+  const ops: Op[] = [];
+  let x = n;
+  let y = m;
+  for (let d = found; d > 0; d--) {
+    const prev = trace[d];
+    const k = x - y;
+    const down =
+      k === -d || (k !== d && prev[offset + k - 1] < prev[offset + k + 1]);
+    const pk = down ? k + 1 : k - 1;
+    const px = prev[offset + pk];
+    const py = px - pk;
+    while (x > px && y > py) {
+      x--;
+      y--;
+      ops.push({ t: "eq", i: x, j: y });
+    }
+    if (down) {
+      y--;
+      ops.push({ t: "add", i: x, j: y });
+    } else {
+      x--;
+      ops.push({ t: "del", i: x, j: y });
+    }
+  }
+  while (x > 0 && y > 0) {
+    x--;
+    y--;
+    ops.push({ t: "eq", i: x, j: y });
+  }
+  return ops.reverse();
+}
+
+const tokens = (s: string) =>
+  s.match(/\s+|[\p{L}\p{N}_]+|[^\s\p{L}\p{N}_]/gu) ?? [];
+
+// The words of two paired lines: what each side kept and what it changed.
+function wordParts(
+  before: string,
+  after: string
+): { del: WordPart[]; add: WordPart[] } | null {
+  const a = tokens(before);
+  const b = tokens(after);
+  if (a.length > MAX_WORD_TOKENS || b.length > MAX_WORD_TOKENS) return null;
+  const ops = myers(a, b, MAX_WORD_TOKENS);
+  if (!ops) return null;
+  const del: WordPart[] = [];
+  const add: WordPart[] = [];
+  const push = (list: WordPart[], t: WordPart["t"], s: string) => {
+    const last = list[list.length - 1];
+    if (last && last.t === t) last.s += s;
+    else list.push({ t, s });
+  };
+  for (const op of ops) {
+    if (op.t === "eq") {
+      push(del, "eq", a[op.i]);
+      push(add, "eq", b[op.j]);
+    } else if (op.t === "del") push(del, "del", a[op.i]);
+    else push(add, "add", b[op.j]);
+  }
+  return { del, add };
+}
+
+export type DiffResult =
+  { ok: true; lines: DiffLine[]; summary: DiffSummary } | { ok: false };
+
+export function diffLines(before: string, after: string): DiffResult {
+  const a = before === "" ? [] : before.split("\n");
+  const b = after === "" ? [] : after.split("\n");
+  if (a.length > MAX_LINES || b.length > MAX_LINES) return { ok: false };
+  const ops = myers(a, b, MAX_EDITS);
+  if (!ops) return { ok: false };
+
+  const lines: DiffLine[] = [];
+  let added = 0;
+  let removed = 0;
+  for (let p = 0; p < ops.length;) {
+    if (ops[p].t === "eq") {
+      lines.push({ t: "eq", s: a[ops[p].i] });
+      p++;
+      continue;
+    }
+    // A run of changes: removals first, then additions, paired in order.
+    const dels: string[] = [];
+    const adds: string[] = [];
+    while (p < ops.length && ops[p].t !== "eq") {
+      if (ops[p].t === "del") dels.push(a[ops[p].i]);
+      else adds.push(b[ops[p].j]);
+      p++;
+    }
+    removed += dels.length;
+    added += adds.length;
+    const delLines: DiffLine[] = dels.map((s) => ({ t: "del", s }));
+    const addLines: DiffLine[] = adds.map((s) => ({ t: "add", s }));
+    for (let q = 0; q < Math.min(dels.length, adds.length); q++) {
+      const w = wordParts(dels[q], adds[q]);
+      if (w) {
+        delLines[q].words = w.del;
+        addLines[q].words = w.add;
+      }
+    }
+    lines.push(...delLines, ...addLines);
+  }
+  return { ok: true, lines, summary: { added, removed } };
+}
+
+export function summaryLabel(s: DiffSummary): string {
+  if (!s.added && !s.removed) return "No changes";
+  return `+${s.added} −${s.removed} lines`;
+}
+
+export type Shown = DiffLine | { gap: number };
+
+// Long unchanged stretches folded to a gap, keeping `context` lines around
+// every change.
+export function foldUnchanged(lines: DiffLine[], context = 3): Shown[] {
+  const keep = new Array<boolean>(lines.length).fill(false);
+  lines.forEach((l, i) => {
+    if (l.t === "eq") return;
+    for (
+      let k = Math.max(0, i - context);
+      k <= Math.min(lines.length - 1, i + context);
+      k++
+    )
+      keep[k] = true;
+  });
+  const out: Shown[] = [];
+  let gap = 0;
+  lines.forEach((l, i) => {
+    if (keep[i]) {
+      if (gap) out.push({ gap });
+      gap = 0;
+      out.push(l);
+    } else gap++;
+  });
+  if (gap) out.push({ gap });
+  return out;
+}

package/lib/artifacts/compare/extractText.ts

@@ -0,0 +1,64 @@
+// The text a reader sees on a page, one block per line: scripts, styles and
+// the head gone, headings, paragraphs, list items and table cells each on
+// their own line.
+
+const DROPPED =
+  /<(script|style|noscript|template|head|svg|iframe)\b[\s\S]*?<\/\1\s*>/gi;
+const COMMENTS = /<!--[\s\S]*?-->/g;
+const BREAKING =
+  /<\/?(?:p|div|section|article|aside|header|footer|main|nav|ul|ol|li|dl|dt|dd|h[1-6]|tr|td|th|table|thead|tbody|tfoot|caption|blockquote|pre|figure|figcaption|form|fieldset|details|summary|hr|br|address|label|button|option)\b[^>]*>/gi;
+const TAGS = /<[^>]*>/g;
+
+const NAMED: Record<string, string> = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  ndash: "–",
+  mdash: "—",
+  hellip: "…",
+  lsquo: "‘",
+  rsquo: "’",
+  ldquo: "“",
+  rdquo: "”",
+  middot: "·",
+  bull: "•",
+  times: "×",
+  rarr: "→",
+  larr: "←",
+  copy: "©",
+};
+
+function codePoint(n: number, whole: string): string {
+  try {
+    return n > 0 && n <= 0x10ffff ? String.fromCodePoint(n) : whole;
+  } catch {
+    return whole;
+  }
+}
+
+export function decodeEntities(s: string): string {
+  return s.replace(
+    /&(?:#(\d{1,7})|#[xX]([0-9a-fA-F]{1,6})|([a-zA-Z]{2,8}));/g,
+    (whole, dec, hex, name) => {
+      if (dec) return codePoint(parseInt(dec, 10), whole);
+      if (hex) return codePoint(parseInt(hex, 16), whole);
+      return NAMED[name.toLowerCase()] ?? whole;
+    }
+  );
+}
+
+export function extractText(html: string): string {
+  const flat = html
+    .replace(COMMENTS, "")
+    .replace(DROPPED, "")
+    .replace(BREAKING, "\n")
+    .replace(TAGS, "");
+  return decodeEntities(flat)
+    .split("\n")
+    .map((l) => l.replace(/\s+/g, " ").trim())
+    .filter(Boolean)
+    .join("\n");
+}

package/lib/artifacts/compare/index.ts

@@ -0,0 +1,11 @@
+export { compareVersions, MAX_COMPARE_BYTES } from "./compareVersions";
+export { diffLines, foldUnchanged, summaryLabel, type Shown } from "./diff";
+export { extractText } from "./extractText";
+export type {
+  CompareMode,
+  CompareResult,
+  Comparison,
+  DiffLine,
+  DiffSummary,
+  WordPart,
+} from "./types";

package/lib/artifacts/compare/types.ts

@@ -0,0 +1,44 @@
+import type { ArtifactVersion } from "../actions";
+
+export type CompareMode = "changes" | "source";
+
+// A piece of one line: kept, or (on a removed line) taken out, or (on an
+// added line) put in.
+export interface WordPart {
+  t: "eq" | "add" | "del";
+  s: string;
+}
+
+export interface DiffLine {
+  t: "eq" | "add" | "del";
+  s: string;
+  // Only on a removed or added line that pairs with one on the other side.
+  words?: WordPart[];
+}
+
+export interface DiffSummary {
+  added: number;
+  removed: number;
+}
+
+export type Comparison =
+  | {
+      ok: true;
+      mode: CompareMode;
+      from: ArtifactVersion;
+      to: ArtifactVersion;
+      summary: DiffSummary;
+      lines: DiffLine[];
+    }
+  | {
+      ok: true;
+      mode: CompareMode;
+      from: ArtifactVersion;
+      to: ArtifactVersion;
+      // Too big to diff: the client shows the pages side by side only.
+      tooLarge: true;
+      reason: string;
+    };
+
+export type CompareResult =
+  Comparison | { ok: false; status: 400 | 404; error: string };

package/lib/artifacts/match.ts

@@ -0,0 +1,64 @@
+// Finds which earlier page a new render is a revision of, by its visible text.
+// Used when an agent retitles a page without passing `update`.
+
+// Word-5-gram overlap (Jaccard) of the visible text. A revision keeps most of
+// its sentences, so it stays well above 0.6; two pages that only share a
+// template (nav, footer, same CSS) have different text and land far below.
+export const MATCH_THRESHOLD = 0.6;
+// A clear winner: the runner-up must trail by this much, else it is a tie.
+export const MATCH_MARGIN = 0.1;
+// Too little text to tell documents apart.
+export const MIN_TOKENS = 12;
+export const SHINGLE = 5;
+export const MAX_CANDIDATES = 20;
+
+export function visibleText(html: string): string {
+  return html
+    .replace(/<!--[\s\S]*?-->/g, " ")
+    .replace(/<(script|style|noscript|template|svg)\b[\s\S]*?<\/\1\s*>/gi, " ")
+    .replace(/<[^>]*>/g, " ")
+    .replace(/&nbsp;/gi, " ")
+    .replace(/&amp;/gi, "&")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+export function tokens(html: string): string[] {
+  return visibleText(html).match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+
+function shingles(toks: string[]): Set<string> {
+  const out = new Set<string>();
+  const n = Math.min(SHINGLE, toks.length);
+  for (let i = 0; i + n <= toks.length; i++)
+    out.add(toks.slice(i, i + n).join(" "));
+  return out;
+}
+
+export function similarity(a: string, b: string): number {
+  const ta = tokens(a);
+  const tb = tokens(b);
+  if (ta.length < MIN_TOKENS || tb.length < MIN_TOKENS) return 0;
+  const sa = shingles(ta);
+  const sb = shingles(tb);
+  let shared = 0;
+  for (const s of sa) if (sb.has(s)) shared++;
+  const union = sa.size + sb.size - shared;
+  return union ? shared / union : 0;
+}
+
+// The id of the one candidate that clearly is the same document, if any.
+export function findRevisionOf<T extends { key: string; html: string }>(
+  html: string,
+  candidates: T[]
+): string | undefined {
+  const scored = candidates
+    .slice(0, MAX_CANDIDATES)
+    .map((c) => ({ key: c.key, score: similarity(html, c.html) }))
+    .sort((a, b) => b.score - a.score);
+  const [best, next] = scored;
+  if (!best || best.score < MATCH_THRESHOLD) return undefined;
+  if (next && best.score - next.score < MATCH_MARGIN) return undefined;
+  return best.key;
+}

package/lib/artifacts/store.ts

@@ -8,6 +8,7 @@ import fs from "fs";
 import path from "path";
 import { createHash, randomUUID } from "crypto";
 import { db } from "../db";
+import { findRevisionOf, MAX_CANDIDATES } from "./match";
 
 export interface Artifact {
   id: string;
@@ -29,6 +30,9 @@ export interface SaveOptions {
   update?: string;
   // With no update, the newest page in this session with the same title.
   sameTitle?: boolean;
+  // With no update and no title match, the page in this session whose latest
+  // version has clearly the same text (see match.ts).
+  matchContent?: boolean;
   note?: string;
 }
 
@@ -78,16 +82,18 @@ export function saveArtifact(
   if (bytes > MAX_HTML_BYTES)
     throw new Error("The page is over 2 MB; make it smaller.");
   const clean = oneLine(title, MAX_TITLE_CHARS) || "Untitled";
-  const note = opts.note ? oneLine(opts.note, MAX_NOTE_CHARS) || null : null;
+  let note = opts.note ? oneLine(opts.note, MAX_NOTE_CHARS) || null : null;
   const sha256 = createHash("sha256").update(html).digest("hex");
   const id = randomUUID();
   const dir = sessionDir(sessionId);
   const file = path.join(dir, `${id}.html`);
   return db.transaction((): Saved => {
-    const pageId = resolvePage(sessionId, clean, opts);
+    const { pageId, fuzzy } = resolvePage(sessionId, clean, html, opts);
     const latest = pageId ? latestVersion(pageId) : undefined;
     if (latest && latest.sha256 === sha256)
       return { artifact: latest, created: false };
+    if (fuzzy && latest && !note && latest.title !== clean)
+      note = oneLine(`Retitled from '${latest.title}'`, MAX_NOTE_CHARS);
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     fs.writeFileSync(file, html, { mode: 0o600 });
     db.prepare(
@@ -111,24 +117,47 @@ export function saveArtifact(
 function resolvePage(
   sessionId: string,
   title: string,
+  html: string,
   opts: SaveOptions
-): string | undefined {
+): { pageId?: string; fuzzy?: boolean } {
   if (opts.update) {
     const base = getArtifact(opts.update);
     if (!base || base.session_id !== sessionId)
       throw new Error(
         `No page ${opts.update} in this chat; leave out update to show a new page.`
       );
-    return base.page_id;
+    return { pageId: base.page_id };
+  }
+  if (!opts.sameTitle && !opts.matchContent) return {};
+  // A page is named by its latest version, so an older title no longer finds it.
+  const latest = latestPerPage(sessionId, MAX_CANDIDATES);
+  if (opts.sameTitle) {
+    const lower = title.toLowerCase();
+    const same = latest.find((a) => a.title.toLowerCase() === lower);
+    if (same) return { pageId: same.page_id };
   }
-  if (!opts.sameTitle) return undefined;
-  const row = db
+  if (!opts.matchContent) return {};
+  const candidates = latest.flatMap((a) => {
+    try {
+      return [{ key: a.page_id, html: fs.readFileSync(a.path, "utf8") }];
+    } catch {
+      return [];
+    }
+  });
+  const pageId = findRevisionOf(html, candidates);
+  return pageId ? { pageId, fuzzy: true } : {};
+}
+
+// The newest version of each page in a session, most recently shown first.
+function latestPerPage(sessionId: string, limit: number): Artifact[] {
+  return db
     .prepare(
-      `SELECT page_id FROM artifacts WHERE session_id = ? AND lower(title) = lower(?)
-       ORDER BY created_at DESC, rowid DESC LIMIT 1`
+      `SELECT a.* FROM artifacts a
+        WHERE a.session_id = ?
+          AND a.version = (SELECT MAX(version) FROM artifacts WHERE page_id = a.page_id)
+        ORDER BY a.created_at DESC, a.rowid DESC LIMIT ?`
     )
-    .get(sessionId, title) as { page_id: string } | undefined;
-  return row?.page_id;
+    .all(sessionId, limit) as Artifact[];
 }
 
 // Every version of a page, oldest first.

package/lib/artifacts/tools.ts

@@ -100,7 +100,12 @@ export async function renderPage(
       ctx.sessionId,
       args.title,
       readSource(args, ctx.cwd),
-      { update: args.update, note: args.note, sameTitle: true }
+      {
+        update: args.update,
+        note: args.note,
+        sameTitle: true,
+        matchContent: true,
+      }
     );
     if (created) {
       ctx.onRender(artifact, args.height);
@@ -112,7 +117,7 @@ export async function renderPage(
         {
           type: "text",
           text: created
-            ? `Shown in the chat as ${name} (artifact ${artifact.id}). To change it, call html_render again with update: "${artifact.id}"; every version is kept.`
+            ? `Shown in the chat as ${name} (artifact ${artifact.id}). To revise this page, pass update: "${artifact.id}" to html_render, even if the title changes; every version is kept.`
             : `Unchanged: the page is the same as ${name} (artifact ${artifact.id}), already in the chat.`,
         },
       ],
@@ -191,7 +196,7 @@ export function visualsTools(
             .string()
             .optional()
             .describe(
-              "The artifact id of a page you already showed in this chat, to show a new version of it. A page with the same title is updated too. Every version is kept."
+              "When revising a page you already showed, pass its artifact id, even if the title changes, to show a new version of it. Without it a page is matched by title or similar content, and otherwise saved as a new page. Every version is kept."
             ),
           note: z
             .string()
@@ -207,7 +212,7 @@ export function visualsTools(
 
 export const VISUALS_BRIEF = `## Showing visuals
 
-When a chart, table, diagram or mockup would say more than prose, build a self-contained HTML page (a chart is an HTML page; a CDN library such as Chart.js is fine), check it with \`html_preview\` and fix what the screenshot and console show, then show it with \`html_render\` before your final reply. The reader sees the page above that reply, so add only what the page doesn't say. An SVG or image file you write shows inline when your reply links to it by its absolute path, as ![name](/abs/path.svg).`;
+When a chart, table, diagram or mockup would say more than prose, build a self-contained HTML page (a chart is an HTML page; a CDN library such as Chart.js is fine), check it with \`html_preview\` and fix what the screenshot and console show, then show it with \`html_render\` before your final reply. The reader sees the page above that reply, so add only what the page doesn't say. To revise a page you already showed, call \`html_render\` again with \`update\` set to its artifact id (even if the title changes), so it becomes the next version, not a second page. An SVG or image file you write shows inline when your reply links to it by its absolute path, as ![name](/abs/path.svg).`;
 
 // An orchestrator reads other sessions' text, so it gets the short form and
 // is told what to keep out of a page.

package/lib/artifacts/versions.ts

@@ -66,8 +66,9 @@ export function pageVersions(
   const versions = listVersions(a.page_id).map(toVersion);
   return {
     pageId: a.page_id,
+    title: versions[versions.length - 1]?.title ?? a.title,
     latestId: versions[versions.length - 1]?.id ?? a.id,
     versions,
-    actions: pageActions(ctx),
+    actions: pageActions({ ...ctx, versions: versions.length }),
   };
 }