@agent-native/core 0.106.0 → 0.106.2

package/corpus/templates/design/actions/propose-node-rewrite.ts

@@ -0,0 +1,290 @@
+import { defineAction } from "@agent-native/core";
+import {
+  compareAndSetAppState,
+  readAppState,
+  writeAppState,
+} from "@agent-native/core/application-state";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  readLiveSourceFile,
+  type SourceWorkspaceFile,
+} from "../server/source-workspace.js";
+import type { CodeLayerSource } from "../shared/code-layer.js";
+import {
+  designRepromptPendingStateKey,
+  designRepromptProposalStateKey,
+  MAX_NODE_REWRITE_PROPOSAL_BYTES,
+  resolveNodeRewriteTarget,
+  validateNodeRewriteVariant,
+  type NodeHtmlPreviewBridgeMessage,
+  type NodeRewriteProposal,
+  type NodeRewriteTarget,
+} from "../shared/node-rewrite.js";
+import { designSourceTypeFromData } from "../shared/source-mode.js";
+
+const sourceSchema = z
+  .object({
+    designId: z.string().min(1).optional(),
+    fileId: z.string().min(1).optional(),
+    filename: z.string().min(1).optional(),
+  })
+  .superRefine((source, ctx) => {
+    if (!source.designId && !source.fileId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["designId"],
+        message: "source.designId or source.fileId is required",
+      });
+    }
+  });
+
+const targetSchema = z
+  .object({
+    nodeId: z.string().min(1).optional(),
+    selector: z.string().min(1).optional(),
+  })
+  .superRefine((target, ctx) => {
+    if (!target.nodeId && !target.selector) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["nodeId"],
+        message: "target.nodeId or target.selector is required",
+      });
+    }
+  });
+
+const variantSchema = z.object({
+  html: z
+    .string()
+    .min(1)
+    .max(250_000)
+    .describe("Replacement outerHTML for the selected subtree"),
+  summary: z.string().trim().min(1).max(240),
+});
+
+const pendingRepromptSchema = z.object({
+  repromptId: z.string().min(1),
+  designId: z.string().min(1),
+  fileId: z.string().min(1),
+  target: targetSchema,
+  baseVersionHash: z.string().min(1),
+  instruction: z.string(),
+  createdAt: z.string(),
+  priorProposalId: z.string().min(1).optional(),
+  priorRepromptId: z.string().min(1).optional(),
+});
+
+interface EditableDesignFile extends SourceWorkspaceFile {
+  designData: string | null;
+}
+
+async function resolveEditableDesignFile(source: {
+  designId?: string;
+  fileId?: string;
+  filename?: string;
+}): Promise<EditableDesignFile> {
+  const db = getDb();
+  const conditions = [
+    accessFilter(schema.designs, schema.designShares),
+    source.fileId
+      ? eq(schema.designFiles.id, source.fileId)
+      : eq(schema.designFiles.designId, source.designId ?? ""),
+  ];
+  if (!source.fileId) {
+    conditions.push(
+      eq(schema.designFiles.filename, source.filename ?? "index.html"),
+    );
+  }
+
+  const [file] = await db
+    .select({
+      id: schema.designFiles.id,
+      designId: schema.designFiles.designId,
+      filename: schema.designFiles.filename,
+      fileType: schema.designFiles.fileType,
+      content: schema.designFiles.content,
+      createdAt: schema.designFiles.createdAt,
+      updatedAt: schema.designFiles.updatedAt,
+      designData: schema.designs.data,
+    })
+    .from(schema.designFiles)
+    .innerJoin(
+      schema.designs,
+      eq(schema.designFiles.designId, schema.designs.id),
+    )
+    .where(and(...conditions))
+    .limit(1);
+
+  if (!file) throw new Error("Design HTML file not found.");
+  if (source.designId && source.designId !== file.designId) {
+    throw new Error(
+      `source.designId "${source.designId}" does not match file "${file.id}"`,
+    );
+  }
+  if (source.filename && source.filename !== file.filename) {
+    throw new Error(
+      `source.filename "${source.filename}" does not match file "${file.id}"`,
+    );
+  }
+  if (file.fileType !== "html") {
+    throw new Error("Node rewrites only support HTML design files.");
+  }
+  if (designSourceTypeFromData(file.designData) !== "inline") {
+    throw new Error("Node rewrites only support inline design screens.");
+  }
+  await assertAccess("design", file.designId, "editor");
+  return file;
+}
+
+function targetsMatch(a: NodeRewriteTarget, b: NodeRewriteTarget): boolean {
+  const nodeIdsConflict = a.nodeId && b.nodeId && a.nodeId !== b.nodeId;
+  const selectorsConflict =
+    a.selector && b.selector && a.selector !== b.selector;
+  if (nodeIdsConflict || selectorsConflict) return false;
+  return Boolean(
+    (a.nodeId && b.nodeId && a.nodeId === b.nodeId) ||
+    (a.selector && b.selector && a.selector === b.selector),
+  );
+}
+
+export default defineAction({
+  description:
+    "Propose one to three scoped HTML rewrites for a pending Design selection. " +
+    "This previews only: it stores proposal state and never changes the design file. " +
+    "The target must identify, and the reprompt id and base hash must exactly match, the pending client selection.",
+  schema: z.object({
+    source: sourceSchema,
+    target: targetSchema,
+    baseVersionHash: z.string().min(1),
+    variants: z.array(variantSchema).min(1).max(3),
+    repromptId: z.string().min(1),
+  }),
+  run: async ({ source, target, baseVersionHash, variants, repromptId }) => {
+    const file = await resolveEditableDesignFile(source);
+    const sourceDescriptor: CodeLayerSource = {
+      kind: "design-file",
+      sourceType: "inline",
+      designId: file.designId,
+      fileId: file.id,
+      filename: file.filename,
+    };
+    const live = await readLiveSourceFile(file);
+    if (live.versionHash !== baseVersionHash) {
+      throw new Error(
+        "Screen changed since the selection was captured — regenerate the proposal.",
+      );
+    }
+
+    const pendingKey = designRepromptPendingStateKey(file.designId, file.id);
+    const pending = pendingRepromptSchema.parse(await readAppState(pendingKey));
+    if (pending.repromptId !== repromptId) {
+      throw new Error("Pending reprompt does not match this request.");
+    }
+    if (
+      pending.designId !== file.designId ||
+      pending.fileId !== file.id ||
+      !targetsMatch(pending.target, target)
+    ) {
+      throw new Error(
+        "The proposed target does not match the pending selected subtree.",
+      );
+    }
+    if (pending.baseVersionHash !== baseVersionHash) {
+      throw new Error(
+        "The proposal base hash does not match the pending selection.",
+      );
+    }
+
+    const authoritativeTarget = pending.target;
+    const node = resolveNodeRewriteTarget(
+      live.content,
+      authoritativeTarget,
+      sourceDescriptor,
+    );
+    const validatedVariants = variants.map((variant) =>
+      validateNodeRewriteVariant(variant, sourceDescriptor),
+    );
+    const proposalId = `node-rewrite-${nanoid()}`;
+    const resolvedTarget = {
+      nodeId: node.id,
+      selector: node.selector,
+    };
+    const proposal: NodeRewriteProposal = {
+      proposalId,
+      repromptId,
+      designId: file.designId,
+      fileId: file.id,
+      filename: file.filename,
+      target: authoritativeTarget,
+      resolvedTarget,
+      baseVersionHash,
+      variants: validatedVariants,
+      chosenIndex: 0,
+      createdAt: new Date().toISOString(),
+    };
+    const serializedProposal = JSON.stringify(proposal);
+    if (
+      Buffer.byteLength(serializedProposal, "utf8") >
+      MAX_NODE_REWRITE_PROPOSAL_BYTES
+    ) {
+      throw new Error(
+        "Generated candidates are too large to preview safely. Use fewer variants or regenerate a smaller selected subtree.",
+      );
+    }
+    const proposalKey = designRepromptProposalStateKey(
+      file.designId,
+      file.id,
+      repromptId,
+    );
+    await writeAppState(
+      proposalKey,
+      proposal as unknown as Record<string, unknown>,
+    );
+    const currentPending = await readAppState(pendingKey);
+    if (currentPending?.repromptId !== repromptId) {
+      await compareAndSetAppState(
+        proposalKey,
+        proposal as unknown as Record<string, unknown>,
+        null,
+      );
+      throw new Error(
+        "This regeneration was superseded by a newer request before its candidates were published.",
+      );
+    }
+    if (pending.priorProposalId && pending.priorRepromptId) {
+      const priorProposalKey = designRepromptProposalStateKey(
+        file.designId,
+        file.id,
+        pending.priorRepromptId,
+      );
+      const priorProposal = await readAppState(priorProposalKey);
+      if (priorProposal?.proposalId === pending.priorProposalId) {
+        await compareAndSetAppState(priorProposalKey, priorProposal, null);
+      }
+    }
+
+    const bridgeMessages: NodeHtmlPreviewBridgeMessage[] = [
+      {
+        type: "node-html-preview",
+        proposalId,
+        target: resolvedTarget,
+        html: validatedVariants[0]!.html,
+        operation: "preview",
+      },
+    ];
+    return {
+      proposalId,
+      repromptId,
+      designId: file.designId,
+      fileId: file.id,
+      target: resolvedTarget,
+      variants: validatedVariants,
+      bridgeMessages,
+    };
+  },
+});

package/corpus/templates/design/actions/resolve-node-rewrite.ts

@@ -0,0 +1,257 @@
+import { defineAction } from "@agent-native/core";
+import {
+  compareAndSetAppState,
+  listAppState,
+  readAppState,
+} from "@agent-native/core/application-state";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  readLiveSourceFile,
+  writeInlineSourceFile,
+  type SourceWorkspaceFile,
+} from "../server/source-workspace.js";
+import type { CodeLayerSource } from "../shared/code-layer.js";
+import {
+  DESIGN_REPROMPT_PROPOSAL_STATE_PREFIX,
+  designRepromptPendingStateKey,
+  designRepromptProposalStateKey,
+  isPendingDesignReprompt,
+  spliceNodeRewriteVariant,
+  type NodeHtmlPreviewBridgeMessage,
+  type NodeRewriteProposal,
+} from "../shared/node-rewrite.js";
+import { designSourceTypeFromData } from "../shared/source-mode.js";
+
+const targetSchema = z
+  .object({
+    nodeId: z.string().min(1).optional(),
+    selector: z.string().min(1).optional(),
+  })
+  .superRefine((target, ctx) => {
+    if (!target.nodeId && !target.selector) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["nodeId"],
+        message: "target.nodeId or target.selector is required",
+      });
+    }
+  });
+
+const proposalSchema = z.object({
+  proposalId: z.string().min(1),
+  repromptId: z.string().min(1),
+  designId: z.string().min(1),
+  fileId: z.string().min(1),
+  filename: z.string().min(1),
+  target: targetSchema,
+  resolvedTarget: z.object({
+    nodeId: z.string().min(1),
+    selector: z.string().min(1),
+  }),
+  baseVersionHash: z.string().min(1),
+  variants: z
+    .array(
+      z.object({
+        html: z.string().min(1).max(250_000),
+        summary: z.string().min(1).max(240),
+      }),
+    )
+    .min(1)
+    .max(3),
+  chosenIndex: z.number().int().min(0),
+  createdAt: z.string(),
+});
+
+interface EditableDesignFile extends SourceWorkspaceFile {
+  designData: string | null;
+}
+
+async function resolveProposal(proposalId: string): Promise<{
+  key: string;
+  proposal: NodeRewriteProposal;
+}> {
+  const candidates = await listAppState(DESIGN_REPROMPT_PROPOSAL_STATE_PREFIX);
+  const matches = candidates.filter(
+    ({ value }) => value.proposalId === proposalId,
+  );
+  if (matches.length !== 1) {
+    throw new Error(
+      matches.length === 0
+        ? "Node rewrite proposal not found or already resolved."
+        : "Multiple node rewrite proposals matched this id.",
+    );
+  }
+  const match = matches[0]!;
+  const proposal = proposalSchema.parse(match.value) as NodeRewriteProposal;
+  const expectedKey = designRepromptProposalStateKey(
+    proposal.designId,
+    proposal.fileId,
+    proposal.repromptId,
+  );
+  if (match.key !== expectedKey) {
+    throw new Error("Node rewrite proposal state is scoped to the wrong file.");
+  }
+  return { key: match.key, proposal };
+}
+
+async function resolveEditableDesignFile(
+  proposal: NodeRewriteProposal,
+): Promise<EditableDesignFile> {
+  const db = getDb();
+  const [file] = await db
+    .select({
+      id: schema.designFiles.id,
+      designId: schema.designFiles.designId,
+      filename: schema.designFiles.filename,
+      fileType: schema.designFiles.fileType,
+      content: schema.designFiles.content,
+      createdAt: schema.designFiles.createdAt,
+      updatedAt: schema.designFiles.updatedAt,
+      designData: schema.designs.data,
+    })
+    .from(schema.designFiles)
+    .innerJoin(
+      schema.designs,
+      eq(schema.designFiles.designId, schema.designs.id),
+    )
+    .where(
+      and(
+        accessFilter(schema.designs, schema.designShares),
+        eq(schema.designFiles.id, proposal.fileId),
+        eq(schema.designFiles.designId, proposal.designId),
+      ),
+    )
+    .limit(1);
+
+  if (!file) throw new Error("Design HTML file not found.");
+  if (file.filename !== proposal.filename || file.fileType !== "html") {
+    throw new Error("Node rewrite proposal no longer matches its HTML file.");
+  }
+  if (designSourceTypeFromData(file.designData) !== "inline") {
+    throw new Error("Node rewrites only support inline design screens.");
+  }
+  await assertAccess("design", proposal.designId, "editor");
+  return file;
+}
+
+async function clearProposalState(
+  proposalKey: string,
+  proposal: NodeRewriteProposal,
+  pending: Record<string, unknown>,
+): Promise<void> {
+  const pendingKey = designRepromptPendingStateKey(
+    proposal.designId,
+    proposal.fileId,
+  );
+  const [proposalCleared] = await Promise.all([
+    compareAndSetAppState(
+      proposalKey,
+      proposal as unknown as Record<string, unknown>,
+      null,
+    ),
+    compareAndSetAppState(pendingKey, pending, null),
+  ]);
+  if (!proposalCleared) {
+    throw new Error("Node rewrite proposal changed while it was resolving.");
+  }
+}
+
+export default defineAction({
+  agentTool: false,
+  description:
+    "Accept or reject a pending scoped Design node rewrite. Accept performs one " +
+    "version-checked inline/Yjs content transaction; reject changes no design content. " +
+    "Both resolutions clear the proposal and its matching paired pending reprompt.",
+  schema: z.object({
+    proposalId: z.string().min(1),
+    resolution: z.enum(["accept", "reject"]),
+    variantIndex: z.number().int().min(0).optional(),
+  }),
+  run: async ({ proposalId, resolution, variantIndex }) => {
+    const { key: proposalKey, proposal } = await resolveProposal(proposalId);
+    const pendingKey = designRepromptPendingStateKey(
+      proposal.designId,
+      proposal.fileId,
+    );
+    const pending = await readAppState(pendingKey);
+    if (
+      !isPendingDesignReprompt(pending) ||
+      pending.repromptId !== proposal.repromptId
+    ) {
+      throw new Error(
+        "A newer regeneration request replaced this proposal. Review the latest candidates instead.",
+      );
+    }
+    const restoreMessage: NodeHtmlPreviewBridgeMessage = {
+      type: "node-html-preview",
+      proposalId,
+      target: proposal.resolvedTarget,
+      operation: "restore",
+    };
+
+    if (resolution === "reject") {
+      await assertAccess("design", proposal.designId, "editor");
+      await clearProposalState(proposalKey, proposal, pending);
+      return {
+        proposalId,
+        repromptId: proposal.repromptId,
+        resolution,
+        changed: false,
+        bridgeMessages: [restoreMessage],
+      };
+    }
+
+    const file = await resolveEditableDesignFile(proposal);
+    const chosenIndex = variantIndex ?? proposal.chosenIndex;
+    const variant = proposal.variants[chosenIndex];
+    if (!variant) {
+      throw new Error(
+        `Variant index ${chosenIndex} is out of range for this proposal.`,
+      );
+    }
+
+    const live = await readLiveSourceFile(file);
+    if (live.versionHash !== proposal.baseVersionHash) {
+      throw new Error(
+        "Screen changed since proposal — regenerate before accepting.",
+      );
+    }
+    const source: CodeLayerSource = {
+      kind: "design-file",
+      sourceType: "inline",
+      designId: file.designId,
+      fileId: file.id,
+      filename: file.filename,
+    };
+    const rewrite = spliceNodeRewriteVariant({
+      content: live.content,
+      target: proposal.resolvedTarget,
+      variant,
+      source,
+      fileType: file.fileType,
+    });
+    const write = await writeInlineSourceFile({
+      designId: file.designId,
+      file,
+      content: rewrite.content,
+      expectedVersionHash: proposal.baseVersionHash,
+    });
+    await clearProposalState(proposalKey, proposal, pending);
+
+    return {
+      proposalId,
+      repromptId: proposal.repromptId,
+      resolution,
+      variantIndex: chosenIndex,
+      summary: variant.summary,
+      changed: write.changed,
+      designId: file.designId,
+      fileId: file.id,
+      versionHash: write.versionHash,
+    };
+  },
+});

package/corpus/templates/design/actions/view-screen.ts

@@ -9,6 +9,7 @@
 
 import { defineAction } from "@agent-native/core";
 import {
+  listAppState,
   readAppState,
   readAppStateForCurrentTab,
 } from "@agent-native/core/application-state";
@@ -30,6 +31,14 @@ import { getDb, schema } from "../server/db/index.js";
 import { parseCanvasFrameGeometryById } from "../shared/canvas-frames.js";
 import { getDesignTemplatePreset } from "../shared/design-template-presets.js";
 import { designGenerationSessionKey } from "../shared/generation-session.js";
+import {
+  DESIGN_REPROMPT_PENDING_STATE_PREFIX,
+  DESIGN_REPROMPT_PROPOSAL_STATE_PREFIX,
+  designRepromptPendingStateKey,
+  designRepromptProposalStateKey,
+  isNodeRewriteProposal,
+  isPendingDesignReprompt,
+} from "../shared/node-rewrite.js";
 
 interface ReviewThreadSummary {
   openCount: number;
@@ -309,14 +318,101 @@ export default defineAction({
             data = {};
           }
         }
+        const activeScreen = resolveActiveScreen(
+          files,
+          navigation,
+          designSelection,
+        );
         screen.design = {
           id: designId,
           title: (access.resource as { title?: unknown }).title ?? null,
           screens: files,
-          activeScreen: resolveActiveScreen(files, navigation, designSelection),
+          activeScreen,
           activeCodeFile: resolveActiveCodeFile(files, designSelection),
           canvasFrames: parseCanvasFrameGeometryById(data.canvasFrames),
         };
+        const proposalPrefix = `${DESIGN_REPROMPT_PROPOSAL_STATE_PREFIX}${designId}:`;
+        const pendingPrefix = `${DESIGN_REPROMPT_PENDING_STATE_PREFIX}${designId}:`;
+        const [proposalEntries, pendingEntries] = await Promise.all([
+          listAppState(proposalPrefix),
+          listAppState(pendingPrefix),
+        ]);
+        const filesById = new Map(files.map((file) => [file.id, file]));
+        const pendingByFileId = new Map(
+          pendingEntries.flatMap(({ key, value }) => {
+            if (
+              !isPendingDesignReprompt(value) ||
+              value.designId !== designId ||
+              !filesById.has(value.fileId) ||
+              key !== designRepromptPendingStateKey(designId, value.fileId)
+            ) {
+              return [];
+            }
+            return [[value.fileId, value] as const];
+          }),
+        );
+        const proposalsByReprompt = new Map(
+          proposalEntries.flatMap(({ key, value }) => {
+            if (
+              !isNodeRewriteProposal(value) ||
+              value.designId !== designId ||
+              !filesById.has(value.fileId) ||
+              key !==
+                designRepromptProposalStateKey(
+                  designId,
+                  value.fileId,
+                  value.repromptId,
+                )
+            ) {
+              return [];
+            }
+            return [[`${value.fileId}:${value.repromptId}`, value] as const];
+          }),
+        );
+        const proposalsByFileId = new Map(
+          [...pendingByFileId.entries()].flatMap(([fileId, pending]) => {
+            const current = proposalsByReprompt.get(
+              `${fileId}:${pending.repromptId}`,
+            );
+            const prior = pending.priorRepromptId
+              ? proposalsByReprompt.get(`${fileId}:${pending.priorRepromptId}`)
+              : undefined;
+            const proposal =
+              current ??
+              (prior?.proposalId === pending.priorProposalId
+                ? prior
+                : undefined);
+            return proposal ? [[fileId, proposal] as const] : [];
+          }),
+        );
+        const pendingCandidateReviews = [...proposalsByFileId.values()].map(
+          (proposal) => {
+            const file = filesById.get(proposal.fileId)!;
+            return {
+              proposalId: proposal.proposalId,
+              fileId: proposal.fileId,
+              filename: proposal.filename || file.filename,
+              candidateCount: proposal.variants.length,
+              chosenIndex: proposal.chosenIndex,
+              target: proposal.target,
+              createdAt: proposal.createdAt,
+            };
+          },
+        );
+        if (pendingCandidateReviews.length > 0) {
+          (screen.design as Record<string, unknown>).pendingCandidateReviews =
+            pendingCandidateReviews;
+        }
+        if (activeScreen?.id) {
+          const pendingReprompt = pendingByFileId.get(activeScreen.id);
+          const proposal = proposalsByFileId.get(activeScreen.id);
+          if (pendingReprompt || proposal) {
+            (screen.design as Record<string, unknown>).reprompt = {
+              pending: pendingReprompt ?? null,
+              proposal: proposal ?? null,
+            };
+          }
+        }
         const reviewContext = ctx as ReviewResourceContext | undefined;
         const reviewScope = {
           userEmail: reviewContext?.userEmail ?? null,
@@ -357,7 +453,7 @@ export default defineAction({
           redactReviewIdentity
             ? redactPublicReviewStatusIdentity(reviewStatus)
             : reviewStatus,
-          resolveActiveScreen(files, navigation, designSelection)?.id,
+          activeScreen?.id,
           reviewSummary,
         );
       }