@tablestore/tablestore-agent-cli 0.2.11 → 0.3.1

package/dist/dashboard-runtime/dashboard/src/components/memory/memory-files-browser.tsx

@@ -15,22 +15,20 @@ import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import {
-  useCreateFileMemory,
-  useDeleteFileMemory,
-  useFileMemories,
-  useFileMemory,
-  useRenameFileMemory,
-  useUpdateFileMemory,
+  useAddItem,
+  useDeleteItem,
+  useItem,
+  useItems,
+  useUpdateItem,
 } from "@/hooks/use-file-memory";
 import { useI18n } from "@/i18n/i18n-context";
 import { buildFileTree, flattenVisible } from "@/lib/file-tree";
 import { cn } from "@/lib/utils";
 import { ApiClientError } from "@/services/api-client";
 import type {
-  FileMemory,
+  FileMemoryItem,
   FileMemoryScope,
-  ListFileMemoriesResponse,
-  UpdateFileMemoryRequest,
+  ListItemsResponse,
 } from "@/types/file-memory";
 
 import { FileDetailsPanel } from "./file-details-panel";
@@ -48,7 +46,8 @@ import { FileWorkspaceToolbar } from "./file-workspace-toolbar";
 export interface WorkspaceEditorState {
   selectedPath: string | null;
   content: string;
-  loadedSha256: string | null;
+  loadedItemId: string | null;
+  loadedVersionId: string | null;
   dirty: boolean;
   conflict: string | null;
 }
@@ -56,16 +55,28 @@ export interface WorkspaceEditorState {
 export const initialWorkspaceEditorState: WorkspaceEditorState = {
   selectedPath: null,
   content: "",
-  loadedSha256: null,
+  loadedItemId: null,
+  loadedVersionId: null,
   dirty: false,
   conflict: null,
 };
 
 type WorkspaceEditorAction =
   | { type: "select"; path: string | null }
-  | { type: "load"; path: string; content: string; sha256: string }
+  | {
+      type: "load";
+      path: string;
+      content: string;
+      itemId: string;
+      versionId: string;
+    }
   | { type: "edit"; content: string }
-  | { type: "save-success"; sha256: string; content?: string }
+  | {
+      type: "save-success";
+      itemId: string;
+      versionId: string;
+      content?: string;
+    }
   | { type: "save-conflict"; message: string };
 
 export function workspaceEditorReducer(
@@ -83,7 +94,8 @@ export function workspaceEditorReducer(
       return {
         selectedPath: action.path,
         content: action.content,
-        loadedSha256: action.sha256,
+        loadedItemId: action.itemId,
+        loadedVersionId: action.versionId,
         dirty: false,
         conflict: null,
       };
@@ -93,7 +105,8 @@ export function workspaceEditorReducer(
       return {
         ...state,
         content: action.content ?? state.content,
-        loadedSha256: action.sha256,
+        loadedItemId: action.itemId,
+        loadedVersionId: action.versionId,
         dirty: false,
         conflict: null,
       };
@@ -103,7 +116,7 @@ export function workspaceEditorReducer(
 }
 
 export function isFileMemoryReadOnly(
-  pages: Array<Pick<ListFileMemoriesResponse, "readOnly">> | undefined,
+  pages: Array<Pick<ListItemsResponse, "readOnly">> | undefined,
 ): boolean {
   return pages?.some((page) => page.readOnly === true) ?? false;
 }
@@ -116,25 +129,22 @@ export function shouldApplyFileSelection(
   return !editor.dirty || nextPath === editor.selectedPath || confirmDiscard();
 }
 
-export function isFileMemoryShaConflict(error: unknown): boolean {
-  if (error instanceof ApiClientError && error.code === "SHA_MISMATCH") {
+export function isFileMemoryVersionConflict(error: unknown): boolean {
+  if (error instanceof ApiClientError && error.code === "LOCK_CONFLICT") {
     return true;
   }
-  return error instanceof Error && error.message.includes("SHA_MISMATCH");
+  return error instanceof Error && error.message.includes("LOCK_CONFLICT");
 }
 
 export function buildFileUpdateRequest(
-  memoryStoreName: string,
-  scope: FileMemoryScope,
-  editor: WorkspaceEditorState,
-): UpdateFileMemoryRequest & { memoryStoreName: string } {
-  if (!editor.selectedPath) throw new Error("FILE_NOT_SELECTED");
+  current: Pick<FileMemoryItem, "itemId" | "latestVersionId">,
+  content: string,
+) {
   return {
-    memoryStoreName,
-    scope,
-    path: editor.selectedPath,
-    content: editor.content,
-    ...(editor.loadedSha256 ? { expectedSha256: editor.loadedSha256 } : {}),
+    itemId: current.itemId,
+    content,
+    precondition: { expectedVersionId: current.latestVersionId },
+    view: "full" as const,
   };
 }
 
@@ -177,21 +187,27 @@ export function MemoryFilesBrowser({
     }
   }, [initialPath]);
 
-  const listQuery = useFileMemories(memoryStoreName, scope, {
+  const listQuery = useItems(memoryStoreName, scope, {
+    depth: 0,
+    view: "basic",
     limit: 100,
     enabled,
   });
-  const fileQuery = useFileMemory(memoryStoreName, scope, editor.selectedPath);
-  const createMutation = useCreateFileMemory();
-  const updateMutation = useUpdateFileMemory();
-  const renameMutation = useRenameFileMemory();
-  const deleteMutation = useDeleteFileMemory();
+  const fileQuery = useItem(
+    memoryStoreName,
+    scope,
+    editor.selectedPath ? { path: editor.selectedPath } : null,
+  );
+  const addMutation = useAddItem();
+  const updateMutation = useUpdateItem();
+  const deleteMutation = useDeleteItem();
 
   const pages = listQuery.data?.pages;
   const memories = useMemo(() => {
-    const byPath = new Map<string, FileMemory>();
+    const byPath = new Map<string, FileMemoryItem>();
     for (const page of pages ?? []) {
-      for (const file of page.memories) {
+      for (const file of page.items) {
+        if (file.type !== "memoryfile") continue;
         byPath.set(normalizeFileMemoryPath(file.path), {
           ...file,
           path: normalizeFileMemoryPath(file.path),
@@ -232,19 +248,30 @@ export function MemoryFilesBrowser({
 
   useEffect(() => {
     const file = fileQuery.data;
-    if (!file || editor.dirty || !editor.selectedPath) return;
+    if (
+      !file ||
+      editor.dirty ||
+      !editor.selectedPath ||
+      editor.loadedItemId !== null
+    ) {
+      return;
+    }
     dispatch({
       type: "load",
       path: normalizeFileMemoryPath(file.path),
       content: file.content ?? "",
-      sha256: file.contentSha256,
+      itemId: file.itemId,
+      versionId: file.latestVersionId,
     });
   }, [
     editor.dirty,
+    editor.loadedItemId,
     editor.selectedPath,
     fileQuery.data,
     fileQuery.data?.content,
     fileQuery.data?.contentSha256,
+    fileQuery.data?.itemId,
+    fileQuery.data?.latestVersionId,
     fileQuery.data?.path,
   ]);
 
@@ -275,18 +302,30 @@ export function MemoryFilesBrowser({
       return;
     }
     try {
-      const updated = await updateMutation.mutateAsync(
-        buildFileUpdateRequest(memoryStoreName, scope, editor),
-      );
+      if (!editor.loadedItemId || !editor.loadedVersionId) {
+        throw new Error("FILE_VERSION_NOT_LOADED");
+      }
+      const updated = await updateMutation.mutateAsync({
+        memoryStoreName,
+        scope,
+        ...buildFileUpdateRequest(
+          {
+            itemId: editor.loadedItemId,
+            latestVersionId: editor.loadedVersionId,
+          },
+          editor.content,
+        ),
+      });
       dispatch({
         type: "save-success",
-        sha256: updated.contentSha256,
+        itemId: updated.itemId,
+        versionId: updated.latestVersionId,
         content: editor.content,
       });
       toast.success(t("memory.files.saveSuccess"));
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (isFileMemoryShaConflict(error)) {
+      if (isFileMemoryVersionConflict(error)) {
         dispatch({ type: "save-conflict", message });
         return;
       }
@@ -295,36 +334,44 @@ export function MemoryFilesBrowser({
   }
 
   async function create(path: string, content: string) {
-    const created = await createMutation.mutateAsync({
+    const created = await addMutation.mutateAsync({
       memoryStoreName,
       scope,
       path,
       content,
+      view: "full",
     });
     dispatch({ type: "select", path: normalizeFileMemoryPath(created.path) });
     toast.success(t("memory.files.createSuccess"));
   }
 
   async function rename(toPath: string) {
-    if (!editor.selectedPath) return;
-    const renamed = await renameMutation.mutateAsync({
+    if (
+      !editor.selectedPath ||
+      !editor.loadedItemId ||
+      !editor.loadedVersionId
+    ) {
+      return;
+    }
+    const renamed = await updateMutation.mutateAsync({
       memoryStoreName,
       scope,
-      fromPath: editor.selectedPath,
-      toPath,
-      expectedSha256: selectedFile?.contentSha256,
+      itemId: editor.loadedItemId,
+      path: toPath,
+      precondition: { expectedVersionId: editor.loadedVersionId },
+      view: "full",
     });
     dispatch({ type: "select", path: normalizeFileMemoryPath(renamed.path) });
     toast.success(t("memory.files.renameSuccess"));
   }
 
   async function remove() {
-    if (!editor.selectedPath) return;
+    if (!editor.loadedItemId || !editor.loadedVersionId) return;
     await deleteMutation.mutateAsync({
       memoryStoreName,
       scope,
-      path: editor.selectedPath,
-      expectedSha256: selectedFile?.contentSha256,
+      itemId: editor.loadedItemId,
+      precondition: { expectedVersionId: editor.loadedVersionId },
     });
     dispatch({ type: "select", path: null });
     toast.success(t("memory.files.deleteSuccess"));
@@ -336,8 +383,8 @@ export function MemoryFilesBrowser({
   }
 
   const mutationPending =
-    createMutation.isPending ||
-    renameMutation.isPending ||
+    addMutation.isPending ||
+    updateMutation.isPending ||
     deleteMutation.isPending;
 
   return (
@@ -486,7 +533,8 @@ export function MemoryFilesBrowser({
                 type: "load",
                 path: normalizeFileMemoryPath(file.path),
                 content,
-                sha256: file.contentSha256,
+                itemId: file.itemId,
+                versionId: file.latestVersionId,
               })
             }
           />