@agent-native/core 0.164.12 → 0.164.17

package/corpus/templates/content/app/components/sidebar/local-source-hierarchy.ts

@@ -0,0 +1,189 @@
+import type { ContentDatabaseItem, DocumentProperty } from "@shared/api";
+
+const LOCAL_SOURCE_DIRECTORY_PREFIX = "local-source-directory:";
+
+function normalizedSourcePath(path: string | undefined) {
+  const normalized = (path ?? "").replace(/\\/g, "/").replace(/^\/+/, "");
+  if (
+    !normalized ||
+    normalized.includes("\0") ||
+    normalized.split("/").some((part) => !part || part === "." || part === "..")
+  ) {
+    return null;
+  }
+  return normalized;
+}
+
+function parentPath(path: string) {
+  const separator = path.lastIndexOf("/");
+  return separator === -1 ? "" : path.slice(0, separator);
+}
+
+function sourceIds(item: ContentDatabaseItem) {
+  const value = item.properties.find(
+    (property) => property.definition.systemRole === "files_source",
+  )?.value;
+  return Array.isArray(value)
+    ? value.filter(
+        (candidate): candidate is string =>
+          typeof candidate === "string" && candidate !== "local",
+      )
+    : [];
+}
+
+export function localSourceItemIdentity(item: ContentDatabaseItem) {
+  return sourceIds(item)[0] ?? item.document.source?.rootPath ?? null;
+}
+
+function directoryId(sourceIdentity: string, path: string) {
+  return `${LOCAL_SOURCE_DIRECTORY_PREFIX}${encodeURIComponent(sourceIdentity)}:${encodeURIComponent(path)}`;
+}
+
+function systemProperties(
+  item: ContentDatabaseItem,
+  sourceIdentity: string,
+  parentId: string | null,
+): DocumentProperty[] {
+  return item.properties
+    .filter((property) => property.definition.systemRole)
+    .map((property) => {
+      if (property.definition.systemRole === "files_parent") {
+        return { ...property, value: parentId, editable: false };
+      }
+      if (property.definition.systemRole === "files_source") {
+        return { ...property, value: [sourceIdentity], editable: false };
+      }
+      return { ...property, editable: false };
+    });
+}
+
+function directoryItem(
+  template: ContentDatabaseItem,
+  sourceIdentity: string,
+  path: string,
+  position: number,
+): ContentDatabaseItem {
+  const parent = parentPath(path);
+  const parentId = parent ? directoryId(sourceIdentity, parent) : null;
+  const id = directoryId(sourceIdentity, path);
+  return {
+    id,
+    databaseId: template.databaseId,
+    document: {
+      ...template.document,
+      id,
+      parentId,
+      title: path.split("/").pop()?.replace(/[-_]+/g, " ") || path,
+      content: "",
+      description: "",
+      icon: null,
+      position,
+      isFavorite: false,
+      hideFromSearch: true,
+      accessRole: "viewer",
+      canView: true,
+      canComment: false,
+      canEdit: false,
+      canManage: false,
+      databaseMembership: undefined,
+      source: {
+        mode: "local-files",
+        kind: "folder",
+        path,
+        rootPath: template.document.source?.rootPath,
+      },
+    },
+    position,
+    properties: systemProperties(template, sourceIdentity, parentId),
+  };
+}
+
+export interface LocalSourceHierarchySelection {
+  sourceId?: string | null;
+  rootPath?: string | null;
+}
+
+export function firstLocalSourceDocumentId(items: ContentDatabaseItem[]) {
+  return items.find(
+    (item) =>
+      item.document.source?.mode === "local-files" &&
+      item.document.source.kind !== "folder",
+  )?.document.id;
+}
+
+export function projectLocalSourceHierarchy(
+  items: ContentDatabaseItem[],
+  selection: LocalSourceHierarchySelection = {},
+) {
+  const localFiles = items.filter((item) => {
+    if (
+      item.document.source?.mode !== "local-files" ||
+      item.document.source.kind === "folder"
+    ) {
+      return false;
+    }
+    if (selection.sourceId) {
+      return sourceIds(item).includes(selection.sourceId);
+    }
+    if (selection.rootPath) {
+      return item.document.source.rootPath === selection.rootPath;
+    }
+    return true;
+  });
+  const retained = items.filter(
+    (item) => item.document.source?.mode !== "local-files",
+  );
+  const directories = new Map<
+    string,
+    { template: ContentDatabaseItem; sourceIdentity: string; path: string }
+  >();
+  const projectedFiles: ContentDatabaseItem[] = [];
+
+  for (const item of localFiles) {
+    const path = normalizedSourcePath(item.document.source?.path);
+    const sourceIdentity =
+      selection.sourceId && sourceIds(item).includes(selection.sourceId)
+        ? selection.sourceId
+        : localSourceItemIdentity(item);
+    if (!path || !sourceIdentity) continue;
+    const folder = parentPath(path);
+    if (folder) {
+      const parts = folder.split("/");
+      for (let index = 1; index <= parts.length; index += 1) {
+        const directoryPath = parts.slice(0, index).join("/");
+        directories.set(`${sourceIdentity}\0${directoryPath}`, {
+          template: item,
+          sourceIdentity,
+          path: directoryPath,
+        });
+      }
+    }
+    const parentId = folder ? directoryId(sourceIdentity, folder) : null;
+    projectedFiles.push({
+      ...item,
+      document: { ...item.document, parentId },
+      properties: item.properties.map((property) =>
+        property.definition.systemRole === "files_parent"
+          ? { ...property, value: parentId }
+          : property,
+      ),
+    });
+  }
+
+  const projectedDirectories = [...directories.values()]
+    .sort((left, right) =>
+      left.sourceIdentity === right.sourceIdentity
+        ? left.path.localeCompare(right.path)
+        : left.sourceIdentity.localeCompare(right.sourceIdentity),
+    )
+    .map((directory, index) =>
+      directoryItem(
+        directory.template,
+        directory.sourceIdentity,
+        directory.path,
+        index,
+      ),
+    );
+
+  return [...retained, ...projectedDirectories, ...projectedFiles];
+}

package/corpus/templates/content/app/hooks/use-create-page.ts

@@ -1,7 +1,7 @@
 import type { Document } from "@shared/api";
 import { useQueryClient } from "@tanstack/react-query";
 import { useCallback } from "react";
-import { useNavigate } from "react-router";
+import { useLocation, useNavigate } from "react-router";
 import { toast } from "sonner";
 
 import {
@@ -10,7 +10,10 @@ import {
   SELECTED_CONTENT_SPACE_STORAGE_KEY,
 } from "@/components/sidebar/select-content-space";
 import { useContentSpaces } from "@/hooks/use-content-spaces";
-import { useCreateDocument } from "@/hooks/use-documents";
+import {
+  rollbackOptimisticCreatedDocument,
+  useCreateDocument,
+} from "@/hooks/use-documents";
 import { useLocalStorage } from "@/hooks/use-local-storage";
 import { documentQueryFilter } from "@/lib/document-query";
 import { markDocumentCreationPending } from "@/lib/optimistic-document";
@@ -34,6 +37,7 @@ export function useCreatePage(opts?: {
   awaitPersist?: boolean;
 }) {
   const navigate = useNavigate();
+  const location = useLocation();
   const queryClient = useQueryClient();
   const createDocument = useCreateDocument();
   const contentSpacesQuery = useContentSpaces();
@@ -78,11 +82,19 @@ export function useCreatePage(opts?: {
         createdAt: now,
         updatedAt: now,
       });
+      const previousDocuments = queryClient.getQueryData(
+        LIST_DOCUMENTS_QUERY_KEY,
+      );
+      const previousPath = `${location.pathname}${location.search}${location.hash}`;
 
       queryClient.setQueryData(LIST_DOCUMENTS_QUERY_KEY, (old: any) => {
         const docs: Document[] =
           old?.documents ?? (Array.isArray(old) ? old : []);
-        return { documents: [...docs, tempDoc] };
+        if (Array.isArray(old)) return [...docs, tempDoc];
+        return {
+          ...(old && typeof old === "object" ? old : {}),
+          documents: [...docs, tempDoc],
+        };
       });
       queryClient.setQueryData(["action", "get-document", { id }], tempDoc);
 
@@ -111,11 +123,18 @@ export function useCreatePage(opts?: {
       };
 
       const onPersistError = (err: unknown) => {
+        rollbackOptimisticCreatedDocument(
+          queryClient,
+          id,
+          previousDocuments !== undefined,
+        );
         queryClient.invalidateQueries({
           queryKey: ["action", "list-documents"],
         });
         queryClient.removeQueries(documentQueryFilter(id));
-        if (shouldNavigate) navigate("/");
+        if (shouldNavigate) {
+          navigate(previousPath, { replace: true, flushSync: true });
+        }
         toast.error("Failed to create page", {
           description:
             err instanceof Error ? err.message : "Something went wrong",
@@ -137,6 +156,9 @@ export function useCreatePage(opts?: {
     },
     [
       createDocument,
+      location.hash,
+      location.pathname,
+      location.search,
       navigate,
       onAfterNavigate,
       queryClient,

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

@@ -66,6 +66,89 @@ export const LIST_DOCUMENTS_QUERY_KEY = [
   undefined,
 ] as const;
 
+export function restoreListDocumentsSnapshot(
+  queryClient: Pick<QueryClient, "removeQueries" | "setQueryData">,
+  snapshot: unknown,
+) {
+  if (snapshot === undefined) {
+    queryClient.removeQueries({ queryKey: LIST_DOCUMENTS_QUERY_KEY });
+    return;
+  }
+  queryClient.setQueryData(LIST_DOCUMENTS_QUERY_KEY, snapshot);
+}
+
+export function rollbackOptimisticCreatedDocument(
+  queryClient: Pick<
+    QueryClient,
+    "getQueryData" | "removeQueries" | "setQueryData"
+  >,
+  documentId: string,
+  hadListSnapshot: boolean,
+) {
+  const current = queryClient.getQueryData(LIST_DOCUMENTS_QUERY_KEY);
+  const documents: Document[] = Array.isArray(current)
+    ? current
+    : ((current as DocumentListResponse | undefined)?.documents ?? []);
+  const remaining = documents.filter((document) => document.id !== documentId);
+
+  if (!hadListSnapshot && remaining.length === 0) {
+    queryClient.removeQueries({ queryKey: LIST_DOCUMENTS_QUERY_KEY });
+    return;
+  }
+
+  if (Array.isArray(current)) {
+    queryClient.setQueryData(LIST_DOCUMENTS_QUERY_KEY, remaining);
+    return;
+  }
+
+  queryClient.setQueryData(LIST_DOCUMENTS_QUERY_KEY, {
+    ...(current && typeof current === "object" ? current : {}),
+    documents: remaining,
+  });
+}
+
+export function restoreDeletedDocumentSnapshots(
+  queryClient: Pick<QueryClient, "getQueryData" | "setQueryData">,
+  listSnapshot: unknown,
+  documentSnapshots: Array<[readonly unknown[], unknown]>,
+  deletedDocumentIds: Iterable<string>,
+) {
+  const deletedIds = new Set(deletedDocumentIds);
+  const snapshotDocuments: Document[] = Array.isArray(listSnapshot)
+    ? listSnapshot
+    : ((listSnapshot as DocumentListResponse | undefined)?.documents ?? []);
+  const current = queryClient.getQueryData(LIST_DOCUMENTS_QUERY_KEY);
+  const currentDocuments: Document[] = Array.isArray(current)
+    ? current
+    : ((current as DocumentListResponse | undefined)?.documents ?? []);
+  const currentDocumentIds = new Set(
+    currentDocuments.map((document) => document.id),
+  );
+  const restoredDocuments = snapshotDocuments.filter(
+    (document) =>
+      deletedIds.has(document.id) && !currentDocumentIds.has(document.id),
+  );
+  const documents = [...currentDocuments, ...restoredDocuments];
+
+  if (Array.isArray(current)) {
+    queryClient.setQueryData(LIST_DOCUMENTS_QUERY_KEY, documents);
+  } else {
+    queryClient.setQueryData(LIST_DOCUMENTS_QUERY_KEY, {
+      ...(current && typeof current === "object"
+        ? current
+        : listSnapshot && typeof listSnapshot === "object"
+          ? listSnapshot
+          : {}),
+      documents,
+    });
+  }
+  for (const [queryKey, data] of documentSnapshots) {
+    if (queryClient.getQueryData(queryKey) === undefined) {
+      queryClient.setQueryData(queryKey, data);
+    }
+  }
+}
+
 const DOCUMENT_LIST_PAGE_SIZE = 200;
 
 export async function fetchCompleteDocumentList(