@tablestore/tablestore-agent-cli 0.2.10 → 0.3.1

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

@@ -1,6 +1,6 @@
 "use client";
 
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { usePathname, useRouter, useSearchParams } from "next/navigation";
 import {
   Check,
@@ -30,12 +30,21 @@ import {
 import {
   buildMemoryScope,
   hasWildcardScope,
+  scopeLabel,
   scopeToSearchParams,
 } from "@/lib/memory";
+import {
+  clearRecentMemoryScopes,
+  excludeRecentMemoryScopes,
+  isAllWildcardMemoryScope,
+  readRecentMemoryScopes,
+  rememberRecentMemoryScope,
+} from "@/lib/memory-scope-history";
 import { useAllMemoryStoreScopes } from "@/hooks/use-memory-store-scopes";
 import { cn } from "@/lib/utils";
 import { useI18n } from "@/i18n/i18n-context";
 import type { TranslateFn } from "@/i18n/i18n-context";
+import { useDataScopeKey } from "@/providers/runtime-context-provider";
 import type { MemoryScope } from "@/types/memory";
 
 const FIELD_KEYS: Array<{
@@ -59,23 +68,62 @@ const WILDCARD_SCOPE: MemoryScope = {
   agentId: "*",
   runId: "*",
 };
+const NO_SCOPES: MemoryScope[] = [];
+
+type RecentMemoryScopeStorage = Pick<
+  Storage,
+  "getItem" | "setItem" | "removeItem"
+>;
+
+const unavailableLocalStorage: RecentMemoryScopeStorage = {
+  getItem: () => null,
+  setItem: () => {},
+  removeItem: () => {},
+};
 
-function scopeLabel(scope: MemoryScope): string {
-  return [scope.appId, scope.tenantId, scope.agentId, scope.runId]
-    .map((v) => v || "—")
-    .join(" / ");
+function getLocalStorage(): RecentMemoryScopeStorage {
+  try {
+    return window.localStorage;
+  } catch {
+    return unavailableLocalStorage;
+  }
 }
 
-function scopesEqual(a: MemoryScope, b: MemoryScope): boolean {
-  return (
-    (a.appId ?? "") === (b.appId ?? "") &&
-    (a.tenantId ?? "") === (b.tenantId ?? "") &&
-    (a.agentId ?? "") === (b.agentId ?? "") &&
-    (a.runId ?? "") === (b.runId ?? "")
-  );
+export function memoryScopeIdentity(scope: MemoryScope): string {
+  return JSON.stringify([
+    scope.appId,
+    scope.tenantId ?? "",
+    scope.agentId ?? "",
+    scope.runId ?? "",
+  ]);
 }
 
-export function MemoryScopeBar() {
+export function isMemoryScopeSelected(
+  scope: MemoryScope,
+  currentScope: MemoryScope,
+): boolean {
+  return memoryScopeIdentity(scope) === memoryScopeIdentity(currentScope);
+}
+
+export function normalizeMemoryScopeForApply(
+  scope: MemoryScope,
+): MemoryScope | null {
+  const appId = (scope.appId ?? "").trim();
+  if (!appId) return null;
+
+  return {
+    appId,
+    tenantId: (scope.tenantId ?? "").trim() || undefined,
+    agentId: (scope.agentId ?? "").trim() || undefined,
+    runId: (scope.runId ?? "").trim() || undefined,
+  };
+}
+
+export function MemoryScopeBar({
+  allowScopeDiscovery = true,
+}: {
+  allowScopeDiscovery?: boolean;
+}) {
   const { t } = useI18n();
   const FIELDS = FIELD_KEYS.map((f) => ({
     key: f.key,
@@ -85,6 +133,7 @@ export function MemoryScopeBar() {
   const router = useRouter();
   const pathname = usePathname();
   const searchParams = useSearchParams();
+  const dataScopeKey = useDataScopeKey();
   const searchParamsString = searchParams.toString();
   const currentScope = useMemo(
     () => buildMemoryScope(new URLSearchParams(searchParamsString)),
@@ -97,8 +146,36 @@ export function MemoryScopeBar() {
   const [pickerOpen, setPickerOpen] = useState(false);
 
   const storeName = pathname.split("/").filter(Boolean)[1];
+  const recentScopeId =
+    allowScopeDiscovery && storeName
+      ? JSON.stringify([dataScopeKey, storeName])
+      : null;
+  const [recentState, setRecentState] = useState<{
+    scopeId: string | null;
+    scopes: MemoryScope[];
+  }>({ scopeId: recentScopeId, scopes: [] });
+  const recentScopes =
+    recentState.scopeId === recentScopeId ? recentState.scopes : NO_SCOPES;
   const hasWildcard = hasWildcardScope(currentScope);
 
+  // Hydrate browser history separately from the online inventory. Carrying
+  // the composite identity in state prevents one render of the old runtime or
+  // store while this effect catches up after a route/context switch.
+  useEffect(() => {
+    if (!recentScopeId || !storeName) {
+      setRecentState({ scopeId: recentScopeId, scopes: [] });
+      return;
+    }
+    setRecentState({
+      scopeId: recentScopeId,
+      scopes: readRecentMemoryScopes(
+        getLocalStorage(),
+        dataScopeKey,
+        storeName,
+      ),
+    });
+  }, [dataScopeKey, recentScopeId, storeName]);
+
   // Default to wildcard when entering a memory detail page without scope
   // params so list/read views immediately show everything in the store.
   useEffect(() => {
@@ -112,39 +189,53 @@ export function MemoryScopeBar() {
   // Sync draft from URL whenever the URL changes; typing into the
   // expanded inputs is the only thing that should diverge draft from URL.
   useEffect(() => {
-    setDraft((prev) => (scopesEqual(prev, currentScope) ? prev : currentScope));
+    setDraft((prev) =>
+      isMemoryScopeSelected(prev, currentScope) ? prev : currentScope,
+    );
     setError(null);
   }, [currentScope]);
 
-  // Pull the real list of scope tuples present in this store. The engine
-  // accepts wildcard `*` for any dimension, so we always send the wildcard
-  // envelope and let it return every scope under the store. Replaces the
-  // previous "guess from the first memory unit's scope" heuristic which
-  // could only ever surface one tuple even on stores with dozens of scopes.
-  const scopeQuery = useAllMemoryStoreScopes(storeName ?? "", WILDCARD_SCOPE);
-  const knownScopes = scopeQuery.data?.items ?? [];
+  // Pull real scope tuples only for storage modes that expose ListMemoryScopes.
+  // Writable filemem deliberately disables this query and uses manual + local
+  // recent scopes instead; no server-discovered data is implied in that mode.
+  const scopeQuery = useAllMemoryStoreScopes(storeName ?? "", WILDCARD_SCOPE, {
+    enabled: allowScopeDiscovery,
+  });
+  const knownScopes = scopeQuery.data?.items ?? NO_SCOPES;
+  const knownScopesWithoutRecent = useMemo(
+    () => excludeRecentMemoryScopes(knownScopes, recentScopes),
+    [knownScopes, recentScopes],
+  );
   const knownTruncated = scopeQuery.data?.truncated ?? false;
-  const isWildcardSelected = hasWildcardScope(currentScope);
+  const isWildcardSelected = isAllWildcardMemoryScope(currentScope);
 
-  function applyScope(scope: MemoryScope) {
-    const trimmed: MemoryScope = {
-      appId: (scope.appId ?? "").trim() || "*",
-      tenantId: (scope.tenantId ?? "").trim() || undefined,
-      agentId: (scope.agentId ?? "").trim() || undefined,
-      runId: (scope.runId ?? "").trim() || undefined,
-    };
-    if (!trimmed.appId) {
+  function applyScope(scope: MemoryScope): boolean {
+    const trimmed = normalizeMemoryScopeForApply(scope);
+    if (!trimmed) {
       setError(t("memory.scopeBar.appRequired"));
-      return;
+      return false;
     }
     setError(null);
     const params = scopeToSearchParams(trimmed);
+    if (recentScopeId && storeName) {
+      setRecentState({
+        scopeId: recentScopeId,
+        scopes: rememberRecentMemoryScope(
+          getLocalStorage(),
+          dataScopeKey,
+          storeName,
+          trimmed,
+        ),
+      });
+    }
     router.replace(`${pathname}?${params.toString()}`);
+    return true;
   }
 
   function applyDraft() {
-    applyScope(draft);
-    setExpanded(false);
+    if (applyScope(draft)) {
+      setExpanded(false);
+    }
   }
 
   function resetScope() {
@@ -153,6 +244,12 @@ export function MemoryScopeBar() {
     router.replace(`${pathname}?appId=*&tenantId=*&agentId=*&runId=*`);
   }
 
+  function clearRecentScopes() {
+    if (!recentScopeId || !storeName) return;
+    clearRecentMemoryScopes(getLocalStorage(), dataScopeKey, storeName);
+    setRecentState({ scopeId: recentScopeId, scopes: [] });
+  }
+
   function updateField(key: keyof MemoryScope, value: string) {
     if (key === "appId") {
       setDraft((prev) => ({ ...prev, appId: value }));
@@ -162,8 +259,8 @@ export function MemoryScopeBar() {
   }
 
   function pickFromList(scope: MemoryScope) {
+    if (!applyScope(scope)) return;
     setDraft(scope);
-    applyScope(scope);
     setPickerOpen(false);
     setExpanded(false);
   }
@@ -192,20 +289,25 @@ export function MemoryScopeBar() {
                 {t("memory.scopeBar.readOnly")}
               </span>
             )}
-            <ScopePicker
-              open={pickerOpen}
-              onOpenChange={setPickerOpen}
-              currentScope={currentScope}
-              knownScopes={knownScopes}
-              isLoading={scopeQuery.isLoading}
-              isFetching={scopeQuery.isFetching}
-              truncated={knownTruncated}
-              isWildcardSelected={isWildcardSelected}
-              onPickWildcard={() => pickFromList(WILDCARD_SCOPE)}
-              onPickScope={pickFromList}
-              onRefresh={() => scopeQuery.refetch()}
-              t={t}
-            />
+            {allowScopeDiscovery ? (
+              <ScopePicker
+                open={pickerOpen}
+                onOpenChange={setPickerOpen}
+                currentScope={currentScope}
+                recentScopes={recentScopes}
+                knownScopes={knownScopesWithoutRecent}
+                isLoading={scopeQuery.isLoading}
+                isError={scopeQuery.isError}
+                isFetching={scopeQuery.isFetching}
+                truncated={knownTruncated}
+                isWildcardSelected={isWildcardSelected}
+                onPickWildcard={() => pickFromList(WILDCARD_SCOPE)}
+                onPickScope={pickFromList}
+                onClearRecent={clearRecentScopes}
+                onRefresh={() => scopeQuery.refetch()}
+                t={t}
+              />
+            ) : null}
             <Button
               variant="outline"
               size="sm"
@@ -279,13 +381,16 @@ interface ScopePickerProps {
   open: boolean;
   onOpenChange: (open: boolean) => void;
   currentScope: MemoryScope;
+  recentScopes: MemoryScope[];
   knownScopes: MemoryScope[];
   isLoading: boolean;
+  isError: boolean;
   isFetching: boolean;
   truncated: boolean;
   isWildcardSelected: boolean;
   onPickWildcard: () => void;
   onPickScope: (scope: MemoryScope) => void;
+  onClearRecent: () => void;
   onRefresh: () => void;
   t: TranslateFn;
 }
@@ -301,19 +406,23 @@ function ScopePicker({
   open,
   onOpenChange,
   currentScope,
+  recentScopes,
   knownScopes,
   isLoading,
+  isError,
   isFetching,
   truncated,
   isWildcardSelected,
   onPickWildcard,
   onPickScope,
+  onClearRecent,
   onRefresh,
   t,
 }: ScopePickerProps) {
   const triggerLabel = isWildcardSelected
     ? t("memory.common.allData")
     : scopeLabel(currentScope);
+  const searchInputRef = useRef<HTMLInputElement>(null);
 
   return (
     <Popover open={open} onOpenChange={onOpenChange}>
@@ -330,6 +439,7 @@ function ScopePicker({
       <PopoverContent align="end" className="w-[420px] p-0">
         <Command shouldFilter>
           <CommandInput
+            ref={searchInputRef}
             placeholder={t("memory.common.searchScopePlaceholder")}
             className="text-xs"
           />
@@ -337,7 +447,9 @@ function ScopePicker({
             <CommandEmpty>
               {isLoading
                 ? t("common.loading")
-                : t("memory.common.noMatchingScope")}
+                : isError
+                  ? t("memory.scopeCombobox.loadFailed")
+                  : t("memory.common.noMatchingScope")}
             </CommandEmpty>
             <CommandGroup heading={t("memory.common.presets")}>
               <CommandItem
@@ -356,6 +468,35 @@ function ScopePicker({
                 </span>
               </CommandItem>
             </CommandGroup>
+            {recentScopes.length > 0 && (
+              <CommandGroup
+                heading={t("memory.common.recentScopes", {
+                  count: recentScopes.length,
+                })}
+              >
+                {recentScopes.map((scope) => {
+                  const label = scopeLabel(scope);
+                  const identity = memoryScopeIdentity(scope);
+                  const isSelected = isMemoryScopeSelected(scope, currentScope);
+                  return (
+                    <CommandItem
+                      key={`recent-${identity}`}
+                      value={`recent ${identity} ${label}`}
+                      onSelect={() => onPickScope(scope)}
+                      className="text-xs"
+                    >
+                      <Check
+                        className={cn(
+                          "mr-2 h-3.5 w-3.5",
+                          isSelected ? "opacity-100" : "opacity-0",
+                        )}
+                      />
+                      <span className="truncate font-mono">{label}</span>
+                    </CommandItem>
+                  );
+                })}
+              </CommandGroup>
+            )}
             {knownScopes.length > 0 && (
               <CommandGroup
                 heading={
@@ -368,14 +509,14 @@ function ScopePicker({
                       })
                 }
               >
-                {knownScopes.map((scope, idx) => {
+                {knownScopes.map((scope) => {
                   const label = scopeLabel(scope);
-                  const isSelected =
-                    !isWildcardSelected && scopesEqual(scope, currentScope);
+                  const identity = memoryScopeIdentity(scope);
+                  const isSelected = isMemoryScopeSelected(scope, currentScope);
                   return (
                     <CommandItem
-                      key={`${label}-${idx}`}
-                      value={label}
+                      key={`known-${identity}`}
+                      value={`known ${identity} ${label}`}
                       onSelect={() => onPickScope(scope)}
                       className="text-xs"
                     >
@@ -396,25 +537,42 @@ function ScopePicker({
             <span>
               {isLoading
                 ? t("memory.common.querying")
-                : truncated
-                  ? t("memory.common.scopeCountTruncated", {
-                      count: knownScopes.length,
-                    })
-                  : t("memory.common.scopeCount", {
-                      count: knownScopes.length,
-                    })}
+                : isError
+                  ? t("memory.scopeCombobox.loadFailed")
+                  : truncated
+                    ? t("memory.common.scopeCountTruncated", {
+                        count: knownScopes.length,
+                      })
+                    : t("memory.common.scopeCount", {
+                        count: knownScopes.length,
+                      })}
             </span>
-            <button
-              type="button"
-              onClick={(e) => {
-                e.preventDefault();
-                onRefresh();
-              }}
-              disabled={isFetching}
-              className="rounded px-1.5 py-0.5 hover:bg-[hsl(var(--accent))] disabled:opacity-50"
-            >
-              {t("common.refresh")}
-            </button>
+            <div className="flex items-center gap-1">
+              {recentScopes.length > 0 && (
+                <button
+                  type="button"
+                  onClick={(event) => {
+                    event.preventDefault();
+                    searchInputRef.current?.focus();
+                    onClearRecent();
+                  }}
+                  className="h-6 rounded px-1.5 py-0.5 hover:bg-[hsl(var(--accent))] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[hsl(var(--primary)/0.3)]"
+                >
+                  {t("memory.common.clearRecentScopes")}
+                </button>
+              )}
+              <button
+                type="button"
+                onClick={(event) => {
+                  event.preventDefault();
+                  onRefresh();
+                }}
+                disabled={isFetching}
+                className="h-6 rounded px-1.5 py-0.5 hover:bg-[hsl(var(--accent))] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[hsl(var(--primary)/0.3)] disabled:opacity-50"
+              >
+                {t("common.refresh")}
+              </button>
+            </div>
           </div>
         </Command>
       </PopoverContent>

package/dist/dashboard-runtime/dashboard/src/components/memory/memory-search-form.tsx

@@ -25,6 +25,46 @@ interface MemorySearchFormProps {
   onSubmit: (values: MemorySearchValues) => void | Promise<void>;
 }
 
+interface MemorySearchValidationInput {
+  searchable: boolean;
+  query: string;
+  topK: number;
+  minSimilarity: number;
+}
+
+interface MemorySearchValidationMessages {
+  scopeRequired: string;
+  queryRequired: string;
+  topKRange: string;
+  similarityRange: string;
+}
+
+const DEFAULT_VALIDATION_MESSAGES: MemorySearchValidationMessages = {
+  scopeRequired: "请先在范围栏中设置「应用」和「租户」的具体值",
+  queryRequired: "请输入检索内容",
+  topKRange: "Top K 必须在 1 到 50 之间",
+  similarityRange: "相似度阈值必须在 0 到 1 之间",
+};
+
+export function validateSearchForm(
+  values: MemorySearchValidationInput,
+  messages: MemorySearchValidationMessages = DEFAULT_VALIDATION_MESSAGES,
+): string | null {
+  if (!values.searchable) return messages.scopeRequired;
+  if (!values.query.trim()) return messages.queryRequired;
+  if (!Number.isInteger(values.topK) || values.topK < 1 || values.topK > 50) {
+    return messages.topKRange;
+  }
+  if (
+    !Number.isFinite(values.minSimilarity) ||
+    values.minSimilarity < 0 ||
+    values.minSimilarity > 1
+  ) {
+    return messages.similarityRange;
+  }
+  return null;
+}
+
 export function MemorySearchForm({
   scope,
   isLoading,
@@ -43,20 +83,17 @@ export function MemorySearchForm({
   async function handleSubmit(event: React.FormEvent<HTMLFormElement>) {
     event.preventDefault();
     setError(null);
-    if (!searchable) {
-      setError(t("memory.search.scopeRequired"));
-      return;
-    }
-    if (!query.trim()) {
-      setError(t("memory.search.queryRequired"));
-      return;
-    }
-    if (topK < 0 || topK > 50) {
-      setError(t("memory.search.topKRange"));
-      return;
-    }
-    if (minSimilarity < 0 || minSimilarity > 1) {
-      setError(t("memory.search.similarityRange"));
+    const validationError = validateSearchForm(
+      { searchable, query, topK, minSimilarity },
+      {
+        scopeRequired: t("memory.search.scopeRequired"),
+        queryRequired: t("memory.search.queryRequired"),
+        topKRange: t("memory.search.topKRange"),
+        similarityRange: t("memory.search.similarityRange"),
+      },
+    );
+    if (validationError) {
+      setError(validationError);
       return;
     }
 

package/dist/dashboard-runtime/dashboard/src/components/memory/memory-search-results.tsx

@@ -33,6 +33,10 @@ export function MemorySearchResults({
   elapsedMs,
 }: MemorySearchResultsProps) {
   const { t, locale } = useI18n();
+  // `created_at` is the event time of the source message, not the write time —
+  // surface the fallback rules on hover so the line isn't read as an insert
+  // timestamp.
+  const hintCreatedAt = t("memory.search.resultCreatedAtHint");
   if (!results) {
     return (
       <EmptyState
@@ -100,7 +104,7 @@ export function MemorySearchResults({
                     scope: formatScope(hit.unit.scope),
                   })}
                 </span>
-                <span>
+                <span title={hintCreatedAt}>
                   {t("memory.search.resultCreatedAt", {
                     time: formatTimestamp(hit.unit.created_at, locale),
                   })}