@agent-native/creative-context 0.0.0-beta-20260820202238

package/src/store/generation.ts

@@ -0,0 +1,226 @@
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, desc, eq } from "drizzle-orm";
+
+import { getCreativeContext } from "../server/context.js";
+import {
+  assertGenerationArtifactAccessProof,
+  type GenerationArtifactAccessProof,
+} from "../server/generation-artifact-access.js";
+import type {
+  CreativeContextGenerationRecord,
+  CreativeContextElementProvenance,
+  CreativeContextReuseLabel,
+} from "../types.js";
+import {
+  newId,
+  nowIso,
+  parseJson,
+  requireActor,
+  stringifyJson,
+} from "./helpers.js";
+
+export function assertGenerationCreativeContextInvariants(input: {
+  contextMode: "off" | "auto" | "pinned";
+  contextPackId: string | null;
+  reuseLabels: readonly CreativeContextReuseLabel[];
+  elementProvenance: readonly CreativeContextElementProvenance[];
+}): void {
+  if (input.contextMode === "off" && input.contextPackId) {
+    throw new Error("Creative context off records cannot reference a pack");
+  }
+  if (input.contextMode === "pinned" && !input.contextPackId) {
+    throw new Error("Pinned creative context records require a context pack");
+  }
+
+  const references = [
+    ...input.reuseLabels.map((label) => ({
+      influence: label.influence ?? "reference-conditioned",
+      itemId: label.itemId,
+      itemVersionId: label.itemVersionId,
+    })),
+    ...input.elementProvenance,
+  ];
+  for (const reference of references) {
+    const hasItemId = Boolean(reference.itemId);
+    const hasItemVersionId = Boolean(reference.itemVersionId);
+    if (hasItemId !== hasItemVersionId) {
+      throw new Error(
+        "Creative context provenance must provide both itemId and itemVersionId",
+      );
+    }
+    if (reference.influence !== "generated" && !hasItemId) {
+      throw new Error(
+        "Only generated creative context provenance may omit item references",
+      );
+    }
+    if (!input.contextPackId && hasItemId) {
+      throw new Error(
+        "Creative context provenance cannot reference items without a context pack",
+      );
+    }
+    if (
+      input.contextMode === "off" &&
+      (reference.influence !== "generated" || hasItemId)
+    ) {
+      throw new Error(
+        "Creative context off records may contain only generated provenance without item references",
+      );
+    }
+  }
+}
+
+export async function recordGenerationCreativeContext(
+  input: {
+    appId: string;
+    artifactType: string;
+    artifactId: string;
+    contextMode: "off" | "auto" | "pinned";
+    contextPackId: string | null;
+    reuseLabels: CreativeContextReuseLabel[];
+    elementProvenance?: CreativeContextElementProvenance[];
+  },
+  options: {
+    db?: any;
+    artifactAccess?: GenerationArtifactAccessProof;
+  } = {},
+): Promise<CreativeContextGenerationRecord> {
+  const elementProvenance =
+    input.elementProvenance ??
+    input.reuseLabels.map((label, index) => ({
+      elementId: label.elementId ?? `reference:${index + 1}`,
+      influence: label.influence ?? ("reference-conditioned" as const),
+      ...(label.itemId ? { itemId: label.itemId } : {}),
+      ...(label.itemVersionId ? { itemVersionId: label.itemVersionId } : {}),
+      label: label.label,
+    }));
+  assertGenerationCreativeContextInvariants({
+    contextMode: input.contextMode,
+    contextPackId: input.contextPackId,
+    reuseLabels: input.reuseLabels,
+    elementProvenance,
+  });
+  if (input.contextPackId) {
+    await assertAccess(
+      "creative-context-pack",
+      input.contextPackId,
+      "viewer",
+      undefined,
+      { skipResourceBody: true },
+    );
+  }
+  if (input.contextPackId) {
+    const { getDb, schema } = getCreativeContext();
+    const db = options.db ?? getDb();
+    const members = await db
+      .select({
+        itemId: schema.contextPackMembers.itemId,
+        itemVersionId: schema.contextPackMembers.itemVersionId,
+      })
+      .from(schema.contextPackMembers)
+      .where(eq(schema.contextPackMembers.packId, input.contextPackId));
+    const allowed = new Set(
+      members.map((member: any) => `${member.itemId}:${member.itemVersionId}`),
+    );
+    for (const entry of elementProvenance) {
+      if (
+        (entry.itemId || entry.itemVersionId) &&
+        (!entry.itemId ||
+          !entry.itemVersionId ||
+          !allowed.has(`${entry.itemId}:${entry.itemVersionId}`))
+      ) {
+        throw new Error(
+          "Element provenance references must belong to the recorded context pack",
+        );
+      }
+    }
+  }
+  const { getDb, schema } = getCreativeContext();
+  const db = options.db ?? getDb();
+  const actor = requireActor();
+  if (options.artifactAccess) {
+    assertGenerationArtifactAccessProof(
+      input,
+      options.artifactAccess,
+      "editor",
+    );
+  }
+  const row = {
+    id: newId("ccgr"),
+    appId: input.appId,
+    artifactType: input.artifactType,
+    artifactId: input.artifactId,
+    contextMode: input.contextMode,
+    contextPackId: input.contextPackId,
+    elementProvenance: stringifyJson(elementProvenance),
+    createdAt: nowIso(),
+    ownerEmail: actor.ownerEmail,
+    orgId: options.artifactAccess ? actor.orgId : null,
+  };
+  await db.insert(schema.generationRecords).values(row);
+  await getCreativeContext().projections?.generation?.record({
+    appId: input.appId,
+    artifactType: input.artifactType,
+    artifactId: input.artifactId,
+    contextPackId: input.contextPackId,
+    elementProvenance,
+  });
+  return {
+    ...row,
+    elementProvenance: parseJson(row.elementProvenance, []),
+  };
+}
+
+export async function getGenerationCreativeContext(
+  input: {
+    appId: string;
+    artifactType: string;
+    artifactId: string;
+  },
+  options: {
+    artifactAccess?: GenerationArtifactAccessProof;
+  } = {},
+): Promise<CreativeContextGenerationRecord | null> {
+  const { getDb, schema } = getCreativeContext();
+  const actor = requireActor();
+  if (options.artifactAccess && !actor.orgId) {
+    throw new Error(
+      "Collaborative generation context reads require an organization",
+    );
+  }
+  if (options.artifactAccess) {
+    assertGenerationArtifactAccessProof(
+      input,
+      options.artifactAccess,
+      "viewer",
+    );
+  }
+  const actorScope = options.artifactAccess
+    ? eq(schema.generationRecords.orgId, actor.orgId!)
+    : eq(schema.generationRecords.ownerEmail, actor.ownerEmail);
+  const rows = await getDb()
+    .select()
+    .from(schema.generationRecords)
+    .where(
+      and(
+        eq(schema.generationRecords.appId, input.appId),
+        eq(schema.generationRecords.artifactType, input.artifactType),
+        eq(schema.generationRecords.artifactId, input.artifactId),
+        actorScope,
+      ),
+    )
+    .orderBy(desc(schema.generationRecords.createdAt))
+    .limit(1);
+  const row = rows[0];
+  return row
+    ? {
+        id: row.id,
+        appId: row.appId,
+        artifactType: row.artifactType,
+        artifactId: row.artifactId,
+        contextMode: row.contextMode,
+        contextPackId: row.contextPackId ?? null,
+        elementProvenance: parseJson(row.elementProvenance, []),
+        createdAt: row.createdAt,
+      }
+    : null;
+}

package/src/store/helpers.ts

@@ -0,0 +1,53 @@
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server/request-context";
+
+export function nowIso(): string {
+  return new Date().toISOString();
+}
+
+export function newId(prefix: string): string {
+  return `${prefix}_${crypto.randomUUID()}`;
+}
+
+export function requireActor(): { ownerEmail: string; orgId: string | null } {
+  const ownerEmail = getRequestUserEmail()?.trim().toLowerCase();
+  if (!ownerEmail) throw new Error("Not authenticated");
+  return { ownerEmail, orgId: getRequestOrgId() ?? null };
+}
+
+export function parseJson<T>(value: string | null | undefined, fallback: T): T {
+  if (!value) return fallback;
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+export function stringifyJson(value: unknown): string {
+  return JSON.stringify(value ?? {});
+}
+
+export async function sha256(value: string): Promise<string> {
+  const bytes = new TextEncoder().encode(value);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return Array.from(new Uint8Array(digest), (byte) =>
+    byte.toString(16).padStart(2, "0"),
+  ).join("");
+}
+
+export function parseOffsetCursor(cursor: string | undefined): number {
+  if (!cursor) return 0;
+  const parsed = Number.parseInt(cursor, 10);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+
+export function nextOffsetCursor(
+  offset: number,
+  limit: number,
+  hasMore: boolean,
+): string | undefined {
+  return hasMore ? String(offset + limit) : undefined;
+}

package/src/store/index.ts

@@ -0,0 +1,10 @@
+export * from "./brand.js";
+export * from "./content.js";
+export * from "./contexts.js";
+export * from "./generation.js";
+export * from "./inference.js";
+export * from "./jobs.js";
+export * from "./packs.js";
+export * from "./purge.js";
+export * from "./sources.js";
+export * from "./suggestions.js";

package/src/store/inference.spec.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  BRAND_DNA_MATERIAL_DRIFT_THRESHOLD,
+  brandDnaDriftScore,
+  selectRepresentativeBrandDocuments,
+} from "./inference.js";
+
+describe("brand DNA material drift", () => {
+  it("does not propose churn for evidence-id-only changes", () => {
+    const before = {
+      summary: "Published",
+      visual: {
+        colors: ["#5B4FE9"],
+        layoutPatterns: [
+          { name: "kpi-scorecard", itemId: "old", thumbnailBlobRef: "old" },
+        ],
+      },
+      voice: { descriptors: ["direct", "concise"] },
+    };
+    const after = {
+      summary: "Inferred",
+      visual: {
+        colors: ["#5B4FE9"],
+        layoutPatterns: [
+          { name: "kpi-scorecard", itemId: "new", thumbnailBlobRef: "new" },
+        ],
+      },
+      voice: { descriptors: ["direct", "concise"] },
+    };
+    expect(brandDnaDriftScore(before, after)).toBe(0);
+  });
+
+  it("crosses the explicit threshold for changed brand signals", () => {
+    const score = brandDnaDriftScore(
+      {
+        summary: "Before",
+        visual: { colors: ["#5B4FE9"], fonts: ["Inter"] },
+        voice: { descriptors: ["direct"] },
+      },
+      {
+        summary: "After",
+        visual: { colors: ["#FF5500"], fonts: ["Roboto"] },
+        voice: { descriptors: ["playful"] },
+      },
+    );
+    expect(score).toBeGreaterThanOrEqual(BRAND_DNA_MATERIAL_DRIFT_THRESHOLD);
+  });
+
+  it("selects the same quality-weighted sample regardless of insertion order", () => {
+    const document = (
+      itemId: string,
+      overrides: Record<string, unknown> = {},
+    ) =>
+      ({
+        itemId,
+        sourceId: "source-a",
+        kind: "slide",
+        curationRank: "normal",
+        starred: false,
+        priorReuseCount: 0,
+        helpfulFeedbackCount: 0,
+        updatedAt: "2026-07-01T00:00:00.000Z",
+        inventoryOnly: false,
+        ...overrides,
+      }) as any;
+    const corpus = [
+      document("normal"),
+      document("canonical", { curationRank: "canonical" }),
+      document("starred", { starred: true }),
+      document("other-kind", { sourceId: "source-b", kind: "figma-frame" }),
+    ];
+    const forward = selectRepresentativeBrandDocuments(corpus, 3).map(
+      (entry) => entry.itemId,
+    );
+    const reverse = selectRepresentativeBrandDocuments(
+      [...corpus].reverse(),
+      3,
+    ).map((entry) => entry.itemId);
+    expect(reverse).toEqual(forward);
+    expect(forward).toContain("canonical");
+    expect(forward).toContain("other-kind");
+  });
+});