@tablestore/tablestore-agent-cli 0.2.11 → 0.4.0

package/dist/dashboard-runtime/dashboard/src/components/memory/scope-workspace-cards.tsx

@@ -0,0 +1,475 @@
+import Link from "next/link";
+
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Card,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+} from "@/components/ui/card";
+import type { MessageKey, TranslateFn } from "@/i18n/i18n-context";
+import type { ChatScopeStorageMode } from "@/lib/chat-scope-entry";
+import {
+  buildScopeChatHref,
+  buildScopeFeatureHref,
+  type ScopeWorkspaceStatus,
+} from "@/lib/scope-workspace";
+import type { StorageMode } from "@/lib/memory-storage-mode";
+import type {
+  WikiBuildChanges,
+  WikiBuildQuality,
+  WikiBuildStatus,
+} from "@/types/wiki";
+import type { FileMemoryScope } from "@/types/file-memory";
+
+export interface ScopeWorkspaceViewModel {
+  memoryStoreName: string;
+  storageMode: StorageMode;
+  chatStorageMode?: ChatScopeStorageMode;
+  scope: FileMemoryScope;
+  status: ScopeWorkspaceStatus;
+  memory: { exists?: boolean; loading: boolean; error?: string };
+  dream: {
+    skillCount: number;
+    profileCount: number;
+    partial: boolean;
+    error?: string;
+  };
+  wiki: {
+    pageCount?: number;
+    quality?: WikiBuildQuality;
+    changes?: WikiBuildChanges;
+    latestStatus?: WikiBuildStatus;
+    error?: string;
+  };
+  chat: { memoryEnabled: true; wikiEnabled: boolean; usesFallback: boolean };
+}
+
+const REVIEWABLE_STATUSES = new Set<ScopeWorkspaceStatus>([
+  "draft",
+  "stale",
+  "failed_with_fallback",
+  "blocked",
+]);
+
+const STATUS_VARIANT: Record<
+  ScopeWorkspaceStatus,
+  "secondary" | "success" | "warning" | "danger"
+> = {
+  loading: "secondary",
+  draft: "secondary",
+  building: "warning",
+  ready: "success",
+  stale: "warning",
+  failed_with_fallback: "warning",
+  blocked: "danger",
+};
+
+const STATUS_DESCRIPTION_KEY: Record<ScopeWorkspaceStatus, MessageKey> = {
+  loading: "memory.scopeWorkspace.statusDescription.loading",
+  draft: "memory.scopeWorkspace.statusDescription.draft",
+  building: "memory.scopeWorkspace.statusDescription.building",
+  ready: "memory.scopeWorkspace.statusDescription.ready",
+  stale: "memory.scopeWorkspace.statusDescription.stale",
+  failed_with_fallback:
+    "memory.scopeWorkspace.statusDescription.failed_with_fallback",
+  blocked: "memory.scopeWorkspace.statusDescription.blocked",
+};
+
+function ScopeLinks({
+  view,
+  segment,
+  label,
+}: {
+  view: ScopeWorkspaceViewModel;
+  segment: "units" | "search" | "dream" | "wiki";
+  label: string;
+}) {
+  return (
+    <Button asChild size="sm" variant="outline">
+      <Link
+        href={buildScopeFeatureHref(view.memoryStoreName, segment, view.scope)}
+      >
+        {label}
+      </Link>
+    </Button>
+  );
+}
+
+function canOpenStructuredChat(
+  view: ScopeWorkspaceViewModel,
+): view is ScopeWorkspaceViewModel & {
+  chatStorageMode: ChatScopeStorageMode;
+} {
+  return (
+    view.chatStorageMode !== undefined &&
+    !view.memory.loading &&
+    !view.memory.error
+  );
+}
+
+export function ScopeWorkspaceHeader({
+  view,
+  t,
+}: {
+  view: ScopeWorkspaceViewModel;
+  t: TranslateFn;
+}) {
+  const reviewHref = buildScopeFeatureHref(
+    view.memoryStoreName,
+    "wiki",
+    view.scope,
+    {
+      tab: "build",
+    },
+  );
+  const scopeText = [
+    view.scope.appId,
+    view.scope.tenantId,
+    view.scope.agentId,
+    view.scope.runId,
+  ].join(" / ");
+  const statusDescriptionKey: MessageKey =
+    view.status === "building" && !view.chat.wikiEnabled
+      ? "memory.scopeWorkspace.statusDescription.firstBuilding"
+      : STATUS_DESCRIPTION_KEY[view.status];
+
+  return (
+    <header
+      className="flex flex-col gap-4 rounded-xl border bg-card p-5 sm:flex-row sm:items-start sm:justify-between"
+      data-storage-mode={view.storageMode}
+      data-testid="scope-workspace-header"
+    >
+      <div className="min-w-0">
+        <div className="flex flex-wrap items-center gap-2">
+          <h2 className="text-lg font-semibold">
+            {t("memory.scopeWorkspace.title")}
+          </h2>
+          <Badge variant={STATUS_VARIANT[view.status]}>
+            {t(`memory.scopeWorkspace.status.${view.status}`)}
+          </Badge>
+        </div>
+        <p className="mt-1 text-sm text-muted-foreground">
+          {t("memory.scopeWorkspace.description")}
+        </p>
+        <dl className="mt-3 grid gap-x-5 gap-y-1 text-sm sm:grid-cols-2">
+          <div className="flex gap-2">
+            <dt className="text-muted-foreground">
+              {t("memory.scopeWorkspace.store")}
+            </dt>
+            <dd className="font-medium">{view.memoryStoreName}</dd>
+          </div>
+          <div className="flex min-w-0 gap-2">
+            <dt className="shrink-0 text-muted-foreground">
+              {t("memory.scopeWorkspace.scope")}
+            </dt>
+            <dd className="truncate font-medium">{scopeText}</dd>
+          </div>
+        </dl>
+        <p className="mt-2 text-xs text-muted-foreground">
+          {t(statusDescriptionKey)}
+        </p>
+      </div>
+      <div className="flex shrink-0 flex-wrap gap-2">
+        {REVIEWABLE_STATUSES.has(view.status) ? (
+          <Button asChild size="sm">
+            <Link href={reviewHref}>
+              {t("memory.scopeWorkspace.reviewBuild")}
+            </Link>
+          </Button>
+        ) : null}
+        {canOpenStructuredChat(view) ? (
+          <Button asChild size="sm" variant="outline">
+            <Link
+              href={buildScopeChatHref(
+                view.memoryStoreName,
+                view.chatStorageMode,
+                view.scope,
+                "auto",
+              )}
+            >
+              {t("memory.scopeWorkspace.openChat")}
+            </Link>
+          </Button>
+        ) : null}
+      </div>
+    </header>
+  );
+}
+
+export function ScopeWorkspaceMemoryCard({
+  view,
+  t,
+}: {
+  view: ScopeWorkspaceViewModel;
+  t: TranslateFn;
+}) {
+  return (
+    <Card data-testid="scope-workspace-memory">
+      <CardHeader>
+        <CardTitle>{t("memory.scopeWorkspace.memoryTitle")}</CardTitle>
+        <CardDescription>
+          {t("memory.scopeWorkspace.memoryDescription")}
+        </CardDescription>
+      </CardHeader>
+      <CardContent className="space-y-2 text-sm">
+        {view.memory.loading ? (
+          <p>{t("memory.scopeWorkspace.loading")}</p>
+        ) : null}
+        {!view.memory.loading && !view.memory.error ? (
+          <p>
+            {view.memory.exists
+              ? t("memory.scopeWorkspace.exists")
+              : t("memory.scopeWorkspace.notFound")}
+          </p>
+        ) : null}
+        {view.memory.error ? (
+          <p className="text-danger">{view.memory.error}</p>
+        ) : null}
+      </CardContent>
+      <CardFooter className="gap-2">
+        <ScopeLinks
+          view={view}
+          segment="units"
+          label={t("memory.scopeWorkspace.openUnits")}
+        />
+        <ScopeLinks
+          view={view}
+          segment="search"
+          label={t("memory.scopeWorkspace.openSearch")}
+        />
+      </CardFooter>
+    </Card>
+  );
+}
+
+export function ScopeWorkspaceDreamCard({
+  view,
+  t,
+}: {
+  view: ScopeWorkspaceViewModel;
+  t: TranslateFn;
+}) {
+  return (
+    <Card data-testid="scope-workspace-dream">
+      <CardHeader>
+        <CardTitle>{t("memory.scopeWorkspace.dreamTitle")}</CardTitle>
+        <CardDescription>
+          {t("memory.scopeWorkspace.dreamDescription")}
+        </CardDescription>
+      </CardHeader>
+      <CardContent className="space-y-2 text-sm">
+        <p>
+          {t("memory.scopeWorkspace.skillCount", {
+            count: view.dream.skillCount,
+          })}
+        </p>
+        <p>
+          {t("memory.scopeWorkspace.profileCount", {
+            count: view.dream.profileCount,
+          })}
+        </p>
+        {view.dream.partial ? (
+          <p className="text-warning">{t("memory.scopeWorkspace.partial")}</p>
+        ) : null}
+        {view.dream.error ? (
+          <p className="text-danger">{view.dream.error}</p>
+        ) : null}
+      </CardContent>
+      <CardFooter className="gap-2">
+        <ScopeLinks
+          view={view}
+          segment="dream"
+          label={t("memory.scopeWorkspace.openDream")}
+        />
+        <Button asChild size="sm" variant="outline">
+          <Link
+            href={buildScopeFeatureHref(
+              view.memoryStoreName,
+              "wiki",
+              view.scope,
+              { tab: "build" },
+            )}
+          >
+            {t("memory.scopeWorkspace.reviewBuild")}
+          </Link>
+        </Button>
+      </CardFooter>
+    </Card>
+  );
+}
+
+export function ScopeWorkspaceWikiCard({
+  view,
+  t,
+}: {
+  view: ScopeWorkspaceViewModel;
+  t: TranslateFn;
+}) {
+  const quality = view.wiki.quality;
+  const changes = view.wiki.changes;
+  return (
+    <Card data-testid="scope-workspace-wiki">
+      <CardHeader>
+        <CardTitle>{t("memory.scopeWorkspace.wikiTitle")}</CardTitle>
+        <CardDescription>
+          {t("memory.scopeWorkspace.wikiDescription")}
+        </CardDescription>
+      </CardHeader>
+      <CardContent className="space-y-2 text-sm">
+        {view.wiki.pageCount !== undefined ? (
+          <p>
+            {t("memory.scopeWorkspace.pageCount", {
+              count: view.wiki.pageCount,
+            })}
+          </p>
+        ) : null}
+        {view.wiki.latestStatus ? (
+          <p>
+            {t("memory.scopeWorkspace.latestStage", {
+              status: view.wiki.latestStatus,
+            })}
+          </p>
+        ) : null}
+        {quality ? (
+          <>
+            <p>
+              {t("memory.scopeWorkspace.qualitySourceCoverage", {
+                percent: Math.round(quality.sourceCoverage * 100),
+              })}
+            </p>
+            <p>
+              {t("memory.scopeWorkspace.qualityGroundedRate", {
+                percent: Math.round(quality.groundedPageRate * 100),
+              })}
+            </p>
+          </>
+        ) : null}
+        {changes ? (
+          <>
+            <p>
+              {t("memory.scopeWorkspace.changesAdded", {
+                count: changes.added,
+              })}
+            </p>
+            <p>
+              {t("memory.scopeWorkspace.changesModified", {
+                count: changes.modified,
+              })}
+            </p>
+            <p>
+              {t("memory.scopeWorkspace.changesDeleted", {
+                count: changes.deleted,
+              })}
+            </p>
+            <p>
+              {t("memory.scopeWorkspace.changesAffectedPages", {
+                count: changes.affectedPages,
+              })}
+            </p>
+          </>
+        ) : null}
+        {view.status === "stale" ? (
+          <p className="text-warning">
+            {t("memory.scopeWorkspace.staleGuidance")}
+          </p>
+        ) : null}
+        {view.status === "failed_with_fallback" ? (
+          <p className="text-warning">
+            {t("memory.scopeWorkspace.fallbackGuidance")}
+          </p>
+        ) : null}
+        {view.status === "building" ? (
+          <p className="text-muted-foreground">
+            {view.chat.wikiEnabled
+              ? t("memory.scopeWorkspace.buildingGuidance")
+              : t("memory.scopeWorkspace.firstBuildGuidance")}
+          </p>
+        ) : null}
+        {view.status === "draft" ? (
+          <p className="text-muted-foreground">
+            {t("memory.scopeWorkspace.draftGuidance")}
+          </p>
+        ) : null}
+        {view.wiki.error ? (
+          <p className="text-danger">{view.wiki.error}</p>
+        ) : null}
+      </CardContent>
+      <CardFooter>
+        <ScopeLinks
+          view={view}
+          segment="wiki"
+          label={t("memory.scopeWorkspace.openWiki")}
+        />
+      </CardFooter>
+    </Card>
+  );
+}
+
+export function ScopeWorkspaceChatCard({
+  view,
+  t,
+}: {
+  view: ScopeWorkspaceViewModel;
+  t: TranslateFn;
+}) {
+  return (
+    <Card data-testid="scope-workspace-chat">
+      <CardHeader>
+        <CardTitle>{t("memory.scopeWorkspace.chatTitle")}</CardTitle>
+        <CardDescription>
+          {t("memory.scopeWorkspace.chatDescription")}
+        </CardDescription>
+      </CardHeader>
+      <CardContent className="space-y-2 text-sm">
+        <p>{t("memory.scopeWorkspace.chatMemoryEnabled")}</p>
+        <p>
+          {view.chat.wikiEnabled
+            ? t("memory.scopeWorkspace.chatWikiEnabled")
+            : t("memory.scopeWorkspace.chatWikiDisabled")}
+        </p>
+        {view.chat.usesFallback ? (
+          <p className="text-warning">
+            {t("memory.scopeWorkspace.chatFallback")}
+          </p>
+        ) : null}
+      </CardContent>
+      <CardFooter>
+        {canOpenStructuredChat(view) ? (
+          <Button asChild size="sm">
+            <Link
+              href={buildScopeChatHref(
+                view.memoryStoreName,
+                view.chatStorageMode,
+                view.scope,
+                "auto",
+              )}
+            >
+              {t("memory.scopeWorkspace.openChat")}
+            </Link>
+          </Button>
+        ) : null}
+      </CardFooter>
+    </Card>
+  );
+}
+
+export function ScopeWorkspaceCards({
+  view,
+  t,
+}: {
+  view: ScopeWorkspaceViewModel;
+  t: TranslateFn;
+}) {
+  return (
+    <div className="grid gap-4 lg:grid-cols-2">
+      <ScopeWorkspaceMemoryCard view={view} t={t} />
+      <ScopeWorkspaceDreamCard view={view} t={t} />
+      <ScopeWorkspaceWikiCard view={view} t={t} />
+      <ScopeWorkspaceChatCard view={view} t={t} />
+    </div>
+  );
+}

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

@@ -0,0 +1,197 @@
+"use client";
+
+import { useMemoryStore } from "@/hooks/use-memory-store";
+import { useMemoryStoreScopes } from "@/hooks/use-memory-store-scopes";
+import { useWiki, useWikiArtifacts } from "@/hooks/use-wikis";
+import { useI18n } from "@/i18n/i18n-context";
+import {
+  parseKnownStorageMode,
+  type StorageMode,
+} from "@/lib/memory-storage-mode";
+import { deriveScopeWorkspaceStatus } from "@/lib/scope-workspace";
+import { ApiClientError } from "@/services/api-client";
+import type { MemoryScope } from "@/types/memory";
+import type { FileMemoryScope } from "@/types/file-memory";
+import type { WikiDreamArtifact } from "@/types/wiki";
+
+import {
+  ScopeWorkspaceCards,
+  ScopeWorkspaceHeader,
+  type ScopeWorkspaceViewModel,
+} from "./scope-workspace-cards";
+
+function sameScope(left: MemoryScope, right: FileMemoryScope): boolean {
+  return (
+    left.appId === right.appId &&
+    left.tenantId === right.tenantId &&
+    left.agentId === right.agentId &&
+    left.runId === right.runId
+  );
+}
+
+function loadedPages<T>(query: { data?: { pages?: T[] } }): T[] {
+  return query.data?.pages ?? [];
+}
+
+function isPendingOrLoading(query: {
+  isPending?: boolean;
+  isLoading?: boolean;
+}): boolean {
+  return Boolean(query.isPending || query.isLoading);
+}
+
+function errorText(error: unknown, fallback: string): string | undefined {
+  if (!error) return undefined;
+  if (error instanceof ApiClientError) {
+    return [error.displayMessage, error.requestId].filter(Boolean).join(" · ");
+  }
+  return fallback;
+}
+
+function flattenArtifacts(query: {
+  data?: { pages?: Array<{ artifacts: WikiDreamArtifact[] }> };
+}): WikiDreamArtifact[] {
+  return loadedPages(query).flatMap((page) => page.artifacts);
+}
+
+export function ScopeWorkspace({
+  memoryStoreName,
+  scope,
+}: {
+  memoryStoreName: string;
+  scope: FileMemoryScope;
+}) {
+  const store = useMemoryStore(memoryStoreName);
+
+  if (isPendingOrLoading(store)) {
+    return <ScopeWorkspaceGateState state="loading" />;
+  }
+  if (store.error) {
+    return <ScopeWorkspaceGateState state="error" />;
+  }
+
+  const storageMode = parseKnownStorageMode(store.data?.storageMode);
+  if (storageMode === null || storageMode === "filemem") {
+    return <ScopeWorkspaceGateState state="unsupported" />;
+  }
+
+  return (
+    <LoadedScopeWorkspace
+      memoryStoreName={memoryStoreName}
+      scope={scope}
+      storageMode={storageMode}
+    />
+  );
+}
+
+function ScopeWorkspaceGateState({
+  state,
+}: {
+  state: "loading" | "error" | "unsupported";
+}) {
+  const { t } = useI18n();
+  const messageKey =
+    state === "loading"
+      ? "memory.scopeWorkspace.loading"
+      : state === "error"
+        ? "memory.scopeWorkspace.loadFailed"
+        : "memory.scopeWorkspace.unsupported";
+
+  return (
+    <div className="rounded-lg border border-dashed bg-card px-6 py-10 text-center text-sm text-muted-foreground">
+      {t(messageKey)}
+    </div>
+  );
+}
+
+function LoadedScopeWorkspace({
+  memoryStoreName,
+  scope,
+  storageMode,
+}: {
+  memoryStoreName: string;
+  scope: FileMemoryScope;
+  storageMode: Exclude<StorageMode, "filemem">;
+}) {
+  const { t } = useI18n();
+  const scopeInventory = useMemoryStoreScopes(memoryStoreName, scope, {
+    limit: 1,
+  });
+  const wiki = useWiki(memoryStoreName, scope);
+  const skill = useWikiArtifacts(memoryStoreName, scope, {
+    kind: "skill",
+    limit: 100,
+  });
+  const profile = useWikiArtifacts(memoryStoreName, scope, {
+    kind: "profile",
+    limit: 100,
+  });
+
+  const skillArtifacts = flattenArtifacts(skill);
+  const profileArtifacts = flattenArtifacts(profile);
+  const artifactCoverageComplete =
+    !skill.error &&
+    skill.hasNextPage === false &&
+    !profile.error &&
+    profile.hasNextPage === false &&
+    !isPendingOrLoading(skill) &&
+    !isPendingOrLoading(profile);
+  const latestBuild = wiki.data?.latestBuild;
+  const safeError = t("memory.scopeWorkspace.loadFailed");
+  const wikiError = errorText(wiki.error, safeError);
+  const memoryError = errorText(scopeInventory.error, safeError);
+  const status = deriveScopeWorkspaceStatus({
+    loading:
+      isPendingOrLoading(scopeInventory) ||
+      isPendingOrLoading(wiki) ||
+      isPendingOrLoading(skill) ||
+      isPendingOrLoading(profile),
+    error: wiki.error,
+    wiki: wiki.data,
+  });
+  const exists = scopeInventory.data?.items.some((item) =>
+    sameScope(item, scope),
+  );
+  const wikiEnabled = wiki.data?.status === "ready";
+  const artifactErrors =
+    [errorText(skill.error, safeError), errorText(profile.error, safeError)]
+      .filter(Boolean)
+      .join(" · ") || undefined;
+  const view: ScopeWorkspaceViewModel = {
+    memoryStoreName,
+    storageMode,
+    chatStorageMode: storageMode,
+    scope,
+    status,
+    memory: {
+      exists,
+      loading: isPendingOrLoading(scopeInventory),
+      error: memoryError,
+    },
+    dream: {
+      skillCount: skillArtifacts.length,
+      profileCount: profileArtifacts.length,
+      partial: !artifactCoverageComplete,
+      error: artifactErrors,
+    },
+    wiki: {
+      pageCount: wiki.data?.pageCount,
+      quality: latestBuild?.quality,
+      changes: latestBuild?.changes,
+      latestStatus: latestBuild?.status,
+      error: wikiError,
+    },
+    chat: {
+      memoryEnabled: true,
+      wikiEnabled,
+      usesFallback: status === "failed_with_fallback",
+    },
+  };
+
+  return (
+    <div className="space-y-4">
+      <ScopeWorkspaceHeader view={view} t={t} />
+      <ScopeWorkspaceCards view={view} t={t} />
+    </div>
+  );
+}