@agent-native/core 0.149.4 → 0.149.6

package/corpus/templates/slides/actions/update-slide.ts

@@ -16,6 +16,11 @@ import { normalizeSlidePadding } from "../app/lib/normalize-slide-padding.js";
 import { getDb, schema } from "../server/db/index.js"; // ensure registerShareableResource runs
 import { notifyClients } from "../server/handlers/decks.js";
 import { createDeckVersionSnapshot } from "../server/lib/deck-versions.js";
+import {
+  applySlideContentEdits,
+  formatSlideHtml,
+  type SlideContentEdit,
+} from "../server/lib/slide-content-patch.js";
 import {
   assertSourceSlidePreserved,
   sourceImportForDeck,
@@ -92,8 +97,7 @@ function storedCreativeContext(value: unknown): {
 
 export default defineAction({
   description:
-    "Surgically edit a slide's content using search-replace or full replacement. " +
-    "Syncs live to open editors. Prefer this over full deck rewrites. Source-imported slides preserve their original images and factual copy by default.",
+    "Atomically patch a slide's HTML like a code editor: send several exact edits against the current source, optionally format it with Prettier, and sync the result live to open editors. Prefer edits over fullContent so unrelated markup is not regenerated. Use baseContentHash from get-deck to reject stale patches. Content edits clear existing click-reveal metadata; use patch-deck with the complete animations list when the edit intentionally changes both content and reveals. Source-imported slides preserve their original images and factual copy by default.",
   schema: z.object({
     deckId: z.string().describe("Deck ID"),
     slideId: z.string().describe("Slide ID"),
@@ -109,6 +113,64 @@ export default defineAction({
       .string()
       .optional()
       .describe("Full HTML to replace entire slide content"),
+    edits: z
+      .array(
+        z.union([
+          z.object({
+            op: z.literal("replace").optional(),
+            find: z.string(),
+            replace: z.string(),
+            all: z.boolean().optional(),
+            occurrence: z.number().int().positive().optional(),
+            expectedMatches: z.number().int().nonnegative().optional(),
+            required: z.boolean().optional(),
+          }),
+          z.object({
+            op: z.enum(["insert-before", "insert-after"]),
+            marker: z.string(),
+            content: z.string(),
+            occurrence: z.number().int().positive().optional(),
+            expectedMatches: z.number().int().nonnegative().optional(),
+            required: z.boolean().optional(),
+          }),
+          z.object({
+            op: z.literal("replace-between"),
+            start: z.string(),
+            end: z.string(),
+            content: z.string(),
+            includeDelimiters: z.boolean().optional(),
+            expectedMatches: z.number().int().nonnegative().optional(),
+            required: z.boolean().optional(),
+          }),
+          z.object({
+            op: z.literal("regex-replace"),
+            pattern: z.string(),
+            replace: z.string(),
+            flags: z.string().optional(),
+            all: z.boolean().optional(),
+            expectedMatches: z.number().int().nonnegative().optional(),
+            required: z.boolean().optional(),
+          }),
+        ]),
+      )
+      .min(1)
+      .optional()
+      .describe(
+        "Ordered atomic edits against the current HTML. Each edit must match unless required=false. Use expectedMatches to make ambiguity explicit.",
+      ),
+    baseContentHash: z
+      .string()
+      .optional()
+      .describe(
+        "Hash returned by get-deck for the exact slide source being patched. The edit is rejected if the source changed since it was read.",
+      ),
+    format: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe(
+        "Format the resulting HTML with Prettier before persisting it.",
+      ),
     preserveSource: z
       .boolean()
       .optional()
@@ -142,13 +204,24 @@ export default defineAction({
       find,
       replace,
       fullContent,
+      edits,
+      baseContentHash,
+      format,
       preserveSource,
       contextPackId,
       contextModeOverride,
       reuseLabels,
     } = args;
-    if (!find && !fullContent) {
-      throw new Error("Either --find or --fullContent is required");
+    if (!edits && find === undefined && fullContent === undefined) {
+      throw new Error("One of --edits, --find, or --fullContent is required");
+    }
+    if (find !== undefined && find.length === 0) {
+      throw new Error("find must not be empty for legacy search/replace");
+    }
+    if (edits && (find !== undefined || fullContent !== undefined)) {
+      throw new Error(
+        "Use --edits instead of combining it with --find or --fullContent",
+      );
     }
     await assertAccess("deck", deckId, "editor");
 
@@ -203,6 +276,15 @@ export default defineAction({
         throw new Error(`Slide ${slideId} not found in deck ${deckId}`);
       }
 
+      if (
+        baseContentHash !== undefined &&
+        hashSlideContent(String(slide.content ?? "")) !== baseContentHash
+      ) {
+        throw new Error(
+          "Slide content changed since it was read. Call get-deck with this slideId again and rebase the patch.",
+        );
+      }
+
       // ─── Apply the edit to the slide content in decks.data ────────────────
       //
       // The agent edits the canonical slide HTML stored in `decks.data` (SQL is
@@ -215,8 +297,9 @@ export default defineAction({
       // structure renders and merges with concurrent typing via the Yjs CRDT.
       let applied = false;
       let notFound = false;
+      const previousContent = String(slide.content ?? "");
 
-      if (fullContent) {
+      if (fullContent !== undefined) {
         const nextContent = normalizeSlidePadding(fullContent);
         assertSourceSlidePreserved({
           metadata: sourceImportForDeck(deck.sourceImport),
@@ -225,16 +308,35 @@ export default defineAction({
           preserveSource,
         });
         slide.content = nextContent;
-        applied = true;
-      } else if (find) {
-        const idx = (slide.content as string).indexOf(find);
+        applied = nextContent !== previousContent;
+      } else if (edits) {
+        const sourceContent = format
+          ? await formatSlideHtml(previousContent)
+          : previousContent;
+        const patched = await applySlideContentEdits(
+          sourceContent,
+          edits as SlideContentEdit[],
+          format,
+        );
+        const nextContent = normalizeSlidePadding(patched.content);
+        assertSourceSlidePreserved({
+          metadata: sourceImportForDeck(deck.sourceImport),
+          slideId,
+          nextContent,
+          preserveSource,
+        });
+        slide.content = nextContent;
+        applied = patched.changed;
+        if (!applied) slide.content = previousContent;
+      } else if (find !== undefined) {
+        const idx = previousContent.indexOf(find);
         if (idx === -1) {
           notFound = true;
         } else {
           const nextContent =
-            slide.content.slice(0, idx) +
+            previousContent.slice(0, idx) +
             (replace ?? "") +
-            slide.content.slice(idx + find.length);
+            previousContent.slice(idx + find.length);
           assertSourceSlidePreserved({
             metadata: sourceImportForDeck(deck.sourceImport),
             slideId,
@@ -242,10 +344,19 @@ export default defineAction({
             preserveSource,
           });
           slide.content = nextContent;
-          applied = true;
+          applied = nextContent !== previousContent;
         }
       }
 
+      // Animation targets are paths into the persisted HTML. A content edit
+      // can keep every path valid while changing which visual element lives at
+      // that path, so preserving the old list would reveal the wrong content.
+      // patch-deck is the explicit escape hatch when content and animations
+      // are intentionally revised together.
+      if (applied && Array.isArray(slide.animations)) {
+        delete slide.animations;
+      }
+
       // ─── Persist to SQL ───────────────────────────────────────────────────
       //
       // The fresh `updatedAt` (on both the deck JSON and the row) is the signal
@@ -352,23 +463,41 @@ export default defineAction({
           notFound,
           slide,
           slideIndex,
+          contentHash: hashSlideContent(String(slide.content ?? "")),
           contextMode,
           contextPackId: validated.contextPackId,
           reuseLabels: slideReuseLabels,
         };
       }
 
-      return { applied, notFound, slide, slideIndex };
+      return {
+        applied,
+        notFound,
+        slide,
+        slideIndex,
+        contentHash: hashSlideContent(String(slide.content ?? "")),
+      };
     });
 
     if (rmw.notFound) {
       return {
         ok: false,
-        message: `Text not found in slide: "${find!.slice(0, 60)}". Use get-deck with compact=false to see the current slide HTML.`,
+        message: `Text not found in slide: "${find!.slice(0, 60)}". Use get-deck with this slideId to see the current slide HTML.`,
       };
     }
 
     const { applied } = rmw;
+    if (!applied) {
+      return {
+        ok: true,
+        deckId,
+        slideId,
+        applied: false,
+        contentHash: rmw.contentHash,
+        deepLink: deckDeepLink(deckId),
+      };
+    }
+
     // Start the freshness window after the SQL write and before notifying the
     // editor. This keeps a fast render from being rejected as stale.
     const fitSince = Date.now();
@@ -390,7 +519,7 @@ export default defineAction({
     notifyClients(deckId, { slideId, actor: "agent" });
 
     console.log(
-      `update-slide: deck=${deckId} slide=${slideId} ${find ? `find="${find.slice(0, 40)}"` : "fullContent"} applied=${applied}`,
+      `update-slide: deck=${deckId} slide=${slideId} ${edits ? `edits=${edits.length}` : find !== undefined ? `find="${find.slice(0, 40)}"` : "fullContent"} applied=${applied}`,
     );
 
     // Wait briefly for the editor to re-render and measure. If the patched
@@ -408,6 +537,7 @@ export default defineAction({
       deckId,
       slideId,
       applied,
+      contentHash: rmw.contentHash,
       deepLink: deckDeepLink(deckId),
       ...(rmw.contextMode
         ? {

package/corpus/templates/slides/app/lib/create-deck-generation.ts

@@ -108,11 +108,19 @@ export function isSourceImprovementRequest(
     /\bmake\b[\s\S]{0,40}\b(better|modern|professional|polished|prett\w*)\b/.test(
       normalized,
     );
+  const asksToPreserveSource =
+    /(?:\b(turn|convert|transform)\b[\s\S]{0,50}\b(into|to)\b[\s\S]{0,30}\b(deck|presentation|slides?)\b|\b(create|build|make|generate)\b[\s\S]{0,80}\b(deck|presentation|slides?)\b[\s\S]{0,80}\bfrom\b)/.test(
+      normalized,
+    ) &&
+    /\b(copy|slide[- ]for[- ]slide|preserv\w*|same order|before\s*\/?\s*after|placeholder\w*|out of order)\b/.test(
+      normalized,
+    );
   // A source deck attachment is the object being improved even when the
-  // prompt uses an implicit phrase such as "make this prettier". Requiring a
-  // source noun here silently falls back to reference-only generation and can
-  // discard the uploaded deck's slide IDs and content.
-  return asksToImprove;
+  // prompt uses an implicit phrase such as "make this prettier" or asks to
+  // copy and restyle it. Requiring a source noun here silently falls back to
+  // reference-only generation and can discard the uploaded deck's slide IDs
+  // and content.
+  return asksToImprove || asksToPreserveSource;
 }
 
 function describeUploadedFilesForAgent(

package/corpus/templates/slides/changelog/2026-08-11-pdf-requests-to-restyle-and-preserve-a-source-deck-now-impor.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-11
+---
+
+PDF requests to restyle and preserve a source deck now import the full deck before editing

package/corpus/templates/slides/changelog/2026-08-11-slide-edits-preserve-their-layout-without-introducing-hidden.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-11
+---
+
+Slide edits preserve their layout without introducing hidden duplicate elements or stale click reveals

package/corpus/templates/slides/changelog/2026-08-11-slides-reliably-imports-uploaded-pdfs-and-presentations.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-11
+---
+
+Slides reliably imports uploaded PDFs and presentations

package/corpus/templates/slides/changelog/2026-08-11-slides-support-atomic-code-style-html-patches-without-regene.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-11
+---
+
+Slides support atomic code-style HTML patches without regenerating whole slides

package/corpus/templates/slides/package.json

@@ -57,6 +57,7 @@
     "pdf-parse": "^2.4.5",
     "pdfjs-dist": "5.4.296",
     "pptxgenjs": "4.0.1",
+    "prettier": "^3.9.6",
     "react-markdown": "^10.1.0",
     "rehype-raw": "^7.0.0",
     "y-protocols": "catalog:",

package/corpus/templates/slides/server/lib/slide-content-patch.ts

@@ -0,0 +1,355 @@
+export type SlideContentEdit =
+  | {
+      op?: "replace";
+      find: string;
+      replace: string;
+      all?: boolean;
+      occurrence?: number;
+      expectedMatches?: number;
+      required?: boolean;
+    }
+  | {
+      op: "insert-before" | "insert-after";
+      marker: string;
+      content: string;
+      occurrence?: number;
+      expectedMatches?: number;
+      required?: boolean;
+    }
+  | {
+      op: "replace-between";
+      start: string;
+      end: string;
+      content: string;
+      includeDelimiters?: boolean;
+      expectedMatches?: number;
+      required?: boolean;
+    }
+  | {
+      op: "regex-replace";
+      pattern: string;
+      replace: string;
+      flags?: string;
+      all?: boolean;
+      expectedMatches?: number;
+      required?: boolean;
+    };
+
+export class SlideContentEditError extends Error {
+  readonly code = "slide_content_edit_failed";
+
+  constructor(message: string) {
+    super(message);
+    this.name = "SlideContentEditError";
+  }
+}
+
+export interface SlideContentPatchResult {
+  content: string;
+  applied: string[];
+  formatted: boolean;
+  changed: boolean;
+}
+
+/**
+ * Applies every edit to an in-memory string before the caller persists it.
+ * A failed edit throws, so callers never write a partially applied patch list.
+ */
+export async function applySlideContentEdits(
+  currentContent: string,
+  edits: readonly SlideContentEdit[],
+  format = false,
+): Promise<SlideContentPatchResult> {
+  try {
+    let content = currentContent;
+    const applied: string[] = [];
+
+    for (const edit of edits) {
+      const result = applyEdit(content, edit);
+      content = result.content;
+      applied.push(result.summary);
+    }
+
+    const changed = content !== currentContent;
+
+    if (format) {
+      content = await formatSlideHtml(content);
+    }
+
+    return { content, applied, formatted: format, changed };
+  } catch (error) {
+    if (error instanceof SlideContentEditError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new SlideContentEditError(message);
+  }
+}
+
+export async function formatSlideHtml(content: string): Promise<string> {
+  try {
+    const prettier = await import("prettier");
+    return await prettier.format(content, {
+      parser: "html",
+      htmlWhitespaceSensitivity: "ignore",
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (
+      message.includes("Cannot find package 'prettier'") ||
+      message.includes('Cannot find package "prettier"') ||
+      message.includes("Cannot find module 'prettier'") ||
+      message.includes('Cannot find module "prettier"')
+    ) {
+      throw new SlideContentEditError(
+        "HTML formatting is unavailable because Prettier is not installed",
+      );
+    }
+    throw new SlideContentEditError(`Unable to format slide HTML: ${message}`);
+  }
+}
+
+function applyEdit(
+  content: string,
+  edit: SlideContentEdit,
+): { content: string; summary: string } {
+  switch (edit.op ?? "replace") {
+    case "replace":
+      return applyLiteralReplace(
+        content,
+        edit as Extract<SlideContentEdit, { op?: "replace" }>,
+      );
+    case "insert-before":
+    case "insert-after":
+      return applyInsert(
+        content,
+        edit as Extract<
+          SlideContentEdit,
+          { op: "insert-before" | "insert-after" }
+        >,
+      );
+    case "replace-between":
+      return applyReplaceBetween(
+        content,
+        edit as Extract<SlideContentEdit, { op: "replace-between" }>,
+      );
+    case "regex-replace":
+      return applyRegexReplace(
+        content,
+        edit as Extract<SlideContentEdit, { op: "regex-replace" }>,
+      );
+    default:
+      throw new SlideContentEditError(
+        `Unsupported slide content edit operation: ${String(edit.op)}`,
+      );
+  }
+}
+
+function applyLiteralReplace(
+  content: string,
+  edit: Extract<SlideContentEdit, { op?: "replace" }>,
+): { content: string; summary: string } {
+  const matches = countOccurrences(content, edit.find);
+  assertMatchCount("replace", matches, edit.expectedMatches, edit.required);
+  if (matches === 0) return { content, summary: "replace:0" };
+
+  if (edit.occurrence !== undefined) {
+    return {
+      content: replaceNth(content, edit.find, edit.replace, edit.occurrence),
+      summary: `replace:nth:${edit.occurrence}`,
+    };
+  }
+
+  if (edit.all) {
+    return {
+      content: content.split(edit.find).join(edit.replace),
+      summary: `replace:all:${matches}`,
+    };
+  }
+
+  return {
+    content: content.replace(edit.find, edit.replace),
+    summary: "replace:first",
+  };
+}
+
+function applyInsert(
+  content: string,
+  edit: Extract<SlideContentEdit, { op: "insert-before" | "insert-after" }>,
+): { content: string; summary: string } {
+  const matches = countOccurrences(content, edit.marker);
+  assertMatchCount(edit.op, matches, edit.expectedMatches, edit.required);
+  if (matches === 0) return { content, summary: `${edit.op}:0` };
+
+  const occurrence = edit.occurrence ?? 1;
+  const index = nthIndexOf(content, edit.marker, occurrence);
+  if (index < 0) {
+    throw new SlideContentEditError(
+      `${edit.op} could not find occurrence ${occurrence}`,
+    );
+  }
+  const insertAt =
+    edit.op === "insert-before" ? index : index + edit.marker.length;
+  return {
+    content:
+      content.slice(0, insertAt) + edit.content + content.slice(insertAt),
+    summary: `${edit.op}:${occurrence}`,
+  };
+}
+
+function applyReplaceBetween(
+  content: string,
+  edit: Extract<SlideContentEdit, { op: "replace-between" }>,
+): { content: string; summary: string } {
+  const ranges = findBetweenRanges(content, edit.start, edit.end);
+  assertMatchCount(
+    "replace-between",
+    ranges.length,
+    edit.expectedMatches,
+    edit.required,
+  );
+  if (!ranges.length) return { content, summary: "replace-between:0" };
+  if (ranges.length > 1 && edit.expectedMatches === undefined) {
+    throw new SlideContentEditError(
+      `replace-between matched ${ranges.length} ranges; pass expectedMatches to confirm`,
+    );
+  }
+
+  let next = content;
+  for (const range of ranges.slice().reverse()) {
+    const start = edit.includeDelimiters ? range.start : range.innerStart;
+    const end = edit.includeDelimiters ? range.end : range.innerEnd;
+    next = next.slice(0, start) + edit.content + next.slice(end);
+  }
+  return { content: next, summary: `replace-between:${ranges.length}` };
+}
+
+function applyRegexReplace(
+  content: string,
+  edit: Extract<SlideContentEdit, { op: "regex-replace" }>,
+): { content: string; summary: string } {
+  const flags = normalizeRegexFlags(edit.flags, edit.all);
+  const regex = new RegExp(edit.pattern, flags);
+  const countRegex = new RegExp(edit.pattern, ensureGlobal(flags));
+  const matches = Array.from(content.matchAll(countRegex)).length;
+  assertMatchCount(
+    "regex-replace",
+    matches,
+    edit.expectedMatches,
+    edit.required,
+  );
+  if (matches === 0) return { content, summary: "regex-replace:0" };
+  return {
+    content: content.replace(regex, edit.replace),
+    summary: `regex-replace:${edit.all ? "all" : "first"}:${matches}`,
+  };
+}
+
+function assertMatchCount(
+  op: string,
+  actual: number,
+  expected: number | undefined,
+  required: boolean | undefined,
+): void {
+  if (expected !== undefined && actual !== expected) {
+    throw new SlideContentEditError(
+      `${op} expected ${expected} match(es), found ${actual}`,
+    );
+  }
+  if (expected === undefined && required !== false && actual === 0) {
+    throw new SlideContentEditError(`${op} found no matches`);
+  }
+}
+
+function countOccurrences(content: string, needle: string): number {
+  if (!needle) {
+    throw new SlideContentEditError("Patch find/marker text cannot be empty");
+  }
+  let count = 0;
+  let index = 0;
+  while (true) {
+    index = content.indexOf(needle, index);
+    if (index < 0) return count;
+    count += 1;
+    index += needle.length;
+  }
+}
+
+function nthIndexOf(
+  content: string,
+  needle: string,
+  occurrence: number,
+): number {
+  if (!Number.isInteger(occurrence) || occurrence < 1) {
+    throw new SlideContentEditError("occurrence must be a positive integer");
+  }
+  let index = -1;
+  let from = 0;
+  for (let i = 0; i < occurrence; i += 1) {
+    index = content.indexOf(needle, from);
+    if (index < 0) return -1;
+    from = index + needle.length;
+  }
+  return index;
+}
+
+function replaceNth(
+  content: string,
+  find: string,
+  replace: string,
+  occurrence: number,
+): string {
+  const index = nthIndexOf(content, find, occurrence);
+  if (index < 0) {
+    throw new SlideContentEditError(
+      `replace could not find occurrence ${occurrence}`,
+    );
+  }
+  return content.slice(0, index) + replace + content.slice(index + find.length);
+}
+
+function findBetweenRanges(
+  content: string,
+  startMarker: string,
+  endMarker: string,
+): Array<{ start: number; innerStart: number; innerEnd: number; end: number }> {
+  if (!startMarker || !endMarker) {
+    throw new SlideContentEditError(
+      "replace-between requires non-empty start and end markers",
+    );
+  }
+  const ranges: Array<{
+    start: number;
+    innerStart: number;
+    innerEnd: number;
+    end: number;
+  }> = [];
+  let cursor = 0;
+  while (cursor < content.length) {
+    const start = content.indexOf(startMarker, cursor);
+    if (start < 0) break;
+    const innerStart = start + startMarker.length;
+    const innerEnd = content.indexOf(endMarker, innerStart);
+    if (innerEnd < 0) {
+      throw new SlideContentEditError(
+        "replace-between found a start marker without an end",
+      );
+    }
+    const end = innerEnd + endMarker.length;
+    ranges.push({ start, innerStart, innerEnd, end });
+    cursor = end;
+  }
+  return ranges;
+}
+
+function normalizeRegexFlags(flags: string | undefined, all?: boolean): string {
+  const unique = new Set((flags ?? "").split("").filter(Boolean));
+  if (all) {
+    unique.add("g");
+  } else {
+    unique.delete("g");
+  }
+  return Array.from(unique).join("");
+}
+
+function ensureGlobal(flags: string): string {
+  return flags.includes("g") ? flags : `${flags}g`;
+}