@tablestore/tablestore-agent-cli 0.2.11 → 0.4.0

package/dist/dashboard-runtime/dashboard/src/components/memory/memory-dream-plan-approval-dialog.tsx

@@ -0,0 +1,172 @@
+"use client";
+
+import { useState } from "react";
+import { toast } from "sonner";
+
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { useApproveDreamPlan } from "@/hooks/use-approve-dream-plan";
+import { useI18n } from "@/i18n/i18n-context";
+import type { DreamPlan, DreamTaskStatus } from "@/types/memory";
+
+interface DreamPlanTask {
+  dreamId: string;
+  status: DreamTaskStatus;
+  plan?: DreamPlan;
+}
+
+export type DreamPlanDecision =
+  | { kind: "approve"; dreamId: string; approver: string }
+  | { kind: "cancel"; dreamId: string };
+
+export function buildDreamPlanDecision(
+  task: DreamPlanTask,
+  decision: "approve" | "reject",
+  approver?: string,
+): DreamPlanDecision {
+  if (task.status !== "awaiting_plan_approval") {
+    throw new Error(
+      `Dream task must be awaiting_plan_approval; current status is ${task.status}`,
+    );
+  }
+  if (decision === "reject") {
+    return { kind: "cancel", dreamId: task.dreamId };
+  }
+  if (
+    !task.plan ||
+    typeof task.plan.summary !== "string" ||
+    task.plan.summary.trim() === "" ||
+    !Array.isArray(task.plan.deleteMemoryIds) ||
+    !task.plan.deleteMemoryIds.every(
+      (memoryId) => typeof memoryId === "string" && memoryId.trim() !== "",
+    )
+  ) {
+    throw new Error("Dream task does not contain a valid plan");
+  }
+  const trimmedApprover = approver?.trim() ?? "";
+  if (trimmedApprover === "") {
+    throw new Error("Approver is required");
+  }
+  return {
+    kind: "approve",
+    dreamId: task.dreamId,
+    approver: trimmedApprover,
+  };
+}
+
+interface MemoryDreamPlanApprovalDialogProps {
+  memoryStoreName: string;
+  task: DreamPlanTask;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+}
+
+export function MemoryDreamPlanApprovalDialog({
+  memoryStoreName,
+  task,
+  open,
+  onOpenChange,
+}: MemoryDreamPlanApprovalDialogProps) {
+  const { t } = useI18n();
+  const approveMutation = useApproveDreamPlan(memoryStoreName);
+  const [approver, setApprover] = useState("");
+
+  const handleOpenChange = (nextOpen: boolean) => {
+    if (!nextOpen) setApprover("");
+    onOpenChange(nextOpen);
+  };
+
+  const handleApprove = async () => {
+    try {
+      const decision = buildDreamPlanDecision(task, "approve", approver);
+      if (decision.kind !== "approve") return;
+      await approveMutation.mutateAsync({
+        dreamId: decision.dreamId,
+        approver: decision.approver,
+      });
+      toast.success(t("memory.dream.planApprovalSuccess"));
+      handleOpenChange(false);
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : t("memory.dream.planApprovalFailed"),
+      );
+    }
+  };
+
+  const plan = task.plan;
+  return (
+    <Dialog open={open} onOpenChange={handleOpenChange}>
+      <DialogContent className="max-w-2xl">
+        <DialogHeader>
+          <DialogTitle>{t("memory.dream.planApprovalTitle")}</DialogTitle>
+          <DialogDescription>
+            {t("memory.dream.planApprovalDescription")}
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          <section className="rounded-md border border-[hsl(var(--border))] p-3">
+            <h4 className="mb-1 text-xs font-semibold uppercase text-muted-foreground">
+              {t("memory.dream.planSummary")}
+            </h4>
+            <p className="whitespace-pre-wrap text-sm">{plan?.summary}</p>
+          </section>
+          <section className="rounded-md border border-[hsl(var(--border))] p-3">
+            <h4 className="mb-2 text-xs font-semibold uppercase text-muted-foreground">
+              {t("memory.dream.planDeletionWhitelist")}
+            </h4>
+            {plan?.deleteMemoryIds.length ? (
+              <ul className="space-y-1 font-mono text-xs">
+                {plan.deleteMemoryIds.map((memoryId) => (
+                  <li key={memoryId} className="break-all">
+                    {memoryId}
+                  </li>
+                ))}
+              </ul>
+            ) : (
+              <p className="text-sm text-muted-foreground">
+                {t("memory.dream.planNoDeletions")}
+              </p>
+            )}
+          </section>
+          <div className="space-y-2">
+            <Label htmlFor="dream-plan-approver">
+              {t("memory.dream.planApprover")}
+            </Label>
+            <Input
+              id="dream-plan-approver"
+              value={approver}
+              onChange={(event) => setApprover(event.target.value)}
+              placeholder={t("memory.dream.planApproverPlaceholder")}
+            />
+          </div>
+        </div>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={() => handleOpenChange(false)}>
+            {t("common.cancel")}
+          </Button>
+          <Button
+            onClick={handleApprove}
+            disabled={approveMutation.isPending || approver.trim() === ""}
+          >
+            {approveMutation.isPending
+              ? t("memory.dream.planApproving")
+              : t("memory.dream.planApprove")}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

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,
               })
             }
           />