@tablestore/tablestore-agent-cli 0.3.1 → 0.4.1

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

@@ -1,56 +1,116 @@
 "use client";
 
-import { useState } from "react";
+import { useMemo, useState } from "react";
+import { usePathname, useRouter, useSearchParams } from "next/navigation";
+import { ChevronDown, SlidersHorizontal } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Checkbox } from "@/components/ui/checkbox";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Textarea } from "@/components/ui/textarea";
-import { parseJsonObject, hasSearchableScope } from "@/lib/memory";
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "@/components/ui/collapsible";
+import {
+  parseJsonObject,
+  hasPreciseScope,
+  hasSearchableScope,
+} from "@/lib/memory";
 import { useI18n } from "@/i18n/i18n-context";
-import type { MemoryScope } from "@/types/memory";
+import type {
+  MemoryScope,
+  ScopeDirectoryFilter,
+  SearchMemoryRequest,
+} from "@/types/memory";
+import {
+  parseSerializedVisualScopeFilter,
+  ScopeFilterBuilder,
+} from "./scope-filter-builder";
 
 export interface MemorySearchValues {
   query: string;
   scope: MemoryScope;
   topK: number;
   enableRerank: boolean;
+  includeEvidence: boolean;
   minSimilarity: number;
+  minScore: number;
+  filter?: ScopeDirectoryFilter;
+  contextScope?: MemoryScope;
   metadata?: Record<string, string>;
 }
 
 interface MemorySearchFormProps {
   scope: MemoryScope;
+  requiresExactScope?: boolean;
   isLoading?: boolean;
   onSubmit: (values: MemorySearchValues) => void | Promise<void>;
 }
 
 interface MemorySearchValidationInput {
   searchable: boolean;
+  exactScopeRequired?: boolean;
+  preciseScope?: boolean;
   query: string;
   topK: number;
   minSimilarity: number;
+  minScore?: number;
 }
 
 interface MemorySearchValidationMessages {
   scopeRequired: string;
+  exactScopeRequired: string;
   queryRequired: string;
   topKRange: string;
   similarityRange: string;
+  scoreRange: string;
 }
 
 const DEFAULT_VALIDATION_MESSAGES: MemorySearchValidationMessages = {
-  scopeRequired: "请先在范围栏中设置「应用」和「租户」的具体值",
+  scopeRequired: "请先在范围栏中设置非通配的「应用」",
+  exactScopeRequired: "当前记忆库会返回文件结果，请为 Scope 四个字段设置具体值",
   queryRequired: "请输入检索内容",
   topKRange: "Top K 必须在 1 到 50 之间",
   similarityRange: "相似度阈值必须在 0 到 1 之间",
+  scoreRange: "相关度阈值必须在 0 到 1 之间",
 };
 
+function numberFromSearchParams(
+  params: URLSearchParams,
+  key: string,
+  fallback: number,
+): number {
+  const raw = params.get(key);
+  if (raw === null || raw.trim() === "") return fallback;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : fallback;
+}
+
+export function hasRestoredAdvancedSearchOptions(
+  params: URLSearchParams,
+): boolean {
+  return [
+    "topK",
+    "rerank",
+    "evidence",
+    "minSimilarity",
+    "minScore",
+    "filter",
+    "contextScope",
+    "metadata",
+  ].some((key) => params.has(key));
+}
+
 export function validateSearchForm(
   values: MemorySearchValidationInput,
   messages: MemorySearchValidationMessages = DEFAULT_VALIDATION_MESSAGES,
 ): string | null {
   if (!values.searchable) return messages.scopeRequired;
+  if (values.exactScopeRequired && !values.preciseScope) {
+    return messages.exactScopeRequired;
+  }
   if (!values.query.trim()) return messages.queryRequired;
   if (!Number.isInteger(values.topK) || values.topK < 1 || values.topK > 50) {
     return messages.topKRange;
@@ -62,35 +122,175 @@ export function validateSearchForm(
   ) {
     return messages.similarityRange;
   }
+  if (
+    values.minScore !== undefined &&
+    (!Number.isFinite(values.minScore) ||
+      values.minScore < 0 ||
+      values.minScore > 1)
+  ) {
+    return messages.scoreRange;
+  }
   return null;
 }
 
+export function buildSearchMemoryRequest(
+  memoryStoreName: string,
+  values: MemorySearchValues,
+): SearchMemoryRequest {
+  return {
+    memoryStoreName,
+    query: values.query,
+    scope: values.scope,
+    topK: values.topK,
+    enableRerank: values.enableRerank,
+    includeEvidence: values.includeEvidence,
+    ...(values.filter ? { filter: values.filter } : {}),
+    ...(values.contextScope ? { contextScope: values.contextScope } : {}),
+    ...(values.minSimilarity > 0 || values.minScore > 0
+      ? {
+          thresholds: {
+            ...(values.minSimilarity > 0
+              ? { minSimilarity: values.minSimilarity }
+              : {}),
+            ...(values.minScore > 0 ? { minScore: values.minScore } : {}),
+          },
+        }
+      : {}),
+    ...(values.metadata ? { metadata: values.metadata } : {}),
+  };
+}
+
+interface ContextScopeValidationMessages {
+  invalidJson: string;
+  notObject: string;
+  fieldRequired: (field: string) => string;
+}
+
+export function parseContextScope(
+  value: string,
+  messages: ContextScopeValidationMessages,
+): MemoryScope | undefined {
+  if (!value.trim()) return undefined;
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(value) as unknown;
+  } catch {
+    throw new Error(messages.invalidJson);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(messages.notObject);
+  }
+  const fields = ["appId", "tenantId", "agentId", "runId"] as const;
+  const scope = {} as Record<(typeof fields)[number], string>;
+  for (const field of fields) {
+    const item = (parsed as Record<string, unknown>)[field];
+    const normalized = typeof item === "string" ? item.trim() : "";
+    if (!normalized || normalized === "*") {
+      throw new Error(messages.fieldRequired(field));
+    }
+    scope[field] = normalized;
+  }
+  return scope;
+}
+
 export function MemorySearchForm({
   scope,
+  requiresExactScope = false,
   isLoading,
   onSubmit,
 }: MemorySearchFormProps) {
   const { t } = useI18n();
-  const [query, setQuery] = useState("");
-  const [topK, setTopK] = useState(10);
-  const [enableRerank, setEnableRerank] = useState(true);
-  const [minSimilarity, setMinSimilarity] = useState(0);
-  const [metadataJson, setMetadataJson] = useState("");
+  const router = useRouter();
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+  const searchParamsString = searchParams.toString();
+  const initialParams = new URLSearchParams(searchParamsString);
+  const [query, setQuery] = useState(() => initialParams.get("q") ?? "");
+  const [topKInput, setTopKInput] = useState(() =>
+    String(numberFromSearchParams(initialParams, "topK", 10)),
+  );
+  const [enableRerank, setEnableRerank] = useState(
+    () => initialParams.get("rerank") !== "false",
+  );
+  const [includeEvidence, setIncludeEvidence] = useState(
+    () => initialParams.get("evidence") !== "false",
+  );
+  const [minSimilarityInput, setMinSimilarityInput] = useState(() =>
+    String(numberFromSearchParams(initialParams, "minSimilarity", 0)),
+  );
+  const [minScoreInput, setMinScoreInput] = useState(() =>
+    String(numberFromSearchParams(initialParams, "minScore", 0)),
+  );
+  const [filter, setFilter] = useState<ScopeDirectoryFilter | undefined>(
+    () => parseSerializedVisualScopeFilter(initialParams.get("filter"))?.filter,
+  );
+  const [contextScopeJson, setContextScopeJson] = useState(
+    () => initialParams.get("contextScope") ?? "",
+  );
+  const [metadataJson, setMetadataJson] = useState(
+    () => initialParams.get("metadata") ?? "",
+  );
   const [error, setError] = useState<string | null>(null);
+  const [advancedOpen, setAdvancedOpen] = useState(() =>
+    hasRestoredAdvancedSearchOptions(initialParams),
+  );
 
   const searchable = hasSearchableScope(scope);
+  const preciseScope = hasPreciseScope(scope);
+  const topK = Number(topKInput);
+  const minSimilarity = Number(minSimilarityInput);
+  const minScore = Number(minScoreInput);
+  const scopeEligible = searchable && (!requiresExactScope || preciseScope);
+  const queryMissing = !query.trim();
+  const validationMessages = useMemo<MemorySearchValidationMessages>(
+    () => ({
+      scopeRequired: t("memory.search.scopeRequired"),
+      exactScopeRequired: t("memory.search.exactScopeRequired"),
+      queryRequired: t("memory.search.queryRequired"),
+      topKRange: t("memory.search.topKRange"),
+      similarityRange: t("memory.search.similarityRange"),
+      scoreRange: t("memory.search.scoreRange"),
+    }),
+    [t],
+  );
+  const realtimeValidationError = validateSearchForm(
+    {
+      searchable,
+      exactScopeRequired: requiresExactScope,
+      preciseScope,
+      query,
+      topK,
+      minSimilarity,
+      minScore,
+    },
+    validationMessages,
+  );
+  let validationHint: string | null = null;
+  let validationHintIsWarning = false;
+  if (!scopeEligible) {
+    validationHint =
+      requiresExactScope && searchable
+        ? t("memory.search.exactScopeRequiredHint")
+        : t("memory.search.scopeRequiredHint");
+    validationHintIsWarning = true;
+  } else if (queryMissing) {
+    validationHint = t("memory.search.queryRequired");
+  }
 
   async function handleSubmit(event: React.FormEvent<HTMLFormElement>) {
     event.preventDefault();
     setError(null);
     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"),
+        searchable,
+        exactScopeRequired: requiresExactScope,
+        preciseScope,
+        query,
+        topK,
+        minSimilarity,
+        minScore,
       },
+      validationMessages,
     );
     if (validationError) {
       setError(validationError);
@@ -98,21 +298,54 @@ export function MemorySearchForm({
     }
 
     try {
-      await onSubmit({
+      const values: MemorySearchValues = {
         query: query.trim(),
         scope,
         topK,
         enableRerank,
+        includeEvidence,
         minSimilarity,
+        minScore,
+        filter,
+        contextScope: parseContextScope(contextScopeJson, {
+          invalidJson: t("memory.search.contextScopeInvalidJson"),
+          notObject: t("memory.search.contextScopeNotObject"),
+          fieldRequired: (field) =>
+            t("memory.search.contextScopeFieldRequired", { field }),
+        }),
         metadata: parseJsonObject(metadataJson),
-      });
+      };
+      const nextParams = new URLSearchParams(searchParamsString);
+      nextParams.set("q", values.query);
+      nextParams.set("topK", String(values.topK));
+      nextParams.set("rerank", String(values.enableRerank));
+      nextParams.set("evidence", String(values.includeEvidence));
+      nextParams.set("minSimilarity", String(values.minSimilarity));
+      nextParams.set("minScore", String(values.minScore));
+      if (values.filter) {
+        nextParams.set("filter", JSON.stringify(values.filter));
+      } else {
+        nextParams.delete("filter");
+      }
+      if (contextScopeJson.trim()) {
+        nextParams.set("contextScope", contextScopeJson.trim());
+      } else {
+        nextParams.delete("contextScope");
+      }
+      if (metadataJson.trim()) {
+        nextParams.set("metadata", metadataJson.trim());
+      } else {
+        nextParams.delete("metadata");
+      }
+      router.replace(`${pathname}?${nextParams.toString()}`, { scroll: false });
+      await onSubmit(values);
     } catch (err) {
       setError(err instanceof Error ? err.message : t("memory.search.failed"));
     }
   }
 
   return (
-    <form onSubmit={handleSubmit} className="space-y-4 rounded-lg border p-4">
+    <form onSubmit={handleSubmit} className="space-y-4">
       <div>
         <h3 className="text-lg font-semibold">{t("memory.search.title")}</h3>
         <p className="mt-1 text-xs text-muted-foreground">
@@ -130,66 +363,147 @@ export function MemorySearchForm({
         />
       </div>
 
-      <div className="grid gap-4 sm:grid-cols-2">
-        <div className="space-y-2">
-          <Label>Top K</Label>
-          <Input
-            type="number"
-            min={1}
-            max={50}
-            value={topK}
-            onChange={(event) => setTopK(Number(event.target.value))}
-          />
-        </div>
-
-        <div className="flex items-end pb-1">
+      {validationHint ? (
+        <p
+          className={
+            validationHintIsWarning
+              ? "rounded-md border border-amber-500/30 bg-amber-500/10 px-3 py-2 text-xs text-amber-800 dark:text-amber-200"
+              : "text-xs text-muted-foreground"
+          }
+        >
+          {validationHint}
+        </p>
+      ) : null}
+
+      {scopeEligible && !queryMissing && realtimeValidationError ? (
+        <p className="text-xs text-[hsl(var(--destructive))]">
+          {realtimeValidationError}
+        </p>
+      ) : null}
+
+      {error ? (
+        <p className="text-sm text-[hsl(var(--destructive))]">{error}</p>
+      ) : null}
+
+      <div className="sticky top-0 z-10 -mx-1 rounded-md bg-card/95 p-1 backdrop-blur">
+        <Button
+          type="submit"
+          className="w-full"
+          disabled={isLoading || realtimeValidationError !== null}
+        >
+          {isLoading ? t("memory.search.searching") : t("memory.search.submit")}
+        </Button>
+      </div>
+
+      <Collapsible open={advancedOpen} onOpenChange={setAdvancedOpen}>
+        <CollapsibleTrigger asChild>
+          <Button
+            type="button"
+            variant="outline"
+            className="w-full justify-between"
+          >
+            <span className="inline-flex items-center gap-2">
+              <SlidersHorizontal className="h-4 w-4" />
+              {t("memory.search.advancedOptions")}
+            </span>
+            <ChevronDown
+              className={`h-4 w-4 transition-transform ${advancedOpen ? "rotate-180" : ""}`}
+            />
+          </Button>
+        </CollapsibleTrigger>
+        <CollapsibleContent forceMount className="space-y-4 pt-4">
+          <div className="grid gap-4 sm:grid-cols-2">
+            <div className="space-y-2">
+              <Label>Top K</Label>
+              <Input
+                type="number"
+                min={1}
+                max={50}
+                value={topKInput}
+                onChange={(event) => setTopKInput(event.target.value)}
+              />
+            </div>
+
+            <div className="flex items-end pb-1">
+              <label className="flex items-center gap-2 text-sm">
+                <Checkbox
+                  checked={enableRerank}
+                  onCheckedChange={(checked) =>
+                    setEnableRerank(checked === true)
+                  }
+                />
+                {t("memory.search.enableRerank")}
+              </label>
+            </div>
+          </div>
+
+          <div className="grid gap-4 sm:grid-cols-2">
+            <div className="space-y-2">
+              <Label>{t("memory.search.minSimilarity")}</Label>
+              <Input
+                type="number"
+                min={0}
+                max={1}
+                step={0.05}
+                value={minSimilarityInput}
+                onChange={(event) => setMinSimilarityInput(event.target.value)}
+              />
+              <p className="text-xs text-muted-foreground">
+                {t("memory.search.minSimilarityHelp")}
+              </p>
+            </div>
+            <div className="space-y-2">
+              <Label>{t("memory.search.minScore")}</Label>
+              <Input
+                type="number"
+                min={0}
+                max={1}
+                step={0.05}
+                value={minScoreInput}
+                onChange={(event) => setMinScoreInput(event.target.value)}
+              />
+              <p className="text-xs text-muted-foreground">
+                {t("memory.search.minScoreHelp")}
+              </p>
+            </div>
+          </div>
+
           <label className="flex items-center gap-2 text-sm">
             <Checkbox
-              checked={enableRerank}
-              onCheckedChange={(checked) => setEnableRerank(checked === true)}
+              checked={includeEvidence}
+              onCheckedChange={(checked) =>
+                setIncludeEvidence(checked === true)
+              }
             />
-            {t("memory.search.enableRerank")}
+            {t("memory.search.includeEvidence")}
           </label>
-        </div>
-      </div>
 
-      <div className="space-y-2">
-        <Label>{t("memory.search.minSimilarity")}</Label>
-        <Input
-          type="number"
-          min={0}
-          max={1}
-          step={0.05}
-          value={minSimilarity}
-          onChange={(event) => setMinSimilarity(Number(event.target.value))}
-        />
-        <p className="text-xs text-muted-foreground">
-          {t("memory.search.minSimilarityHelp")}
-        </p>
-      </div>
+          <ScopeFilterBuilder initialFilter={filter} onChange={setFilter} />
 
-      <div className="space-y-2">
-        <Label>{t("memory.search.metadataFilter")}</Label>
-        <Textarea
-          value={metadataJson}
-          onChange={(event) => setMetadataJson(event.target.value)}
-          placeholder='{"source":"dashboard"}'
-          rows={4}
-        />
-      </div>
+          <div className="space-y-2">
+            <Label>{t("memory.search.contextScope")}</Label>
+            <Textarea
+              value={contextScopeJson}
+              onChange={(event) => setContextScopeJson(event.target.value)}
+              placeholder='{"appId":"app-001","tenantId":"tenant-001","agentId":"assistant","runId":"session-001"}'
+              rows={4}
+            />
+            <p className="text-xs text-muted-foreground">
+              {t("memory.search.contextScopeHelp")}
+            </p>
+          </div>
 
-      {error && (
-        <p className="text-sm text-[hsl(var(--destructive))]">{error}</p>
-      )}
-
-      <Button type="submit" disabled={isLoading || !searchable}>
-        {isLoading ? t("memory.search.searching") : t("memory.search.submit")}
-      </Button>
-      {!searchable && (
-        <p className="text-xs text-muted-foreground">
-          {t("memory.search.scopeRequiredHint")}
-        </p>
-      )}
+          <div className="space-y-2">
+            <Label>{t("memory.search.metadataFilter")}</Label>
+            <Textarea
+              value={metadataJson}
+              onChange={(event) => setMetadataJson(event.target.value)}
+              placeholder='{"source":"dashboard"}'
+              rows={4}
+            />
+          </div>
+        </CollapsibleContent>
+      </Collapsible>
     </form>
   );
 }