@tablestore/tablestore-agent-cli 0.2.10 → 0.3.1

package/dist/dashboard-runtime/dashboard/src/components/memory/file-version-history.tsx

@@ -0,0 +1,251 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import { Clock3, Loader2, RotateCcw, ShieldOff } from "lucide-react";
+import { toast } from "sonner";
+
+import { Button } from "@/components/ui/button";
+import {
+  useAddItem,
+  useItemVersion,
+  useItemVersions,
+  useRedactItemVersion,
+  useUpdateItem,
+} from "@/hooks/use-file-memory";
+import { useI18n } from "@/i18n/i18n-context";
+import type {
+  FileMemoryItem,
+  FileMemoryItemVersion,
+  FileMemoryScope,
+} from "@/types/file-memory";
+
+export function buildVersionRestoreRequest(
+  memoryStoreName: string,
+  scope: FileMemoryScope,
+  current: FileMemoryItem | undefined,
+  version: FileMemoryItemVersion,
+) {
+  if (version.redacted) throw new Error("VERSION_REDACTED");
+  if (version.content === undefined) {
+    throw new Error("VERSION_CONTENT_UNAVAILABLE");
+  }
+  if (current) {
+    return {
+      kind: "update" as const,
+      request: {
+        memoryStoreName,
+        scope,
+        itemId: current.itemId,
+        content: version.content,
+        precondition: { expectedVersionId: current.latestVersionId },
+        view: "full" as const,
+      },
+    };
+  }
+  return {
+    kind: "add" as const,
+    request: {
+      memoryStoreName,
+      scope,
+      path: version.path,
+      content: version.content,
+      view: "full" as const,
+    },
+  };
+}
+
+function shortVersionId(versionId: string): string {
+  return versionId.length > 12
+    ? `${versionId.slice(0, 6)}…${versionId.slice(-5)}`
+    : versionId;
+}
+
+function actorLabel(actor: FileMemoryItemVersion["redactedBy"]): string {
+  return actor ? `${actor.actorType}:${actor.actorId}` : "—";
+}
+
+export function FileVersionHistory({
+  memoryStoreName,
+  scope,
+  file,
+  readOnly,
+  onRestored,
+}: {
+  memoryStoreName: string;
+  scope: FileMemoryScope;
+  file: FileMemoryItem;
+  readOnly: boolean;
+  onRestored?: (file: FileMemoryItem, content: string) => void;
+}) {
+  const { t } = useI18n();
+  const [selectedVersionId, setSelectedVersionId] = useState<string | null>(
+    null,
+  );
+  const versionsQuery = useItemVersions(memoryStoreName, scope, file.itemId, {
+    view: "basic",
+    limit: 50,
+  });
+  const versionQuery = useItemVersion(
+    memoryStoreName,
+    scope,
+    selectedVersionId ?? undefined,
+  );
+  const addMutation = useAddItem();
+  const updateMutation = useUpdateItem();
+  const redactMutation = useRedactItemVersion();
+
+  const versions = useMemo(
+    () => versionsQuery.data?.pages.flatMap((page) => page.versions) ?? [],
+    [versionsQuery.data?.pages],
+  );
+
+  async function restore() {
+    if (!versionQuery.data) return;
+    try {
+      const operation = buildVersionRestoreRequest(
+        memoryStoreName,
+        scope,
+        file,
+        versionQuery.data,
+      );
+      const restored =
+        operation.kind === "update"
+          ? await updateMutation.mutateAsync(operation.request)
+          : await addMutation.mutateAsync(operation.request);
+      onRestored?.(restored, versionQuery.data.content ?? "");
+      toast.success(t("memory.files.restoreSuccess"));
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : t("memory.files.restoreFailed"),
+      );
+    }
+  }
+
+  async function redact() {
+    const version = versionQuery.data;
+    if (!version || version.redacted) return;
+    if (!window.confirm(t("memory.files.redactConfirm"))) return;
+    try {
+      await redactMutation.mutateAsync({
+        memoryStoreName,
+        scope,
+        versionId: version.versionId,
+      });
+      await versionQuery.refetch();
+      toast.success(t("memory.files.redactSuccess"));
+    } catch (error) {
+      toast.error(
+        error instanceof Error ? error.message : t("memory.files.redactFailed"),
+      );
+    }
+  }
+
+  if (readOnly) return null;
+
+  return (
+    <section className="min-h-0 border-t border-[hsl(var(--border))] pt-3">
+      <div className="mb-2 flex items-center justify-between">
+        <h4 className="flex items-center gap-1.5 text-xs font-semibold">
+          <Clock3 className="h-3.5 w-3.5" />
+          {t("memory.files.versionHistory")}
+        </h4>
+        {versionsQuery.hasNextPage ? (
+          <Button
+            type="button"
+            variant="ghost"
+            size="sm"
+            disabled={versionsQuery.isFetchingNextPage}
+            onClick={() => void versionsQuery.fetchNextPage()}
+          >
+            {t("memory.files.loadMore")}
+          </Button>
+        ) : null}
+      </div>
+
+      {versionsQuery.isLoading ? (
+        <p className="text-xs text-muted-foreground">{t("common.loading")}</p>
+      ) : versions.length === 0 ? (
+        <p className="text-xs text-muted-foreground">
+          {t("memory.files.noVersions")}
+        </p>
+      ) : (
+        <div className="max-h-48 space-y-1 overflow-auto pr-1">
+          {versions.map((version) => (
+            <button
+              type="button"
+              key={version.versionId}
+              onClick={() => setSelectedVersionId(version.versionId)}
+              className="flex w-full items-center justify-between rounded-md border border-transparent px-2 py-1.5 text-left text-xs hover:border-[hsl(var(--border))] hover:bg-[hsl(var(--accent))]"
+            >
+              <span className="truncate">
+                {version.operation} · {shortVersionId(version.versionId)}
+                {version.redacted ? ` · ${t("memory.files.redacted")}` : ""}
+              </span>
+              <span className="shrink-0 text-[10px] text-muted-foreground">
+                {new Date(version.createdAt).toLocaleString()}
+              </span>
+            </button>
+          ))}
+        </div>
+      )}
+
+      {selectedVersionId ? (
+        <div className="mt-3 rounded-md border border-[hsl(var(--border))] bg-[hsl(var(--muted)/0.25)] p-2">
+          {versionQuery.isLoading ? (
+            <Loader2 className="h-4 w-4 animate-spin text-muted-foreground" />
+          ) : versionQuery.data ? (
+            <>
+              <pre className="max-h-40 overflow-auto whitespace-pre-wrap break-words font-mono text-[11px] leading-4">
+                {versionQuery.data.content ??
+                  t("memory.files.contentUnavailable")}
+              </pre>
+              {versionQuery.data.redacted ? (
+                <p className="mt-2 text-[10px] text-muted-foreground">
+                  {t("memory.files.redactedDetails", {
+                    at: versionQuery.data.redactedAt
+                      ? new Date(versionQuery.data.redactedAt).toLocaleString()
+                      : "—",
+                    actor: actorLabel(versionQuery.data.redactedBy),
+                  })}
+                </p>
+              ) : null}
+              <div className="mt-2 grid grid-cols-2 gap-2">
+                <Button
+                  type="button"
+                  size="sm"
+                  variant="outline"
+                  disabled={
+                    versionQuery.data.redacted === true ||
+                    versionQuery.data.content === undefined ||
+                    updateMutation.isPending ||
+                    addMutation.isPending
+                  }
+                  onClick={() => void restore()}
+                >
+                  <RotateCcw />
+                  {t("memory.files.restoreVersion")}
+                </Button>
+                <Button
+                  type="button"
+                  size="sm"
+                  variant="outline"
+                  className="text-[hsl(var(--destructive))]"
+                  disabled={
+                    versionQuery.data.redacted === true ||
+                    redactMutation.isPending
+                  }
+                  onClick={() => void redact()}
+                >
+                  <ShieldOff />
+                  {t("memory.files.redactVersion")}
+                </Button>
+              </div>
+            </>
+          ) : null}
+        </div>
+      ) : null}
+    </section>
+  );
+}

package/dist/dashboard-runtime/dashboard/src/components/memory/file-workspace-toolbar.tsx

@@ -0,0 +1,101 @@
+"use client";
+
+import {
+  FilePlus2,
+  Loader2,
+  Pencil,
+  RefreshCw,
+  Save,
+  Trash2,
+} from "lucide-react";
+
+import { Button } from "@/components/ui/button";
+import { useI18n } from "@/i18n/i18n-context";
+
+export function FileWorkspaceToolbar({
+  readOnly,
+  loading,
+  hasSelection,
+  dirty,
+  saving,
+  onCreate,
+  onRename,
+  onDelete,
+  onRefresh,
+  onSave,
+}: {
+  readOnly: boolean;
+  loading: boolean;
+  hasSelection: boolean;
+  dirty: boolean;
+  saving: boolean;
+  onCreate: () => void;
+  onRename: () => void;
+  onDelete: () => void;
+  onRefresh: () => void;
+  onSave: () => void;
+}) {
+  const { t } = useI18n();
+  return (
+    <div className="flex flex-wrap items-center justify-between gap-2 border-b border-[hsl(var(--border))] bg-[hsl(var(--muted)/0.2)] px-3 py-2">
+      <div className="flex items-center gap-1.5">
+        <Button
+          type="button"
+          size="sm"
+          onClick={onCreate}
+          disabled={readOnly || loading || dirty}
+        >
+          <FilePlus2 />
+          {t("memory.files.newFile")}
+        </Button>
+        <Button
+          type="button"
+          size="sm"
+          variant="outline"
+          onClick={onRename}
+          disabled={readOnly || !hasSelection || dirty}
+        >
+          <Pencil />
+          {t("memory.files.rename")}
+        </Button>
+        <Button
+          type="button"
+          size="sm"
+          variant="outline"
+          onClick={onDelete}
+          disabled={readOnly || !hasSelection || dirty}
+          className="text-[hsl(var(--destructive))]"
+        >
+          <Trash2 />
+          {t("common.delete")}
+        </Button>
+      </div>
+      <div className="flex items-center gap-1.5">
+        <span className="mr-1 rounded-full border border-[hsl(var(--border))] bg-[hsl(var(--card))] px-2 py-0.5 text-[10px] text-muted-foreground">
+          {readOnly
+            ? t("memory.files.readOnlyMode")
+            : t("memory.files.writableMode")}
+        </span>
+        <Button
+          type="button"
+          size="sm"
+          variant="outline"
+          onClick={onRefresh}
+          disabled={loading}
+        >
+          <RefreshCw className={loading ? "animate-spin" : undefined} />
+          {t("common.refresh")}
+        </Button>
+        <Button
+          type="button"
+          size="sm"
+          onClick={onSave}
+          disabled={readOnly || !hasSelection || !dirty || saving}
+        >
+          {saving ? <Loader2 className="animate-spin" /> : <Save />}
+          {saving ? t("common.saving") : t("common.save")}
+        </Button>
+      </div>
+    </div>
+  );
+}