@agent-native/core 0.84.0 → 0.84.1

package/corpus/templates/content/app/components/editor/database/DatabaseView.tsx

@@ -146,8 +146,10 @@ import {
   useContentDatabase,
   useContentDatabases,
   contentDatabaseQueryKey,
+  useDeleteDatabaseItems,
   useDisconnectContentDatabaseSource,
   useDuplicateDatabaseItem,
+  useDuplicateDatabaseItems,
   useExecuteBuilderSourceExecution,
   useMoveDatabaseItem,
   usePrepareBuilderSourceReview,
@@ -2766,9 +2768,9 @@ function DatabaseTableView({
 }) {
   const queryClient = useQueryClient();
   const moveItem = useMoveDatabaseItem(databaseDocumentId);
-  const duplicateItem = useDuplicateDatabaseItem(databaseDocumentId);
+  const duplicateItems = useDuplicateDatabaseItems(databaseDocumentId);
   const setProperty = useSetDocumentProperty(databaseDocumentId);
-  const deleteDocument = useDeleteDocument();
+  const deleteItems = useDeleteDatabaseItems(databaseDocumentId);
   const [draggedItemId, setDraggedItemId] = useState<string | null>(null);
   const [dropTargetItemId, setDropTargetItemId] = useState<string | null>(null);
   const [draggedPropertyId, setDraggedPropertyId] = useState<string | null>(
@@ -3012,14 +3014,15 @@ function DatabaseTableView({
   async function deleteSelectedRows() {
     if (selectedItems.length === 0) return;
     const selectedSnapshot = selectedItems;
-    onClearSelection();
     setConfirmDeleteSelectedOpen(false);
 
     try {
+      await deleteItems.mutateAsync({
+        documentId: databaseDocumentId,
+        itemIds: selectedSnapshot.map((item) => item.id),
+      });
+      onClearSelection();
       onDeletedPreviewItems(selectedSnapshot);
-      for (const item of selectedSnapshot) {
-        await deleteDocument.mutateAsync({ id: item.document.id });
-      }
       await queryClient.invalidateQueries({
         queryKey: [
           "action",
@@ -3043,22 +3046,11 @@ function DatabaseTableView({
     const selectedSnapshot = selectedItems;
     setIsDuplicatingSelected(true);
 
-    let duplicatedPreviewItem: ContentDatabaseItem | null = null;
-    let duplicatedCount = 0;
-    let failedCount = 0;
-
     try {
-      for (const item of selectedSnapshot) {
-        try {
-          const response = await duplicateItem.mutateAsync({ itemId: item.id });
-          duplicatedCount += 1;
-          duplicatedPreviewItem =
-            databaseDuplicatedItemFromResponse(response) ??
-            duplicatedPreviewItem;
-        } catch {
-          failedCount += 1;
-        }
-      }
+      const response = await duplicateItems.mutateAsync({
+        documentId: databaseDocumentId,
+        itemIds: selectedSnapshot.map((item) => item.id),
+      });
 
       await queryClient.invalidateQueries({
         queryKey: [
@@ -3071,16 +3063,15 @@ function DatabaseTableView({
         queryKey: ["action", "list-documents"],
       });
 
+      const duplicatedPreviewItem =
+        databaseDuplicatedItemFromResponse(response);
       if (duplicatedPreviewItem) onPreview(duplicatedPreviewItem);
-      if (duplicatedCount > 0) onClearSelection();
-      if (failedCount > 0) {
-        toast.error(dbText("failedToDuplicateEverySelectedRow"), {
-          description:
-            duplicatedCount > 0
-              ? `${duplicatedCount} duplicated, ${failedCount} failed.`
-              : "No rows were duplicated.",
-        });
-      }
+      onClearSelection();
+    } catch (err) {
+      toast.error(dbText("failedToDuplicateEverySelectedRow"), {
+        description:
+          err instanceof Error ? err.message : dbText("somethingWentWrong"),
+      });
     } finally {
       setIsDuplicatingSelected(false);
     }
@@ -3139,9 +3130,11 @@ function DatabaseTableView({
             canEdit={canEdit}
             properties={bulkEditableProperties}
             duplicateDisabled={
-              isDuplicatingSelected || deleteDocument.isPending
+              isDuplicatingSelected ||
+              duplicateItems.isPending ||
+              deleteItems.isPending
             }
-            deleteDisabled={deleteDocument.isPending}
+            deleteDisabled={deleteItems.isPending}
             updateDisabled={setProperty.isPending}
             onClearSelection={onClearSelection}
             onSetPropertyValue={setSelectedPropertyValue}
@@ -3360,10 +3353,10 @@ function DatabaseTableView({
             <AlertDialogCancel>Cancel</AlertDialogCancel>
             <AlertDialogAction
               className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
-              disabled={deleteDocument.isPending}
+              disabled={deleteItems.isPending}
               onClick={() => void deleteSelectedRows()}
             >
-              {deleteDocument.isPending ? "Deleting..." : "Delete"}
+              {deleteItems.isPending ? "Deleting..." : "Delete"}
             </AlertDialogAction>
           </AlertDialogFooter>
         </AlertDialogContent>

package/corpus/templates/content/app/components/editor/database/navigation-state.ts

@@ -250,11 +250,17 @@ export function databaseBulkScalarInputState(
 
 export function databaseDuplicatedItemFromResponse(
   response: Pick<ContentDatabaseResponse, "items"> &
-    Pick<Partial<ContentDatabaseResponse>, "duplicatedItemId">,
+    Pick<
+      Partial<ContentDatabaseResponse>,
+      "duplicatedItemId" | "duplicatedItemIds"
+    >,
 ) {
-  return (
-    response.items.find((item) => item.id === response.duplicatedItemId) ?? null
-  );
+  const duplicatedItemIds = response.duplicatedItemIds ?? [];
+  const duplicatedItemId =
+    duplicatedItemIds.length > 0
+      ? duplicatedItemIds[duplicatedItemIds.length - 1]
+      : response.duplicatedItemId;
+  return response.items.find((item) => item.id === duplicatedItemId) ?? null;
 }
 
 export function toggleDatabaseRowSelection(

package/corpus/templates/content/app/components/sidebar/NotionButton.tsx

@@ -22,7 +22,11 @@ import {
   TooltipContent,
   TooltipTrigger,
 } from "@/components/ui/tooltip";
-import { useNotionConnection, useDisconnectNotion } from "@/hooks/use-notion";
+import {
+  openNotionOAuthUrl,
+  useDisconnectNotion,
+  useNotionConnection,
+} from "@/hooks/use-notion";
 import { cn } from "@/lib/utils";
 
 // ─── Notion SVG icon ────────────────────────────────────────────────────────
@@ -125,8 +129,8 @@ export function NotionButton() {
     };
   }, []);
 
-  function handleConnect() {
-    if (!connection?.authUrl) {
+  async function handleConnect() {
+    if (connection?.error === "missing_credentials") {
       if (needsCredentials) {
         setShowWizard(true);
         return;
@@ -134,7 +138,24 @@ export function NotionButton() {
       toast.error(t("sidebar.notionOAuthNotConfigured"));
       return;
     }
-    window.open(connection.authUrl, "_blank");
+    const popup = window.open("about:blank", "_blank");
+    if (!popup) {
+      toast.error(t("sidebar.notionOAuthNotConfigured"));
+      return;
+    }
+    popup.opener = null;
+
+    try {
+      popup.location.href = await openNotionOAuthUrl();
+    } catch (error) {
+      popup.close();
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : t("sidebar.notionOAuthNotConfigured"),
+      );
+      return;
+    }
 
     // Clear any existing poll before starting a new one
     if (pollRef.current) clearInterval(pollRef.current);
@@ -142,18 +163,12 @@ export function NotionButton() {
 
     // Poll for connection
     pollRef.current = setInterval(async () => {
-      const res = await fetch(appApiPath("/api/notion/status")).catch(
-        () => null,
-      );
-      if (res?.ok) {
-        const data = await res.json();
-        if (data.connected) {
-          clearInterval(pollRef.current);
-          pollRef.current = undefined;
-          setShowWizard(false);
-          setOpen(false);
-          refetch();
-        }
+      const result = await refetch();
+      if (result.data?.connected) {
+        clearInterval(pollRef.current);
+        pollRef.current = undefined;
+        setShowWizard(false);
+        setOpen(false);
       }
     }, 2000);
 
@@ -166,7 +181,7 @@ export function NotionButton() {
 
   async function handleDisconnect() {
     try {
-      await disconnectNotion.mutateAsync();
+      await disconnectNotion.mutateAsync({});
       toast.success(t("sidebar.notionDisconnectedWorkspace"));
     } catch (err) {
       toast.error(

package/corpus/templates/content/app/hooks/use-content-database.ts

@@ -13,6 +13,7 @@ import type {
   ContentDatabaseSourceFieldPropertyResponse,
   ContentDatabaseSourceStatusResponse,
   CreateDatabaseRequest,
+  DatabaseItemsBatchRequest,
   DisconnectContentDatabaseSourceRequest,
   ExecuteBuilderSourceBatchRequest,
   ExecuteBuilderSourceBatchResponse,
@@ -258,6 +259,40 @@ export function useDuplicateDatabaseItem(documentId: string) {
   });
 }
 
+export function useDuplicateDatabaseItems(documentId: string) {
+  const queryClient = useQueryClient();
+  return useActionMutation<ContentDatabaseResponse, DatabaseItemsBatchRequest>(
+    "duplicate-database-items",
+    {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: contentDatabaseQueryKey(documentId),
+        });
+        queryClient.invalidateQueries({
+          queryKey: ["action", "list-documents"],
+        });
+      },
+    },
+  );
+}
+
+export function useDeleteDatabaseItems(documentId: string) {
+  const queryClient = useQueryClient();
+  return useActionMutation<ContentDatabaseResponse, DatabaseItemsBatchRequest>(
+    "delete-database-items",
+    {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: contentDatabaseQueryKey(documentId),
+        });
+        queryClient.invalidateQueries({
+          queryKey: ["action", "list-documents"],
+        });
+      },
+    },
+  );
+}
+
 export function useMoveDatabaseItem(documentId: string) {
   const queryClient = useQueryClient();
   return useActionMutation<ContentDatabaseResponse, MoveDatabaseItemRequest>(

package/corpus/templates/content/app/hooks/use-notion.ts

@@ -1,4 +1,9 @@
-import { appApiPath } from "@agent-native/core/client";
+import {
+  appApiPath,
+  callAction,
+  useActionMutation,
+  useActionQuery,
+} from "@agent-native/core/client";
 import type {
   CreateNotionPageRequest,
   Document,
@@ -8,18 +13,20 @@ import type {
   NotionSearchResponse,
   ResolveDocumentSyncConflictRequest,
 } from "@shared/api";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useEffect, useRef } from "react";
 
-async function fetchJson<T>(url: string, init?: RequestInit): Promise<T> {
-  const res = await fetch(appApiPath(url), init);
+async function fetchNotionAuthUrl(): Promise<string> {
+  const res = await fetch(appApiPath("/api/notion/auth-url"));
   if (!res.ok) {
     const body = await res.json().catch(() => null);
     throw new Error(
       body?.error || body?.message || `${res.status} ${res.statusText}`,
     );
   }
-  return res.json();
+  const body = (await res.json()) as { url?: string };
+  if (!body.url) throw new Error("Notion OAuth URL is unavailable");
+  return body.url;
 }
 
 function invalidateDocumentQueries(
@@ -27,34 +34,65 @@ function invalidateDocumentQueries(
   documentId: string,
 ) {
   queryClient.invalidateQueries({ queryKey: ["action"] });
-  queryClient.invalidateQueries({ queryKey: ["document-sync", documentId] });
+  queryClient.invalidateQueries({
+    queryKey: documentSyncStatusQueryKey(documentId),
+  });
+  queryClient.invalidateQueries({
+    queryKey: documentSyncStatusQueryKey(documentId, { autoSync: true }),
+  });
+}
+
+export function documentSyncStatusQueryKey(
+  documentId: string,
+  options?: { autoSync?: boolean },
+) {
+  return [
+    "action",
+    "refresh-notion-sync-status",
+    { documentId, autoSync: !!options?.autoSync },
+  ] as const;
 }
 
 export function useNotionConnection() {
+  return useActionQuery<NotionConnectionStatus>(
+    "connect-notion-status",
+    undefined,
+    {
+      staleTime: 30_000,
+    },
+  );
+}
+
+export function useNotionAuthUrl(enabled: boolean) {
   return useQuery({
-    queryKey: ["notion-connection"],
-    queryFn: () => fetchJson<NotionConnectionStatus>("/api/notion/status"),
+    queryKey: ["notion-auth-url"],
+    queryFn: fetchNotionAuthUrl,
+    enabled,
     staleTime: 30_000,
   });
 }
 
+export async function openNotionOAuthUrl() {
+  return fetchNotionAuthUrl();
+}
+
 export function useDocumentSyncStatus(
   documentId: string | null,
   options?: { autoSync?: boolean },
 ) {
   const queryClient = useQueryClient();
   const lastObservedSyncedAtRef = useRef<string | null>(null);
-  const query = useQuery({
-    queryKey: ["document-sync", documentId],
-    queryFn: () =>
-      fetchJson<DocumentSyncStatus>(
-        `/api/documents/${documentId}/notion/refresh`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ autoSync: !!options?.autoSync }),
-        },
-      ),
+  const query = useQuery<DocumentSyncStatus>({
+    queryKey: documentId
+      ? documentSyncStatusQueryKey(documentId, options)
+      : ["action", "refresh-notion-sync-status", null],
+    queryFn: () => {
+      if (!documentId) throw new Error("documentId is required");
+      return callAction<DocumentSyncStatus>("refresh-notion-sync-status", {
+        documentId,
+        autoSync: !!options?.autoSync,
+      });
+    },
     enabled: !!documentId,
     // Poll Notion aggressively when auto-sync is on so remote changes appear
     // within ~2s. Server throttles match (see REFRESH_THROTTLE_AUTO_SYNC_MS in
@@ -97,118 +135,89 @@ export function useDocumentSyncStatus(
 
 export function useDisconnectNotion() {
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: () =>
-      fetchJson<{ success: boolean }>("/api/notion/disconnect", {
-        method: "POST",
-      }),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["notion-connection"] });
-      queryClient.invalidateQueries({ queryKey: ["document-sync"] });
+  return useActionMutation<{ success: boolean; deleted: number }>(
+    "disconnect-notion",
+    {
+      onSuccess: () => {
+        queryClient.invalidateQueries({
+          queryKey: ["action", "connect-notion-status"],
+        });
+        queryClient.invalidateQueries({
+          queryKey: ["action", "refresh-notion-sync-status"],
+        });
+      },
     },
-  });
+  );
 }
 
 export function useLinkDocumentToNotion(documentId: string) {
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data: LinkNotionPageRequest) =>
-      fetchJson<DocumentSyncStatus>(
-        `/api/documents/${documentId}/notion/link`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(data),
-        },
-      ),
+  return useActionMutation<
+    DocumentSyncStatus,
+    LinkNotionPageRequest & { documentId: string }
+  >("link-notion-page", {
     onSuccess: () => invalidateDocumentQueries(queryClient, documentId),
   });
 }
 
 export function useUnlinkDocumentFromNotion(documentId: string) {
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: () =>
-      fetchJson<{ success: boolean }>(
-        `/api/documents/${documentId}/notion/unlink`,
-        {
-          method: "DELETE",
-        },
-      ),
-    onSuccess: () => invalidateDocumentQueries(queryClient, documentId),
-  });
+  return useActionMutation<{ success: boolean }, { documentId: string }>(
+    "unlink-notion-page",
+    {
+      method: "DELETE",
+      onSuccess: () => invalidateDocumentQueries(queryClient, documentId),
+    },
+  );
 }
 
 export function usePullDocumentFromNotion(documentId: string) {
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: () =>
-      fetchJson<DocumentSyncStatus>(
-        `/api/documents/${documentId}/notion/pull`,
-        {
-          method: "POST",
-        },
-      ),
-    onSuccess: () => invalidateDocumentQueries(queryClient, documentId),
-  });
+  return useActionMutation<DocumentSyncStatus, { documentId: string }>(
+    "pull-notion-page",
+    {
+      onSuccess: () => invalidateDocumentQueries(queryClient, documentId),
+    },
+  );
 }
 
 export function usePushDocumentToNotion(documentId: string) {
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: () =>
-      fetchJson<DocumentSyncStatus>(
-        `/api/documents/${documentId}/notion/push`,
-        {
-          method: "POST",
-        },
-      ),
-    onSuccess: () => invalidateDocumentQueries(queryClient, documentId),
-  });
+  return useActionMutation<DocumentSyncStatus, { documentId: string }>(
+    "push-notion-page",
+    {
+      onSuccess: () => invalidateDocumentQueries(queryClient, documentId),
+    },
+  );
 }
 
 export function useResolveDocumentSyncConflict(documentId: string) {
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data: ResolveDocumentSyncConflictRequest) =>
-      fetchJson<DocumentSyncStatus>(
-        `/api/documents/${documentId}/notion/resolve`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(data),
-        },
-      ),
+  return useActionMutation<
+    DocumentSyncStatus,
+    ResolveDocumentSyncConflictRequest & { documentId: string }
+  >("resolve-notion-sync-conflict", {
     onSuccess: () => invalidateDocumentQueries(queryClient, documentId),
   });
 }
 
 export function useCreateAndLinkNotionPage(documentId: string) {
   const queryClient = useQueryClient();
-  return useMutation({
-    mutationFn: (data?: CreateNotionPageRequest) =>
-      fetchJson<DocumentSyncStatus>(
-        `/api/documents/${documentId}/notion/create-and-link`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(data ?? {}),
-        },
-      ),
+  return useActionMutation<
+    DocumentSyncStatus,
+    CreateNotionPageRequest & { documentId: string }
+  >("create-and-link-notion-page", {
     onSuccess: () => invalidateDocumentQueries(queryClient, documentId),
   });
 }
 
 export function useSearchNotionPages(query: string, enabled: boolean) {
-  return useQuery({
-    queryKey: ["notion-search", query],
-    queryFn: () =>
-      fetchJson<NotionSearchResponse>("/api/notion/search", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ query }),
-      }),
-    enabled,
-    staleTime: 10_000,
-  });
+  return useActionQuery<NotionSearchResponse>(
+    "search-notion-pages",
+    { query },
+    {
+      enabled,
+      staleTime: 10_000,
+    },
+  );
 }

package/corpus/templates/content/package.json

@@ -9,6 +9,9 @@
     "build": "agent-native build",
     "start": "agent-native start",
     "test": "vitest --run",
+    "test:parity": "vitest --run parity",
+    "test:parity-capabilities": "vitest --run parity actions/content-database-lifecycle.db.test.ts actions/bind-content-database-source-field.db.test.ts actions/_local-file-documents.test.ts actions/builder-source-review-gates.db.test.ts",
+    "eval:parity": "agent-native eval parity",
     "format.fix": "oxfmt --write .",
     "typecheck": "agent-native typecheck",
     "action": "agent-native action",

package/corpus/templates/content/parity/README.md

@@ -0,0 +1,69 @@
+# Content Parity Harness
+
+This folder is the living audit for Content's agent/UI action parity. The
+matrix records which visible workflows are action-backed, which have explicit
+exceptions, and which gaps need follow-up.
+
+PR 2.2 adds two executable tiers:
+
+- Deterministic parity tests run in normal CI. They use fixture data and
+  existing action tests, make no model calls, and require no private provider
+  credentials.
+- Gated agent evals run through `agent-native eval parity`. They are opt-in via
+  `CONTENT_PARITY_EVALS=1`, capped to four initial scenarios, and should be
+  reserved for manual or nightly checks.
+
+## Deterministic Checks
+
+```bash
+cd templates/content
+./node_modules/.bin/vitest --run parity
+./node_modules/.bin/vitest --run actions/content-database-lifecycle.db.test.ts actions/bind-content-database-source-field.db.test.ts actions/_local-file-documents.test.ts actions/builder-source-review-gates.db.test.ts
+```
+
+The matrix rows use `coverageRefs` to point at deterministic files that prove a
+capability. The meta-tests fail with the row id when a priority capability loses
+coverage, so reviewers do not have to map a random test name back to the audit.
+
+## Gated Agent Evals
+
+```bash
+cd templates/content
+./node_modules/.bin/agent-native eval parity --json
+CONTENT_PARITY_EVALS=1 ANTHROPIC_API_KEY=... ./node_modules/.bin/agent-native eval parity
+```
+
+With `CONTENT_PARITY_EVALS` unset, parity evals return skipped rows and do not
+call the agent runner. The CLI still exits `0`, but both readable and JSON
+reports mark each row with `status: "skipped"` and a `skipReason` such as
+`Skipped because CONTENT_PARITY_EVALS is unset`.
+
+With the gate set, the eval files run the four PR 2.2 scenarios:
+
+- `database-source-scope`
+- `document-search-edit`
+- `local-file-source-truth`
+- `builder-source-review-readonly`
+
+The scenarios use fake or fixture data only. They must not require private
+Builder, Notion, customer, or workspace credentials. The Builder scenario is
+readonly/mocked by default and must not execute a live write.
+
+## CI Posture
+
+Normal PR CI runs deterministic parity checks through `pnpm test:content-parity`.
+Live or LLM-backed parity evals are reserved for the gated eval workflow, which
+can be triggered manually or by the nightly schedule. Missing provider secrets
+should show as skipped in that workflow summary, not as a scored pass.
+
+## Updating The Matrix
+
+Edit `matrix.ts`, then regenerate:
+
+```bash
+cd templates/content
+./node_modules/.bin/tsx parity/render-matrix.ts --write
+```
+
+`parity/__tests__/matrix-render-fresh.test.ts` keeps `matrix.md` synced with
+the typed source.